chili3d 0.6.1

package/packages/chili-core/src/shape/meshData.ts

@@ -0,0 +1,347 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { VisualConfig } from "../config";
+import type { Matrix4, XYZ } from "../math";
+import { Serializer } from "../serialize";
+import { LineType } from "./lineType";
+import type { ISubShape } from "./shape";
+
+@Serializer.register(["start", "count", "materialIndex"])
+export class MeshGroup {
+    @Serializer.serialze()
+    start: number;
+    @Serializer.serialze()
+    count: number;
+    @Serializer.serialze()
+    materialIndex: number;
+
+    constructor(start: number, count: number, materialIndex: number) {
+        this.start = start;
+        this.count = count;
+        this.materialIndex = materialIndex;
+    }
+}
+
+export type MeshType = "surface" | "linesegments";
+
+@Serializer.register([])
+export class Mesh {
+    static createSurface(positionSize: number, indexSize: number) {
+        const mesh = new Mesh();
+        mesh.meshType = "surface";
+        mesh.normal = new Float32Array(positionSize * 3);
+        mesh.uv = new Float32Array(positionSize * 2);
+        mesh.position = new Float32Array(positionSize * 3);
+        mesh.index = new Uint32Array(indexSize);
+        return mesh;
+    }
+
+    static createLineSegments(size: number) {
+        const mesh = new Mesh();
+        mesh.meshType = "linesegments";
+        mesh.position = new Float32Array(size * 3);
+        return mesh;
+    }
+
+    @Serializer.serialze()
+    meshType: MeshType = "linesegments";
+
+    @Serializer.serialze()
+    position: Float32Array | undefined;
+
+    @Serializer.serialze()
+    normal: Float32Array | undefined = undefined;
+
+    @Serializer.serialze()
+    index: Uint32Array | undefined = undefined;
+
+    @Serializer.serialze()
+    color: number | number[] = 0xfff;
+
+    @Serializer.serialze()
+    uv: Float32Array | undefined = undefined;
+
+    @Serializer.serialze()
+    groups: MeshGroup[] = [];
+}
+
+export interface IShapeMeshData {
+    edges: EdgeMeshData | undefined;
+    faces: FaceMeshData | undefined;
+}
+
+export interface ShapeMeshRange {
+    start: number;
+    count: number;
+    shape: ISubShape;
+    transform?: Matrix4;
+}
+
+export interface ShapeMeshData {
+    position: Float32Array;
+    range: ShapeMeshRange[];
+    color?: number | number[];
+}
+
+export interface MeshLike {
+    position: Float32Array;
+    index: Uint32Array;
+    normal: Float32Array;
+    uv: Float32Array;
+    color?: number | number[];
+}
+
+export namespace ShapeMeshData {
+    export function isVertex(data: ShapeMeshData): data is VertexMeshData {
+        return (data as VertexMeshData)?.size !== undefined;
+    }
+
+    export function isEdge(data: ShapeMeshData): data is EdgeMeshData {
+        return (data as EdgeMeshData)?.lineType !== undefined;
+    }
+
+    export function isFace(data: ShapeMeshData): data is FaceMeshData {
+        return (data as FaceMeshData)?.index !== undefined;
+    }
+}
+
+export interface VertexMeshData extends ShapeMeshData {
+    size: number;
+}
+
+export namespace VertexMeshData {
+    export function from(point: XYZ, size: number, color: number): VertexMeshData {
+        return {
+            position: new Float32Array([point.x, point.y, point.z]),
+            range: [],
+            color,
+            size,
+        };
+    }
+}
+
+export interface EdgeMeshData extends ShapeMeshData {
+    lineType: LineType;
+    lineWidth?: number;
+}
+
+export function concatTypedArrays<T extends Float32Array | Uint32Array>(arrays: T[]): T {
+    const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0);
+    const result = new (arrays[0].constructor as new (length: number) => T)(totalLength);
+    let offset = 0;
+    for (const arr of arrays) {
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    return result;
+}
+
+export namespace EdgeMeshData {
+    export function from(start: XYZ, end: XYZ, color: number, lineType: LineType): EdgeMeshData {
+        return {
+            position: new Float32Array([start.x, start.y, start.z, end.x, end.y, end.z]),
+            color,
+            lineType,
+            range: [],
+        };
+    }
+
+    export function merge(data: EdgeMeshData, other: EdgeMeshData): EdgeMeshData {
+        const otherRange = other.range.map((range) => {
+            return {
+                start: range.start + data.position.length / 3,
+                count: range.count,
+                shape: range.shape,
+                transform: range.transform,
+            };
+        });
+        return {
+            position: concatTypedArrays([data.position, other.position]),
+            range: data.range.concat(otherRange),
+            color: data.color,
+            lineType: data.lineType,
+            lineWidth: data.lineWidth,
+        };
+    }
+}
+
+export interface FaceMeshData extends ShapeMeshData {
+    index: Uint32Array;
+    normal: Float32Array;
+    uv: Float32Array;
+    groups: MeshGroup[];
+}
+
+export namespace FaceMeshData {
+    export function merge(data: FaceMeshData, other: FaceMeshData): FaceMeshData {
+        const otherRange = other.range.map((range) => {
+            return {
+                start: range.start + data.position.length / 3,
+                count: range.count,
+                shape: range.shape,
+                transform: range.transform,
+            };
+        });
+        const groups = other.groups.map((group) => {
+            return {
+                start: group.start + data.index.length,
+                count: group.count,
+                materialIndex: group.materialIndex,
+            };
+        });
+        return {
+            position: concatTypedArrays([data.position, other.position]),
+            range: data.range.concat(otherRange),
+            index: concatTypedArrays([data.index, other.index]),
+            normal: concatTypedArrays([data.normal, other.normal]),
+            uv: concatTypedArrays([data.uv, other.uv]),
+            color: data.color,
+            groups,
+        };
+    }
+}
+
+export abstract class MeshDataBuilder<T extends ShapeMeshData> {
+    protected readonly _positions: number[] = [];
+    protected readonly _groups: ShapeMeshRange[] = [];
+    protected _color: number | undefined;
+    protected _vertexColor: number[] | undefined;
+
+    setColor(color: number) {
+        this._color = color;
+    }
+
+    addColor(r: number, g: number, b: number) {
+        this._vertexColor ??= [];
+        this._vertexColor.push(r, g, b);
+        return this;
+    }
+
+    protected getColor() {
+        let color: number | number[] | undefined = this._vertexColor;
+        if (this._vertexColor?.length !== this._positions.length) {
+            color = this._color;
+        }
+        return color;
+    }
+
+    abstract newGroup(): this;
+
+    abstract endGroup(shape: ISubShape): this;
+
+    abstract addPosition(x: number, y: number, z: number): this;
+
+    abstract build(): T;
+}
+
+/**
+ * LineSegments
+ */
+export class EdgeMeshDataBuilder extends MeshDataBuilder<EdgeMeshData> {
+    protected _positionStart: number = 0;
+    private _previousVertex: [number, number, number] | undefined = undefined;
+    private _lineType: LineType = LineType.Solid;
+
+    constructor() {
+        super();
+        this._color = VisualConfig.defaultEdgeColor;
+    }
+
+    setType(type: LineType) {
+        this._lineType = type;
+    }
+
+    override newGroup() {
+        this._positionStart = this._positions.length;
+        this._previousVertex = undefined;
+        return this;
+    }
+
+    override endGroup(shape: ISubShape) {
+        this._groups.push({
+            start: this._positionStart / 3,
+            count: (this._positions.length - this._positionStart) / 3,
+            shape,
+        });
+        return this;
+    }
+
+    override addPosition(x: number, y: number, z: number) {
+        if (this._previousVertex) {
+            this._positions.push(...this._previousVertex, x, y, z);
+        }
+        this._previousVertex = [x, y, z];
+        return this;
+    }
+
+    override build(): EdgeMeshData {
+        const color = this.getColor()!;
+        return {
+            position: new Float32Array(this._positions),
+            range: this._groups,
+            lineType: this._lineType,
+            color,
+        };
+    }
+}
+
+export class FaceMeshDataBuilder extends MeshDataBuilder<FaceMeshData> {
+    private _indexStart: number = 0;
+    private _groupStart: number = 0;
+    private readonly _normals: number[] = [];
+    private readonly _uvs: number[] = [];
+    private readonly _indices: number[] = [];
+
+    constructor() {
+        super();
+        this._color = VisualConfig.defaultFaceColor;
+    }
+
+    override newGroup() {
+        this._groupStart = this._indices.length;
+        this._indexStart = this._positions.length / 3;
+        return this;
+    }
+
+    override endGroup(shape: ISubShape) {
+        this._groups.push({
+            start: this._groupStart,
+            count: this._indices.length - this._groupStart,
+            shape,
+        });
+        return this;
+    }
+
+    override addPosition(x: number, y: number, z: number) {
+        this._positions.push(x, y, z);
+        return this;
+    }
+
+    addNormal(x: number, y: number, z: number) {
+        this._normals.push(x, y, z);
+        return this;
+    }
+
+    addUV(u: number, v: number) {
+        this._uvs.push(u, v);
+        return this;
+    }
+
+    addIndices(i1: number, i2: number, i3: number) {
+        this._indices.push(this._indexStart + i1, this._indexStart + i2, this._indexStart + i3);
+        return this;
+    }
+
+    build(): FaceMeshData {
+        return {
+            position: new Float32Array(this._positions),
+            color: this.getColor()!,
+            normal: new Float32Array(this._normals),
+            index: new Uint32Array(this._indices),
+            uv: new Float32Array(this._uvs),
+            range: this._groups,
+            groups: [],
+        };
+    }
+}

