3D-printing/OrcaSlicer
1
0
Fork 0
mirror of https://github.com/SoftFever/OrcaSlicer.git synced 2025-07-21 05:37:52 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Colors in GLVolume defined as std::array<float, 4>

Browse source
This commit is contained in:
enricoturri1966 2021-07-19 11:11:49 +02:00
parent 21abf8d88e
commit 2848ae9c4d
4 changed files with 88 additions and 106 deletions
Download patch file Download diff file Expand all files Collapse all files

99
src/slic3r/GUI/3DScene.cpp
View file

@ -286,21 +286,21 @@ void GLIndexedVertexArray::render(
glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0)); glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
} }
const float GLVolume::SELECTED_COLOR[4] = { 0.0f, 1.0f, 0.0f, 1.0f }; const std::array<float, 4> GLVolume::SELECTED_COLOR = { 0.0f, 1.0f, 0.0f, 1.0f };
const float GLVolume::HOVER_SELECT_COLOR[4] = { 0.4f, 0.9f, 0.1f, 1.0f }; const std::array<float, 4> GLVolume::HOVER_SELECT_COLOR = { 0.4f, 0.9f, 0.1f, 1.0f };
const float GLVolume::HOVER_DESELECT_COLOR[4] = { 1.0f, 0.75f, 0.75f, 1.0f }; const std::array<float, 4> GLVolume::HOVER_DESELECT_COLOR = { 1.0f, 0.75f, 0.75f, 1.0f };
const float GLVolume::OUTSIDE_COLOR[4] = { 0.0f, 0.38f, 0.8f, 1.0f }; const std::array<float, 4> GLVolume::OUTSIDE_COLOR = { 0.0f, 0.38f, 0.8f, 1.0f };
const float GLVolume::SELECTED_OUTSIDE_COLOR[4] = { 0.19f, 0.58f, 1.0f, 1.0f }; const std::array<float, 4> GLVolume::SELECTED_OUTSIDE_COLOR = { 0.19f, 0.58f, 1.0f, 1.0f };
const float GLVolume::DISABLED_COLOR[4] = { 0.25f, 0.25f, 0.25f, 1.0f }; const std::array<float, 4> GLVolume::DISABLED_COLOR = { 0.25f, 0.25f, 0.25f, 1.0f };
const float GLVolume::MODEL_COLOR[4][4] = { const std::array<float, 4> GLVolume::SLA_SUPPORT_COLOR = { 0.75f, 0.75f, 0.75f, 1.0f };
const std::array<float, 4> GLVolume::SLA_PAD_COLOR = { 0.0f, 0.2f, 0.0f, 1.0f };
const std::array<float, 4> GLVolume::NEUTRAL_COLOR = { 0.9f, 0.9f, 0.9f, 1.0f };
const std::array<std::array<float, 4>, 4> GLVolume::MODEL_COLOR = { {
{ 1.0f, 1.0f, 0.0f, 1.f }, { 1.0f, 1.0f, 0.0f, 1.f },
{ 1.0f, 0.5f, 0.5f, 1.f }, { 1.0f, 0.5f, 0.5f, 1.f },
{ 0.5f, 1.0f, 0.5f, 1.f }, { 0.5f, 1.0f, 0.5f, 1.f },
{ 0.5f, 0.5f, 1.0f, 1.f } { 0.5f, 0.5f, 1.0f, 1.f }
}; } };
const float GLVolume::SLA_SUPPORT_COLOR[4] = { 0.75f, 0.75f, 0.75f, 1.0f };
const float GLVolume::SLA_PAD_COLOR[4] = { 0.0f, 0.2f, 0.0f, 1.0f };
const float GLVolume::NEUTRAL_COLOR[4] = { 0.9f, 0.9f, 0.9f, 1.0f };
GLVolume::GLVolume(float r, float g, float b, float a) GLVolume::GLVolume(float r, float g, float b, float a)
: m_transformed_bounding_box_dirty(true) : m_transformed_bounding_box_dirty(true)
@ -326,24 +326,18 @@ GLVolume::GLVolume(float r, float g, float b, float a)
, tverts_range(0, size_t(-1)) , tverts_range(0, size_t(-1))
, qverts_range(0, size_t(-1)) , qverts_range(0, size_t(-1))
{ {
color[0] = r; color = { r, g, b, a };
color[1] = g; set_render_color(color);
color[2] = b;
color[3] = a;
set_render_color(r, g, b, a);
} }
void GLVolume::set_render_color(float r, float g, float b, float a) void GLVolume::set_render_color(float r, float g, float b, float a)
{ {
render_color[0] = r; render_color = { r, g, b, a };
render_color[1] = g;
render_color[2] = b;
render_color[3] = a;
} }
void GLVolume::set_render_color(const float* rgba, unsigned int size) void GLVolume::set_render_color(const std::array<float, 4>& rgba)
{ {
::memcpy((void*)render_color, (const void*)rgba, (size_t)(std::min((unsigned int)4, size) * sizeof(float))); render_color = rgba;
} }
void GLVolume::set_render_color() void GLVolume::set_render_color()
@ -358,35 +352,35 @@ void GLVolume::set_render_color()
#else #else
if (is_outside && shader_outside_printer_detection_enabled) if (is_outside && shader_outside_printer_detection_enabled)
#endif // ENABLE_ALLOW_NEGATIVE_Z #endif // ENABLE_ALLOW_NEGATIVE_Z
set_render_color(OUTSIDE_COLOR, 4); set_render_color(OUTSIDE_COLOR);
else { else {
if (force_native_color) if (force_native_color)
set_render_color(color, 4); set_render_color(color);
else else
set_render_color(NEUTRAL_COLOR, 4); set_render_color(NEUTRAL_COLOR);
} }
} }
else { else {
if (hover == HS_Select) if (hover == HS_Select)
set_render_color(HOVER_SELECT_COLOR, 4); set_render_color(HOVER_SELECT_COLOR);
else if (hover == HS_Deselect) else if (hover == HS_Deselect)
set_render_color(HOVER_DESELECT_COLOR, 4); set_render_color(HOVER_DESELECT_COLOR);
else if (selected) else if (selected)
#if ENABLE_ALLOW_NEGATIVE_Z #if ENABLE_ALLOW_NEGATIVE_Z
set_render_color(outside ? SELECTED_OUTSIDE_COLOR : SELECTED_COLOR, 4); set_render_color(outside ? SELECTED_OUTSIDE_COLOR : SELECTED_COLOR);
#else #else
set_render_color(is_outside ? SELECTED_OUTSIDE_COLOR : SELECTED_COLOR, 4); set_render_color(is_outside ? SELECTED_OUTSIDE_COLOR : SELECTED_COLOR);
#endif // ENABLE_ALLOW_NEGATIVE_Z #endif // ENABLE_ALLOW_NEGATIVE_Z
else if (disabled) else if (disabled)
set_render_color(DISABLED_COLOR, 4); set_render_color(DISABLED_COLOR);
#if ENABLE_ALLOW_NEGATIVE_Z #if ENABLE_ALLOW_NEGATIVE_Z
else if (outside && shader_outside_printer_detection_enabled) else if (outside && shader_outside_printer_detection_enabled)
#else #else
else if (is_outside && shader_outside_printer_detection_enabled) else if (is_outside && shader_outside_printer_detection_enabled)
#endif // ENABLE_ALLOW_NEGATIVE_Z #endif // ENABLE_ALLOW_NEGATIVE_Z
set_render_color(OUTSIDE_COLOR, 4); set_render_color(OUTSIDE_COLOR);
else else
set_render_color(color, 4); set_render_color(color);
} }
if (!printable) { if (!printable) {
@ -399,29 +393,29 @@ void GLVolume::set_render_color()
render_color[3] = color[3]; render_color[3] = color[3];
} }
void GLVolume::set_color_from_model_volume(const ModelVolume *model_volume) void GLVolume::set_color_from_model_volume(const ModelVolume& model_volume)
{ {
if (model_volume->is_negative_volume()) { if (model_volume.is_negative_volume()) {
color[0] = 0.2f; color[0] = 0.2f;
color[1] = 0.2f; color[1] = 0.2f;
color[2] = 0.2f; color[2] = 0.2f;
} }
else if (model_volume->is_modifier()) { else if (model_volume.is_modifier()) {
color[0] = 0.2f; color[0] = 0.2f;
color[1] = 1.0f; color[1] = 1.0f;
color[2] = 0.2f; color[2] = 0.2f;
} }
else if (model_volume->is_support_blocker()) { else if (model_volume.is_support_blocker()) {
color[0] = 1.0f; color[0] = 1.0f;
color[1] = 0.2f; color[1] = 0.2f;
color[2] = 0.2f; color[2] = 0.2f;
} }
else if (model_volume->is_support_enforcer()) { else if (model_volume.is_support_enforcer()) {
color[0] = 0.2f; color[0] = 0.2f;
color[1] = 0.2f; color[1] = 0.2f;
color[2] = 1.0f; color[2] = 1.0f;
} }
color[3] = model_volume->is_model_part() ? 1.f : 0.5f; color[3] = model_volume.is_model_part() ? 1.f : 0.5f;
} }
Transform3d GLVolume::world_matrix() const Transform3d GLVolume::world_matrix() const
@ -571,22 +565,11 @@ int GLVolumeCollection::load_object_volume(
const int extruder_id = model_volume->extruder_id(); const int extruder_id = model_volume->extruder_id();
const ModelInstance *instance = model_object->instances[instance_idx]; const ModelInstance *instance = model_object->instances[instance_idx];
const TriangleMesh &mesh = model_volume->mesh(); const TriangleMesh &mesh = model_volume->mesh();
float color[4]; std::array<float, 4> color = GLVolume::MODEL_COLOR[((color_by == "volume") ? volume_idx : obj_idx) % 4];
memcpy(color, GLVolume::MODEL_COLOR[((color_by == "volume") ? volume_idx : obj_idx) % 4], sizeof(float) * 3);
/* if (model_volume->is_support_blocker()) {
color[0] = 1.0f;
color[1] = 0.2f;
color[2] = 0.2f;
} else if (model_volume->is_support_enforcer()) {
color[0] = 0.2f;
color[1] = 0.2f;
color[2] = 1.0f;
}
color[3] = model_volume->is_model_part() ? 1.f : 0.5f; */
color[3] = model_volume->is_model_part() ? 1.f : 0.5f; color[3] = model_volume->is_model_part() ? 1.f : 0.5f;
this->volumes.emplace_back(new GLVolume(color)); this->volumes.emplace_back(new GLVolume(color));
GLVolume& v = *this->volumes.back(); GLVolume& v = *this->volumes.back();
v.set_color_from_model_volume(model_volume); v.set_color_from_model_volume(*model_volume);
#if ENABLE_SMOOTH_NORMALS #if ENABLE_SMOOTH_NORMALS
v.indexed_vertex_array.load_mesh(mesh, true); v.indexed_vertex_array.load_mesh(mesh, true);
#else #else
@ -664,7 +647,7 @@ int GLVolumeCollection::load_wipe_tower_preview(
height = 0.1f; height = 0.1f;
TriangleMesh mesh; TriangleMesh mesh;
float color[4] = { 0.5f, 0.5f, 0.0f, 1.f }; std::array<float, 4> color = { 0.5f, 0.5f, 0.0f, 1.0f };
// In case we don't know precise dimensions of the wipe tower yet, we'll draw // In case we don't know precise dimensions of the wipe tower yet, we'll draw
// the box with different color with one side jagged: // the box with different color with one side jagged:
@ -712,8 +695,8 @@ int GLVolumeCollection::load_wipe_tower_preview(
brim_mesh.translate(-brim_width, -brim_width, 0.f); brim_mesh.translate(-brim_width, -brim_width, 0.f);
mesh.merge(brim_mesh); mesh.merge(brim_mesh);
this->volumes.emplace_back(new GLVolume(color)); volumes.emplace_back(new GLVolume(color));
GLVolume& v = *this->volumes.back(); GLVolume& v = *volumes.back();
v.indexed_vertex_array.load_mesh(mesh); v.indexed_vertex_array.load_mesh(mesh);
v.indexed_vertex_array.finalize_geometry(opengl_initialized); v.indexed_vertex_array.finalize_geometry(opengl_initialized);
v.set_volume_offset(Vec3d(pos_x, pos_y, 0.0)); v.set_volume_offset(Vec3d(pos_x, pos_y, 0.0));
@ -723,17 +706,17 @@ int GLVolumeCollection::load_wipe_tower_preview(
v.geometry_id.second = wipe_tower_instance_id().id; v.geometry_id.second = wipe_tower_instance_id().id;
v.is_wipe_tower = true; v.is_wipe_tower = true;
v.shader_outside_printer_detection_enabled = !size_unknown; v.shader_outside_printer_detection_enabled = !size_unknown;
return int(this->volumes.size() - 1); return int(volumes.size() - 1);
} }
GLVolume* GLVolumeCollection::new_toolpath_volume(const float *rgba, size_t reserve_vbo_floats) GLVolume* GLVolumeCollection::new_toolpath_volume(const std::array<float, 4>& rgba, size_t reserve_vbo_floats)
{ {
GLVolume *out = new_nontoolpath_volume(rgba, reserve_vbo_floats); GLVolume *out = new_nontoolpath_volume(rgba, reserve_vbo_floats);
out->is_extrusion_path = true; out->is_extrusion_path = true;
return out; return out;
} }
GLVolume* GLVolumeCollection::new_nontoolpath_volume(const float *rgba, size_t reserve_vbo_floats) GLVolume* GLVolumeCollection::new_nontoolpath_volume(const std::array<float, 4>& rgba, size_t reserve_vbo_floats)
{ {
GLVolume *out = new GLVolume(rgba); GLVolume *out = new GLVolume(rgba);
out->is_extrusion_path = false; out->is_extrusion_path = false;
@ -812,7 +795,7 @@ void GLVolumeCollection::render(GLVolumeCollection::ERenderType type, bool disab
GLVolumeWithIdAndZList to_render = volumes_to_render(this->volumes, type, view_matrix, filter_func); GLVolumeWithIdAndZList to_render = volumes_to_render(this->volumes, type, view_matrix, filter_func);
for (GLVolumeWithIdAndZ& volume : to_render) { for (GLVolumeWithIdAndZ& volume : to_render) {
volume.first->set_render_color(); volume.first->set_render_color();
shader->set_uniform("uniform_color", volume.first->render_color, 4); shader->set_uniform("uniform_color", volume.first->render_color);
shader->set_uniform("print_box.actived", volume.first->shader_outside_printer_detection_enabled); shader->set_uniform("print_box.actived", volume.first->shader_outside_printer_detection_enabled);
shader->set_uniform("print_box.volume_world_matrix", volume.first->world_matrix()); shader->set_uniform("print_box.volume_world_matrix", volume.first->world_matrix());
shader->set_uniform("slope.actived", m_slope.active && !volume.first->is_modifier && !volume.first->is_wipe_tower); shader->set_uniform("slope.actived", m_slope.active && !volume.first->is_modifier && !volume.first->is_wipe_tower);

35
src/slic3r/GUI/3DScene.hpp
View file

@ -236,16 +236,16 @@ private:
class GLVolume { class GLVolume {
public: public:
static const float SELECTED_COLOR[4]; static const std::array<float, 4> SELECTED_COLOR;
static const float HOVER_SELECT_COLOR[4]; static const std::array<float, 4> HOVER_SELECT_COLOR;
static const float HOVER_DESELECT_COLOR[4]; static const std::array<float, 4> HOVER_DESELECT_COLOR;
static const float OUTSIDE_COLOR[4]; static const std::array<float, 4> OUTSIDE_COLOR;
static const float SELECTED_OUTSIDE_COLOR[4]; static const std::array<float, 4> SELECTED_OUTSIDE_COLOR;
static const float DISABLED_COLOR[4]; static const std::array<float, 4> DISABLED_COLOR;
static const float MODEL_COLOR[4][4]; static const std::array<float, 4> SLA_SUPPORT_COLOR;
static const float SLA_SUPPORT_COLOR[4]; static const std::array<float, 4> SLA_PAD_COLOR;
static const float SLA_PAD_COLOR[4]; static const std::array<float, 4> NEUTRAL_COLOR;
static const float NEUTRAL_COLOR[4]; static const std::array<std::array<float, 4>, 4> MODEL_COLOR;
enum EHoverState : unsigned char enum EHoverState : unsigned char
{ {
@ -255,7 +255,7 @@ public:
}; };
GLVolume(float r = 1.f, float g = 1.f, float b = 1.f, float a = 1.f); GLVolume(float r = 1.f, float g = 1.f, float b = 1.f, float a = 1.f);
GLVolume(const float *rgba) : GLVolume(rgba[0], rgba[1], rgba[2], rgba[3]) {} GLVolume(const std::array<float, 4>& rgba) : GLVolume(rgba[0], rgba[1], rgba[2], rgba[3]) {}
private: private:
Geometry::Transformation m_instance_transformation; Geometry::Transformation m_instance_transformation;
@ -276,9 +276,10 @@ private:
public: public:
// Color of the triangles / quads held by this volume. // Color of the triangles / quads held by this volume.
float color[4]; std::array<float, 4> color;
// Color used to render this volume. // Color used to render this volume.
float render_color[4]; std::array<float, 4> render_color;
struct CompositeID { struct CompositeID {
CompositeID(int object_id, int volume_id, int instance_id) : object_id(object_id), volume_id(volume_id), instance_id(instance_id) {} CompositeID(int object_id, int volume_id, int instance_id) : object_id(object_id), volume_id(volume_id), instance_id(instance_id) {}
CompositeID() : object_id(-1), volume_id(-1), instance_id(-1) {} CompositeID() : object_id(-1), volume_id(-1), instance_id(-1) {}
@ -362,11 +363,11 @@ public:
} }
void set_render_color(float r, float g, float b, float a); void set_render_color(float r, float g, float b, float a);
void set_render_color(const float* rgba, unsigned int size); void set_render_color(const std::array<float, 4>& rgba);
// Sets render color in dependence of current state // Sets render color in dependence of current state
void set_render_color(); void set_render_color();
// set color according to model volume // set color according to model volume
void set_color_from_model_volume(const ModelVolume *model_volume); void set_color_from_model_volume(const ModelVolume& model_volume);
const Geometry::Transformation& get_instance_transformation() const { return m_instance_transformation; } const Geometry::Transformation& get_instance_transformation() const { return m_instance_transformation; }
void set_instance_transformation(const Geometry::Transformation& transformation) { m_instance_transformation = transformation; set_bounding_boxes_as_dirty(); } void set_instance_transformation(const Geometry::Transformation& transformation) { m_instance_transformation = transformation; set_bounding_boxes_as_dirty(); }
@ -542,8 +543,8 @@ public:
int load_wipe_tower_preview( int load_wipe_tower_preview(
int obj_idx, float pos_x, float pos_y, float width, float depth, float height, float rotation_angle, bool size_unknown, float brim_width, bool opengl_initialized); int obj_idx, float pos_x, float pos_y, float width, float depth, float height, float rotation_angle, bool size_unknown, float brim_width, bool opengl_initialized);
GLVolume* new_toolpath_volume(const float *rgba, size_t reserve_vbo_floats = 0); GLVolume* new_toolpath_volume(const std::array<float, 4>& rgba, size_t reserve_vbo_floats = 0);
GLVolume* new_nontoolpath_volume(const float *rgba, size_t reserve_vbo_floats = 0); GLVolume* new_nontoolpath_volume(const std::array<float, 4>& rgba, size_t reserve_vbo_floats = 0);
// Render the volumes by OpenGL. // Render the volumes by OpenGL.
void render(ERenderType type, bool disable_cullface, const Transform3d& view_matrix, std::function<bool(const GLVolume&)> filter_func = std::function<bool(const GLVolume&)>()) const; void render(ERenderType type, bool disable_cullface, const Transform3d& view_matrix, std::function<bool(const GLVolume&)> filter_func = std::function<bool(const GLVolume&)>()) const;

58
src/slic3r/GUI/GLCanvas3D.cpp
View file

@ -1881,7 +1881,7 @@ void GLCanvas3D::reload_scene(bool refresh_immediately, bool force_full_scene_re
volume->extruder_id = extruder_id; volume->extruder_id = extruder_id;
volume->is_modifier = !mvs->model_volume->is_model_part(); volume->is_modifier = !mvs->model_volume->is_model_part();
volume->set_color_from_model_volume(mvs->model_volume); volume->set_color_from_model_volume(*mvs->model_volume);
// updates volumes transformations // updates volumes transformations
volume->set_instance_transformation(mvs->model_volume->get_object()->instances[mvs->composite_id.instance_id]->get_transformation()); volume->set_instance_transformation(mvs->model_volume->get_object()->instances[mvs->composite_id.instance_id]->get_transformation());
@ -5710,7 +5710,7 @@ void GLCanvas3D::_load_print_toolpaths()
if (!print->has_skirt() && !print->has_brim()) if (!print->has_skirt() && !print->has_brim())
return; return;
const float color[] = { 0.5f, 1.0f, 0.5f, 1.0f }; // greenish const std::array<float, 4> color = { 0.5f, 1.0f, 0.5f, 1.0f }; // greenish
// number of skirt layers // number of skirt layers
size_t total_layer_count = 0; size_t total_layer_count = 0;
@ -5756,7 +5756,7 @@ void GLCanvas3D::_load_print_toolpaths()
void GLCanvas3D::_load_print_object_toolpaths(const PrintObject& print_object, const std::vector<std::string>& str_tool_colors, const std::vector<CustomGCode::Item>& color_print_values) void GLCanvas3D::_load_print_object_toolpaths(const PrintObject& print_object, const std::vector<std::string>& str_tool_colors, const std::vector<CustomGCode::Item>& color_print_values)
{ {
std::vector<float> tool_colors = _parse_colors(str_tool_colors); std::vector<std::array<float, 4>> tool_colors = _parse_colors(str_tool_colors);
struct Ctxt struct Ctxt
{ {
@ -5765,20 +5765,20 @@ void GLCanvas3D::_load_print_object_toolpaths(const PrintObject& print_object, c
bool has_perimeters; bool has_perimeters;
bool has_infill; bool has_infill;
bool has_support; bool has_support;
const std::vector<float>* tool_colors; const std::vector<std::array<float, 4>>* tool_colors;
bool is_single_material_print; bool is_single_material_print;
int extruders_cnt; int extruders_cnt;
const std::vector<CustomGCode::Item>* color_print_values; const std::vector<CustomGCode::Item>* color_print_values;
static const float* color_perimeters() { static float color[4] = { 1.0f, 1.0f, 0.0f, 1.f }; return color; } // yellow static const std::array<float, 4>& color_perimeters() { static std::array<float, 4> color = { 1.0f, 1.0f, 0.0f, 1.f }; return color; } // yellow
static const float* color_infill() { static float color[4] = { 1.0f, 0.5f, 0.5f, 1.f }; return color; } // redish static const std::array<float, 4>& color_infill() { static std::array<float, 4> color = { 1.0f, 0.5f, 0.5f, 1.f }; return color; } // redish
static const float* color_support() { static float color[4] = { 0.5f, 1.0f, 0.5f, 1.f }; return color; } // greenish static const std::array<float, 4>& color_support() { static std::array<float, 4> color = { 0.5f, 1.0f, 0.5f, 1.f }; return color; } // greenish
static const float* color_pause_or_custom_code() { static float color[4] = { 0.5f, 0.5f, 0.5f, 1.f }; return color; } // gray static const std::array<float, 4>& color_pause_or_custom_code() { static std::array<float, 4> color = { 0.5f, 0.5f, 0.5f, 1.f }; return color; } // gray
// For cloring by a tool, return a parsed color. // For cloring by a tool, return a parsed color.
bool color_by_tool() const { return tool_colors != nullptr; } bool color_by_tool() const { return tool_colors != nullptr; }
size_t number_tools() const { return this->color_by_tool() ? tool_colors->size() / 4 : 0; } size_t number_tools() const { return color_by_tool() ? tool_colors->size() : 0; }
const float* color_tool(size_t tool) const { return tool_colors->data() + tool * 4; } const std::array<float, 4>& color_tool(size_t tool) const { return (*tool_colors)[tool]; }
// For coloring by a color_print(M600), return a parsed color. // For coloring by a color_print(M600), return a parsed color.
bool color_by_color_print() const { return color_print_values!=nullptr; } bool color_by_color_print() const { return color_print_values!=nullptr; }
@ -5918,8 +5918,8 @@ void GLCanvas3D::_load_print_object_toolpaths(const PrintObject& print_object, c
//FIXME Improve the heuristics for a grain size. //FIXME Improve the heuristics for a grain size.
size_t grain_size = std::max(ctxt.layers.size() / 16, size_t(1)); size_t grain_size = std::max(ctxt.layers.size() / 16, size_t(1));
tbb::spin_mutex new_volume_mutex; tbb::spin_mutex new_volume_mutex;
auto new_volume = [this, &new_volume_mutex](const float *color) -> GLVolume* { auto new_volume = [this, &new_volume_mutex](const std::array<float, 4>& color) {
// Allocate the volume before locking. // Allocate the volume before locking.
GLVolume *volume = new GLVolume(color); GLVolume *volume = new GLVolume(color);
volume->is_extrusion_path = true; volume->is_extrusion_path = true;
tbb::spin_mutex::scoped_lock lock; tbb::spin_mutex::scoped_lock lock;
@ -6056,23 +6056,22 @@ void GLCanvas3D::_load_wipe_tower_toolpaths(const std::vector<std::string>& str_
if (!print->is_step_done(psWipeTower)) if (!print->is_step_done(psWipeTower))
return; return;
std::vector<float> tool_colors = _parse_colors(str_tool_colors); std::vector<std::array<float, 4>> tool_colors = _parse_colors(str_tool_colors);
struct Ctxt struct Ctxt
{ {
const Print *print; const Print *print;
const std::vector<float> *tool_colors; const std::vector<std::array<float, 4>>* tool_colors;
Vec2f wipe_tower_pos; Vec2f wipe_tower_pos;
float wipe_tower_angle; float wipe_tower_angle;
static const float* color_support() { static float color[4] = { 0.5f, 1.0f, 0.5f, 1.f }; return color; } // greenish static const std::array<float, 4>& color_support() { static std::array<float, 4> color = { 0.5f, 1.0f, 0.5f, 1.f }; return color; } // greenish
// For cloring by a tool, return a parsed color. // For cloring by a tool, return a parsed color.
bool color_by_tool() const { return tool_colors != nullptr; } bool color_by_tool() const { return tool_colors != nullptr; }
size_t number_tools() const { return this->color_by_tool() ? tool_colors->size() / 4 : 0; } size_t number_tools() const { return this->color_by_tool() ? tool_colors->size() : 0; }
const float* color_tool(size_t tool) const { return tool_colors->data() + tool * 4; } const std::array<float, 4>& color_tool(size_t tool) const { return (*tool_colors)[tool]; }
int volume_idx(int tool, int feature) const int volume_idx(int tool, int feature) const {
{
return this->color_by_tool() ? std::min<int>(this->number_tools() - 1, std::max<int>(tool, 0)) : feature; return this->color_by_tool() ? std::min<int>(this->number_tools() - 1, std::max<int>(tool, 0)) : feature;
} }
@ -6103,7 +6102,7 @@ void GLCanvas3D::_load_wipe_tower_toolpaths(const std::vector<std::string>& str_
size_t n_items = print->wipe_tower_data().tool_changes.size() + (ctxt.priming.empty() ? 0 : 1); size_t n_items = print->wipe_tower_data().tool_changes.size() + (ctxt.priming.empty() ? 0 : 1);
size_t grain_size = std::max(n_items / 128, size_t(1)); size_t grain_size = std::max(n_items / 128, size_t(1));
tbb::spin_mutex new_volume_mutex; tbb::spin_mutex new_volume_mutex;
auto new_volume = [this, &new_volume_mutex](const float *color) -> GLVolume* { auto new_volume = [this, &new_volume_mutex](const std::array<float, 4>& color) {
auto *volume = new GLVolume(color); auto *volume = new GLVolume(color);
volume->is_extrusion_path = true; volume->is_extrusion_path = true;
tbb::spin_mutex::scoped_lock lock; tbb::spin_mutex::scoped_lock lock;
@ -6219,7 +6218,7 @@ void GLCanvas3D::_load_sla_shells()
return; return;
auto add_volume = [this](const SLAPrintObject &object, int volume_id, const SLAPrintObject::Instance& instance, auto add_volume = [this](const SLAPrintObject &object, int volume_id, const SLAPrintObject::Instance& instance,
const TriangleMesh &mesh, const float color[4], bool outside_printer_detection_enabled) { const TriangleMesh& mesh, const std::array<float, 4>& color, bool outside_printer_detection_enabled) {
m_volumes.volumes.emplace_back(new GLVolume(color)); m_volumes.volumes.emplace_back(new GLVolume(color));
GLVolume& v = *m_volumes.volumes.back(); GLVolume& v = *m_volumes.volumes.back();
#if ENABLE_SMOOTH_NORMALS #if ENABLE_SMOOTH_NORMALS
@ -6230,8 +6229,8 @@ void GLCanvas3D::_load_sla_shells()
v.indexed_vertex_array.finalize_geometry(m_initialized); v.indexed_vertex_array.finalize_geometry(m_initialized);
v.shader_outside_printer_detection_enabled = outside_printer_detection_enabled; v.shader_outside_printer_detection_enabled = outside_printer_detection_enabled;
v.composite_id.volume_id = volume_id; v.composite_id.volume_id = volume_id;
v.set_instance_offset(unscale(instance.shift.x(), instance.shift.y(), 0)); v.set_instance_offset(unscale(instance.shift.x(), instance.shift.y(), 0.0));
v.set_instance_rotation(Vec3d(0.0, 0.0, (double)instance.rotation)); v.set_instance_rotation({ 0.0, 0.0, (double)instance.rotation });
v.set_instance_mirror(X, object.is_left_handed() ? -1. : 1.); v.set_instance_mirror(X, object.is_left_handed() ? -1. : 1.);
v.set_convex_hull(mesh.convex_hull_3d()); v.set_convex_hull(mesh.convex_hull_3d());
}; };
@ -6252,9 +6251,8 @@ void GLCanvas3D::_load_sla_shells()
} }
double shift_z = obj->get_current_elevation(); double shift_z = obj->get_current_elevation();
for (unsigned int i = initial_volumes_count; i < m_volumes.volumes.size(); ++ i) { for (unsigned int i = initial_volumes_count; i < m_volumes.volumes.size(); ++ i) {
GLVolume& v = *m_volumes.volumes[i];
// apply shift z // apply shift z
v.set_sla_shift_z(shift_z); m_volumes.volumes[i]->set_sla_shift_z(shift_z);
} }
} }
@ -6265,7 +6263,7 @@ void GLCanvas3D::_update_toolpath_volumes_outside_state()
{ {
BoundingBoxf3 test_volume = (m_config != nullptr) ? print_volume(*m_config) : BoundingBoxf3(); BoundingBoxf3 test_volume = (m_config != nullptr) ? print_volume(*m_config) : BoundingBoxf3();
for (GLVolume* volume : m_volumes.volumes) { for (GLVolume* volume : m_volumes.volumes) {
volume->is_outside = ((test_volume.radius() > 0.0) && volume->is_extrusion_path) ? !test_volume.contains(volume->bounding_box()) : false; volume->is_outside = (test_volume.radius() > 0.0 && volume->is_extrusion_path) ? !test_volume.contains(volume->bounding_box()) : false;
} }
} }
@ -6273,7 +6271,7 @@ void GLCanvas3D::_update_sla_shells_outside_state()
{ {
BoundingBoxf3 test_volume = (m_config != nullptr) ? print_volume(*m_config) : BoundingBoxf3(); BoundingBoxf3 test_volume = (m_config != nullptr) ? print_volume(*m_config) : BoundingBoxf3();
for (GLVolume* volume : m_volumes.volumes) { for (GLVolume* volume : m_volumes.volumes) {
volume->is_outside = ((test_volume.radius() > 0.0) && volume->shader_outside_printer_detection_enabled) ? !test_volume.contains(volume->transformed_convex_hull_bounding_box()) : false; volume->is_outside = (test_volume.radius() > 0.0 && volume->shader_outside_printer_detection_enabled) ? !test_volume.contains(volume->transformed_convex_hull_bounding_box()) : false;
} }
} }
@ -6294,11 +6292,11 @@ void GLCanvas3D::_set_warning_notification_if_needed(EWarning warning)
_set_warning_notification(warning, show); _set_warning_notification(warning, show);
} }
std::vector<float> GLCanvas3D::_parse_colors(const std::vector<std::string>& colors) std::vector<std::array<float, 4>> GLCanvas3D::_parse_colors(const std::vector<std::string>& colors)
{ {
static const float INV_255 = 1.0f / 255.0f; static const float INV_255 = 1.0f / 255.0f;
std::vector<float> output(colors.size() * 4, 1.0f); std::vector<std::array<float, 4>> output(colors.size(), { 1.0f, 1.0f, 1.0f, 1.0f });
for (size_t i = 0; i < colors.size(); ++i) { for (size_t i = 0; i < colors.size(); ++i) {
const std::string& color = colors[i]; const std::string& color = colors[i];
const char* c = color.data() + 1; const char* c = color.data() + 1;
@ -6309,7 +6307,7 @@ std::vector<float> GLCanvas3D::_parse_colors(const std::vector<std::string>& col
if (digit1 == -1 || digit2 == -1) if (digit1 == -1 || digit2 == -1)
break; break;
output[i * 4 + j] = float(digit1 * 16 + digit2) * INV_255; output[i][j] = float(digit1 * 16 + digit2) * INV_255;
} }
} }
} }

2
src/slic3r/GUI/GLCanvas3D.hpp
View file

@ -907,7 +907,7 @@ private:
float get_overlay_window_width() { return LayersEditing::get_overlay_window_width(); } float get_overlay_window_width() { return LayersEditing::get_overlay_window_width(); }
static std::vector<float> _parse_colors(const std::vector<std::string>& colors); static std::vector<std::array<float, 4>> GLCanvas3D::_parse_colors(const std::vector<std::string>& colors);
}; };
} // namespace GUI } // namespace GUI