chili3d 0.6.1

package/packages/chili-wasm/src/helper.ts

@@ -0,0 +1,435 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    Continuity,
+    CurveType,
+    gc,
+    type ICurve,
+    Id,
+    type IShape,
+    type ISurface,
+    JoinType,
+    type Line,
+    Matrix4,
+    Orientation,
+    Plane,
+    ShapeType,
+    SurfaceType,
+    XYZ,
+} from "chili-core";
+import type {
+    Geom_BezierCurve,
+    Geom_BSplineCurve,
+    Geom_Circle,
+    Geom_Curve,
+    Geom_Ellipse,
+    Geom_Hyperbola,
+    Geom_Line,
+    Geom_OffsetCurve,
+    Geom_Parabola,
+    Geom_Surface,
+    Geom_TrimmedCurve,
+    GeomAbs_Shape,
+    gp_Ax1,
+    gp_Ax2,
+    gp_Ax3,
+    gp_Dir,
+    gp_Pln,
+    gp_Pnt,
+    gp_Trsf,
+    gp_Vec,
+    TopAbs_ShapeEnum,
+    TopoDS_Shape,
+    Vector3,
+} from "../lib/chili-wasm";
+import {
+    OccBezierCurve,
+    OccBSplineCurve,
+    OccCircle,
+    OccEllipse,
+    OccHyperbola,
+    OccLine,
+    OccOffsetCurve,
+    OccParabola,
+    OccTrimmedCurve,
+} from "./curve";
+import {
+    OccCompound,
+    OccCompSolid,
+    OccEdge,
+    OccFace,
+    OccShape,
+    OccShell,
+    OccSolid,
+    OccVertex,
+    OccWire,
+} from "./shape";
+import {
+    OccBezierSurface,
+    OccBSplineSurface,
+    OccCompositeSurface,
+    OccConicalSurface,
+    OccCylindricalSurface,
+    OccOffsetSurface,
+    OccPlane,
+    OccPlateSurface,
+    OccRectangularSurface,
+    OccSphericalSurface,
+    OccSurfaceOfLinearExtrusion,
+    OccSurfaceOfRevolution,
+    OccToroidalSurface,
+} from "./surface";
+
+export class OcctHelper {
+    static toXYZ(p: gp_Pnt | gp_Dir | gp_Vec | Vector3): XYZ {
+        return new XYZ(p.x, p.y, p.z);
+    }
+
+    static toDir(value: Vector3) {
+        return new wasm.gp_Dir(value.x, value.y, value.z);
+    }
+
+    static toPnt(value: Vector3) {
+        return new wasm.gp_Pnt(value.x, value.y, value.z);
+    }
+
+    static toVec(value: Vector3) {
+        return new wasm.gp_Vec(value.x, value.y, value.z);
+    }
+
+    static toAx1(ray: Line): gp_Ax1 {
+        return gc((c) => {
+            return new wasm.gp_Ax1(c(OcctHelper.toPnt(ray.point)), c(OcctHelper.toDir(ray.direction)));
+        });
+    }
+
+    static toAx2(plane: Plane): gp_Ax2 {
+        return gc((c) => {
+            return new wasm.gp_Ax2(
+                c(OcctHelper.toPnt(plane.origin)),
+                c(OcctHelper.toDir(plane.normal)),
+                c(OcctHelper.toDir(plane.xvec)),
+            );
+        });
+    }
+
+    static toAx3(plane: Plane): gp_Ax3 {
+        return new wasm.gp_Ax3(
+            OcctHelper.toPnt(plane.origin),
+            OcctHelper.toDir(plane.normal),
+            OcctHelper.toDir(plane.xvec),
+        );
+    }
+
+    static fromAx23(ax: gp_Ax2 | gp_Ax3): Plane {
+        return gc((c) => {
+            return new Plane(
+                OcctHelper.toXYZ(c(ax.location())),
+                OcctHelper.toXYZ(c(ax.direction())),
+                OcctHelper.toXYZ(c(ax.xDirection())),
+            );
+        });
+    }
+
+    static fromPln(pln: gp_Pln): Plane {
+        return gc((c) => {
+            const ax3 = c(pln.position());
+            return OcctHelper.fromAx23(ax3);
+        });
+    }
+
+    static toPln(plane: Plane): gp_Pln {
+        return gc((c) => {
+            return new wasm.gp_Pln(c(OcctHelper.toAx3(plane)));
+        });
+    }
+
+    static convertFromMatrix(matrix: Matrix4): gp_Trsf {
+        const arr = matrix.toArray();
+        const trsf = new wasm.gp_Trsf();
+        trsf.setValues(
+            arr[0],
+            arr[4],
+            arr[8],
+            arr[12],
+            arr[1],
+            arr[5],
+            arr[9],
+            arr[13],
+            arr[2],
+            arr[6],
+            arr[10],
+            arr[14],
+        );
+        return trsf;
+    }
+
+    static convertToMatrix(matrix: gp_Trsf): Matrix4 {
+        const arr: number[] = [
+            matrix.value(1, 1),
+            matrix.value(2, 1),
+            matrix.value(3, 1),
+            0,
+            matrix.value(1, 2),
+            matrix.value(2, 2),
+            matrix.value(3, 2),
+            0,
+            matrix.value(1, 3),
+            matrix.value(2, 3),
+            matrix.value(3, 3),
+            0,
+            matrix.value(1, 4),
+            matrix.value(2, 4),
+            matrix.value(3, 4),
+            1,
+        ];
+        return Matrix4.fromArray(arr);
+    }
+
+    static getOrientation(shape: TopoDS_Shape): Orientation {
+        switch (shape.getOrientation()) {
+            case wasm.TopAbs_Orientation.TopAbs_FORWARD:
+                return Orientation.FORWARD;
+            case wasm.TopAbs_Orientation.TopAbs_REVERSED:
+                return Orientation.REVERSED;
+            case wasm.TopAbs_Orientation.TopAbs_INTERNAL:
+                return Orientation.INTERNAL;
+            case wasm.TopAbs_Orientation.TopAbs_EXTERNAL:
+                return Orientation.EXTERNAL;
+            default:
+                return Orientation.FORWARD;
+        }
+    }
+
+    static getShapeType(shape: TopoDS_Shape): ShapeType {
+        if (shape.isNull()) {
+            throw new Error("Shape is null");
+        }
+
+        switch (shape.shapeType()) {
+            case wasm.TopAbs_ShapeEnum.TopAbs_COMPOUND:
+                return ShapeType.Compound;
+            case wasm.TopAbs_ShapeEnum.TopAbs_COMPSOLID:
+                return ShapeType.CompoundSolid;
+            case wasm.TopAbs_ShapeEnum.TopAbs_SOLID:
+                return ShapeType.Solid;
+            case wasm.TopAbs_ShapeEnum.TopAbs_SHELL:
+                return ShapeType.Shell;
+            case wasm.TopAbs_ShapeEnum.TopAbs_FACE:
+                return ShapeType.Face;
+            case wasm.TopAbs_ShapeEnum.TopAbs_WIRE:
+                return ShapeType.Wire;
+            case wasm.TopAbs_ShapeEnum.TopAbs_EDGE:
+                return ShapeType.Edge;
+            case wasm.TopAbs_ShapeEnum.TopAbs_VERTEX:
+                return ShapeType.Vertex;
+            default:
+                return ShapeType.Shape;
+        }
+    }
+
+    static getShapeEnum(shapeType: ShapeType): TopAbs_ShapeEnum {
+        switch (shapeType) {
+            case ShapeType.Compound:
+                return wasm.TopAbs_ShapeEnum.TopAbs_COMPOUND;
+            case ShapeType.CompoundSolid:
+                return wasm.TopAbs_ShapeEnum.TopAbs_COMPSOLID;
+            case ShapeType.Solid:
+                return wasm.TopAbs_ShapeEnum.TopAbs_SOLID;
+            case ShapeType.Shell:
+                return wasm.TopAbs_ShapeEnum.TopAbs_SHELL;
+            case ShapeType.Face:
+                return wasm.TopAbs_ShapeEnum.TopAbs_FACE;
+            case ShapeType.Wire:
+                return wasm.TopAbs_ShapeEnum.TopAbs_WIRE;
+            case ShapeType.Edge:
+                return wasm.TopAbs_ShapeEnum.TopAbs_EDGE;
+            case ShapeType.Vertex:
+                return wasm.TopAbs_ShapeEnum.TopAbs_VERTEX;
+            case ShapeType.Shape:
+                return wasm.TopAbs_ShapeEnum.TopAbs_SHAPE;
+            default:
+                throw new Error("Unknown shape type: " + shapeType);
+        }
+    }
+
+    static getActualShape(shape: TopoDS_Shape): TopoDS_Shape {
+        if (shape.isNull()) {
+            throw new Error("Shape is null");
+        }
+
+        switch (shape.shapeType()) {
+            case wasm.TopAbs_ShapeEnum.TopAbs_COMPOUND:
+                return wasm.TopoDS.compound(shape);
+            case wasm.TopAbs_ShapeEnum.TopAbs_COMPSOLID:
+                return wasm.TopoDS.compsolid(shape);
+            case wasm.TopAbs_ShapeEnum.TopAbs_SOLID:
+                return wasm.TopoDS.solid(shape);
+            case wasm.TopAbs_ShapeEnum.TopAbs_SHELL:
+                return wasm.TopoDS.shell(shape);
+            case wasm.TopAbs_ShapeEnum.TopAbs_FACE:
+                return wasm.TopoDS.face(shape);
+            case wasm.TopAbs_ShapeEnum.TopAbs_WIRE:
+                return wasm.TopoDS.wire(shape);
+            case wasm.TopAbs_ShapeEnum.TopAbs_EDGE:
+                return wasm.TopoDS.edge(shape);
+            case wasm.TopAbs_ShapeEnum.TopAbs_VERTEX:
+                return wasm.TopoDS.vertex(shape);
+            default:
+                return shape;
+        }
+    }
+
+    static getJoinType(joinType: JoinType) {
+        switch (joinType) {
+            case JoinType.arc:
+                return wasm.GeomAbs_JoinType.GeomAbs_Arc;
+            case JoinType.intersection:
+                return wasm.GeomAbs_JoinType.GeomAbs_Intersection;
+            case JoinType.tangent:
+                return wasm.GeomAbs_JoinType.GeomAbs_Tangent;
+            default:
+                throw new Error("Unknown join type: " + joinType);
+        }
+    }
+
+    static wrapShape(shape: TopoDS_Shape, id: string = Id.generate()): IShape {
+        if (shape.isNull()) {
+            throw new Error("Shape is null");
+        }
+
+        switch (shape.shapeType()) {
+            case wasm.TopAbs_ShapeEnum.TopAbs_COMPOUND:
+                return new OccCompound(wasm.TopoDS.compound(shape), id);
+            case wasm.TopAbs_ShapeEnum.TopAbs_COMPSOLID:
+                return new OccCompSolid(wasm.TopoDS.compsolid(shape), id);
+            case wasm.TopAbs_ShapeEnum.TopAbs_SOLID:
+                return new OccSolid(wasm.TopoDS.solid(shape), id);
+            case wasm.TopAbs_ShapeEnum.TopAbs_SHELL:
+                return new OccShell(wasm.TopoDS.shell(shape), id);
+            case wasm.TopAbs_ShapeEnum.TopAbs_FACE:
+                return new OccFace(wasm.TopoDS.face(shape), id);
+            case wasm.TopAbs_ShapeEnum.TopAbs_WIRE:
+                return new OccWire(wasm.TopoDS.wire(shape), id);
+            case wasm.TopAbs_ShapeEnum.TopAbs_EDGE:
+                return new OccEdge(wasm.TopoDS.edge(shape), id);
+            case wasm.TopAbs_ShapeEnum.TopAbs_VERTEX:
+                return new OccVertex(wasm.TopoDS.vertex(shape), id);
+            default:
+                return new OccShape(shape, id);
+        }
+    }
+
+    static wrapCurve(curve: Geom_Curve): ICurve {
+        const isType = (type: string) => wasm.Transient.isInstance(curve, type);
+        if (isType("Geom_Line")) return new OccLine(curve as Geom_Line);
+        else if (isType("Geom_Circle")) return new OccCircle(curve as Geom_Circle);
+        else if (isType("Geom_Ellipse")) return new OccEllipse(curve as Geom_Ellipse);
+        else if (isType("Geom_Hyperbola")) return new OccHyperbola(curve as Geom_Hyperbola);
+        else if (isType("Geom_Parabola")) return new OccParabola(curve as Geom_Parabola);
+        else if (isType("Geom_BezierCurve")) return new OccBezierCurve(curve as Geom_BezierCurve);
+        else if (isType("Geom_BSplineCurve")) return new OccBSplineCurve(curve as Geom_BSplineCurve);
+        else if (isType("Geom_OffsetCurve")) return new OccOffsetCurve(curve as Geom_OffsetCurve);
+        else if (isType("Geom_TrimmedCurve")) return new OccTrimmedCurve(curve as Geom_TrimmedCurve);
+
+        throw new Error("Unknown curve type: " + String(curve));
+    }
+
+    static getCurveType(curve: Geom_Curve): CurveType {
+        const isType = (type: string) => wasm.Transient.isInstance(curve, type);
+        if (isType("Geom_Line")) return CurveType.Line;
+        else if (isType("Geom_Circle")) return CurveType.Circle;
+        else if (isType("Geom_Ellipse")) return CurveType.Ellipse;
+        else if (isType("Geom_Hyperbola")) return CurveType.Hyperbola;
+        else if (isType("Geom_Parabola")) return CurveType.Parabola;
+        else if (isType("Geom_BezierCurve")) return CurveType.BezierCurve;
+        else if (isType("Geom_BSplineCurve")) return CurveType.BSplineCurve;
+        else if (isType("Geom_OffsetCurve")) return CurveType.OffsetCurve;
+        else if (isType("Geom_TrimmedCurve")) return CurveType.TrimmedCurve;
+
+        throw new Error("Unknown curve type");
+    }
+
+    static wrapSurface(surface: Geom_Surface): ISurface {
+        const isType = (type: string) => wasm.Transient.isInstance(surface, type);
+        const actualSurface = surface as any;
+        if (isType("GeomPlate_Surface")) return new OccPlateSurface(actualSurface);
+        else if (isType("Geom_Plane")) return new OccPlane(actualSurface);
+        else if (isType("Geom_SurfaceOfLinearExtrusion"))
+            return new OccSurfaceOfLinearExtrusion(actualSurface);
+        else if (isType("Geom_SurfaceOfRevolution")) return new OccSurfaceOfRevolution(actualSurface);
+        else if (isType("Geom_OffsetSurface")) return new OccOffsetSurface(actualSurface);
+        else if (isType("Geom_BSplineSurface")) return new OccBSplineSurface(actualSurface);
+        else if (isType("Geom_BezierSurface")) return new OccBezierSurface(actualSurface);
+        else if (isType("Geom_CylindricalSurface")) return new OccCylindricalSurface(actualSurface);
+        else if (isType("Geom_ConicalSurface")) return new OccConicalSurface(actualSurface);
+        else if (isType("Geom_SphericalSurface")) return new OccSphericalSurface(actualSurface);
+        else if (isType("Geom_RectangularTrimmedSurface")) return new OccRectangularSurface(actualSurface);
+        else if (isType("Geom_ToroidalSurface")) return new OccToroidalSurface(actualSurface);
+        else if (isType("ShapeExtent_CompositeSurface")) return new OccCompositeSurface(actualSurface);
+
+        throw new Error("Unknown surface type: " + String(surface));
+    }
+
+    static getSurfaceType(surface: Geom_Surface): SurfaceType {
+        const isType = (type: string) => wasm.Transient.isInstance(surface, type);
+        if (isType("GeomPlate_Surface")) return SurfaceType.Plate;
+        else if (isType("Geom_Plane")) return SurfaceType.Plane;
+        else if (isType("Geom_SurfaceOfLinearExtrusion")) return SurfaceType.Extrusion;
+        else if (isType("Geom_SurfaceOfRevolution")) return SurfaceType.Revolution;
+        else if (isType("Geom_OffsetSurface")) return SurfaceType.Offset;
+        else if (isType("Geom_BSplineSurface")) return SurfaceType.BSpline;
+        else if (isType("Geom_BezierSurface")) return SurfaceType.Bezier;
+        else if (isType("Geom_CylindricalSurface")) return SurfaceType.Cylinder;
+        else if (isType("Geom_ConicalSurface")) return SurfaceType.Conical;
+        else if (isType("Geom_SphericalSurface")) return SurfaceType.Spherical;
+        else if (isType("Geom_RectangularTrimmedSurface")) return SurfaceType.RectangularTrimmed;
+        else if (isType("Geom_ToroidalSurface")) return SurfaceType.Toroidal;
+        else if (isType("ShapeExtent_CompositeSurface")) return SurfaceType.Composite;
+
+        throw new Error("Unknown surface type");
+    }
+
+    static convertToContinuity(cni: GeomAbs_Shape) {
+        switch (cni) {
+            case wasm.GeomAbs_Shape.GeomAbs_C0:
+                return Continuity.C0;
+            case wasm.GeomAbs_Shape.GeomAbs_G1:
+                return Continuity.G1;
+            case wasm.GeomAbs_Shape.GeomAbs_C1:
+                return Continuity.C1;
+            case wasm.GeomAbs_Shape.GeomAbs_G2:
+                return Continuity.G2;
+            case wasm.GeomAbs_Shape.GeomAbs_C2:
+                return Continuity.C2;
+            case wasm.GeomAbs_Shape.GeomAbs_C3:
+                return Continuity.C3;
+            case wasm.GeomAbs_Shape.GeomAbs_CN:
+                return Continuity.CN;
+            default:
+                throw new Error("unknown continuity");
+        }
+    }
+
+    static convertFromContinuity(continuity: Continuity) {
+        switch (continuity) {
+            case Continuity.C0:
+                return wasm.GeomAbs_Shape.GeomAbs_C0;
+            case Continuity.G1:
+                return wasm.GeomAbs_Shape.GeomAbs_G1;
+            case Continuity.C1:
+                return wasm.GeomAbs_Shape.GeomAbs_C1;
+            case Continuity.G2:
+                return wasm.GeomAbs_Shape.GeomAbs_G2;
+            case Continuity.C2:
+                return wasm.GeomAbs_Shape.GeomAbs_C2;
+            case Continuity.C3:
+                return wasm.GeomAbs_Shape.GeomAbs_C3;
+            case Continuity.CN:
+                return wasm.GeomAbs_Shape.GeomAbs_CN;
+            default:
+                throw new Error("unknown continuity");
+        }
+    }
+}