package/packages/chili-core/src/shape/shape.ts

@@ -0,0 +1,104 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { IDisposable, Result } from "../foundation";
+import type { Line, Matrix4, Plane, XYZ, XYZLike } from "../math";
+import type { ICurve, ITrimmedCurve } from "./curve";
+import type { EdgeMeshData, IShapeMeshData } from "./meshData";
+import type { ShapeType } from "./shapeType";
+import type { ISurface } from "./surface";
+
+export enum Orientation {
+    FORWARD,
+    REVERSED,
+    INTERNAL,
+    EXTERNAL,
+}
+
+export interface IShape extends IDisposable {
+    readonly shapeType: ShapeType;
+    get id(): string;
+    get mesh(): IShapeMeshData;
+    transformed(matrix: Matrix4): IShape;
+    transformedMul(matrix: Matrix4): IShape;
+    edgesMeshPosition(): EdgeMeshData;
+    matrix: Matrix4;
+    isClosed(): boolean;
+    isNull(): boolean;
+    /**
+     * they share the same TShape with the same Locations and Orientations.
+     */
+    isEqual(other: IShape): boolean;
+    /**
+     * they share the same TShape with the same Locations, Orientations may differ.
+     */
+    isSame(other: IShape): boolean;
+    /**
+     * they share the same TShape. Locations and Orientations may differ.
+     */
+    isPartner(other: IShape): boolean;
+    orientation(): Orientation;
+    findAncestor(ancestorType: ShapeType, fromShape: IShape): IShape[];
+    findSubShapes(subshapeType: ShapeType): IShape[];
+    iterShape(): IShape[];
+    section(shape: IShape | Plane): IShape;
+    split(shapes: IShape[]): IShape;
+    reserve(): void;
+    clone(): IShape;
+    hlr(position: XYZLike, direction: XYZLike, xDir: XYZLike): IShape;
+}
+
+export interface ISubShape extends IShape {
+    index: number;
+    parent: IShape;
+}
+
+export interface ISubEdgeShape extends ISubShape, IEdge {}
+
+export interface ISubFaceShape extends ISubShape, IFace {}
+
+export interface IVertex extends IShape {}
+
+export interface IEdge extends IShape {
+    update(curve: ICurve): void;
+    intersect(other: IEdge | Line): { parameter: number; point: XYZ }[];
+    length(): number;
+    get curve(): ITrimmedCurve;
+    offset(distance: number, dir: XYZ): Result<IEdge>;
+    trim(start: number, end: number): IEdge;
+}
+
+export enum JoinType {
+    arc,
+    tangent,
+    intersection,
+}
+
+export interface IWire extends IShape {
+    toFace(): Result<IFace>;
+    edgeLoop(): IEdge[];
+    offset(distance: number, joinType: JoinType): Result<IShape>;
+}
+
+export interface IFace extends IShape {
+    area(): number;
+    normal(u: number, v: number): [point: XYZ, normal: XYZ];
+    outerWire(): IWire;
+    surface(): ISurface;
+    segmentsOfEdgeOnFace(edge: IEdge):
+        | undefined
+        | {
+              start: number;
+              end: number;
+          };
+}
+
+export interface IShell extends IShape {}
+
+export interface ISolid extends IShape {
+    volume(): number;
+}
+
+export interface ICompound extends IShape {}
+
+export interface ICompoundSolid extends IShape {}

