Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp} Namespace Reference

Functions
void	push_slim_scrollbar_style (float width, bool dark)
void	pop_slim_scrollbar_style ()
std::string	ellipsize (std::string s, float max_w, float font_size=0.f)
bool	point_in_triangle_coplanar (const Vec3f &p, const std::array< Vec3f, 3 > &t)
TriangleSelector::TriangleSplittingData	remap_texture_paint_spatial (const TriangleMesh &src_mesh, const TriangleSelector::TriangleSplittingData &src_data, const AABBTreeIndirect::Tree3f &src_tree, const TriangleMesh &dst_mesh, const Vec3f &dst_to_src)
std::vector< std::string >	mixed_slot_signature (const DynamicPrintConfig &project_config)
bool	same_palette (const std::vector< PrintableColor > &l, const std::vector< PrintableColor > &r)
static Vec3f	srgb_to_lab (const Vec3f &c)
static Vec3f	lab_to_srgb (const Vec3f &lab)
std::unique_ptr< GLTexture >	upload_height_thumbnail (const DecodedHeightTexture &decoded, int max_px=THUMBNAIL_MAX_PX)
std::unique_ptr< GLTexture >	upload_color_texture (const DecodedHeightTexture &decoded, int max_px)
bool	ray_plane_hit (const Camera &camera, const Vec2d &mouse_pos, const Transform3d &trafo, const Vec3f &plane_point_local, const Vec3f &plane_normal_local, Vec3d &out_world_hit)

Variables
constexpr float	ImGuiLogSlider = float(ImGuiSliderFlags_Logarithmic)
constexpr int	THUMBNAIL_MAX_PX = 128
constexpr int	HEIGHT_TEX_MAX_PX = 2048
constexpr int	ADJUST_PREVIEW_MAX_PX = 384
constexpr int	PICKER_LOADS_PER_FRAME = 2
constexpr int	BORDER_BAND_RINGS = 2
constexpr int	PALETTE_LUT_EDGE = 24
constexpr int	PALETTE_MAX_ENTRIES = 64
constexpr float	PREFER_PURE_DE = 2.f
constexpr size_t	MIX_TARGET_SAMPLES = size_t(1) << 20
constexpr size_t	MIX_TARGET_BINS = 256
constexpr float	MIN_MIX_GAIN = 0.05f

Function Documentation

ellipsize()

std::string Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::ellipsize	(	std::string	s,
		float	max_w,
		float	font_size = 0.f )

{
    const auto text_width = [&](const std::string &text) {
        return font_size > 0.f
                   ? ImGui::GetFont()->CalcTextSizeA(font_size, std::numeric_limits<float>::max(), 0.f, text.c_str()).x
                   : ImGui::CalcTextSize(text.c_str()).x;
    };
    if (text_width(s) <= max_w)
        return s;
    while (!s.empty() && text_width(s + "...") > max_w) {
        unsigned char c;
        do { // a whole code point at a time
            c = static_cast<unsigned char>(s.back());
            s.pop_back();
        } while (!s.empty() && (c & 0xC0) == 0x80);
    }
    return s + "...";
}

References ellipsize().

Referenced by ellipsize().

Here is the call graph for this function:

Here is the caller graph for this function:

lab_to_srgb()

Vec3f Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::lab_to_srgb ( const Vec3f & lab )

static

{
    const float fy = (lab.x() + 16.f) / 116.f, fx = lab.y() / 500.f + fy, fz = fy - lab.z() / 200.f;
    const auto  finv = [](float t) { return t > 0.206893f ? t * t * t : (t - 16.f / 116.f) / 7.787f; };
    const float x = finv(fx) * 0.95047f, y = finv(fy), z = finv(fz) * 1.08883f;
    const float r = 3.2406f * x - 1.5372f * y - 0.4986f * z;
    const float g = -0.9689f * x + 1.8758f * y + 0.0415f * z;
    const float b = 0.0557f * x - 0.2040f * y + 1.0570f * z;
    const auto gam = [](float v) {
        v = std::clamp(v, 0.f, 1.f);
        return v > 0.0031308f ? 1.055f * std::pow(v, 1.f / 2.4f) - 0.055f : 12.92f * v;
    };
    return Vec3f(gam(r), gam(g), gam(b));
}

