openscad-cpp-evaluator 1.49.7__tar.gz → 1.49.8__tar.gz

{openscad_cpp_evaluator-1.49.7 → openscad_cpp_evaluator-1.49.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.49.7
+Version: 1.49.8
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT AND OFL-1.1

{openscad_cpp_evaluator-1.49.7 → openscad_cpp_evaluator-1.49.8}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -45,6 +45,16 @@ inline constexpr std::array<float, 4> kDefaultGeometryColor{0.9f, 0.85f, 0.1f, 1
 // geometry colour so a cut reads as a cut.
 inline constexpr std::array<float, 4> kCutFaceColor{157.0f / 255.0f, 203.0f / 255.0f, 81.0f / 255.0f, 1.0f};
 
+// What a per-triangle colour array holds for the two colours above, so a
+// renderer can still draw them in its live theme: baking the real values
+// painted every uncoloured difference() yellow and green whatever the
+// theme (BelfrySCAD #884's follow-up). Negative RGB is no colour a script
+// can make; alpha 1 keeps them opaque for a renderer's alpha split.
+// Export writes the real colours in their place (resolveThemeColors), so
+// files are unchanged.
+inline constexpr std::array<float, 4> kThemeBodyColor{-1.0f, -1.0f, -1.0f, 1.0f};
+inline constexpr std::array<float, 4> kThemeCutColor{-2.0f, -2.0f, -2.0f, 1.0f};
+
 struct ColoredBody {
     std::optional<manifold::Manifold> body;
     std::optional<std::array<float, 4>> color; // RGBA; nullopt = "no explicit color() -- follow the live theme"

{openscad_cpp_evaluator-1.49.7 → openscad_cpp_evaluator-1.49.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "1.49.7"
+version = "1.49.8"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-1.49.7 → openscad_cpp_evaluator-1.49.8}/src/builtins/booleans.cpp

@@ -214,12 +214,12 @@ void attachTriColors(Evaluator& ev, ColoredBody& cb) {
         std::all_of(perRunColor.begin(), perRunColor.end(), [&](const auto& c) { return c == perRunColor.front(); });
     if (allSame) return;
 
-    std::vector<std::array<float, 4>> triColors(numTris, kDefaultGeometryColor);
+    std::vector<std::array<float, 4>> triColors(numTris, kThemeBodyColor);
     for (size_t i = 0; i + 1 < runIdx.size(); ++i) {
         const size_t start = runIdx[i] / 3;
         const size_t end = std::min<size_t>(runIdx[i + 1] / 3, numTris);
         if (start >= numTris) continue;
-        const std::array<float, 4> color = perRunColor[i].value_or(kDefaultGeometryColor);
+        const std::array<float, 4> color = perRunColor[i].value_or(kThemeBodyColor);
         for (size_t t = start; t < end; ++t) triColors[t] = color;
     }
     cb.triColors = std::move(triColors);
@@ -458,7 +458,7 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
         if (op == "difference" && res3d && !ev.measuring()) {
             for (ColoredBody& c : bodies3d) {
                 if (c.color || c.triColors) continue;
-                ev.recordRunColors(c, kCutFaceColor);
+                ev.recordRunColors(c, kThemeCutColor);
                 mixedColors = true;
             }
         }

{openscad_cpp_evaluator-1.49.7 → openscad_cpp_evaluator-1.49.8}/src/csg_generate.cpp

@@ -517,7 +517,7 @@ void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::
         if (cb.triColors && cb.body) {
             const manifold::MeshGL rebuilt = cb.body->GetMeshGL();
             const size_t numTris = rebuilt.triVerts.size() / 3;
-            std::vector<std::array<float, 4>> triColors(numTris, cb.color.value_or(kDefaultGeometryColor));
+            std::vector<std::array<float, 4>> triColors(numTris, cb.color.value_or(kThemeBodyColor));
             for (size_t i = 0; i + 1 < rebuilt.runIndex.size() && i < rebuilt.runOriginalID.size(); ++i) {
                 auto it = runColor.find(rebuilt.runOriginalID[i]);
                 if (it == runColor.end()) continue;

{openscad_cpp_evaluator-1.49.7 → openscad_cpp_evaluator-1.49.8}/src/export.cpp

@@ -459,6 +459,16 @@ std::vector<std::string> mixedDimensionWarnings(const std::vector<ColoredBody>&
     return out;
 }
 
+// A file has no theme: the stand-ins a renderer draws in its theme's colours
+// are written as the colours they stand in for (colored_body.hpp).
+static std::vector<std::array<float, 4>> resolveThemeColors(std::vector<std::array<float, 4>> colors) {
+    for (auto& c : colors) {
+        if (c == kThemeBodyColor) c = kDefaultGeometryColor;
+        else if (c == kThemeCutColor) c = kCutFaceColor;
+    }
+    return colors;
+}
+
 std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies, std::vector<int>* openParts,
                                                 bool splitComponents, bool splitColors) {
     struct Solid {
@@ -492,7 +502,7 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
             meshToArrays(*cb.rawMesh, obj.verts, obj.tris);
             if (obj.tris.empty()) continue;
             obj.color = cb.color.value_or(kDefaultExportColor);
-            if (cb.triColors) obj.triColors = *cb.triColors;
+            if (cb.triColors) obj.triColors = resolveThemeColors(*cb.triColors);
             loose.push_back(std::move(obj));
             if (openParts) openParts->push_back(index);
             continue;
@@ -501,7 +511,7 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
         Solid s;
         s.man = *cb.body;
         s.color = cb.color;
-        if (cb.triColors) s.triColors = *cb.triColors;
+        if (cb.triColors) s.triColors = resolveThemeColors(*cb.triColors);
         s.tris = s.man.GetMeshGL().triVerts;
         if (s.tris.empty()) continue;
         solids.push_back(std::move(s));

{openscad_cpp_evaluator-1.49.7 → openscad_cpp_evaluator-1.49.8}/tests/test_multi_color_merge.cpp

@@ -1,4 +1,5 @@
 #include "openscad_cpp_evaluator/evaluator.hpp"
+#include "openscad_cpp_evaluator/export.hpp"
 #include "openscad_cpp_evaluator/manifold_cache.hpp"
 
 #include "test_helpers.hpp"
@@ -73,7 +74,7 @@ TEST(MultiColorCsgMerge, DifferenceCutFaceGetsTheCutGreen) {
     const auto distinct = distinctColors(*e.bodies[0].triColors);
     EXPECT_EQ(distinct.size(), 3u);
     EXPECT_TRUE(std::any_of(distinct.begin(), distinct.end(), [](const auto& c) { return approxEqual(c, {0.0f, 1.0f, 1.0f, 0.5f}); }));
-    EXPECT_TRUE(std::any_of(distinct.begin(), distinct.end(), [](const auto& c) { return approxEqual(c, kCutFaceColor); }));
+    EXPECT_TRUE(std::any_of(distinct.begin(), distinct.end(), [](const auto& c) { return approxEqual(c, kThemeCutColor); }));
 }
 
 TEST(MultiColorCsgMerge, UncolouredMinuendCutByUncolouredToolStillShowsTheCut) {
@@ -84,6 +85,20 @@ TEST(MultiColorCsgMerge, UncolouredMinuendCutByUncolouredToolStillShowsTheCut) {
     ASSERT_TRUE(e.bodies[0].triColors.has_value());
     const auto distinct = distinctColors(*e.bodies[0].triColors);
     EXPECT_EQ(distinct.size(), 2u);
+    // Both are the theme stand-ins, not baked colours, so a renderer can
+    // draw them in its live theme rather than always yellow and green.
+    EXPECT_TRUE(std::any_of(distinct.begin(), distinct.end(), [](const auto& c) { return approxEqual(c, kThemeCutColor); }));
+    EXPECT_TRUE(std::any_of(distinct.begin(), distinct.end(), [](const auto& c) { return approxEqual(c, kThemeBodyColor); }));
+}
+
+TEST(MultiColorCsgMerge, ExportWritesRealColoursForTheThemeStandIns) {
+    // A file has no theme: the stand-ins are written as the colours they
+    // replaced, so exports are unchanged.
+    Evaluated e = evalSrc("difference() { cube(10); translate([5,5,-1]) cylinder(h=12, d=6, $fn=16); }");
+    const std::vector<ExportObject> objs = splitBodiesForExport(e.bodies, nullptr, false, true);
+    ASSERT_EQ(objs.size(), 1u);
+    const auto distinct = distinctColors(objs[0].triColors);
+    EXPECT_EQ(distinct.size(), 2u);
     EXPECT_TRUE(std::any_of(distinct.begin(), distinct.end(), [](const auto& c) { return approxEqual(c, kCutFaceColor); }));
     EXPECT_TRUE(std::any_of(distinct.begin(), distinct.end(), [](const auto& c) { return approxEqual(c, kDefaultGeometryColor); }));
 }