chili3d 0.6.1

package/packages/chili-core/src/serialize/serializer.ts

@@ -0,0 +1,231 @@
+// 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 { Observable } from "../foundation/observer";
+
+export interface ISerialize {
+    serialize(): Serialized;
+}
+
+export type Serialized = {
+    classKey: string;
+    properties: SerializedProperties<any>;
+};
+
+export type SerializedProperties<T> = {
+    [P in keyof T]?: any;
+};
+
+export interface RefelectData {
+    ctor: new (...args: any[]) => any;
+    ctorParamNames: string[];
+    serialize?: (target: any) => SerializedProperties<any>;
+    deserialize?: (...args: any[]) => any;
+}
+
+export function registerReflect(data: RefelectData, name?: string) {
+    const actualName = name ?? data.ctor.name;
+    if (reflectMap.has(actualName)) {
+        console.warn(`Class ${actualName} already registered, skip.`);
+        return;
+    }
+
+    reflectMap.set(actualName, data);
+}
+
+export function registerTypeArray(
+    TypeArray: new (array: number[]) => Float32Array | Uint32Array,
+): RefelectData {
+    return {
+        ctor: TypeArray,
+        ctorParamNames: ["buffer"],
+        serialize: (target: Float16Array | Uint32Array) => {
+            return {
+                buffer: Array.from(target),
+            };
+        },
+        deserialize: (buffer) => {
+            return new TypeArray(buffer);
+        },
+    };
+}
+
+const propertiesMap = new Map<new (...args: any[]) => any, Set<string>>();
+const reflectMap = new Map<string, RefelectData>();
+reflectMap.set("Float32Array", registerTypeArray(Float32Array));
+reflectMap.set("Uint32Array", registerTypeArray(Uint32Array));
+
+export namespace Serializer {
+    export function serialze() {
+        return (target: any, property: string) => {
+            let keys = propertiesMap.get(target);
+            if (keys === undefined) {
+                keys = new Set();
+                propertiesMap.set(target, keys);
+            }
+            keys.add(property);
+        };
+    }
+
+    export function register<T>(
+        ctorParamNames: (keyof T & string)[],
+        deserialize?: (...args: any[]) => T,
+        serialize?: (target: T) => SerializedProperties<T>,
+    ) {
+        return (target: new (...args: any[]) => T) => {
+            registerReflect({
+                ctor: target,
+                ctorParamNames,
+                serialize,
+                deserialize,
+            });
+        };
+    }
+}
+
+export namespace Serializer {
+    /**
+     * Deserialize an object
+     *
+     * @param document Document that contains the object.
+     * @param data Serialize the data. If the serialized data does not contain
+     * the parameters required by the deserialization function, these parameters
+     * should be added to the serialized data, for example:
+     * ```
+     * data.properties[“parent”] = node.
+     * ```
+     * @returns Deserialized object
+     */
+    export function deserializeObject(document: IDocument, data: Serialized) {
+        const instance = deserializeInstance(document, data.classKey, data.properties);
+        deserializeProperties(document, instance, data);
+        return instance;
+    }
+
+    function deserializeInstance(
+        document: IDocument,
+        className: string,
+        properties: SerializedProperties<any>,
+    ) {
+        if (!reflectMap.has(className)) {
+            throw new Error(
+                `${className} cannot be deserialize. Did you forget to add the decorator @Serializer.register?`,
+            );
+        }
+
+        const { ctor, ctorParamNames, deserialize } = reflectMap.get(className)!;
+        const parameters = deserilizeParameters(document, ctorParamNames, properties, className);
+        if (deserialize) {
+            return deserialize(...ctorParamNames.map((x) => parameters[x]));
+        }
+        return new ctor(...ctorParamNames.map((x) => parameters[x]));
+    }
+
+    function deserilizeParameters(
+        document: IDocument,
+        ctorParamNames: any[],
+        properties: SerializedProperties<any>,
+        className: string,
+    ) {
+        const parameters: SerializedProperties<any> = {};
+        parameters["document"] = document;
+        for (const key of ctorParamNames) {
+            if (key in properties) {
+                parameters[key] = deserialValue(document, properties[key]);
+            } else if (key !== "document") {
+                parameters[key] = undefined;
+                console.warn(`${className} constructor parameter ${key} is missing`);
+            }
+        }
+        return parameters;
+    }
+
+    function deserialValue(document: IDocument, value: any) {
+        if (value === null || value === undefined) {
+            return undefined;
+        }
+        if (Array.isArray(value)) {
+            return value.map((v) => {
+                if (v === null || v === undefined) {
+                    return undefined;
+                }
+                return typeof v === "object" ? deserializeObject(document, v) : v;
+            });
+        }
+        return (value as Serialized).classKey ? deserializeObject(document, value) : value;
+    }
+
+    function deserializeProperties(document: IDocument, instance: any, data: Serialized, ignores?: string[]) {
+        const { ctorParamNames } = reflectMap.get(data.classKey)!;
+        const filter = (key: string) => {
+            return !ctorParamNames.includes(key) && !ignores?.includes(key);
+        };
+        const keys = Object.keys(data.properties).filter(filter);
+        for (const key of keys) {
+            if (instance instanceof Observable) {
+                instance.setPrivateValue(
+                    key as keyof Observable,
+                    deserialValue(document, data.properties[key]),
+                );
+            } else {
+                instance[key] = deserialValue(document, data.properties[key]);
+            }
+        }
+    }
+}
+
+export namespace Serializer {
+    export function serializeObject(target: Object): Serialized {
+        const classKey = target.constructor.name;
+        if (!reflectMap.has(classKey)) {
+            console.log(target);
+
+            throw new Error(
+                `Type ${target.constructor.name} is not registered, please add the @Serializer.register decorator.`,
+            );
+        }
+        const data = reflectMap.get(classKey)!;
+        const properties = data.serialize?.(target) ?? serializeProperties(target);
+        return {
+            classKey,
+            properties,
+        };
+    }
+
+    export function serializeProperties(target: Object) {
+        const data: SerializedProperties<any> = {};
+        const keys = getAllKeysOfPrototypeChain(target, propertiesMap);
+        for (const key of keys) {
+            const value = (target as any)[key];
+            if (Array.isArray(value)) {
+                data[key] = value.map((v) => serializePropertyValue(v));
+            } else {
+                data[key] = serializePropertyValue(value);
+            }
+        }
+        return data;
+    }
+
+    function serializePropertyValue(value: any) {
+        const type = typeof value;
+        if (type === "object") {
+            return serializeObject(value);
+        }
+        if (type !== "function" && type !== "symbol") {
+            return value;
+        }
+        throw new Error(`Unsupported serialized object: ${value}`);
+    }
+
+    function getAllKeysOfPrototypeChain(target: Object, map: Map<new (...args: any[]) => any, Set<string>>) {
+        const keys: string[] = [];
+        let prototype = Object.getPrototypeOf(target);
+        while (prototype !== null) {
+            const k = map.get(prototype);
+            if (k) keys.push(...k.values());
+            prototype = Object.getPrototypeOf(prototype); // prototype chain
+        }
+        return new Set(keys);
+    }
+}

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