References lab_to_srgb().

Referenced by lab_to_srgb().

Here is the call graph for this function:

Here is the caller graph for this function:

mixed_slot_signature()

std::vector< std::string > Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::mixed_slot_signature

(

const DynamicPrintConfig &

project_config

)

{
    std::vector<std::string> out;
    const auto *is_mixed = project_config.option<ConfigOptionBools>("filament_is_mixed");
    const auto *comps    = project_config.option<ConfigOptionStrings>("filament_mixed_components");
    const auto *ratios   = project_config.option<ConfigOptionStrings>("filament_mixed_sublayer_ratios");
    const auto *gradient = project_config.option<ConfigOptionBools>("filament_mixed_gradient");
    if (is_mixed == nullptr || comps == nullptr || ratios == nullptr)
        return out;
    for (size_t i = 0; i < is_mixed->values.size(); ++i)
        if (is_mixed->values[i])
            out.push_back(std::to_string(i) + ':' + (i < comps->values.size() ? comps->values[i] : std::string()) + '|' +
                          (i < ratios->values.size() ? ratios->values[i] : std::string()) + '|' +
                          (gradient != nullptr && i < gradient->values.size() && gradient->values[i] ? "g" : ""));
    return out;
}

References mixed_slot_signature(), Slic3r::ConfigBase::option(), Slic3r::ConfigOptionVector< T >::size(), Slic3r::ConfigOptionVector< T >::values, and Slic3r::ConfigOptionVector< unsigned char >::values.

Referenced by mixed_slot_signature().

Here is the call graph for this function:

Here is the caller graph for this function:

point_in_triangle_coplanar()

bool Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::point_in_triangle_coplanar	(	const Vec3f &	p,
		const std::array< Vec3f, 3 > &	t )

{
    const Vec3f n = (t[1] - t[0]).cross(t[2] - t[0]);
    const float n2 = n.squaredNorm();
    if (n2 < 1e-20f)
        return false; // degenerate: it covers no area, so nothing is inside it
    // A small negative tolerance, scaled by the triangle, keeps a centroid sitting exactly on a shared
    // edge from falling through the gap between two neighbouring pieces.
    const float eps = -1e-4f * n2;
    return (t[1] - t[0]).cross(p - t[0]).dot(n) >= eps &&
           (t[2] - t[1]).cross(p - t[1]).dot(n) >= eps &&
           (t[0] - t[2]).cross(p - t[2]).dot(n) >= eps;
}

References Slic3r::cross(), and point_in_triangle_coplanar().

Referenced by point_in_triangle_coplanar().

Here is the call graph for this function:

Here is the caller graph for this function:

pop_slim_scrollbar_style()

void Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::pop_slim_scrollbar_style

(

)

{
    ImGui::PopStyleColor(5);
    ImGui::PopStyleVar(2);
}

References pop_slim_scrollbar_style().

Referenced by pop_slim_scrollbar_style().

Here is the call graph for this function:

Here is the caller graph for this function:

push_slim_scrollbar_style()

void Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::push_slim_scrollbar_style	(	float	width,
		bool	dark )

{
    const ImVec4 grab = dark ? ImVec4(1.f, 1.f, 1.f, 0.26f) : ImVec4(0.f, 0.f, 0.f, 0.26f);
    ImGui::PushStyleVar(ImGuiStyleVar_ScrollbarSize, width);
    ImGui::PushStyleVar(ImGuiStyleVar_ScrollbarRounding, 0.5f * width);
    ImGui::PushStyleColor(ImGuiCol_ScrollbarBg, ImVec4(0.f, 0.f, 0.f, 0.f));
    ImGui::PushStyleColor(ImGuiCol_ScrollbarGrab, grab);
    ImGui::PushStyleColor(ImGuiCol_ScrollbarGrabHovered, ImVec4(grab.x, grab.y, grab.z, 0.45f));
    ImGui::PushStyleColor(ImGuiCol_ScrollbarGrabActive, ImVec4(grab.x, grab.y, grab.z, 0.65f));
    ImGui::PushStyleColor(ImGuiCol_ChildBg, ImVec4(0.f, 0.f, 0.f, 0.f));
}