package/packages/chili-core/src/shape/shapeConverter.ts

@@ -0,0 +1,17 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { IDocument } from "../document";
+import type { Result } from "../foundation";
+import type { FolderNode } from "../model";
+import type { IShape } from "./shape";
+
+export interface IShapeConverter {
+    convertToIGES(...shapes: IShape[]): Result<string>;
+    convertFromIGES(document: IDocument, iges: Uint8Array): Result<FolderNode>;
+    convertToSTEP(...shapes: IShape[]): Result<string>;
+    convertFromSTEP(document: IDocument, step: Uint8Array): Result<FolderNode>;
+    convertToBrep(shape: IShape): Result<string>;
+    convertFromBrep(brep: string): Result<IShape>;
+    convertFromSTL(document: IDocument, stl: Uint8Array): Result<FolderNode>;
+}

package/packages/chili-core/src/shape/shapeFactory.ts

@@ -0,0 +1,58 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { Result } from "../foundation";
+import type { Line, Plane, XYZ, XYZLike } from "../math";
+import type { Continuity } from "./curve";
+import type { ICompound, IEdge, IFace, IShape, IShell, ISolid, IVertex, IWire } from "./shape";
+import type { IShapeConverter } from "./shapeConverter";
+
+export interface IShapeFactory {
+    readonly kernelName: string;
+    readonly converter: IShapeConverter;
+    face(wire: IWire[]): Result<IFace>;
+    shell(faces: IFace[]): Result<IShell>;
+    solid(shells: IShell[]): Result<ISolid>;
+    bezier(points: XYZLike[], weights?: number[]): Result<IEdge>;
+    point(point: XYZLike): Result<IVertex>;
+    line(start: XYZLike, end: XYZLike): Result<IEdge>;
+    arc(normal: XYZLike, center: XYZLike, start: XYZLike, angle: number): Result<IEdge>;
+    circle(normal: XYZLike, center: XYZLike, radius: number): Result<IEdge>;
+    rect(plane: Plane, dx: number, dy: number): Result<IFace>;
+    polygon(points: XYZLike[]): Result<IWire>;
+    box(plane: Plane, dx: number, dy: number, dz: number): Result<ISolid>;
+    ellipse(
+        normal: XYZLike,
+        center: XYZLike,
+        xvec: XYZLike,
+        majorRadius: number,
+        minorRadius: number,
+    ): Result<IEdge>;
+    cylinder(normal: XYZLike, center: XYZLike, radius: number, dz: number): Result<ISolid>;
+    cone(normal: XYZLike, center: XYZLike, radius: number, radiusUp: number, dz: number): Result<ISolid>;
+    sphere(center: XYZLike, radius: number): Result<ISolid>;
+    pyramid(plane: Plane, dx: number, dy: number, dz: number): Result<ISolid>;
+    wire(edges: IEdge[]): Result<IWire>;
+    prism(shape: IShape, vec: XYZ): Result<IShape>;
+    fuse(bottom: IShape, top: IShape): Result<IShape>;
+    sweep(profile: IShape[], path: IWire, isRoundCorner: boolean): Result<IShape>;
+    revolve(profile: IShape, axis: Line, angle: number): Result<IShape>;
+    booleanCommon(shape1: IShape[], shape2: IShape[]): Result<IShape>;
+    booleanCut(shape1: IShape[], shape2: IShape[]): Result<IShape>;
+    booleanFuse(shape1: IShape[], shape2: IShape[]): Result<IShape>;
+    combine(shapes: IShape[]): Result<ICompound>;
+    makeThickSolidBySimple(shape: IShape, thickness: number): Result<IShape>;
+    makeThickSolidByJoin(shape: IShape, closingFaces: IShape[], thickness: number): Result<IShape>;
+    fillet(shape: IShape, edges: number[], radius: number): Result<IShape>;
+    chamfer(shape: IShape, edges: number[], distance: number): Result<IShape>;
+    loft(
+        sections: (IVertex | IEdge | IWire)[],
+        isSolid: boolean,
+        isRuled: boolean,
+        continuity: Continuity,
+    ): Result<IShape>;
+    removeFeature(shape: IShape, faces: IFace[]): Result<IShape>;
+    removeSubShape(shape: IShape, subShapes: IShape[]): IShape;
+    replaceSubShape(shape: IShape, subShape: IShape, newSubShape: IShape): IShape;
+    curveProjection(curve: IEdge | IWire, targetFace: IFace, vec: XYZ): Result<IShape>;
+}