@@ -0,0 +1,10 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { IApplication } from "./application";
+
+export interface IService {
+    register(app: IApplication): void;
+    start(): void;
+    stop(): void;
+}

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

@@ -0,0 +1,174 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { Line, XYZ } from "../math";
+import type { IGeometry } from "./geometry";
+import type { IEdge } from "./shape";
+
+export enum CurveType {
+    Line,
+    Circle,
+    Ellipse,
+    Hyperbola,
+    Parabola,
+    BezierCurve,
+    BSplineCurve,
+    OffsetCurve,
+    OtherCurve,
+    TrimmedCurve,
+}
+
+export enum Continuity {
+    C0,
+    G1,
+    C1,
+    G2,
+    C2,
+    C3,
+    CN,
+}
+
+export interface ICurve extends IGeometry {
+    get curveType(): CurveType;
+    uniformAbscissaByLength(length: number): XYZ[];
+    uniformAbscissaByCount(curveCount: number): XYZ[];
+    length(): number;
+    parameter(point: XYZ, tolerance: number): number | undefined;
+    firstParameter(): number;
+    lastParameter(): number;
+    project(point: XYZ): XYZ[];
+    value(parameter: number): XYZ;
+    isCN(n: number): boolean;
+    trim(u1: number, u2: number): ITrimmedCurve;
+    d0(u: number): XYZ;
+    d1(u: number): { point: XYZ; vec: XYZ };
+    d2(u: number): { point: XYZ; vec1: XYZ; vec2: XYZ };
+    d3(u: number): { point: XYZ; vec1: XYZ; vec2: XYZ; vec3: XYZ };
+    dn(u: number, n: number): XYZ;
+    reverse(): void;
+    reversed(): ICurve;
+    nearestFromPoint(point: XYZ): {
+        point: XYZ;
+        parameter: number;
+        distance: number;
+    };
+    nearestExtrema(curve: ICurve | Line):
+        | undefined
+        | {
+              isParallel: boolean;
+              distance: number;
+              p1: XYZ;
+              p2: XYZ;
+              u1: number;
+              u2: number;
+          };
+    isClosed(): boolean;
+    period(): number;
+    isPeriodic(): boolean;
+    continutity(): Continuity;
+    makeEdge(): IEdge;
+}
+
+export interface ILine extends ICurve {
+    direction: XYZ;
+}
+
+export interface IConic extends ICurve {
+    axis: XYZ;
+    xAxis: XYZ;
+    yAxis: XYZ;
+    eccentricity(): number;
+}
+
+export interface ICircle extends IConic {
+    center: XYZ;
+    radius: number;
+}
+
+export interface IEllipse extends IConic {
+    center: XYZ;
+    get focus1(): XYZ;
+    get focus2(): XYZ;
+    majorRadius: number;
+    minorRadius: number;
+}
+
+export interface IHyperbola extends IConic {
+    focal(): number;
+    location: XYZ;
+    get focus1(): XYZ;
+    get focus2(): XYZ;
+    majorRadius: number;
+    minorRadius: number;
+}
+
+export interface IParabola extends IConic {
+    focal(): number;
+    get focus(): XYZ;
+    get directrix(): XYZ;
+}
+
+export interface IBoundedCurve extends ICurve {
+    startPoint(): XYZ;
+    endPoint(): XYZ;
+}
+
+export interface IBezierCurve extends IBoundedCurve {
+    degree(): number;
+    weight(index: number): number;
+    insertPoleAfter(index: number, point: XYZ, weight?: number): void;
+    insertPoleBefore(index: number, point: XYZ, weight?: number): void;
+    removePole(index: number): void;
+    setPole(index: number, point: XYZ, weight?: number): void;
+    setWeight(index: number, weight: number): void;
+    nbPoles(): number;
+    pole(index: number): XYZ;
+    poles(): XYZ[];
+}
+
+export interface IBSplineCurve extends IBoundedCurve {
+    degree(): number;
+    nbKnots(): number;
+    knot(index: number): number;
+    setKnot(index: number, value: number): void;
+    nbPoles(): number;
+    pole(index: number): XYZ;
+    poles(): XYZ[];
+    weight(index: number): number;
+    setWeight(index: number, value: number): void;
+}
+
+export interface ITrimmedCurve extends IBoundedCurve {
+    get basisCurve(): ICurve;
+    setTrim(u1: number, u2: number): void;
+}
+
+export interface IOffsetCurve extends ICurve {
+    get basisCurve(): ICurve;
+    offset(): number;
+    direction(): XYZ;
+}
+
+export interface IComplexCurve {
+    nbCurves(): number;
+    curve(index: number): ICurve;
+}
+
+export namespace ICurve {
+    export function isConic(curve: ICurve): curve is IConic {
+        return (curve as IConic).axis !== undefined;
+    }
+
+    export function isCircle(curve: ICurve): curve is ICircle {
+        const circle = curve as ICircle;
+        return circle.center !== undefined && circle.radius !== undefined;
+    }
+
+    export function isLine(curve: ICurve): curve is ILine {
+        return (curve as ILine).direction !== undefined;
+    }
+
+    export function isTrimmed(curve: ICurve): curve is ITrimmedCurve {
+        return (curve as ITrimmedCurve).basisCurve !== undefined;
+    }
+}

package/packages/chili-core/src/shape/geometry.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 { IDisposable } from "../foundation";
+import type { Matrix4 } from "../math";
+
+export enum GeometryType {
+    Curve,
+    Surface,
+}
+
+export interface IGeometry extends IDisposable {
+    get geometryType(): GeometryType;
+    transform(matrix: Matrix4): void;
+    transformed(matrix: Matrix4): IGeometry;
+    copy(): IGeometry;
+}

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

@@ -0,0 +1,12 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export * from "./curve";
+export * from "./geometry";
+export * from "./lineType";
+export * from "./meshData";
+export * from "./shape";
+export * from "./shapeConverter";
+export * from "./shapeFactory";
+export * from "./shapeType";
+export * from "./surface";

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

@@ -0,0 +1,7 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export enum LineType {
+    Solid,
+    Dash,
+}