References push_slim_scrollbar_style().

Referenced by push_slim_scrollbar_style().

Here is the call graph for this function:

Here is the caller graph for this function:

ray_plane_hit()

bool Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::ray_plane_hit	(	const Camera &	camera,
		const Vec2d &	mouse_pos,
		const Transform3d &	trafo,
		const Vec3f &	plane_point_local,
		const Vec3f &	plane_normal_local,
		Vec3d &	out_world_hit )

{
    Vec3d ray_origin, ray_dir;
    CameraUtils::ray_from_screen_pos(camera, mouse_pos, ray_origin, ray_dir);
 
    const Vec3d plane_point_world  = trafo * plane_point_local.cast<double>();
    const Vec3d plane_normal_world = (trafo.matrix().block(0, 0, 3, 3).inverse().transpose() * plane_normal_local.cast<double>()).normalized();
 
    const double denom = ray_dir.dot(plane_normal_world);
    if (std::abs(denom) < 1e-8)
        return false;
 
    const double t = (plane_point_world - ray_origin).dot(plane_normal_world) / denom;
    if (t < 0.0)
        return false;
 
    out_world_hit = ray_origin + ray_dir * t;
    return true;
}

References Slic3r::dot(), Slic3r::GUI::CameraUtils::ray_from_screen_pos(), and ray_plane_hit().

Referenced by ray_plane_hit().

Here is the call graph for this function:

Here is the caller graph for this function:

remap_texture_paint_spatial()

TriangleSelector::TriangleSplittingData Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::remap_texture_paint_spatial	(	const TriangleMesh &	src_mesh,
		const TriangleSelector::TriangleSplittingData &	src_data,
		const AABBTreeIndirect::Tree3f &	src_tree,
		const TriangleMesh &	dst_mesh,
		const Vec3f &	dst_to_src )