package/packages/chili-wasm/src/index.ts

@@ -0,0 +1,5 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export * from "./factory";
+export * from "./wasm";

package/packages/chili-wasm/src/mesher.ts

@@ -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.
+
+import {
+    type EdgeMeshData,
+    type FaceMeshData,
+    gc,
+    type IDisposable,
+    type IShapeMeshData,
+    LineType,
+    type ShapeMeshRange,
+    VisualConfig,
+} from "chili-core";
+import type { EdgeMeshData as OccEdgeMeshData, FaceMeshData as OccFaceMeshData } from "../lib/chili-wasm";
+import { type OccShape, OccSubEdgeShape, OccSubFaceShape } from "./shape";
+
+export class Mesher implements IShapeMeshData, IDisposable {
+    private _isMeshed = false;
+    private _lines?: EdgeMeshData;
+    private _faces?: FaceMeshData;
+
+    get edges(): EdgeMeshData | undefined {
+        if (this._lines === undefined) {
+            this.mesh();
+        }
+        return this._lines;
+    }
+    set edges(value: EdgeMeshData | undefined) {
+        this._lines = value;
+    }
+
+    get faces(): FaceMeshData | undefined {
+        if (this._faces === undefined) {
+            this.mesh();
+        }
+        return this._faces;
+    }
+    set faces(value: FaceMeshData | undefined) {
+        this._faces = value;
+    }
+
+    constructor(private shape: OccShape) {}
+
+    private mesh() {
+        if (this._isMeshed) {
+            return;
+        }
+        this._isMeshed = true;
+
+        gc((c) => {
+            const occMesher = c(new wasm.Mesher(this.shape.shape, 0.005));
+            const meshData = c(occMesher.mesh());
+            const faceMeshData = c(meshData.faceMeshData);
+            const edgeMeshData = c(meshData.edgeMeshData);
+
+            this._faces = this.parseFaceMeshData(faceMeshData);
+            this._lines = this.parseEdgeMeshData(edgeMeshData);
+        });
+    }
+
+    private parseFaceMeshData(faceMeshData: OccFaceMeshData): FaceMeshData {
+        return {
+            position: new Float32Array(faceMeshData.position),
+            normal: new Float32Array(faceMeshData.normal),
+            uv: new Float32Array(faceMeshData.uv),
+            index: new Uint32Array(faceMeshData.index),
+            range: this.getFaceRanges(faceMeshData),
+            color: VisualConfig.defaultFaceColor,
+            groups: [],
+        };
+    }
+
+    private parseEdgeMeshData(edgeMeshData: OccEdgeMeshData): EdgeMeshData {
+        return {
+            lineType: LineType.Solid,
+            position: new Float32Array(edgeMeshData.position),
+            range: this.getEdgeRanges(edgeMeshData),
+            color: VisualConfig.defaultEdgeColor,
+        };
+    }
+
+    dispose(): void {
+        this._faces?.range.forEach((g) => g.shape.dispose());
+        this._lines?.range.forEach((g) => g.shape.dispose());
+
+        this.shape = null as any;
+        this._faces = null as any;
+        this._lines = null as any;
+    }
+
+    private getEdgeRanges(data: OccEdgeMeshData): ShapeMeshRange[] {
+        const result: ShapeMeshRange[] = [];
+        for (let i = 0; i < data.edges.length; i++) {
+            result.push({
+                start: data.group[2 * i],
+                count: data.group[2 * i + 1],
+                shape: new OccSubEdgeShape(this.shape, data.edges[i], i),
+            });
+        }
+        return result;
+    }
+
+    private getFaceRanges(data: OccFaceMeshData): ShapeMeshRange[] {
+        const result: ShapeMeshRange[] = [];
+        for (let i = 0; i < data.faces.length; i++) {
+            result.push({
+                start: data.group[2 * i],
+                count: data.group[2 * i + 1],
+                shape: new OccSubFaceShape(this.shape, data.faces[i], i),
+            });
+        }
+        return result;
+    }
+}