openscad-cpp-evaluator 1.32.0__tar.gz → 1.34.0__tar.gz

{openscad_cpp_evaluator-1.32.0 → openscad_cpp_evaluator-1.34.0}/CLAUDE.md

@@ -1091,8 +1091,8 @@ grep for `ponytail:`.
   — skip it and the mesh comes out non-manifold at the seam). Self-contained 2D geometry math here
   (`dot2`/`len2`/`norm2`, the parabola-canonical-frame rotation in `discretizeArc`) exists nowhere
   else in this codebase.
-- `include/openscad_cpp_evaluator/export.hpp`, `src/export.cpp` — the writers for all eleven
-  formats `exportExtensions()` lists: 3MF, AMF, DXF, PDF, STL, OBJ, OFF, PLY, SVG, VRML, X3D (3MF via
+- `include/openscad_cpp_evaluator/export.hpp`, `src/export.cpp` — the writers for all twelve
+  formats `exportExtensions()` lists: 3MF, AMF, DXF, PDF, STL, OBJ, OFF, PLY, POV, SVG, VRML, X3D (3MF via
   `zip_stored.hpp`'s `writeDeflateZip`). **`exportExtensions()` is the one source of truth for
   which formats exist** — the Python facade and BelfrySCAD's dialog/CLI all ask it rather than
   restating the list, because three hand-written copies had already drifted far enough that `.off`
@@ -1120,6 +1120,20 @@ grep for `ponytail:`.
   binary's, vertex order and 6-vertex line wrap included. A 3D body in the list throws
   ("Current top level object is not a 2D object"), as OpenSCAD refuses too: there is no projection
   to fall back on. `ExportOptions::svg` carries OpenSCAD's five `-O export-svg/...` settings.
+  **`writePov` writes POV-Ray, as `mesh2`** — one per object `splitBodiesForExport` produces, with
+  a welded vertex list, a `texture_list` of the object's colours and a texture index per triangle
+  (so per-triangle colour needs no unwelding, unlike PLY), and `inside_vector` so POV-Ray treats it
+  as a SOLID (the `ior 1.32` interior refracts; CSG works). OpenSCAD's `export_pov.cc` writes every
+  face as its own flat `polygon` object instead. The rest of the scene is OpenSCAD's: header,
+  MATERIAL finish, 27 lights around the bounding box, radiosity from `rad_def.inc`, colour as
+  `rgbf` with filter = 1 − alpha. `ExportPovOptions::camera` ($vpt, $vpr, distance, fov; Python
+  `pov_camera`, 8 numbers) writes OpenSCAD's camera block with **two fixes, both found by rendering
+  in POV-Ray 3.7 and comparing with BelfrySCAD's PNG of the same camera** (they now agree to a
+  pixel): `rotate` comes before `translate`, since the eye orbits `$vpt` (OpenSCAD translates first
+  and frames the wrong place when a view both pans and turns); and the viewport's **vertical** fov
+  becomes POV-Ray's **horizontal** `angle` through an expression on `image_width/image_height`
+  (OpenSCAD writes it across unchanged, zooming its renders in by the aspect ratio). No camera frames
+  the bounding box, as OpenSCAD does without one.
   **`writeDxf` is the third 2D writer**, also on `collect2d()`: OpenSCAD's own `export_dxf.cc`
   layout verbatim (AC1006 header with the extents, one CONTINUOUS linetype, layer 0, every contour
   a closed `LWPOLYLINE` on layer 0 with holes as ordinary contours; 1- and 2-vertex contours as
@@ -1171,10 +1185,21 @@ grep for `ponytail:`.
 - `include/openscad_cpp_evaluator/mesh_import.hpp`, `src/import/mesh_import.cpp` — STL (ASCII +
   binary, exact-match vertex welding)/OBJ/OFF/3MF mesh loaders, returning plain `(verts, tris)` —
   no `Evaluator`/`Value` dependency, so these are reusable from both `import()` contexts below.
+- `src/import/scene_import.cpp` — AMF, X3D and VRML97 import, the three multi-object formats export
+  writes that nothing could read back (current upstream OpenSCAD removed its AMF importer, so all
+  three go beyond it). Geometry only, like the loaders above, but each format's scene structure is
+  honoured: X3D/VRML `Transform`s nest and apply in full (`T·C·R·SR·S·SR⁻¹·C⁻¹`), `DEF`/`USE`
+  resolves, `ccw FALSE` flips winding, `IndexedFaceSet` polygons fan-triangulate (a last polygon
+  without `-1` counts), and X3D's `IndexedTriangleSet`/`TriangleSet` are read. X3D goes through a
+  small real XML parser (comments, CDATA, DOCTYPE, entities); VRML through a tokenizer + generic
+  node parser that steps over `PROTO`/`EXTERNPROTO`/`ROUTE` (VRML 1.0 is refused by name). AMF's
+  `unit` scales to mm, and a zipped AMF (`PK` header) is read through `readStoredZipEntryBySuffix`.
+  What is not a mesh — primitives (Box, Sphere, ...), `Inline`, AMF constellations — lands in
+  `LoadedMesh::warnings`, which both `import()` faces emit as `import: '<file>': ...`.
 - `include/openscad_cpp_evaluator/import_builtin.hpp`, `include/openscad_cpp_evaluator/
   zip_stored.hpp` (+ `src/zip_stored.cpp`), `src/builtins/import.cpp` — `import()`'s two faces:
   `resolveImport`/`generateImport` (registered in `registry.cpp` like any other builtin *module* —
-  a geometry statement, STL/OBJ/OFF/3MF/DXF/SVG) and `importAsValue` (called directly from
+  a geometry statement, STL/OBJ/OFF/3MF/AMF/X3D/VRML/DXF/SVG) and `importAsValue` (called directly from
   `user_calls.cpp`'s `evalFunctionCall`, special-cased *before* the `isBuiltinFunctionName` gate
   since `import` isn't in that table — returns a VNF `[[verts],[faces]]` for a mesh file, a Region
   `[[[x,y],...],...]` for DXF/SVG, or the JSON file's content as native values).

{openscad_cpp_evaluator-1.32.0 → openscad_cpp_evaluator-1.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.32.0
+Version: 1.34.0
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT

{openscad_cpp_evaluator-1.32.0 → openscad_cpp_evaluator-1.34.0}/bindings/module.cpp

@@ -436,14 +436,30 @@ nb::list exportModelPy(const std::string& path, const Geometry& geom, const std:
                         bool stripSlivers, bool splitComponents, bool splitColors, bool svgFill,
                         const std::string& svgFillColor,
                         bool svgStroke, const std::string& svgStrokeColor, double svgStrokeWidth,
-                        nb::object pdfOptions) {
+                        nb::object pdfOptions, nb::object povCamera) {
     oscadeval::ExportPdfOptions pdf;
     if (!pdfOptions.is_none()) applyPdfOptions(nb::cast<nb::dict>(pdfOptions), pdf);
+    oscadeval::ExportPovOptions pov;
+    if (!povCamera.is_none()) {
+        const std::vector<double> c = nb::cast<std::vector<double>>(povCamera);
+        if (c.size() != 8) {
+            throw std::runtime_error("pov_camera takes 8 numbers: $vpt x, y, z, $vpr x, y, z, distance, fov");
+        }
+        oscadeval::ExportPovCamera cam;
+        for (int k = 0; k < 3; ++k) {
+            cam.vpt[k] = c[k];
+            cam.vpr[k] = c[3 + k];
+        }
+        cam.distance = c[6];
+        cam.fov = c[7];
+        pov.camera = cam;
+    }
     std::vector<std::string> warnings;
     {
         nb::gil_scoped_release rel;
         oscadeval::ExportOptions opts;
         opts.pdf = pdf;
+        opts.pov = pov;
         opts.format = format;
         opts.asciiStl = asciiStl;
         opts.stripSlivers = stripSlivers;
@@ -957,7 +973,7 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           nb::arg("svg_fill") = false,
           nb::arg("svg_fill_color") = std::string("white"), nb::arg("svg_stroke") = true,
           nb::arg("svg_stroke_color") = std::string("black"), nb::arg("svg_stroke_width") = 0.35,
-          nb::arg("pdf_options") = nb::none(),
+          nb::arg("pdf_options") = nb::none(), nb::arg("pov_camera") = nb::none(),
           "Write `geometry` to `path`, format taken from the extension unless `format` says otherwise. "
           "Returns the warnings to surface (open shells, mesh problems, slivers removed) rather than "
           "logging them. Raises RuntimeError when there is no geometry, the format is unknown, or the "
@@ -976,7 +992,10 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "(paper-size, orientation, show-scale, show-scale-message, show-grid, grid-size, "
           "show-filename, design-filename, fill, fill-color, stroke, stroke-color, stroke-width, "
           "add-meta-data, title, author, subject, keywords). An unknown key raises rather than "
-          "being ignored. .pdf is 2D-only too, and centres the drawing on a fixed paper size.");
+          "being ignored. .pdf is 2D-only too, and centres the drawing on a fixed paper size.\n\n"
+          "pov_camera is .pov's camera as 8 numbers -- $vpt x, y, z, $vpr x, y, z, distance, fov -- "
+          "so a POV-Ray render frames what the viewport showed. None frames the model from its "
+          "bounding box, as OpenSCAD does without a camera.");
 
     m.def("list_fonts", []() {
         nb::list out;

{openscad_cpp_evaluator-1.32.0 → openscad_cpp_evaluator-1.34.0}/include/openscad_cpp_evaluator/export.hpp

@@ -4,6 +4,7 @@
 
 #include <array>
 #include <cstdint>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -233,6 +234,33 @@ std::vector<std::string> writePdf(const std::string& path, const std::vector<Col
 
 // -- one entry point ------------------------------------------------------
 
+// POV-Ray's camera, as OpenSCAD's viewport states it: $vpt, $vpr, $vpd and
+// the field of view. Without one the scene is framed from the model's
+// bounding box, as OpenSCAD frames it when it has no camera to pass.
+struct ExportPovCamera {
+    double vpt[3] = {0, 0, 0};
+    double vpr[3] = {0, 0, 0};
+    double distance = 0;
+    double fov = 22.5;
+};
+
+struct ExportPovOptions {
+    std::optional<ExportPovCamera> camera;
+};
+
+// POV-Ray scene description. Every object splitBodiesForExport produces is
+// one mesh2 -- a welded vertex list, a texture per colour, and a texture
+// index per triangle, so per-triangle colour needs no unwelding -- with
+// inside_vector, which makes it a SOLID to POV-Ray (refraction, CSG). That
+// is the difference from OpenSCAD's export_pov.cc, which writes every face
+// as its own flat polygon object. The rest of the scene is OpenSCAD's: its
+// header, MATERIAL finish and ior 1.32 interior, 27 lights around the
+// bounding box, its camera, and radiosity from rad_def.inc. Colour is rgbf
+// with filter = 1 - alpha, as OpenSCAD writes it. Numbers are the shortest
+// text that round-trips, in the classic locale.
+void writePov(const std::string& path, const std::vector<ExportObject>& objects,
+              const ExportPovOptions& opts = {});
+
 struct ExportOptions {
     // Empty means "decide from the path's extension".
     std::string format;
@@ -258,6 +286,8 @@ struct ExportOptions {
     ExportSvgOptions svg;
     // .pdf only.
     ExportPdfOptions pdf;
+    // .pov only.
+    ExportPovOptions pov;
 };
 
 // Writes `bodies` to `path`, choosing the writer from the extension (or

{openscad_cpp_evaluator-1.32.0 → openscad_cpp_evaluator-1.34.0}/include/openscad_cpp_evaluator/mesh_import.hpp

@@ -13,6 +13,9 @@ namespace oscadeval {
 struct LoadedMesh {
     std::vector<std::array<double, 3>> verts;
     std::vector<std::array<int, 3>> tris;
+    // What the loader read but could not turn into mesh (X3D/VRML primitives,
+    // Inline, AMF constellations), for import() to warn about.
+    std::vector<std::string> warnings;
 };
 
 // Each throws std::runtime_error with a message suitable for wrapping into
@@ -23,5 +26,11 @@ LoadedMesh loadStl(const std::string& path);
 LoadedMesh loadObj(const std::string& path);
 LoadedMesh loadOff(const std::string& path);
 LoadedMesh loadThreeMf(const std::string& path);
+// scene_import.cpp: the three multi-object formats export writes. AMF (plain
+// or zipped, `unit` scaled to mm), X3D and VRML97 (Transforms applied,
+// DEF/USE resolved, polygons fan-triangulated). Geometry only, like the rest.
+LoadedMesh loadAmf(const std::string& path);
+LoadedMesh loadX3d(const std::string& path);
+LoadedMesh loadVrml(const std::string& path);
 
 } // namespace oscadeval

{openscad_cpp_evaluator-1.32.0 → openscad_cpp_evaluator-1.34.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.32.0 → openscad_cpp_evaluator-1.34.0}/python/openscad_cpp_evaluator/__init__.py

@@ -331,7 +331,8 @@ def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
                  split_colors: bool = True,
                  svg_fill: bool = False, svg_fill_color: str = "white",
                  svg_stroke: bool = True, svg_stroke_color: str = "black",
-                 svg_stroke_width: float = 0.35, pdf_options: dict | None = None) -> list:
+                 svg_stroke_width: float = 0.35, pdf_options: dict | None = None,
+                 pov_camera=None) -> list:
     """Write `geometry` to `path`. Returns the warnings to surface.
 
     `geometry` is the handle an Evaluator stashes on itself as
@@ -374,12 +375,17 @@ def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
     size with nothing to explain it. `.pdf` is 2D-only like `.svg`, and
     centres the drawing on a fixed paper size instead of cutting the page
     to fit.
+
+    `pov_camera` is `.pov`'s camera as eight numbers -- `$vpt` x, y, z,
+    `$vpr` x, y, z, distance, field of view -- so a POV-Ray render frames
+    what the viewport showed. None frames the model from its bounding box,
+    as OpenSCAD does when it has no camera to pass.
     """
     try:
         return list(_ext.export_model(path, geometry, format, ascii_stl, strip_slivers,
                                        split_components, split_colors, svg_fill, svg_fill_color,
                                        svg_stroke, svg_stroke_color, svg_stroke_width,
-                                       pdf_options))
+                                       pdf_options, pov_camera))
     except Exception as e:
         raise EvalError(str(e)) from e
 

{openscad_cpp_evaluator-1.32.0 → openscad_cpp_evaluator-1.34.0}/src/CMakeLists.txt

@@ -23,6 +23,7 @@ add_library(openscad_cpp_evaluator STATIC
   mesh_check.cpp
   zip_stored.cpp
   import/mesh_import.cpp
+  import/scene_import.cpp
   import/surface_load.cpp
   import/dxf_import.cpp
   import/svg_import.cpp

{openscad_cpp_evaluator-1.32.0 → openscad_cpp_evaluator-1.34.0}/src/builtins/import.cpp

@@ -46,10 +46,16 @@ LoadedMesh loadMeshByExt(const std::string& path, const std::string& ext) {
     if (ext == ".stl") return loadStl(path);
     if (ext == ".obj") return loadObj(path);
     if (ext == ".off") return loadOff(path);
+    if (ext == ".amf") return loadAmf(path);
+    if (ext == ".x3d") return loadX3d(path);
+    if (ext == ".wrl") return loadVrml(path);
     return loadThreeMf(path);
 }
 
-bool isMeshExt(const std::string& ext) { return ext == ".stl" || ext == ".obj" || ext == ".off" || ext == ".3mf"; }
+bool isMeshExt(const std::string& ext) {
+    return ext == ".stl" || ext == ".obj" || ext == ".off" || ext == ".3mf" || ext == ".amf" || ext == ".x3d" ||
+           ext == ".wrl";
+}
 
 
 Value jsonToValue(const nlohmann::ordered_json& j) {
@@ -208,7 +214,10 @@ CSGParams resolveImport(Evaluator& ev, const oscad::ModularCall& node, EvalConte
         params["dxf"] = Value{ext == ".dxf"};
         return params;
     }
-    if (ext == ".dxf" || ext == ".svg" || ext == ".pdf") {
+    // .pdf is not here: it used to be, handed to the SVG parser, which hung on
+    // a PDF's bytes. Nothing reads PDF (OpenSCAD does not either), so it takes
+    // the ordinary "unsupported file type" error below.
+    if (ext == ".dxf" || ext == ".svg") {
         std::vector<Contour2d> contours;
         bool filteredMiss = false;
         try {
@@ -257,6 +266,7 @@ CSGParams resolveImport(Evaluator& ev, const oscad::ModularCall& node, EvalConte
         } catch (const std::exception& e) {
             ev.error(std::string("import: ") + e.what(), node);
         }
+        for (const std::string& w : mesh.warnings) ev.warn("import: '" + path + "': " + w, &node.position());
         std::vector<Value> vertsFlat;
         vertsFlat.reserve(mesh.verts.size() * 3);
         for (const auto& v : mesh.verts) {
@@ -428,8 +438,12 @@ Value importAsValue(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& n
 
     try {
         if (ext == ".json") return loadJsonAsValue(path);
-        if (isMeshExt(ext)) return meshToVnf(loadMeshByExt(path, ext));
-        if (ext == ".dxf" || ext == ".svg" || ext == ".pdf") {
+        if (isMeshExt(ext)) {
+            const LoadedMesh mesh = loadMeshByExt(path, ext);
+            for (const std::string& w : mesh.warnings) ev.warn("import: '" + path + "': " + w, &node.position());
+            return meshToVnf(mesh);
+        }
+        if (ext == ".dxf" || ext == ".svg") {
             std::vector<Contour2d> contours;
             if (ext == ".dxf") {
                 std::optional<std::string> layer;

{openscad_cpp_evaluator-1.32.0 → openscad_cpp_evaluator-1.34.0}/src/export.cpp

@@ -915,7 +915,8 @@ std::string lowerExtension(const std::string& path) {
 }
 
 bool isMultiObject(const std::string& ext) {
-    return ext == ".3mf" || ext == ".amf" || ext == ".obj" || ext == ".ply" || ext == ".wrl" || ext == ".x3d";
+    return ext == ".3mf" || ext == ".amf" || ext == ".obj" || ext == ".ply" || ext == ".pov" || ext == ".wrl" ||
+           ext == ".x3d";
 }
 
 // The merged single mesh STL/OFF write, with the open shells kept.
@@ -1256,6 +1257,159 @@ void writeDxf(const std::string& path, const std::vector<ColoredBody>& bodies) {
 
 namespace {
 
+// dxfNum's rule for a float: the shortest text that reads back as the same
+// float. Mesh vertices and colours are floats, and printing them as doubles
+// would turn 0.1f into 0.100000001490116.
+std::string floatNum(float v) {
+    if (!std::isfinite(v) || v == 0.0f) return "0";
+    for (int digits = 6; digits <= 9; ++digits) {
+        std::ostringstream o;
+        o.imbue(std::locale::classic());
+        o.precision(digits);
+        o << v;
+        std::istringstream in(o.str());
+        in.imbue(std::locale::classic());
+        float back = 0.0f;
+        in >> back;
+        if (back == v) return o.str();
+    }
+    std::ostringstream o;  // unreachable: 9 digits always round-trips a float
+    o.imbue(std::locale::classic());
+    o.precision(9);
+    o << v;
+    return o.str();
+}
+
+std::string povVec(double x, double y, double z) {
+    return "<" + dxfNum(x) + ", " + dxfNum(y) + ", " + dxfNum(z) + ">";
+}
+
+}  // namespace
+
+void writePov(const std::string& path, const std::vector<ExportObject>& objects, const ExportPovOptions& opts) {
+    std::ofstream out(path);
+    if (!out) throw std::runtime_error("Could not open '" + path + "' for writing");
+    out.imbue(std::locale::classic());
+
+    out << "// Generated by BelfrySCAD (openscad_cpp_evaluator)\n\n"
+        << "// Camera settings are at the bottom of this script\n\n"
+        << "#version 3.7;\n"
+        << "global_settings { assumed_gamma 1.0 }\n"
+        << "#declare MATERIAL=finish { specular 0.5 roughness 0.001 reflection{0 0.63 fresnel} ambient 0 "
+           "diffuse 0.6 conserve_energy }\n"
+        << "#declare MATERIAL_INT=interior{ior 1.32}\n";
+
+    const auto rgbf = [](const std::array<float, 4>& c) {
+        return "<" + floatNum(c[0]) + ", " + floatNum(c[1]) + ", " + floatNum(c[2]) + ", " +
+               floatNum(1.0f - c[3]) + ">";
+    };
+
+    bool any = false;
+    double lo[3] = {0, 0, 0}, hi[3] = {0, 0, 0};
+    for (const ExportObject& o : objects) {
+        const size_t vertCount = o.verts.size() / 3;
+        const size_t triCount = o.tris.size() / 3;
+        if (vertCount == 0 || triCount == 0) continue;
+        for (size_t v = 0; v < vertCount; ++v) {
+            for (int k = 0; k < 3; ++k) {
+                const double c = o.verts[v * 3 + k];
+                if (!any) {
+                    lo[k] = hi[k] = c;
+                } else {
+                    lo[k] = std::min(lo[k], c);
+                    hi[k] = std::max(hi[k], c);
+                }
+            }
+            any = true;
+        }
+
+        // One texture per distinct colour, in order of first use.
+        std::vector<std::array<float, 4>> palette;
+        std::vector<size_t> triTexture(triCount, 0);
+        const auto textureOf = [&](const std::array<float, 4>& c) {
+            for (size_t i = 0; i < palette.size(); ++i) {
+                if (palette[i] == c) return i;
+            }
+            palette.push_back(c);
+            return palette.size() - 1;
+        };
+        for (size_t t = 0; t < triCount; ++t) {
+            triTexture[t] = textureOf(o.triColors.empty() ? o.color : o.triColors[t]);
+        }
+
+        out << "mesh2 {\n  vertex_vectors { " << vertCount;
+        for (size_t v = 0; v < vertCount; ++v) {
+            out << ",\n    <" << floatNum(o.verts[v * 3]) << ", " << floatNum(o.verts[v * 3 + 1]) << ", "
+                << floatNum(o.verts[v * 3 + 2]) << ">";
+        }
+        out << "\n  }\n  texture_list { " << palette.size();
+        for (const std::array<float, 4>& c : palette) {
+            out << "\n    texture { pigment { color rgbf " << rgbf(c) << " } finish { MATERIAL } }";
+        }
+        out << "\n  }\n  face_indices { " << triCount;
+        for (size_t t = 0; t < triCount; ++t) {
+            out << ",\n    <" << o.tris[t * 3] << ", " << o.tris[t * 3 + 1] << ", " << o.tris[t * 3 + 2] << ">, "
+                << triTexture[t];
+        }
+        // inside_vector: without it POV-Ray treats a mesh as a bare surface,
+        // with no inside for the interior (and its ior) or CSG to act on.
+        out << "\n  }\n  inside_vector <0, 0, 1>\n  interior { MATERIAL_INT }\n}\n";
+    }
+    if (!any) throw std::runtime_error("No geometry to export");
+
+    // 27 lights: every combination of {below, centre, above} on each axis,
+    // twice the model's size out, at OpenSCAD's brightness.
+    const double move = 2.0;
+    double at[3][3];
+    for (int k = 0; k < 3; ++k) {
+        const double d = hi[k] - lo[k];
+        at[k][0] = lo[k] - d * move;
+        at[k][1] = (lo[k] + hi[k]) / 2.0;
+        at[k][2] = hi[k] + d * move;
+    }
+    for (double x : at[0]) {
+        for (double y : at[1]) {
+            for (double z : at[2]) {
+                out << "light_source { " << povVec(x, y, z) << " color rgb <0.2, 0.2, 0.2> }\n";
+            }
+        }
+    }
+
+    if (opts.camera) {
+        // OpenSCAD's camera block, with two fixes, both checked by rendering
+        // in POV-Ray against BelfrySCAD's own image of the same camera:
+        //  - rotate BEFORE translate. The eye orbits $vpt, so it is rotated
+        //    about the origin and then moved; OpenSCAD translates first,
+        //    which rotates $vpt itself away and frames the wrong place
+        //    whenever a view both pans and turns.
+        //  - the field of view is VERTICAL in the viewport and HORIZONTAL to
+        //    POV-Ray's `angle`. OpenSCAD writes it straight across, so its
+        //    renders come out zoomed in by the aspect ratio (1.33x at 4:3).
+        //    The horizontal angle is left to POV-Ray to work out from the
+        //    image it is asked for, so any size frames the same.
+        const ExportPovCamera& c = *opts.camera;
+        out << "camera { look_at <0, 0, 0>\n"
+            << " location <0, 0, " << dxfNum(c.distance) << ">\n"
+            << " angle degrees(2 * atan(tan(radians(" << dxfNum(c.fov) << " / 2)) * image_width / image_height))"
+            << " up <0, 1, 0> right <1, 0, 0> sky <0, 1, 0> right -x*image_width/image_height\n"
+            << "rotate <" << dxfNum(c.vpr[0]) << ", " << dxfNum(c.vpr[1]) << " + clock * 3, " << dxfNum(c.vpr[2])
+            << " + clock>\n"
+            << "translate " << povVec(c.vpt[0], c.vpt[1], c.vpt[2]) << "\n"
+            << "}\n";
+    } else {
+        const double dx = hi[0] - lo[0], dy = hi[1] - lo[1], dz = hi[2] - lo[2];
+        out << "camera { look_at " << povVec((lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2)
+            << " location " << povVec(lo[0] + dx * move, lo[1] - dy * move, lo[2] + dz * move)
+            << " up <0, 0, 1> right <1, 0, 0> sky <0, 0, 1> rotate <-55, clock * 3, clock + 25> right "
+               "x*image_width/image_height }\n";
+    }
+    out << "#include \"rad_def.inc\"\n"
+        << "global_settings { photons { count 20000 autostop 0 jitter .4 } radiosity { "
+           "Rad_Settings(Radiosity_Normal, off, off) } }\n";
+}
+
+namespace {
+
 // PDF's own unit is 1/72 inch; models are millimetres.
 constexpr double kPtPerMm = 72.0 / 25.4;
 // Page margin the ruler is drawn on, in points. OpenSCAD's own MARGIN.
@@ -1599,7 +1753,7 @@ std::vector<std::string> writePdf(const std::string& path, const std::vector<Col
 
 const std::vector<std::string>& exportExtensions() {
     static const std::vector<std::string> exts = {".3mf", ".amf", ".dxf", ".pdf", ".stl", ".obj",
-                                                  ".off", ".ply", ".svg", ".wrl", ".x3d"};
+                                                  ".off", ".ply", ".pov", ".svg", ".wrl", ".x3d"};
     return exts;
 }
 
@@ -1656,6 +1810,8 @@ std::vector<std::string> exportModel(const std::string& path, const std::vector<
             writeObj(path, objects);
         } else if (ext == ".ply") {
             writePly(path, objects);
+        } else if (ext == ".pov") {
+            writePov(path, objects, opts.pov);
         } else if (ext == ".wrl") {
             writeVrml(path, objects);
         } else {