{
    const indexed_triangle_set &src  = src_mesh.its;
    const indexed_triangle_set &dst  = dst_mesh.its;
    const size_t                ntri = src.indices.size();
    if (src_data.bitstream.empty() || ntri == 0 || dst.indices.empty() || src_tree.empty())
        return {};
 
    // The painted patch, split into per-source-triangle pieces - the same shape
    // collect_paint_region() builds, and for the same reason: a source triangle the brush only
    // partly covered has to answer "is this point painted" geometrically rather than be rounded to
    // painted-or-not, which leaves a ragged fringe along any curved brush boundary.
    TriangleSelector src_sel(src_mesh);
    src_sel.deserialize(src_data, false);
    std::vector<int>           piece_src;
    const indexed_triangle_set patch = src_sel.get_facets_strict(EnforcerBlockerType::ENFORCER, &piece_src);
    if (patch.indices.empty())
        return {};
 
    const auto tri_area2 = [](const Vec3f &a, const Vec3f &b, const Vec3f &c) {
        return (b - a).cross(c - a).norm();
    };
    std::vector<float> src_area2(ntri, 0.f), covered2(ntri, 0.f);
    for (size_t i = 0; i < ntri; ++i)
        src_area2[i] = tri_area2(src.vertices[size_t(src.indices[i][0])], src.vertices[size_t(src.indices[i][1])],
                                 src.vertices[size_t(src.indices[i][2])]);
    for (size_t j = 0; j < patch.indices.size() && j < piece_src.size(); ++j) {
        if (size_t(piece_src[j]) >= ntri)
            continue;
        const stl_triangle_vertex_indices &t = patch.indices[j];
        covered2[size_t(piece_src[j])] += tri_area2(patch.vertices[size_t(t[0])], patch.vertices[size_t(t[1])],
                                                    patch.vertices[size_t(t[2])]);
    }
    std::vector<uint8_t> full(ntri, 0);
    for (size_t i = 0; i < ntri; ++i)
        full[i] = (src_area2[i] > 0.f && covered2[i] >= 0.999f * src_area2[i]) ? 1 : 0;
 
    // CSR pieces, kept for partly covered sources only - a full one answers every query "painted".
    std::vector<int> part_start(ntri + 1, 0);
    for (size_t j = 0; j < patch.indices.size() && j < piece_src.size(); ++j)
        if (size_t(piece_src[j]) < ntri && !full[size_t(piece_src[j])])
            ++part_start[size_t(piece_src[j]) + 1];
    for (size_t i = 0; i < ntri; ++i)
        part_start[i + 1] += part_start[i];
    std::vector<std::array<Vec3f, 3>> part;
    part.resize(size_t(part_start[ntri])); // not a constructor call: `vector<T> p(size_t(x[n]));` parses
                                           // as a function declaration, and every use of `part` below
                                           // then fails with something that does not mention the cause.
    {
        std::vector<int> fill(part_start.begin(), part_start.begin() + ntri);
        for (size_t j = 0; j < patch.indices.size() && j < piece_src.size(); ++j) {
            const size_t S = size_t(piece_src[j]);
            if (S >= ntri || full[S])
                continue;
            const stl_triangle_vertex_indices &t = patch.indices[j];
            part[size_t(fill[S]++)] = { patch.vertices[size_t(t[0])], patch.vertices[size_t(t[1])],
                                        patch.vertices[size_t(t[2])] };
        }
    }
 
    // Classify in parallel, then write the mask serially - TriangleSelector is not thread safe.
    std::vector<uint8_t> painted(dst.indices.size(), 0);
    tbb::parallel_for(tbb::blocked_range<size_t>(0, dst.indices.size()),
                      [&](const tbb::blocked_range<size_t> &range) {
        for (size_t i = range.begin(); i < range.end(); ++i) {
            const stl_triangle_vertex_indices &t = dst.indices[i];
            const Vec3f centroid = (dst.vertices[size_t(t[0])] + dst.vertices[size_t(t[1])] +
                                    dst.vertices[size_t(t[2])]) / 3.f + dst_to_src;
            size_t hit     = 0;
            Vec3f  hit_pos = Vec3f::Zero();
            if (AABBTreeIndirect::squared_distance_to_indexed_triangle_set(src.vertices, src.indices, src_tree,
                                                                          centroid, hit, hit_pos) < 0.f ||
                hit >= ntri)
                continue;
            if (full[hit]) {
                painted[i] = 1;
                continue;
            }
            for (int k = part_start[hit]; k < part_start[hit + 1]; ++k)
                if (point_in_triangle_coplanar(hit_pos, part[size_t(k)])) {
                    painted[i] = 1;
                    break;
                }
        }
    });
 
    TriangleSelector dst_sel(dst_mesh);
    for (size_t i = 0; i < painted.size(); ++i)
        if (painted[i])
            dst_sel.set_facet(int(i), EnforcerBlockerType::ENFORCER);
    return dst_sel.serialize();
}

References Slic3r::TriangleSelector::TriangleSplittingData::bitstream, Slic3r::TriangleSelector::deserialize(), Slic3r::AABBTreeIndirect::Tree< ANumDimensions, ACoordType >::empty(), Slic3r::ENFORCER, Slic3r::TriangleSelector::get_facets_strict(), Slic3r::TriangleMesh::its, Slic3r::range(), and remap_texture_paint_spatial().

Referenced by remap_texture_paint_spatial().

Here is the call graph for this function:

Here is the caller graph for this function:

same_palette()

bool Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::same_palette	(	const std::vector< PrintableColor > &	l,
		const std::vector< PrintableColor > &	r )