package/packages/chili-core/src/shape/shapeType.ts

@@ -0,0 +1,75 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export enum ShapeType {
+    Shape = 0b0,
+    Compound = 0b1,
+    CompoundSolid = 0b10,
+    Solid = 0b100,
+    Shell = 0b1000,
+    Face = 0b10000,
+    Wire = 0b100000,
+    Edge = 0b1000000,
+    Vertex = 0b10000000,
+}
+
+export namespace ShapeType {
+    export function isWhole(type: ShapeType) {
+        return (
+            type === ShapeType.Shape ||
+            type === ShapeType.Compound ||
+            type === ShapeType.CompoundSolid ||
+            type === ShapeType.Solid
+        );
+    }
+
+    export function stringValue(type: ShapeType) {
+        switch (type) {
+            case ShapeType.Shape:
+                return "Shape";
+            case ShapeType.Compound:
+                return "Compound";
+            case ShapeType.CompoundSolid:
+                return "CompoundSolid";
+            case ShapeType.Solid:
+                return "Solid";
+            case ShapeType.Shell:
+                return "Shell";
+            case ShapeType.Face:
+                return "Face";
+            case ShapeType.Wire:
+                return "Wire";
+            case ShapeType.Edge:
+                return "Edge";
+            case ShapeType.Vertex:
+                return "Vertex";
+            default:
+                return "Unknown";
+        }
+    }
+
+    export function hasCompound(type: ShapeType): boolean {
+        return (type & ShapeType.Compound) !== 0;
+    }
+    export function hasCompoundSolid(type: ShapeType): boolean {
+        return (type & ShapeType.CompoundSolid) !== 0;
+    }
+    export function hasSolid(type: ShapeType): boolean {
+        return (type & ShapeType.Solid) !== 0;
+    }
+    export function hasShell(type: ShapeType): boolean {
+        return (type & ShapeType.Shell) !== 0;
+    }
+    export function hasFace(type: ShapeType): boolean {
+        return (type & ShapeType.Face) !== 0;
+    }
+    export function hasWire(type: ShapeType): boolean {
+        return (type & ShapeType.Wire) !== 0;
+    }
+    export function hasEdge(type: ShapeType): boolean {
+        return (type & ShapeType.Edge) !== 0;
+    }
+    export function hasVertex(type: ShapeType): boolean {
+        return (type & ShapeType.Vertex) !== 0;
+    }
+}