viewit/OrcaSlicer-KX
5
4
Fork 1
Code Issues 2 Pull Requests Packages Projects Releases 3 Wiki Activity
Files
195b5868ac134232d033342fcda89aed20072820
OrcaSlicer-KX/src/slic3r/GUI/Gizmos/GLGizmoMmuSegmentation.cpp

6826 lines
298 KiB
C++
Raw Blame History

#include "GLGizmoMmuSegmentation.hpp"
#include "slic3r/GUI/GLCanvas3D.hpp"
#include "slic3r/GUI/GUI_App.hpp"
#include "slic3r/GUI/ImGuiWrapper.hpp"
#include "slic3r/GUI/Camera.hpp"
#include "slic3r/GUI/Plater.hpp"
#include "slic3r/GUI/BitmapCache.hpp"
#include "slic3r/GUI/format.hpp"
#include "slic3r/GUI/GUI_ObjectList.hpp"
#include "slic3r/GUI/NotificationManager.hpp"
#include "slic3r/GUI/GUI.hpp"
#include "slic3r/GUI/ObjColorDialog.hpp"
#include "slic3r/GUI/MainFrame.hpp"
#include "slic3r/GUI/Tab.hpp"
#include "libslic3r/PresetBundle.hpp"
#include "libslic3r/Model.hpp"
#include "libslic3r/TextureMapping.hpp"
#include "slic3r/Utils/UndoRedo.hpp"
#include "GLGizmoUtils.hpp"
#include <glad/gl.h>
#include <algorithm>
#include <array>
#include <cmath>
#include <cstdio>
#include <cstdint>
#include <functional>
#include <limits>
#include <optional>
#include <unordered_map>
#include <boost/log/trivial.hpp>
#include <wx/button.h>
#include <wx/dialog.h>
#include <wx/filedlg.h>
#include <wx/image.h>
#include <wx/menu.h>
#include <wx/sizer.h>
#include <wx/statline.h>
#include <wx/stattext.h>
namespace Slic3r::GUI {
static inline void show_notification_extruders_limit_exceeded()
{
wxGetApp()
.plater()
->get_notification_manager()
->push_notification(NotificationType::MmSegmentationExceededExtrudersLimit, NotificationManager::NotificationLevel::PrintInfoNotificationLevel,
GUI::format(_L("Filament count exceeds the maximum number that painting tool supports. Only the "
"first %1% filaments will be available in painting tool."), GLGizmoMmuSegmentation::EXTRUDERS_LIMIT));
}
void GLGizmoMmuSegmentation::on_opening()
{
if (get_extruders_colors().size() > GLGizmoMmuSegmentation::EXTRUDERS_LIMIT)
show_notification_extruders_limit_exceeded();
}
void GLGizmoMmuSegmentation::on_shutdown()
{
m_parent.use_slope(false);
m_parent.toggle_model_objects_visibility(true);
}
std::string GLGizmoMmuSegmentation::on_get_name() const
{
return _u8L("Color Region Painting");
}
bool GLGizmoMmuSegmentation::on_is_selectable() const
{
return (wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptFFF
&& /*wxGetApp().get_mode() != comSimple && */wxGetApp().filaments_cnt() > 1);
}
bool GLGizmoMmuSegmentation::on_is_activable() const
{
const Selection& selection = m_parent.get_selection();
return !selection.is_empty() && (selection.is_single_full_instance() || selection.is_any_volume()) && wxGetApp().filaments_cnt() > 1;
}
//BBS: use the global one in 3DScene.cpp
/*static std::vector<ColorRGBA> get_extruders_colors()
{
unsigned char rgb_color[3] = {};
std::vector<std::string> colors = Slic3r::GUI::wxGetApp().plater()->get_extruder_colors_from_plater_config();
std::vector<ColorRGBA> colors_out(colors.size());
for (const std::string &color : colors) {
Slic3r::GUI::BitmapCache::parse_color(color, rgb_color);
size_t color_idx = &color - &colors.front();
colors_out[color_idx] = {float(rgb_color[0]) / 255.f, float(rgb_color[1]) / 255.f, float(rgb_color[2]) / 255.f, 1.f};
}
return colors_out;
}*/
static std::vector<int> get_extruder_id_for_volumes(const ModelObject &model_object)
{
std::vector<int> extruders_idx;
extruders_idx.reserve(model_object.volumes.size());
for (const ModelVolume *model_volume : model_object.volumes) {
if (!model_volume->is_model_part())
continue;
extruders_idx.emplace_back(model_volume->extruder_id());
}
return extruders_idx;
}
static std::vector<unsigned int> get_display_filament_ids(size_t total_filaments)
{
std::vector<unsigned int> ordered_filament_ids;
if (wxGetApp().plater() != nullptr)
ordered_filament_ids = wxGetApp().plater()->sidebar().get_ui_ordered_filament_ids();
std::vector<unsigned int> sanitized_filament_ids;
sanitized_filament_ids.reserve(total_filaments);
std::vector<bool> used_filament_ids(total_filaments + 1, false);
const size_t physical_count = size_t(std::max(wxGetApp().filaments_cnt(), 0));
auto real_filament_id = [physical_count](unsigned int filament_id) {
if (filament_id >= 1 && filament_id <= physical_count)
return true;
return wxGetApp().preset_bundle != nullptr &&
wxGetApp().preset_bundle->texture_mapping_zones.is_texture_mapping_zone_id(filament_id);
};
for (const unsigned int filament_id : ordered_filament_ids) {
if (filament_id == 0 || filament_id > total_filaments || used_filament_ids[filament_id] || !real_filament_id(filament_id))
continue;
used_filament_ids[filament_id] = true;
sanitized_filament_ids.emplace_back(filament_id);
}
for (unsigned int filament_id = 1; filament_id <= total_filaments; ++filament_id) {
if (!used_filament_ids[filament_id] && real_filament_id(filament_id))
sanitized_filament_ids.emplace_back(filament_id);
}
return sanitized_filament_ids;
}
static unsigned int ensure_texture_mapping_zone()
{
if (wxGetApp().preset_bundle == nullptr || wxGetApp().plater() == nullptr)
return 0;
TextureMappingManager &mgr = wxGetApp().preset_bundle->texture_mapping_zones;
const size_t num_physical = static_cast<size_t>(std::max(wxGetApp().filaments_cnt(), 0));
std::vector<std::string> physical_colors = wxGetApp().plater()->get_extruder_colors_from_plater_config(nullptr, false);
physical_colors.resize(num_physical, "#26A69A");
if (unsigned int existing_id = mgr.find_image_texture_zone_id(num_physical); existing_id != 0) {
if (TextureMappingZone *zone = mgr.zone_from_id(existing_id);
zone == nullptr || !TextureMappingManager::auto_adjust_texture_component_ids(*zone, num_physical, physical_colors)) {
return existing_id;
}
} else if (num_physical < 2) {
return 0;
} else {
mgr.ensure_image_texture_zone(num_physical, physical_colors);
}
const std::string texture_serialized = mgr.serialize_entries();
DynamicPrintConfig *print_cfg = &wxGetApp().preset_bundle->prints.get_edited_preset().config;
if (ConfigOptionString *opt = print_cfg->option<ConfigOptionString>("texture_mapping_definitions"))
opt->value = texture_serialized;
else
print_cfg->set_key_value("texture_mapping_definitions", new ConfigOptionString(texture_serialized));
if (ConfigOptionString *opt = wxGetApp().preset_bundle->project_config.option<ConfigOptionString>("texture_mapping_definitions"))
opt->value = texture_serialized;
else
wxGetApp().preset_bundle->project_config.set_key_value("texture_mapping_definitions", new ConfigOptionString(texture_serialized));
wxGetApp().sidebar().update_texture_mapping_panel(false);
wxGetApp().sidebar().update_dynamic_filament_list();
if (auto *print_tab = wxGetApp().get_tab(Preset::TYPE_PRINT))
print_tab->update_dirty();
if (wxGetApp().mainframe != nullptr)
wxGetApp().mainframe->on_config_changed(print_cfg);
return mgr.find_image_texture_zone_id(num_physical);
}
static bool model_volume_has_imported_image_texture_data(const ModelVolume *volume)
{
return volume != nullptr &&
!volume->imported_texture_rgba.empty() &&
volume->imported_texture_width > 0 &&
volume->imported_texture_height > 0;
}
static bool model_volume_has_bakeable_image_texture_data(const ModelVolume *volume)
{
if (!model_volume_has_imported_image_texture_data(volume))
return false;
const indexed_triangle_set &its = volume->mesh().its;
return !its.vertices.empty() &&
!its.indices.empty() &&
volume->imported_texture_uv_valid.size() == its.indices.size() &&
volume->imported_texture_uvs_per_face.size() >= its.indices.size() * 6 &&
volume->imported_texture_rgba.size() >=
size_t(volume->imported_texture_width) * size_t(volume->imported_texture_height) * 4 &&
std::any_of(volume->imported_texture_uv_valid.begin(), volume->imported_texture_uv_valid.end(), [](uint8_t valid) {
return valid != 0;
});
}
static float wrap_texture_uv_for_vertex_bake(float uv)
{
if (!std::isfinite(uv))
return 0.f;
float wrapped = uv - std::floor(uv);
if (wrapped < 0.f)
wrapped += 1.f;
return wrapped;
}
static ColorRGBA sample_texture_rgba_for_vertex_bake(const std::vector<uint8_t> &rgba,
uint32_t width,
uint32_t height,
const Vec2f &uv)
{
if (width == 0 || height == 0 || rgba.size() < size_t(width) * size_t(height) * 4)
return ColorRGBA(1.f, 1.f, 1.f, 1.f);
const float u = wrap_texture_uv_for_vertex_bake(uv.x());
const float v = wrap_texture_uv_for_vertex_bake(uv.y());
const float x = u * float(width > 1 ? width - 1 : 0);
const float y = v * float(height > 1 ? height - 1 : 0);
const size_t x0 = std::min<size_t>(size_t(std::floor(x)), size_t(width - 1));
const size_t y0 = std::min<size_t>(size_t(std::floor(y)), size_t(height - 1));
const size_t x1 = std::min<size_t>(x0 + 1, size_t(width - 1));
const size_t y1 = std::min<size_t>(y0 + 1, size_t(height - 1));
const float tx = x - float(x0);
const float ty = y - float(y0);
auto sample_channel = [&rgba, width](size_t sx, size_t sy, size_t channel) {
const size_t idx = (sy * size_t(width) + sx) * 4 + channel;
return float(rgba[idx]) / 255.f;
};
auto blend_channel = [&](size_t channel) {
const float c00 = sample_channel(x0, y0, channel);
const float c10 = sample_channel(x1, y0, channel);
const float c01 = sample_channel(x0, y1, channel);
const float c11 = sample_channel(x1, y1, channel);
const float cx0 = c00 + (c10 - c00) * tx;
const float cx1 = c01 + (c11 - c01) * tx;
return std::clamp(cx0 + (cx1 - cx0) * ty, 0.f, 1.f);
};
return ColorRGBA(blend_channel(0), blend_channel(1), blend_channel(2), 1.f);
}
static uint32_t pack_vertex_color_rgba(const ColorRGBA &color)
{
auto to_u8 = [](float value) -> uint32_t {
return uint32_t(std::clamp(value, 0.f, 1.f) * 255.f + 0.5f);
};
const uint32_t r = to_u8(color.r());
const uint32_t g = to_u8(color.g());
const uint32_t b = to_u8(color.b());
const uint32_t a = to_u8(color.a());
return (r << 24) | (g << 16) | (b << 8) | a;
}
static ColorRGBA unpack_vertex_color_rgba_for_conversion(uint32_t packed)
{
return ColorRGBA(float((packed >> 24) & 0xFFu) / 255.f,
float((packed >> 16) & 0xFFu) / 255.f,
float((packed >> 8) & 0xFFu) / 255.f,
float(packed & 0xFFu) / 255.f);
}
static float triangle_max_edge_length(const std::array<Vec3f, 3> &vertices)
{
return std::max({ (vertices[1] - vertices[0]).norm(),
(vertices[2] - vertices[1]).norm(),
(vertices[0] - vertices[2]).norm() });
}
static float mesh_max_axis_span(const indexed_triangle_set &its)
{
if (its.vertices.empty())
return 1.f;
Vec3f min_point = its.vertices.front().cast<float>();
Vec3f max_point = min_point;
for (const stl_vertex &vertex : its.vertices) {
const Vec3f point = vertex.cast<float>();
min_point = min_point.cwiseMin(point);
max_point = max_point.cwiseMax(point);
}
const Vec3f span = max_point - min_point;
return std::max({ span.x(), span.y(), span.z(), 1.f });
}
static int texture_mapping_depth_from_span(float span, float target_span, int max_depth)
{
if (!std::isfinite(span) || !std::isfinite(target_span) || span <= target_span || target_span <= EPSILON)
return 0;
return std::clamp(int(std::ceil(std::log2(span / target_span))), 0, max_depth);
}
static int texture_mapping_depth_for_budget(size_t triangle_count, int requested_max_depth, size_t max_leaf_triangles)
{
int depth = std::clamp(requested_max_depth, 0, 7);
while (depth > 0) {
double leaf_count = double(std::max<size_t>(triangle_count, 1));
for (int idx = 0; idx < depth; ++idx)
leaf_count *= 4.0;
if (leaf_count <= double(max_leaf_triangles))
break;
--depth;
}
return depth;
}
static constexpr float TRUE_COLOR_BRUSH_SUBDIVISION_FRACTION = 1.f / 8.f;
static constexpr float TRUE_COLOR_BRUSH_MIN_SUBDIVISION_EDGE_MM = 0.1f;
static float true_color_brush_subdivision_target(float brush_radius)
{
return std::max(std::max(brush_radius, 0.f) * TRUE_COLOR_BRUSH_SUBDIVISION_FRACTION,
TRUE_COLOR_BRUSH_MIN_SUBDIVISION_EDGE_MM);
}
static void normalize_color_mix_weights(std::vector<float> &weights)
{
float sum = 0.f;
for (float &weight : weights) {
if (!std::isfinite(weight) || weight < 0.f)
weight = 0.f;
sum += weight;
}
if (sum <= EPSILON) {
const float uniform = weights.empty() ? 0.f : 1.f / float(weights.size());
for (float &weight : weights)
weight = uniform;
return;
}
const float inv_sum = 1.f / sum;
for (float &weight : weights)
weight *= inv_sum;
}
static ColorRGBA color_mix_from_weights(const std::vector<ColorRGBA> &colors,
const std::vector<float> &weights,
const ColorRGBA &fallback)
{
if (colors.empty() || weights.empty())
return fallback;
float sum = 0.f;
float r = 0.f;
float g = 0.f;
float b = 0.f;
for (size_t idx = 0; idx < colors.size() && idx < weights.size(); ++idx) {
const float weight = std::max(weights[idx], 0.f);
sum += weight;
r += colors[idx].r() * weight;
g += colors[idx].g() * weight;
b += colors[idx].b() * weight;
}
if (sum <= EPSILON)
return fallback;
const float inv_sum = 1.f / sum;
return ColorRGBA(r * inv_sum, g * inv_sum, b * inv_sum, fallback.a());
}
static float color_mix_error_squared(const std::vector<ColorRGBA> &colors, const std::vector<float> &weights, const ColorRGBA &target)
{
const ColorRGBA mix = color_mix_from_weights(colors, weights, target);
return Slic3r::sqr(mix.r() - target.r()) + Slic3r::sqr(mix.g() - target.g()) + Slic3r::sqr(mix.b() - target.b());
}
static std::vector<float> closest_color_mix_weights(const std::vector<ColorRGBA> &colors, const ColorRGBA &target)
{
std::vector<float> weights(colors.size(), 0.f);
if (colors.empty())
return weights;
auto improve = [&colors, &target](std::vector<float> candidate) {
normalize_color_mix_weights(candidate);
float step = 0.28f;
for (int iter = 0; iter < 140; ++iter) {
const ColorRGBA mix = color_mix_from_weights(colors, candidate, target);
const float err_r = mix.r() - target.r();
const float err_g = mix.g() - target.g();
const float err_b = mix.b() - target.b();
std::vector<float> next = candidate;
for (size_t idx = 0; idx < colors.size(); ++idx) {
const float grad = 2.f * (err_r * colors[idx].r() + err_g * colors[idx].g() + err_b * colors[idx].b());
next[idx] -= step * grad;
}
normalize_color_mix_weights(next);
candidate = std::move(next);
step *= 0.985f;
}
return candidate;
};
std::vector<float> uniform(colors.size(), 1.f / float(colors.size()));
weights = improve(uniform);
float best_error = color_mix_error_squared(colors, weights, target);
for (size_t idx = 0; idx < colors.size(); ++idx) {
std::vector<float> single(colors.size(), 0.f);
single[idx] = 1.f;
single = improve(std::move(single));
const float error = color_mix_error_squared(colors, single, target);
if (error < best_error) {
best_error = error;
weights = std::move(single);
}
}
return weights;
}
static float texture_triangle_uv_pixel_span(const ModelVolume *volume, size_t tri_idx)
{
if (volume == nullptr ||
tri_idx >= volume->imported_texture_uv_valid.size() ||
volume->imported_texture_uv_valid[tri_idx] == 0)
return 0.f;
const size_t uv_offset = tri_idx * 6;
if (uv_offset + 5 >= volume->imported_texture_uvs_per_face.size())
return 0.f;
const Vec2f uv0(volume->imported_texture_uvs_per_face[uv_offset + 0], volume->imported_texture_uvs_per_face[uv_offset + 1]);
const Vec2f uv1(volume->imported_texture_uvs_per_face[uv_offset + 2], volume->imported_texture_uvs_per_face[uv_offset + 3]);
const Vec2f uv2(volume->imported_texture_uvs_per_face[uv_offset + 4], volume->imported_texture_uvs_per_face[uv_offset + 5]);
const float width = float(std::max<uint32_t>(volume->imported_texture_width, 1));
const float height = float(std::max<uint32_t>(volume->imported_texture_height, 1));
auto pixel_edge_length = [width, height](const Vec2f &a, const Vec2f &b) {
const Vec2f delta = b - a;
return std::sqrt(Slic3r::sqr(delta.x() * width) + Slic3r::sqr(delta.y() * height));
};
return std::max({ pixel_edge_length(uv0, uv1),
pixel_edge_length(uv1, uv2),
pixel_edge_length(uv2, uv0) });
}
static bool barycentric_weights_for_region_vertex_colors(const Vec3f &point,
const Vec3f &p0,
const Vec3f &p1,
const Vec3f &p2,
Vec3f &weights)
{
const Vec3f edge_0 = p1 - p0;
const Vec3f edge_1 = p2 - p0;
const Vec3f delta = point - p0;
const float d00 = edge_0.dot(edge_0);
const float d01 = edge_0.dot(edge_1);
const float d11 = edge_1.dot(edge_1);
const float d20 = delta.dot(edge_0);
const float d21 = delta.dot(edge_1);
const float denom = d00 * d11 - d01 * d01;
if (std::abs(denom) <= EPSILON)
return false;
weights.y() = (d11 * d20 - d01 * d21) / denom;
weights.z() = (d00 * d21 - d01 * d20) / denom;
weights.x() = 1.f - weights.y() - weights.z();
return std::isfinite(weights.x()) && std::isfinite(weights.y()) && std::isfinite(weights.z());
}
static std::string rgb_metadata_json(const ColorRGBA &background)
{
const uint32_t packed = pack_vertex_color_rgba(background);
char buffer[48];
std::snprintf(buffer,
sizeof(buffer),
"{\"background_color\":\"#%02X%02X%02X%02X\"}",
unsigned((packed >> 24) & 0xFFu),
unsigned((packed >> 16) & 0xFFu),
unsigned((packed >> 8) & 0xFFu),
unsigned(packed & 0xFFu));
return buffer;
}
static ColorRGBA rgb_metadata_background_color(const ColorFacetsAnnotation &annotation)
{
const std::string &metadata = annotation.metadata_json();
const std::string key = "\"background_color\":\"#";
const size_t start = metadata.find(key);
if (start == std::string::npos || start + key.size() + 8 > metadata.size())
return ColorRGBA(1.f, 1.f, 1.f, 1.f);
uint32_t packed = 0;
for (size_t idx = 0; idx < 8; ++idx) {
const char ch = metadata[start + key.size() + idx];
const int value = ch >= '0' && ch <= '9' ? ch - '0' :
ch >= 'a' && ch <= 'f' ? ch - 'a' + 10 :
ch >= 'A' && ch <= 'F' ? ch - 'A' + 10 : -1;
if (value < 0)
return ColorRGBA(1.f, 1.f, 1.f, 1.f);
packed = (packed << 4) | uint32_t(value);
}
return unpack_vertex_color_rgba_for_conversion(packed);
}
static void refresh_imported_texture_storage(ModelVolume &volume)
{
std::vector<uint8_t> refreshed(volume.imported_texture_rgba.begin(), volume.imported_texture_rgba.end());
volume.imported_texture_rgba.swap(refreshed);
}
static std::optional<ColorRGBA> sample_rgb_color_facets(const std::vector<ColorFacetTriangle> &facets,
const std::unordered_map<int, std::vector<size_t>> &facets_by_source_triangle,
int source_triangle,
const Vec3f &point)
{
auto found = facets_by_source_triangle.find(source_triangle);
if (found == facets_by_source_triangle.end())
return std::nullopt;
const float tolerance = -1e-4f;
for (const size_t facet_idx : found->second) {
if (facet_idx >= facets.size())
continue;
const ColorFacetTriangle &facet = facets[facet_idx];
Vec3f weights = Vec3f::Zero();
if (!barycentric_weights_for_region_vertex_colors(point, facet.vertices[0], facet.vertices[1], facet.vertices[2], weights))
continue;
if (weights.x() >= tolerance && weights.y() >= tolerance && weights.z() >= tolerance)
return unpack_vertex_color_rgba_for_conversion(facet.rgba);
}
if (found->second.empty() || found->second.front() >= facets.size())
return std::nullopt;
return unpack_vertex_color_rgba_for_conversion(facets[found->second.front()].rgba);
}
struct RGBStrokeVertexKey
{
long long x = 0;
long long y = 0;
long long z = 0;
};
struct RGBStrokeEdgeKey
{
RGBStrokeVertexKey a;
RGBStrokeVertexKey b;
};
struct RGBStrokeBoundaryEdge
{
int source_triangle = -1;
Vec3f a = Vec3f::Zero();
Vec3f b = Vec3f::Zero();
};
struct RGBStrokeEdgeData
{
int count = 0;
RGBStrokeBoundaryEdge edge;
};
struct RGBStrokeEdgeKeyHash
{
size_t operator()(const RGBStrokeEdgeKey &key) const
{
size_t hash = 1469598103934665603ull;
auto mix = [&hash](long long value) {
hash ^= std::hash<long long>{}(value) + 0x9e3779b97f4a7c15ull + (hash << 6) + (hash >> 2);
};
mix(key.a.x);
mix(key.a.y);
mix(key.a.z);
mix(key.b.x);
mix(key.b.y);
mix(key.b.z);
return hash;
}
};
static bool operator==(const RGBStrokeVertexKey &lhs, const RGBStrokeVertexKey &rhs)
{
return lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z;
}
static bool operator==(const RGBStrokeEdgeKey &lhs, const RGBStrokeEdgeKey &rhs)
{
return lhs.a == rhs.a && lhs.b == rhs.b;
}
static bool rgb_stroke_vertex_key_less(const RGBStrokeVertexKey &lhs, const RGBStrokeVertexKey &rhs)
{
if (lhs.x != rhs.x)
return lhs.x < rhs.x;
if (lhs.y != rhs.y)
return lhs.y < rhs.y;
return lhs.z < rhs.z;
}
static RGBStrokeVertexKey rgb_stroke_vertex_key(const Vec3f &point)
{
auto key = [](float value) {
return std::isfinite(value) ? static_cast<long long>(std::llround(double(value) * 100000.0)) : 0ll;
};
return { key(point.x()), key(point.y()), key(point.z()) };
}
struct RGBStrokeBoundaryEdges
{
std::unordered_map<int, std::vector<RGBStrokeBoundaryEdge>> by_source_triangle;
std::vector<RGBStrokeBoundaryEdge> all;
};
static RGBStrokeBoundaryEdges build_rgb_stroke_boundary_edges(
const std::vector<TriangleSelector::FacetStateTriangle> &stroke_facets)
{
std::unordered_map<RGBStrokeEdgeKey, RGBStrokeEdgeData, RGBStrokeEdgeKeyHash> edges;
edges.reserve(stroke_facets.size() * 3);
auto add_edge = [&edges](const TriangleSelector::FacetStateTriangle &facet, const Vec3f &a, const Vec3f &b) {
RGBStrokeEdgeKey key { rgb_stroke_vertex_key(a), rgb_stroke_vertex_key(b) };
if (rgb_stroke_vertex_key_less(key.b, key.a))
std::swap(key.a, key.b);
RGBStrokeEdgeData &data = edges[key];
++data.count;
if (data.count == 1)
data.edge = { facet.source_triangle, a, b };
};
for (const TriangleSelector::FacetStateTriangle &facet : stroke_facets) {
add_edge(facet, facet.vertices[0], facet.vertices[1]);
add_edge(facet, facet.vertices[1], facet.vertices[2]);
add_edge(facet, facet.vertices[2], facet.vertices[0]);
}
RGBStrokeBoundaryEdges boundary_edges;
boundary_edges.all.reserve(edges.size());
for (const auto &edge : edges) {
if (edge.second.count != 1)
continue;
boundary_edges.by_source_triangle[edge.second.edge.source_triangle].emplace_back(edge.second.edge);
boundary_edges.all.emplace_back(edge.second.edge);
}
return boundary_edges;
}
static float distance_to_segment(const Vec3f &point, const Vec3f &a, const Vec3f &b)
{
const Vec3f ab = b - a;
const float len2 = ab.squaredNorm();
if (len2 <= EPSILON)
return (point - a).norm();
const float t = std::clamp((point - a).dot(ab) / len2, 0.f, 1.f);
return (point - (a + ab * t)).norm();
}
static float distance_between_segments(const Vec3f &p1, const Vec3f &q1, const Vec3f &p2, const Vec3f &q2)
{
const Vec3f d1 = q1 - p1;
const Vec3f d2 = q2 - p2;
const Vec3f r = p1 - p2;
const float a = d1.dot(d1);
const float e = d2.dot(d2);
const float f = d2.dot(r);
float s = 0.f;
float t = 0.f;
if (a <= EPSILON && e <= EPSILON)
return (p1 - p2).norm();
if (a <= EPSILON) {
t = std::clamp(f / e, 0.f, 1.f);
} else {
const float c = d1.dot(r);
if (e <= EPSILON) {
s = std::clamp(-c / a, 0.f, 1.f);
} else {
const float b = d1.dot(d2);
const float denom = a * e - b * b;
if (denom > EPSILON)
s = std::clamp((b * f - c * e) / denom, 0.f, 1.f);
const float tnom = b * s + f;
if (tnom < 0.f) {
t = 0.f;
s = std::clamp(-c / a, 0.f, 1.f);
} else if (tnom > e) {
t = 1.f;
s = std::clamp((b - c) / a, 0.f, 1.f);
} else {
t = tnom / e;
}
}
}
return (p1 + d1 * s - (p2 + d2 * t)).norm();
}
static Vec3f transform_point(const Transform3d &matrix, const Vec3f &point)
{
return (matrix * point.cast<double>()).cast<float>();
}
static std::array<Vec3f, 3> transform_triangle(const Transform3d &matrix, const std::array<Vec3f, 3> &vertices)
{
return {
transform_point(matrix, vertices[0]),
transform_point(matrix, vertices[1]),
transform_point(matrix, vertices[2])
};
}
static Vec3f closest_point_on_triangle(const Vec3f &point, const Vec3f &a, const Vec3f &b, const Vec3f &c)
{
const Vec3f ab = b - a;
const Vec3f ac = c - a;
const Vec3f ap = point - a;
const float d1 = ab.dot(ap);
const float d2 = ac.dot(ap);
if (d1 <= 0.f && d2 <= 0.f)
return a;
const Vec3f bp = point - b;
const float d3 = ab.dot(bp);
const float d4 = ac.dot(bp);
if (d3 >= 0.f && d4 <= d3)
return b;
const float vc = d1 * d4 - d3 * d2;
if (vc <= 0.f && d1 >= 0.f && d3 <= 0.f)
return a + ab * (d1 / (d1 - d3));
const Vec3f cp = point - c;
const float d5 = ab.dot(cp);
const float d6 = ac.dot(cp);
if (d6 >= 0.f && d5 <= d6)
return c;
const float vb = d5 * d2 - d1 * d6;
if (vb <= 0.f && d2 >= 0.f && d6 <= 0.f)
return a + ac * (d2 / (d2 - d6));
const float va = d3 * d6 - d5 * d4;
if (va <= 0.f && d4 - d3 >= 0.f && d5 - d6 >= 0.f)
return b + (c - b) * ((d4 - d3) / ((d4 - d3) + (d5 - d6)));
const float denom_sum = va + vb + vc;
if (std::abs(denom_sum) <= EPSILON)
return a;
const float denom = 1.f / denom_sum;
const float v = vb * denom;
const float w = vc * denom;
return a + ab * v + ac * w;
}
static float distance_to_triangle(const Vec3f &point, const std::array<Vec3f, 3> &vertices)
{
return (point - closest_point_on_triangle(point, vertices[0], vertices[1], vertices[2])).norm();
}
static bool aabb_overlap(const Vec3f &min_a, const Vec3f &max_a, const Vec3f &min_b, const Vec3f &max_b)
{
return min_a.x() <= max_b.x() && max_a.x() >= min_b.x() &&
min_a.y() <= max_b.y() && max_a.y() >= min_b.y() &&
min_a.z() <= max_b.z() && max_a.z() >= min_b.z();
}
static bool triangle_intersects_brush_segment(const std::array<Vec3f, 3> &vertices, const Vec3f &a, const Vec3f &b, float radius)
{
if (distance_to_triangle(a, vertices) <= radius || distance_to_triangle(b, vertices) <= radius)
return true;
for (const Vec3f &vertex : vertices)
if (distance_to_segment(vertex, a, b) <= radius)
return true;
for (size_t edge_idx = 0; edge_idx < 3; ++edge_idx)
if (distance_between_segments(vertices[edge_idx], vertices[(edge_idx + 1) % 3], a, b) <= radius)
return true;
return false;
}
static float distance_to_brush_path(const std::vector<Vec3f> &stroke_points, const Vec3f &point)
{
if (stroke_points.empty())
return std::numeric_limits<float>::max();
if (stroke_points.size() == 1)
return (point - stroke_points.front()).norm();
float distance = std::numeric_limits<float>::max();
for (size_t idx = 1; idx < stroke_points.size(); ++idx)
distance = std::min(distance, distance_to_segment(point, stroke_points[idx - 1], stroke_points[idx]));
return distance;
}
static float sample_rgb_brush_path_alpha(const std::vector<Vec3f> &stroke_points,
const Vec3f &point,
float hardness,
float opacity,
float brush_radius)
{
opacity = std::clamp(opacity, 0.f, 1.f);
if (opacity <= 0.f || brush_radius <= EPSILON)
return 0.f;
const float distance = distance_to_brush_path(stroke_points, point);
if (!std::isfinite(distance) || distance > brush_radius)
return 0.f;
hardness = std::clamp(hardness, 0.f, 1.f);
const float solid_radius = brush_radius * hardness;
if (distance <= solid_radius)
return opacity;
const float fade_width = brush_radius - solid_radius;
if (fade_width <= EPSILON)
return opacity;
const float t = std::clamp((brush_radius - distance) / fade_width, 0.f, 1.f);
const float soft_alpha = t * t * (3.f - 2.f * t);
return opacity * soft_alpha;
}
static float sample_rgb_stroke_alpha(const std::vector<TriangleSelector::FacetStateTriangle> &stroke_facets,
const std::unordered_map<int, std::vector<size_t>> &stroke_by_source_triangle,
const RGBStrokeBoundaryEdges &stroke_boundary_edges,
int source_triangle,
const Vec3f &point,
float hardness,
float opacity,
float brush_radius)
{
if (opacity <= 0.f)
return 0.f;
auto found = stroke_by_source_triangle.find(source_triangle);
if (found == stroke_by_source_triangle.end())
return 0.f;
const float tolerance = -1e-4f;
bool inside_stroke = false;
for (const size_t facet_idx : found->second) {
if (facet_idx >= stroke_facets.size())
continue;
const TriangleSelector::FacetStateTriangle &facet = stroke_facets[facet_idx];
Vec3f weights = Vec3f::Zero();
if (!barycentric_weights_for_region_vertex_colors(point, facet.vertices[0], facet.vertices[1], facet.vertices[2], weights))
continue;
if (weights.x() < tolerance || weights.y() < tolerance || weights.z() < tolerance)
continue;
inside_stroke = true;
break;
}
if (!inside_stroke)
return 0.f;
hardness = std::clamp(hardness, 0.f, 1.f);
opacity = std::clamp(opacity, 0.f, 1.f);
const float fade_width = brush_radius * (1.f - hardness);
if (fade_width <= EPSILON)
return opacity;
if (stroke_boundary_edges.all.empty())
return opacity;
float boundary_distance = std::numeric_limits<float>::max();
auto boundary_found = stroke_boundary_edges.by_source_triangle.find(source_triangle);
if (boundary_found != stroke_boundary_edges.by_source_triangle.end())
for (const RGBStrokeBoundaryEdge &edge : boundary_found->second)
boundary_distance = std::min(boundary_distance, distance_to_segment(point, edge.a, edge.b));
if (!std::isfinite(boundary_distance) || boundary_distance > fade_width) {
for (const RGBStrokeBoundaryEdge &edge : stroke_boundary_edges.all)
boundary_distance = std::min(boundary_distance, distance_to_segment(point, edge.a, edge.b));
}
if (!std::isfinite(boundary_distance))
return opacity;
const float t = std::clamp(boundary_distance / fade_width, 0.f, 1.f);
const float soft_alpha = t * t * (3.f - 2.f * t);
return opacity * soft_alpha;
}
static std::vector<bool> rgb_brush_candidate_source_triangles(
const ModelVolume &volume,
const std::vector<Vec3f> &stroke_points,
float brush_radius,
const std::unordered_map<int, std::vector<size_t>> &stroke_by_source_triangle,
const Transform3d &world_matrix)
{
const indexed_triangle_set &its = volume.mesh().its;
std::vector<bool> candidates(its.indices.size(), false);
for (const auto &entry : stroke_by_source_triangle)
if (entry.first >= 0 && size_t(entry.first) < candidates.size())
candidates[size_t(entry.first)] = true;
if (stroke_points.empty() || brush_radius <= EPSILON)
return candidates;
std::vector<Vec3f> stroke_points_world;
stroke_points_world.reserve(stroke_points.size());
for (const Vec3f &point : stroke_points)
stroke_points_world.emplace_back(transform_point(world_matrix, point));
Vec3f path_min = stroke_points_world.front();
Vec3f path_max = stroke_points_world.front();
for (const Vec3f &point : stroke_points_world) {
path_min = path_min.cwiseMin(point);
path_max = path_max.cwiseMax(point);
}
path_min -= Vec3f::Constant(brush_radius);
path_max += Vec3f::Constant(brush_radius);
for (size_t tri_idx = 0; tri_idx < its.indices.size(); ++tri_idx) {
if (candidates[tri_idx])
continue;
const stl_triangle_vertex_indices &tri = its.indices[tri_idx];
if (tri[0] < 0 || tri[1] < 0 || tri[2] < 0)
continue;
if (size_t(tri[0]) >= its.vertices.size() ||
size_t(tri[1]) >= its.vertices.size() ||
size_t(tri[2]) >= its.vertices.size())
continue;
const std::array<Vec3f, 3> local_vertices = {
its.vertices[size_t(tri[0])].cast<float>(),
its.vertices[size_t(tri[1])].cast<float>(),
its.vertices[size_t(tri[2])].cast<float>()
};
const std::array<Vec3f, 3> vertices = transform_triangle(world_matrix, local_vertices);
Vec3f tri_min = vertices[0].cwiseMin(vertices[1]).cwiseMin(vertices[2]);
Vec3f tri_max = vertices[0].cwiseMax(vertices[1]).cwiseMax(vertices[2]);
if (!aabb_overlap(tri_min, tri_max, path_min, path_max))
continue;
for (size_t point_idx = 0; point_idx < stroke_points_world.size(); ++point_idx) {
const Vec3f segment_a = stroke_points_world[point_idx];
const Vec3f segment_b = point_idx + 1 < stroke_points_world.size() ?
stroke_points_world[point_idx + 1] :
stroke_points_world[point_idx];
Vec3f segment_min = segment_a.cwiseMin(segment_b) - Vec3f::Constant(brush_radius);
Vec3f segment_max = segment_a.cwiseMax(segment_b) + Vec3f::Constant(brush_radius);
if (aabb_overlap(tri_min, tri_max, segment_min, segment_max) &&
triangle_intersects_brush_segment(vertices, segment_a, segment_b, brush_radius)) {
candidates[tri_idx] = true;
break;
}
}
}
return candidates;
}
static int rgb_leaf_count_depth(size_t leaf_count)
{
int depth = 0;
size_t depth_leaf_count = 1;
while (depth_leaf_count < leaf_count && depth < 7) {
depth_leaf_count *= 4;
++depth;
}
return depth;
}
static std::vector<int> rgb_existing_source_triangle_depths(const std::vector<ColorFacetTriangle> &facets, size_t triangle_count)
{
std::vector<size_t> leaf_counts(triangle_count, 0);
for (const ColorFacetTriangle &facet : facets)
if (facet.source_triangle >= 0 && size_t(facet.source_triangle) < leaf_counts.size())
++leaf_counts[size_t(facet.source_triangle)];
std::vector<int> depths(triangle_count, 0);
for (size_t tri_idx = 0; tri_idx < leaf_counts.size(); ++tri_idx)
depths[tri_idx] = rgb_leaf_count_depth(leaf_counts[tri_idx]);
return depths;
}
static bool apply_rgb_stroke_to_volume(ModelVolume &volume,
const std::vector<TriangleSelector::FacetStateTriangle> &stroke_facets,
const ColorRGBA &brush_color,
float hardness,
float opacity,
float brush_radius,
const std::vector<Vec3f> &brush_stroke_points,
const Transform3d &world_matrix)
{
if (stroke_facets.empty())
return false;
std::vector<ColorFacetTriangle> existing_facets;
volume.texture_mapping_color_facets.get_facet_triangles(volume, existing_facets);
std::unordered_map<int, std::vector<size_t>> existing_by_source_triangle;
existing_by_source_triangle.reserve(existing_facets.size());
for (size_t idx = 0; idx < existing_facets.size(); ++idx)
existing_by_source_triangle[existing_facets[idx].source_triangle].emplace_back(idx);
std::unordered_map<int, std::vector<size_t>> stroke_by_source_triangle;
stroke_by_source_triangle.reserve(stroke_facets.size());
for (size_t idx = 0; idx < stroke_facets.size(); ++idx)
stroke_by_source_triangle[stroke_facets[idx].source_triangle].emplace_back(idx);
RGBStrokeBoundaryEdges stroke_boundary_edges = build_rgb_stroke_boundary_edges(stroke_facets);
const std::vector<bool> brush_candidate_triangles =
rgb_brush_candidate_source_triangles(volume, brush_stroke_points, brush_radius, stroke_by_source_triangle, world_matrix);
const bool use_brush_path = !brush_stroke_points.empty();
std::vector<Vec3f> brush_stroke_points_world;
if (use_brush_path) {
brush_stroke_points_world.reserve(brush_stroke_points.size());
for (const Vec3f &point : brush_stroke_points)
brush_stroke_points_world.emplace_back(transform_point(world_matrix, point));
}
const ColorRGBA background = rgb_metadata_background_color(volume.texture_mapping_color_facets);
const uint32_t brush_packed = pack_vertex_color_rgba(brush_color);
TextureMappingColorSampler sampler = [&existing_facets,
&existing_by_source_triangle,
&stroke_facets,
&stroke_by_source_triangle,
&stroke_boundary_edges,
background,
brush_color,
brush_packed,
hardness,
opacity,
brush_radius,
use_brush_path,
&brush_candidate_triangles,
&brush_stroke_points_world,
&world_matrix](size_t tri_idx, const Vec3f &point, const Vec3f &) {
ColorRGBA source_color = background;
if (std::optional<ColorRGBA> sampled =
sample_rgb_color_facets(existing_facets, existing_by_source_triangle, int(tri_idx), point)) {
source_color = *sampled;
}
if (use_brush_path && (tri_idx >= brush_candidate_triangles.size() || !brush_candidate_triangles[tri_idx]))
return pack_vertex_color_rgba(source_color);
const float alpha = use_brush_path ?
sample_rgb_brush_path_alpha(brush_stroke_points_world,
transform_point(world_matrix, point),
hardness,
opacity,
brush_radius) :
sample_rgb_stroke_alpha(stroke_facets,
stroke_by_source_triangle,
stroke_boundary_edges,
int(tri_idx),
point,
hardness,
opacity,
brush_radius);
if (alpha <= 0.f)
return pack_vertex_color_rgba(source_color);
if (alpha >= 1.f)
return brush_packed;
return pack_vertex_color_rgba(ColorRGBA(source_color.r() * (1.f - alpha) + brush_color.r() * alpha,
source_color.g() * (1.f - alpha) + brush_color.g() * alpha,
source_color.b() * (1.f - alpha) + brush_color.b() * alpha,
source_color.a() * (1.f - alpha) + brush_color.a() * alpha));
};
const float mesh_span = mesh_max_axis_span(volume.mesh().its);
const int safe_max_depth = texture_mapping_depth_for_budget(volume.mesh().its.indices.size(), 7, 1800000);
const float brush_subdivision_target = true_color_brush_subdivision_target(brush_radius);
const std::vector<int> existing_source_triangle_depths =
rgb_existing_source_triangle_depths(existing_facets, volume.mesh().its.indices.size());
TextureMappingColorSubdivisionDepths subdivision_depths =
[mesh_span,
safe_max_depth,
brush_subdivision_target,
&brush_candidate_triangles,
&existing_source_triangle_depths,
&world_matrix](size_t tri_idx, const std::array<Vec3f, 3> &vertices) {
const int base_depth = texture_mapping_depth_from_span(triangle_max_edge_length(vertices),
std::max(mesh_span / 220.f, 0.18f),
std::min(6, safe_max_depth));
const int preserved_depth = tri_idx < existing_source_triangle_depths.size() ?
existing_source_triangle_depths[tri_idx] :
0;
int min_depth = std::max(base_depth, preserved_depth);
int max_depth = std::max(safe_max_depth, preserved_depth);
if (tri_idx < brush_candidate_triangles.size() && brush_candidate_triangles[tri_idx]) {
const std::array<Vec3f, 3> world_vertices = transform_triangle(world_matrix, vertices);
const int brush_depth = texture_mapping_depth_from_span(triangle_max_edge_length(world_vertices),
brush_subdivision_target,
7);
min_depth = std::max(min_depth, brush_depth);
max_depth = std::max(max_depth, min_depth);
}
return std::make_pair(min_depth, max_depth);
};
return volume.texture_mapping_color_facets.set_from_triangle_sampler(volume, sampler, safe_max_depth, 0.012f, subdivision_depths);
}
static bool build_volume_rgb_data(const ModelVolume &volume, const ColorRGBA &background, ColorFacetsAnnotation &out)
{
if (volume.mesh().its.indices.empty() || volume.mesh().its.vertices.empty())
return false;
out.reset();
const uint32_t packed = pack_vertex_color_rgba(background);
TextureMappingColorSampler sampler = [packed](size_t, const Vec3f &, const Vec3f &) { return packed; };
const bool changed = out.set_from_triangle_sampler(volume, sampler, 0, 0.f);
out.set_metadata_json(rgb_metadata_json(background));
return changed || !out.empty();
}
static bool initialize_volume_rgb_data(ModelVolume &volume, const ColorRGBA &background)
{
std::unique_ptr<ColorFacetsAnnotation> rgb_data = ColorFacetsAnnotation::make_temporary();
if (!rgb_data || !build_volume_rgb_data(volume, background, *rgb_data))
return false;
if (volume.texture_mapping_color_facets.equals(*rgb_data))
return false;
volume.texture_mapping_color_facets.assign(*rgb_data);
return true;
}
struct ProjectionContext
{
Matrix4d view_projection = Matrix4d::Identity();
int canvas_width = 1;
int canvas_height = 1;
float overlay_left = 0.f;
float overlay_top = 0.f;
float overlay_width = 0.f;
float overlay_height = 0.f;
const std::vector<uint8_t> *image_rgba = nullptr;
uint32_t image_width = 0;
uint32_t image_height = 0;
float image_opacity = 1.f;
bool apply_transparency_as_background = false;
};
struct VolumeColorSource
{
std::vector<ColorFacetTriangle> rgb_facets;
std::unordered_map<int, std::vector<size_t>> rgb_by_source_triangle;
};
static ColorRGBA sample_rgba_bilinear_clamped(const std::vector<uint8_t> &rgba, uint32_t width, uint32_t height, float u, float v)
{
if (width == 0 || height == 0 || rgba.size() < size_t(width) * size_t(height) * 4)
return ColorRGBA(1.f, 1.f, 1.f, 1.f);
u = std::clamp(u, 0.f, 1.f);
v = std::clamp(v, 0.f, 1.f);
const float x = u * float(width > 1 ? width - 1 : 0);
const float y = v * float(height > 1 ? height - 1 : 0);
const size_t x0 = std::min<size_t>(size_t(std::floor(x)), size_t(width - 1));
const size_t y0 = std::min<size_t>(size_t(std::floor(y)), size_t(height - 1));
const size_t x1 = std::min<size_t>(x0 + 1, size_t(width - 1));
const size_t y1 = std::min<size_t>(y0 + 1, size_t(height - 1));
const float tx = x - float(x0);
const float ty = y - float(y0);
auto channel = [&rgba, width](size_t sx, size_t sy, size_t ch) {
return float(rgba[(sy * size_t(width) + sx) * 4 + ch]) / 255.f;
};
auto blend_channel = [&](size_t ch) {
const float c00 = channel(x0, y0, ch);
const float c10 = channel(x1, y0, ch);
const float c01 = channel(x0, y1, ch);
const float c11 = channel(x1, y1, ch);
return std::clamp((c00 + (c10 - c00) * tx) + ((c01 + (c11 - c01) * tx) - (c00 + (c10 - c00) * tx)) * ty, 0.f, 1.f);
};
auto blend_premultiplied_channel = [&](size_t ch) {
const float c00 = channel(x0, y0, ch) * channel(x0, y0, 3);
const float c10 = channel(x1, y0, ch) * channel(x1, y0, 3);
const float c01 = channel(x0, y1, ch) * channel(x0, y1, 3);
const float c11 = channel(x1, y1, ch) * channel(x1, y1, 3);
return std::clamp((c00 + (c10 - c00) * tx) + ((c01 + (c11 - c01) * tx) - (c00 + (c10 - c00) * tx)) * ty, 0.f, 1.f);
};
const float a = blend_channel(3);
if (a <= 0.f)
return ColorRGBA(blend_channel(0), blend_channel(1), blend_channel(2), 0.f);
return ColorRGBA(std::clamp(blend_premultiplied_channel(0) / a, 0.f, 1.f),
std::clamp(blend_premultiplied_channel(1) / a, 0.f, 1.f),
std::clamp(blend_premultiplied_channel(2) / a, 0.f, 1.f),
a);
}
static ColorRGBA blend_projection_color(const ColorRGBA &base, const ColorRGBA &overlay, float opacity)
{
const float alpha = std::clamp(overlay.a(), 0.f, 1.f) * std::clamp(opacity, 0.f, 1.f);
if (alpha <= 0.f)
return base;
const float out_alpha = std::clamp(alpha + base.a() * (1.f - alpha), 0.f, 1.f);
if (out_alpha <= EPSILON)
return ColorRGBA(overlay.r(), overlay.g(), overlay.b(), 0.f);
return ColorRGBA(base.r() * (1.f - alpha) + overlay.r() * alpha,
base.g() * (1.f - alpha) + overlay.g() * alpha,
base.b() * (1.f - alpha) + overlay.b() * alpha,
out_alpha);
}
static float projection_overlay_alpha(const ColorRGBA &overlay, const ProjectionContext &context)
{
return std::clamp(overlay.a(), 0.f, 1.f) * std::clamp(context.image_opacity, 0.f, 1.f);
}
static bool projection_overlay_has_paintable_alpha(const ColorRGBA &overlay, const ProjectionContext &context)
{
return projection_overlay_alpha(overlay, context) > 0.5f / 255.f;
}
static ColorRGBA apply_projection_color(const ColorRGBA &base, const ColorRGBA &overlay, const ProjectionContext &context, bool image_texture_target)
{
const float opacity = std::clamp(context.image_opacity, 0.f, 1.f);
if (!context.apply_transparency_as_background)
return blend_projection_color(base, overlay, opacity);
const float alpha = std::clamp(overlay.a(), 0.f, 1.f) * opacity;
if (image_texture_target)
return ColorRGBA(overlay.r() * alpha, overlay.g() * alpha, overlay.b() * alpha, 1.f);
return ColorRGBA(overlay.r(), overlay.g(), overlay.b(), alpha);
}
static bool wx_image_to_rgba(const wxImage &image, std::vector<uint8_t> &rgba, uint32_t &width, uint32_t &height)
{
if (!image.IsOk() || image.GetWidth() <= 0 || image.GetHeight() <= 0)
return false;
width = uint32_t(image.GetWidth());
height = uint32_t(image.GetHeight());
rgba.assign(size_t(width) * size_t(height) * 4, 255);
const unsigned char *rgb = image.GetData();
const unsigned char *alpha = image.HasAlpha() ? image.GetAlpha() : nullptr;
const bool has_mask = image.HasMask();
const int mask_r = has_mask ? image.GetMaskRed() : -1;
const int mask_g = has_mask ? image.GetMaskGreen() : -1;
const int mask_b = has_mask ? image.GetMaskBlue() : -1;
if (rgb == nullptr)
return false;
for (size_t idx = 0; idx < size_t(width) * size_t(height); ++idx) {
rgba[idx * 4 + 0] = rgb[idx * 3 + 0];
rgba[idx * 4 + 1] = rgb[idx * 3 + 1];
rgba[idx * 4 + 2] = rgb[idx * 3 + 2];
rgba[idx * 4 + 3] =
has_mask &&
int(rgb[idx * 3 + 0]) == mask_r &&
int(rgb[idx * 3 + 1]) == mask_g &&
int(rgb[idx * 3 + 2]) == mask_b ?
0 :
(alpha == nullptr ? 255 : alpha[idx]);
}
return true;
}
static bool project_point_to_screen(const ProjectionContext &context, const Vec3d &world_point, Vec2f &screen, float *ndc_z = nullptr)
{
const Vec4d clip = context.view_projection * Vec4d(world_point.x(), world_point.y(), world_point.z(), 1.0);
if (clip.w() <= 0.0)
return false;
const Vec3d ndc = clip.head<3>() / clip.w();
if (ndc.x() < -1.0 || ndc.x() > 1.0 || ndc.y() < -1.0 || ndc.y() > 1.0 || ndc.z() < -1.0 || ndc.z() > 1.0)
return false;
screen.x() = float((ndc.x() * 0.5 + 0.5) * double(context.canvas_width));
screen.y() = float((1.0 - (ndc.y() * 0.5 + 0.5)) * double(context.canvas_height));
if (ndc_z != nullptr)
*ndc_z = float(ndc.z());
return true;
}
static std::optional<ColorRGBA> projected_image_color_at_point(const ProjectionContext &context,
const Transform3d &world_matrix,
const Vec3f &point)
{
if (context.image_rgba == nullptr || context.overlay_width <= 0.f || context.overlay_height <= 0.f)
return std::nullopt;
Vec2f screen = Vec2f::Zero();
if (!project_point_to_screen(context, world_matrix * point.cast<double>(), screen))
return std::nullopt;
if (screen.x() < context.overlay_left ||
screen.y() < context.overlay_top ||
screen.x() > context.overlay_left + context.overlay_width ||
screen.y() > context.overlay_top + context.overlay_height)
return std::nullopt;
const float u = (screen.x() - context.overlay_left) / context.overlay_width;
const float v = (screen.y() - context.overlay_top) / context.overlay_height;
return sample_rgba_bilinear_clamped(*context.image_rgba, context.image_width, context.image_height, u, v);
}
static bool projection_triangle_intersects_overlay(const ProjectionContext &context,
const Transform3d &world_matrix,
const std::array<Vec3f, 3> &vertices)
{
float min_x = std::numeric_limits<float>::max();
float min_y = std::numeric_limits<float>::max();
float max_x = std::numeric_limits<float>::lowest();
float max_y = std::numeric_limits<float>::lowest();
bool any_projected = false;
for (const Vec3f &vertex : vertices) {
Vec2f screen = Vec2f::Zero();
if (!project_point_to_screen(context, world_matrix * vertex.cast<double>(), screen))
continue;
min_x = std::min(min_x, screen.x());
min_y = std::min(min_y, screen.y());
max_x = std::max(max_x, screen.x());
max_y = std::max(max_y, screen.y());
any_projected = true;
}
if (!any_projected)
return false;
return max_x >= context.overlay_left &&
min_x <= context.overlay_left + context.overlay_width &&
max_y >= context.overlay_top &&
min_y <= context.overlay_top + context.overlay_height;
}
static bool barycentric_weights_2d(const Vec2f &point, const Vec2f &a, const Vec2f &b, const Vec2f &c, Vec3f &weights)
{
const Vec2f v0 = b - a;
const Vec2f v1 = c - a;
const Vec2f v2 = point - a;
const float d00 = v0.dot(v0);
const float d01 = v0.dot(v1);
const float d11 = v1.dot(v1);
const float d20 = v2.dot(v0);
const float d21 = v2.dot(v1);
const float denom = d00 * d11 - d01 * d01;
if (std::abs(denom) <= EPSILON)
return false;
weights.y() = (d11 * d20 - d01 * d21) / denom;
weights.z() = (d00 * d21 - d01 * d20) / denom;
weights.x() = 1.f - weights.y() - weights.z();
return std::isfinite(weights.x()) && std::isfinite(weights.y()) && std::isfinite(weights.z());
}
static Vec3f normalized_nonnegative_barycentric(Vec3f weights)
{
weights.x() = std::max(weights.x(), 0.f);
weights.y() = std::max(weights.y(), 0.f);
weights.z() = std::max(weights.z(), 0.f);
const float sum = weights.x() + weights.y() + weights.z();
if (sum <= EPSILON)
return Vec3f(1.f / 3.f, 1.f / 3.f, 1.f / 3.f);
weights /= sum;
return weights;
}
static float distance_to_segment_2d(const Vec2f &point, const Vec2f &a, const Vec2f &b)
{
const Vec2f ab = b - a;
const float len2 = ab.squaredNorm();
if (len2 <= EPSILON)
return (point - a).norm();
const float t = std::clamp((point - a).dot(ab) / len2, 0.f, 1.f);
return (point - (a + ab * t)).norm();
}
static bool conservative_barycentric_weights_2d(const Vec2f &point,
const Vec2f &a,
const Vec2f &b,
const Vec2f &c,
float tolerance,
Vec3f &weights)
{
if (!barycentric_weights_2d(point, a, b, c, weights))
return false;
if (weights.x() >= -1e-4f && weights.y() >= -1e-4f && weights.z() >= -1e-4f)
return true;
const float distance = std::min({ distance_to_segment_2d(point, a, b),
distance_to_segment_2d(point, b, c),
distance_to_segment_2d(point, c, a) });
if (distance > tolerance)
return false;
weights = normalized_nonnegative_barycentric(weights);
return true;
}
static std::array<Vec2f, 3> unwrap_projection_uvs(std::array<Vec2f, 3> uvs)
{
auto unwrap_axis = [&uvs](bool use_u_axis) mutable {
std::array<float, 3> values = {
use_u_axis ? uvs[0].x() : uvs[0].y(),
use_u_axis ? uvs[1].x() : uvs[1].y(),
use_u_axis ? uvs[2].x() : uvs[2].y()
};
const float min_value = std::min({ values[0], values[1], values[2] });
const float max_value = std::max({ values[0], values[1], values[2] });
if (max_value - min_value <= 0.5f)
return;
for (float &value : values)
if (value < 0.5f)
value += 1.f;
if (use_u_axis) {
uvs[0].x() = values[0];
uvs[1].x() = values[1];
uvs[2].x() = values[2];
} else {
uvs[0].y() = values[0];
uvs[1].y() = values[1];
uvs[2].y() = values[2];
}
};
unwrap_axis(true);
unwrap_axis(false);
const float min_u = std::min({ uvs[0].x(), uvs[1].x(), uvs[2].x() });
const float min_v = std::min({ uvs[0].y(), uvs[1].y(), uvs[2].y() });
const Vec2f offset(std::floor(min_u), std::floor(min_v));
for (Vec2f &uv : uvs)
uv -= offset;
return uvs;
}
static uint32_t wrapped_texture_pixel(int value, uint32_t size)
{
if (size == 0)
return 0;
int wrapped = value % int(size);
if (wrapped < 0)
wrapped += int(size);
return uint32_t(wrapped);
}
static VolumeColorSource build_volume_color_source(const ModelVolume &volume)
{
VolumeColorSource source;
if (!volume.texture_mapping_color_facets.empty()) {
volume.texture_mapping_color_facets.get_facet_triangles(volume, source.rgb_facets);
source.rgb_by_source_triangle.reserve(source.rgb_facets.size());
for (size_t idx = 0; idx < source.rgb_facets.size(); ++idx)
source.rgb_by_source_triangle[source.rgb_facets[idx].source_triangle].emplace_back(idx);
}
return source;
}
static ColorRGBA sample_volume_color_source(const ModelVolume &volume,
const VolumeColorSource &source,
size_t tri_idx,
const Vec3f &point,
const Vec3f &barycentric,
bool use_image_texture = true,
const ColorRGBA *fallback_color = nullptr)
{
if (!volume.texture_mapping_color_facets.empty()) {
if (std::optional<ColorRGBA> color = sample_rgb_color_facets(source.rgb_facets,
source.rgb_by_source_triangle,
int(tri_idx),
point))
return *color;
return rgb_metadata_background_color(volume.texture_mapping_color_facets);
}
const indexed_triangle_set &its = volume.mesh().its;
if (use_image_texture && model_volume_has_bakeable_image_texture_data(&volume) && tri_idx < volume.imported_texture_uv_valid.size()) {
const size_t uv_offset = tri_idx * 6;
if (volume.imported_texture_uv_valid[tri_idx] != 0 && uv_offset + 5 < volume.imported_texture_uvs_per_face.size()) {
const Vec2f uv0(volume.imported_texture_uvs_per_face[uv_offset + 0], volume.imported_texture_uvs_per_face[uv_offset + 1]);
const Vec2f uv1(volume.imported_texture_uvs_per_face[uv_offset + 2], volume.imported_texture_uvs_per_face[uv_offset + 3]);
const Vec2f uv2(volume.imported_texture_uvs_per_face[uv_offset + 4], volume.imported_texture_uvs_per_face[uv_offset + 5]);
const Vec2f uv = uv0 * barycentric.x() + uv1 * barycentric.y() + uv2 * barycentric.z();
return sample_texture_rgba_for_vertex_bake(volume.imported_texture_rgba,
volume.imported_texture_width,
volume.imported_texture_height,
uv);
}
}
if (volume.imported_vertex_colors_rgba.size() == its.vertices.size() && tri_idx < its.indices.size()) {
const stl_triangle_vertex_indices &tri = its.indices[tri_idx];
if (tri[0] >= 0 && tri[1] >= 0 && tri[2] >= 0 &&
size_t(tri[0]) < volume.imported_vertex_colors_rgba.size() &&
size_t(tri[1]) < volume.imported_vertex_colors_rgba.size() &&
size_t(tri[2]) < volume.imported_vertex_colors_rgba.size()) {
const ColorRGBA c0 = unpack_vertex_color_rgba_for_conversion(volume.imported_vertex_colors_rgba[size_t(tri[0])]);
const ColorRGBA c1 = unpack_vertex_color_rgba_for_conversion(volume.imported_vertex_colors_rgba[size_t(tri[1])]);
const ColorRGBA c2 = unpack_vertex_color_rgba_for_conversion(volume.imported_vertex_colors_rgba[size_t(tri[2])]);
return ColorRGBA(c0.r() * barycentric.x() + c1.r() * barycentric.y() + c2.r() * barycentric.z(),
c0.g() * barycentric.x() + c1.g() * barycentric.y() + c2.g() * barycentric.z(),
c0.b() * barycentric.x() + c1.b() * barycentric.y() + c2.b() * barycentric.z(),
c0.a() * barycentric.x() + c1.a() * barycentric.y() + c2.a() * barycentric.z());
}
}
return fallback_color != nullptr ? *fallback_color : ColorRGBA(1.f, 1.f, 1.f, 1.f);
}
static bool build_volume_rgb_data_from_current_surface_color(const ModelVolume &volume,
const ColorRGBA &fallback_color,
ColorFacetsAnnotation &out)
{
const indexed_triangle_set &its = volume.mesh().its;
if (its.indices.empty() || its.vertices.empty())
return false;
const bool has_image_texture = model_volume_has_bakeable_image_texture_data(&volume);
const bool has_vertex_colors = volume.imported_vertex_colors_rgba.size() == its.vertices.size();
if (!has_image_texture && !has_vertex_colors)
return build_volume_rgb_data(volume, fallback_color, out);
out.reset();
const VolumeColorSource source = build_volume_color_source(volume);
TextureMappingColorSampler sampler = [&volume, source, fallback_color](size_t tri_idx, const Vec3f &point, const Vec3f &barycentric) {
return pack_vertex_color_rgba(sample_volume_color_source(volume, source, tri_idx, point, barycentric, true, &fallback_color));
};
bool changed = false;
if (has_image_texture) {
const int safe_max_depth = texture_mapping_depth_for_budget(its.indices.size(), 7, 3200000);
TextureMappingColorSubdivisionDepths subdivision_depths = [&volume, safe_max_depth](size_t tri_idx, const std::array<Vec3f, 3> &) {
const int depth = texture_mapping_depth_from_span(texture_triangle_uv_pixel_span(&volume, tri_idx), 8.f, safe_max_depth);
return std::make_pair(depth, depth);
};
changed = out.set_from_triangle_sampler(volume, sampler, safe_max_depth, 0.015f, subdivision_depths);
} else {
const float target_edge = std::max(mesh_max_axis_span(its) / 160.f, 0.25f);
TextureMappingColorSubdivisionDepths subdivision_depths = [target_edge](size_t, const std::array<Vec3f, 3> &vertices) {
const int depth = texture_mapping_depth_from_span(triangle_max_edge_length(vertices), target_edge, 5);
return std::make_pair(depth, depth);
};
changed = out.set_from_triangle_sampler(volume, sampler, 5, 0.025f, subdivision_depths);
}
if (changed && out.metadata_json().empty())
out.set_metadata_json(rgb_metadata_json(fallback_color));
return changed || !out.empty();
}
static bool initialize_volume_rgb_data_from_current_surface_color(ModelVolume &volume, const ColorRGBA &fallback_color)
{
std::unique_ptr<ColorFacetsAnnotation> rgb_data = ColorFacetsAnnotation::make_temporary();
if (!rgb_data || !build_volume_rgb_data_from_current_surface_color(volume, fallback_color, *rgb_data))
return false;
if (volume.texture_mapping_color_facets.equals(*rgb_data))
return false;
volume.texture_mapping_color_facets.assign(*rgb_data);
return true;
}
static ColorRGBA projection_base_color_for_volume(const ModelVolume &volume)
{
std::vector<ColorRGBA> colors = get_extruders_colors();
if (!colors.empty()) {
int extruder_idx = volume.extruder_id() > 0 ? volume.extruder_id() - 1 : 0;
extruder_idx = std::clamp(extruder_idx, 0, int(colors.size() - 1));
ColorRGBA color = colors[size_t(extruder_idx)];
color.a(1.f);
return color;
}
return ColorRGBA(0.15f, 0.65f, 0.6f, 1.f);
}
static uint32_t projection_texture_size_for_triangles(size_t triangle_count)
{
const uint32_t grid = uint32_t(std::max<size_t>(1, size_t(std::ceil(std::sqrt(double(std::max<size_t>(triangle_count, 1)))))));
uint32_t size = 256;
while (size < grid * 8 && size < 4096)
size *= 2;
return std::clamp<uint32_t>(size, 256, 4096);
}
static bool write_rgba_pixel(std::vector<uint8_t> &rgba, uint32_t width, uint32_t x, uint32_t y, const ColorRGBA &color)
{
if (width == 0)
return false;
const size_t idx = (size_t(y) * size_t(width) + size_t(x)) * 4;
if (idx + 3 >= rgba.size())
return false;
const uint8_t r = uint8_t(std::clamp(color.r(), 0.f, 1.f) * 255.f + 0.5f);
const uint8_t g = uint8_t(std::clamp(color.g(), 0.f, 1.f) * 255.f + 0.5f);
const uint8_t b = uint8_t(std::clamp(color.b(), 0.f, 1.f) * 255.f + 0.5f);
const uint8_t a = uint8_t(std::clamp(color.a(), 0.f, 1.f) * 255.f + 0.5f);
if (rgba[idx + 0] == r && rgba[idx + 1] == g && rgba[idx + 2] == b && rgba[idx + 3] == a)
return false;
rgba[idx + 0] = r;
rgba[idx + 1] = g;
rgba[idx + 2] = b;
rgba[idx + 3] = a;
return true;
}
static ColorRGBA read_rgba_pixel(const std::vector<uint8_t> &rgba, uint32_t width, uint32_t x, uint32_t y)
{
if (width == 0)
return ColorRGBA(1.f, 1.f, 1.f, 1.f);
const size_t idx = (size_t(y) * size_t(width) + size_t(x)) * 4;
if (idx + 3 >= rgba.size())
return ColorRGBA(1.f, 1.f, 1.f, 1.f);
return ColorRGBA(float(rgba[idx + 0]) / 255.f,
float(rgba[idx + 1]) / 255.f,
float(rgba[idx + 2]) / 255.f,
float(rgba[idx + 3]) / 255.f);
}
static Transform3d projection_world_matrix_for_volume(const GLCanvas3D &parent,
const ModelObject *object,
const ModelVolume *volume,
int instance_idx)
{
if (object == nullptr || volume == nullptr || object->instances.empty())
return Transform3d::Identity();
instance_idx = std::clamp(instance_idx, 0, int(object->instances.size() - 1));
const ModelInstance *instance = object->instances[size_t(instance_idx)];
if (parent.get_canvas_type() == GLCanvas3D::CanvasAssembleView)
return instance->get_assemble_transformation().get_matrix() * volume->get_matrix();
return instance->get_transformation().get_matrix() * volume->get_matrix();
}
struct ProjectionVisibility
{
int width = 0;
int height = 0;
float left = 0.f;
float top = 0.f;
float scale = 1.f;
std::vector<float> depth;
};
static bool projection_visibility_valid(const ProjectionVisibility &visibility)
{
return visibility.width > 0 &&
visibility.height > 0 &&
visibility.depth.size() == size_t(visibility.width) * size_t(visibility.height);
}
static ProjectionVisibility build_projection_visibility(const ProjectionContext &context,
const GLCanvas3D &parent,
const ModelObject *object,
int instance_idx)
{
ProjectionVisibility visibility;
if (object == nullptr || context.overlay_width <= 0.f || context.overlay_height <= 0.f)
return visibility;
const float max_dim = std::max(context.overlay_width, context.overlay_height);
visibility.scale = max_dim > 2048.f ? 2048.f / max_dim : 1.f;
visibility.width = std::max(1, int(std::ceil(context.overlay_width * visibility.scale)));
visibility.height = std::max(1, int(std::ceil(context.overlay_height * visibility.scale)));
visibility.left = context.overlay_left;
visibility.top = context.overlay_top;
visibility.depth.assign(size_t(visibility.width) * size_t(visibility.height), std::numeric_limits<float>::max());
auto rasterize_triangle = [&visibility](const std::array<Vec2f, 3> &screen, const std::array<float, 3> &depths) {
const float min_screen_x = std::min({ screen[0].x(), screen[1].x(), screen[2].x() });
const float max_screen_x = std::max({ screen[0].x(), screen[1].x(), screen[2].x() });
const float min_screen_y = std::min({ screen[0].y(), screen[1].y(), screen[2].y() });
const float max_screen_y = std::max({ screen[0].y(), screen[1].y(), screen[2].y() });
const int min_x = std::clamp(int(std::floor((min_screen_x - visibility.left) * visibility.scale)) - 1, 0, visibility.width - 1);
const int max_x = std::clamp(int(std::ceil((max_screen_x - visibility.left) * visibility.scale)) + 1, 0, visibility.width - 1);
const int min_y = std::clamp(int(std::floor((min_screen_y - visibility.top) * visibility.scale)) - 1, 0, visibility.height - 1);
const int max_y = std::clamp(int(std::ceil((max_screen_y - visibility.top) * visibility.scale)) + 1, 0, visibility.height - 1);
for (int y = min_y; y <= max_y; ++y) {
for (int x = min_x; x <= max_x; ++x) {
const Vec2f pixel(visibility.left + (float(x) + 0.5f) / visibility.scale,
visibility.top + (float(y) + 0.5f) / visibility.scale);
Vec3f weights = Vec3f::Zero();
if (!barycentric_weights_2d(pixel, screen[0], screen[1], screen[2], weights))
continue;
if (weights.x() < -1e-4f || weights.y() < -1e-4f || weights.z() < -1e-4f)
continue;
const float depth = depths[0] * weights.x() + depths[1] * weights.y() + depths[2] * weights.z();
const size_t idx = size_t(y) * size_t(visibility.width) + size_t(x);
visibility.depth[idx] = std::min(visibility.depth[idx], depth);
}
}
};
for (const ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
const indexed_triangle_set &its = volume->mesh().its;
if (its.vertices.empty() || its.indices.empty())
continue;
const Transform3d world_matrix = projection_world_matrix_for_volume(parent, object, volume, instance_idx);
for (const stl_triangle_vertex_indices &tri : its.indices) {
if (tri[0] < 0 || tri[1] < 0 || tri[2] < 0)
continue;
if (size_t(tri[0]) >= its.vertices.size() ||
size_t(tri[1]) >= its.vertices.size() ||
size_t(tri[2]) >= its.vertices.size())
continue;
const std::array<Vec3f, 3> vertices = {
its.vertices[size_t(tri[0])].cast<float>(),
its.vertices[size_t(tri[1])].cast<float>(),
its.vertices[size_t(tri[2])].cast<float>()
};
if (!projection_triangle_intersects_overlay(context, world_matrix, vertices))
continue;
std::array<Vec2f, 3> screen;
std::array<float, 3> depths;
bool projected = true;
for (size_t idx = 0; idx < vertices.size(); ++idx) {
if (!project_point_to_screen(context, world_matrix * vertices[idx].cast<double>(), screen[idx], &depths[idx])) {
projected = false;
break;
}
}
if (projected)
rasterize_triangle(screen, depths);
}
}
return visibility;
}
static bool projection_point_is_visible(const ProjectionVisibility &visibility,
const ProjectionContext &context,
const Transform3d &world_matrix,
const Vec3f &point)
{
if (!projection_visibility_valid(visibility))
return true;
Vec2f screen = Vec2f::Zero();
float depth = 0.f;
if (!project_point_to_screen(context, world_matrix * point.cast<double>(), screen, &depth))
return false;
const int x = int(std::floor((screen.x() - visibility.left) * visibility.scale));
const int y = int(std::floor((screen.y() - visibility.top) * visibility.scale));
if (x < 0 || y < 0 || x >= visibility.width || y >= visibility.height)
return false;
const float nearest = visibility.depth[size_t(y) * size_t(visibility.width) + size_t(x)];
if (!std::isfinite(nearest))
return false;
return depth <= nearest + 2e-3f;
}
enum class ManagedColorDataType
{
ColorRegions,
VertexColors,
ImageTexture,
RgbaData
};
struct ManagedColorDataCreateSource
{
std::optional<ManagedColorDataType> type;
};
struct ManagedColorDataSummary
{
bool has_color_regions = false;
bool has_vertex_colors = false;
bool has_image_texture = false;
bool has_rgba_data = false;
size_t color_region_triangle_count = 0;
size_t vertex_color_count = 0;
size_t image_texture_count = 0;
uint32_t max_texture_width = 0;
uint32_t max_texture_height = 0;
size_t rgba_data_bytes = 0;
};
static bool object_has_color_regions(const ModelObject &object)
{
for (const ModelVolume *volume : object.volumes)
if (volume != nullptr && volume->is_model_part() && !volume->mmu_segmentation_facets.empty())
return true;
return false;
}
static bool object_has_vertex_color_data(const ModelObject &object)
{
for (const ModelVolume *volume : object.volumes)
if (volume != nullptr && volume->is_model_part() && !volume->imported_vertex_colors_rgba.empty())
return true;
return false;
}
static bool object_has_image_texture_data(const ModelObject &object)
{
for (const ModelVolume *volume : object.volumes)
if (volume != nullptr && volume->is_model_part() && model_volume_has_imported_image_texture_data(volume))
return true;
return false;
}
static bool object_has_rgba_data(const ModelObject &object)
{
for (const ModelVolume *volume : object.volumes)
if (volume != nullptr && volume->is_model_part() && !volume->texture_mapping_color_facets.empty())
return true;
return false;
}
static bool object_has_managed_color_data(const ModelObject &object, ManagedColorDataType type)
{
switch (type) {
case ManagedColorDataType::ColorRegions:
return object_has_color_regions(object);
case ManagedColorDataType::VertexColors:
return object_has_vertex_color_data(object);
case ManagedColorDataType::ImageTexture:
return object_has_image_texture_data(object);
case ManagedColorDataType::RgbaData:
return object_has_rgba_data(object);
}
return false;
}
static bool managed_color_data_summary_has_type(const ManagedColorDataSummary &summary, ManagedColorDataType type)
{
switch (type) {
case ManagedColorDataType::ColorRegions:
return summary.has_color_regions;
case ManagedColorDataType::VertexColors:
return summary.has_vertex_colors;
case ManagedColorDataType::ImageTexture:
return summary.has_image_texture;
case ManagedColorDataType::RgbaData:
return summary.has_rgba_data;
}
return false;
}
static wxString managed_color_data_type_label(ManagedColorDataType type)
{
switch (type) {
case ManagedColorDataType::ColorRegions:
return _L("3mf color regions");
case ManagedColorDataType::VertexColors:
return _L("Vertex Colors");
case ManagedColorDataType::ImageTexture:
return _L("Image Texture");
case ManagedColorDataType::RgbaData:
return _L("RGBA data");
}
return wxString();
}
static size_t estimated_rgba_data_bytes(const ColorFacetsAnnotation &annotation)
{
const TriangleColorSplittingData &data = annotation.get_data();
return data.triangles_to_split.size() * sizeof(ColorTriangleBitStreamMapping) +
(data.bitstream.size() + 7) / 8 +
data.colors_rgba.size() * sizeof(uint32_t) +
data.metadata_json.size();
}
static ManagedColorDataSummary summarize_managed_color_data(const ModelObject *object)
{
ManagedColorDataSummary summary;
if (object == nullptr)
return summary;
for (const ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
if (!volume->mmu_segmentation_facets.empty()) {
summary.has_color_regions = true;
summary.color_region_triangle_count += volume->mmu_segmentation_facets.get_data().triangles_to_split.size();
}
if (!volume->imported_vertex_colors_rgba.empty()) {
summary.has_vertex_colors = true;
summary.vertex_color_count += volume->imported_vertex_colors_rgba.size();
}
if (model_volume_has_imported_image_texture_data(volume)) {
summary.has_image_texture = true;
++summary.image_texture_count;
summary.max_texture_width = std::max(summary.max_texture_width, volume->imported_texture_width);
summary.max_texture_height = std::max(summary.max_texture_height, volume->imported_texture_height);
}
if (!volume->texture_mapping_color_facets.empty()) {
summary.has_rgba_data = true;
summary.rgba_data_bytes += estimated_rgba_data_bytes(volume->texture_mapping_color_facets);
}
}
return summary;
}
static wxString managed_color_data_size_text(const ManagedColorDataSummary &summary, ManagedColorDataType type)
{
switch (type) {
case ManagedColorDataType::ColorRegions:
return wxString::Format(_L("%llu triangles"), static_cast<unsigned long long>(summary.color_region_triangle_count));
case ManagedColorDataType::VertexColors:
return wxString::Format(_L("%llu vertices"), static_cast<unsigned long long>(summary.vertex_color_count));
case ManagedColorDataType::ImageTexture:
if (!summary.has_image_texture)
return _L("0 x 0");
if (summary.image_texture_count <= 1)
return wxString::Format(_L("%u x %u"),
static_cast<unsigned>(summary.max_texture_width),
static_cast<unsigned>(summary.max_texture_height));
return wxString::Format(_L("%llu textures, max %u x %u"),
static_cast<unsigned long long>(summary.image_texture_count),
static_cast<unsigned>(summary.max_texture_width),
static_cast<unsigned>(summary.max_texture_height));
case ManagedColorDataType::RgbaData:
if (summary.rgba_data_bytes > 0 && summary.rgba_data_bytes < 1024 * 1024 / 100)
return _L("<0.01 MB");
return wxString::Format(_L("%.2f MB"), double(summary.rgba_data_bytes) / (1024.0 * 1024.0));
}
return wxString();
}
static bool clear_object_managed_color_data(ModelObject &object, ManagedColorDataType type)
{
bool changed = false;
for (ModelVolume *volume : object.volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
switch (type) {
case ManagedColorDataType::ColorRegions:
if (!volume->mmu_segmentation_facets.empty()) {
volume->mmu_segmentation_facets.reset();
changed = true;
}
break;
case ManagedColorDataType::VertexColors:
if (!volume->imported_vertex_colors_rgba.empty()) {
volume->imported_vertex_colors_rgba.clear();
changed = true;
}
break;
case ManagedColorDataType::ImageTexture:
if (!volume->imported_texture_rgba.empty() ||
!volume->imported_texture_uvs_per_face.empty() ||
!volume->imported_texture_uv_valid.empty() ||
volume->imported_texture_width != 0 ||
volume->imported_texture_height != 0) {
volume->imported_texture_uvs_per_face.clear();
volume->imported_texture_uv_valid.clear();
volume->imported_texture_rgba.clear();
volume->imported_texture_width = 0;
volume->imported_texture_height = 0;
changed = true;
}
break;
case ManagedColorDataType::RgbaData:
if (!volume->texture_mapping_color_facets.empty()) {
volume->texture_mapping_color_facets.reset();
changed = true;
}
break;
}
}
return changed;
}
static bool assign_object_to_texture_mapping_zone(ModelObject &object)
{
const unsigned int texture_mapping_filament_id = ensure_texture_mapping_zone();
if (texture_mapping_filament_id == 0)
return false;
object.config.set("extruder", int(texture_mapping_filament_id));
for (ModelVolume *volume : object.volumes)
if (volume != nullptr && volume->is_model_part())
volume->config.set("extruder", int(texture_mapping_filament_id));
return true;
}
struct ManagedRegionColorSource
{
std::vector<std::vector<TriangleSelector::FacetStateTriangle>> triangles_per_type;
std::vector<std::unordered_map<int, std::vector<size_t>>> by_source_triangle;
std::vector<ColorRGBA> state_colors;
};
struct ManagedColorSourceFlags
{
bool use_rgba = false;
bool use_image_texture = false;
bool use_vertex_colors = false;
bool use_color_regions = false;
};
static ManagedColorSourceFlags managed_color_source_flags(const ManagedColorDataCreateSource &source)
{
ManagedColorSourceFlags flags;
if (!source.type)
return flags;
switch (*source.type) {
case ManagedColorDataType::ColorRegions:
flags.use_color_regions = true;
break;
case ManagedColorDataType::VertexColors:
flags.use_vertex_colors = true;
break;
case ManagedColorDataType::ImageTexture:
flags.use_image_texture = true;
break;
case ManagedColorDataType::RgbaData:
flags.use_rgba = true;
break;
}
return flags;
}
static ColorRGBA blank_color_for_managed_target(ManagedColorDataType target)
{
return target == ManagedColorDataType::RgbaData ? ColorRGBA(1.f, 1.f, 1.f, 0.f) :
ColorRGBA(1.f, 1.f, 1.f, 1.f);
}
static std::vector<ColorRGBA> parse_managed_color_strings(const std::vector<std::string> &color_strings)
{
std::vector<ColorRGBA> colors;
colors.reserve(color_strings.size());
for (const std::string &color_string : color_strings) {
unsigned char rgba[4] = { 38, 166, 154, 255 };
BitmapCache::parse_color4(color_string, rgba);
colors.emplace_back(float(rgba[0]) / 255.f,
float(rgba[1]) / 255.f,
float(rgba[2]) / 255.f,
float(rgba[3]) / 255.f);
}
return colors;
}
static ColorRGBA managed_filament_color(unsigned int filament_id,
unsigned int base_filament_id,
const std::vector<ColorRGBA> &physical_colors,
const std::vector<ColorRGBA> &display_colors)
{
const size_t physical_count = physical_colors.size();
const ColorRGBA fallback = physical_colors.empty() ? ColorRGBA(0.15f, 0.65f, 0.6f, 1.f) : physical_colors.front();
auto physical_or_fallback = [&physical_colors, fallback](unsigned int id) {
if (id >= 1 && id <= physical_colors.size())
return physical_colors[size_t(id - 1)];
return fallback;
};
const bool texture_mapping_zone =
wxGetApp().preset_bundle != nullptr &&
wxGetApp().preset_bundle->texture_mapping_zones.is_texture_mapping_zone_id(filament_id);
if (texture_mapping_zone) {
if (base_filament_id != 0 && base_filament_id != filament_id)
return managed_filament_color(base_filament_id, 0, physical_colors, display_colors);
return fallback;
}
if (filament_id >= 1 && filament_id <= physical_count)
return physical_or_fallback(filament_id);
if (filament_id >= 1 && filament_id <= display_colors.size())
return display_colors[size_t(filament_id - 1)];
return fallback;
}
static ManagedRegionColorSource build_managed_region_color_source(const ModelVolume &volume)
{
ManagedRegionColorSource source;
if (volume.mmu_segmentation_facets.empty())
return source;
volume.mmu_segmentation_facets.get_facet_triangles(volume, source.triangles_per_type);
source.by_source_triangle.resize(source.triangles_per_type.size());
const std::vector<std::string> physical_color_strings =
wxGetApp().plater() != nullptr ? wxGetApp().plater()->get_extruder_colors_from_plater_config(nullptr, false) :
std::vector<std::string>();
const std::vector<std::string> display_color_strings =
wxGetApp().plater() != nullptr ? wxGetApp().plater()->get_extruder_colors_from_plater_config() :
physical_color_strings;
const std::vector<ColorRGBA> physical_colors = parse_managed_color_strings(physical_color_strings);
const std::vector<ColorRGBA> display_colors = parse_managed_color_strings(display_color_strings);
const unsigned int base_filament_id = volume.extruder_id() > 0 ? unsigned(volume.extruder_id()) : 1u;
source.state_colors.reserve(source.triangles_per_type.size());
for (size_t state_idx = 0; state_idx < source.triangles_per_type.size(); ++state_idx) {
const unsigned int filament_id = state_idx == 0 ? base_filament_id : unsigned(state_idx);
ColorRGBA color = managed_filament_color(filament_id, base_filament_id, physical_colors, display_colors);
color.a(1.f);
source.state_colors.emplace_back(color);
std::unordered_map<int, std::vector<size_t>> &by_source = source.by_source_triangle[state_idx];
by_source.reserve(source.triangles_per_type[state_idx].size());
for (size_t idx = 0; idx < source.triangles_per_type[state_idx].size(); ++idx)
by_source[source.triangles_per_type[state_idx][idx].source_triangle].emplace_back(idx);
}
return source;
}
static std::optional<ColorRGBA> sample_managed_region_color_source(const ManagedRegionColorSource &source,
int source_triangle,
const Vec3f &point)
{
std::optional<ColorRGBA> inside_color;
float best_inside_score = -std::numeric_limits<float>::max();
size_t best_inside_state = 0;
std::optional<ColorRGBA> nearest_color;
float nearest_distance_sq = std::numeric_limits<float>::max();
size_t nearest_state = 0;
for (size_t state_idx = 0; state_idx < source.triangles_per_type.size(); ++state_idx) {
if (state_idx >= source.by_source_triangle.size() || state_idx >= source.state_colors.size())
continue;
const auto found = source.by_source_triangle[state_idx].find(source_triangle);
if (found == source.by_source_triangle[state_idx].end())
continue;
const float tolerance = -1e-4f;
const std::vector<TriangleSelector::FacetStateTriangle> &state_triangles = source.triangles_per_type[state_idx];
for (const size_t facet_idx : found->second) {
if (facet_idx >= state_triangles.size())
continue;
const TriangleSelector::FacetStateTriangle &facet = state_triangles[facet_idx];
Vec3f weights = Vec3f::Zero();
if (!barycentric_weights_for_region_vertex_colors(point, facet.vertices[0], facet.vertices[1], facet.vertices[2], weights))
continue;
if (weights.x() >= tolerance && weights.y() >= tolerance && weights.z() >= tolerance) {
const float score = std::min({ weights.x(), weights.y(), weights.z() });
if (!inside_color ||
score > best_inside_score + 1e-6f ||
(std::abs(score - best_inside_score) <= 1e-6f && state_idx > best_inside_state)) {
inside_color = source.state_colors[state_idx];
best_inside_score = score;
best_inside_state = state_idx;
}
}
const Vec3f closest = closest_point_on_triangle(point, facet.vertices[0], facet.vertices[1], facet.vertices[2]);
const float distance_sq = (point - closest).squaredNorm();
if (!nearest_color ||
distance_sq < nearest_distance_sq - 1e-8f ||
(std::abs(distance_sq - nearest_distance_sq) <= 1e-8f && state_idx > nearest_state)) {
nearest_color = source.state_colors[state_idx];
nearest_distance_sq = distance_sq;
nearest_state = state_idx;
}
}
}
return inside_color ? inside_color : nearest_color;
}
static ColorRGBA sample_managed_volume_color_source(const ModelVolume &volume,
const VolumeColorSource &rgba_source,
const ManagedRegionColorSource &region_source,
size_t tri_idx,
const Vec3f &point,
const Vec3f &barycentric,
bool use_rgba,
bool use_image_texture,
bool use_vertex_colors,
bool use_color_regions,
const ColorRGBA &fallback_color)
{
if (use_rgba && !volume.texture_mapping_color_facets.empty()) {
if (std::optional<ColorRGBA> color = sample_rgb_color_facets(rgba_source.rgb_facets,
rgba_source.rgb_by_source_triangle,
int(tri_idx),
point))
return *color;
return rgb_metadata_background_color(volume.texture_mapping_color_facets);
}
const indexed_triangle_set &its = volume.mesh().its;
if (use_image_texture && model_volume_has_bakeable_image_texture_data(&volume) && tri_idx < volume.imported_texture_uv_valid.size()) {
const size_t uv_offset = tri_idx * 6;
if (volume.imported_texture_uv_valid[tri_idx] != 0 && uv_offset + 5 < volume.imported_texture_uvs_per_face.size()) {
const Vec2f uv0(volume.imported_texture_uvs_per_face[uv_offset + 0], volume.imported_texture_uvs_per_face[uv_offset + 1]);
const Vec2f uv1(volume.imported_texture_uvs_per_face[uv_offset + 2], volume.imported_texture_uvs_per_face[uv_offset + 3]);
const Vec2f uv2(volume.imported_texture_uvs_per_face[uv_offset + 4], volume.imported_texture_uvs_per_face[uv_offset + 5]);
const Vec2f uv = uv0 * barycentric.x() + uv1 * barycentric.y() + uv2 * barycentric.z();
return sample_texture_rgba_for_vertex_bake(volume.imported_texture_rgba,
volume.imported_texture_width,
volume.imported_texture_height,
uv);
}
}
if (use_vertex_colors && volume.imported_vertex_colors_rgba.size() == its.vertices.size() && tri_idx < its.indices.size()) {
const stl_triangle_vertex_indices &tri = its.indices[tri_idx];
if (tri[0] >= 0 && tri[1] >= 0 && tri[2] >= 0 &&
size_t(tri[0]) < volume.imported_vertex_colors_rgba.size() &&
size_t(tri[1]) < volume.imported_vertex_colors_rgba.size() &&
size_t(tri[2]) < volume.imported_vertex_colors_rgba.size()) {
const ColorRGBA c0 = unpack_vertex_color_rgba_for_conversion(volume.imported_vertex_colors_rgba[size_t(tri[0])]);
const ColorRGBA c1 = unpack_vertex_color_rgba_for_conversion(volume.imported_vertex_colors_rgba[size_t(tri[1])]);
const ColorRGBA c2 = unpack_vertex_color_rgba_for_conversion(volume.imported_vertex_colors_rgba[size_t(tri[2])]);
return ColorRGBA(c0.r() * barycentric.x() + c1.r() * barycentric.y() + c2.r() * barycentric.z(),
c0.g() * barycentric.x() + c1.g() * barycentric.y() + c2.g() * barycentric.z(),
c0.b() * barycentric.x() + c1.b() * barycentric.y() + c2.b() * barycentric.z(),
c0.a() * barycentric.x() + c1.a() * barycentric.y() + c2.a() * barycentric.z());
}
}
if (use_color_regions) {
if (std::optional<ColorRGBA> color = sample_managed_region_color_source(region_source, int(tri_idx), point))
return *color;
}
return fallback_color;
}
static bool convert_object_to_vertex_colors(ModelObject &object, const ManagedColorDataCreateSource &source)
{
if (object_has_vertex_color_data(object))
return false;
bool changed = false;
const ManagedColorSourceFlags source_flags = managed_color_source_flags(source);
const ColorRGBA fallback_color = blank_color_for_managed_target(ManagedColorDataType::VertexColors);
for (ModelVolume *volume : object.volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
const indexed_triangle_set &its = volume->mesh().its;
if (its.vertices.empty())
continue;
const VolumeColorSource rgba_source = build_volume_color_source(*volume);
const ManagedRegionColorSource region_source = build_managed_region_color_source(*volume);
std::vector<std::array<float, 4>> accumulators(its.vertices.size(), { 0.f, 0.f, 0.f, 0.f });
std::vector<unsigned int> counts(its.vertices.size(), 0);
for (size_t tri_idx = 0; tri_idx < its.indices.size(); ++tri_idx) {
const stl_triangle_vertex_indices &tri = its.indices[tri_idx];
for (int corner = 0; corner < 3; ++corner) {
if (tri[corner] < 0 || size_t(tri[corner]) >= its.vertices.size())
continue;
Vec3f barycentric = Vec3f::Zero();
barycentric[corner] = 1.f;
const ColorRGBA color = sample_managed_volume_color_source(*volume,
rgba_source,
region_source,
tri_idx,
its.vertices[size_t(tri[corner])].cast<float>(),
barycentric,
source_flags.use_rgba,
source_flags.use_image_texture,
source_flags.use_vertex_colors,
source_flags.use_color_regions,
fallback_color);
std::array<float, 4> &accumulator = accumulators[size_t(tri[corner])];
accumulator[0] += color.r();
accumulator[1] += color.g();
accumulator[2] += color.b();
accumulator[3] += color.a();
++counts[size_t(tri[corner])];
}
}
std::vector<uint32_t> vertex_colors;
vertex_colors.reserve(its.vertices.size());
for (size_t idx = 0; idx < its.vertices.size(); ++idx) {
ColorRGBA color = fallback_color;
if (counts[idx] > 0) {
const float inv = 1.f / float(counts[idx]);
color = ColorRGBA(accumulators[idx][0] * inv,
accumulators[idx][1] * inv,
accumulators[idx][2] * inv,
accumulators[idx][3] * inv);
}
vertex_colors.emplace_back(pack_vertex_color_rgba(color));
}
volume->imported_vertex_colors_rgba = std::move(vertex_colors);
changed = true;
}
return changed;
}
static bool convert_object_to_image_texture(ModelObject &object, const ManagedColorDataCreateSource &source)
{
if (object_has_image_texture_data(object))
return false;
bool changed = false;
const ManagedColorSourceFlags source_flags = managed_color_source_flags(source);
const ColorRGBA fallback_color = blank_color_for_managed_target(ManagedColorDataType::ImageTexture);
const uint32_t fallback_packed = pack_vertex_color_rgba(fallback_color);
for (ModelVolume *volume : object.volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
const indexed_triangle_set &its = volume->mesh().its;
if (its.vertices.empty() || its.indices.empty())
continue;
const uint32_t texture_size = projection_texture_size_for_triangles(its.indices.size());
const uint32_t grid = uint32_t(std::ceil(std::sqrt(double(std::max<size_t>(its.indices.size(), 1)))));
const float tile = float(texture_size) / float(std::max<uint32_t>(grid, 1));
volume->imported_texture_width = texture_size;
volume->imported_texture_height = texture_size;
volume->imported_texture_rgba.assign(size_t(texture_size) * size_t(texture_size) * 4, 0);
for (size_t idx = 0; idx < size_t(texture_size) * size_t(texture_size); ++idx) {
volume->imported_texture_rgba[idx * 4 + 0] = uint8_t((fallback_packed >> 24) & 0xFFu);
volume->imported_texture_rgba[idx * 4 + 1] = uint8_t((fallback_packed >> 16) & 0xFFu);
volume->imported_texture_rgba[idx * 4 + 2] = uint8_t((fallback_packed >> 8) & 0xFFu);
volume->imported_texture_rgba[idx * 4 + 3] = uint8_t(fallback_packed & 0xFFu);
}
volume->imported_texture_uv_valid.assign(its.indices.size(), 1);
volume->imported_texture_uvs_per_face.assign(its.indices.size() * 6, 0.f);
for (size_t tri_idx = 0; tri_idx < its.indices.size(); ++tri_idx) {
const uint32_t cell_x = uint32_t(tri_idx % grid);
const uint32_t cell_y = uint32_t(tri_idx / grid);
const float left = float(cell_x) * tile + 0.5f;
const float top = float(cell_y) * tile + 0.5f;
const float right = std::min(float(texture_size) - 0.5f, float(cell_x + 1) * tile - 0.5f);
const float bottom = std::min(float(texture_size) - 0.5f, float(cell_y + 1) * tile - 0.5f);
const size_t uv = tri_idx * 6;
volume->imported_texture_uvs_per_face[uv + 0] = left / float(texture_size);
volume->imported_texture_uvs_per_face[uv + 1] = top / float(texture_size);
volume->imported_texture_uvs_per_face[uv + 2] = right / float(texture_size);
volume->imported_texture_uvs_per_face[uv + 3] = top / float(texture_size);
volume->imported_texture_uvs_per_face[uv + 4] = left / float(texture_size);
volume->imported_texture_uvs_per_face[uv + 5] = bottom / float(texture_size);
}
const VolumeColorSource rgba_source = build_volume_color_source(*volume);
const ManagedRegionColorSource region_source = build_managed_region_color_source(*volume);
for (size_t tri_idx = 0; tri_idx < its.indices.size(); ++tri_idx) {
const stl_triangle_vertex_indices &tri = its.indices[tri_idx];
if (tri[0] < 0 || tri[1] < 0 || tri[2] < 0)
continue;
if (size_t(tri[0]) >= its.vertices.size() ||
size_t(tri[1]) >= its.vertices.size() ||
size_t(tri[2]) >= its.vertices.size())
continue;
const size_t uv_offset = tri_idx * 6;
const std::array<Vec2f, 3> uvs = unwrap_projection_uvs(std::array<Vec2f, 3>{
Vec2f(volume->imported_texture_uvs_per_face[uv_offset + 0], volume->imported_texture_uvs_per_face[uv_offset + 1]),
Vec2f(volume->imported_texture_uvs_per_face[uv_offset + 2], volume->imported_texture_uvs_per_face[uv_offset + 3]),
Vec2f(volume->imported_texture_uvs_per_face[uv_offset + 4], volume->imported_texture_uvs_per_face[uv_offset + 5])
});
const std::array<Vec3f, 3> vertices = {
its.vertices[size_t(tri[0])].cast<float>(),
its.vertices[size_t(tri[1])].cast<float>(),
its.vertices[size_t(tri[2])].cast<float>()
};
const float texture_width = float(volume->imported_texture_width);
const float texture_height = float(volume->imported_texture_height);
const std::array<Vec2f, 3> pixel_uvs = {
Vec2f(uvs[0].x() * texture_width, uvs[0].y() * texture_height),
Vec2f(uvs[1].x() * texture_width, uvs[1].y() * texture_height),
Vec2f(uvs[2].x() * texture_width, uvs[2].y() * texture_height)
};
const float texture_padding = 2.f;
const int padding_px = int(std::ceil(texture_padding));
int min_x = int(std::floor(std::min({ uvs[0].x(), uvs[1].x(), uvs[2].x() }) * texture_width)) - padding_px;
int max_x = int(std::ceil(std::max({ uvs[0].x(), uvs[1].x(), uvs[2].x() }) * texture_width)) + padding_px;
int min_y = int(std::floor(std::min({ uvs[0].y(), uvs[1].y(), uvs[2].y() }) * texture_height)) - padding_px;
int max_y = int(std::ceil(std::max({ uvs[0].y(), uvs[1].y(), uvs[2].y() }) * texture_height)) + padding_px;
const int cell_min_x = std::clamp(int(std::floor(float(cell_x) * tile)), 0, int(volume->imported_texture_width) - 1);
const int cell_max_x = std::clamp(int(std::ceil(float(cell_x + 1) * tile)) - 1, 0, int(volume->imported_texture_width) - 1);
const int cell_min_y = std::clamp(int(std::floor(float(cell_y) * tile)), 0, int(volume->imported_texture_height) - 1);
const int cell_max_y = std::clamp(int(std::ceil(float(cell_y + 1) * tile)) - 1, 0, int(volume->imported_texture_height) - 1);
min_x = std::clamp(min_x, cell_min_x, cell_max_x);
max_x = std::clamp(max_x, cell_min_x, cell_max_x);
min_y = std::clamp(min_y, cell_min_y, cell_max_y);
max_y = std::clamp(max_y, cell_min_y, cell_max_y);
for (int y_px = min_y; y_px <= max_y; ++y_px) {
for (int x_px = min_x; x_px <= max_x; ++x_px) {
Vec3f barycentric = Vec3f::Zero();
const Vec2f pixel(float(x_px) + 0.5f, float(y_px) + 0.5f);
if (!conservative_barycentric_weights_2d(pixel, pixel_uvs[0], pixel_uvs[1], pixel_uvs[2], texture_padding, barycentric))
continue;
const Vec3f point = vertices[0] * barycentric.x() +
vertices[1] * barycentric.y() +
vertices[2] * barycentric.z();
const ColorRGBA color = sample_managed_volume_color_source(*volume,
rgba_source,
region_source,
tri_idx,
point,
barycentric,
source_flags.use_rgba,
source_flags.use_image_texture,
source_flags.use_vertex_colors,
source_flags.use_color_regions,
fallback_color);
write_rgba_pixel(volume->imported_texture_rgba,
volume->imported_texture_width,
uint32_t(x_px),
uint32_t(y_px),
color);
}
}
}
refresh_imported_texture_storage(*volume);
changed = true;
}
return changed;
}
static bool convert_object_to_rgba_data(ModelObject &object, const ManagedColorDataCreateSource &source)
{
if (object_has_rgba_data(object))
return false;
bool changed = false;
const ManagedColorSourceFlags source_flags = managed_color_source_flags(source);
const ColorRGBA fallback_color = blank_color_for_managed_target(ManagedColorDataType::RgbaData);
for (ModelVolume *volume : object.volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
const indexed_triangle_set &its = volume->mesh().its;
if (its.indices.empty() || its.vertices.empty())
continue;
std::unique_ptr<ColorFacetsAnnotation> rgb_data = ColorFacetsAnnotation::make_temporary();
if (!rgb_data)
continue;
const VolumeColorSource rgba_source = build_volume_color_source(*volume);
const ManagedRegionColorSource region_source = build_managed_region_color_source(*volume);
TextureMappingColorSampler sampler = [volume, rgba_source, region_source, fallback_color, source_flags](size_t tri_idx,
const Vec3f &point,
const Vec3f &barycentric) {
return pack_vertex_color_rgba(sample_managed_volume_color_source(*volume,
rgba_source,
region_source,
tri_idx,
point,
barycentric,
source_flags.use_rgba,
source_flags.use_image_texture,
source_flags.use_vertex_colors,
source_flags.use_color_regions,
fallback_color));
};
bool sampled = false;
if (source_flags.use_image_texture && model_volume_has_bakeable_image_texture_data(volume)) {
const int safe_max_depth = texture_mapping_depth_for_budget(its.indices.size(), 7, 3200000);
TextureMappingColorSubdivisionDepths subdivision_depths = [volume, safe_max_depth](size_t tri_idx,
const std::array<Vec3f, 3> &) {
const int depth = texture_mapping_depth_from_span(texture_triangle_uv_pixel_span(volume, tri_idx), 8.f, safe_max_depth);
return std::make_pair(depth, depth);
};
sampled = rgb_data->set_from_triangle_sampler(*volume, sampler, safe_max_depth, 0.015f, subdivision_depths);
} else if ((source_flags.use_vertex_colors && !volume->imported_vertex_colors_rgba.empty()) ||
(source_flags.use_color_regions && !volume->mmu_segmentation_facets.empty())) {
const float target_edge = std::max(mesh_max_axis_span(its) / 160.f, 0.25f);
TextureMappingColorSubdivisionDepths subdivision_depths = [target_edge](size_t, const std::array<Vec3f, 3> &vertices) {
const int depth = texture_mapping_depth_from_span(triangle_max_edge_length(vertices), target_edge, 5);
return std::make_pair(depth, depth);
};
sampled = rgb_data->set_from_triangle_sampler(*volume, sampler, 5, 0.025f, subdivision_depths);
} else {
sampled = build_volume_rgb_data(*volume, fallback_color, *rgb_data);
}
if (!sampled && rgb_data->empty())
continue;
if (rgb_data->metadata_json().empty())
rgb_data->set_metadata_json(rgb_metadata_json(fallback_color));
if (volume->texture_mapping_color_facets.equals(*rgb_data))
continue;
volume->texture_mapping_color_facets.assign(*rgb_data);
changed = true;
}
if (changed)
assign_object_to_texture_mapping_zone(object);
return changed;
}
static bool append_dialog_vertex_colors_for_volume(const ModelVolume &volume,
std::vector<RGBA> &input_colors,
const ManagedColorDataCreateSource &source)
{
const indexed_triangle_set &its = volume.mesh().its;
if (its.vertices.empty())
return false;
const ManagedColorSourceFlags source_flags = managed_color_source_flags(source);
if (source_flags.use_vertex_colors && volume.imported_vertex_colors_rgba.size() == its.vertices.size()) {
input_colors.reserve(input_colors.size() + volume.imported_vertex_colors_rgba.size());
for (const uint32_t packed : volume.imported_vertex_colors_rgba) {
const ColorRGBA color = unpack_vertex_color_rgba_for_conversion(packed);
input_colors.emplace_back(RGBA{ color.r(), color.g(), color.b(), color.a() });
}
return true;
}
const ColorRGBA fallback_color = blank_color_for_managed_target(ManagedColorDataType::ColorRegions);
const VolumeColorSource rgba_source = build_volume_color_source(volume);
const ManagedRegionColorSource empty_region_source;
std::vector<std::array<float, 4>> accumulators(its.vertices.size(), { 0.f, 0.f, 0.f, 0.f });
std::vector<unsigned int> counts(its.vertices.size(), 0);
for (size_t tri_idx = 0; tri_idx < its.indices.size(); ++tri_idx) {
const stl_triangle_vertex_indices &tri = its.indices[tri_idx];
for (int corner = 0; corner < 3; ++corner) {
if (tri[corner] < 0 || size_t(tri[corner]) >= its.vertices.size())
continue;
Vec3f barycentric = Vec3f::Zero();
barycentric[corner] = 1.f;
const ColorRGBA color = sample_managed_volume_color_source(volume,
rgba_source,
empty_region_source,
tri_idx,
its.vertices[size_t(tri[corner])].cast<float>(),
barycentric,
source_flags.use_rgba,
source_flags.use_image_texture,
false,
false,
fallback_color);
std::array<float, 4> &accumulator = accumulators[size_t(tri[corner])];
accumulator[0] += color.r();
accumulator[1] += color.g();
accumulator[2] += color.b();
accumulator[3] += color.a();
++counts[size_t(tri[corner])];
}
}
input_colors.reserve(input_colors.size() + its.vertices.size());
for (size_t idx = 0; idx < its.vertices.size(); ++idx) {
ColorRGBA color = fallback_color;
if (counts[idx] > 0) {
const float inv = 1.f / float(counts[idx]);
color = ColorRGBA(accumulators[idx][0] * inv,
accumulators[idx][1] * inv,
accumulators[idx][2] * inv,
accumulators[idx][3] * inv);
}
input_colors.emplace_back(RGBA{ color.r(), color.g(), color.b(), color.a() });
}
return true;
}
static std::string encode_managed_region_state_to_hex(unsigned int state)
{
std::vector<int> nibbles;
if (state < 3U) {
nibbles.emplace_back(int(state) << 2);
} else {
nibbles.emplace_back(0x0C);
unsigned int remainder = state - 3U;
while (remainder >= 15U) {
nibbles.emplace_back(0x0F);
remainder -= 15U;
}
nibbles.emplace_back(int(remainder));
}
std::string encoded;
encoded.reserve(nibbles.size());
for (auto it = nibbles.rbegin(); it != nibbles.rend(); ++it) {
const int nibble = *it;
encoded.push_back(char(nibble < 10 ? ('0' + nibble) : ('A' + (nibble - 10))));
}
return encoded;
}
static unsigned char normalized_region_filament_id(unsigned char filament_id, unsigned char first_extruder_id)
{
if (filament_id == 0)
return first_extruder_id == 0 ? 1 : first_extruder_id;
return filament_id;
}
static bool set_volume_regions_from_vertex_filament_ids(ModelVolume &volume,
const std::vector<unsigned char> &vertex_filament_ids,
size_t offset,
unsigned char first_extruder_id)
{
const indexed_triangle_set &its = volume.mesh().its;
if (offset + its.vertices.size() > vertex_filament_ids.size())
return false;
first_extruder_id = first_extruder_id == 0 ? 1 : first_extruder_id;
volume.config.set("extruder", int(first_extruder_id));
volume.mmu_segmentation_facets.reset();
volume.mmu_segmentation_facets.reserve(int(its.indices.size()));
auto filament_id = [&vertex_filament_ids, offset, first_extruder_id](int vertex_idx) {
return normalized_region_filament_id(vertex_filament_ids[offset + size_t(vertex_idx)], first_extruder_id);
};
auto encoded = [](unsigned char id) {
return encode_managed_region_state_to_hex(unsigned(id));
};
auto safe_angle = [](const Vec3f &a, const Vec3f &b) {
if (a.squaredNorm() <= EPSILON || b.squaredNorm() <= EPSILON)
return 0.f;
return std::acos(std::clamp(a.normalized().dot(b.normalized()), -1.f, 1.f));
};
for (size_t tri_idx = 0; tri_idx < its.indices.size(); ++tri_idx) {
const stl_triangle_vertex_indices &tri = its.indices[tri_idx];
if (tri[0] < 0 || tri[1] < 0 || tri[2] < 0)
continue;
if (size_t(tri[0]) >= its.vertices.size() ||
size_t(tri[1]) >= its.vertices.size() ||
size_t(tri[2]) >= its.vertices.size())
continue;
const unsigned char id0 = filament_id(tri[0]);
const unsigned char id1 = filament_id(tri[1]);
const unsigned char id2 = filament_id(tri[2]);
if (id0 == first_extruder_id && id1 == first_extruder_id && id2 == first_extruder_id)
continue;
if (id0 == id1 && id1 == id2) {
volume.mmu_segmentation_facets.set_triangle_from_string(int(tri_idx), encoded(id0));
continue;
}
const std::string result0 = encoded(id0);
const std::string result1 = encoded(id1);
const std::string result2 = encoded(id2);
if (id0 != id1 && id1 != id2 && id0 != id2) {
const Vec3f v0 = its.vertices[size_t(tri[0])].cast<float>();
const Vec3f v1 = its.vertices[size_t(tri[1])].cast<float>();
const Vec3f v2 = its.vertices[size_t(tri[2])].cast<float>();
const float angle0 = safe_angle(v1 - v0, v2 - v0);
const float angle1 = safe_angle(v0 - v1, v2 - v1);
const float angle2 = PI - angle0 - angle1;
std::array<float, 3> angles = { angle0, angle1, angle2 };
int max_angle_vertex_index = 0;
for (size_t idx = 1; idx < angles.size(); ++idx)
if (angles[idx] > angles[size_t(max_angle_vertex_index)])
max_angle_vertex_index = int(idx);
if (max_angle_vertex_index == 0)
volume.mmu_segmentation_facets.set_triangle_from_string(int(tri_idx),
result0 + result1 + result2 + (result1 + result2 + "5") + "3");
else if (max_angle_vertex_index == 1)
volume.mmu_segmentation_facets.set_triangle_from_string(int(tri_idx),
result0 + result1 + result2 + (result0 + result2 + "9") + "3");
else
volume.mmu_segmentation_facets.set_triangle_from_string(int(tri_idx),
result0 + result1 + result2 + (result1 + result0 + "1") + "3");
continue;
}
if (id0 == id1)
volume.mmu_segmentation_facets.set_triangle_from_string(int(tri_idx), result2 + result0 + result0 + "A");
else if (id1 == id2)
volume.mmu_segmentation_facets.set_triangle_from_string(int(tri_idx), result0 + result1 + result2 + "2");
else if (id0 == id2)
volume.mmu_segmentation_facets.set_triangle_from_string(int(tri_idx), result1 + result0 + result0 + "6");
}
return true;
}
static bool apply_dialog_vertex_filaments_to_color_regions(ModelObject &object,
const std::vector<unsigned char> &vertex_filament_ids,
unsigned char first_extruder_id)
{
size_t offset = 0;
bool changed = false;
first_extruder_id = first_extruder_id == 0 ? 1 : first_extruder_id;
object.config.set("extruder", int(first_extruder_id));
for (ModelVolume *volume : object.volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
const size_t vertex_count = volume->mesh().its.vertices.size();
if (!set_volume_regions_from_vertex_filament_ids(*volume, vertex_filament_ids, offset, first_extruder_id))
return false;
offset += vertex_count;
changed = true;
}
return changed && offset == vertex_filament_ids.size();
}
static bool convert_object_to_color_regions(ModelObject &object, const ManagedColorDataCreateSource &source, wxWindow *parent)
{
if (object_has_color_regions(object))
return false;
std::vector<RGBA> input_colors;
for (const ModelVolume *volume : object.volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
append_dialog_vertex_colors_for_volume(*volume, input_colors, source);
}
if (input_colors.empty())
return false;
bool is_single_color = true;
const RGBA first_color = input_colors.front();
for (const RGBA &color : input_colors) {
if (color != first_color) {
is_single_color = false;
break;
}
}
std::vector<unsigned char> filament_ids;
unsigned char first_extruder_id = 1;
const std::vector<std::string> extruder_colours = wxGetApp().plater()->get_extruder_colors_from_plater_config();
ObjColorDialog color_dlg(parent, input_colors, is_single_color, extruder_colours, filament_ids, first_extruder_id);
if (color_dlg.ShowModal() != wxID_OK || filament_ids.size() != input_colors.size())
return false;
Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Create 3mf color regions", UndoRedo::SnapshotType::GizmoAction);
return apply_dialog_vertex_filaments_to_color_regions(object, filament_ids, first_extruder_id);
}
static bool convert_object_managed_color_data(ModelObject &object,
ManagedColorDataType type,
const ManagedColorDataCreateSource &source,
wxWindow *parent = nullptr)
{
switch (type) {
case ManagedColorDataType::ColorRegions:
return convert_object_to_color_regions(object, source, parent);
case ManagedColorDataType::VertexColors:
return convert_object_to_vertex_colors(object, source);
case ManagedColorDataType::ImageTexture:
return convert_object_to_image_texture(object, source);
case ManagedColorDataType::RgbaData:
return convert_object_to_rgba_data(object, source);
}
return false;
}
static void refresh_managed_color_data_object(GLCanvas3D &parent, ModelObject *object)
{
if (object == nullptr)
return;
parent.update_volumes_colors_by_extruder();
parent.set_as_dirty();
parent.request_extra_frame();
const ModelObjectPtrs &objects = wxGetApp().model().objects;
const size_t object_idx = size_t(std::find(objects.begin(), objects.end(), object) - objects.begin());
if (object_idx < objects.size()) {
wxGetApp().obj_list()->update_info_items(object_idx);
wxGetApp().plater()->get_partplate_list().notify_instance_update(object_idx, 0);
}
parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
}
class ColorDataManagementDialog : public wxDialog
{
public:
ColorDataManagementDialog(wxWindow *parent, GLCanvas3D &canvas, ModelObject *object, std::function<void()> on_object_changed = {})
: wxDialog(parent,
wxID_ANY,
_L("Manage Color Data for this object"),
wxDefaultPosition,
wxDefaultSize,
wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER)
, m_canvas(canvas)
, m_object(object)
, m_on_object_changed(std::move(on_object_changed))
{
wxBoxSizer *main_sizer = new wxBoxSizer(wxVERTICAL);
wxFlexGridSizer *grid = new wxFlexGridSizer(5, 8, 14);
grid->AddGrowableCol(2, 1);
grid->Add(new wxStaticText(this, wxID_ANY, _L("Type")), 0, wxALIGN_CENTER_VERTICAL);
grid->Add(new wxStaticText(this, wxID_ANY, _L("Status")), 0, wxALIGN_CENTER_VERTICAL);
grid->Add(new wxStaticText(this, wxID_ANY, _L("Size")), 0, wxALIGN_CENTER_VERTICAL);
grid->AddSpacer(1);
grid->AddSpacer(1);
add_row(grid, ManagedColorDataType::ColorRegions, managed_color_data_type_label(ManagedColorDataType::ColorRegions));
add_row(grid, ManagedColorDataType::VertexColors, managed_color_data_type_label(ManagedColorDataType::VertexColors));
add_row(grid, ManagedColorDataType::ImageTexture, managed_color_data_type_label(ManagedColorDataType::ImageTexture));
add_row(grid, ManagedColorDataType::RgbaData, managed_color_data_type_label(ManagedColorDataType::RgbaData));
main_sizer->Add(grid, 1, wxEXPAND | wxALL, 16);
main_sizer->Add(new wxStaticLine(this), 0, wxEXPAND | wxLEFT | wxRIGHT, 16);
wxStdDialogButtonSizer *buttons = new wxStdDialogButtonSizer();
wxButton *close_button = new wxButton(this, wxID_CLOSE, _L("Close"));
buttons->AddButton(close_button);
buttons->Realize();
main_sizer->Add(buttons, 0, wxEXPAND | wxALL, 16);
SetSizer(main_sizer);
refresh_rows();
Fit();
SetMinSize(GetSize());
CenterOnParent();
Bind(wxEVT_BUTTON, [this](wxCommandEvent &) { EndModal(wxID_CLOSE); }, wxID_CLOSE);
}
private:
struct Row
{
ManagedColorDataType type;
wxStaticText *status = nullptr;
wxStaticText *size = nullptr;
wxButton *clear = nullptr;
wxButton *create = nullptr;
};
void add_row(wxFlexGridSizer *grid, ManagedColorDataType type, const wxString &label)
{
wxStaticText *status = new wxStaticText(this, wxID_ANY, wxString());
wxStaticText *size = new wxStaticText(this, wxID_ANY, wxString());
wxButton *clear = new wxButton(this, wxID_ANY, _L("Clear"));
wxButton *create = new wxButton(this, wxID_ANY, _L("Create From..."));
grid->Add(new wxStaticText(this, wxID_ANY, label), 0, wxALIGN_CENTER_VERTICAL);
grid->Add(status, 0, wxALIGN_CENTER_VERTICAL);
grid->Add(size, 1, wxEXPAND | wxALIGN_CENTER_VERTICAL);
grid->Add(clear, 0, wxALIGN_CENTER_VERTICAL);
grid->Add(create, 0, wxALIGN_CENTER_VERTICAL);
clear->Bind(wxEVT_BUTTON, [this, type](wxCommandEvent &) { clear_data(type); });
create->Bind(wxEVT_BUTTON, [this, type, create](wxCommandEvent &) { show_create_menu(type, create); });
m_rows.push_back({ type, status, size, clear, create });
}
void refresh_rows()
{
const ManagedColorDataSummary summary = summarize_managed_color_data(m_object);
for (Row &row : m_rows) {
const bool has_data = managed_color_data_summary_has_type(summary, row.type);
row.status->SetLabel(has_data ? _L("Present") : _L("None"));
row.size->SetLabel(managed_color_data_size_text(summary, row.type));
row.clear->Enable(has_data);
row.create->Enable(m_object != nullptr && !has_data);
}
Layout();
Fit();
}
void clear_data(ManagedColorDataType type)
{
if (m_object == nullptr || !object_has_managed_color_data(*m_object, type))
return;
Plater::TakeSnapshot snapshot(wxGetApp().plater(), clear_snapshot_name(type), UndoRedo::SnapshotType::GizmoAction);
if (!clear_object_managed_color_data(*m_object, type))
return;
refresh_managed_color_data_object(m_canvas, m_object);
notify_object_changed();
refresh_rows();
}
void show_create_menu(ManagedColorDataType type, wxButton *button)
{
if (m_object == nullptr || object_has_managed_color_data(*m_object, type))
return;
wxMenu menu;
std::vector<std::pair<int, ManagedColorDataCreateSource>> sources;
const ManagedColorDataSummary summary = summarize_managed_color_data(m_object);
auto add_item = [&menu, &sources](const wxString &label, const ManagedColorDataCreateSource &source) {
const int id = wxWindow::NewControlId();
menu.Append(id, label);
sources.emplace_back(id, source);
};
const std::array<ManagedColorDataType, 4> types = {
ManagedColorDataType::ColorRegions,
ManagedColorDataType::VertexColors,
ManagedColorDataType::ImageTexture,
ManagedColorDataType::RgbaData
};
bool added_data_source = false;
for (const ManagedColorDataType source_type : types) {
if (source_type == type || !managed_color_data_summary_has_type(summary, source_type))
continue;
add_item(managed_color_data_type_label(source_type),
ManagedColorDataCreateSource{ std::optional<ManagedColorDataType>(source_type) });
added_data_source = true;
}
if (added_data_source)
menu.AppendSeparator();
add_item(_L("Blank Canvas"), ManagedColorDataCreateSource{});
menu.Bind(wxEVT_COMMAND_MENU_SELECTED, [this, type, sources](wxCommandEvent &event) {
for (const auto &source : sources) {
if (source.first == event.GetId()) {
create_data(type, source.second);
break;
}
}
});
button->PopupMenu(&menu, wxPoint(0, button->GetSize().GetHeight()));
}
void create_data(ManagedColorDataType type, const ManagedColorDataCreateSource &source)
{
if (m_object == nullptr || object_has_managed_color_data(*m_object, type) || (source.type && *source.type == type))
return;
if (type == ManagedColorDataType::ColorRegions) {
if (!convert_object_managed_color_data(*m_object, type, source, this))
return;
refresh_managed_color_data_object(m_canvas, m_object);
notify_object_changed();
refresh_rows();
return;
}
Plater::TakeSnapshot snapshot(wxGetApp().plater(), create_snapshot_name(type), UndoRedo::SnapshotType::GizmoAction);
if (!convert_object_managed_color_data(*m_object, type, source))
return;
refresh_managed_color_data_object(m_canvas, m_object);
notify_object_changed();
refresh_rows();
}
void notify_object_changed()
{
if (m_on_object_changed)
m_on_object_changed();
}
const char *clear_snapshot_name(ManagedColorDataType type) const
{
switch (type) {
case ManagedColorDataType::ColorRegions:
return "Clear 3mf color regions";
case ManagedColorDataType::VertexColors:
return "Clear vertex colors";
case ManagedColorDataType::ImageTexture:
return "Clear image texture data";
case ManagedColorDataType::RgbaData:
return "Clear RGBA data";
}
return "Clear color data";
}
const char *create_snapshot_name(ManagedColorDataType type) const
{
switch (type) {
case ManagedColorDataType::ColorRegions:
return "Create 3mf color regions";
case ManagedColorDataType::VertexColors:
return "Create vertex colors";
case ManagedColorDataType::ImageTexture:
return "Create image texture";
case ManagedColorDataType::RgbaData:
return "Create RGBA data";
}
return "Create color data";
}
GLCanvas3D &m_canvas;
ModelObject *m_object = nullptr;
std::function<void()> m_on_object_changed;
std::vector<Row> m_rows;
};
void GLGizmoMmuSegmentation::init_extruders_data(const std::vector<ColorRGBA> &extruder_colors)
{
const unsigned int old_selected_filament_id =
m_selected_extruder_idx < m_display_filament_ids.size() ? m_display_filament_ids[m_selected_extruder_idx] :
(m_selected_extruder_idx < m_extruders_colors.size() ? unsigned(m_selected_extruder_idx + 1) : 0);
m_extruders_colors = extruder_colors;
m_display_filament_ids = get_display_filament_ids(m_extruders_colors.size());
m_selected_extruder_idx = 0;
if (!m_display_filament_ids.empty()) {
auto selected_it = std::find(m_display_filament_ids.begin(), m_display_filament_ids.end(), old_selected_filament_id);
if (selected_it != m_display_filament_ids.end())
m_selected_extruder_idx = size_t(std::distance(m_display_filament_ids.begin(), selected_it));
}
// keep remap table consistent with current extruder count
m_extruder_remap.resize(m_display_filament_ids.size());
for (size_t i = 0; i < m_extruder_remap.size(); ++i)
m_extruder_remap[i] = i;
}
void GLGizmoMmuSegmentation::init_extruders_data()
{
init_extruders_data(get_extruders_colors());
}
bool GLGizmoMmuSegmentation::on_init()
{
// BBS
m_shortcut_key = WXK_CONTROL_N;
// FIXME: maybe should be using GUI::shortkey_ctrl_prefix() or equivalent?
const wxString ctrl = _L("Ctrl+");
// FIXME: maybe should be using GUI::shortkey_alt_prefix() or equivalent?
const wxString alt = _L("Alt+");
const wxString shift = _L("Shift+");
m_desc["clipping_of_view_caption"] = alt + _L("Mouse wheel");
m_desc["clipping_of_view"] = _L("Section view");
m_desc["reset_direction"] = _L("Reset direction");
m_desc["cursor_size_caption"] = ctrl + _L("Mouse wheel");
m_desc["cursor_size"] = _L("Pen size");
m_desc["cursor_type"] = _L("Pen shape");
m_desc["paint_caption"] = _L("Left mouse button");
m_desc["paint"] = _L("Paint");
m_desc["erase_caption"] = shift + _L("Left mouse button");
m_desc["erase"] = _L("Erase");
m_desc["shortcut_key_caption"] = _L("Key 1~9");
m_desc["shortcut_key"] = _L("Choose filament");
m_desc["edge_detection"] = _L("Edge detection");
m_desc["gap_area_caption"] = ctrl + _L("Mouse wheel");
m_desc["gap_area"] = _L("Gap area");
m_desc["perform"] = _L("Perform");
m_desc["remove_all"] = _L("Erase all painting");
m_desc["circle"] = _L("Circle");
m_desc["sphere"] = _L("Sphere");
m_desc["pointer"] = _L("Triangles");
m_desc["filaments"] = _L("Filaments");
m_desc["tool_type"] = _L("Tool type");
m_desc["tool_brush"] = _L("Brush");
m_desc["tool_smart_fill"] = _L("Smart fill");
m_desc["tool_bucket_fill"] = _L("Bucket fill");
m_desc["smart_fill_angle_caption"] = ctrl + _L("Mouse wheel");
m_desc["smart_fill_angle"] = _L("Smart fill angle");
m_desc["height_range_caption"] = ctrl + _L("Mouse wheel");
m_desc["height_range"] = _L("Height range");
//add toggle wire frame hint
m_desc["toggle_wireframe_caption"] = alt + shift + _L("Enter");
m_desc["toggle_wireframe"] = _L("Toggle Wireframe");
// Filament remapping descriptions
m_desc["perform_remap"] = _L("Remap filaments");
m_desc["remap"] = _L("Remap");
m_desc["cancel_remap"] = _L("Cancel");
init_extruders_data();
return true;
}
GLGizmoMmuSegmentation::GLGizmoMmuSegmentation(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id)
: GLGizmoPainterBase(parent, icon_filename, sprite_id), m_current_tool(ImGui::CircleButtonIcon)
{
}
void GLGizmoMmuSegmentation::render_painter_gizmo()
{
const Selection& selection = m_parent.get_selection();
glsafe(::glEnable(GL_BLEND));
glsafe(::glEnable(GL_DEPTH_TEST));
render_triangles(selection);
m_c->object_clipper()->render_cut();
m_c->instances_hider()->render_cut();
render_cursor();
glsafe(::glDisable(GL_BLEND));
}
void GLGizmoMmuSegmentation::data_changed(bool is_serializing)
{
GLGizmoPainterBase::data_changed(is_serializing);
if (m_state != On || wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() != ptFFF || wxGetApp().extruders_edited_cnt() <= 1)
return;
ModelObject* model_object = m_c->selection_info()->model_object();
const std::vector<ColorRGBA> current_extruder_colors = get_extruders_colors();
const int prev_extruders_count = int(m_extruders_colors.size());
const int current_extruders_count = int(current_extruder_colors.size());
const std::vector<unsigned int> current_display_filament_ids = get_display_filament_ids(current_extruder_colors.size());
if (prev_extruders_count != current_extruders_count) {
if (current_extruder_colors.size() > GLGizmoMmuSegmentation::EXTRUDERS_LIMIT)
show_notification_extruders_limit_exceeded();
this->init_extruders_data(current_extruder_colors);
// Reinitialize triangle selectors because of change of extruder count need also change the size of GLIndexedVertexArray
if (prev_extruders_count != current_extruders_count)
this->init_model_triangle_selectors();
}
else if (current_extruder_colors != m_extruders_colors) {
this->init_extruders_data(current_extruder_colors);
this->update_triangle_selectors_colors();
}
else if (current_display_filament_ids != m_display_filament_ids) {
this->init_extruders_data(current_extruder_colors);
}
else if (model_object != nullptr && get_extruder_id_for_volumes(*model_object) != m_volumes_extruder_idxs) {
this->init_model_triangle_selectors();
}
}
// BBS
bool GLGizmoMmuSegmentation::on_number_key_down(int number)
{
int extruder_idx = number - 1;
if (extruder_idx >= 0 && size_t(extruder_idx) < m_display_filament_ids.size())
m_selected_extruder_idx = extruder_idx;
return true;
}
bool GLGizmoMmuSegmentation::on_key_down_select_tool_type(int keyCode) {
switch (keyCode)
{
case 'F':
m_current_tool = ImGui::FillButtonIcon;
break;
case 'T':
m_current_tool = ImGui::TriangleButtonIcon;
break;
case 'S':
m_current_tool = ImGui::SphereButtonIcon;
break;
case 'C':
m_current_tool = ImGui::CircleButtonIcon;
break;
case 'H':
m_current_tool = ImGui::HeightRangeIcon;
break;
case 'G':
m_current_tool = ImGui::GapFillIcon;
break;
default:
return false;
break;
}
return true;
}
static void render_extruders_combo(const std::string& label,
const std::vector<std::string>& extruders,
const std::vector<ColorRGBA>& extruders_colors,
size_t& selection_idx)
{
assert(!extruders_colors.empty());
assert(extruders.size() == extruders_colors.size());
size_t selection_out = selection_idx;
// It is necessary to use BeginGroup(). Otherwise, when using SameLine() is called, then other items will be drawn inside the combobox.
ImGui::BeginGroup();
ImVec2 combo_pos = ImGui::GetCursorScreenPos();
if (ImGui::BeginCombo(label.c_str(), "")) {
for (size_t extruder_idx = 0; extruder_idx < extruders.size(); ++extruder_idx) {
ImGui::PushID(int(extruder_idx));
ImVec2 start_position = ImGui::GetCursorScreenPos();
if (ImGui::Selectable("", extruder_idx == selection_idx))
selection_out = extruder_idx;
ImGui::SameLine();
ImGuiStyle &style = ImGui::GetStyle();
float height = ImGui::GetTextLineHeight();
ImGui::GetWindowDrawList()->AddRectFilled(start_position, ImVec2(start_position.x + height + height / 2, start_position.y + height), ImGuiWrapper::to_ImU32(extruders_colors[extruder_idx]));
ImGui::GetWindowDrawList()->AddRect(start_position, ImVec2(start_position.x + height + height / 2, start_position.y + height), IM_COL32_BLACK);
ImGui::SetCursorScreenPos(ImVec2(start_position.x + height + height / 2 + style.FramePadding.x, start_position.y));
ImGui::Text("%s", extruders[extruder_idx].c_str());
ImGui::PopID();
}
ImGui::EndCombo();
}
ImVec2 backup_pos = ImGui::GetCursorScreenPos();
ImGuiStyle &style = ImGui::GetStyle();
ImGui::SetCursorScreenPos(ImVec2(combo_pos.x + style.FramePadding.x, combo_pos.y + style.FramePadding.y));
ImVec2 p = ImGui::GetCursorScreenPos();
float height = ImGui::GetTextLineHeight();
ImGui::GetWindowDrawList()->AddRectFilled(p, ImVec2(p.x + height + height / 2, p.y + height), ImGuiWrapper::to_ImU32(extruders_colors[selection_idx]));
ImGui::GetWindowDrawList()->AddRect(p, ImVec2(p.x + height + height / 2, p.y + height), IM_COL32_BLACK);
ImGui::SetCursorScreenPos(ImVec2(p.x + height + height / 2 + style.FramePadding.x, p.y));
ImGui::Text("%s", extruders[selection_out].c_str());
ImGui::SetCursorScreenPos(backup_pos);
ImGui::EndGroup();
selection_idx = selection_out;
}
void GLGizmoMmuSegmentation::show_tooltip_information(float caption_max, float x, float y)
{
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(std::string_view{": "}).x + 15.f;
float scale = m_parent.get_scale();
ImVec2 button_size = ImVec2(25 * scale, 25 * scale); // ORCA: Use exact resolution will prevent blur on icon
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0f);
ImGui::PushStyleVar(ImGuiStyleVar_FramePadding, {0, 0}); // ORCA: Dont add padding
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);
};
std::vector<std::string> tip_items;
switch (m_tool_type) {
case ToolType::BRUSH:
tip_items = {"paint", "erase", "cursor_size", "clipping_of_view", "toggle_wireframe"};
break;
case ToolType::BUCKET_FILL:
tip_items = {"paint", "erase", "smart_fill_angle", "clipping_of_view", "toggle_wireframe"};
break;
case ToolType::SMART_FILL:
// TODO:
break;
case ToolType::GAP_FILL:
tip_items = {"gap_area", "toggle_wireframe"};
break;
default:
break;
}
for (const auto &t : tip_items) draw_text_with_caption(m_desc.at(t + "_caption") + ": ", m_desc.at(t));
ImGui::EndTooltip();
}
ImGui::PopStyleVar(2);
}
void GLGizmoMmuSegmentation::on_render_input_window(float x, float y, float bottom_limit)
{
if (!m_c->selection_info()->model_object()) return;
const float approx_height = m_imgui->scaled(22.0f);
y = std::min(y, bottom_limit - approx_height);
GizmoImguiSetNextWIndowPos(x, y, ImGuiCond_Always);
wchar_t old_tool = m_current_tool;
// BBS
ImGuiWrapper::push_toolbar_style(m_parent.get_scale());
GizmoImguiBegin(get_name(), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar);
// First calculate width of all the texts that are could possibly be shown. We will decide set the dialog width based on that:
const float space_size = m_imgui->get_style_scaling() * 8;
const float clipping_slider_left = std::max(m_imgui->calc_text_size(m_desc.at("clipping_of_view")).x + m_imgui->scaled(1.5f),
m_imgui->calc_text_size(m_desc.at("reset_direction")).x + m_imgui->scaled(1.5f) + ImGui::GetStyle().FramePadding.x * 2);
const float cursor_slider_left = m_imgui->calc_text_size(m_desc.at("cursor_size")).x + m_imgui->scaled(1.5f);
const float smart_fill_slider_left = m_imgui->calc_text_size(m_desc.at("smart_fill_angle")).x + m_imgui->scaled(1.5f);
const float edge_detect_slider_left = m_imgui->calc_text_size(m_desc.at("edge_detection")).x + m_imgui->scaled(1.f);
const float gap_area_slider_left = m_imgui->calc_text_size(m_desc.at("gap_area")).x + m_imgui->scaled(1.5f) + space_size;
const float height_range_slider_left = m_imgui->calc_text_size(m_desc.at("height_range")).x + m_imgui->scaled(2.f);
const float remove_btn_width = m_imgui->calc_text_size(m_desc.at("remove_all")).x + m_imgui->scaled(1.f);
const float filter_btn_width = m_imgui->calc_text_size(m_desc.at("perform")).x + m_imgui->scaled(1.f);
const float remap_btn_width = m_imgui->calc_text_size(m_desc.at("perform_remap")).x + m_imgui->scaled(1.f);
const float buttons_width = remove_btn_width + filter_btn_width + remap_btn_width + m_imgui->scaled(2.f);
const float minimal_slider_width = m_imgui->scaled(4.f);
const float color_button_width = m_imgui->calc_text_size(std::string_view{""}).x + m_imgui->scaled(1.75f);
const size_t total_filament_count = m_extruders_colors.size();
const std::string max_filament_label = std::to_string(std::max<size_t>(total_filament_count, 1));
const ImVec2 max_filament_label_size = ImGui::CalcTextSize(max_filament_label.c_str(), NULL, true);
float caption_max = 0.f;
float total_text_max = 0.f;
for (const auto &t : std::array<std::string, 6>{"paint", "erase", "cursor_size", "smart_fill_angle", "height_range", "clipping_of_view"}) {
caption_max = std::max(caption_max, m_imgui->calc_text_size(m_desc[t + "_caption"]).x);
total_text_max = std::max(total_text_max, m_imgui->calc_text_size(m_desc[t]).x);
}
total_text_max += caption_max + m_imgui->scaled(1.f);
caption_max += m_imgui->scaled(1.f);
const float circle_max_width = std::max(clipping_slider_left,cursor_slider_left);
const float height_max_width = std::max(clipping_slider_left,height_range_slider_left);
const float sliders_left_width = std::max(smart_fill_slider_left,
std::max(cursor_slider_left, std::max(edge_detect_slider_left, std::max(gap_area_slider_left, std::max(height_range_slider_left,
clipping_slider_left))))) + space_size;
const float slider_icon_width = m_imgui->get_slider_icon_size().x;
float window_width = minimal_slider_width + sliders_left_width + slider_icon_width;
const int max_filament_items_per_line = 8;
const float empty_button_width = m_imgui->calc_button_size("").x;
const float filament_item_width = std::max(empty_button_width, max_filament_label_size.x + m_imgui->scaled(1.4f)) + m_imgui->scaled(1.5f);
window_width = std::max(window_width, total_text_max);
window_width = std::max(window_width, buttons_width);
window_width = std::max(window_width, max_filament_items_per_line * filament_item_width + +m_imgui->scaled(0.5f));
const float sliders_width = m_imgui->scaled(7.0f);
const float drag_left_width = ImGui::GetStyle().WindowPadding.x + sliders_width - space_size;
const float max_tooltip_width = ImGui::GetFontSize() * 20.0f;
ImDrawList * draw_list = ImGui::GetWindowDrawList();
ImVec2 pos = ImGui::GetCursorScreenPos();
static float color_button_high = 25.0;
draw_list->AddRectFilled({pos.x - 10.0f, pos.y - 7.0f}, {pos.x + window_width + ImGui::GetFrameHeight(), pos.y + color_button_high}, ImGui::GetColorU32(ImGuiCol_FrameBgActive, 1.0f), 5.0f);
float color_button = ImGui::GetCursorPos().y;
m_imgui->text(m_desc.at("filaments"));
float start_pos_x = ImGui::GetCursorPos().x;
size_t n_extruder_colors = std::min(GLGizmoMmuSegmentation::EXTRUDERS_LIMIT, m_display_filament_ids.size());
for (size_t extruder_idx = 0; extruder_idx < n_extruder_colors; ++extruder_idx) {
const unsigned int actual_filament_id = m_display_filament_ids[extruder_idx];
if (actual_filament_id == 0 || actual_filament_id > m_extruders_colors.size())
continue;
const ColorRGBA &extruder_color = m_extruders_colors[actual_filament_id - 1];
ImVec4 color_vec = ImGuiWrapper::to_ImVec4(extruder_color);
std::string color_label = std::string("##extruder color ") + std::to_string(extruder_idx);
std::string item_text = std::to_string(extruder_idx + 1);
const ImVec2 label_size = ImGui::CalcTextSize(item_text.c_str(), NULL, true);
const ImVec2 button_size(max_filament_label_size.x + m_imgui->scaled(0.5f), 0.f);
float button_offset = start_pos_x;
if (extruder_idx % max_filament_items_per_line != 0) {
button_offset += filament_item_width * (extruder_idx % max_filament_items_per_line);
ImGui::SameLine(button_offset);
}
// draw filament background
ImGuiColorEditFlags flags = ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoInputs | ImGuiColorEditFlags_NoLabel | ImGuiColorEditFlags_NoPicker | ImGuiColorEditFlags_NoTooltip;
if (m_selected_extruder_idx != extruder_idx) flags |= ImGuiColorEditFlags_NoBorder;
#ifdef __APPLE__
ImGui::PushStyleColor(ImGuiCol_FrameBg, ImGuiWrapper::COL_ORCA); // ORCA use orca color for selected filament border
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0f);
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 3.0);
bool color_picked = ImGui::ColorButton(color_label.c_str(), color_vec, flags, button_size);
ImGui::PopStyleVar(2);
ImGui::PopStyleColor(1);
#else
ImGui::PushStyleColor(ImGuiCol_FrameBg, ImGuiWrapper::COL_ORCA); // ORCA use orca color for selected filament border
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0);
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 2.0);
bool color_picked = ImGui::ColorButton(color_label.c_str(), color_vec, flags, button_size);
ImGui::PopStyleVar(2);
ImGui::PopStyleColor(1);
#endif
color_button_high = ImGui::GetCursorPos().y - color_button - 2.0;
if (color_picked) { m_selected_extruder_idx = extruder_idx; }
if (ImGui::IsItemHovered()) {
if (extruder_idx < 9)
m_imgui->tooltip(_L("Shortcut Key ") + std::to_string(extruder_idx + 1), max_tooltip_width);
else
m_imgui->tooltip(wxString::Format(_L("Filament %d"), int(extruder_idx + 1)), max_tooltip_width);
}
// draw filament id
float gray = 0.299 * extruder_color.r() + 0.587 * extruder_color.g() + 0.114 * extruder_color.b();
ImGui::SameLine(button_offset + (button_size.x - label_size.x) / 2.f);
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, {10.0,15.0});
if (gray * 255.f < 80.f)
ImGui::TextColored(ImVec4(1.0f, 1.0f, 1.0f, 1.0f), "%s", item_text.c_str());
else
ImGui::TextColored(ImVec4(0.0f, 0.0f, 0.0f, 1.0f), "%s", item_text.c_str());
ImGui::PopStyleVar();
}
//ImGui::NewLine();
ImGui::Dummy(ImVec2(0.0f, ImGui::GetFontSize() * 0.1));
if (n_extruder_colors > 0) {
int selected_filament = int(m_selected_extruder_idx) + 1;
ImGui::AlignTextToFramePadding();
m_imgui->text(_L("Selected filament"));
ImGui::SameLine();
ImGui::PushItemWidth(m_imgui->scaled(4.5f));
if (ImGui::InputInt("##selected_filament", &selected_filament, 1, 10, ImGuiInputTextFlags_CharsDecimal)) {
selected_filament = std::clamp(selected_filament, 1, int(n_extruder_colors));
m_selected_extruder_idx = size_t(selected_filament - 1);
}
ImGui::SameLine();
m_imgui->text(wxString::Format(_L("/ %d"), int(n_extruder_colors)));
ImGui::Dummy(ImVec2(0.0f, ImGui::GetFontSize() * 0.1));
}
m_imgui->text(m_desc.at("tool_type"));
std::array<wchar_t, 6> tool_ids;
tool_ids = { ImGui::CircleButtonIcon, ImGui::SphereButtonIcon, ImGui::TriangleButtonIcon, ImGui::HeightRangeIcon, ImGui::FillButtonIcon, ImGui::GapFillIcon };
std::array<wchar_t, 6> icons;
if (m_is_dark_mode)
icons = { ImGui::CircleButtonDarkIcon, ImGui::SphereButtonDarkIcon, ImGui::TriangleButtonDarkIcon, ImGui::HeightRangeDarkIcon, ImGui::FillButtonDarkIcon, ImGui::GapFillDarkIcon };
else
icons = { ImGui::CircleButtonIcon, ImGui::SphereButtonIcon, ImGui::TriangleButtonIcon, ImGui::HeightRangeIcon, ImGui::FillButtonIcon, ImGui::GapFillIcon };
std::array<wxString, 6> tool_tips = { _L("Circle"), _L("Sphere"), _L("Triangle"), _L("Height Range"), _L("Fill"), _L("Gap Fill") };
for (int i = 0; i < tool_ids.size(); i++) {
std::string str_label = std::string("");
std::wstring btn_name = icons[i] + boost::nowide::widen(str_label);
if (i != 0) ImGui::SameLine((empty_button_width + m_imgui->scaled(1.75f)) * i + m_imgui->scaled(1.5f));
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0);
ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.f, 0.f, 0.f, 0.f)); // ORCA Removes button background on dark mode
ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.f, 1.f, 1.f, 1.f)); // ORCA Fixes icon rendered without colors while using Light theme
if (m_current_tool == tool_ids[i]) {
ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.f, 0.59f, 0.53f, 0.25f)); // ORCA use orca color for selected tool / brush
ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.f, 0.59f, 0.53f, 0.25f)); // ORCA use orca color for selected tool / brush
ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.f, 0.59f, 0.53f, 0.30f)); // ORCA use orca color for selected tool / brush
ImGui::PushStyleColor(ImGuiCol_Border, ImGuiWrapper::COL_ORCA); // ORCA use orca color for border on selected tool / brush
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 1.0);
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 1.0);
}
bool btn_clicked = ImGui::Button(into_u8(btn_name).c_str());
if (m_current_tool == tool_ids[i])
{
ImGui::PopStyleColor(4);
ImGui::PopStyleVar(2);
}
ImGui::PopStyleColor(2);
ImGui::PopStyleVar(1);
if (btn_clicked && m_current_tool != tool_ids[i]) {
m_current_tool = tool_ids[i];
for (auto &triangle_selector : m_triangle_selectors) {
triangle_selector->seed_fill_unselect_all_triangles();
triangle_selector->request_update_render_data();
}
}
if (ImGui::IsItemHovered()) {
m_imgui->tooltip(tool_tips[i], max_tooltip_width);
}
}
ImGui::Dummy(ImVec2(0.0f, ImGui::GetFontSize() * 0.1));
if (m_current_tool != old_tool)
this->tool_changed(old_tool, m_current_tool);
if (m_current_tool == ImGui::CircleButtonIcon || m_current_tool == ImGui::SphereButtonIcon) {
if (m_current_tool == ImGui::CircleButtonIcon)
m_cursor_type = TriangleSelector::CursorType::CIRCLE;
else
m_cursor_type = TriangleSelector::CursorType::SPHERE;
m_tool_type = ToolType::BRUSH;
ImGui::AlignTextToFramePadding();
m_imgui->text(m_desc.at("cursor_size"));
ImGui::SameLine(circle_max_width);
ImGui::PushItemWidth(sliders_width);
m_imgui->bbl_slider_float_style("##cursor_radius", &m_cursor_radius, CursorRadiusMin, CursorRadiusMax, "%.2f", 1.0f, true);
ImGui::SameLine(drag_left_width + circle_max_width);
ImGui::PushItemWidth(1.5 * slider_icon_width);
ImGui::BBLDragFloat("##cursor_radius_input", &m_cursor_radius, 0.05f, 0.0f, 0.0f, "%.2f");
ImGui::Separator();
if (m_c->object_clipper()->get_position() == 0.f) {
ImGui::AlignTextToFramePadding();
m_imgui->text(m_desc.at("clipping_of_view"));
}
else {
if (m_imgui->button(m_desc.at("reset_direction"))) {
wxGetApp().CallAfter([this]() {
m_c->object_clipper()->set_position_by_ratio(-1., false);
});
}
}
auto clp_dist = float(m_c->object_clipper()->get_position());
ImGui::SameLine(circle_max_width);
ImGui::PushItemWidth(sliders_width);
bool slider_clp_dist = m_imgui->bbl_slider_float_style("##clp_dist", &clp_dist, 0.f, 1.f, "%.2f", 1.0f, true);
ImGui::SameLine(drag_left_width + circle_max_width);
ImGui::PushItemWidth(1.5 * slider_icon_width);
bool b_clp_dist_input = ImGui::BBLDragFloat("##clp_dist_input", &clp_dist, 0.05f, 0.0f, 0.0f, "%.2f");
if (slider_clp_dist || b_clp_dist_input) { m_c->object_clipper()->set_position_by_ratio(clp_dist, true); }
} else if (m_current_tool == ImGui::TriangleButtonIcon) {
m_cursor_type = TriangleSelector::CursorType::POINTER;
m_tool_type = ToolType::BRUSH;
if (m_c->object_clipper()->get_position() == 0.f) {
ImGui::AlignTextToFramePadding();
m_imgui->text(m_desc.at("clipping_of_view"));
}
else {
if (m_imgui->button(m_desc.at("reset_direction"))) {
wxGetApp().CallAfter([this]() {
m_c->object_clipper()->set_position_by_ratio(-1., false);
});
}
}
auto clp_dist = float(m_c->object_clipper()->get_position());
ImGui::SameLine(clipping_slider_left);
ImGui::PushItemWidth(sliders_width);
bool slider_clp_dist = m_imgui->bbl_slider_float_style("##clp_dist", &clp_dist, 0.f, 1.f, "%.2f", 1.0f, true);
ImGui::SameLine(drag_left_width + clipping_slider_left);
ImGui::PushItemWidth(1.5 * slider_icon_width);
bool b_clp_dist_input = ImGui::BBLDragFloat("##clp_dist_input", &clp_dist, 0.05f, 0.0f, 0.0f, "%.2f");
if (slider_clp_dist || b_clp_dist_input) { m_c->object_clipper()->set_position_by_ratio(clp_dist, true); }
} else if (m_current_tool == ImGui::FillButtonIcon) {
m_cursor_type = TriangleSelector::CursorType::POINTER;
m_imgui->bbl_checkbox(m_desc["edge_detection"], m_detect_geometry_edge);
m_tool_type = ToolType::BUCKET_FILL;
if (m_detect_geometry_edge) {
ImGui::AlignTextToFramePadding();
m_imgui->text(m_desc["smart_fill_angle"]);
std::string format_str = std::string("%.f") + I18N::translate_utf8("°", "Face angle threshold,"
"placed after the number with no whitespace in between.");
ImGui::SameLine(sliders_left_width);
ImGui::PushItemWidth(sliders_width);
if (m_imgui->bbl_slider_float_style("##smart_fill_angle", &m_smart_fill_angle, SmartFillAngleMin, SmartFillAngleMax, format_str.data(), 1.0f, true))
for (auto &triangle_selector : m_triangle_selectors) {
triangle_selector->seed_fill_unselect_all_triangles();
triangle_selector->request_update_render_data();
}
ImGui::SameLine(drag_left_width + sliders_left_width);
ImGui::PushItemWidth(1.5 * slider_icon_width);
ImGui::BBLDragFloat("##smart_fill_angle_input", &m_smart_fill_angle, 0.05f, 0.0f, 0.0f, "%.2f");
} else {
// set to negative value to disable edge detection
m_smart_fill_angle = -1.f;
}
ImGui::Separator();
if (m_c->object_clipper()->get_position() == 0.f) {
ImGui::AlignTextToFramePadding();
m_imgui->text(m_desc.at("clipping_of_view"));
}
else {
if (m_imgui->button(m_desc.at("reset_direction"))) {
wxGetApp().CallAfter([this]() {
m_c->object_clipper()->set_position_by_ratio(-1., false);
});
}
}
auto clp_dist = float(m_c->object_clipper()->get_position());
ImGui::SameLine(sliders_left_width);
ImGui::PushItemWidth(sliders_width);
bool slider_clp_dist = m_imgui->bbl_slider_float_style("##clp_dist", &clp_dist, 0.f, 1.f, "%.2f", 1.0f, true);
ImGui::SameLine(drag_left_width + sliders_left_width);
ImGui::PushItemWidth(1.5 * slider_icon_width);
bool b_clp_dist_input = ImGui::BBLDragFloat("##clp_dist_input", &clp_dist, 0.05f, 0.0f, 0.0f, "%.2f");
if (slider_clp_dist || b_clp_dist_input) { m_c->object_clipper()->set_position_by_ratio(clp_dist, true);}
} else if (m_current_tool == ImGui::HeightRangeIcon) {
m_tool_type = ToolType::BRUSH;
m_cursor_type = TriangleSelector::CursorType::HEIGHT_RANGE;
ImGui::AlignTextToFramePadding();
m_imgui->text(m_desc["height_range"] + ":");
ImGui::SameLine(height_max_width);
ImGui::PushItemWidth(sliders_width);
std::string format_str = std::string("%.2f") + I18N::translate_utf8("mm", "Heigh range," "Facet in [cursor z, cursor z + height] will be selected.");
m_imgui->bbl_slider_float_style("##cursor_height", &m_cursor_height, CursorHeightMin, CursorHeightMax, format_str.data(), 1.0f, true);
ImGui::SameLine(drag_left_width + height_max_width);
ImGui::PushItemWidth(1.5 * slider_icon_width);
ImGui::BBLDragFloat("##cursor_height_input", &m_cursor_height, 0.05f, 0.0f, 0.0f, "%.2f");
ImGui::Separator();
if (m_c->object_clipper()->get_position() == 0.f) {
ImGui::AlignTextToFramePadding();
m_imgui->text(m_desc.at("clipping_of_view"));
}
else {
if (m_imgui->button(m_desc.at("reset_direction"))) {
wxGetApp().CallAfter([this]() {
m_c->object_clipper()->set_position_by_ratio(-1., false);
});
}
}
auto clp_dist = float(m_c->object_clipper()->get_position());
ImGui::SameLine(height_max_width);
ImGui::PushItemWidth(sliders_width);
bool slider_clp_dist = m_imgui->bbl_slider_float_style("##clp_dist", &clp_dist, 0.f, 1.f, "%.2f", 1.0f, true);
ImGui::SameLine(drag_left_width + height_max_width);
ImGui::PushItemWidth(1.5 * slider_icon_width);
bool b_clp_dist_input = ImGui::BBLDragFloat("##clp_dist_input", &clp_dist, 0.05f, 0.0f, 0.0f, "%.2f");
if (slider_clp_dist || b_clp_dist_input) { m_c->object_clipper()->set_position_by_ratio(clp_dist, true); }
}
else if (m_current_tool == ImGui::GapFillIcon) {
m_tool_type = ToolType::GAP_FILL;
m_cursor_type = TriangleSelector::CursorType::POINTER;
ImGui::AlignTextToFramePadding();
m_imgui->text(m_desc["gap_area"] + ":");
ImGui::SameLine(gap_area_slider_left);
ImGui::PushItemWidth(sliders_width);
std::string format_str = std::string("%.2f") + I18N::translate_utf8("", "Triangle patch area threshold,""triangle patch will be merged to neighbor if its area is less than threshold");
m_imgui->bbl_slider_float_style("##gap_area", &TriangleSelectorPatch::gap_area, TriangleSelectorPatch::GapAreaMin, TriangleSelectorPatch::GapAreaMax, format_str.data(), 1.0f, true);
ImGui::SameLine(drag_left_width + gap_area_slider_left);
ImGui::PushItemWidth(1.5 * slider_icon_width);
ImGui::BBLDragFloat("##gap_area_input", &TriangleSelectorPatch::gap_area, 0.05f, 0.0f, 0.0f, "%.2f");
}
ImGui::Separator();
if(m_imgui->bbl_checkbox(_L("Vertical"), m_vertical_only)){
if(m_vertical_only){
m_horizontal_only = false;
}
}
if(m_imgui->bbl_checkbox(_L("Horizontal"), m_horizontal_only)){
if(m_horizontal_only){
m_vertical_only = false;
}
}
ImGui::Separator();
const bool can_convert_regions_to_vertex_colors = selected_object_has_painted_regions();
m_imgui->disabled_begin(!can_convert_regions_to_vertex_colors);
if (m_imgui->button(_L("Convert regions to vertex colors")))
convert_selected_regions_to_vertex_colors();
if (ImGui::IsItemHovered()) {
if (can_convert_regions_to_vertex_colors)
m_imgui->tooltip(_L("Convert painted color regions into imported vertex color data, clear the regions, and assign a texture mapping zone."), max_tooltip_width);
else
m_imgui->tooltip(_L("This object does not have painted color regions."), max_tooltip_width);
}
m_imgui->disabled_end();
ImGui::Separator();
const bool can_apply_stored_vertex_colors = selected_object_has_imported_vertex_colors();
m_imgui->disabled_begin(!can_apply_stored_vertex_colors);
if (m_imgui->button(_L("Convert vertex colors to regions (will erase painting)")))
open_obj_vertex_color_mapping_dialog();
if (ImGui::IsItemHovered()) {
if (can_apply_stored_vertex_colors)
m_imgui->tooltip(_L("Open OBJ color mapping dialog using stored imported vertex colors."), max_tooltip_width);
else
m_imgui->tooltip(_L("This object does not have stored imported vertex colors."), max_tooltip_width);
}
m_imgui->disabled_end();
ImGui::Separator();
if (m_imgui->button(m_desc.at("perform_remap"))) {
m_show_filament_remap_ui = !m_show_filament_remap_ui;
if (m_show_filament_remap_ui) {
// reset remap to identity on opening
m_extruder_remap.resize(m_extruders_colors.size());
for (size_t i = 0; i < m_extruder_remap.size(); ++i)
m_extruder_remap[i] = i;
}
}
// Render filament swap UI if enabled
if (m_show_filament_remap_ui) {
ImGui::Separator();
render_filament_remap_ui(window_width, max_tooltip_width);
}
ImGui::Separator();
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(6.0f, 10.0f));
float get_cur_y = ImGui::GetContentRegionMax().y + ImGui::GetFrameHeight() + y;
show_tooltip_information(caption_max, 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();
if (m_current_tool == ImGui::GapFillIcon) {
if (m_imgui->button(m_desc.at("perform"))) {
Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Gap fill", UndoRedo::SnapshotType::GizmoAction);
for (int i = 0; i < m_triangle_selectors.size(); i++) {
TriangleSelectorPatch* ts_mm = dynamic_cast<TriangleSelectorPatch*>(m_triangle_selectors[i].get());
ts_mm->update_selector_triangles();
ts_mm->request_update_render_data(true);
}
update_model_object();
m_parent.set_as_dirty();
}
ImGui::SameLine();
}
if (m_imgui->button(m_desc.at("remove_all"))) {
Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Reset selection", UndoRedo::SnapshotType::GizmoAction);
ModelObject * mo = m_c->selection_info()->model_object();
int idx = -1;
for (ModelVolume *mv : mo->volumes)
if (mv->is_model_part()) {
++idx;
m_triangle_selectors[idx]->reset();
m_triangle_selectors[idx]->request_update_render_data(true);
}
update_model_object();
m_parent.set_as_dirty();
}
ImGui::PopStyleVar(2);
GizmoImguiEnd();
// BBS
ImGuiWrapper::pop_toolbar_style();
}
void GLGizmoMmuSegmentation::update_model_object()
{
bool updated = false;
ModelObject* mo = m_c->selection_info()->model_object();
int idx = -1;
for (ModelVolume* mv : mo->volumes) {
if (! mv->is_model_part())
continue;
++idx;
updated |= mv->mmu_segmentation_facets.set(*m_triangle_selectors[idx].get());
}
if (updated) {
const size_t num_physical = static_cast<size_t>(std::max(wxGetApp().filaments_cnt(), 0));
size_t num_total = num_physical;
if (wxGetApp().preset_bundle != nullptr)
num_total = wxGetApp().preset_bundle->texture_mapping_zones.total_filaments(num_physical);
size_t max_used_state = 0;
for (const ModelVolume *mv : mo->volumes) {
if (!mv->is_model_part())
continue;
const auto &used_states = mv->mmu_segmentation_facets.get_data().used_states;
for (size_t state_idx = static_cast<size_t>(EnforcerBlockerType::Extruder1); state_idx < used_states.size(); ++state_idx) {
if (used_states[state_idx])
max_used_state = std::max(max_used_state, state_idx);
}
}
if (max_used_state > num_physical) {
BOOST_LOG_TRIVIAL(warning) << "GLGizmoMmuSegmentation::update_model_object painted virtual extruder state detected"
<< " max_used_state=" << max_used_state
<< " physical_filaments=" << num_physical
<< " total_filaments=" << num_total;
}
const ModelObjectPtrs &mos = wxGetApp().model().objects;
size_t obj_idx = std::find(mos.begin(), mos.end(), mo) - mos.begin();
wxGetApp().obj_list()->update_info_items(obj_idx);
wxGetApp().plater()->get_partplate_list().notify_instance_update(obj_idx, 0);
m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
}
}
void GLGizmoMmuSegmentation::init_model_triangle_selectors()
{
const ModelObject *mo = m_c->selection_info()->model_object();
m_triangle_selectors.clear();
m_volumes_extruder_idxs.clear();
// Don't continue when extruders colors are not initialized
if(m_extruders_colors.empty())
return;
// BBS: Don't continue when model object is null
if (mo == nullptr)
return;
for (const ModelVolume *mv : mo->volumes) {
if (!mv->is_model_part())
continue;
int extruder_idx = (mv->extruder_id() > 0) ? mv->extruder_id() - 1 : 0;
std::vector<ColorRGBA> ebt_colors;
ebt_colors.push_back(m_extruders_colors[size_t(extruder_idx)]);
ebt_colors.insert(ebt_colors.end(), m_extruders_colors.begin(), m_extruders_colors.end());
// This mesh does not account for the possible Z up SLA offset.
const TriangleMesh* mesh = &mv->mesh();
m_triangle_selectors.emplace_back(std::make_unique<TriangleSelectorPatch>(*mesh, mv, ebt_colors, 0.2));
// Reset of TriangleSelector is done inside TriangleSelectorMmGUI's constructor, so we don't need it to perform it again in deserialize().
EnforcerBlockerType max_ebt = (EnforcerBlockerType)std::min(m_extruders_colors.size(), (size_t)EnforcerBlockerType::ExtruderMax);
m_triangle_selectors.back()->deserialize(mv->mmu_segmentation_facets.get_data(), false, max_ebt);
m_triangle_selectors.back()->request_update_render_data();
m_triangle_selectors.back()->set_wireframe_needed(true);
m_volumes_extruder_idxs.push_back(mv->extruder_id());
}
}
void GLGizmoMmuSegmentation::update_triangle_selectors_colors()
{
for (int i = 0; i < m_triangle_selectors.size(); i++) {
TriangleSelectorPatch* selector = dynamic_cast<TriangleSelectorPatch*>(m_triangle_selectors[i].get());
int extruder_idx = m_volumes_extruder_idxs[i];
int extruder_color_idx = std::max(0, extruder_idx - 1);
std::vector<ColorRGBA> ebt_colors;
ebt_colors.push_back(m_extruders_colors[extruder_color_idx]);
ebt_colors.insert(ebt_colors.end(), m_extruders_colors.begin(), m_extruders_colors.end());
selector->set_ebt_colors(ebt_colors);
}
}
void GLGizmoMmuSegmentation::update_from_model_object(bool first_update)
{
wxBusyCursor wait;
// Extruder colors need to be reloaded before calling init_model_triangle_selectors to render painted triangles
// using colors from loaded 3MF and not from printer profile in Slicer.
const std::vector<ColorRGBA> current_extruder_colors = get_extruders_colors();
if (int prev_extruders_count = int(m_extruders_colors.size());
prev_extruders_count != int(current_extruder_colors.size()) || current_extruder_colors != m_extruders_colors)
this->init_extruders_data(current_extruder_colors);
this->init_model_triangle_selectors();
}
void GLGizmoMmuSegmentation::tool_changed(wchar_t old_tool, wchar_t new_tool)
{
if ((old_tool == ImGui::GapFillIcon && new_tool == ImGui::GapFillIcon) ||
(old_tool != ImGui::GapFillIcon && new_tool != ImGui::GapFillIcon))
return;
for (auto& selector_ptr : m_triangle_selectors) {
TriangleSelectorPatch* tsp = dynamic_cast<TriangleSelectorPatch*>(selector_ptr.get());
tsp->set_filter_state(new_tool == ImGui::GapFillIcon);
}
}
bool GLGizmoMmuSegmentation::selected_object_has_imported_vertex_colors() const
{
const ModelObject *object = m_c->selection_info()->model_object();
if (object == nullptr)
return false;
for (const ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
if (!volume->imported_vertex_colors_rgba.empty())
return true;
}
return false;
}
bool GLGizmoMmuSegmentation::selected_object_has_imported_texture_data() const
{
const ModelObject *object = m_c->selection_info()->model_object();
if (object == nullptr)
return false;
for (const ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
if (model_volume_has_imported_image_texture_data(volume))
return true;
}
return false;
}
bool GLGizmoMmuSegmentation::selected_object_has_bakeable_image_texture_data() const
{
const ModelObject *object = m_c->selection_info()->model_object();
if (object == nullptr)
return false;
for (const ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
if (model_volume_has_bakeable_image_texture_data(volume))
return true;
}
return false;
}
bool GLGizmoMmuSegmentation::selected_object_has_texture_mapping_color_data() const
{
const ModelObject *object = m_c->selection_info()->model_object();
if (object == nullptr)
return false;
for (const ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
if (!volume->texture_mapping_color_facets.empty())
return true;
}
return false;
}
bool GLGizmoMmuSegmentation::selected_object_has_painted_regions() const
{
for (const auto &selector : m_triangle_selectors) {
if (selector == nullptr)
continue;
const TriangleSelector::TriangleSplittingData data = selector->serialize();
for (size_t state_idx = static_cast<size_t>(EnforcerBlockerType::Extruder1); state_idx < data.used_states.size(); ++state_idx)
if (data.used_states[state_idx])
return true;
}
const ModelObject *object = m_c->selection_info()->model_object();
if (object == nullptr)
return false;
for (const ModelVolume *volume : object->volumes) {
if (volume != nullptr && volume->is_model_part() && !volume->mmu_segmentation_facets.empty())
return true;
}
return false;
}
void GLGizmoMmuSegmentation::open_obj_vertex_color_mapping_dialog()
{
ModelObject *object = m_c->selection_info()->model_object();
if (object == nullptr)
return;
ModelVolume *target_volume = nullptr;
for (ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
if (!volume->imported_vertex_colors_rgba.empty()) {
target_volume = volume;
break;
}
}
if (target_volume == nullptr)
return;
if (target_volume->mesh().its.vertices.size() != target_volume->imported_vertex_colors_rgba.size())
return;
std::vector<RGBA> input_colors;
input_colors.reserve(target_volume->imported_vertex_colors_rgba.size());
for (const uint32_t packed : target_volume->imported_vertex_colors_rgba) {
const float r = float((packed >> 24) & 0xFF) / 255.f;
const float g = float((packed >> 16) & 0xFF) / 255.f;
const float b = float((packed >> 8) & 0xFF) / 255.f;
const float a = float(packed & 0xFF) / 255.f;
input_colors.emplace_back(RGBA{r, g, b, a});
}
if (input_colors.empty())
return;
bool is_single_color = true;
const RGBA first_color = input_colors.front();
for (const RGBA &color : input_colors) {
if (color != first_color) {
is_single_color = false;
break;
}
}
std::vector<unsigned char> filament_ids;
unsigned char first_extruder_id = 1;
const std::vector<std::string> extruder_colours = wxGetApp().plater()->get_extruder_colors_from_plater_config();
ObjColorDialog color_dlg(nullptr, input_colors, is_single_color, extruder_colours, filament_ids, first_extruder_id);
if (color_dlg.ShowModal() != wxID_OK)
return;
if (filament_ids.empty())
return;
if (!Model::obj_import_vertex_color_deal_for_object(filament_ids, first_extruder_id, object))
return;
update_from_model_object();
m_parent.set_as_dirty();
const ModelObjectPtrs &objects = wxGetApp().model().objects;
const size_t object_idx = size_t(std::find(objects.begin(), objects.end(), object) - objects.begin());
if (object_idx < objects.size()) {
wxGetApp().obj_list()->update_info_items(object_idx);
wxGetApp().plater()->get_partplate_list().notify_instance_update(object_idx, 0);
}
m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
}
void GLGizmoMmuSegmentation::bake_selected_object_image_texture_to_vertex_colors()
{
ModelObject *object = m_c->selection_info()->model_object();
if (object == nullptr)
return;
bool baked = false;
Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Bake image texture to vertex colors", UndoRedo::SnapshotType::GizmoAction);
for (ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part() || !model_volume_has_bakeable_image_texture_data(volume))
continue;
const indexed_triangle_set &its = volume->mesh().its;
struct VertexColorAccumulator
{
double r = 0.0;
double g = 0.0;
double b = 0.0;
double a = 0.0;
double weight = 0.0;
};
std::vector<VertexColorAccumulator> accumulators(its.vertices.size());
for (size_t tri_idx = 0; tri_idx < its.indices.size(); ++tri_idx) {
if (volume->imported_texture_uv_valid[tri_idx] == 0)
continue;
const auto &tri = its.indices[tri_idx];
if (tri[0] < 0 || tri[1] < 0 || tri[2] < 0)
continue;
if (size_t(tri[0]) >= its.vertices.size() ||
size_t(tri[1]) >= its.vertices.size() ||
size_t(tri[2]) >= its.vertices.size())
continue;
const size_t uv_offset = tri_idx * 6;
const std::array<Vec2f, 3> uvs = {
Vec2f(volume->imported_texture_uvs_per_face[uv_offset + 0], volume->imported_texture_uvs_per_face[uv_offset + 1]),
Vec2f(volume->imported_texture_uvs_per_face[uv_offset + 2], volume->imported_texture_uvs_per_face[uv_offset + 3]),
Vec2f(volume->imported_texture_uvs_per_face[uv_offset + 4], volume->imported_texture_uvs_per_face[uv_offset + 5])
};
const Vec3f p0 = its.vertices[size_t(tri[0])].cast<float>();
const Vec3f p1 = its.vertices[size_t(tri[1])].cast<float>();
const Vec3f p2 = its.vertices[size_t(tri[2])].cast<float>();
const float area = 0.5f * (p1 - p0).cross(p2 - p0).norm();
const double weight = std::isfinite(area) && area > EPSILON ? double(area) : 1.0;
const std::array<int, 3> vertex_indices = { tri[0], tri[1], tri[2] };
for (size_t corner = 0; corner < 3; ++corner) {
const ColorRGBA color = sample_texture_rgba_for_vertex_bake(volume->imported_texture_rgba,
volume->imported_texture_width,
volume->imported_texture_height,
uvs[corner]);
VertexColorAccumulator &acc = accumulators[size_t(vertex_indices[corner])];
acc.r += double(color.r()) * weight;
acc.g += double(color.g()) * weight;
acc.b += double(color.b()) * weight;
acc.a += double(color.a()) * weight;
acc.weight += weight;
}
}
std::vector<uint32_t> vertex_colors;
vertex_colors.reserve(its.vertices.size());
for (size_t vertex_idx = 0; vertex_idx < its.vertices.size(); ++vertex_idx) {
const VertexColorAccumulator &acc = accumulators[vertex_idx];
if (acc.weight > 0.0) {
vertex_colors.emplace_back(pack_vertex_color_rgba(ColorRGBA(float(acc.r / acc.weight),
float(acc.g / acc.weight),
float(acc.b / acc.weight),
float(acc.a / acc.weight))));
} else if (vertex_idx < volume->imported_vertex_colors_rgba.size()) {
vertex_colors.emplace_back(volume->imported_vertex_colors_rgba[vertex_idx]);
} else {
vertex_colors.emplace_back(pack_vertex_color_rgba(ColorRGBA(1.f, 1.f, 1.f, 1.f)));
}
}
if (vertex_colors.size() != its.vertices.size())
continue;
volume->imported_vertex_colors_rgba = std::move(vertex_colors);
volume->imported_texture_uvs_per_face.clear();
volume->imported_texture_uv_valid.clear();
volume->imported_texture_rgba.clear();
volume->imported_texture_width = 0;
volume->imported_texture_height = 0;
baked = true;
}
if (!baked)
return;
for (auto &selector : m_triangle_selectors)
if (selector != nullptr)
selector->request_update_render_data(true);
update_from_model_object();
m_parent.update_volumes_colors_by_extruder();
m_parent.set_as_dirty();
const ModelObjectPtrs &objects = wxGetApp().model().objects;
const size_t object_idx = size_t(std::find(objects.begin(), objects.end(), object) - objects.begin());
if (object_idx < objects.size()) {
wxGetApp().obj_list()->update_info_items(object_idx);
wxGetApp().plater()->get_partplate_list().notify_instance_update(object_idx, 0);
}
m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
}
void GLGizmoMmuSegmentation::convert_selected_object_vertex_colors_to_texture_mapping_colors()
{
ModelObject *object = m_c->selection_info()->model_object();
if (object == nullptr)
return;
bool converted = false;
Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Convert vertex colors to RGB data", UndoRedo::SnapshotType::GizmoAction);
for (ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
const indexed_triangle_set &its = volume->mesh().its;
if (its.vertices.empty() ||
its.indices.empty() ||
volume->imported_vertex_colors_rgba.size() != its.vertices.size())
continue;
TextureMappingColorSampler sampler = [volume, &its](size_t tri_idx, const Vec3f &, const Vec3f &barycentric) {
if (tri_idx >= its.indices.size())
return 0xFFFFFFFFu;
const auto &tri = its.indices[tri_idx];
if (tri[0] < 0 || tri[1] < 0 || tri[2] < 0)
return 0xFFFFFFFFu;
if (size_t(tri[0]) >= volume->imported_vertex_colors_rgba.size() ||
size_t(tri[1]) >= volume->imported_vertex_colors_rgba.size() ||
size_t(tri[2]) >= volume->imported_vertex_colors_rgba.size())
return 0xFFFFFFFFu;
const ColorRGBA c0 = unpack_vertex_color_rgba_for_conversion(volume->imported_vertex_colors_rgba[size_t(tri[0])]);
const ColorRGBA c1 = unpack_vertex_color_rgba_for_conversion(volume->imported_vertex_colors_rgba[size_t(tri[1])]);
const ColorRGBA c2 = unpack_vertex_color_rgba_for_conversion(volume->imported_vertex_colors_rgba[size_t(tri[2])]);
return pack_vertex_color_rgba(ColorRGBA(c0.r() * barycentric.x() + c1.r() * barycentric.y() + c2.r() * barycentric.z(),
c0.g() * barycentric.x() + c1.g() * barycentric.y() + c2.g() * barycentric.z(),
c0.b() * barycentric.x() + c1.b() * barycentric.y() + c2.b() * barycentric.z(),
c0.a() * barycentric.x() + c1.a() * barycentric.y() + c2.a() * barycentric.z()));
};
const float target_edge = std::max(mesh_max_axis_span(its) / 160.f, 0.25f);
TextureMappingColorSubdivisionDepths subdivision_depths = [target_edge](size_t, const std::array<Vec3f, 3> &vertices) {
const int depth = texture_mapping_depth_from_span(triangle_max_edge_length(vertices), target_edge, 5);
return std::make_pair(depth, depth);
};
volume->texture_mapping_color_facets.set_from_triangle_sampler(*volume, sampler, 5, 0.025f, subdivision_depths);
if (volume->texture_mapping_color_facets.metadata_json().empty())
volume->texture_mapping_color_facets.set_metadata_json(rgb_metadata_json(ColorRGBA(1.f, 1.f, 1.f, 1.f)));
converted = true;
}
if (!converted)
return;
const unsigned int texture_mapping_filament_id = ensure_texture_mapping_zone();
if (texture_mapping_filament_id != 0) {
object->config.set("extruder", int(texture_mapping_filament_id));
for (ModelVolume *volume : object->volumes)
if (volume != nullptr && volume->is_model_part())
volume->config.set("extruder", int(texture_mapping_filament_id));
}
for (auto &selector : m_triangle_selectors)
if (selector != nullptr)
selector->request_update_render_data(true);
update_from_model_object();
m_parent.update_volumes_colors_by_extruder();
m_parent.set_as_dirty();
const ModelObjectPtrs &objects = wxGetApp().model().objects;
const size_t object_idx = size_t(std::find(objects.begin(), objects.end(), object) - objects.begin());
if (object_idx < objects.size()) {
wxGetApp().obj_list()->update_info_items(object_idx);
wxGetApp().plater()->get_partplate_list().notify_instance_update(object_idx, 0);
}
m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
}
void GLGizmoMmuSegmentation::convert_selected_object_image_texture_to_texture_mapping_colors()
{
ModelObject *object = m_c->selection_info()->model_object();
if (object == nullptr)
return;
bool converted = false;
Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Convert image texture to RGB data", UndoRedo::SnapshotType::GizmoAction);
for (ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part() || !model_volume_has_bakeable_image_texture_data(volume))
continue;
const indexed_triangle_set &its = volume->mesh().its;
TextureMappingColorSampler sampler = [volume, &its](size_t tri_idx, const Vec3f &, const Vec3f &barycentric) {
if (tri_idx >= its.indices.size() ||
tri_idx >= volume->imported_texture_uv_valid.size() ||
volume->imported_texture_uv_valid[tri_idx] == 0)
return 0xFFFFFFFFu;
const size_t uv_offset = tri_idx * 6;
if (uv_offset + 5 >= volume->imported_texture_uvs_per_face.size())
return 0xFFFFFFFFu;
const Vec2f uv0(volume->imported_texture_uvs_per_face[uv_offset + 0], volume->imported_texture_uvs_per_face[uv_offset + 1]);
const Vec2f uv1(volume->imported_texture_uvs_per_face[uv_offset + 2], volume->imported_texture_uvs_per_face[uv_offset + 3]);
const Vec2f uv2(volume->imported_texture_uvs_per_face[uv_offset + 4], volume->imported_texture_uvs_per_face[uv_offset + 5]);
const Vec2f uv = uv0 * barycentric.x() + uv1 * barycentric.y() + uv2 * barycentric.z();
return pack_vertex_color_rgba(sample_texture_rgba_for_vertex_bake(volume->imported_texture_rgba,
volume->imported_texture_width,
volume->imported_texture_height,
uv));
};
const int safe_max_depth = texture_mapping_depth_for_budget(its.indices.size(), 7, 3200000);
TextureMappingColorSubdivisionDepths subdivision_depths = [volume, safe_max_depth](size_t tri_idx, const std::array<Vec3f, 3> &) {
const int depth = texture_mapping_depth_from_span(texture_triangle_uv_pixel_span(volume, tri_idx), 8.f, safe_max_depth);
return std::make_pair(depth, depth);
};
volume->texture_mapping_color_facets.set_from_triangle_sampler(*volume, sampler, safe_max_depth, 0.015f, subdivision_depths);
if (volume->texture_mapping_color_facets.metadata_json().empty())
volume->texture_mapping_color_facets.set_metadata_json(rgb_metadata_json(ColorRGBA(1.f, 1.f, 1.f, 1.f)));
converted = true;
}
if (!converted)
return;
const unsigned int texture_mapping_filament_id = ensure_texture_mapping_zone();
if (texture_mapping_filament_id != 0) {
object->config.set("extruder", int(texture_mapping_filament_id));
for (ModelVolume *volume : object->volumes)
if (volume != nullptr && volume->is_model_part())
volume->config.set("extruder", int(texture_mapping_filament_id));
}
for (auto &selector : m_triangle_selectors)
if (selector != nullptr)
selector->request_update_render_data(true);
update_from_model_object();
m_parent.update_volumes_colors_by_extruder();
m_parent.set_as_dirty();
const ModelObjectPtrs &objects = wxGetApp().model().objects;
const size_t object_idx = size_t(std::find(objects.begin(), objects.end(), object) - objects.begin());
if (object_idx < objects.size()) {
wxGetApp().obj_list()->update_info_items(object_idx);
wxGetApp().plater()->get_partplate_list().notify_instance_update(object_idx, 0);
}
m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
}
void GLGizmoMmuSegmentation::convert_selected_regions_to_vertex_colors()
{
ModelObject *object = m_c->selection_info()->model_object();
if (object == nullptr || m_triangle_selectors.empty())
return;
std::vector<std::string> color_strings;
if (wxGetApp().plater() != nullptr)
color_strings = wxGetApp().plater()->get_extruder_colors_from_plater_config();
std::vector<ColorRGBA> filament_colors;
filament_colors.reserve(color_strings.size());
for (const std::string &color_string : color_strings) {
unsigned char rgba[4] = { 38, 166, 154, 255 };
BitmapCache::parse_color4(color_string, rgba);
filament_colors.emplace_back(float(rgba[0]) / 255.f,
float(rgba[1]) / 255.f,
float(rgba[2]) / 255.f,
float(rgba[3]) / 255.f);
}
if (filament_colors.empty())
filament_colors.emplace_back(0.15f, 0.65f, 0.6f, 1.f);
auto color_for_filament_id = [&filament_colors](unsigned int filament_id) {
if (filament_id >= 1 && filament_id <= filament_colors.size())
return filament_colors[filament_id - 1];
return filament_colors.front();
};
Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Convert regions to vertex colors", UndoRedo::SnapshotType::GizmoAction);
bool converted = false;
int selector_idx = -1;
for (ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
++selector_idx;
if (selector_idx < 0 || size_t(selector_idx) >= m_triangle_selectors.size() || m_triangle_selectors[size_t(selector_idx)] == nullptr)
continue;
const auto &its = volume->mesh().its;
if (its.vertices.empty() || its.indices.empty())
continue;
std::vector<std::vector<TriangleSelector::FacetStateTriangle>> triangles_per_type;
m_triangle_selectors[size_t(selector_idx)]->get_facet_triangles(triangles_per_type);
if (triangles_per_type.empty())
continue;
struct VertexColorAccumulator
{
double r = 0.0;
double g = 0.0;
double b = 0.0;
double a = 0.0;
double weight = 0.0;
};
std::vector<VertexColorAccumulator> accumulators(its.vertices.size());
bool accumulated_any = false;
const unsigned int base_filament_id = volume->extruder_id() > 0 ? unsigned(volume->extruder_id()) : 1u;
for (size_t state_idx = 0; state_idx < triangles_per_type.size(); ++state_idx) {
const unsigned int filament_id = state_idx == 0 ? base_filament_id : unsigned(state_idx);
ColorRGBA state_color = color_for_filament_id(filament_id);
state_color.a(1.f);
for (const TriangleSelector::FacetStateTriangle &triangle : triangles_per_type[state_idx]) {
if (triangle.source_triangle < 0)
continue;
const size_t source_triangle = size_t(triangle.source_triangle);
if (source_triangle >= its.indices.size())
continue;
const auto &source_indices = its.indices[source_triangle];
if (source_indices[0] < 0 || source_indices[1] < 0 || source_indices[2] < 0)
continue;
if (size_t(source_indices[0]) >= its.vertices.size() ||
size_t(source_indices[1]) >= its.vertices.size() ||
size_t(source_indices[2]) >= its.vertices.size())
continue;
const Vec3f source_p0 = its.vertices[size_t(source_indices[0])].cast<float>();
const Vec3f source_p1 = its.vertices[size_t(source_indices[1])].cast<float>();
const Vec3f source_p2 = its.vertices[size_t(source_indices[2])].cast<float>();
const Vec3f centroid = (triangle.vertices[0] + triangle.vertices[1] + triangle.vertices[2]) / 3.f;
Vec3f weights(1.f / 3.f, 1.f / 3.f, 1.f / 3.f);
if (!barycentric_weights_for_region_vertex_colors(centroid, source_p0, source_p1, source_p2, weights))
weights = Vec3f(1.f / 3.f, 1.f / 3.f, 1.f / 3.f);
weights.x() = std::max(0.f, weights.x());
weights.y() = std::max(0.f, weights.y());
weights.z() = std::max(0.f, weights.z());
const float weights_sum = weights.x() + weights.y() + weights.z();
if (weights_sum > EPSILON)
weights /= weights_sum;
else
weights = Vec3f(1.f / 3.f, 1.f / 3.f, 1.f / 3.f);
const float area = 0.5f * (triangle.vertices[1] - triangle.vertices[0]).cross(triangle.vertices[2] - triangle.vertices[0]).norm();
const double area_weight = std::max(double(area), 1e-6);
const std::array<float, 3> bary = { weights.x(), weights.y(), weights.z() };
for (size_t corner = 0; corner < 3; ++corner) {
VertexColorAccumulator &acc = accumulators[size_t(source_indices[corner])];
const double weight = area_weight * double(bary[corner]);
acc.r += double(state_color.r()) * weight;
acc.g += double(state_color.g()) * weight;
acc.b += double(state_color.b()) * weight;
acc.a += double(state_color.a()) * weight;
acc.weight += weight;
}
accumulated_any = true;
}
}
if (!accumulated_any)
continue;
const ColorRGBA fallback_color = color_for_filament_id(base_filament_id);
std::vector<uint32_t> vertex_colors;
vertex_colors.reserve(its.vertices.size());
for (const VertexColorAccumulator &acc : accumulators) {
if (acc.weight > 0.0) {
vertex_colors.emplace_back(pack_vertex_color_rgba(ColorRGBA(float(acc.r / acc.weight),
float(acc.g / acc.weight),
float(acc.b / acc.weight),
float(acc.a / acc.weight))));
} else {
vertex_colors.emplace_back(pack_vertex_color_rgba(fallback_color));
}
}
volume->imported_vertex_colors_rgba = std::move(vertex_colors);
volume->mmu_segmentation_facets.reset();
m_triangle_selectors[size_t(selector_idx)]->reset();
m_triangle_selectors[size_t(selector_idx)]->request_update_render_data(true);
converted = true;
}
if (!converted)
return;
const unsigned int texture_mapping_filament_id = ensure_texture_mapping_zone();
if (texture_mapping_filament_id != 0) {
object->config.set("extruder", int(texture_mapping_filament_id));
for (ModelVolume *volume : object->volumes)
if (volume != nullptr && volume->is_model_part())
volume->config.set("extruder", int(texture_mapping_filament_id));
}
update_from_model_object();
m_parent.update_volumes_colors_by_extruder();
m_parent.set_as_dirty();
const ModelObjectPtrs &objects = wxGetApp().model().objects;
const size_t object_idx = size_t(std::find(objects.begin(), objects.end(), object) - objects.begin());
if (object_idx < objects.size()) {
wxGetApp().obj_list()->update_info_items(object_idx);
wxGetApp().plater()->get_partplate_list().notify_instance_update(object_idx, 0);
}
m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
}
void GLGizmoMmuSegmentation::clear_selected_object_image_texture_data()
{
ModelObject *object = m_c->selection_info()->model_object();
if (object == nullptr)
return;
bool cleared = false;
Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Clear image texture data", UndoRedo::SnapshotType::GizmoAction);
for (ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part() || !model_volume_has_imported_image_texture_data(volume))
continue;
volume->imported_texture_uvs_per_face.clear();
volume->imported_texture_uv_valid.clear();
volume->imported_texture_rgba.clear();
volume->imported_texture_width = 0;
volume->imported_texture_height = 0;
cleared = true;
}
if (!cleared)
return;
for (auto &selector : m_triangle_selectors)
if (selector != nullptr)
selector->request_update_render_data(true);
update_from_model_object();
m_parent.update_volumes_colors_by_extruder();
m_parent.set_as_dirty();
const ModelObjectPtrs &objects = wxGetApp().model().objects;
const size_t object_idx = size_t(std::find(objects.begin(), objects.end(), object) - objects.begin());
if (object_idx < objects.size()) {
wxGetApp().obj_list()->update_info_items(object_idx);
wxGetApp().plater()->get_partplate_list().notify_instance_update(object_idx, 0);
}
m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
}
void GLGizmoMmuSegmentation::clear_selected_object_texture_mapping_color_data()
{
ModelObject *object = m_c->selection_info()->model_object();
if (object == nullptr)
return;
bool cleared = false;
Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Clear RGB data", UndoRedo::SnapshotType::GizmoAction);
for (ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part() || volume->texture_mapping_color_facets.empty())
continue;
volume->texture_mapping_color_facets.reset();
cleared = true;
}
if (!cleared)
return;
for (auto &selector : m_triangle_selectors)
if (selector != nullptr)
selector->request_update_render_data(true);
update_from_model_object();
m_parent.update_volumes_colors_by_extruder();
m_parent.set_as_dirty();
const ModelObjectPtrs &objects = wxGetApp().model().objects;
const size_t object_idx = size_t(std::find(objects.begin(), objects.end(), object) - objects.begin());
if (object_idx < objects.size()) {
wxGetApp().obj_list()->update_info_items(object_idx);
wxGetApp().plater()->get_partplate_list().notify_instance_update(object_idx, 0);
}
m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
}
PainterGizmoType GLGizmoMmuSegmentation::get_painter_type() const
{
return PainterGizmoType::MM_SEGMENTATION;
}
// BBS
ColorRGBA GLGizmoMmuSegmentation::get_cursor_hover_color() const
{
if (m_selected_extruder_idx < m_display_filament_ids.size()) {
const unsigned int actual_filament_id = m_display_filament_ids[m_selected_extruder_idx];
if (actual_filament_id >= 1 && actual_filament_id <= m_extruders_colors.size())
return m_extruders_colors[actual_filament_id - 1];
}
return m_extruders_colors.empty() ? ColorRGBA() : m_extruders_colors[0];
}
void GLGizmoMmuSegmentation::on_set_state()
{
GLGizmoPainterBase::on_set_state();
if (get_state() == Off) {
ModelObject* mo = m_c->selection_info()->model_object();
if (mo) Slic3r::save_object_mesh(*mo);
m_parent.post_event(SimpleEvent(EVT_GLCANVAS_FORCE_UPDATE));
}
}
wxString GLGizmoMmuSegmentation::handle_snapshot_action_name(bool shift_down, GLGizmoPainterBase::Button button_down) const
{
wxString action_name;
if (shift_down)
action_name = _L("Remove painted color");
else {
action_name = GUI::format(_L("Painted using: Filament %1%"), m_selected_extruder_idx + 1);
}
return action_name;
}
GLGizmoTrueColorPainting::GLGizmoTrueColorPainting(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id)
: GLGizmoPainterBase(parent, icon_filename, sprite_id)
{
}
bool GLGizmoTrueColorPainting::on_init()
{
m_cursor_type = TriangleSelector::CursorType::SPHERE;
m_tool_type = ToolType::BRUSH;
m_triangle_splitting_enabled = true;
m_cursor_radius = 1.f;
sync_active_color_mode_from_rgb(true);
return true;
}
void GLGizmoTrueColorPainting::on_opening()
{
update_selected_object_color_state();
if (m_color_input_mode == ColorInputMode::FilamentColors)
sync_active_color_mode_from_rgb(true);
}
void GLGizmoTrueColorPainting::on_shutdown()
{
m_color_picker_active = false;
clear_brush_stroke_points();
m_preview_rgb_data_by_volume.clear();
m_color_picker_source_cache.clear();
m_parent.use_slope(false);
m_parent.toggle_model_objects_visibility(true);
}
PainterGizmoType GLGizmoTrueColorPainting::get_painter_type() const
{
return PainterGizmoType::TRUE_COLOR;
}
std::string GLGizmoTrueColorPainting::on_get_name() const
{
return _u8L("True Color Painting");
}
bool GLGizmoTrueColorPainting::on_is_selectable() const
{
return wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptFFF;
}
bool GLGizmoTrueColorPainting::on_is_activable() const
{
const Selection& selection = m_parent.get_selection();
return wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptFFF &&
!selection.is_empty() &&
(selection.is_single_full_instance() || selection.is_any_volume());
}
ColorRGBA GLGizmoTrueColorPainting::get_cursor_hover_color() const
{
if (m_color_picker_active) {
ColorRGBA color;
if (sample_color_from_model(m_parent.get_local_mouse_position(), color))
return ColorRGBA(std::clamp(color.r(), 0.f, 1.f),
std::clamp(color.g(), 0.f, 1.f),
std::clamp(color.b(), 0.f, 1.f),
1.f);
}
return ColorRGBA(m_rgb_color[0], m_rgb_color[1], m_rgb_color[2], 1.f);
}
ColorRGBA GLGizmoTrueColorPainting::get_cursor_sphere_left_button_color() const
{
return ColorRGBA(m_rgb_color[0],
m_rgb_color[1],
m_rgb_color[2],
0.15f + 0.35f * std::clamp(m_opacity, 0.f, 1.f));
}
void GLGizmoTrueColorPainting::render_painter_gizmo()
{
const ModelObject *object = selected_model_object();
if (object == nullptr)
return;
if (object->id() != m_selected_color_state_object_id)
update_selected_object_color_state();
const Selection& selection = m_parent.get_selection();
glsafe(::glEnable(GL_BLEND));
glsafe(::glEnable(GL_DEPTH_TEST));
render_triangles(selection);
m_c->object_clipper()->render_cut();
m_c->instances_hider()->render_cut();
render_cursor();
glsafe(::glDisable(GL_BLEND));
}
bool GLGizmoTrueColorPainting::gizmo_event(SLAGizmoEventType action,
const Vec2d& mouse_position,
bool shift_down,
bool alt_down,
bool control_down)
{
const bool painting_event =
action == SLAGizmoEventType::LeftDown ||
action == SLAGizmoEventType::RightDown ||
action == SLAGizmoEventType::Dragging ||
action == SLAGizmoEventType::LeftUp ||
action == SLAGizmoEventType::RightUp ||
action == SLAGizmoEventType::Moving;
const ModelObject *object = selected_model_object();
if (object == nullptr || object->id() != m_selected_color_state_object_id)
update_selected_object_color_state();
if (m_color_picker_active) {
if (action == SLAGizmoEventType::LeftDown) {
if (pick_color_from_model(mouse_position))
m_color_picker_active = false;
m_parent.set_as_dirty();
return true;
}
if (action == SLAGizmoEventType::RightDown) {
m_color_picker_active = false;
m_parent.set_as_dirty();
return true;
}
if (painting_event)
return true;
}
if (action == SLAGizmoEventType::LeftDown) {
clear_brush_stroke_points();
m_brush_stroke_active = !shift_down && !control_down && record_brush_stroke_point(mouse_position);
} else if (action == SLAGizmoEventType::Dragging && m_brush_stroke_active && !shift_down && !control_down) {
record_brush_stroke_point(mouse_position);
} else if (action == SLAGizmoEventType::RightDown || (action == SLAGizmoEventType::Dragging && shift_down)) {
clear_brush_stroke_points();
}
const bool handled = GLGizmoPainterBase::gizmo_event(action, mouse_position, shift_down, alt_down, control_down);
if (action == SLAGizmoEventType::LeftUp || action == SLAGizmoEventType::RightUp) {
clear_brush_stroke_points();
m_brush_stroke_active = false;
}
return handled;
}
void GLGizmoTrueColorPainting::init_model_triangle_selectors()
{
const ModelObject *object = selected_model_object();
m_triangle_selectors.clear();
m_preview_rgb_data_by_volume.clear();
if (object == nullptr)
return;
const std::vector<ColorRGBA> colors = {
ColorRGBA(1.f, 1.f, 1.f, 0.f),
ColorRGBA(m_rgb_color[0], m_rgb_color[1], m_rgb_color[2], 1.f)
};
for (const ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
const ColorFacetsAnnotation *preview_rgb_data = nullptr;
m_preview_rgb_data_by_volume.emplace_back();
if (volume->texture_mapping_color_facets.empty()) {
std::unique_ptr<ColorFacetsAnnotation> preview = ColorFacetsAnnotation::make_temporary();
if (preview &&
build_volume_rgb_data_from_current_surface_color(*volume, ColorRGBA(1.f, 1.f, 1.f, 1.f), *preview)) {
preview_rgb_data = preview.get();
m_preview_rgb_data_by_volume.back() = std::move(preview);
}
}
m_triangle_selectors.emplace_back(std::make_unique<TriangleSelectorPatch>(volume->mesh(), volume, colors, 0.2f));
if (TriangleSelectorPatch *patch = dynamic_cast<TriangleSelectorPatch *>(m_triangle_selectors.back().get())) {
patch->set_none_state_rendered(false);
patch->set_texture_mapping_color_preview(preview_rgb_data);
patch->set_texture_preview_needed(!volume->texture_mapping_color_facets.empty() || preview_rgb_data != nullptr);
patch->set_texture_preview_opaque(true);
}
m_triangle_selectors.back()->set_wireframe_needed(true);
m_triangle_selectors.back()->request_update_render_data(true);
}
}
bool GLGizmoTrueColorPainting::record_brush_stroke_point(const Vec2d &mouse_position)
{
int mesh_id = -1;
Vec3f hit = Vec3f::Zero();
size_t facet = 0;
if (!raycast_to_selected_mesh(mouse_position, mesh_id, hit, facet) || mesh_id < 0)
return false;
if (m_brush_stroke_points_by_volume.size() <= size_t(mesh_id))
m_brush_stroke_points_by_volume.resize(size_t(mesh_id) + 1);
const ModelObject *object = selected_model_object();
const ModelVolume *hit_volume = nullptr;
if (object != nullptr) {
int model_part_idx = -1;
for (const ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
++model_part_idx;
if (model_part_idx == mesh_id) {
hit_volume = volume;
break;
}
}
}
Transform3d world_matrix = Transform3d::Identity();
if (object != nullptr && hit_volume != nullptr) {
const Selection &selection = m_parent.get_selection();
world_matrix = projection_world_matrix_for_volume(m_parent, object, hit_volume, selection.get_instance_idx());
}
std::vector<Vec3f> &points = m_brush_stroke_points_by_volume[size_t(mesh_id)];
const float min_spacing = true_color_brush_subdivision_target(m_cursor_radius);
if (points.empty() ||
(transform_point(world_matrix, points.back()) - transform_point(world_matrix, hit)).norm() >= min_spacing)
points.emplace_back(hit);
return true;
}
void GLGizmoTrueColorPainting::clear_brush_stroke_points()
{
m_brush_stroke_points_by_volume.clear();
m_brush_stroke_active = false;
}
void GLGizmoTrueColorPainting::update_triangle_selectors_color()
{
const std::vector<ColorRGBA> colors = {
ColorRGBA(1.f, 1.f, 1.f, 0.f),
ColorRGBA(m_rgb_color[0], m_rgb_color[1], m_rgb_color[2], 1.f)
};
for (std::unique_ptr<TriangleSelectorGUI> &selector : m_triangle_selectors) {
TriangleSelectorPatch *patch = dynamic_cast<TriangleSelectorPatch *>(selector.get());
if (patch == nullptr)
continue;
patch->set_ebt_colors(colors);
}
m_parent.set_as_dirty();
}
void GLGizmoTrueColorPainting::update_from_model_object(bool first_update)
{
(void)first_update;
wxBusyCursor wait;
update_selected_object_color_state();
init_model_triangle_selectors();
}
void GLGizmoTrueColorPainting::update_model_object()
{
ModelObject *object = selected_model_object();
if (object == nullptr)
return;
bool updated = false;
int selector_idx = -1;
for (ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
++selector_idx;
if (selector_idx < 0 ||
size_t(selector_idx) >= m_triangle_selectors.size() ||
m_triangle_selectors[size_t(selector_idx)] == nullptr)
continue;
std::vector<std::vector<TriangleSelector::FacetStateTriangle>> triangles_per_type;
m_triangle_selectors[size_t(selector_idx)]->get_facet_triangles(triangles_per_type);
const size_t paint_state = size_t(EnforcerBlockerType::ENFORCER);
if (triangles_per_type.size() <= paint_state || triangles_per_type[paint_state].empty())
continue;
bool initialized_rgb_data = false;
if (volume->texture_mapping_color_facets.empty()) {
bool initialized = false;
if (selector_idx < int(m_preview_rgb_data_by_volume.size()) &&
m_preview_rgb_data_by_volume[size_t(selector_idx)] != nullptr &&
!m_preview_rgb_data_by_volume[size_t(selector_idx)]->empty()) {
volume->texture_mapping_color_facets.assign(*m_preview_rgb_data_by_volume[size_t(selector_idx)]);
initialized = true;
initialized_rgb_data = true;
}
if (!initialized)
initialized_rgb_data = initialize_volume_rgb_data_from_current_surface_color(*volume, ColorRGBA(1.f, 1.f, 1.f, 1.f));
}
const ColorRGBA brush_color(m_rgb_color[0], m_rgb_color[1], m_rgb_color[2], 1.f);
const std::vector<Vec3f> empty_brush_stroke_points;
const std::vector<Vec3f> &brush_stroke_points =
selector_idx < int(m_brush_stroke_points_by_volume.size()) ?
m_brush_stroke_points_by_volume[size_t(selector_idx)] :
empty_brush_stroke_points;
const Selection &selection = m_parent.get_selection();
const Transform3d world_matrix =
projection_world_matrix_for_volume(m_parent, object, volume, selection.get_instance_idx());
const bool stroke_changed = apply_rgb_stroke_to_volume(*volume,
triangles_per_type[paint_state],
brush_color,
m_brush_hardness,
m_opacity,
m_cursor_radius,
brush_stroke_points,
world_matrix);
updated |= initialized_rgb_data || stroke_changed;
m_triangle_selectors[size_t(selector_idx)]->reset();
m_triangle_selectors[size_t(selector_idx)]->request_update_render_data(true);
}
if (!updated)
return;
const unsigned int texture_mapping_filament_id = ensure_texture_mapping_zone();
if (texture_mapping_filament_id != 0) {
object->config.set("extruder", int(texture_mapping_filament_id));
for (ModelVolume *volume : object->volumes)
if (volume != nullptr && volume->is_model_part())
volume->config.set("extruder", int(texture_mapping_filament_id));
}
refresh_selected_object_after_rgb_change(object);
}
ModelObject *GLGizmoTrueColorPainting::selected_model_object() const
{
if (m_c == nullptr)
return nullptr;
const auto *selection_info = m_c->selection_info();
return selection_info != nullptr ? selection_info->model_object() : nullptr;
}
void GLGizmoTrueColorPainting::open_color_data_management_dialog()
{
ModelObject *object = selected_model_object();
if (object == nullptr)
return;
ColorDataManagementDialog dialog(wxGetApp().mainframe, m_parent, object, [this]() {
update_selected_object_color_state();
init_model_triangle_selectors();
m_parent.set_as_dirty();
m_parent.request_extra_frame();
});
dialog.ShowModal();
update_selected_object_color_state();
init_model_triangle_selectors();
m_parent.set_as_dirty();
m_parent.request_extra_frame();
}
void GLGizmoTrueColorPainting::update_selected_object_color_state()
{
m_selected_has_rgb_data = false;
m_selected_has_imported_color_data = false;
m_selected_can_convert_vertex = false;
m_selected_can_convert_image = false;
const ModelObject *object = selected_model_object();
const ObjectID previous_object_id = m_selected_color_state_object_id;
m_selected_color_state_object_id = object != nullptr ? object->id() : ObjectID();
if (m_selected_color_state_object_id != previous_object_id)
m_color_picker_source_cache.clear();
if (object == nullptr)
return;
for (const ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
m_selected_has_rgb_data |= !volume->texture_mapping_color_facets.empty();
m_selected_can_convert_vertex |= !volume->imported_vertex_colors_rgba.empty();
m_selected_can_convert_image |= model_volume_has_bakeable_image_texture_data(volume);
}
m_selected_has_imported_color_data = m_selected_can_convert_vertex || m_selected_can_convert_image;
}
bool GLGizmoTrueColorPainting::selected_object_has_rgb_data() const
{
return m_selected_has_rgb_data;
}
bool GLGizmoTrueColorPainting::selected_object_has_imported_color_data() const
{
return m_selected_has_imported_color_data;
}
void GLGizmoTrueColorPainting::initialize_selected_object_rgb_data()
{
ModelObject *object = selected_model_object();
if (object == nullptr)
return;
bool initialized = false;
Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Create blank RGB data", UndoRedo::SnapshotType::GizmoAction);
for (ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
initialized |= initialize_volume_rgb_data(*volume, ColorRGBA(1.f, 1.f, 1.f, 1.f));
}
if (!initialized)
return;
const unsigned int texture_mapping_filament_id = ensure_texture_mapping_zone();
if (texture_mapping_filament_id != 0) {
object->config.set("extruder", int(texture_mapping_filament_id));
for (ModelVolume *volume : object->volumes)
if (volume != nullptr && volume->is_model_part())
volume->config.set("extruder", int(texture_mapping_filament_id));
}
refresh_selected_object_after_rgb_change(object);
}
void GLGizmoTrueColorPainting::convert_selected_object_vertex_colors_to_rgb_data()
{
ModelObject *object = selected_model_object();
if (object == nullptr)
return;
bool converted = false;
Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Convert vertex colors to RGB data", UndoRedo::SnapshotType::GizmoAction);
for (ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
const indexed_triangle_set &its = volume->mesh().its;
if (its.vertices.empty() ||
its.indices.empty() ||
volume->imported_vertex_colors_rgba.size() != its.vertices.size())
continue;
TextureMappingColorSampler sampler = [volume, &its](size_t tri_idx, const Vec3f &, const Vec3f &barycentric) {
if (tri_idx >= its.indices.size())
return 0xFFFFFFFFu;
const stl_triangle_vertex_indices &tri = its.indices[tri_idx];
if (tri[0] < 0 || tri[1] < 0 || tri[2] < 0)
return 0xFFFFFFFFu;
if (size_t(tri[0]) >= volume->imported_vertex_colors_rgba.size() ||
size_t(tri[1]) >= volume->imported_vertex_colors_rgba.size() ||
size_t(tri[2]) >= volume->imported_vertex_colors_rgba.size())
return 0xFFFFFFFFu;
const ColorRGBA c0 = unpack_vertex_color_rgba_for_conversion(volume->imported_vertex_colors_rgba[size_t(tri[0])]);
const ColorRGBA c1 = unpack_vertex_color_rgba_for_conversion(volume->imported_vertex_colors_rgba[size_t(tri[1])]);
const ColorRGBA c2 = unpack_vertex_color_rgba_for_conversion(volume->imported_vertex_colors_rgba[size_t(tri[2])]);
return pack_vertex_color_rgba(ColorRGBA(c0.r() * barycentric.x() + c1.r() * barycentric.y() + c2.r() * barycentric.z(),
c0.g() * barycentric.x() + c1.g() * barycentric.y() + c2.g() * barycentric.z(),
c0.b() * barycentric.x() + c1.b() * barycentric.y() + c2.b() * barycentric.z(),
c0.a() * barycentric.x() + c1.a() * barycentric.y() + c2.a() * barycentric.z()));
};
const float target_edge = std::max(mesh_max_axis_span(its) / 160.f, 0.25f);
TextureMappingColorSubdivisionDepths subdivision_depths = [target_edge](size_t, const std::array<Vec3f, 3> &vertices) {
const int depth = texture_mapping_depth_from_span(triangle_max_edge_length(vertices), target_edge, 5);
return std::make_pair(depth, depth);
};
volume->texture_mapping_color_facets.set_from_triangle_sampler(*volume, sampler, 5, 0.025f, subdivision_depths);
if (volume->texture_mapping_color_facets.metadata_json().empty())
volume->texture_mapping_color_facets.set_metadata_json(rgb_metadata_json(ColorRGBA(1.f, 1.f, 1.f, 1.f)));
converted = true;
}
if (!converted)
return;
const unsigned int texture_mapping_filament_id = ensure_texture_mapping_zone();
if (texture_mapping_filament_id != 0) {
object->config.set("extruder", int(texture_mapping_filament_id));
for (ModelVolume *volume : object->volumes)
if (volume != nullptr && volume->is_model_part())
volume->config.set("extruder", int(texture_mapping_filament_id));
}
refresh_selected_object_after_rgb_change(object);
}
void GLGizmoTrueColorPainting::convert_selected_object_image_texture_to_rgb_data()
{
ModelObject *object = selected_model_object();
if (object == nullptr)
return;
bool converted = false;
Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Convert image texture to RGB data", UndoRedo::SnapshotType::GizmoAction);
for (ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part() || !model_volume_has_bakeable_image_texture_data(volume))
continue;
const indexed_triangle_set &its = volume->mesh().its;
TextureMappingColorSampler sampler = [volume, &its](size_t tri_idx, const Vec3f &, const Vec3f &barycentric) {
if (tri_idx >= its.indices.size() ||
tri_idx >= volume->imported_texture_uv_valid.size() ||
volume->imported_texture_uv_valid[tri_idx] == 0)
return 0xFFFFFFFFu;
const size_t uv_offset = tri_idx * 6;
if (uv_offset + 5 >= volume->imported_texture_uvs_per_face.size())
return 0xFFFFFFFFu;
const Vec2f uv0(volume->imported_texture_uvs_per_face[uv_offset + 0], volume->imported_texture_uvs_per_face[uv_offset + 1]);
const Vec2f uv1(volume->imported_texture_uvs_per_face[uv_offset + 2], volume->imported_texture_uvs_per_face[uv_offset + 3]);
const Vec2f uv2(volume->imported_texture_uvs_per_face[uv_offset + 4], volume->imported_texture_uvs_per_face[uv_offset + 5]);
const Vec2f uv = uv0 * barycentric.x() + uv1 * barycentric.y() + uv2 * barycentric.z();
return pack_vertex_color_rgba(sample_texture_rgba_for_vertex_bake(volume->imported_texture_rgba,
volume->imported_texture_width,
volume->imported_texture_height,
uv));
};
const int safe_max_depth = texture_mapping_depth_for_budget(its.indices.size(), 7, 3200000);
TextureMappingColorSubdivisionDepths subdivision_depths = [volume, safe_max_depth](size_t tri_idx, const std::array<Vec3f, 3> &) {
const int depth = texture_mapping_depth_from_span(texture_triangle_uv_pixel_span(volume, tri_idx), 8.f, safe_max_depth);
return std::make_pair(depth, depth);
};
volume->texture_mapping_color_facets.set_from_triangle_sampler(*volume, sampler, safe_max_depth, 0.015f, subdivision_depths);
if (volume->texture_mapping_color_facets.metadata_json().empty())
volume->texture_mapping_color_facets.set_metadata_json(rgb_metadata_json(ColorRGBA(1.f, 1.f, 1.f, 1.f)));
converted = true;
}
if (!converted)
return;
const unsigned int texture_mapping_filament_id = ensure_texture_mapping_zone();
if (texture_mapping_filament_id != 0) {
object->config.set("extruder", int(texture_mapping_filament_id));
for (ModelVolume *volume : object->volumes)
if (volume != nullptr && volume->is_model_part())
volume->config.set("extruder", int(texture_mapping_filament_id));
}
refresh_selected_object_after_rgb_change(object);
}
void GLGizmoTrueColorPainting::refresh_selected_object_after_rgb_change(ModelObject *object)
{
update_selected_object_color_state();
init_model_triangle_selectors();
m_parent.update_volumes_colors_by_extruder();
m_parent.set_as_dirty();
const ModelObjectPtrs &objects = wxGetApp().model().objects;
const size_t object_idx = size_t(std::find(objects.begin(), objects.end(), object) - objects.begin());
if (object_idx < objects.size()) {
wxGetApp().obj_list()->update_info_items(object_idx);
wxGetApp().plater()->get_partplate_list().notify_instance_update(object_idx, 0);
}
m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
}
bool GLGizmoTrueColorPainting::pick_color_from_model(const Vec2d &mouse_position)
{
ColorRGBA color;
if (!sample_color_from_model(mouse_position, color))
return false;
set_active_color_from_sample(color);
return true;
}
bool GLGizmoTrueColorPainting::sample_color_from_model(const Vec2d &mouse_position, ColorRGBA &color) const
{
ModelObject *object = selected_model_object();
if (object == nullptr)
return false;
int mesh_idx = -1;
Vec3f hit = Vec3f::Zero();
size_t tri_idx = 0;
if (!raycast_to_selected_mesh(mouse_position, mesh_idx, hit, tri_idx) || mesh_idx < 0)
return false;
ModelVolume *volume = nullptr;
int part_idx = -1;
for (ModelVolume *candidate : object->volumes) {
if (candidate == nullptr || !candidate->is_model_part())
continue;
++part_idx;
if (part_idx == mesh_idx) {
volume = candidate;
break;
}
}
if (volume == nullptr)
return false;
const indexed_triangle_set &its = volume->mesh().its;
if (tri_idx >= its.indices.size())
return false;
const stl_triangle_vertex_indices &tri = its.indices[tri_idx];
if (tri[0] < 0 || tri[1] < 0 || tri[2] < 0)
return false;
if (size_t(tri[0]) >= its.vertices.size() ||
size_t(tri[1]) >= its.vertices.size() ||
size_t(tri[2]) >= its.vertices.size())
return false;
Vec3f barycentric = Vec3f::Zero();
if (!barycentric_weights_for_region_vertex_colors(hit,
its.vertices[size_t(tri[0])].cast<float>(),
its.vertices[size_t(tri[1])].cast<float>(),
its.vertices[size_t(tri[2])].cast<float>(),
barycentric))
return false;
if (!volume->texture_mapping_color_facets.empty()) {
const ColorPickerVolumeSourceCache &source = cached_volume_color_source(*volume);
if (std::optional<ColorRGBA> sampled = sample_rgb_color_facets(source.rgb_facets,
source.rgb_by_source_triangle,
int(tri_idx),
hit)) {
color = *sampled;
} else {
color = rgb_metadata_background_color(volume->texture_mapping_color_facets);
}
return true;
}
const VolumeColorSource source;
color = sample_volume_color_source(*volume, source, tri_idx, hit, barycentric);
return true;
}
const GLGizmoTrueColorPainting::ColorPickerVolumeSourceCache &
GLGizmoTrueColorPainting::cached_volume_color_source(const ModelVolume &volume) const
{
const ObjectID volume_id = volume.id();
const ObjectBase::Timestamp timestamp = volume.texture_mapping_color_facets.timestamp();
auto cache_it = std::find_if(m_color_picker_source_cache.begin(),
m_color_picker_source_cache.end(),
[volume_id](const ColorPickerVolumeSourceCache &cache) {
return cache.volume_id == volume_id;
});
if (cache_it == m_color_picker_source_cache.end()) {
m_color_picker_source_cache.emplace_back();
cache_it = m_color_picker_source_cache.end() - 1;
cache_it->volume_id = volume_id;
}
if (cache_it->timestamp != timestamp) {
cache_it->timestamp = timestamp;
cache_it->rgb_facets.clear();
cache_it->rgb_by_source_triangle.clear();
volume.texture_mapping_color_facets.get_facet_triangles(volume, cache_it->rgb_facets);
cache_it->rgb_by_source_triangle.reserve(cache_it->rgb_facets.size());
for (size_t idx = 0; idx < cache_it->rgb_facets.size(); ++idx)
cache_it->rgb_by_source_triangle[cache_it->rgb_facets[idx].source_triangle].emplace_back(idx);
}
return *cache_it;
}
void GLGizmoTrueColorPainting::set_active_color_from_sample(const ColorRGBA &color)
{
m_rgb_color[0] = std::clamp(color.r(), 0.f, 1.f);
m_rgb_color[1] = std::clamp(color.g(), 0.f, 1.f);
m_rgb_color[2] = std::clamp(color.b(), 0.f, 1.f);
m_rgb_color[3] = 1.f;
sync_active_color_mode_from_rgb(true);
update_triangle_selectors_color();
}
void GLGizmoTrueColorPainting::sync_cmy_from_rgb()
{
m_cmy_color[0] = 1.f - std::clamp(m_rgb_color[0], 0.f, 1.f);
m_cmy_color[1] = 1.f - std::clamp(m_rgb_color[1], 0.f, 1.f);
m_cmy_color[2] = 1.f - std::clamp(m_rgb_color[2], 0.f, 1.f);
}
void GLGizmoTrueColorPainting::sync_rgb_from_cmy()
{
m_rgb_color[0] = 1.f - std::clamp(m_cmy_color[0], 0.f, 1.f);
m_rgb_color[1] = 1.f - std::clamp(m_cmy_color[1], 0.f, 1.f);
m_rgb_color[2] = 1.f - std::clamp(m_cmy_color[2], 0.f, 1.f);
}
void GLGizmoTrueColorPainting::sync_cmyk_from_rgb()
{
const float r = std::clamp(m_rgb_color[0], 0.f, 1.f);
const float g = std::clamp(m_rgb_color[1], 0.f, 1.f);
const float b = std::clamp(m_rgb_color[2], 0.f, 1.f);
const float k = 1.f - std::max({ r, g, b });
m_cmyk_color[3] = std::clamp(k, 0.f, 1.f);
if (k >= 1.f - EPSILON) {
m_cmyk_color[0] = 0.f;
m_cmyk_color[1] = 0.f;
m_cmyk_color[2] = 0.f;
return;
}
const float denom = 1.f - k;
m_cmyk_color[0] = std::clamp((1.f - r - k) / denom, 0.f, 1.f);
m_cmyk_color[1] = std::clamp((1.f - g - k) / denom, 0.f, 1.f);
m_cmyk_color[2] = std::clamp((1.f - b - k) / denom, 0.f, 1.f);
}
void GLGizmoTrueColorPainting::sync_rgb_from_cmyk()
{
const float c = std::clamp(m_cmyk_color[0], 0.f, 1.f);
const float m = std::clamp(m_cmyk_color[1], 0.f, 1.f);
const float y = std::clamp(m_cmyk_color[2], 0.f, 1.f);
const float k = std::clamp(m_cmyk_color[3], 0.f, 1.f);
m_rgb_color[0] = std::clamp((1.f - c) * (1.f - k), 0.f, 1.f);
m_rgb_color[1] = std::clamp((1.f - m) * (1.f - k), 0.f, 1.f);
m_rgb_color[2] = std::clamp((1.f - y) * (1.f - k), 0.f, 1.f);
}
void GLGizmoTrueColorPainting::sync_cmyw_from_rgb()
{
const std::vector<ColorRGBA> colors = {
ColorRGBA(0.f, 1.f, 1.f, 1.f),
ColorRGBA(1.f, 0.f, 1.f, 1.f),
ColorRGBA(1.f, 1.f, 0.f, 1.f),
ColorRGBA(1.f, 1.f, 1.f, 1.f)
};
const std::vector<float> weights = closest_color_mix_weights(colors, ColorRGBA(m_rgb_color[0], m_rgb_color[1], m_rgb_color[2], 1.f));
for (size_t idx = 0; idx < m_cmyw_color.size() && idx < weights.size(); ++idx)
m_cmyw_color[idx] = weights[idx];
}
void GLGizmoTrueColorPainting::sync_rgb_from_cmyw()
{
const std::vector<ColorRGBA> colors = {
ColorRGBA(0.f, 1.f, 1.f, 1.f),
ColorRGBA(1.f, 0.f, 1.f, 1.f),
ColorRGBA(1.f, 1.f, 0.f, 1.f),
ColorRGBA(1.f, 1.f, 1.f, 1.f)
};
const std::vector<float> weights(m_cmyw_color.begin(), m_cmyw_color.end());
const ColorRGBA mixed = color_mix_from_weights(colors, weights, ColorRGBA(1.f, 1.f, 1.f, 1.f));
m_rgb_color[0] = mixed.r();
m_rgb_color[1] = mixed.g();
m_rgb_color[2] = mixed.b();
}
void GLGizmoTrueColorPainting::sync_rgbk_from_rgb()
{
const std::vector<ColorRGBA> colors = {
ColorRGBA(1.f, 0.f, 0.f, 1.f),
ColorRGBA(0.f, 1.f, 0.f, 1.f),
ColorRGBA(0.f, 0.f, 1.f, 1.f),
ColorRGBA(0.f, 0.f, 0.f, 1.f)
};
const std::vector<float> weights = closest_color_mix_weights(colors, ColorRGBA(m_rgb_color[0], m_rgb_color[1], m_rgb_color[2], 1.f));
for (size_t idx = 0; idx < m_rgbk_color.size() && idx < weights.size(); ++idx)
m_rgbk_color[idx] = weights[idx];
}
void GLGizmoTrueColorPainting::sync_rgb_from_rgbk()
{
const std::vector<ColorRGBA> colors = {
ColorRGBA(1.f, 0.f, 0.f, 1.f),
ColorRGBA(0.f, 1.f, 0.f, 1.f),
ColorRGBA(0.f, 0.f, 1.f, 1.f),
ColorRGBA(0.f, 0.f, 0.f, 1.f)
};
const std::vector<float> weights(m_rgbk_color.begin(), m_rgbk_color.end());
const ColorRGBA mixed = color_mix_from_weights(colors, weights, ColorRGBA(0.f, 0.f, 0.f, 1.f));
m_rgb_color[0] = mixed.r();
m_rgb_color[1] = mixed.g();
m_rgb_color[2] = mixed.b();
}
void GLGizmoTrueColorPainting::sync_rgbw_from_rgb()
{
const std::vector<ColorRGBA> colors = {
ColorRGBA(1.f, 0.f, 0.f, 1.f),
ColorRGBA(0.f, 1.f, 0.f, 1.f),
ColorRGBA(0.f, 0.f, 1.f, 1.f),
ColorRGBA(1.f, 1.f, 1.f, 1.f)
};
const std::vector<float> weights = closest_color_mix_weights(colors, ColorRGBA(m_rgb_color[0], m_rgb_color[1], m_rgb_color[2], 1.f));
for (size_t idx = 0; idx < m_rgbw_color.size() && idx < weights.size(); ++idx)
m_rgbw_color[idx] = weights[idx];
}
void GLGizmoTrueColorPainting::sync_rgb_from_rgbw()
{
const std::vector<ColorRGBA> colors = {
ColorRGBA(1.f, 0.f, 0.f, 1.f),
ColorRGBA(0.f, 1.f, 0.f, 1.f),
ColorRGBA(0.f, 0.f, 1.f, 1.f),
ColorRGBA(1.f, 1.f, 1.f, 1.f)
};
const std::vector<float> weights(m_rgbw_color.begin(), m_rgbw_color.end());
const ColorRGBA mixed = color_mix_from_weights(colors, weights, ColorRGBA(1.f, 1.f, 1.f, 1.f));
m_rgb_color[0] = mixed.r();
m_rgb_color[1] = mixed.g();
m_rgb_color[2] = mixed.b();
}
void GLGizmoTrueColorPainting::sync_bw_from_rgb()
{
const float r = std::clamp(m_rgb_color[0], 0.f, 1.f);
const float g = std::clamp(m_rgb_color[1], 0.f, 1.f);
const float b = std::clamp(m_rgb_color[2], 0.f, 1.f);
const float luminance = std::clamp(0.2126f * r + 0.7152f * g + 0.0722f * b, 0.f, 1.f);
m_bw_color[0] = 1.f - luminance;
m_bw_color[1] = luminance;
}
void GLGizmoTrueColorPainting::sync_rgb_from_bw()
{
const float black = std::clamp(m_bw_color[0], 0.f, 1.f);
const float white = std::clamp(m_bw_color[1], 0.f, 1.f);
const float sum = black + white;
const float value = sum <= EPSILON ? 1.f : white / sum;
m_rgb_color[0] = value;
m_rgb_color[1] = value;
m_rgb_color[2] = value;
}
void GLGizmoTrueColorPainting::ensure_filament_mix_colors()
{
std::vector<ColorRGBA> colors = get_extruders_colors();
const size_t physical_count = size_t(std::max(wxGetApp().filaments_cnt(), 0));
if (physical_count > 0 && colors.size() > physical_count)
colors.resize(physical_count);
bool changed = colors.size() != m_filament_mix_colors.size();
if (!changed) {
for (size_t idx = 0; idx < colors.size(); ++idx) {
if (colors[idx] != m_filament_mix_colors[idx]) {
changed = true;
break;
}
}
}
if (changed) {
m_filament_mix_colors = std::move(colors);
m_filament_mix.clear();
}
if (m_filament_mix.size() != m_filament_mix_colors.size())
sync_filament_mix_from_rgb();
}
void GLGizmoTrueColorPainting::sync_filament_mix_from_rgb()
{
m_filament_mix = closest_color_mix_weights(m_filament_mix_colors, ColorRGBA(m_rgb_color[0], m_rgb_color[1], m_rgb_color[2], 1.f));
}
void GLGizmoTrueColorPainting::sync_rgb_from_filament_mix()
{
const ColorRGBA mixed = color_mix_from_weights(m_filament_mix_colors,
m_filament_mix,
ColorRGBA(m_rgb_color[0], m_rgb_color[1], m_rgb_color[2], 1.f));
m_rgb_color[0] = mixed.r();
m_rgb_color[1] = mixed.g();
m_rgb_color[2] = mixed.b();
}
void GLGizmoTrueColorPainting::sync_active_color_mode_from_rgb(bool update_filament_mix)
{
switch (m_color_input_mode) {
case ColorInputMode::FilamentColors:
ensure_filament_mix_colors();
if (update_filament_mix)
sync_filament_mix_from_rgb();
break;
case ColorInputMode::RGB:
break;
case ColorInputMode::CMY:
sync_cmy_from_rgb();
break;
case ColorInputMode::CMYK:
sync_cmyk_from_rgb();
break;
case ColorInputMode::CMYW:
sync_cmyw_from_rgb();
break;
case ColorInputMode::RGBK:
sync_rgbk_from_rgb();
break;
case ColorInputMode::RGBW:
sync_rgbw_from_rgb();
break;
case ColorInputMode::BW:
sync_bw_from_rgb();
break;
}
}
bool GLGizmoTrueColorPainting::render_rgb_picker(float item_width)
{
bool changed = false;
ImGui::PushItemWidth(item_width);
ImGuiColorEditFlags flags = ImGuiColorEditFlags_DisplayRGB |
ImGuiColorEditFlags_InputRGB |
ImGuiColorEditFlags_NoInputs;
changed |= ImGui::ColorEdit3("##true_color_rgb_visual", m_rgb_color.data(), flags);
changed |= ImGui::SliderFloat("Red", &m_rgb_color[0], 0.f, 1.f, "%.2f");
changed |= ImGui::SliderFloat("Green", &m_rgb_color[1], 0.f, 1.f, "%.2f");
changed |= ImGui::SliderFloat("Blue", &m_rgb_color[2], 0.f, 1.f, "%.2f");
ImGui::PopItemWidth();
return changed;
}
bool GLGizmoTrueColorPainting::render_cmy_picker(float item_width)
{
bool changed = false;
ImGui::PushItemWidth(item_width);
ImGuiColorEditFlags flags = ImGuiColorEditFlags_DisplayRGB |
ImGuiColorEditFlags_InputRGB |
ImGuiColorEditFlags_NoInputs;
if (ImGui::ColorEdit3("##true_color_cmy_visual", m_rgb_color.data(), flags)) {
sync_cmy_from_rgb();
changed = true;
}
bool cmy_changed = false;
cmy_changed |= ImGui::SliderFloat("Cyan", &m_cmy_color[0], 0.f, 1.f, "%.2f");
cmy_changed |= ImGui::SliderFloat("Magenta", &m_cmy_color[1], 0.f, 1.f, "%.2f");
cmy_changed |= ImGui::SliderFloat("Yellow", &m_cmy_color[2], 0.f, 1.f, "%.2f");
ImGui::PopItemWidth();
if (cmy_changed) {
sync_rgb_from_cmy();
changed = true;
}
return changed;
}
bool GLGizmoTrueColorPainting::render_cmyk_picker(float item_width)
{
bool changed = false;
ImGui::PushItemWidth(item_width);
ImGuiColorEditFlags flags = ImGuiColorEditFlags_DisplayRGB |
ImGuiColorEditFlags_InputRGB |
ImGuiColorEditFlags_NoInputs;
if (ImGui::ColorEdit3("##true_color_cmyk_visual", m_rgb_color.data(), flags)) {
sync_cmyk_from_rgb();
changed = true;
}
bool cmyk_changed = false;
cmyk_changed |= ImGui::SliderFloat("Cyan", &m_cmyk_color[0], 0.f, 1.f, "%.2f");
cmyk_changed |= ImGui::SliderFloat("Magenta", &m_cmyk_color[1], 0.f, 1.f, "%.2f");
cmyk_changed |= ImGui::SliderFloat("Yellow", &m_cmyk_color[2], 0.f, 1.f, "%.2f");
cmyk_changed |= ImGui::SliderFloat("Key", &m_cmyk_color[3], 0.f, 1.f, "%.2f");
ImGui::PopItemWidth();
if (cmyk_changed) {
sync_rgb_from_cmyk();
changed = true;
}
return changed;
}
bool GLGizmoTrueColorPainting::render_cmyw_picker(float item_width)
{
bool changed = false;
ImGui::PushItemWidth(item_width);
ImGuiColorEditFlags flags = ImGuiColorEditFlags_DisplayRGB |
ImGuiColorEditFlags_InputRGB |
ImGuiColorEditFlags_NoInputs;
if (ImGui::ColorEdit3("##true_color_cmyw_visual", m_rgb_color.data(), flags)) {
sync_cmyw_from_rgb();
changed = true;
}
bool cmyw_changed = false;
cmyw_changed |= ImGui::SliderFloat("Cyan", &m_cmyw_color[0], 0.f, 1.f, "%.2f");
cmyw_changed |= ImGui::SliderFloat("Magenta", &m_cmyw_color[1], 0.f, 1.f, "%.2f");
cmyw_changed |= ImGui::SliderFloat("Yellow", &m_cmyw_color[2], 0.f, 1.f, "%.2f");
cmyw_changed |= ImGui::SliderFloat("White", &m_cmyw_color[3], 0.f, 1.f, "%.2f");
ImGui::PopItemWidth();
if (cmyw_changed) {
sync_rgb_from_cmyw();
changed = true;
}
return changed;
}
bool GLGizmoTrueColorPainting::render_rgbk_picker(float item_width)
{
bool changed = false;
ImGui::PushItemWidth(item_width);
ImGuiColorEditFlags flags = ImGuiColorEditFlags_DisplayRGB |
ImGuiColorEditFlags_InputRGB |
ImGuiColorEditFlags_NoInputs;
if (ImGui::ColorEdit3("##true_color_rgbk_visual", m_rgb_color.data(), flags)) {
sync_rgbk_from_rgb();
changed = true;
}
bool rgbk_changed = false;
rgbk_changed |= ImGui::SliderFloat("Red", &m_rgbk_color[0], 0.f, 1.f, "%.2f");
rgbk_changed |= ImGui::SliderFloat("Green", &m_rgbk_color[1], 0.f, 1.f, "%.2f");
rgbk_changed |= ImGui::SliderFloat("Blue", &m_rgbk_color[2], 0.f, 1.f, "%.2f");
rgbk_changed |= ImGui::SliderFloat("Black", &m_rgbk_color[3], 0.f, 1.f, "%.2f");
ImGui::PopItemWidth();
if (rgbk_changed) {
sync_rgb_from_rgbk();
changed = true;
}
return changed;
}
bool GLGizmoTrueColorPainting::render_rgbw_picker(float item_width)
{
bool changed = false;
ImGui::PushItemWidth(item_width);
ImGuiColorEditFlags flags = ImGuiColorEditFlags_DisplayRGB |
ImGuiColorEditFlags_InputRGB |
ImGuiColorEditFlags_NoInputs;
if (ImGui::ColorEdit3("##true_color_rgbw_visual", m_rgb_color.data(), flags)) {
sync_rgbw_from_rgb();
changed = true;
}
bool rgbw_changed = false;
rgbw_changed |= ImGui::SliderFloat("Red", &m_rgbw_color[0], 0.f, 1.f, "%.2f");
rgbw_changed |= ImGui::SliderFloat("Green", &m_rgbw_color[1], 0.f, 1.f, "%.2f");
rgbw_changed |= ImGui::SliderFloat("Blue", &m_rgbw_color[2], 0.f, 1.f, "%.2f");
rgbw_changed |= ImGui::SliderFloat("White", &m_rgbw_color[3], 0.f, 1.f, "%.2f");
ImGui::PopItemWidth();
if (rgbw_changed) {
sync_rgb_from_rgbw();
changed = true;
}
return changed;
}
bool GLGizmoTrueColorPainting::render_bw_picker(float item_width)
{
bool changed = false;
ImGui::PushItemWidth(item_width);
ImGuiColorEditFlags flags = ImGuiColorEditFlags_DisplayRGB |
ImGuiColorEditFlags_InputRGB |
ImGuiColorEditFlags_NoInputs;
if (ImGui::ColorEdit3("##true_color_bw_visual", m_rgb_color.data(), flags)) {
sync_bw_from_rgb();
changed = true;
}
float value = std::clamp(m_bw_color[1], 0.f, 1.f);
const bool slider_changed = ImGui::SliderFloat("Black / White", &value, 0.f, 1.f, "%.2f");
ImGui::PopItemWidth();
if (slider_changed) {
m_bw_color[0] = 1.f - value;
m_bw_color[1] = value;
sync_rgb_from_bw();
changed = true;
}
return changed;
}
bool GLGizmoTrueColorPainting::render_filament_colors_picker(float item_width)
{
ensure_filament_mix_colors();
if (m_filament_mix_colors.empty()) {
m_imgui->text(_L("No real filaments are available."));
return false;
}
bool changed = false;
ImGui::PushItemWidth(item_width);
ImGuiColorEditFlags flags = ImGuiColorEditFlags_DisplayRGB |
ImGuiColorEditFlags_InputRGB |
ImGuiColorEditFlags_NoInputs;
if (ImGui::ColorEdit3("##true_color_filament_visual", m_rgb_color.data(), flags))
changed = true;
if (ImGui::IsItemDeactivatedAfterEdit())
sync_filament_mix_from_rgb();
bool mix_changed = false;
for (size_t idx = 0; idx < m_filament_mix.size(); ++idx) {
const std::string label = GUI::format(_u8L("Filament %1%"), idx + 1);
mix_changed |= ImGui::SliderFloat(label.c_str(), &m_filament_mix[idx], 0.f, 1.f, "%.2f");
}
ImGui::PopItemWidth();
if (mix_changed) {
sync_rgb_from_filament_mix();
changed = true;
}
return changed;
}
void GLGizmoTrueColorPainting::on_render_input_window(float x, float y, float bottom_limit)
{
ModelObject *object = selected_model_object();
if (object == nullptr)
return;
if (object->id() != m_selected_color_state_object_id)
update_selected_object_color_state();
const float approx_height = m_imgui->scaled(22.0f);
y = std::min(y, bottom_limit - approx_height);
GizmoImguiSetNextWIndowPos(x, y, ImGuiCond_Always);
ImGuiWrapper::push_toolbar_style(m_parent.get_scale());
GizmoImguiBegin(get_name(), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize |
ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar);
const float slider_width = m_imgui->scaled(8.f);
const float max_tooltip_width = ImGui::GetFontSize() * 20.f;
const char *mode_labels[] = {
"Filament colors",
"RGB",
"CMY",
"CMYK",
"CMYW",
"RGBK",
"RGBW",
"BW"
};
const int mode_count = int(sizeof(mode_labels) / sizeof(mode_labels[0]));
int mode = std::clamp(int(m_color_input_mode), 0, mode_count - 1);
if (ImGui::BeginCombo("##true_color_mode", mode_labels[mode])) {
for (int idx = 0; idx < mode_count; ++idx) {
const bool selected = idx == mode;
if (ImGui::Selectable(mode_labels[idx], selected)) {
mode = idx;
m_color_input_mode = ColorInputMode(mode);
sync_active_color_mode_from_rgb(true);
update_triangle_selectors_color();
}
if (selected)
ImGui::SetItemDefaultFocus();
}
ImGui::EndCombo();
}
const wxString picker_label = m_color_picker_active ? _L("Cancel color picker") : _L("Pick color from model");
if (m_imgui->button(picker_label)) {
m_color_picker_active = !m_color_picker_active;
m_parent.set_as_dirty();
}
if (m_imgui->button(_L("Manage Color Data for this object")))
open_color_data_management_dialog();
bool color_changed = false;
switch (m_color_input_mode) {
case ColorInputMode::FilamentColors:
color_changed = render_filament_colors_picker(slider_width);
break;
case ColorInputMode::RGB:
color_changed = render_rgb_picker(slider_width);
break;
case ColorInputMode::CMY:
color_changed = render_cmy_picker(slider_width);
break;
case ColorInputMode::CMYK:
color_changed = render_cmyk_picker(slider_width);
break;
case ColorInputMode::CMYW:
color_changed = render_cmyw_picker(slider_width);
break;
case ColorInputMode::RGBK:
color_changed = render_rgbk_picker(slider_width);
break;
case ColorInputMode::RGBW:
color_changed = render_rgbw_picker(slider_width);
break;
case ColorInputMode::BW:
color_changed = render_bw_picker(slider_width);
break;
}
if (color_changed)
update_triangle_selectors_color();
ImGui::Separator();
m_imgui->text(_L("Pen size"));
ImGui::PushItemWidth(slider_width);
m_imgui->bbl_slider_float_style("##true_color_cursor_radius", &m_cursor_radius, CursorRadiusMin, CursorRadiusMax, "%.2f", 1.f, true);
ImGui::PopItemWidth();
float softness_pct = (1.f - m_brush_hardness) * 100.f;
m_imgui->text(_L("Brush softness"));
ImGui::PushItemWidth(slider_width);
if (m_imgui->bbl_slider_float_style("##true_color_softness", &softness_pct, 0.f, 100.f, "%.0f%%", 1.f, true))
m_brush_hardness = 1.f - std::clamp(softness_pct / 100.f, 0.f, 1.f);
ImGui::PopItemWidth();
float opacity_pct = m_opacity * 100.f;
m_imgui->text(_L("Opacity"));
ImGui::PushItemWidth(slider_width);
if (m_imgui->bbl_slider_float_style("##true_color_opacity", &opacity_pct, 0.f, 100.f, "%.0f%%", 1.f, true)) {
m_opacity = std::clamp(opacity_pct / 100.f, 0.f, 1.f);
m_parent.set_as_dirty();
}
ImGui::PopItemWidth();
ImGui::Separator();
if (m_c->object_clipper()->get_position() == 0.f) {
m_imgui->text(_L("Section view"));
} else if (m_imgui->button(_L("Reset direction"))) {
wxGetApp().CallAfter([this]() {
m_c->object_clipper()->set_position_by_ratio(-1., false);
});
}
float clp_dist = float(m_c->object_clipper()->get_position());
ImGui::PushItemWidth(slider_width);
if (m_imgui->bbl_slider_float_style("##true_color_clp_dist", &clp_dist, 0.f, 1.f, "%.2f", 1.f, true))
m_c->object_clipper()->set_position_by_ratio(clp_dist, true);
ImGui::PopItemWidth();
if (ImGui::IsItemHovered())
m_imgui->tooltip(_L("Section view"), max_tooltip_width);
GizmoImguiEnd();
ImGuiWrapper::pop_toolbar_style();
}
wxString GLGizmoTrueColorPainting::handle_snapshot_action_name(bool shift_down, GLGizmoPainterBase::Button button_down) const
{
(void)shift_down;
(void)button_down;
return _L("Paint RGB color");
}
GLGizmoImageProjection::GLGizmoImageProjection(GLCanvas3D& parent, const std::string& icon_filename, unsigned int sprite_id)
: GLGizmoBase(parent, icon_filename, sprite_id)
{
}
bool GLGizmoImageProjection::on_init()
{
return true;
}
void GLGizmoImageProjection::on_render()
{
}
std::string GLGizmoImageProjection::on_get_name() const
{
return _u8L("Project image to model surface");
}
void GLGizmoImageProjection::on_set_state()
{
if (get_state() == On) {
m_parent.enable_picking(false);
m_projection_mode_initialized = false;
} else if (get_state() == Off) {
m_parent.enable_picking(true);
m_parent.toggle_model_objects_visibility(true);
}
}
bool GLGizmoImageProjection::on_is_selectable() const
{
return wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptFFF;
}
bool GLGizmoImageProjection::on_is_activable() const
{
const Selection& selection = m_parent.get_selection();
return wxGetApp().preset_bundle->printers.get_edited_preset().printer_technology() == ptFFF &&
!selection.is_empty() &&
(selection.is_single_full_instance() || selection.is_any_volume());
}
CommonGizmosDataID GLGizmoImageProjection::on_get_requirements() const
{
return CommonGizmosDataID(int(CommonGizmosDataID::SelectionInfo) | int(CommonGizmosDataID::InstancesHider));
}
bool GLGizmoImageProjection::load_projection_image()
{
m_image_error.clear();
wxFileDialog dialog(wxGetApp().mainframe,
_L("Load projection image"),
"",
"",
_L("Image files (*.png;*.jpg;*.jpeg;*.bmp)|*.png;*.jpg;*.jpeg;*.bmp|All files (*.*)|*.*"),
wxFD_OPEN | wxFD_FILE_MUST_EXIST);
if (dialog.ShowModal() != wxID_OK)
return false;
wxImage image(dialog.GetPath(), wxBITMAP_TYPE_ANY);
std::vector<uint8_t> rgba;
uint32_t width = 0;
uint32_t height = 0;
if (!wx_image_to_rgba(image, rgba, width, height)) {
m_image_error = _u8L("Unable to load the selected image.");
return false;
}
m_image_path = into_u8(dialog.GetPath());
m_image_rgba = std::move(rgba);
m_image_width = width;
m_image_height = height;
m_overlay_texture_dirty = true;
m_parent.set_as_dirty();
return true;
}
void GLGizmoImageProjection::clear_projection_image()
{
m_image_path.clear();
m_image_error.clear();
m_image_rgba.clear();
m_image_width = 0;
m_image_height = 0;
m_overlay_texture.reset();
m_overlay_texture_dirty = false;
m_parent.set_as_dirty();
}
bool GLGizmoImageProjection::ensure_overlay_texture()
{
if (m_overlay_texture.get_id() != 0 && !m_overlay_texture_dirty)
return true;
if (m_image_rgba.empty() || m_image_width == 0 || m_image_height == 0)
return false;
std::vector<unsigned char> raw(m_image_rgba.begin(), m_image_rgba.end());
if (!m_overlay_texture.load_from_raw_data(std::move(raw), m_image_width, m_image_height)) {
m_image_error = _u8L("Unable to display the selected image.");
return false;
}
m_overlay_texture_dirty = false;
return true;
}
GLGizmoImageProjection::OverlayRect GLGizmoImageProjection::overlay_rect() const
{
OverlayRect rect;
if (m_image_width == 0 || m_image_height == 0)
return rect;
const Size canvas_size = m_parent.get_canvas_size();
const float canvas_w = float(std::max(1, canvas_size.get_width()));
const float canvas_h = float(std::max(1, canvas_size.get_height()));
const float max_w = canvas_w * 0.48f;
const float max_h = canvas_h * 0.48f;
float scale = std::min(max_w / float(m_image_width), max_h / float(m_image_height));
if (!std::isfinite(scale) || scale <= 0.f)
scale = 1.f;
rect.width = float(m_image_width) * scale;
rect.height = float(m_image_height) * scale;
rect.left = (canvas_w - rect.width) * 0.5f;
rect.top = (canvas_h - rect.height) * 0.5f;
return rect;
}
ModelObject *GLGizmoImageProjection::selected_model_object() const
{
if (m_c == nullptr)
return nullptr;
const auto *selection_info = m_c->selection_info();
return selection_info != nullptr ? selection_info->model_object() : nullptr;
}
void GLGizmoImageProjection::open_color_data_management_dialog()
{
ModelObject *object = selected_model_object();
if (object == nullptr)
return;
ColorDataManagementDialog dialog(wxGetApp().mainframe, m_parent, object, [this]() {
m_projection_mode_initialized = false;
update_default_projection_mode();
m_parent.set_as_dirty();
m_parent.request_extra_frame();
});
dialog.ShowModal();
m_projection_mode_initialized = false;
update_default_projection_mode();
m_parent.set_as_dirty();
m_parent.request_extra_frame();
}
void GLGizmoImageProjection::update_default_projection_mode()
{
const ModelObject *object = selected_model_object();
if (object == nullptr)
return;
if (m_projection_mode_initialized &&
object->id() == m_projection_mode_object_id &&
projection_mode_allowed(m_projection_mode))
return;
m_projection_mode = default_projection_mode();
m_projection_mode_initialized = true;
m_projection_mode_object_id = object->id();
}
GLGizmoImageProjection::ProjectionMode GLGizmoImageProjection::default_projection_mode() const
{
if (selected_object_has_rgb_data())
return ProjectionMode::RGBData;
if (selected_object_has_image_texture_data())
return ProjectionMode::ImageTexture;
return ProjectionMode::RGBData;
}
bool GLGizmoImageProjection::projection_mode_allowed(ProjectionMode mode) const
{
if (selected_object_has_rgb_data())
return mode == ProjectionMode::RGBData;
if (selected_object_has_image_texture_data())
return mode == ProjectionMode::ImageTexture || mode == ProjectionMode::RGBData;
return true;
}
bool GLGizmoImageProjection::selected_object_has_image_texture_data() const
{
const ModelObject *object = selected_model_object();
if (object == nullptr)
return false;
for (const ModelVolume *volume : object->volumes)
if (volume != nullptr && volume->is_model_part() && model_volume_has_bakeable_image_texture_data(volume))
return true;
return false;
}
bool GLGizmoImageProjection::selected_object_has_vertex_color_data() const
{
const ModelObject *object = selected_model_object();
if (object == nullptr)
return false;
for (const ModelVolume *volume : object->volumes)
if (volume != nullptr && volume->is_model_part() && !volume->imported_vertex_colors_rgba.empty())
return true;
return false;
}
bool GLGizmoImageProjection::selected_object_has_rgb_data() const
{
const ModelObject *object = selected_model_object();
if (object == nullptr)
return false;
for (const ModelVolume *volume : object->volumes)
if (volume != nullptr && volume->is_model_part() && !volume->texture_mapping_color_facets.empty())
return true;
return false;
}
void GLGizmoImageProjection::on_render_input_window(float x, float y, float bottom_limit)
{
update_default_projection_mode();
if (ensure_overlay_texture()) {
const OverlayRect rect = overlay_rect();
if (rect.width > 0.f && rect.height > 0.f) {
ImGui::SetNextWindowPos(ImVec2(rect.left, rect.top), ImGuiCond_Always);
ImGui::SetNextWindowSize(ImVec2(rect.width, rect.height), ImGuiCond_Always);
ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.f, 0.f));
ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.f);
ImGui::Begin("##image_projection_overlay",
nullptr,
ImGuiWindowFlags_NoDecoration |
ImGuiWindowFlags_NoInputs |
ImGuiWindowFlags_NoBackground |
ImGuiWindowFlags_NoSavedSettings);
ImGui::Image((void *)(intptr_t)m_overlay_texture.get_id(),
ImVec2(rect.width, rect.height),
ImVec2(0.f, 0.f),
ImVec2(1.f, 1.f),
ImVec4(1.f, 1.f, 1.f, 0.72f * std::clamp(m_projection_opacity, 0.f, 1.f)));
ImGui::End();
ImGui::PopStyleVar(2);
}
}
const float approx_height = m_imgui->scaled(12.0f);
y = std::min(y, bottom_limit - approx_height);
GizmoImguiSetNextWIndowPos(x, y, ImGuiCond_Always);
ImGuiWrapper::push_toolbar_style(m_parent.get_scale());
GizmoImguiBegin(get_name(), ImGuiWindowFlags_NoMove | ImGuiWindowFlags_AlwaysAutoResize |
ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar);
if (m_imgui->button(_L("Load image")))
load_projection_image();
ImGui::SameLine();
m_imgui->disabled_begin(m_image_rgba.empty());
if (m_imgui->button(_L("Clear image")))
clear_projection_image();
m_imgui->disabled_end();
if (!m_image_path.empty()) {
const size_t slash = m_image_path.find_last_of("/\\");
ImGui::SameLine();
m_imgui->text(from_u8(slash == std::string::npos ? m_image_path : m_image_path.substr(slash + 1)));
}
if (m_imgui->button(_L("Manage Color Data for this object")))
open_color_data_management_dialog();
m_imgui->text(_L("Apply to:"));
ImGui::SameLine();
const char *mode_labels[] = { "Vertex colors", "Image Texture", "RGB data" };
int mode = std::clamp(int(m_projection_mode), 0, 2);
if (ImGui::BeginCombo("##projection_mode", mode_labels[mode])) {
for (int idx = 0; idx < 3; ++idx) {
const ProjectionMode candidate = ProjectionMode(idx);
if (!projection_mode_allowed(candidate))
continue;
const bool selected = m_projection_mode == candidate;
if (ImGui::Selectable(mode_labels[idx], selected)) {
mode = idx;
m_projection_mode = candidate;
}
if (selected)
ImGui::SetItemDefaultFocus();
}
ImGui::EndCombo();
}
float opacity_pct = m_projection_opacity * 100.f;
m_imgui->text(_L("Opacity"));
ImGui::PushItemWidth(m_imgui->scaled(8.f));
if (m_imgui->bbl_slider_float_style("##image_projection_opacity", &opacity_pct, 0.f, 100.f, "%.0f%%", 1.f, true)) {
m_projection_opacity = std::clamp(opacity_pct / 100.f, 0.f, 1.f);
m_parent.set_as_dirty();
}
ImGui::PopItemWidth();
ImGui::Checkbox("Apply transparent regions as background color", &m_apply_transparency_as_background);
ImGui::Checkbox("Pass through model", &m_pass_through_model);
m_imgui->disabled_begin(m_image_rgba.empty());
if (m_imgui->button(_L("Project image onto model")))
project_image_to_selected_object();
m_imgui->disabled_end();
if (!m_image_error.empty())
m_imgui->warning_text(from_u8(m_image_error));
GizmoImguiEnd();
ImGuiWrapper::pop_toolbar_style();
}
bool GLGizmoImageProjection::project_image_to_selected_object()
{
ModelObject *object = selected_model_object();
if (object == nullptr || m_image_rgba.empty())
return false;
update_default_projection_mode();
if (!projection_mode_allowed(m_projection_mode))
return false;
bool changed = false;
Plater::TakeSnapshot snapshot(wxGetApp().plater(), "Project image onto model", UndoRedo::SnapshotType::GizmoAction);
switch (m_projection_mode) {
case ProjectionMode::VertexColors:
changed = project_to_vertex_colors(object);
break;
case ProjectionMode::ImageTexture:
changed = project_to_image_texture(object);
break;
case ProjectionMode::RGBData:
changed = project_to_rgb_data(object);
break;
}
if (!changed)
return false;
const unsigned int texture_mapping_filament_id = ensure_texture_mapping_zone();
if (texture_mapping_filament_id != 0) {
object->config.set("extruder", int(texture_mapping_filament_id));
for (ModelVolume *volume : object->volumes)
if (volume != nullptr && volume->is_model_part())
volume->config.set("extruder", int(texture_mapping_filament_id));
}
refresh_projected_object(object);
m_projection_mode_initialized = true;
m_projection_mode_object_id = object->id();
return true;
}
bool GLGizmoImageProjection::project_to_vertex_colors(ModelObject *object)
{
const Selection &selection = m_parent.get_selection();
const int instance_idx = selection.get_instance_idx();
const Camera &camera = wxGetApp().plater()->get_camera();
const std::array<int, 4> &viewport = camera.get_viewport();
const OverlayRect rect = overlay_rect();
ProjectionContext context;
context.view_projection = (camera.get_projection_matrix() * camera.get_view_matrix()).matrix();
context.canvas_width = std::max(1, viewport[2]);
context.canvas_height = std::max(1, viewport[3]);
context.overlay_left = rect.left;
context.overlay_top = rect.top;
context.overlay_width = rect.width;
context.overlay_height = rect.height;
context.image_rgba = &m_image_rgba;
context.image_width = m_image_width;
context.image_height = m_image_height;
context.image_opacity = m_projection_opacity;
context.apply_transparency_as_background = m_apply_transparency_as_background;
const ProjectionVisibility visibility = m_pass_through_model ?
ProjectionVisibility() :
build_projection_visibility(context, m_parent, object, instance_idx);
bool changed = false;
for (ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
const indexed_triangle_set &its = volume->mesh().its;
if (its.vertices.empty() || its.indices.empty())
continue;
const VolumeColorSource source = build_volume_color_source(*volume);
const ColorRGBA fallback_color = projection_base_color_for_volume(*volume);
std::vector<std::array<float, 4>> base_accum(its.vertices.size(), { 0.f, 0.f, 0.f, 0.f });
std::vector<unsigned int> base_counts(its.vertices.size(), 0);
for (size_t tri_idx = 0; tri_idx < its.indices.size(); ++tri_idx) {
const stl_triangle_vertex_indices &tri = its.indices[tri_idx];
for (int corner = 0; corner < 3; ++corner) {
if (tri[corner] < 0 || size_t(tri[corner]) >= its.vertices.size())
continue;
Vec3f barycentric = Vec3f::Zero();
barycentric[corner] = 1.f;
const ColorRGBA color = sample_volume_color_source(*volume,
source,
tri_idx,
its.vertices[size_t(tri[corner])].cast<float>(),
barycentric,
true,
&fallback_color);
std::array<float, 4> &accum = base_accum[size_t(tri[corner])];
accum[0] += color.r();
accum[1] += color.g();
accum[2] += color.b();
accum[3] += color.a();
++base_counts[size_t(tri[corner])];
}
}
std::vector<ColorRGBA> base_colors(its.vertices.size(), ColorRGBA(1.f, 1.f, 1.f, 1.f));
for (size_t idx = 0; idx < base_colors.size(); ++idx) {
if (base_counts[idx] == 0)
continue;
const float inv = 1.f / float(base_counts[idx]);
base_colors[idx] = ColorRGBA(base_accum[idx][0] * inv,
base_accum[idx][1] * inv,
base_accum[idx][2] * inv,
base_accum[idx][3] * inv);
}
std::vector<std::array<float, 4>> projected_accum(its.vertices.size(), { 0.f, 0.f, 0.f, 0.f });
std::vector<unsigned int> projected_counts(its.vertices.size(), 0);
const Transform3d world_matrix = projection_world_matrix_for_volume(m_parent, object, volume, instance_idx);
for (size_t tri_idx = 0; tri_idx < its.indices.size(); ++tri_idx) {
const stl_triangle_vertex_indices &tri = its.indices[tri_idx];
if (tri[0] < 0 || tri[1] < 0 || tri[2] < 0)
continue;
if (size_t(tri[0]) >= its.vertices.size() ||
size_t(tri[1]) >= its.vertices.size() ||
size_t(tri[2]) >= its.vertices.size())
continue;
const std::array<Vec3f, 3> vertices = {
its.vertices[size_t(tri[0])].cast<float>(),
its.vertices[size_t(tri[1])].cast<float>(),
its.vertices[size_t(tri[2])].cast<float>()
};
for (int corner = 0; corner < 3; ++corner) {
const size_t vertex_idx = size_t(tri[corner]);
if (!m_pass_through_model && !projection_point_is_visible(visibility, context, world_matrix, vertices[size_t(corner)]))
continue;
if (std::optional<ColorRGBA> projected = projected_image_color_at_point(context, world_matrix, vertices[size_t(corner)])) {
if (!context.apply_transparency_as_background && !projection_overlay_has_paintable_alpha(*projected, context))
continue;
const ColorRGBA color = apply_projection_color(base_colors[vertex_idx], *projected, context, false);
std::array<float, 4> &accum = projected_accum[vertex_idx];
accum[0] += color.r();
accum[1] += color.g();
accum[2] += color.b();
accum[3] += color.a();
++projected_counts[vertex_idx];
}
}
}
volume->imported_vertex_colors_rgba.assign(its.vertices.size(), 0xFFFFFFFFu);
for (size_t idx = 0; idx < its.vertices.size(); ++idx) {
ColorRGBA color = base_colors[idx];
if (projected_counts[idx] > 0) {
const float inv = 1.f / float(projected_counts[idx]);
color = ColorRGBA(projected_accum[idx][0] * inv,
projected_accum[idx][1] * inv,
projected_accum[idx][2] * inv,
projected_accum[idx][3] * inv);
}
volume->imported_vertex_colors_rgba[idx] = pack_vertex_color_rgba(color);
}
changed = true;
}
return changed;
}
bool GLGizmoImageProjection::project_to_image_texture(ModelObject *object)
{
const Selection &selection = m_parent.get_selection();
const int instance_idx = selection.get_instance_idx();
const Camera &camera = wxGetApp().plater()->get_camera();
const std::array<int, 4> &viewport = camera.get_viewport();
const OverlayRect rect = overlay_rect();
ProjectionContext context;
context.view_projection = (camera.get_projection_matrix() * camera.get_view_matrix()).matrix();
context.canvas_width = std::max(1, viewport[2]);
context.canvas_height = std::max(1, viewport[3]);
context.overlay_left = rect.left;
context.overlay_top = rect.top;
context.overlay_width = rect.width;
context.overlay_height = rect.height;
context.image_rgba = &m_image_rgba;
context.image_width = m_image_width;
context.image_height = m_image_height;
context.image_opacity = m_projection_opacity;
context.apply_transparency_as_background = m_apply_transparency_as_background;
const ProjectionVisibility visibility = m_pass_through_model ?
ProjectionVisibility() :
build_projection_visibility(context, m_parent, object, instance_idx);
bool changed = false;
for (ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
const indexed_triangle_set &its = volume->mesh().its;
if (its.vertices.empty() || its.indices.empty())
continue;
const bool generated_texture = !model_volume_has_bakeable_image_texture_data(volume);
if (generated_texture) {
const uint32_t texture_size = projection_texture_size_for_triangles(its.indices.size());
const uint32_t grid = uint32_t(std::ceil(std::sqrt(double(std::max<size_t>(its.indices.size(), 1)))));
const float tile = float(texture_size) / float(std::max<uint32_t>(grid, 1));
volume->imported_texture_width = texture_size;
volume->imported_texture_height = texture_size;
volume->imported_texture_rgba.assign(size_t(texture_size) * size_t(texture_size) * 4, 255);
volume->imported_texture_uv_valid.assign(its.indices.size(), 1);
volume->imported_texture_uvs_per_face.assign(its.indices.size() * 6, 0.f);
for (size_t tri_idx = 0; tri_idx < its.indices.size(); ++tri_idx) {
const uint32_t cell_x = uint32_t(tri_idx % grid);
const uint32_t cell_y = uint32_t(tri_idx / grid);
const float left = float(cell_x) * tile + 0.5f;
const float top = float(cell_y) * tile + 0.5f;
const float right = std::min(float(texture_size) - 0.5f, float(cell_x + 1) * tile - 0.5f);
const float bottom = std::min(float(texture_size) - 0.5f, float(cell_y + 1) * tile - 0.5f);
const size_t uv = tri_idx * 6;
volume->imported_texture_uvs_per_face[uv + 0] = left / float(texture_size);
volume->imported_texture_uvs_per_face[uv + 1] = top / float(texture_size);
volume->imported_texture_uvs_per_face[uv + 2] = right / float(texture_size);
volume->imported_texture_uvs_per_face[uv + 3] = top / float(texture_size);
volume->imported_texture_uvs_per_face[uv + 4] = left / float(texture_size);
volume->imported_texture_uvs_per_face[uv + 5] = bottom / float(texture_size);
}
}
const VolumeColorSource source = build_volume_color_source(*volume);
const ColorRGBA fallback_color = projection_base_color_for_volume(*volume);
const Transform3d world_matrix = projection_world_matrix_for_volume(m_parent, object, volume, instance_idx);
const bool rewrite_texture_base = generated_texture || !volume->texture_mapping_color_facets.empty();
const std::vector<uint8_t> source_texture_rgba(volume->imported_texture_rgba.begin(), volume->imported_texture_rgba.end());
bool volume_changed = generated_texture;
for (size_t tri_idx = 0; tri_idx < its.indices.size(); ++tri_idx) {
const stl_triangle_vertex_indices &tri = its.indices[tri_idx];
if (tri[0] < 0 || tri[1] < 0 || tri[2] < 0)
continue;
if (size_t(tri[0]) >= its.vertices.size() ||
size_t(tri[1]) >= its.vertices.size() ||
size_t(tri[2]) >= its.vertices.size())
continue;
if (tri_idx >= volume->imported_texture_uv_valid.size() ||
volume->imported_texture_uv_valid[tri_idx] == 0)
continue;
const size_t uv_offset = tri_idx * 6;
if (uv_offset + 5 >= volume->imported_texture_uvs_per_face.size())
continue;
const std::array<Vec2f, 3> uvs = unwrap_projection_uvs(std::array<Vec2f, 3>{
Vec2f(volume->imported_texture_uvs_per_face[uv_offset + 0], volume->imported_texture_uvs_per_face[uv_offset + 1]),
Vec2f(volume->imported_texture_uvs_per_face[uv_offset + 2], volume->imported_texture_uvs_per_face[uv_offset + 3]),
Vec2f(volume->imported_texture_uvs_per_face[uv_offset + 4], volume->imported_texture_uvs_per_face[uv_offset + 5])
});
const std::array<Vec3f, 3> vertices = {
its.vertices[size_t(tri[0])].cast<float>(),
its.vertices[size_t(tri[1])].cast<float>(),
its.vertices[size_t(tri[2])].cast<float>()
};
const float texture_width = float(volume->imported_texture_width);
const float texture_height = float(volume->imported_texture_height);
if (texture_width <= 0.f || texture_height <= 0.f)
continue;
const std::array<Vec2f, 3> pixel_uvs = {
Vec2f(uvs[0].x() * texture_width, uvs[0].y() * texture_height),
Vec2f(uvs[1].x() * texture_width, uvs[1].y() * texture_height),
Vec2f(uvs[2].x() * texture_width, uvs[2].y() * texture_height)
};
const float min_u = std::min({ uvs[0].x(), uvs[1].x(), uvs[2].x() });
const float max_u = std::max({ uvs[0].x(), uvs[1].x(), uvs[2].x() });
const float min_v = std::min({ uvs[0].y(), uvs[1].y(), uvs[2].y() });
const float max_v = std::max({ uvs[0].y(), uvs[1].y(), uvs[2].y() });
int min_x = int(std::floor(min_u * texture_width)) - 1;
int max_x = int(std::ceil(max_u * texture_width)) + 1;
int min_y = int(std::floor(min_v * texture_height)) - 1;
int max_y = int(std::ceil(max_v * texture_height)) + 1;
const bool uv_raster_too_large =
max_x - min_x > int(volume->imported_texture_width) * 2 ||
max_y - min_y > int(volume->imported_texture_height) * 2;
if (!uv_raster_too_large) {
for (int y_px = min_y; y_px <= max_y; ++y_px) {
for (int x_px = min_x; x_px <= max_x; ++x_px) {
const Vec2f pixel(float(x_px) + 0.5f, float(y_px) + 0.5f);
Vec3f barycentric = Vec3f::Zero();
if (!conservative_barycentric_weights_2d(pixel, pixel_uvs[0], pixel_uvs[1], pixel_uvs[2], 0.7072f, barycentric))
continue;
const Vec3f point = vertices[0] * barycentric.x() +
vertices[1] * barycentric.y() +
vertices[2] * barycentric.z();
ColorRGBA color = rewrite_texture_base ?
sample_volume_color_source(*volume, source, tri_idx, point, barycentric, false, &fallback_color) :
read_rgba_pixel(source_texture_rgba,
volume->imported_texture_width,
wrapped_texture_pixel(x_px, volume->imported_texture_width),
wrapped_texture_pixel(y_px, volume->imported_texture_height));
if (m_pass_through_model || projection_point_is_visible(visibility, context, world_matrix, point)) {
if (std::optional<ColorRGBA> projected = projected_image_color_at_point(context, world_matrix, point)) {
const bool transparent_sample =
!context.apply_transparency_as_background &&
!projection_overlay_has_paintable_alpha(*projected, context);
if (transparent_sample) {
if (!rewrite_texture_base) {
continue;
}
} else {
color = apply_projection_color(color, *projected, context, true);
}
} else if (!rewrite_texture_base) {
continue;
}
}
volume_changed |= write_rgba_pixel(volume->imported_texture_rgba,
volume->imported_texture_width,
wrapped_texture_pixel(x_px, volume->imported_texture_width),
wrapped_texture_pixel(y_px, volume->imported_texture_height),
color);
}
}
}
}
if (volume_changed) {
refresh_imported_texture_storage(*volume);
changed = true;
}
}
return changed;
}
bool GLGizmoImageProjection::project_to_rgb_data(ModelObject *object)
{
const Selection &selection = m_parent.get_selection();
const int instance_idx = selection.get_instance_idx();
const Camera &camera = wxGetApp().plater()->get_camera();
const std::array<int, 4> &viewport = camera.get_viewport();
const OverlayRect rect = overlay_rect();
ProjectionContext context;
context.view_projection = (camera.get_projection_matrix() * camera.get_view_matrix()).matrix();
context.canvas_width = std::max(1, viewport[2]);
context.canvas_height = std::max(1, viewport[3]);
context.overlay_left = rect.left;
context.overlay_top = rect.top;
context.overlay_width = rect.width;
context.overlay_height = rect.height;
context.image_rgba = &m_image_rgba;
context.image_width = m_image_width;
context.image_height = m_image_height;
context.image_opacity = m_projection_opacity;
context.apply_transparency_as_background = m_apply_transparency_as_background;
const ProjectionVisibility visibility = m_pass_through_model ?
ProjectionVisibility() :
build_projection_visibility(context, m_parent, object, instance_idx);
bool changed = false;
for (ModelVolume *volume : object->volumes) {
if (volume == nullptr || !volume->is_model_part())
continue;
const indexed_triangle_set &its = volume->mesh().its;
if (its.vertices.empty() || its.indices.empty())
continue;
const VolumeColorSource source = build_volume_color_source(*volume);
const ColorRGBA fallback_color = projection_base_color_for_volume(*volume);
const Transform3d world_matrix = projection_world_matrix_for_volume(m_parent, object, volume, instance_idx);
std::vector<bool> projected_triangles(its.indices.size(), false);
for (size_t tri_idx = 0; tri_idx < its.indices.size(); ++tri_idx) {
const stl_triangle_vertex_indices &tri = its.indices[tri_idx];
if (tri[0] < 0 || tri[1] < 0 || tri[2] < 0)
continue;
if (size_t(tri[0]) >= its.vertices.size() ||
size_t(tri[1]) >= its.vertices.size() ||
size_t(tri[2]) >= its.vertices.size())
continue;
const std::array<Vec3f, 3> vertices = {
its.vertices[size_t(tri[0])].cast<float>(),
its.vertices[size_t(tri[1])].cast<float>(),
its.vertices[size_t(tri[2])].cast<float>()
};
projected_triangles[tri_idx] = projection_triangle_intersects_overlay(context, world_matrix, vertices);
}
TextureMappingColorSampler sampler = [this, volume, source, context, world_matrix, fallback_color, &projected_triangles, &visibility](size_t tri_idx,
const Vec3f &point,
const Vec3f &barycentric) {
ColorRGBA color = sample_volume_color_source(*volume, source, tri_idx, point, barycentric, true, &fallback_color);
if (tri_idx < projected_triangles.size() && projected_triangles[tri_idx]) {
if (m_pass_through_model || projection_point_is_visible(visibility, context, world_matrix, point)) {
if (std::optional<ColorRGBA> projected = projected_image_color_at_point(context, world_matrix, point)) {
if (!context.apply_transparency_as_background && !projection_overlay_has_paintable_alpha(*projected, context))
return pack_vertex_color_rgba(color);
color = apply_projection_color(color, *projected, context, false);
}
}
}
return pack_vertex_color_rgba(color);
};
const float mesh_span = mesh_max_axis_span(its);
const int safe_max_depth = texture_mapping_depth_for_budget(its.indices.size(), 7, 2200000);
const float split_threshold = safe_max_depth < 5 ? 0.018f : 0.012f;
TextureMappingColorSubdivisionDepths subdivision_depths =
[volume, mesh_span, safe_max_depth, &projected_triangles](size_t tri_idx, const std::array<Vec3f, 3> &vertices) {
int base_depth = model_volume_has_bakeable_image_texture_data(volume) ?
texture_mapping_depth_from_span(texture_triangle_uv_pixel_span(volume, tri_idx), 8.f, safe_max_depth) :
texture_mapping_depth_from_span(triangle_max_edge_length(vertices), std::max(mesh_span / 180.f, 0.18f), std::min(6, safe_max_depth));
if (tri_idx < projected_triangles.size() && projected_triangles[tri_idx])
base_depth = std::min(std::max(base_depth, 4), safe_max_depth);
return std::make_pair(base_depth, safe_max_depth);
};
volume->texture_mapping_color_facets.set_from_triangle_sampler(*volume, sampler, safe_max_depth, split_threshold, subdivision_depths);
if (volume->texture_mapping_color_facets.metadata_json().empty())
volume->texture_mapping_color_facets.set_metadata_json(rgb_metadata_json(ColorRGBA(1.f, 1.f, 1.f, 1.f)));
changed = true;
}
return changed;
}
void GLGizmoImageProjection::refresh_projected_object(ModelObject *object)
{
m_parent.update_volumes_colors_by_extruder();
m_parent.set_as_dirty();
const ModelObjectPtrs &objects = wxGetApp().model().objects;
const size_t object_idx = size_t(std::find(objects.begin(), objects.end(), object) - objects.begin());
if (object_idx < objects.size()) {
wxGetApp().obj_list()->update_info_items(object_idx);
wxGetApp().plater()->get_partplate_list().notify_instance_update(object_idx, 0);
}
m_parent.post_event(SimpleEvent(EVT_GLCANVAS_SCHEDULE_BACKGROUND_PROCESS));
}
void GLMmSegmentationGizmo3DScene::release_geometry() {
if (this->vertices_VBO_id) {
glsafe(::glDeleteBuffers(1, &this->vertices_VBO_id));
this->vertices_VBO_id = 0;
}
for(auto &triangle_indices_VBO_id : triangle_indices_VBO_ids) {
glsafe(::glDeleteBuffers(1, &triangle_indices_VBO_id));
triangle_indices_VBO_id = 0;
}
this->clear();
}
void GLMmSegmentationGizmo3DScene::render(size_t triangle_indices_idx) const
{
assert(triangle_indices_idx < this->triangle_indices_VBO_ids.size());
assert(this->triangle_patches.size() == this->triangle_indices_VBO_ids.size());
assert(this->vertices_VBO_id != 0);
assert(this->triangle_indices_VBO_ids[triangle_indices_idx] != 0);
GLShaderProgram* shader = wxGetApp().get_current_shader();
if (shader == nullptr)
return;
// the following binding is needed to set the vertex attributes
glsafe(::glBindBuffer(GL_ARRAY_BUFFER, this->vertices_VBO_id));
const GLint position_id = shader->get_attrib_location("v_position");
if (position_id != -1) {
glsafe(::glVertexAttribPointer(position_id, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (GLvoid*)0));
glsafe(::glEnableVertexAttribArray(position_id));
}
// Render using the Vertex Buffer Objects.
if (this->triangle_indices_VBO_ids[triangle_indices_idx] != 0 &&
this->triangle_indices_sizes[triangle_indices_idx] > 0) {
glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->triangle_indices_VBO_ids[triangle_indices_idx]));
glsafe(::glDrawElements(GL_TRIANGLES, GLsizei(this->triangle_indices_sizes[triangle_indices_idx]), GL_UNSIGNED_INT, nullptr));
glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
}
if (position_id != -1)
glsafe(::glDisableVertexAttribArray(position_id));
glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
}
void GLMmSegmentationGizmo3DScene::finalize_vertices()
{
assert(this->vertices_VBO_id == 0);
if (!this->vertices.empty()) {
glsafe(::glGenBuffers(1, &this->vertices_VBO_id));
glsafe(::glBindBuffer(GL_ARRAY_BUFFER, this->vertices_VBO_id));
glsafe(::glBufferData(GL_ARRAY_BUFFER, this->vertices.size() * sizeof(float), this->vertices.data(), GL_STATIC_DRAW));
glsafe(::glBindBuffer(GL_ARRAY_BUFFER, 0));
this->vertices.clear();
}
}
void GLMmSegmentationGizmo3DScene::finalize_triangle_indices()
{
triangle_indices_VBO_ids.resize(this->triangle_patches.size());
triangle_indices_sizes.resize(this->triangle_patches.size());
assert(std::all_of(triangle_indices_VBO_ids.cbegin(), triangle_indices_VBO_ids.cend(), [](const auto &ti_VBO_id) { return ti_VBO_id == 0; }));
for (size_t buffer_idx = 0; buffer_idx < this->triangle_patches.size(); ++buffer_idx) {
std::vector<int>& triangle_indices = this->triangle_patches[buffer_idx].triangle_indices;
triangle_indices_sizes[buffer_idx] = triangle_indices.size();
if (!triangle_indices.empty()) {
glsafe(::glGenBuffers(1, &this->triangle_indices_VBO_ids[buffer_idx]));
glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->triangle_indices_VBO_ids[buffer_idx]));
glsafe(::glBufferData(GL_ELEMENT_ARRAY_BUFFER, triangle_indices.size() * sizeof(int), triangle_indices.data(), GL_STATIC_DRAW));
glsafe(::glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
triangle_indices.clear();
}
}
}
void GLGizmoMmuSegmentation::render_filament_remap_ui(float window_width, float max_tooltip_width)
{
size_t n_extr = std::min((size_t)EnforcerBlockerType::ExtruderMax, m_display_filament_ids.size());
const std::string max_label = std::to_string(std::max<size_t>(n_extr, 1));
const ImVec2 max_label_size = ImGui::CalcTextSize(max_label.c_str(), NULL, true);
const ImVec2 button_size(max_label_size.x + m_imgui->scaled(0.5f), 0.f);
const int max_items_per_line = 8;
const float item_width = button_size.x + m_imgui->scaled(1.5f);
const float start_pos_x = ImGui::GetCursorPosX();
for (int src = 0; src < (int)n_extr; ++src) {
const unsigned int dst_filament_id = m_extruder_remap[src] < m_display_filament_ids.size() ? m_display_filament_ids[m_extruder_remap[src]] : 0;
if (dst_filament_id == 0 || dst_filament_id > m_extruders_colors.size())
continue;
const ColorRGBA &dst_col = m_extruders_colors[dst_filament_id - 1];
ImVec4 col_vec = ImGuiWrapper::to_ImVec4(dst_col);
if (src % max_items_per_line != 0) {
ImGui::SameLine(start_pos_x + item_width * (src % max_items_per_line));
}
std::string btn_id = "##remap_src_" + std::to_string(src);
ImGuiColorEditFlags flags = ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoInputs |
ImGuiColorEditFlags_NoLabel | ImGuiColorEditFlags_NoPicker |
ImGuiColorEditFlags_NoTooltip;
if (m_selected_extruder_idx != src) flags |= ImGuiColorEditFlags_NoBorder;
#ifdef __APPLE__
ImGui::PushStyleColor(ImGuiCol_FrameBg, ImGuiWrapper::COL_ORCA);
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0f);
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 3.0);
bool clicked = ImGui::ColorButton(btn_id.c_str(), col_vec, flags, button_size);
ImGui::PopStyleVar(2);
ImGui::PopStyleColor(1);
#else
ImGui::PushStyleColor(ImGuiCol_FrameBg, ImGuiWrapper::COL_ORCA);
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0);
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 2.0);
bool clicked = ImGui::ColorButton(btn_id.c_str(), col_vec, flags, button_size);
ImGui::PopStyleVar(2);
ImGui::PopStyleColor(1);
#endif
// overlay destination number with proper contrast calculation
std::string dst_txt = std::to_string(m_extruder_remap[src] + 1);
float gray = 0.299f * dst_col.r() + 0.587f * dst_col.g() + 0.114f * dst_col.b();
ImVec2 txt_sz = ImGui::CalcTextSize(dst_txt.c_str());
ImVec2 pos = ImGui::GetItemRectMin();
ImVec2 size = ImGui::GetItemRectSize();
if (gray * 255.f < 80.f)
ImGui::GetWindowDrawList()->AddText(
ImVec2(pos.x + (size.x - txt_sz.x) * 0.5f, pos.y + (size.y - txt_sz.y) * 0.5f),
IM_COL32(255,255,255,255), dst_txt.c_str());
else
ImGui::GetWindowDrawList()->AddText(
ImVec2(pos.x + (size.x - txt_sz.x) * 0.5f, pos.y + (size.y - txt_sz.y) * 0.5f),
IM_COL32(0,0,0,255), dst_txt.c_str());
// popup with possible destinations
std::string pop_id = "popup_" + std::to_string(src);
if (clicked) {
// Calculate popup position centered below the current button
ImVec2 button_pos = ImGui::GetItemRectMin();
ImVec2 button_size = ImGui::GetItemRectSize();
ImVec2 popup_pos(button_pos.x + button_size.x * 0.5f, button_pos.y + button_size.y);
// Set popup styling BEFORE opening popup
ImGui::SetNextWindowPos(popup_pos, ImGuiCond_Appearing, ImVec2(0.5f, -0.1f));
ImGui::SetNextWindowBgAlpha(1.0f); // Ensure full opacity
ImGui::OpenPopup(pop_id.c_str());
}
// Apply popup styling before BeginPopup using standard Orca colors
ImGui::PushStyleVar(ImGuiStyleVar_PopupRounding, 4.0f);
ImGui::PushStyleVar(ImGuiStyleVar_PopupBorderSize, 1.0f);
ImGui::PushStyleColor(ImGuiCol_PopupBg, m_is_dark_mode ? ImGuiWrapper::COL_WINDOW_BG_DARK : ImGuiWrapper::COL_WINDOW_BG);
ImGui::PushStyleColor(ImGuiCol_Border, m_is_dark_mode ? ImVec4(0.5f, 0.5f, 0.5f, 1.0f) : ImVec4(0.6f, 0.6f, 0.6f, 1.0f));
if (ImGui::BeginPopup(pop_id.c_str())) {
const float popup_start_pos_x = ImGui::GetCursorPosX();
for (int dst = 0; dst < (int)n_extr; ++dst) {
const unsigned int popup_filament_id = m_display_filament_ids[dst];
if (popup_filament_id == 0 || popup_filament_id > m_extruders_colors.size())
continue;
const ColorRGBA &dst_col_popup = m_extruders_colors[popup_filament_id - 1];
ImVec4 dst_vec = ImGuiWrapper::to_ImVec4(dst_col_popup);
if (dst % max_items_per_line != 0)
ImGui::SameLine(popup_start_pos_x + item_width * (dst % max_items_per_line));
std::string dst_btn = "##dst_" + std::to_string(src) + "_" + std::to_string(dst);
// Apply same styling to destination buttons
ImGuiColorEditFlags dst_flags = ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoInputs |
ImGuiColorEditFlags_NoLabel | ImGuiColorEditFlags_NoPicker |
ImGuiColorEditFlags_NoTooltip;
// Show border for currently selected destination filament
if (m_extruder_remap[src] != dst) dst_flags |= ImGuiColorEditFlags_NoBorder;
#ifdef __APPLE__
ImGui::PushStyleColor(ImGuiCol_FrameBg, ImGuiWrapper::COL_ORCA);
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0f);
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 3.0);
bool dst_clicked = ImGui::ColorButton(dst_btn.c_str(), dst_vec, dst_flags, button_size);
ImGui::PopStyleVar(2);
ImGui::PopStyleColor(1);
#else
ImGui::PushStyleColor(ImGuiCol_FrameBg, ImGuiWrapper::COL_ORCA);
ImGui::PushStyleVar(ImGuiStyleVar_FrameBorderSize, 0.0);
ImGui::PushStyleVar(ImGuiStyleVar_FrameRounding, 2.0);
bool dst_clicked = ImGui::ColorButton(dst_btn.c_str(), dst_vec, dst_flags, button_size);
ImGui::PopStyleVar(2);
ImGui::PopStyleColor(1);
#endif
// overlay destination number on popup buttons
std::string dst_num_txt = std::to_string(dst + 1);
float dst_gray = 0.299f * dst_col_popup.r() + 0.587f * dst_col_popup.g() + 0.114f * dst_col_popup.b();
ImVec2 dst_txt_sz = ImGui::CalcTextSize(dst_num_txt.c_str());
ImVec2 dst_pos = ImGui::GetItemRectMin();
ImVec2 dst_size = ImGui::GetItemRectSize();
if (dst_gray * 255.f < 80.f)
ImGui::GetWindowDrawList()->AddText(
ImVec2(dst_pos.x + (dst_size.x - dst_txt_sz.x) * 0.5f, dst_pos.y + (dst_size.y - dst_txt_sz.y) * 0.5f),
IM_COL32(255,255,255,255), dst_num_txt.c_str());
else
ImGui::GetWindowDrawList()->AddText(
ImVec2(dst_pos.x + (dst_size.x - dst_txt_sz.x) * 0.5f, dst_pos.y + (dst_size.y - dst_txt_sz.y) * 0.5f),
IM_COL32(0,0,0,255), dst_num_txt.c_str());
if (dst_clicked)
{
m_extruder_remap[src] = dst;
// update the source button color immediately
ImGui::CloseCurrentPopup();
}
}
ImGui::EndPopup();
}
// Clean up popup styling (always pop, whether popup was open or not)
ImGui::PopStyleColor(2); // PopupBg and Border
ImGui::PopStyleVar(2); // PopupRounding and PopupBorderSize
}
ImGui::Dummy(ImVec2(0.0f, ImGui::GetFontSize() * 0.3f));
if (m_imgui->button(m_desc.at("remap"))) {
remap_filament_assignments();
m_show_filament_remap_ui = false;
}
ImGui::SameLine();
if (m_imgui->button(m_desc.at("cancel_remap")))
m_show_filament_remap_ui = false;
}
void GLGizmoMmuSegmentation::remap_filament_assignments()
{
if (m_extruder_remap.empty())
return;
constexpr size_t MAX_EBT = (size_t)EnforcerBlockerType::ExtruderMax;
EnforcerBlockerStateMap state_map;
// identity mapping by default
for (size_t i = 0; i <= MAX_EBT; ++i)
state_map[i] = static_cast<EnforcerBlockerType>(i);
size_t n_extr = std::min({m_extruder_remap.size(), m_display_filament_ids.size(), MAX_EBT});
bool any_change = false;
for (size_t src = 0; src < n_extr; ++src) {
const size_t dst = m_extruder_remap[src];
if (dst >= m_display_filament_ids.size())
continue;
const unsigned int src_state = m_display_filament_ids[src];
const unsigned int dst_state = m_display_filament_ids[dst];
if (src_state == 0 || dst_state == 0 || src_state == dst_state)
continue;
state_map[src_state] = static_cast<EnforcerBlockerType>(dst_state);
if (src_state == 1)
state_map[0] = static_cast<EnforcerBlockerType>(dst_state);
any_change = true;
}
if (!any_change)
return;
Plater::TakeSnapshot snapshot(wxGetApp().plater(),
"Remap filament assignments",
UndoRedo::SnapshotType::GizmoAction);
bool updated = false;
int idx = -1;
ModelObject* mo = m_c->selection_info()->model_object();
if (!mo) return;
for (ModelVolume* mv : mo->volumes) {
if (!mv->is_model_part()) continue;
++idx;
TriangleSelectorGUI* ts = m_triangle_selectors[idx].get();
if (!ts) continue;
ts->remap_triangle_state(state_map);
ts->request_update_render_data(true);
updated = true;
}
if (updated) {
wxGetApp().plater()->get_notification_manager()->push_notification(
_L("Filament remapping finished.").ToStdString());
update_model_object();
m_parent.set_as_dirty();
}
}
} // namespace Slic3r
Reference in New Issue View Git Blame Copy Permalink