{
    return std::equal(l.begin(), l.end(), r.begin(), r.end(), [](const PrintableColor &x, const PrintableColor &y) {
        return x.a == y.a && x.b == y.b && x.num == y.num && x.den == y.den && x.rgb == y.rgb;
    });
}

References same_palette().

Referenced by same_palette().

Here is the call graph for this function:

Here is the caller graph for this function:

srgb_to_lab()

Vec3f Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::srgb_to_lab ( const Vec3f & c )

static

{
    const auto lin = [](float v) { return v > 0.04045f ? std::pow((v + 0.055f) / 1.055f, 2.4f) : v / 12.92f; };
    const float r = lin(c.x()), g = lin(c.y()), b = lin(c.z());
    const float x = (0.4124f * r + 0.3576f * g + 0.1805f * b) / 0.95047f;
    const float y = (0.2126f * r + 0.7152f * g + 0.0722f * b);
    const float z = (0.0193f * r + 0.1192f * g + 0.9505f * b) / 1.08883f;
    const auto f = [](float t) { return t > 0.008856f ? std::cbrt(t) : 7.787f * t + 16.f / 116.f; };
    const float fx = f(x), fy = f(y), fz = f(z);
    return Vec3f(116.f * fy - 16.f, 500.f * (fx - fy), 200.f * (fy - fz));
}

References Slic3r::f(), and srgb_to_lab().

Referenced by srgb_to_lab().

Here is the call graph for this function:

Here is the caller graph for this function:

upload_color_texture()

std::unique_ptr< GLTexture > Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::upload_color_texture	(	const DecodedHeightTexture &	decoded,
		int	max_px )

{
    if (!decoded.has_color())
        return nullptr;
 
    const int scale = std::max(1, (std::max(decoded.width, decoded.height) + max_px - 1) / max_px);
    const int w     = std::max(1, decoded.width / scale);
    const int h     = std::max(1, decoded.height / scale);
 
    std::vector<unsigned char> rgba(size_t(w) * size_t(h) * 4);
    for (int y = 0; y < h; ++y)
        for (int x = 0; x < w; ++x) {
            const int x0 = x * decoded.width / w, x1 = std::max(x0 + 1, (x + 1) * decoded.width / w);
            const int y0 = y * decoded.height / h, y1 = std::max(y0 + 1, (y + 1) * decoded.height / h);
            unsigned int sum[3] = { 0, 0, 0 };
            unsigned int n      = 0;
            for (int sy = y0; sy < y1 && sy < decoded.height; ++sy)
                for (int sx = x0; sx < x1 && sx < decoded.width; ++sx, ++n) {
                    const size_t si = (size_t(sy) * size_t(decoded.width) + size_t(sx)) * 3;
                    for (int c = 0; c < 3; ++c)
                        sum[c] += decoded.rgb[si + size_t(c)];
                }
            const size_t di = (size_t(y) * size_t(w) + size_t(x)) * 4;
            for (int c = 0; c < 3; ++c)
                rgba[di + size_t(c)] = (n > 0) ? static_cast<unsigned char>(sum[size_t(c)] / n) : 0;
            rgba[di + 3] = 255;
        }
 
    auto texture = std::make_unique<GLTexture>();
    if (!texture->load_from_raw_data(std::move(rgba), (unsigned int) w, (unsigned int) h, false, false))
        return nullptr;
    return texture;
}

References Slic3r::DecodedHeightTexture::has_color(), Slic3r::DecodedHeightTexture::height, Slic3r::DecodedHeightTexture::rgb, scale(), upload_color_texture(), and Slic3r::DecodedHeightTexture::width.

Referenced by upload_color_texture().

Here is the call graph for this function:

Here is the caller graph for this function:

upload_height_thumbnail()

std::unique_ptr< GLTexture > Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::upload_height_thumbnail	(	const DecodedHeightTexture &	decoded,
		int	max_px = THUMBNAIL_MAX_PX )

