chili3d 0.6.1

package/cpp/src/shared.hpp

@@ -0,0 +1,211 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+#pragma once
+
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+
+#include <gp_Ax1.hxx>
+#include <gp_Ax2.hxx>
+#include <gp_Ax3.hxx>
+#include <gp_Dir.hxx>
+#include <gp_Pln.hxx>
+#include <gp_Pnt.hxx>
+#include <gp_Vec.hxx>
+
+#define STR(x) #x
+#define REGISTER_HANDLE(T)                                       \
+    class_<Handle_##T>(STR(Handle_##T))                          \
+        .constructor<const T*>()                                 \
+        .function("get", &Handle_##T::get, allow_raw_pointers()) \
+        .function("isNull", &Handle_##T::IsNull)
+
+class Math {
+public:
+    constexpr static const double PI = 3.14159265358979323846;
+    constexpr static const double PI_2 = PI * 2;
+    constexpr static const double PI_h = PI / 2;
+};
+
+struct Domain {
+    double start;
+    double end;
+};
+
+struct UV {
+    double u;
+    double v;
+};
+
+struct Vector3 {
+    double x;
+    double y;
+    double z;
+
+    static gp_XYZ toXYZ(const Vector3& p)
+    {
+        return gp_XYZ(p.x, p.y, p.z);
+    }
+
+    static gp_Pnt toPnt(const Vector3& p)
+    {
+        return gp_Pnt(p.x, p.y, p.z);
+    }
+
+    static Vector3 fromPnt(const gp_Pnt& p)
+    {
+        return Vector3 { p.X(), p.Y(), p.Z() };
+    }
+
+    static gp_Dir toDir(const Vector3& p)
+    {
+        return gp_Dir(p.x, p.y, p.z);
+    }
+
+    static Vector3 fromDir(const gp_Dir& p)
+    {
+        return Vector3 { p.X(), p.Y(), p.Z() };
+    }
+
+    static gp_Vec toVec(const Vector3& p)
+    {
+        return gp_Vec(p.x, p.y, p.z);
+    }
+
+    static Vector3 fromVec(const gp_Vec& p)
+    {
+        return Vector3 { p.X(), p.Y(), p.Z() };
+    }
+};
+
+struct PointAndParameter {
+    Vector3 point;
+    double parameter;
+};
+
+struct Ax1 {
+    Vector3 location;
+    Vector3 direction;
+
+    static gp_Ax1 toAx1(const Ax1& a)
+    {
+        return gp_Ax1(Vector3::toPnt(a.location), Vector3::toDir(a.direction));
+    }
+
+    static Ax1 fromAx1(const gp_Ax1& a)
+    {
+        return Ax1 { Vector3::fromPnt(a.Location()), Vector3::fromDir(a.Direction()) };
+    }
+};
+
+struct Ax2 {
+    Vector3 location;
+    Vector3 direction;
+    Vector3 xDirection;
+
+    static gp_Ax2 toAx2(const Ax2& a)
+    {
+        return gp_Ax2(Vector3::toPnt(a.location), Vector3::toDir(a.direction), Vector3::toDir(a.xDirection));
+    }
+
+    static Ax2 fromAx2(const gp_Ax2& a)
+    {
+        return Ax2 { Vector3::fromPnt(a.Location()), Vector3::fromDir(a.Direction()), Vector3::fromDir(a.XDirection()) };
+    }
+};
+
+struct Ax3 {
+    Vector3 location;
+    Vector3 direction;
+    Vector3 xDirection;
+
+    static gp_Ax2 toAx2(const Ax3& a)
+    {
+        return gp_Ax2(Vector3::toPnt(a.location), Vector3::toDir(a.direction), Vector3::toDir(a.xDirection));
+    }
+
+    static Ax3 fromAx2(const gp_Ax2& a)
+    {
+        return Ax3 { Vector3::fromPnt(a.Location()), Vector3::fromDir(a.Direction()), Vector3::fromDir(a.XDirection()) };
+    }
+
+    static gp_Ax3 toAx3(const Ax3& a)
+    {
+        return gp_Ax3(Vector3::toPnt(a.location), Vector3::toDir(a.direction), Vector3::toDir(a.xDirection));
+    }
+
+    static Ax3 fromAx3(const gp_Ax3& a)
+    {
+        return Ax3 { Vector3::fromPnt(a.Location()), Vector3::fromDir(a.Direction()), Vector3::fromDir(a.XDirection()) };
+    }
+
+    static gp_Pln toPln(const Ax3& a)
+    {
+        return gp_Pln(toAx3(a));
+    }
+};
+
+struct Pln {
+    Vector3 location;
+    Vector3 direction;
+    Vector3 xDirection;
+
+    static gp_Pln toPln(const Pln& a)
+    {
+        return gp_Pln(toAx3(a));
+    }
+
+    static gp_Ax3 toAx3(const Pln& a)
+    {
+        return gp_Ax3(Vector3::toPnt(a.location), Vector3::toDir(a.direction), Vector3::toDir(a.xDirection));
+    }
+
+    static Pln fromAx3(const gp_Ax3& a)
+    {
+        return Pln { Vector3::fromPnt(a.Location()), Vector3::fromDir(a.Direction()), Vector3::fromDir(a.XDirection()) };
+    }
+
+    static Pln fromPln(const gp_Pln& a)
+    {
+        return Pln { Vector3::fromPnt(a.Location()), Vector3::fromDir(a.Axis().Direction()),
+            Vector3::fromDir(a.XAxis().Direction()) };
+    }
+};
+
+struct ProjectPointResult {
+    Vector3 point;
+    double distance;
+    double parameter;
+};
+
+struct ExtremaCCResult {
+    bool isParallel;
+    double distance;
+    Vector3 p1;
+    Vector3 p2;
+    double u1;
+    double u2;
+};
+
+EMSCRIPTEN_DECLARE_VAL_TYPE(Int8Array)
+EMSCRIPTEN_DECLARE_VAL_TYPE(Int16Array)
+EMSCRIPTEN_DECLARE_VAL_TYPE(Int32Array)
+EMSCRIPTEN_DECLARE_VAL_TYPE(Uint8Array)
+EMSCRIPTEN_DECLARE_VAL_TYPE(Uint16Array)
+EMSCRIPTEN_DECLARE_VAL_TYPE(Uint32Array)
+EMSCRIPTEN_DECLARE_VAL_TYPE(Float32Array)
+EMSCRIPTEN_DECLARE_VAL_TYPE(Float64Array)
+EMSCRIPTEN_DECLARE_VAL_TYPE(BigInt64Array)
+EMSCRIPTEN_DECLARE_VAL_TYPE(BigUint64Array)
+
+EMSCRIPTEN_DECLARE_VAL_TYPE(Vector3Array)
+
+EMSCRIPTEN_DECLARE_VAL_TYPE(NumberArray)
+EMSCRIPTEN_DECLARE_VAL_TYPE(EdgeArray)
+EMSCRIPTEN_DECLARE_VAL_TYPE(WireArray)
+EMSCRIPTEN_DECLARE_VAL_TYPE(FaceArray)
+EMSCRIPTEN_DECLARE_VAL_TYPE(ShellArray)
+EMSCRIPTEN_DECLARE_VAL_TYPE(ShapeArray)
+EMSCRIPTEN_DECLARE_VAL_TYPE(PointAndParameterArray)
+EMSCRIPTEN_DECLARE_VAL_TYPE(PntArray)

package/cpp/src/transient.cpp

@@ -0,0 +1,29 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+
+#include <Standard_Transient.hxx>
+
+using namespace emscripten;
+
+class Transient {
+public:
+    static bool isKind(const Standard_Transient* t, const std::string& name)
+    {
+        return t->IsKind(name.c_str());
+    }
+
+    static bool isInstance(const Standard_Transient* t, const std::string& name)
+    {
+        return t->IsInstance(name.c_str());
+    }
+};
+
+EMSCRIPTEN_BINDINGS(Transient)
+{
+    class_<Transient>("Transient")
+        .class_function("isKind", &Transient::isKind, allow_raw_pointers())
+        .class_function("isInstance", &Transient::isInstance, allow_raw_pointers());
+}

package/cpp/src/utils.cpp

@@ -0,0 +1,114 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+#include "utils.hpp"
+
+#include <BRepBndLib.hxx>
+#include <Bnd_Box.hxx>
+#include <GeomAPI_ExtremaCurveCurve.hxx>
+#include <GeomAPI_ProjectPointOnCurve.hxx>
+
+std::vector<ExtremaCCResult> extremaCCs(const Geom_Curve* curve1, const Geom_Curve* curve2, double maxDistance)
+{
+    std::vector<ExtremaCCResult> result;
+    GeomAPI_ExtremaCurveCurve extrema(curve1, curve2);
+    if (extrema.NbExtrema() == 0) {
+        return result;
+    }
+
+    gp_Pnt p1, p2;
+    double u1 = 0, u2 = 0;
+    for (int i = 1; i <= extrema.NbExtrema(); i++) {
+        double distance = extrema.Distance(i);
+        if (distance > maxDistance) {
+            continue;
+        }
+        extrema.Points(i, p1, p2);
+        extrema.Parameters(i, u1, u2);
+        result.push_back(ExtremaCCResult { .isParallel = extrema.IsParallel(),
+            .distance = distance,
+            .p1 = Vector3::fromPnt(p1),
+            .p2 = Vector3::fromPnt(p2),
+            .u1 = u1,
+            .u2 = u2 });
+    }
+
+    return result;
+}
+
+std::optional<ProjectPointResult> projectToCurve(const Geom_Curve* curve, gp_Pnt pnt)
+{
+    GeomAPI_ProjectPointOnCurve projector(pnt, curve);
+    if (projector.NbPoints() > 0) {
+        return ProjectPointResult { .point = Vector3::fromPnt(projector.NearestPoint()),
+            .distance = projector.LowerDistance(),
+            .parameter = projector.LowerDistanceParameter() };
+    }
+
+    return std::nullopt;
+}
+
+ProjectPointResult nearestEnd(const Geom_Curve* curve, gp_Pnt pnt)
+{
+    gp_Pnt start = curve->Value(curve->FirstParameter());
+    gp_Pnt end = curve->Value(curve->LastParameter());
+    double distanceToStart = pnt.Distance(start);
+    double distanceToEnd = pnt.Distance(end);
+    if (distanceToStart < distanceToEnd) {
+        return ProjectPointResult {
+            .point = Vector3::fromPnt(start), .distance = distanceToStart, .parameter = curve->FirstParameter()
+        };
+    } else {
+        return ProjectPointResult {
+            .point = Vector3::fromPnt(end), .distance = distanceToEnd, .parameter = curve->LastParameter()
+        };
+    }
+}
+
+ProjectPointResult projectOrNearestCP(const Geom_Curve* curve, const gp_Pnt& pnt)
+{
+    auto project = projectToCurve(curve, pnt);
+    if (project.has_value()) {
+        return project.value();
+    }
+
+    return nearestEnd(curve, pnt);
+}
+
+double boundingBoxRatio(const TopoDS_Shape& shape, double linearDeflection)
+{
+    Bnd_Box boundingBox;
+    BRepBndLib::Add(shape, boundingBox, false);
+    if (boundingBox.IsVoid()) {
+        return linearDeflection;
+    }
+    Standard_Real xMin, yMin, zMin, xMax, yMax, zMax;
+    boundingBox.Get(xMin, yMin, zMin, xMax, yMax, zMax);
+
+    Standard_Real avgSize = ((xMax - xMin) + (yMax - yMin) + (zMax - zMin)) / 3.0;
+    double linDeflection = avgSize * linearDeflection;
+    if (linDeflection < Precision::Confusion()) {
+        linDeflection = 1.0;
+    }
+    return linDeflection;
+}
+
+TopTools_SequenceOfShape shapeArrayToSequenceOfShape(const ShapeArray& shapes)
+{
+    std::vector<TopoDS_Shape> shapeVector = emscripten::vecFromJSArray<TopoDS_Shape>(shapes);
+    TopTools_SequenceOfShape result;
+    for (auto& s : shapeVector) {
+        result.Append(s);
+    }
+    return result;
+}
+
+TopTools_ListOfShape shapeArrayToListOfShape(const ShapeArray& shapes)
+{
+    std::vector<TopoDS_Shape> shapeVector = emscripten::vecFromJSArray<TopoDS_Shape>(shapes);
+    TopTools_ListOfShape result;
+    for (auto& s : shapeVector) {
+        result.Append(s);
+    }
+    return result;
+}

package/cpp/src/utils.hpp

@@ -0,0 +1,25 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+#pragma once
+
+#include <Geom_Curve.hxx>
+#include <TopTools_ListOfShape.hxx>
+#include <TopTools_SequenceOfShape.hxx>
+#include <TopoDS_Shape.hxx>
+#include <gp_Pnt.hxx>
+
+#include "shared.hpp"
+
+std::vector<ExtremaCCResult> extremaCCs(const Geom_Curve* curve1, const Geom_Curve* curve2, double maxDistance);
+
+std::optional<ProjectPointResult> projectToCurve(const Geom_Curve* curve, gp_Pnt pnt);
+
+ProjectPointResult nearestEnd(const Geom_Curve* curve, gp_Pnt pnt);
+
+ProjectPointResult projectOrNearestCP(const Geom_Curve* curve, const gp_Pnt& pnt);
+
+TopTools_SequenceOfShape shapeArrayToSequenceOfShape(const ShapeArray& shapes);
+TopTools_ListOfShape shapeArrayToListOfShape(const ShapeArray& shapes);
+
+double boundingBoxRatio(const TopoDS_Shape& shape, double linearDeflection);

package/cpp/test/index.html

@@ -0,0 +1,146 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>chili wasm test</title>
+    <style type="text/css">
+        body {
+            font-family: Arial, sans-serif;
+        }
+
+        #output {
+            margin: 20px;
+        }
+
+        h2 {
+            margin-top: 20px;
+        }
+
+        p {
+            margin: 0;
+            margin-left: 20px;
+        }
+
+        .failed {
+            color: red;
+        }
+
+        .result {
+            margin-top: 10px;
+            font-weight: bold;
+        }
+    </style>
+    
+</head>
+
+<body>
+    <div id="output"></div>
+    <script type="text/javascript">
+        function resultMessage(passed, failed, time) {
+            const p = document.createElement('p');
+            p.className = 'result';
+            p.innerHTML = `Passed: ${passed}, Failed: ${failed}, Time: ${time}`;
+            if (failed > 0) {
+                p.className += ' failed';
+            }
+            return p;
+        }
+
+        function failedMessage(actual, expected) {
+            const p = document.createElement('p');
+            p.innerHTML = `Expected ${expected}, but got ${actual}`;
+            p.className = 'failed';
+            return p;
+        }
+
+        async function test(name, fn) {
+            var passed = 0, failed = 0;
+            const expect = (actual) => {
+                return {
+                    toBe(expected) {
+                        if (actual !== expected) {
+                            div.append(failedMessage(actual, expected));
+                            failed++;
+                        } else {
+                            passed++;
+                        }
+                    }
+                };
+            };
+
+            const div = document.createElement('div');
+            div.className = 'test';
+            output.append(div);
+            const title = document.createElement('h2');
+            div.innerHTML = name
+            output.append(title);
+            const start = performance.now();
+            fn(expect);
+            const end = performance.now();
+            div.append(resultMessage(passed, failed, end - start));
+        }
+
+    </script>
+    <script type="module">
+        window.onload = async () => {
+            const initWasm = await import('../build/target/release/chili-wasm.js');
+            const wasm = await initWasm.default();
+            test("test face mesh", (expect) => {
+                const location = { x: 0, y: 0, z: 0 };
+                const direction = { x: 0, y: 0, z: 1 };
+                const xDirection = { x: 1, y: 0, z: 0 };
+                const ax3 = { location, direction, xDirection };
+                const box = wasm.ShapeFactory.box(ax3, 1, 2, 3).shape;
+                const mesher = new wasm.Mesher(box, 0.1);
+                const mesh = mesher.mesh();
+
+                expect(mesh.faceMeshData.position.length).toBe(72);
+                expect(mesh.faceMeshData.index.length).toBe(36);
+                expect(mesh.faceMeshData.group.length).toBe(12);
+                expect(mesh.faceMeshData.normal.length).toBe(72);
+                expect(mesh.faceMeshData.uv.length).toBe(48);
+            })
+
+            test("test edge mesh", (expect) => {
+                const location = { x: 0, y: 0, z: 0 };
+                const direction = { x: 0, y: 0, z: 1 };
+                const xDirection = { x: 1, y: 0, z: 0 };
+                const ax3 = { location, direction, xDirection };
+                const box = wasm.ShapeFactory.box(ax3, 1, 1, 1).shape;
+                const mesher = new wasm.Mesher(box, 0.1);
+                const mesh = mesher.mesh();
+                expect(mesh.edgeMeshData.position.length).toBe(72);
+                expect(mesh.edgeMeshData.group.length).toBe(24);
+            })
+
+            test("test shape", (expect) => {
+                const location = { x: 0, y: 0, z: 0 };
+                const direction = { x: 0, y: 0, z: 1 };
+                const xDirection = { x: 1, y: 0, z: 0 };
+                const ax3 = { location, direction, xDirection };
+                const box = wasm.ShapeFactory.box(ax3, 1, 1, 1).shape;
+                const edges = wasm.Shape.findSubShapes(box, wasm.TopAbs_ShapeEnum.TopAbs_EDGE);
+                expect(edges.length).toBe(12);
+                expect(edges[0].shapeType()).toBe(wasm.TopAbs_ShapeEnum.TopAbs_EDGE);
+
+                const curve = wasm.Edge.curve(wasm.TopoDS.edge(edges[0]));
+                const newEdge = wasm.Edge.fromCurve(curve.get());
+                expect(wasm.Edge.curveLength(newEdge)).toBe(1);
+
+                const faces = wasm.Shape.findAncestor(box, edges[1], wasm.TopAbs_ShapeEnum.TopAbs_FACE);
+                expect(faces.length).toBe(2);
+                expect(faces[0].shapeType()).toBe(wasm.TopAbs_ShapeEnum.TopAbs_FACE)
+
+                const faceEdges = wasm.Shape.findSubShapes(faces[0], wasm.TopAbs_ShapeEnum.TopAbs_EDGE);
+                expect(faceEdges.length).toBe(4);
+
+            })
+
+        }
+    </script>
+
+</body>
+
+</html>

package/package.json

@@ -0,0 +1,49 @@
+{
+    "name": "chili3d",
+    "version": "0.6.1",
+    "description": "",
+    "documentVersion": "0.7",
+    "author": "仙阁",
+    "scripts": {
+        "build": "rspack build",
+        "build:types": "tsc --project tsconfig.build.json",
+        "build:wasm": "cd cpp && cmake --preset release && cmake --build --preset release",
+        "build:all": "npm run build:types && npm run build",
+        "check": "biome check --write",
+        "dev": "rspack dev",
+        "format": "biome check --write . && npx clang-format --style=Webkit --sort-includes -i ./cpp/src/**",
+        "preview": "rspack preview",
+        "release": "node scripts/release.mjs",
+        "setup:wasm": "node scripts/setup_wasm_deps.mjs",
+        "test": "rstest",
+        "testc": "rstest --coverage"
+    },
+    "simple-git-hooks": {
+        "pre-commit": "npx lint-staged"
+    },
+    "lint-staged": {
+        "*.{ts,js,css,json,md,mjs}": [
+            "biome check --write"
+        ],
+        "*.{c,h,cxx,hxx,cpp,hpp}": [
+            "clang-format --style=Webkit --sort-includes -i"
+        ]
+    },
+    "workspaces": [
+        "packages/*"
+    ],
+    "devDependencies": {
+        "@biomejs/biome": "2.3.6",
+        "@rspack/cli": "1.6.3",
+        "@rspack/core": "1.6.3",
+        "@rstest/core": "^0.6.5",
+        "@rstest/coverage-istanbul": "^0.0.5",
+        "clang-format": "^1.8.0",
+        "fork-ts-checker-webpack-plugin": "9.1.0",
+        "happy-dom": "^20.0.10",
+        "lint-staged": "16.2.6",
+        "simple-git-hooks": "2.13.1",
+        "typescript": "5.9.3",
+        "typescript-plugin-css-modules": "^5.2.0"
+    }
+}

package/packages/chili/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "chili",
+  "version": "0.6.1",
+  "description": "",
+  "main": "src/index.ts",
+  "devDependencies": {
+    "chili-core": "*",
+    "chili-geo": "*",
+    "chili-vis": "*"
+  }
+}