mirror of
https://git.mirrors.martin98.com/https://github.com/bambulab/BambuStudio.git
synced 2025-08-04 18:50:36 +08:00
a2378ec1b7
jira: github 5188 Change-Id: I5ecdcdf4b9b9d8bfb85d45604753350d8bde54df (cherry picked from commit e6dc1aa5bee414904ee95259b8d969f173092f82)
1987 lines
82 KiB
C++
1987 lines
82 KiB
C++
// Include GLGizmoBase.hpp before I18N.hpp as it includes some libigl code, which overrides our localization "L" macro.
|
|
#include "GLGizmoText.hpp"
|
|
#include "libslic3r/ClipperUtils.hpp"
|
|
#include "slic3r/GUI/GLCanvas3D.hpp"
|
|
#include "slic3r/GUI/Gizmos/GLGizmosCommon.hpp"
|
|
#include "slic3r/GUI/GUI_App.hpp"
|
|
#include "slic3r/GUI/ImGuiWrapper.hpp"
|
|
#include "slic3r/GUI/GUI_ObjectList.hpp"
|
|
#include "slic3r/GUI/Plater.hpp"
|
|
|
|
#include "libslic3r/Geometry/ConvexHull.hpp"
|
|
#include "libslic3r/Model.hpp"
|
|
|
|
#include "libslic3r/Shape/TextShape.hpp"
|
|
|
|
#include <numeric>
|
|
|
|
#include <boost/log/trivial.hpp>
|
|
|
|
#include <GL/glew.h>
|
|
|
|
#ifndef IMGUI_DEFINE_MATH_OPERATORS
|
|
#define IMGUI_DEFINE_MATH_OPERATORS
|
|
#endif
|
|
#include <imgui/imgui_internal.h>
|
|
#include "libslic3r/SVG.hpp"
|
|
#include <codecvt>
|
|
#include "wx/fontenum.h"
|
|
#include "FontUtils.hpp"
|
|
|
|
namespace Slic3r {
|
|
namespace GUI {
|
|
|
|
static const double PI = 3.141592653589793238;
|
|
static const wxColour FONT_TEXTURE_BG = wxColour(0, 0, 0, 0);
|
|
static const wxColour FONT_TEXTURE_FG = *wxWHITE;
|
|
static const int FONT_SIZE = 12;
|
|
static const float SELECTABLE_INNER_OFFSET = 8.0f;
|
|
|
|
static const wxFontEncoding font_encoding = wxFontEncoding::wxFONTENCODING_SYSTEM;
|
|
const std::array<float, 4> TEXT_GRABBER_COLOR = {1.0, 1.0, 0.0, 1.0};
|
|
const std::array<float, 4> TEXT_GRABBER_HOVER_COLOR = {0.7, 0.7, 0.0, 1.0};
|
|
#ifdef DEBUG_TEXT
|
|
std::string formatFloat(float val)
|
|
{
|
|
std::stringstream ss;
|
|
ss << std::fixed << std::setprecision(2) << val;
|
|
return ss.str();
|
|
}
|
|
#endif
|
|
std::vector<std::string> init_face_names()
|
|
{
|
|
std::vector<std::string> valid_font_names;
|
|
wxArrayString facenames = wxFontEnumerator::GetFacenames(font_encoding);
|
|
std::vector<wxString> bad_fonts;
|
|
|
|
BOOST_LOG_TRIVIAL(info) << "init_fonts_names start";
|
|
|
|
// validation lambda
|
|
auto is_valid_font = [coding = font_encoding, bad = bad_fonts](const wxString &name) {
|
|
if (name.empty())
|
|
return false;
|
|
|
|
// vertical font start with @, we will filter it out
|
|
// Not sure if it is only in Windows so filtering is on all platforms
|
|
if (name[0] == '@')
|
|
return false;
|
|
|
|
// previously detected bad font
|
|
auto it = std::lower_bound(bad.begin(), bad.end(), name);
|
|
if (it != bad.end() && *it == name)
|
|
return false;
|
|
|
|
wxFont wx_font(wxFontInfo().FaceName(name).Encoding(coding));
|
|
// Faster chech if wx_font is loadable but not 100%
|
|
// names could contain not loadable font
|
|
if (!wx_font.IsOk())
|
|
return false;
|
|
|
|
if (!can_load(wx_font))
|
|
return false;
|
|
|
|
return true;
|
|
};
|
|
|
|
std::sort(facenames.begin(), facenames.end());
|
|
for (const wxString &name : facenames) {
|
|
if (is_valid_font(name)) {
|
|
valid_font_names.push_back(name.ToStdString());
|
|
}
|
|
else {
|
|
bad_fonts.emplace_back(name);
|
|
}
|
|
}
|
|
assert(std::is_sorted(bad_fonts.begin(), bad_fonts.end()));
|
|
|
|
BOOST_LOG_TRIVIAL(info) << "init_fonts_names end";
|
|
|
|
return valid_font_names;
|
|
}
|
|
|
|
class Line_3D
|
|
{
|
|
public:
|
|
Line_3D(Vec3d i_a, Vec3d i_b) : a(i_a), b(i_b) {}
|
|
|
|
double length() { return (b - a).cast<double>().norm(); }
|
|
|
|
Vec3d vector()
|
|
{
|
|
Vec3d new_vec = b - a;
|
|
new_vec.normalize();
|
|
return new_vec;
|
|
}
|
|
|
|
void reverse() { std::swap(this->a, this->b); }
|
|
|
|
Vec3d a;
|
|
Vec3d b;
|
|
};
|
|
|
|
class Polygon_3D
|
|
{
|
|
public:
|
|
Polygon_3D(const std::vector<Vec3d> &points) : m_points(points) {}
|
|
|
|
std::vector<Line_3D> get_lines()
|
|
{
|
|
std::vector<Line_3D> lines;
|
|
lines.reserve(m_points.size());
|
|
if (m_points.size() > 2) {
|
|
for (int i = 0; i < m_points.size() - 1; ++i) { lines.push_back(Line_3D(m_points[i], m_points[i + 1])); }
|
|
lines.push_back(Line_3D(m_points.back(), m_points.front()));
|
|
}
|
|
return lines;
|
|
}
|
|
std::vector<Vec3d> m_points;
|
|
};
|
|
|
|
// for debug
|
|
void export_regions_to_svg(const Point &point, const Polygons &polylines)
|
|
{
|
|
std::string path = "D:/svg_profiles/text_poly.svg";
|
|
//BoundingBox bbox = get_extents(polylines);
|
|
SVG svg(path.c_str());
|
|
svg.draw(polylines, "green");
|
|
svg.draw(point, "red", 5e6);
|
|
}
|
|
|
|
int preNUm(unsigned char byte)
|
|
{
|
|
unsigned char mask = 0x80;
|
|
int num = 0;
|
|
for (int i = 0; i < 8; i++) {
|
|
if ((byte & mask) == mask) {
|
|
mask = mask >> 1;
|
|
num++;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
|
|
// https://www.jianshu.com/p/a83d398e3606
|
|
bool get_utf8_sub_strings(char *data, int len, std::vector<std::string> &out_strs)
|
|
{
|
|
out_strs.clear();
|
|
std::string str = std::string(data);
|
|
|
|
int num = 0;
|
|
int i = 0;
|
|
while (i < len) {
|
|
if ((data[i] & 0x80) == 0x00) {
|
|
out_strs.emplace_back(str.substr(i, 1));
|
|
i++;
|
|
continue;
|
|
} else if ((num = preNUm(data[i])) > 2) {
|
|
int start = i;
|
|
i++;
|
|
for (int j = 0; j < num - 1; j++) {
|
|
if ((data[i] & 0xc0) != 0x80) { return false; }
|
|
i++;
|
|
}
|
|
out_strs.emplace_back(str.substr(start, i - start));
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
///////////////////////
|
|
/// GLGizmoText start
|
|
GLGizmoText::GLGizmoText(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id)
|
|
: GLGizmoBase(parent, icon_filename, sprite_id)
|
|
{
|
|
}
|
|
|
|
GLGizmoText::~GLGizmoText()
|
|
{
|
|
if (m_thread.joinable())
|
|
m_thread.join();
|
|
|
|
for (int i = 0; i < m_textures.size(); i++) {
|
|
if (m_textures[i].texture != nullptr)
|
|
delete m_textures[i].texture;
|
|
}
|
|
}
|
|
|
|
bool GLGizmoText::on_init()
|
|
{
|
|
m_init_texture = false;
|
|
m_avail_font_names = init_face_names();
|
|
|
|
m_thread = std::thread(&GLGizmoText::update_font_status, this);
|
|
|
|
//m_avail_font_names = init_occt_fonts();
|
|
//update_font_texture();
|
|
m_scale = m_imgui->get_font_size();
|
|
m_shortcut_key = WXK_CONTROL_T;
|
|
|
|
reset_text_info();
|
|
|
|
m_desc["rotate_text_caption"] = _L("Shift + Mouse move up or down");
|
|
m_desc["rotate_text"] = _L("Rotate text");
|
|
|
|
return true;
|
|
}
|
|
|
|
void GLGizmoText::update_font_texture()
|
|
{
|
|
m_font_names.clear();
|
|
for (int i = 0; i < m_textures.size(); i++) {
|
|
if (m_textures[i].texture != nullptr)
|
|
delete m_textures[i].texture;
|
|
}
|
|
m_combo_width = 0.0f;
|
|
m_combo_height = 0.0f;
|
|
m_textures.clear();
|
|
m_textures.reserve(m_avail_font_names.size());
|
|
for (int i = 0; i < m_avail_font_names.size(); i++)
|
|
{
|
|
GLTexture* texture = new GLTexture();
|
|
auto face = wxString::FromUTF8(m_avail_font_names[i]);
|
|
auto retina_scale = m_parent.get_scale();
|
|
wxFont font { (int)round(retina_scale * FONT_SIZE), wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, false, face };
|
|
int w, h, hl;
|
|
std::unique_lock<std::mutex> lock(m_mutex);
|
|
if (m_font_status[i] && texture->generate_texture_from_text(m_avail_font_names[i], font, w, h, hl, FONT_TEXTURE_BG, FONT_TEXTURE_FG)) {
|
|
//if (h < m_imgui->scaled(2.f)) {
|
|
TextureInfo info;
|
|
info.texture = texture;
|
|
info.w = w;
|
|
info.h = h;
|
|
info.hl = hl;
|
|
info.font_name = m_avail_font_names[i];
|
|
m_textures.push_back(info);
|
|
m_combo_width = std::max(m_combo_width, static_cast<float>(texture->m_original_width));
|
|
m_font_names.push_back(info.font_name);
|
|
//}
|
|
}
|
|
}
|
|
m_combo_height = m_imgui->scaled(32.f / 15.f);
|
|
}
|
|
|
|
bool GLGizmoText::is_mesh_point_clipped(const Vec3d &point, const Transform3d &trafo) const
|
|
{
|
|
if (m_c->object_clipper()->get_position() == 0.)
|
|
return false;
|
|
|
|
auto sel_info = m_c->selection_info();
|
|
Vec3d transformed_point = trafo * point;
|
|
transformed_point(2) += sel_info->get_sla_shift();
|
|
return m_c->object_clipper()->get_clipping_plane()->is_point_clipped(transformed_point);
|
|
}
|
|
|
|
BoundingBoxf3 GLGizmoText::bounding_box() const
|
|
{
|
|
BoundingBoxf3 ret;
|
|
const Selection & selection = m_parent.get_selection();
|
|
const Selection::IndicesList &idxs = selection.get_volume_idxs();
|
|
for (unsigned int i : idxs) {
|
|
const GLVolume *volume = selection.get_volume(i);
|
|
if (!volume->is_modifier) ret.merge(volume->transformed_convex_hull_bounding_box());
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
bool GLGizmoText::gizmo_event(SLAGizmoEventType action, const Vec2d &mouse_position, bool shift_down, bool alt_down, bool control_down)
|
|
{
|
|
std::string text = std::string(m_text);
|
|
if (text.empty())
|
|
return true;
|
|
|
|
|
|
const Selection &selection = m_parent.get_selection();
|
|
auto mo = selection.get_model()->objects[m_object_idx];
|
|
if (mo == nullptr)
|
|
return true;
|
|
|
|
const ModelInstance *mi = mo->instances[selection.get_instance_idx()];
|
|
const Camera & camera = wxGetApp().plater()->get_camera();
|
|
|
|
if (action == SLAGizmoEventType::Moving) {
|
|
if (shift_down && !alt_down && !control_down) {
|
|
float angle = m_rotate_angle + 0.5 * (m_mouse_position - mouse_position).y();
|
|
if (angle == 0)
|
|
return true;
|
|
|
|
while (angle < 0)
|
|
angle += 360;
|
|
|
|
while (angle >= 360)
|
|
angle -= 360;
|
|
|
|
m_rotate_angle = angle;
|
|
m_shift_down = true;
|
|
m_need_update_text = true;
|
|
} else {
|
|
m_shift_down = false;
|
|
m_origin_mouse_position = mouse_position;
|
|
}
|
|
m_mouse_position = mouse_position;
|
|
}
|
|
else if (action == SLAGizmoEventType::LeftDown) {
|
|
if (!selection.is_empty() && get_hover_id() != -1) {
|
|
start_dragging();
|
|
return true;
|
|
}
|
|
|
|
if (m_is_modify)
|
|
return true;
|
|
|
|
Plater *plater = wxGetApp().plater();
|
|
if (!plater || m_thickness <= 0)
|
|
return true;
|
|
|
|
ModelObject *model_object = selection.get_model()->objects[m_object_idx];
|
|
if (m_preview_text_volume_id > 0) {
|
|
model_object->delete_volume(m_preview_text_volume_id);
|
|
plater->update();
|
|
m_preview_text_volume_id = -1;
|
|
}
|
|
|
|
// Precalculate transformations of individual meshes.
|
|
std::vector<Transform3d> trafo_matrices;
|
|
for (const ModelVolume *mv : mo->volumes) {
|
|
if (mv->is_model_part()) { trafo_matrices.emplace_back(mi->get_transformation().get_matrix() * mv->get_matrix()); }
|
|
}
|
|
|
|
Vec3f normal = Vec3f::Zero();
|
|
Vec3f hit = Vec3f::Zero();
|
|
size_t facet = 0;
|
|
Vec3f closest_hit = Vec3f::Zero();
|
|
Vec3f closest_normal = Vec3f::Zero();
|
|
double closest_hit_squared_distance = std::numeric_limits<double>::max();
|
|
int closest_hit_mesh_id = -1;
|
|
|
|
// Cast a ray on all meshes, pick the closest hit and save it for the respective mesh
|
|
for (int mesh_id = 0; mesh_id < int(trafo_matrices.size()); ++mesh_id) {
|
|
MeshRaycaster mesh_raycaster = MeshRaycaster(mo->volumes[mesh_id]->mesh());
|
|
|
|
if (mesh_raycaster.unproject_on_mesh(mouse_position, trafo_matrices[mesh_id], camera, hit, normal,
|
|
m_c->object_clipper()->get_clipping_plane(), &facet)) {
|
|
// In case this hit is clipped, skip it.
|
|
if (is_mesh_point_clipped(hit.cast<double>(), trafo_matrices[mesh_id]))
|
|
continue;
|
|
|
|
// Is this hit the closest to the camera so far?
|
|
double hit_squared_distance = (camera.get_position() - trafo_matrices[mesh_id] * hit.cast<double>()).squaredNorm();
|
|
if (hit_squared_distance < closest_hit_squared_distance) {
|
|
closest_hit_squared_distance = hit_squared_distance;
|
|
closest_hit_mesh_id = mesh_id;
|
|
closest_hit = hit;
|
|
closest_normal = normal;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (closest_hit == Vec3f::Zero() && closest_normal == Vec3f::Zero())
|
|
return true;
|
|
|
|
m_rr = {mouse_position, closest_hit_mesh_id, closest_hit, closest_normal};//left down
|
|
|
|
generate_text_volume(false);
|
|
m_is_modify = true;
|
|
plater->update();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void GLGizmoText::on_set_state()
|
|
{
|
|
if (m_state == EState::On) {
|
|
m_last_text_mv = nullptr;
|
|
m_need_fix = false;
|
|
m_show_text_normal_reset_tip = false;
|
|
load_init_text();
|
|
if (m_last_text_mv) {
|
|
m_reedit_text = true;
|
|
m_need_fix = true;
|
|
m_load_text_tran_in_object = m_text_tran_in_object;
|
|
if (m_really_use_surface_calc) {
|
|
m_show_warning_regenerated = true;
|
|
m_need_fix = false;
|
|
use_fix_normal_position();
|
|
} else if (m_fix_old_tran_flag && m_font_version == "") {
|
|
m_show_warning_old_tran = false;
|
|
auto offset = m_text_tran_in_object.get_offset();
|
|
auto rotation = m_text_tran_in_object.get_rotation();
|
|
float eps = 0.01f;
|
|
int count = 0;
|
|
bool has_rotation = rotation.norm() > eps;
|
|
count += has_rotation ? 1 : 0;
|
|
auto scaling_factor = m_text_tran_in_object.get_scaling_factor();
|
|
bool has_scale = (scaling_factor - Vec3d(1, 1, 1)).norm() > eps;
|
|
count += has_scale ? 1 : 0;
|
|
auto mirror = m_text_tran_in_object.get_mirror();
|
|
bool has_mirror = (mirror - Vec3d(1, 1, 1)).norm() > eps;
|
|
count += has_mirror ? 1 : 0;
|
|
|
|
Geometry::Transformation expert_text_tran_in_world;
|
|
generate_text_tran_in_world(m_fix_text_normal_in_world.cast<double>(), m_text_position_in_world, m_rotate_angle, expert_text_tran_in_world);
|
|
auto temp_expert_text_tran_in_object = m_object_cs_to_world_tran.inverse() * expert_text_tran_in_world.get_matrix();
|
|
Geometry::Transformation expert_text_tran_in_object(temp_expert_text_tran_in_object);
|
|
expert_text_tran_in_object.set_offset(m_text_tran_in_object.get_offset());
|
|
|
|
if (count >= 2) {
|
|
m_show_warning_old_tran = true;
|
|
}
|
|
if (m_is_version1_10_xoy) {
|
|
auto rotate_tran = Geometry::assemble_transform(Vec3d::Zero(), {0.5 * M_PI, 0.0, 0.0});
|
|
m_load_text_tran_in_object.set_from_transform(m_load_text_tran_in_object.get_matrix() * rotate_tran);
|
|
m_load_text_tran_in_object.set_offset(m_load_text_tran_in_object.get_offset() + Vec3d(0, 1.65, 0)); // for size 16
|
|
return;
|
|
}
|
|
//go on
|
|
if (has_rotation && m_show_warning_old_tran == false) {
|
|
m_show_warning_lost_rotate = true;
|
|
m_need_fix = false;
|
|
use_fix_normal_position();
|
|
}
|
|
//not need set set_rotation//has_rotation
|
|
if (has_scale) {
|
|
expert_text_tran_in_object.set_scaling_factor(scaling_factor);
|
|
}
|
|
if (has_mirror) {
|
|
expert_text_tran_in_object.set_mirror(mirror);
|
|
}
|
|
m_load_text_tran_in_object.set_from_transform(expert_text_tran_in_object.get_matrix());
|
|
if (m_is_version1_9_xoz) {
|
|
m_load_text_tran_in_object.set_offset(m_load_text_tran_in_object.get_offset());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (m_state == EState::Off) {
|
|
m_reedit_text = false;
|
|
m_fix_old_tran_flag = false;
|
|
close_warning_flag_after_close_or_drag();
|
|
reset_text_info();
|
|
delete_temp_preview_text_volume();
|
|
m_parent.use_slope(false);
|
|
m_parent.toggle_model_objects_visibility(true);
|
|
}
|
|
}
|
|
|
|
void GLGizmoText::check_text_type(bool is_surface_text, bool is_keep_horizontal) {
|
|
if (is_surface_text && is_keep_horizontal) {
|
|
m_text_type = TextType::SURFACE_HORIZONAL;
|
|
} else if (is_surface_text) {
|
|
m_text_type = TextType::SURFACE;
|
|
} else if (is_keep_horizontal) {
|
|
m_text_type = TextType::HORIZONAL;
|
|
} else {
|
|
m_text_type = TextType::HORIZONAL;
|
|
}
|
|
}
|
|
|
|
void GLGizmoText::generate_text_tran_in_world(const Vec3d &text_normal_in_world, const Vec3d &text_position_in_world,float rotate_degree, Geometry::Transformation &cur_tran)
|
|
{
|
|
Vec3d temp_normal = text_normal_in_world;
|
|
Vec3d cut_plane_in_world = Vec3d::UnitY();
|
|
double epson = 1e-6;
|
|
if (!(abs(temp_normal.x()) <= epson && abs(temp_normal.y()) <= epson && abs(temp_normal.z()) > epson)) { // temp_normal != Vec3d::UnitZ()
|
|
Vec3d v_plane = temp_normal.cross(Vec3d::UnitZ());
|
|
cut_plane_in_world = v_plane.cross(temp_normal);
|
|
}
|
|
Vec3d z_dir = text_normal_in_world;
|
|
Vec3d y_dir = cut_plane_in_world;
|
|
Vec3d x_dir_world = y_dir.cross(z_dir);
|
|
if (m_text_type == TextType::SURFACE_HORIZONAL && text_normal_in_world != Vec3d::UnitZ()) {
|
|
y_dir = Vec3d::UnitZ();
|
|
x_dir_world = y_dir.cross(z_dir);
|
|
z_dir = x_dir_world.cross(y_dir);
|
|
}
|
|
auto temp_tran = Geometry::generate_transform(x_dir_world, y_dir, z_dir, text_position_in_world);
|
|
Geometry::Transformation rotate_trans;
|
|
rotate_trans.set_rotation(Vec3d(0, 0, Geometry::deg2rad(rotate_degree))); // m_rotate_angle
|
|
cur_tran.set_matrix(temp_tran.get_matrix() * rotate_trans.get_matrix());
|
|
}
|
|
|
|
void GLGizmoText::use_fix_normal_position()
|
|
{
|
|
m_text_normal_in_world = m_fix_text_normal_in_world;
|
|
m_text_position_in_world = m_fix_text_position_in_world;
|
|
}
|
|
|
|
void GLGizmoText::load_init_text()
|
|
{
|
|
Plater *plater = wxGetApp().plater();
|
|
if (m_parent.get_selection().is_single_volume() || m_parent.get_selection().is_single_modifier()) {
|
|
ModelVolume *model_volume = m_parent.get_selection().get_selected_single_volume(m_object_idx, m_volume_idx);
|
|
if (model_volume) {
|
|
TextInfo text_info = model_volume->get_text_info();
|
|
if (!text_info.m_text.empty()) {
|
|
if (m_last_text_mv == model_volume) {
|
|
m_last_text_mv = model_volume;
|
|
return;
|
|
}
|
|
if (plater) {
|
|
plater->take_snapshot("enter Text");
|
|
}
|
|
auto box = model_volume->get_mesh_shared_ptr()->bounding_box();
|
|
auto valid_z = text_info.m_embeded_depth + text_info.m_thickness;
|
|
auto text_height = get_text_height(text_info.m_text);
|
|
m_really_use_surface_calc = true;
|
|
int index = -1;
|
|
for (size_t i = 0; i < 3; i++) {
|
|
if (abs(box.size()[i] - valid_z) < 0.1) {
|
|
m_really_use_surface_calc = false;
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
if (abs(box.size()[1] - text_height) > 0.1) {
|
|
m_fix_old_tran_flag = true;
|
|
}
|
|
m_last_text_mv = model_volume;
|
|
load_from_text_info(text_info);
|
|
m_text_volume_tran = model_volume->get_matrix();
|
|
m_text_tran_in_object.set_matrix(m_text_volume_tran);
|
|
int temp_object_idx;
|
|
auto mo = m_parent.get_selection().get_selected_single_object(temp_object_idx);
|
|
const ModelInstance *mi = mo->instances[m_parent.get_selection().get_instance_idx()];
|
|
m_object_cs_to_world_tran = mi->get_transformation().get_matrix();
|
|
auto world_tran = m_object_cs_to_world_tran * m_text_volume_tran;
|
|
m_text_tran_in_world.set_matrix(world_tran);
|
|
m_text_position_in_world = m_text_tran_in_world.get_offset();
|
|
m_text_normal_in_world = m_text_tran_in_world.get_matrix().linear().col(2).cast<float>();
|
|
{
|
|
TriangleMesh text_attach_mesh(mo->volumes[m_rr.mesh_id]->mesh());
|
|
text_attach_mesh.transform(mo->volumes[m_rr.mesh_id]->get_matrix());
|
|
MeshRaycaster temp_ray_caster(text_attach_mesh);
|
|
Vec3f local_center = m_text_tran_in_object.get_offset().cast<float>();//(m_text_tran_in_object.get_matrix() * box.center()).cast<float>(); //
|
|
Vec3f temp_normal;
|
|
Vec3f closest_pt = temp_ray_caster.get_closest_point(local_center, &temp_normal);
|
|
m_fix_text_position_in_world = m_object_cs_to_world_tran * closest_pt.cast<double>();
|
|
m_fix_text_normal_in_world = (mi->get_transformation().get_matrix_no_offset().cast<float>() * temp_normal).normalized();
|
|
int face_id;
|
|
Vec3f direction = m_text_tran_in_world.get_matrix().linear().col(2).cast<float>();
|
|
if (index == 2 && abs(box.size()[1] - text_height) < 0.1) {
|
|
m_is_version1_9_xoz = true;
|
|
m_fix_old_tran_flag = true;
|
|
}
|
|
if (index == 1 && abs(box.size()[2] - text_height) < 0.1) {//for 1.10 version, xoy plane cut,just fix
|
|
m_is_version1_10_xoy = true;
|
|
direction = m_text_tran_in_world.get_matrix().linear().col(1).cast<float>();
|
|
if (!temp_ray_caster.get_closest_point_and_normal(local_center, direction, &closest_pt, &temp_normal, &face_id)) {
|
|
m_show_warning_error_mesh = true;
|
|
}
|
|
}
|
|
else if (!temp_ray_caster.get_closest_point_and_normal(local_center, -direction, &closest_pt, &temp_normal, &face_id)) {
|
|
if (!temp_ray_caster.get_closest_point_and_normal(local_center, direction, &closest_pt, &temp_normal, &face_id)) {
|
|
m_show_warning_error_mesh = true;
|
|
}
|
|
}
|
|
}
|
|
// m_rr.mesh_id
|
|
m_need_update_text = false;
|
|
m_is_modify = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void GLGizmoText::data_changed(bool is_serializing) {
|
|
load_init_text();
|
|
}
|
|
|
|
CommonGizmosDataID GLGizmoText::on_get_requirements() const
|
|
{
|
|
return CommonGizmosDataID(
|
|
int(CommonGizmosDataID::SelectionInfo)
|
|
| int(CommonGizmosDataID::InstancesHider)
|
|
| int(CommonGizmosDataID::Raycaster)
|
|
| int(CommonGizmosDataID::ObjectClipper));
|
|
}
|
|
|
|
std::string GLGizmoText::on_get_name() const
|
|
{
|
|
if (!on_is_activable() && m_state == EState::Off) {
|
|
return _u8L("Text shape") + ":\n" + _u8L("Please select single object.");
|
|
} else {
|
|
return _u8L("Text shape");
|
|
}
|
|
}
|
|
|
|
bool GLGizmoText::on_is_activable() const
|
|
{
|
|
// This is assumed in GLCanvas3D::do_rotate, do not change this
|
|
// without updating that function too.
|
|
if (m_parent.get_selection().is_single_full_instance())
|
|
return true;
|
|
|
|
int obejct_idx, volume_idx;
|
|
ModelVolume *model_volume = m_parent.get_selection().get_selected_single_volume(obejct_idx, volume_idx);
|
|
if (model_volume)
|
|
return !model_volume->get_text_info().m_text.empty();
|
|
|
|
return false;
|
|
}
|
|
|
|
void GLGizmoText::on_render()
|
|
{
|
|
glsafe(::glClear(GL_DEPTH_BUFFER_BIT));
|
|
glsafe(::glEnable(GL_DEPTH_TEST));
|
|
|
|
std::string text = std::string(m_text);
|
|
if (text.empty()) {
|
|
delete_temp_preview_text_volume();
|
|
return;
|
|
}
|
|
|
|
ModelObject *mo = nullptr;
|
|
const Selection &selection = m_parent.get_selection();
|
|
mo = selection.get_model()->objects[m_object_idx];
|
|
|
|
if (mo == nullptr) {
|
|
BOOST_LOG_TRIVIAL(info) << boost::format("Text: selected object is null");
|
|
return;
|
|
}
|
|
// First check that the mouse pointer is on an object.
|
|
const ModelInstance *mi = mo->instances[selection.get_instance_idx()];
|
|
Plater *plater = wxGetApp().plater();
|
|
if (!plater)
|
|
return;
|
|
#ifdef DEBUG_TEXT
|
|
if (m_text_normal_in_world.norm() > 0.1) { // debug
|
|
Geometry::Transformation tran(m_text_volume_tran);
|
|
if (tran.get_offset().norm() > 1) {
|
|
auto text_volume_tran_world = mi->get_transformation().get_matrix() * m_text_volume_tran;
|
|
glsafe(::glPushMatrix());
|
|
glsafe(::glMultMatrixd(text_volume_tran_world.data()));
|
|
render_cross_mark(Vec3f::Zero(), true);
|
|
glsafe(::glPopMatrix());
|
|
}
|
|
|
|
glsafe(::glPushMatrix());
|
|
glsafe(::glMultMatrixd(m_text_tran_in_world.get_matrix().data()));
|
|
render_cross_mark(Vec3f::Zero(), true);
|
|
glsafe(::glPopMatrix());
|
|
|
|
glsafe(::glLineWidth(2.0f));
|
|
::glBegin(GL_LINES);
|
|
glsafe(::glColor3f(1.0f, 0.0f, 0.0f));
|
|
|
|
for (size_t i = 1; i < m_cut_points_in_world.size(); i++) {//draw points
|
|
auto target0 = m_cut_points_in_world[i - 1].cast<float>();
|
|
auto target1 = m_cut_points_in_world[i].cast<float>();
|
|
glsafe(::glVertex3f(target0(0), target0(1), target0(2)));
|
|
glsafe(::glVertex3f(target1(0), target1(1), target1(2)));
|
|
}
|
|
glsafe(::glEnd());
|
|
}
|
|
#endif
|
|
if (!m_is_modify || m_shift_down) {//for temp text
|
|
const Camera &camera = wxGetApp().plater()->get_camera();
|
|
// Precalculate transformations of individual meshes.
|
|
std::vector<Transform3d> trafo_matrices;
|
|
for (const ModelVolume *mv : mo->volumes) {
|
|
if (mv->is_model_part())
|
|
trafo_matrices.emplace_back(mi->get_transformation().get_matrix() * mv->get_matrix());
|
|
}
|
|
// Raycast and return if there's no hit.
|
|
Vec2d mouse_pos;
|
|
if (m_shift_down) {
|
|
if (m_is_modify)
|
|
mouse_pos = m_rr.mouse_position;
|
|
else
|
|
mouse_pos = m_origin_mouse_position;
|
|
}
|
|
else {
|
|
mouse_pos = m_parent.get_local_mouse_position();
|
|
}
|
|
|
|
bool position_changed = update_raycast_cache(mouse_pos, camera, trafo_matrices);
|
|
|
|
if (m_rr.mesh_id == -1) {
|
|
delete_temp_preview_text_volume();
|
|
return;
|
|
}
|
|
|
|
if (!position_changed && !m_need_update_text && !m_shift_down)
|
|
return;
|
|
update_text_pos_normal();
|
|
}
|
|
|
|
if (m_is_modify) {
|
|
update_text_pos_normal();
|
|
Geometry::Transformation tran;//= m_text_tran_in_world;
|
|
{
|
|
double phi;
|
|
Vec3d rotation_axis;
|
|
Matrix3d rotation_matrix;
|
|
Geometry::rotation_from_two_vectors(Vec3d::UnitZ(), m_text_normal_in_world.cast<double>(), rotation_axis, phi, &rotation_matrix);
|
|
tran.set_matrix((Transform3d) rotation_matrix);
|
|
}
|
|
tran.set_offset(m_text_position_in_world);
|
|
bool hover = (m_hover_id == m_move_cube_id);
|
|
std::array<float, 4> render_color;
|
|
if (hover) {
|
|
render_color = TEXT_GRABBER_HOVER_COLOR;
|
|
} else
|
|
render_color = TEXT_GRABBER_COLOR;
|
|
float fullsize = get_grabber_size();
|
|
m_move_grabber.center = tran.get_offset();
|
|
Transform3d rotate_matrix = tran.get_rotation_matrix();
|
|
Transform3d cube_mat = Geometry::translation_transform(m_move_grabber.center) * rotate_matrix * Geometry::scale_transform(fullsize);
|
|
render_glmodel(m_move_grabber.get_cube(), render_color, cube_mat);
|
|
}
|
|
|
|
delete_temp_preview_text_volume();
|
|
|
|
if (m_is_modify && !m_need_update_text)
|
|
return;
|
|
|
|
generate_text_volume();
|
|
plater->update();
|
|
}
|
|
|
|
void GLGizmoText::on_render_for_picking()
|
|
{
|
|
glsafe(::glDisable(GL_DEPTH_TEST));
|
|
|
|
int obejct_idx, volume_idx;
|
|
ModelVolume *model_volume = m_parent.get_selection().get_selected_single_volume(obejct_idx, volume_idx);
|
|
if (model_volume && !model_volume->get_text_info().m_text.empty()) {
|
|
const Selection &selection = m_parent.get_selection();
|
|
auto mo = selection.get_model()->objects[m_object_idx];
|
|
if (mo == nullptr)
|
|
return;
|
|
auto color = picking_color_component(m_move_cube_id);
|
|
m_move_grabber.color[0] = color[0];
|
|
m_move_grabber.color[1] = color[1];
|
|
m_move_grabber.color[2] = color[2];
|
|
m_move_grabber.color[3] = color[3];
|
|
m_move_grabber.render_for_picking();
|
|
}
|
|
}
|
|
|
|
void GLGizmoText::on_start_dragging()
|
|
{
|
|
}
|
|
|
|
void GLGizmoText::on_stop_dragging()
|
|
{
|
|
}
|
|
|
|
void GLGizmoText::on_update(const UpdateData &data)
|
|
{
|
|
Vec2d mouse_pos = Vec2d(data.mouse_pos.x(), data.mouse_pos.y());
|
|
|
|
const Selection &selection = m_parent.get_selection();
|
|
auto mo = selection.get_model()->objects[m_object_idx];
|
|
if (mo == nullptr)
|
|
return;
|
|
|
|
const ModelInstance *mi = mo->instances[selection.get_instance_idx()];
|
|
const Camera & camera = wxGetApp().plater()->get_camera();
|
|
|
|
std::vector<Transform3d> trafo_matrices;
|
|
for (const ModelVolume *mv : mo->volumes) {
|
|
if (mv->is_model_part()) { trafo_matrices.emplace_back(mi->get_transformation().get_matrix() * mv->get_matrix()); }
|
|
}
|
|
|
|
Vec3f normal = Vec3f::Zero();
|
|
Vec3f hit = Vec3f::Zero();
|
|
size_t facet = 0;
|
|
Vec3f closest_hit = Vec3f::Zero();
|
|
Vec3f closest_normal = Vec3f::Zero();
|
|
double closest_hit_squared_distance = std::numeric_limits<double>::max();
|
|
int closest_hit_mesh_id = -1;
|
|
|
|
// Cast a ray on all meshes, pick the closest hit and save it for the respective mesh
|
|
for (int mesh_id = 0; mesh_id < int(trafo_matrices.size()); ++mesh_id) {
|
|
if (mesh_id == m_volume_idx)
|
|
continue;
|
|
|
|
MeshRaycaster mesh_raycaster = MeshRaycaster(mo->volumes[mesh_id]->mesh());
|
|
|
|
if (mesh_raycaster.unproject_on_mesh(mouse_pos, trafo_matrices[mesh_id], camera, hit, normal, m_c->object_clipper()->get_clipping_plane(),
|
|
&facet)) {
|
|
// In case this hit is clipped, skip it.
|
|
if (is_mesh_point_clipped(hit.cast<double>(), trafo_matrices[mesh_id])) continue;
|
|
|
|
// Is this hit the closest to the camera so far?
|
|
double hit_squared_distance = (camera.get_position() - trafo_matrices[mesh_id] * hit.cast<double>()).squaredNorm();
|
|
if (hit_squared_distance < closest_hit_squared_distance) {
|
|
closest_hit_squared_distance = hit_squared_distance;
|
|
closest_hit_mesh_id = mesh_id;
|
|
closest_hit = hit;
|
|
closest_normal = normal;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (closest_hit == Vec3f::Zero() && closest_normal == Vec3f::Zero()) return;
|
|
|
|
if (closest_hit_mesh_id != -1) {
|
|
m_rr = {mouse_pos, closest_hit_mesh_id, closest_hit, closest_normal};//on drag
|
|
m_need_fix = false;
|
|
close_warning_flag_after_close_or_drag();
|
|
m_need_update_text = true;
|
|
}
|
|
}
|
|
|
|
void GLGizmoText::push_button_style(bool pressed) {
|
|
if (m_is_dark_mode) {
|
|
if (pressed) {
|
|
ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(43 / 255.f, 64 / 255.f, 54 / 255.f, 1.f));
|
|
ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(43 / 255.f, 64 / 255.f, 54 / 255.f, 1.f));
|
|
ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(43 / 255.f, 64 / 255.f, 54 / 255.f, 1.f));
|
|
ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.f, 174 / 255.f, 66 / 255.f, 1.f));
|
|
}
|
|
else {
|
|
ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(45.f / 255.f, 45.f / 255.f, 49.f / 255.f, 1.f));
|
|
ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(84 / 255.f, 84 / 255.f, 90 / 255.f, 1.f));
|
|
ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(84 / 255.f, 84 / 255.f, 90 / 255.f, 1.f));
|
|
ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(45.f / 255.f, 45.f / 255.f, 49.f / 255.f, 1.f));
|
|
}
|
|
}
|
|
else {
|
|
if (pressed) {
|
|
ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(219 / 255.f, 253 / 255.f, 231 / 255.f, 1.f));
|
|
ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(219 / 255.f, 253 / 255.f, 231 / 255.f, 1.f));
|
|
ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(219 / 255.f, 253 / 255.f, 231 / 255.f, 1.f));
|
|
ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(0.f, 174 / 255.f, 66 / 255.f, 1.f));
|
|
}
|
|
else {
|
|
ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(1.f, 1.f, 1.f, 1.f));
|
|
ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(238 / 255.f, 238 / 255.f, 238 / 255.f, 1.f));
|
|
ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(238 / 255.f, 238 / 255.f, 238 / 255.f, 1.f));
|
|
ImGui::PushStyleColor(ImGuiCol_Border, ImVec4(1.f, 1.f, 1.f, 1.f));
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
void GLGizmoText::pop_button_style() {
|
|
ImGui::PopStyleColor(4);
|
|
}
|
|
|
|
void GLGizmoText::push_combo_style(const float scale) {
|
|
if (m_is_dark_mode) {
|
|
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 1.0f * scale);
|
|
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f * scale);
|
|
ImGui::PushStyleColor(ImGuiCol_PopupBg, ImGuiWrapper::COL_WINDOW_BG_DARK);
|
|
ImGui::PushStyleColor(ImGuiCol_BorderActive, ImVec4(0.00f, 0.68f, 0.26f, 1.00f));
|
|
ImGui::PushStyleColor(ImGuiCol_HeaderHovered, ImVec4(0.00f, 0.68f, 0.26f, 0.0f));
|
|
ImGui::PushStyleColor(ImGuiCol_HeaderActive, ImVec4(0.00f, 0.68f, 0.26f, 1.0f));
|
|
ImGui::PushStyleColor(ImGuiCol_Header, ImVec4(0.00f, 0.68f, 0.26f, 1.0f));
|
|
ImGui::PushStyleColor(ImGuiCol_ScrollbarBg, ImGuiWrapper::COL_WINDOW_BG_DARK);
|
|
ImGui::PushStyleColor(ImGuiCol_Button, { 1.00f, 1.00f, 1.00f, 0.0f });
|
|
}
|
|
else {
|
|
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 1.0f * scale);
|
|
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f * scale);
|
|
ImGui::PushStyleColor(ImGuiCol_PopupBg, ImGuiWrapper::COL_WINDOW_BG);
|
|
ImGui::PushStyleColor(ImGuiCol_BorderActive, ImVec4(0.00f, 0.68f, 0.26f, 1.00f));
|
|
ImGui::PushStyleColor(ImGuiCol_HeaderHovered, ImVec4(0.00f, 0.68f, 0.26f, 0.0f));
|
|
ImGui::PushStyleColor(ImGuiCol_HeaderActive, ImVec4(0.00f, 0.68f, 0.26f, 1.0f));
|
|
ImGui::PushStyleColor(ImGuiCol_Header, ImVec4(0.00f, 0.68f, 0.26f, 1.0f));
|
|
ImGui::PushStyleColor(ImGuiCol_ScrollbarBg, ImGuiWrapper::COL_WINDOW_BG);
|
|
ImGui::PushStyleColor(ImGuiCol_Button, { 1.00f, 1.00f, 1.00f, 0.0f });
|
|
}
|
|
}
|
|
|
|
void GLGizmoText::pop_combo_style()
|
|
{
|
|
ImGui::PopStyleVar(2);
|
|
ImGui::PopStyleColor(7);
|
|
}
|
|
|
|
// BBS
|
|
void GLGizmoText::on_render_input_window(float x, float y, float bottom_limit)
|
|
{
|
|
if (!m_init_texture) {
|
|
update_font_texture();
|
|
m_init_texture = true;
|
|
}
|
|
|
|
if (m_imgui->get_font_size() != m_scale) {
|
|
m_scale = m_imgui->get_font_size();
|
|
update_font_texture();
|
|
}
|
|
if (m_textures.size() == 0) {
|
|
BOOST_LOG_TRIVIAL(info) << "GLGizmoText has no texture";
|
|
return;
|
|
}
|
|
|
|
const Selection &selection = m_parent.get_selection();
|
|
if (selection.is_single_full_instance() || selection.is_single_full_object()) {
|
|
const GLVolume * gl_volume = selection.get_volume(*selection.get_volume_idxs().begin());
|
|
int object_idx = gl_volume->object_idx();
|
|
if (object_idx != m_object_idx || (object_idx == m_object_idx && m_volume_idx != -1)) {
|
|
m_object_idx = object_idx;
|
|
m_volume_idx = -1;
|
|
reset_text_info();
|
|
}
|
|
} else if (selection.is_single_volume() || selection.is_single_modifier()) {
|
|
int object_idx, volume_idx;
|
|
ModelVolume *model_volume = m_parent.get_selection().get_selected_single_volume(object_idx, volume_idx);
|
|
if ((object_idx != m_object_idx || (object_idx == m_object_idx && volume_idx != m_volume_idx))
|
|
&& model_volume) {
|
|
m_last_text_mv = model_volume;
|
|
TextInfo text_info = model_volume->get_text_info();
|
|
load_from_text_info(text_info);//mouse click down
|
|
m_is_modify = true;
|
|
m_volume_idx = volume_idx;
|
|
m_object_idx = object_idx;
|
|
}
|
|
}
|
|
|
|
const float win_h = ImGui::GetWindowHeight();
|
|
y = std::min(y, bottom_limit - win_h);
|
|
GizmoImguiSetNextWIndowPos(x, y, ImGuiCond_Always, 0.0f, 0.0f);
|
|
|
|
static float last_y = 0.0f;
|
|
static float last_h = 0.0f;
|
|
|
|
const float currt_scale = m_parent.get_scale();
|
|
ImGuiWrapper::push_toolbar_style(currt_scale);
|
|
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(4.0,5.0) * currt_scale);
|
|
ImGui::PushStyleVar(ImGuiStyleVar_ScrollbarSize, 4.0f * currt_scale);
|
|
GizmoImguiBegin("Text", ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar);
|
|
#ifdef DEBUG_TEXT
|
|
std::string world_hit = "world hit x:" + formatFloat(m_text_position_in_world[0]) + " y:" + formatFloat(m_text_position_in_world[1]) +
|
|
" z:" + formatFloat(m_text_position_in_world[2]);
|
|
std::string hit = "local hit x:" + formatFloat(m_rr.hit[0]) + " y:" + formatFloat(m_rr.hit[1]) + " z:" + formatFloat(m_rr.hit[2]);
|
|
std::string normal = "normal x:" + formatFloat(m_rr.normal[0]) + " y:" + formatFloat(m_rr.normal[1]) + " z:" + formatFloat(m_rr.normal[2]);
|
|
auto cut_dir = "cut_dir x:" + formatFloat(m_cut_plane_dir_in_world[0]) + " y:" + formatFloat(m_cut_plane_dir_in_world[1]) + " z:" + formatFloat(m_cut_plane_dir_in_world[2]);
|
|
auto fix_position_str = "fix position:" + formatFloat(m_fix_text_position_in_world[0]) + " y:" + formatFloat(m_fix_text_position_in_world[1]) +
|
|
" z:" + formatFloat(m_fix_text_position_in_world[2]);
|
|
auto fix_normal_str = "fix normal:" + formatFloat(m_fix_text_normal_in_world[0]) + " y:" + formatFloat(m_fix_text_normal_in_world[1]) +
|
|
" z:" + formatFloat(m_fix_text_normal_in_world[2]);
|
|
m_imgui->text(world_hit);
|
|
m_imgui->text(hit);
|
|
m_imgui->text(normal);
|
|
m_imgui->text(cut_dir);
|
|
m_imgui->text(fix_position_str);
|
|
m_imgui->text(fix_normal_str);
|
|
#endif
|
|
float space_size = m_imgui->get_style_scaling() * 8;
|
|
float font_cap = m_imgui->calc_text_size(_L("Font")).x;
|
|
float size_cap = m_imgui->calc_text_size(_L("Size")).x;
|
|
float thickness_cap = m_imgui->calc_text_size(_L("Thickness")).x;
|
|
float input_cap = m_imgui->calc_text_size(_L("Input text")).x;
|
|
float depth_cap = m_imgui->calc_text_size(_L("Embeded")).x;
|
|
float caption_size = std::max(std::max(font_cap, size_cap), std::max(depth_cap, input_cap)) + space_size + ImGui::GetStyle().WindowPadding.x;
|
|
|
|
float input_text_size = m_imgui->scaled(10.0f);
|
|
float button_size = ImGui::GetFrameHeight();
|
|
|
|
ImVec2 selectable_size(std::max((input_text_size + ImGui::GetFrameHeight() * 2), m_combo_width + SELECTABLE_INNER_OFFSET * currt_scale), m_combo_height);
|
|
float list_width = selectable_size.x + ImGui::GetStyle().ScrollbarSize + 2 * currt_scale;
|
|
|
|
float input_size = list_width - button_size * 2 - ImGui::GetStyle().ItemSpacing.x * 4;
|
|
|
|
ImTextureID normal_B = m_parent.get_gizmos_manager().get_icon_texture_id(GLGizmosManager::MENU_ICON_NAME::IC_TEXT_B);
|
|
ImTextureID normal_T = m_parent.get_gizmos_manager().get_icon_texture_id(GLGizmosManager::MENU_ICON_NAME::IC_TEXT_T);
|
|
ImTextureID normal_B_dark = m_parent.get_gizmos_manager().get_icon_texture_id(GLGizmosManager::MENU_ICON_NAME::IC_TEXT_B_DARK);
|
|
ImTextureID normal_T_dark = m_parent.get_gizmos_manager().get_icon_texture_id(GLGizmosManager::MENU_ICON_NAME::IC_TEXT_T_DARK);
|
|
|
|
// adjust window position to avoid overlap the view toolbar
|
|
if (last_h != win_h || last_y != y) {
|
|
// ask canvas for another frame to render the window in the correct position
|
|
m_imgui->set_requires_extra_frame();
|
|
if (last_h != win_h)
|
|
last_h = win_h;
|
|
if (last_y != y)
|
|
last_y = y;
|
|
}
|
|
|
|
ImGui::AlignTextToFramePadding();
|
|
|
|
m_imgui->text(_L("Font"));
|
|
ImGui::SameLine(caption_size);
|
|
ImGui::PushItemWidth(list_width);
|
|
push_combo_style(currt_scale);
|
|
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
|
|
ImGui::PushStyleVar(ImGuiStyleVar_PopupRounding, 4.0f * currt_scale);
|
|
|
|
std::vector<int> filtered_items_idx;
|
|
bool is_filtered = false;
|
|
if (m_imgui->bbl_combo_with_filter("##Combo_Font", m_font_names[m_curr_font_idx], m_font_names, &filtered_items_idx, &is_filtered, selectable_size.y)) {
|
|
int show_items_count = is_filtered ? filtered_items_idx.size() : m_textures.size();
|
|
|
|
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0, 0));
|
|
ImGui::PushStyleVar(ImGuiStyleVar_ItemInnerSpacing, ImVec2(SELECTABLE_INNER_OFFSET, 0)* currt_scale);
|
|
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 0);
|
|
for (int i = 0; i < show_items_count; i++)
|
|
{
|
|
int idx = is_filtered ? filtered_items_idx[i] : i;
|
|
const bool is_selected = (idx == m_curr_font_idx);
|
|
ImTextureID icon_id = (ImTextureID)(intptr_t)(m_textures[idx].texture->get_id());
|
|
ImVec4 tint_color = ImGui::GetStyleColorVec4(ImGuiCol_Text);
|
|
if (ImGui::BBLImageSelectable(icon_id, selectable_size, { (float)m_textures[idx].w, (float)m_textures[idx].h }, m_textures[idx].hl, tint_color, { 0, 0 }, { 1, 1 }, is_selected))
|
|
{
|
|
m_curr_font_idx = idx;
|
|
m_font_name = m_textures[m_curr_font_idx].font_name;
|
|
ImGui::CloseCurrentPopup();
|
|
m_need_update_text = true;
|
|
}
|
|
if (is_selected) {
|
|
ImGui::SetItemDefaultFocus();
|
|
}
|
|
}
|
|
ImGui::PopStyleVar(3);
|
|
ImGui::EndListBox();
|
|
ImGui::EndPopup();
|
|
}
|
|
|
|
ImGui::PopStyleVar(2);
|
|
pop_combo_style();
|
|
ImGui::AlignTextToFramePadding();
|
|
m_imgui->text(_L("Size"));
|
|
ImGui::SameLine(caption_size);
|
|
ImGui::PushItemWidth(input_size);
|
|
if (ImGui::InputFloat("###font_size", &m_font_size, 0.0f, 0.0f, "%.2f")) {
|
|
limit_value(m_font_size, m_font_size_min, m_font_size_max);
|
|
m_need_update_text = true;
|
|
}
|
|
ImGui::SameLine();
|
|
|
|
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0f * currt_scale);
|
|
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, {1.0f * currt_scale, 1.0f * currt_scale });
|
|
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 2.0f * currt_scale);
|
|
push_button_style(m_bold);
|
|
if (ImGui::ImageButton(m_is_dark_mode ? normal_B_dark : normal_B, {button_size - 2 * ImGui::GetStyle().FramePadding.x, button_size - 2 * ImGui::GetStyle().FramePadding.y})) {
|
|
m_bold = !m_bold;
|
|
m_need_update_text = true;
|
|
}
|
|
pop_button_style();
|
|
ImGui::SameLine();
|
|
push_button_style(m_italic);
|
|
if (ImGui::ImageButton(m_is_dark_mode ? normal_T_dark : normal_T, {button_size - 2 * ImGui::GetStyle().FramePadding.x, button_size - 2 * ImGui::GetStyle().FramePadding.y})) {
|
|
m_italic = !m_italic;
|
|
m_need_update_text = true;
|
|
}
|
|
pop_button_style();
|
|
ImGui::PopStyleVar(3);
|
|
|
|
ImGui::AlignTextToFramePadding();
|
|
m_imgui->text(_L("Thickness"));
|
|
ImGui::SameLine(caption_size);
|
|
ImGui::PushItemWidth(list_width);
|
|
float old_value = m_thickness;
|
|
ImGui::InputFloat("###text_thickness", &m_thickness, 0.0f, 0.0f, "%.2f");
|
|
m_thickness = ImClamp(m_thickness, m_thickness_min, m_thickness_max);
|
|
if (old_value != m_thickness)
|
|
m_need_update_text = true;
|
|
|
|
const float slider_icon_width = m_imgui->get_slider_icon_size().x;
|
|
const float slider_width = list_width - 1.5 * slider_icon_width - space_size;
|
|
const float drag_left_width = caption_size + slider_width + space_size;
|
|
|
|
ImGui::AlignTextToFramePadding();
|
|
m_imgui->text(_L("Text Gap"));
|
|
ImGui::SameLine(caption_size);
|
|
ImGui::PushItemWidth(slider_width);
|
|
if (m_imgui->bbl_slider_float_style("##text_gap", &m_text_gap, -100, 100, "%.2f", 1.0f, true))
|
|
m_need_update_text = true;
|
|
ImGui::SameLine(drag_left_width);
|
|
ImGui::PushItemWidth(1.5 * slider_icon_width);
|
|
if (ImGui::BBLDragFloat("##text_gap_input", &m_text_gap, 0.05f, 0.0f, 0.0f, "%.2f"))
|
|
m_need_update_text = true;
|
|
|
|
ImGui::AlignTextToFramePadding();
|
|
m_imgui->text(_L("Angle"));
|
|
ImGui::SameLine(caption_size);
|
|
ImGui::PushItemWidth(slider_width);
|
|
if (m_imgui->bbl_slider_float_style("##angle", &m_rotate_angle, 0, 360, "%.2f", 1.0f, true))
|
|
m_need_update_text = true;
|
|
ImGui::SameLine(drag_left_width);
|
|
ImGui::PushItemWidth(1.5 * slider_icon_width);
|
|
if (ImGui::BBLDragFloat("##angle_input", &m_rotate_angle, 0.05f, 0.0f, 0.0f, "%.2f"))
|
|
m_need_update_text = true;
|
|
|
|
ImGui::AlignTextToFramePadding();
|
|
m_imgui->text(_L("Embeded\r\ndepth"));
|
|
ImGui::SameLine(caption_size);
|
|
ImGui::PushItemWidth(list_width);
|
|
old_value = m_embeded_depth;
|
|
if (ImGui::InputFloat("###text_embeded_depth", &m_embeded_depth, 0.0f, 0.0f, "%.2f")) {
|
|
limit_value(m_embeded_depth, 0.0f, m_embeded_depth_max);
|
|
}
|
|
if (old_value != m_embeded_depth)
|
|
m_need_update_text = true;
|
|
|
|
ImGui::AlignTextToFramePadding();
|
|
m_imgui->text(_L("Input text"));
|
|
ImGui::SameLine(caption_size);
|
|
ImGui::PushItemWidth(list_width);
|
|
|
|
if(ImGui::InputText("", m_text, sizeof(m_text)))
|
|
m_need_update_text = true;
|
|
std::string text = std::string(m_text);
|
|
if (text.empty() && m_is_modify) {
|
|
m_imgui->warning_text(_L("Warning:Input cannot be empty!"));
|
|
}
|
|
if (m_show_warning_text_create_fail) {
|
|
m_imgui->warning_text(_L("Warning:create text fail."));
|
|
}
|
|
if (m_show_text_normal_error) {
|
|
m_imgui->warning_text(_L("Warning:text normal is error."));
|
|
}
|
|
if (m_show_text_normal_reset_tip) {
|
|
m_imgui->warning_text(_L("Warning:text normal has been reset."));
|
|
}
|
|
if (m_show_warning_regenerated) {
|
|
m_imgui->warning_text(_L("Warning:Because current text does indeed use surround algorithm,\nif continue to edit, text has to regenerated according to new location."));
|
|
}
|
|
if (m_show_warning_old_tran) {
|
|
m_imgui->warning_text(_L("Warning:old matrix has at least two parameters: mirroring, scaling, and rotation. \nIf you continue editing, it may not be correct. \nPlease dragging text or cancel using current pose, \nsave and reedit again."));
|
|
}
|
|
if (m_show_warning_error_mesh) {
|
|
m_imgui->warning_text(_L("Error:Detecting an incorrect mesh id or an unknown error, \nregenerating text may result in incorrect outcomes.\nPlease drag text,save it then reedit it again."));
|
|
}
|
|
if (m_show_warning_lost_rotate) {
|
|
m_imgui->warning_text(_L("Warning:Due to functional upgrade, rotation information \ncannot be restored. Please drag or modify text,\n save it and reedit it will ok."));
|
|
}
|
|
ImGui::Separator();
|
|
if (m_need_fix && m_text_type > TextType::HORIZONAL) {
|
|
ImGui::AlignTextToFramePadding();
|
|
ImGui::SameLine(caption_size);
|
|
ImGui::PushItemWidth(list_width);
|
|
ImGui::AlignTextToFramePadding();
|
|
if (m_imgui->bbl_checkbox(_L("Use opened text pose"), m_use_current_pose)) {
|
|
m_need_update_text = true;
|
|
}
|
|
}
|
|
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(6.0f, 10.0f));
|
|
float get_cur_y = ImGui::GetContentRegionMax().y + ImGui::GetFrameHeight() + y;
|
|
show_tooltip_information(x, get_cur_y);
|
|
|
|
float f_scale = m_parent.get_gizmos_manager().get_layout_scale();
|
|
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, ImVec2(6.0f, 4.0f * f_scale));
|
|
|
|
ImGui::SameLine(caption_size);
|
|
ImGui::AlignTextToFramePadding();
|
|
auto is_surface_text = m_text_type == TextType::SURFACE || m_text_type == TextType::SURFACE_HORIZONAL;
|
|
if (m_imgui->bbl_checkbox(_L("Surface"), is_surface_text)) {
|
|
m_need_update_text = true;
|
|
}
|
|
ImGui::SameLine();
|
|
ImGui::AlignTextToFramePadding();
|
|
auto is_keep_horizontal = m_text_type == TextType::HORIZONAL || m_text_type == TextType::SURFACE_HORIZONAL;
|
|
if (m_imgui->bbl_checkbox(_L("Horizontal text"), is_keep_horizontal)) {
|
|
m_need_update_text = true;
|
|
if (is_surface_text && is_keep_horizontal == false) {
|
|
update_text_normal_in_world();
|
|
}
|
|
}
|
|
check_text_type(is_surface_text, is_keep_horizontal);
|
|
|
|
//ImGui::SameLine();
|
|
//ImGui::AlignTextToFramePadding();
|
|
//m_imgui->text(_L("Status:"));
|
|
//float status_cap = m_imgui->calc_text_size(_L("Status:")).x + space_size + ImGui::GetStyle().WindowPadding.x;
|
|
//ImGui::SameLine();
|
|
//m_imgui->text(m_is_modify ? _L("Modify") : _L("Add"));
|
|
|
|
ImGui::PopStyleVar(2);
|
|
|
|
#if 0
|
|
ImGuiIO& io = ImGui::GetIO();
|
|
ImFontAtlas* atlas = io.Fonts;
|
|
ImVec4 tint_col = ImVec4(0.0f, 0.0f, 0.0f, 1.0f);
|
|
ImVec4 border_col = ImVec4(0.0f, 0.0f, 0.0f, 0.8f);
|
|
m_imgui->text(wxString("") << atlas->TexWidth << " * " << atlas->TexHeight);
|
|
ImGui::Image(atlas->TexID, ImVec2((float)atlas->TexWidth, (float)atlas->TexHeight), ImVec2(0.0f, 0.0f), ImVec2(1.0f, 1.0f), tint_col, border_col);
|
|
#endif
|
|
|
|
GizmoImguiEnd();
|
|
ImGui::PopStyleVar(2);
|
|
ImGuiWrapper::pop_toolbar_style();
|
|
}
|
|
|
|
void GLGizmoText::show_tooltip_information(float x, float y)
|
|
{
|
|
std::array<std::string, 1> info_array = std::array<std::string, 1>{"rotate_text"};
|
|
float caption_max = 0.f;
|
|
for (const auto &t : info_array) { caption_max = std::max(caption_max, m_imgui->calc_text_size(m_desc[t + "_caption"]).x); }
|
|
|
|
ImTextureID normal_id = m_parent.get_gizmos_manager().get_icon_texture_id(GLGizmosManager::MENU_ICON_NAME::IC_TOOLBAR_TOOLTIP);
|
|
ImTextureID hover_id = m_parent.get_gizmos_manager().get_icon_texture_id(GLGizmosManager::MENU_ICON_NAME::IC_TOOLBAR_TOOLTIP_HOVER);
|
|
|
|
caption_max += m_imgui->calc_text_size(": ").x + 35.f;
|
|
|
|
float font_size = ImGui::GetFontSize();
|
|
ImVec2 button_size = ImVec2(font_size * 1.8, font_size * 1.3);
|
|
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0f);
|
|
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, {0, ImGui::GetStyle().FramePadding.y});
|
|
ImGui::ImageButton3(normal_id, hover_id, button_size);
|
|
|
|
if (ImGui::IsItemHovered()) {
|
|
ImGui::BeginTooltip2(ImVec2(x, y));
|
|
auto draw_text_with_caption = [this, &caption_max](const wxString &caption, const wxString &text) {
|
|
m_imgui->text_colored(ImGuiWrapper::COL_ACTIVE, caption);
|
|
ImGui::SameLine(caption_max);
|
|
m_imgui->text_colored(ImGuiWrapper::COL_WINDOW_BG, text);
|
|
};
|
|
|
|
for (const auto &t : info_array) draw_text_with_caption(m_desc.at(t + "_caption") + ": ", m_desc.at(t));
|
|
ImGui::EndTooltip();
|
|
}
|
|
ImGui::PopStyleVar(2);
|
|
}
|
|
|
|
void GLGizmoText::reset_text_info()
|
|
{
|
|
m_font_name = "";
|
|
m_font_size = 16.f;
|
|
m_curr_font_idx = 0;
|
|
m_bold = true;
|
|
m_italic = false;
|
|
m_thickness = 2.f;
|
|
strcpy(m_text, m_font_name.c_str());
|
|
m_embeded_depth = 0.f;
|
|
m_rotate_angle = 0;
|
|
m_text_gap = 0.f;
|
|
m_text_type = TextType::SURFACE;
|
|
m_rr = RaycastResult();
|
|
m_is_modify = false;
|
|
}
|
|
|
|
void GLGizmoText::update_text_pos_normal() {
|
|
if (m_rr.mesh_id < 0) { return; }
|
|
if (m_rr.normal.norm() < 0.1) { return; }
|
|
const Selection &selection = m_parent.get_selection();
|
|
auto mo = selection.get_model()->objects[m_object_idx];
|
|
if (mo == nullptr) {
|
|
BOOST_LOG_TRIVIAL(info) << boost::format("Text: selected object is null");
|
|
return;
|
|
}
|
|
const ModelInstance *mi = mo->instances[selection.get_instance_idx()];
|
|
|
|
std::vector<Geometry::Transformation> w_matrices;
|
|
std::vector<Geometry::Transformation> mv_trans;
|
|
for (const ModelVolume *mv : mo->volumes) {
|
|
if (mv->is_model_part()) {
|
|
w_matrices.emplace_back(Geometry::Transformation(mi->get_transformation().get_matrix() * mv->get_matrix()));
|
|
mv_trans.emplace_back(Geometry::Transformation(mv->get_matrix()));
|
|
}
|
|
}
|
|
#ifdef DEBUG_TEXT_VALUE
|
|
m_rr.hit = Vec3f(-0.58, -1.70, -12.8);
|
|
m_rr.normal = Vec3f(0,0,-1);//just rotate cube
|
|
#endif
|
|
m_text_position_in_world = w_matrices[m_rr.mesh_id].get_matrix() * m_rr.hit.cast<double>();
|
|
m_text_normal_in_world = (w_matrices[m_rr.mesh_id].get_matrix_no_offset().cast<float>() * m_rr.normal).normalized();
|
|
}
|
|
|
|
void GLGizmoText::update_font_status()
|
|
{
|
|
std::unique_lock<std::mutex> lock(m_mutex);
|
|
m_font_status.reserve(m_avail_font_names.size());
|
|
for (std::string font_name : m_avail_font_names) {
|
|
if (!can_generate_text_shape(font_name)) {
|
|
m_font_status.emplace_back(false);
|
|
}
|
|
else {
|
|
m_font_status.emplace_back(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
float GLGizmoText::get_text_height(const std::string &text)
|
|
{
|
|
std::wstring_convert<std::codecvt_utf8<wchar_t>> str_cnv;
|
|
std::wstring ws = boost::nowide::widen(text);
|
|
std::vector<std::string> alphas;
|
|
for (auto w : ws) {
|
|
alphas.push_back(str_cnv.to_bytes(w));
|
|
}
|
|
auto texts = alphas ;
|
|
float max_height = 0.f;
|
|
for (int i = 0; i < texts.size(); ++i) {
|
|
std::string alpha;
|
|
if (texts[i] == " ") {
|
|
alpha = "i";
|
|
} else {
|
|
alpha = texts[i];
|
|
}
|
|
TextResult text_result;
|
|
load_text_shape(alpha.c_str(), m_font_name.c_str(), m_font_size, m_thickness + m_embeded_depth, m_bold, m_italic, text_result);
|
|
auto height = text_result.text_mesh.bounding_box().size()[1];
|
|
if (max_height < height ){
|
|
max_height = height;
|
|
}
|
|
}
|
|
return max_height;
|
|
}
|
|
|
|
void GLGizmoText::close_warning_flag_after_close_or_drag()
|
|
{
|
|
m_show_warning_text_create_fail = false;
|
|
m_show_warning_regenerated = false;
|
|
m_show_warning_error_mesh = false;
|
|
m_show_warning_old_tran = false;
|
|
m_show_warning_lost_rotate = false;
|
|
m_show_text_normal_error = false;
|
|
m_show_text_normal_reset_tip = false;
|
|
m_show_warning_lost_rotate = false;
|
|
m_is_version1_10_xoy = false;
|
|
m_is_version1_9_xoz = false;
|
|
}
|
|
|
|
void GLGizmoText::update_text_normal_in_world()
|
|
{
|
|
int temp_object_idx;
|
|
auto mo = m_parent.get_selection().get_selected_single_object(temp_object_idx);
|
|
if (mo && m_rr.mesh_id >= 0) {
|
|
const ModelInstance *mi = mo->instances[m_parent.get_selection().get_instance_idx()];
|
|
TriangleMesh text_attach_mesh(mo->volumes[m_rr.mesh_id]->mesh());
|
|
text_attach_mesh.transform(mo->volumes[m_rr.mesh_id]->get_matrix());
|
|
MeshRaycaster temp_ray_caster(text_attach_mesh);
|
|
Vec3f local_center = m_text_tran_in_object.get_offset().cast<float>(); //(m_text_tran_in_object.get_matrix() * box.center()).cast<float>(); //
|
|
Vec3f temp_normal;
|
|
Vec3f closest_pt = temp_ray_caster.get_closest_point(local_center, &temp_normal);
|
|
m_text_normal_in_world = (mi->get_transformation().get_matrix_no_offset().cast<float>() * temp_normal).normalized();
|
|
}
|
|
else {
|
|
BOOST_LOG_TRIVIAL(info) << boost::format("error: update_text_normal_in_world");
|
|
}
|
|
}
|
|
|
|
bool GLGizmoText::update_text_positions(const std::vector<std::string>& texts)
|
|
{
|
|
std::vector<double> text_lengths;
|
|
for (int i = 0; i < texts.size(); ++i) {
|
|
std::string alpha;
|
|
if (texts[i] == " ") {
|
|
alpha = "i";
|
|
} else {
|
|
alpha = texts[i];
|
|
}
|
|
TextResult text_result;
|
|
load_text_shape(alpha.c_str(), m_font_name.c_str(), m_font_size, m_thickness + m_embeded_depth, m_bold, m_italic, text_result);
|
|
double half_x_length = text_result.text_width / 2;
|
|
text_lengths.emplace_back(half_x_length);
|
|
}
|
|
|
|
int text_num = texts.size();
|
|
m_position_points.clear();
|
|
m_normal_points.clear();
|
|
|
|
const Selection &selection = m_parent.get_selection();
|
|
auto mo = selection.get_model()->objects[m_object_idx];
|
|
if (mo == nullptr)
|
|
return false;
|
|
const ModelInstance *mi = mo->instances[selection.get_instance_idx()];
|
|
m_model_object_in_world_tran = mi->get_transformation();
|
|
// Precalculate transformations of individual meshes.
|
|
std::vector<Transform3d> trafo_matrices;
|
|
std::vector<Transform3d> rotate_trafo_matrices;
|
|
for (const ModelVolume *mv : mo->volumes) {
|
|
if (mv->is_model_part()) {
|
|
trafo_matrices.emplace_back(mi->get_transformation().get_matrix() * mv->get_matrix());
|
|
rotate_trafo_matrices.emplace_back(mi->get_transformation().get_matrix(true, false, true, true) * mv->get_matrix(true, false, true, true));
|
|
}
|
|
}
|
|
|
|
if (m_rr.mesh_id == -1) {
|
|
BOOST_LOG_TRIVIAL(info) << boost::format("Text: mrr_mesh_id is -1");
|
|
return false;
|
|
}
|
|
// mouse_position_world may is error after user modified
|
|
if (m_need_fix) {
|
|
if (m_text_normal_in_world.norm() < 0.1) {
|
|
m_show_text_normal_reset_tip = true;
|
|
}
|
|
use_fix_normal_position();
|
|
}
|
|
if (m_text_normal_in_world.norm() < 0.1) {
|
|
m_show_text_normal_error = true;
|
|
BOOST_LOG_TRIVIAL(info) << "m_text_normal_in_object is error";
|
|
return false;
|
|
}
|
|
m_show_text_normal_error = false;
|
|
auto mouse_position_world = m_text_position_in_world.cast<double>();
|
|
auto mouse_normal_world = m_text_normal_in_world.cast<double>();
|
|
|
|
TriangleMesh slice_meshs;
|
|
int mesh_index = 0;
|
|
int volume_index = 0;
|
|
for (int i = 0; i < mo->volumes.size(); ++i) {
|
|
// skip the editing text volume
|
|
if (m_is_modify && m_volume_idx == i)
|
|
continue;
|
|
|
|
ModelVolume *mv = mo->volumes[i];
|
|
if (mv->is_model_part()) {
|
|
if (mesh_index == m_rr.mesh_id) {
|
|
volume_index = i;
|
|
}
|
|
TriangleMesh vol_mesh(mv->mesh());
|
|
vol_mesh.transform(mv->get_matrix());
|
|
slice_meshs.merge(vol_mesh);
|
|
mesh_index++;
|
|
}
|
|
}
|
|
|
|
ModelVolume* volume = mo->volumes[volume_index];
|
|
|
|
generate_text_tran_in_world(m_text_normal_in_world.cast<double>(), m_text_position_in_world, m_rotate_angle, m_text_tran_in_world);
|
|
|
|
m_cut_plane_dir_in_world = m_text_tran_in_world.get_matrix().linear().col(1);
|
|
m_text_normal_in_world = m_text_tran_in_world.get_matrix().linear().col(2).cast<float>();
|
|
// generate clip cs at click pos
|
|
auto text_position_in_object = mi->get_transformation().get_matrix().inverse() * m_text_position_in_world.cast<double>();
|
|
auto rotate_mat_inv = mi->get_transformation().get_matrix_no_offset().inverse();
|
|
|
|
auto text_tran_in_object = mi->get_transformation().get_matrix().inverse() * m_text_tran_in_world.get_matrix(); // Geometry::generate_transform(cs_x_dir, cs_y_dir, cs_z_dir, text_position_in_object); // todo modify by m_text_tran_in_world
|
|
m_text_tran_in_object.set_matrix(text_tran_in_object);
|
|
m_text_cs_to_world_tran = mi->get_transformation().get_matrix() * m_text_tran_in_object.get_matrix();
|
|
auto rotate_tran = Geometry::assemble_transform(Vec3d::Zero(), {-0.5 * M_PI, 0.0, 0.0});
|
|
if (m_text_type == TextType::HORIZONAL || (m_need_fix && m_use_current_pose)) {
|
|
m_position_points.resize(text_num);
|
|
m_normal_points.resize(text_num);
|
|
|
|
Vec3d pos_dir = m_cut_plane_dir_in_world.cross(mouse_normal_world);
|
|
pos_dir.normalize();
|
|
if (text_num % 2 == 1) {
|
|
m_position_points[text_num / 2] = mouse_position_world;
|
|
for (int i = 0; i < text_num / 2; ++i) {
|
|
double left_gap = text_lengths[text_num / 2 - i - 1] + m_text_gap + text_lengths[text_num / 2 - i];
|
|
if (left_gap < 0)
|
|
left_gap = 0;
|
|
|
|
double right_gap = text_lengths[text_num / 2 + i + 1] + m_text_gap + text_lengths[text_num / 2 + i];
|
|
if (right_gap < 0)
|
|
right_gap = 0;
|
|
|
|
m_position_points[text_num / 2 - 1 - i] = m_position_points[text_num / 2 - i] - left_gap * pos_dir;
|
|
m_position_points[text_num / 2 + 1 + i] = m_position_points[text_num / 2 + i] + right_gap * pos_dir;
|
|
}
|
|
} else {
|
|
for (int i = 0; i < text_num / 2; ++i) {
|
|
double left_gap = i == 0 ? (text_lengths[text_num / 2 - i - 1] + m_text_gap / 2) :
|
|
(text_lengths[text_num / 2 - i - 1] + m_text_gap + text_lengths[text_num / 2 - i]);
|
|
if (left_gap < 0)
|
|
left_gap = 0;
|
|
|
|
double right_gap = i == 0 ? (text_lengths[text_num / 2 + i] + m_text_gap / 2) :
|
|
(text_lengths[text_num / 2 + i] + m_text_gap + text_lengths[text_num / 2 + i - 1]);
|
|
if (right_gap < 0)
|
|
right_gap = 0;
|
|
|
|
if (i == 0) {
|
|
m_position_points[text_num / 2 - 1 - i] = mouse_position_world - left_gap * pos_dir;
|
|
m_position_points[text_num / 2 + i] = mouse_position_world + right_gap * pos_dir;
|
|
continue;
|
|
}
|
|
|
|
m_position_points[text_num / 2 - 1 - i] = m_position_points[text_num / 2 - i] - left_gap * pos_dir;
|
|
m_position_points[text_num / 2 + i] = m_position_points[text_num / 2 + i - 1] + right_gap * pos_dir;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < text_num; ++i) {
|
|
m_normal_points[i] = mouse_normal_world;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
MeshSlicingParams slicing_params;
|
|
auto cut_tran = (m_text_tran_in_object.get_matrix() * rotate_tran);
|
|
slicing_params.trafo = cut_tran.inverse();
|
|
// for debug
|
|
// its_write_obj(slice_meshs.its, "D:/debug_files/mesh.obj");
|
|
// generate polygons
|
|
const Polygons temp_polys = slice_mesh(slice_meshs.its, 0, slicing_params);
|
|
Vec3d scale_click_pt(scale_(0), scale_(0), 0);
|
|
// for debug
|
|
// export_regions_to_svg(Point(scale_pt.x(), scale_pt.y()), temp_polys);
|
|
Polygons polys = union_(temp_polys);
|
|
|
|
auto point_in_line_rectange = [](const Line &line, const Point &point, double& distance) {
|
|
distance = line.distance_to(point);
|
|
return distance < line.length() / 2;
|
|
};
|
|
|
|
int index = 0;
|
|
double min_distance = 1e12;
|
|
Polygon hit_ploy;
|
|
for (const Polygon poly : polys) {
|
|
if (poly.points.size() == 0)
|
|
continue;
|
|
|
|
Lines lines = poly.lines();
|
|
for (int i = 0; i < lines.size(); ++i) {
|
|
Line line = lines[i];
|
|
double distance = min_distance;
|
|
if (point_in_line_rectange(line, Point(scale_click_pt.x(), scale_click_pt.y()), distance)) {
|
|
if (distance < min_distance) {
|
|
min_distance = distance;
|
|
index = i;
|
|
hit_ploy = poly;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (hit_ploy.points.size() == 0) {
|
|
BOOST_LOG_TRIVIAL(info) << boost::format("Text: the hit polygon is null");
|
|
return false;
|
|
}
|
|
|
|
m_cut_points_in_world.clear();
|
|
m_cut_points_in_world.reserve(hit_ploy.points.size());
|
|
for (int i = 0; i < hit_ploy.points.size(); ++i) {
|
|
m_cut_points_in_world.emplace_back(m_text_cs_to_world_tran * rotate_tran * Vec3d(unscale_(hit_ploy.points[i].x()), unscale_(hit_ploy.points[i].y()), 0));
|
|
}
|
|
|
|
Polygon_3D new_polygon(m_cut_points_in_world);
|
|
m_position_points.resize(text_num);
|
|
if (text_num % 2 == 1) {
|
|
m_position_points[text_num / 2] = Vec3d(mouse_position_world.x(), mouse_position_world.y(), mouse_position_world.z());
|
|
|
|
std::vector<Line_3D> lines = new_polygon.get_lines();
|
|
Line_3D line = lines[index];
|
|
{
|
|
int index1 = index;
|
|
double left_length = (mouse_position_world - line.a).cast<double>().norm();
|
|
int left_num = text_num / 2;
|
|
while (left_num > 0) {
|
|
double gap_length = (text_lengths[left_num] + m_text_gap + text_lengths[left_num - 1]);
|
|
if (gap_length < 0)
|
|
gap_length = 0;
|
|
|
|
while (gap_length > left_length) {
|
|
gap_length -= left_length;
|
|
if (index1 == 0)
|
|
index1 = lines.size() - 1;
|
|
else
|
|
--index1;
|
|
left_length = lines[index1].length();
|
|
}
|
|
|
|
Vec3d direction = lines[index1].vector();
|
|
direction.normalize();
|
|
double distance_to_a = (left_length - gap_length);
|
|
Line_3D new_line = lines[index1];
|
|
|
|
double norm_value = direction.cast<double>().norm();
|
|
double deta_x = distance_to_a * direction.x() / norm_value;
|
|
double deta_y = distance_to_a * direction.y() / norm_value;
|
|
double deta_z = distance_to_a * direction.z() / norm_value;
|
|
Vec3d new_pos = new_line.a + Vec3d(deta_x, deta_y, deta_z);
|
|
left_num--;
|
|
m_position_points[left_num] = new_pos;
|
|
left_length = distance_to_a;
|
|
}
|
|
}
|
|
|
|
{
|
|
int index2 = index;
|
|
double right_length = (line.b - mouse_position_world).cast<double>().norm();
|
|
int right_num = text_num / 2;
|
|
while (right_num > 0) {
|
|
double gap_length = (text_lengths[text_num - right_num] + m_text_gap + text_lengths[text_num - right_num - 1]);
|
|
if (gap_length < 0)
|
|
gap_length = 0;
|
|
|
|
while (gap_length > right_length) {
|
|
gap_length -= right_length;
|
|
if (index2 == lines.size() - 1)
|
|
index2 = 0;
|
|
else
|
|
++index2;
|
|
right_length = lines[index2].length();
|
|
}
|
|
|
|
Line_3D line2 = lines[index2];
|
|
line2.reverse();
|
|
Vec3d direction = line2.vector();
|
|
direction.normalize();
|
|
double distance_to_b = (right_length - gap_length);
|
|
Line_3D new_line = lines[index2];
|
|
|
|
double norm_value = direction.cast<double>().norm();
|
|
double deta_x = distance_to_b * direction.x() / norm_value;
|
|
double deta_y = distance_to_b * direction.y() / norm_value;
|
|
double deta_z = distance_to_b * direction.z() / norm_value;
|
|
Vec3d new_pos = new_line.b + Vec3d(deta_x, deta_y, deta_z);
|
|
m_position_points[text_num - right_num] = new_pos;
|
|
right_length = distance_to_b;
|
|
right_num--;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for (int i = 0; i < text_num / 2; ++i) {
|
|
std::vector<Line_3D> lines = new_polygon.get_lines();
|
|
Line_3D line = lines[index];
|
|
{
|
|
int index1 = index;
|
|
double left_length = (mouse_position_world - line.a).cast<double>().norm();
|
|
int left_num = text_num / 2;
|
|
for (int i = 0; i < text_num / 2; ++i) {
|
|
double gap_length = 0;
|
|
if (i == 0) {
|
|
gap_length = m_text_gap / 2 + text_lengths[text_num / 2 - 1 - i];
|
|
}
|
|
else {
|
|
gap_length = text_lengths[text_num / 2 - i] + m_text_gap + text_lengths[text_num / 2 - 1 - i];
|
|
}
|
|
if (gap_length < 0)
|
|
gap_length = 0;
|
|
|
|
while (gap_length > left_length) {
|
|
gap_length -= left_length;
|
|
if (index1 == 0)
|
|
index1 = lines.size() - 1;
|
|
else
|
|
--index1;
|
|
left_length = lines[index1].length();
|
|
}
|
|
|
|
Vec3d direction = lines[index1].vector();
|
|
direction.normalize();
|
|
double distance_to_a = (left_length - gap_length);
|
|
Line_3D new_line = lines[index1];
|
|
|
|
double norm_value = direction.cast<double>().norm();
|
|
double deta_x = distance_to_a * direction.x() / norm_value;
|
|
double deta_y = distance_to_a * direction.y() / norm_value;
|
|
double deta_z = distance_to_a * direction.z() / norm_value;
|
|
Vec3d new_pos = new_line.a + Vec3d(deta_x, deta_y,deta_z);
|
|
|
|
m_position_points[text_num / 2 - 1 - i] = new_pos;
|
|
left_length = distance_to_a;
|
|
}
|
|
}
|
|
|
|
{
|
|
int index2 = index;
|
|
double right_length = (line.b - mouse_position_world).cast<double>().norm();
|
|
int right_num = text_num / 2;
|
|
double gap_length = 0;
|
|
for (int i = 0; i < text_num / 2; ++i) {
|
|
double gap_length = 0;
|
|
if (i == 0) {
|
|
gap_length = m_text_gap / 2 + text_lengths[text_num / 2 + i];
|
|
} else {
|
|
gap_length = text_lengths[text_num / 2 + i] + m_text_gap + text_lengths[text_num / 2 + i - 1];
|
|
}
|
|
if (gap_length < 0)
|
|
gap_length = 0;
|
|
|
|
while (gap_length > right_length) {
|
|
gap_length -= right_length;
|
|
if (index2 == lines.size() - 1)
|
|
index2 = 0;
|
|
else
|
|
++index2;
|
|
right_length = lines[index2].length();
|
|
}
|
|
|
|
Line_3D line2 = lines[index2];
|
|
line2.reverse();
|
|
Vec3d direction = line2.vector();
|
|
direction.normalize();
|
|
double distance_to_b = (right_length - gap_length);
|
|
Line_3D new_line = lines[index2];
|
|
|
|
double norm_value = direction.cast<double>().norm();
|
|
double deta_x = distance_to_b * direction.x() / norm_value;
|
|
double deta_y = distance_to_b * direction.y() / norm_value;
|
|
double deta_z = distance_to_b * direction.z() / norm_value;
|
|
Vec3d new_pos = new_line.b + Vec3d(deta_x, deta_y, deta_z);
|
|
m_position_points[text_num / 2 + i] = new_pos;
|
|
right_length = distance_to_b;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TriangleMesh mesh = slice_meshs;
|
|
std::vector<double> mesh_values(m_position_points.size(), 1e9);
|
|
m_normal_points.resize(m_position_points.size());
|
|
auto point_in_triangle_delete_area = [](const Vec3d &point, const Vec3d &point0, const Vec3d &point1, const Vec3d &point2) {
|
|
Vec3d p0_p = point - point0;
|
|
Vec3d p0_p1 = point1 - point0;
|
|
Vec3d p0_p2 = point2 - point0;
|
|
Vec3d p_p0 = point0 - point;
|
|
Vec3d p_p1 = point1 - point;
|
|
Vec3d p_p2 = point2 - point;
|
|
|
|
double s = p0_p1.cross(p0_p2).norm();
|
|
double s0 = p_p0.cross(p_p1).norm();
|
|
double s1 = p_p1.cross(p_p2).norm();
|
|
double s2 = p_p2.cross(p_p0).norm();
|
|
|
|
return abs(s0 + s1 + s2 - s);
|
|
};
|
|
bool is_mirrored =m_model_object_in_world_tran.is_left_handed();
|
|
for (int i = 0; i < m_position_points.size(); ++i) {
|
|
for (auto indice : mesh.its.indices) {
|
|
stl_vertex stl_point0 = mesh.its.vertices[indice[0]];
|
|
stl_vertex stl_point1 = mesh.its.vertices[indice[1]];
|
|
stl_vertex stl_point2 = mesh.its.vertices[indice[2]];
|
|
|
|
Vec3d point0 = Vec3d(stl_point0[0], stl_point0[1], stl_point0[2]);
|
|
Vec3d point1 = Vec3d(stl_point1[0], stl_point1[1], stl_point1[2]);
|
|
Vec3d point2 = Vec3d(stl_point2[0], stl_point2[1], stl_point2[2]);
|
|
|
|
point0 = mi->get_transformation().get_matrix() * point0;
|
|
point1 = mi->get_transformation().get_matrix() * point1;
|
|
point2 = mi->get_transformation().get_matrix() * point2;
|
|
|
|
double abs_area = point_in_triangle_delete_area(m_position_points[i], point0, point1, point2);
|
|
if (mesh_values[i] > abs_area) {
|
|
mesh_values[i] = abs_area;
|
|
|
|
Vec3d s1 = point1 - point0;
|
|
Vec3d s2 = point2 - point0;
|
|
m_normal_points[i] = s1.cross(s2);
|
|
m_normal_points[i].normalize();
|
|
if(is_mirrored){
|
|
m_normal_points[i] = -m_normal_points[i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
TriangleMesh GLGizmoText::get_text_mesh(const char* text_str, const Vec3d &position, const Vec3d &normal, const Vec3d& text_up_dir)
|
|
{
|
|
TextResult text_result;
|
|
load_text_shape(text_str, m_font_name.c_str(), m_font_size, m_thickness + m_embeded_depth, m_bold, m_italic, text_result);
|
|
TriangleMesh mesh = text_result.text_mesh;
|
|
|
|
|
|
mesh.translate(-text_result.text_width / 2, -m_font_size / 4, 0);
|
|
|
|
double phi;
|
|
Vec3d rotation_axis;
|
|
Matrix3d rotation_matrix;
|
|
Geometry::rotation_from_two_vectors(Vec3d::UnitZ(), normal, rotation_axis, phi, &rotation_matrix);
|
|
mesh.rotate(phi, rotation_axis);
|
|
|
|
auto project_on_plane = [](const Vec3d& dir, const Vec3d& plane_normal) -> Vec3d {
|
|
return dir - (plane_normal.dot(dir) * plane_normal.dot(plane_normal)) * plane_normal;
|
|
};
|
|
|
|
Vec3d old_text_dir = Vec3d::UnitY();
|
|
old_text_dir = rotation_matrix * old_text_dir;
|
|
Vec3d new_text_dir = project_on_plane(text_up_dir, normal);
|
|
new_text_dir.normalize();
|
|
Geometry::rotation_from_two_vectors(old_text_dir, new_text_dir, rotation_axis, phi, &rotation_matrix);
|
|
|
|
if (abs(phi - PI) < EPSILON)
|
|
rotation_axis = normal;
|
|
|
|
mesh.rotate(phi, rotation_axis);
|
|
|
|
|
|
Vec3d offset = position - m_embeded_depth * normal;
|
|
mesh.translate(offset.x(), offset.y(), offset.z());
|
|
|
|
return mesh;//mesh in object cs
|
|
}
|
|
|
|
bool GLGizmoText::update_raycast_cache(const Vec2d &mouse_position, const Camera &camera, const std::vector<Transform3d> &trafo_matrices)
|
|
{
|
|
if (m_rr.mouse_position == mouse_position) {
|
|
return false;
|
|
}
|
|
|
|
if (m_is_modify)
|
|
return false;
|
|
|
|
Vec3f normal = Vec3f::Zero();
|
|
Vec3f hit = Vec3f::Zero();
|
|
size_t facet = 0;
|
|
Vec3f closest_hit = Vec3f::Zero();
|
|
Vec3f closest_nromal = Vec3f::Zero();
|
|
double closest_hit_squared_distance = std::numeric_limits<double>::max();
|
|
int closest_hit_mesh_id = -1;
|
|
|
|
// Cast a ray on all meshes, pick the closest hit and save it for the respective mesh
|
|
for (int mesh_id = 0; mesh_id < int(trafo_matrices.size()); ++mesh_id) {
|
|
if (m_preview_text_volume_id != -1 && mesh_id == int(trafo_matrices.size()) - 1)
|
|
continue;
|
|
|
|
if (m_c->raycaster()->raycasters()[mesh_id]->unproject_on_mesh(mouse_position, trafo_matrices[mesh_id], camera, hit, normal, m_c->object_clipper()->get_clipping_plane(),
|
|
&facet)) {
|
|
// In case this hit is clipped, skip it.
|
|
if (is_mesh_point_clipped(hit.cast<double>(), trafo_matrices[mesh_id]))
|
|
continue;
|
|
|
|
double hit_squared_distance = (camera.get_position() - trafo_matrices[mesh_id] * hit.cast<double>()).squaredNorm();
|
|
if (hit_squared_distance < closest_hit_squared_distance) {
|
|
closest_hit_squared_distance = hit_squared_distance;
|
|
closest_hit_mesh_id = mesh_id;
|
|
closest_hit = hit;
|
|
closest_nromal = normal;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_rr = {mouse_position, closest_hit_mesh_id, closest_hit, closest_nromal};//update_raycast_cache berfor click down
|
|
return true;
|
|
}
|
|
|
|
void GLGizmoText::generate_text_volume(bool is_temp)
|
|
{
|
|
std::string text = std::string(m_text);
|
|
if (text.empty())
|
|
return;
|
|
|
|
std::wstring_convert<std::codecvt_utf8<wchar_t>> str_cnv;
|
|
std::wstring ws = boost::nowide::widen(m_text);
|
|
std::vector<std::string> alphas;
|
|
for (auto w : ws) {
|
|
alphas.push_back(str_cnv.to_bytes(w));
|
|
}
|
|
|
|
update_text_positions(alphas);//update m_model_object_in_world_tran
|
|
|
|
if (m_position_points.size() == 0)
|
|
return;
|
|
auto inv_text_cs_in_object = (m_model_object_in_world_tran.get_matrix() * m_text_tran_in_object.get_matrix()).inverse();
|
|
auto inv_text_cs_in_object_no_offset = (m_model_object_in_world_tran.get_matrix_no_offset() * m_text_tran_in_object.get_matrix_no_offset()).inverse();
|
|
TriangleMesh mesh;
|
|
for (int i = 0; i < alphas.size(); ++i) {
|
|
auto position = inv_text_cs_in_object * m_position_points[i];
|
|
auto normal = inv_text_cs_in_object_no_offset * m_normal_points[i];
|
|
auto cut_plane_dir = inv_text_cs_in_object_no_offset * m_cut_plane_dir_in_world;
|
|
TriangleMesh sub_mesh = get_text_mesh(alphas[i].c_str(), position, normal, cut_plane_dir);
|
|
mesh.merge(sub_mesh);
|
|
}
|
|
if (mesh.empty())
|
|
return;
|
|
auto center = mesh.bounding_box().center();
|
|
if (abs(mesh.bounding_box().size()[2] - (m_embeded_depth + m_thickness)) < 0.01) {
|
|
mesh.translate(Vec3f(-center.x(), -center.y(), 0)); // align horizontal and vertical center
|
|
}
|
|
else {
|
|
mesh.translate(Vec3f(0, -center.y(), 0)); // align vertical center
|
|
}
|
|
|
|
Plater *plater = wxGetApp().plater();
|
|
if (!plater)
|
|
return;
|
|
|
|
TextInfo text_info = get_text_info();
|
|
const Selection &selection = m_parent.get_selection();
|
|
ModelObject * model_object = selection.get_model()->objects[m_object_idx];
|
|
int cur_volume_id;
|
|
if (m_is_modify && m_need_update_text) {
|
|
if (m_object_idx == -1 || m_volume_idx == -1) {
|
|
BOOST_LOG_TRIVIAL(error) << boost::format("Text: selected object_idx = %1%, volume_idx = %2%") % m_object_idx % m_volume_idx;
|
|
return;
|
|
}
|
|
if (!is_temp) {
|
|
plater->take_snapshot("Modify Text");
|
|
}
|
|
text_info.m_font_version = CUR_FONT_VERSION;
|
|
ModelVolume * model_volume = model_object->volumes[m_volume_idx];
|
|
ModelVolume * new_model_volume = model_object->add_volume(std::move(mesh),false);
|
|
if (m_need_fix && // m_reedit_text//m_need_fix
|
|
(m_text_type == TextType::HORIZONAL || (m_text_type > TextType::HORIZONAL && m_use_current_pose))) {
|
|
new_model_volume->set_transformation(m_load_text_tran_in_object.get_matrix());
|
|
}
|
|
else {
|
|
new_model_volume->set_transformation(m_text_tran_in_object.get_matrix());
|
|
}
|
|
new_model_volume->set_text_info(text_info);
|
|
new_model_volume->name = model_volume->name;
|
|
new_model_volume->set_type(model_volume->type());
|
|
new_model_volume->config.apply(model_volume->config);
|
|
std::swap(model_object->volumes[m_volume_idx], model_object->volumes.back());
|
|
model_object->delete_volume(model_object->volumes.size() - 1);
|
|
model_object->invalidate_bounding_box();
|
|
plater->update();
|
|
m_text_volume_tran = new_model_volume->get_matrix();
|
|
} else {
|
|
if (!is_temp && m_need_update_text)
|
|
plater->take_snapshot("Add Text");
|
|
ObjectList *obj_list = wxGetApp().obj_list();
|
|
cur_volume_id = obj_list->add_text_part(mesh, "text_shape", text_info, m_text_tran_in_object.get_matrix(), is_temp);
|
|
m_preview_text_volume_id = is_temp ? cur_volume_id : -1;
|
|
if (cur_volume_id >= 0) {
|
|
m_show_warning_text_create_fail = false;
|
|
ModelVolume *text_model_volume = model_object->volumes[cur_volume_id];
|
|
m_text_volume_tran = text_model_volume->get_matrix();
|
|
}
|
|
else {
|
|
m_show_warning_text_create_fail = true;
|
|
}
|
|
}
|
|
m_need_update_text = false;
|
|
m_show_warning_lost_rotate = false;
|
|
}
|
|
|
|
void GLGizmoText::delete_temp_preview_text_volume()
|
|
{
|
|
const Selection &selection = m_parent.get_selection();
|
|
if (m_preview_text_volume_id > 0) {
|
|
ModelObject *model_object = selection.get_model()->objects[m_object_idx];
|
|
if (m_preview_text_volume_id < model_object->volumes.size()) {
|
|
Plater *plater = wxGetApp().plater();
|
|
if (!plater)
|
|
return;
|
|
|
|
model_object->delete_volume(m_preview_text_volume_id);
|
|
|
|
plater->update();
|
|
}
|
|
m_preview_text_volume_id = -1;
|
|
}
|
|
}
|
|
|
|
TextInfo GLGizmoText::get_text_info()
|
|
{
|
|
TextInfo text_info;
|
|
text_info.m_font_name = m_font_name;
|
|
text_info.m_font_version = m_font_version;
|
|
text_info.m_font_size = m_font_size;
|
|
text_info.m_curr_font_idx = m_curr_font_idx;
|
|
text_info.m_bold = m_bold;
|
|
text_info.m_italic = m_italic;
|
|
text_info.m_thickness = m_thickness;
|
|
text_info.m_text = m_text;
|
|
text_info.m_rr.mesh_id = m_rr.mesh_id;
|
|
text_info.m_embeded_depth = m_embeded_depth;
|
|
text_info.m_rotate_angle = m_rotate_angle;
|
|
text_info.m_text_gap = m_text_gap;
|
|
text_info.m_is_surface_text = m_text_type == TextType::SURFACE || m_text_type == TextType::SURFACE_HORIZONAL;
|
|
text_info.m_keep_horizontal = m_text_type == TextType::HORIZONAL || m_text_type == TextType::SURFACE_HORIZONAL;
|
|
return text_info;
|
|
}
|
|
|
|
void GLGizmoText::load_from_text_info(const TextInfo &text_info)
|
|
{
|
|
m_font_name = text_info.m_font_name;
|
|
m_font_version = text_info.m_font_version;
|
|
m_font_size = text_info.m_font_size;
|
|
// from other user's computer may exist case:font library size is different
|
|
if (text_info.m_curr_font_idx < m_font_names.size()) {
|
|
m_curr_font_idx = text_info.m_curr_font_idx;
|
|
}
|
|
else {
|
|
m_curr_font_idx = 0;
|
|
}
|
|
m_bold = text_info.m_bold;
|
|
m_italic = text_info.m_italic;
|
|
m_thickness = text_info.m_thickness;
|
|
strcpy(m_text, text_info.m_text.c_str());
|
|
m_rr.mesh_id = text_info.m_rr.mesh_id;
|
|
m_embeded_depth = text_info.m_embeded_depth;
|
|
m_rotate_angle = text_info.m_rotate_angle;
|
|
m_text_gap = text_info.m_text_gap;
|
|
check_text_type(text_info.m_is_surface_text, text_info.m_keep_horizontal);
|
|
}
|
|
|
|
} // namespace GUI
|
|
} // namespace Slic3r
|