{
    if (decoded.empty())
        return nullptr;
 
    // Preserve aspect; never upscale a texture that is already small.
    const int scale = std::max(1, (std::max(decoded.width, decoded.height) + max_px - 1) / max_px);
    const int w     = std::max(1, decoded.width / scale);
    const int h     = std::max(1, decoded.height / scale);
 
    // A colour texture is shown in colour, so it can be told apart from its grey neighbours in the picker; its
    // height is the luminance of those same colours, so nothing about the relief is hidden by that.
    const bool                 color = decoded.has_color();
    std::vector<unsigned char> rgba(size_t(w) * size_t(h) * 4);
    for (int y = 0; y < h; ++y)
        for (int x = 0; x < w; ++x) {
            // Average the source block this destination pixel covers.
            const int x0 = x * decoded.width / w, x1 = std::max(x0 + 1, (x + 1) * decoded.width / w);
            const int y0 = y * decoded.height / h, y1 = std::max(y0 + 1, (y + 1) * decoded.height / h);
            unsigned int sum[3] = { 0, 0, 0 };
            unsigned int n      = 0;
            for (int sy = y0; sy < y1 && sy < decoded.height; ++sy)
                for (int sx = x0; sx < x1 && sx < decoded.width; ++sx, ++n) {
                    const size_t si = size_t(sy) * size_t(decoded.width) + size_t(sx);
                    for (int c = 0; c < 3; ++c)
                        sum[c] += color ? decoded.rgb[si * 3 + size_t(c)] : decoded.pixels[si];
                }
 
            const size_t di = (size_t(y) * size_t(w) + size_t(x)) * 4;
            for (int c = 0; c < 3; ++c)
                rgba[di + size_t(c)] = (n > 0) ? static_cast<unsigned char>(sum[c] / n) : 0;
            rgba[di + 3] = 255;
        }
 
    auto texture = std::make_unique<GLTexture>();
    if (!texture->load_from_raw_data(std::move(rgba), (unsigned int) w, (unsigned int) h, false, /* use_mipmaps */ false))
        return nullptr;
    return texture;
}

References Slic3r::DecodedHeightTexture::empty(), Slic3r::DecodedHeightTexture::has_color(), Slic3r::DecodedHeightTexture::height, Slic3r::DecodedHeightTexture::pixels, Slic3r::DecodedHeightTexture::rgb, scale(), THUMBNAIL_MAX_PX, upload_height_thumbnail(), and Slic3r::DecodedHeightTexture::width.

Referenced by upload_height_thumbnail().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

ADJUST_PREVIEW_MAX_PX

int Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::ADJUST_PREVIEW_MAX_PX = 384

constexpr

BORDER_BAND_RINGS

int Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::BORDER_BAND_RINGS = 2

constexpr

HEIGHT_TEX_MAX_PX

int Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::HEIGHT_TEX_MAX_PX = 2048

constexpr

ImGuiLogSlider

float Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::ImGuiLogSlider = float(ImGuiSliderFlags_Logarithmic)

constexpr

MIN_MIX_GAIN

float Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::MIN_MIX_GAIN = 0.05f

constexpr

MIX_TARGET_BINS

size_t Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::MIX_TARGET_BINS = 256

constexpr

MIX_TARGET_SAMPLES

size_t Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::MIX_TARGET_SAMPLES = size_t(1) << 20

constexpr

PALETTE_LUT_EDGE

int Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::PALETTE_LUT_EDGE = 24

constexpr

PALETTE_MAX_ENTRIES

int Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::PALETTE_MAX_ENTRIES = 64

constexpr

PICKER_LOADS_PER_FRAME

int Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::PICKER_LOADS_PER_FRAME = 2

constexpr

PREFER_PURE_DE

float Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::PREFER_PURE_DE = 2.f

constexpr

THUMBNAIL_MAX_PX

int Slic3r::GUI::anonymous_namespace{GLGizmoTextureDisplacement.cpp}::THUMBNAIL_MAX_PX = 128

constexpr

Referenced by upload_height_thumbnail().