chili3d 0.6.1

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

@@ -0,0 +1,269 @@
+// 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 { HistoryObservable, Id } from "./foundation";
+import { XY } from "./math";
+import { Property } from "./property";
+import { Serializer } from "./serialize";
+
+@Serializer.register(["document"])
+export class Texture extends HistoryObservable {
+    @Serializer.serialze()
+    @Property.define("material.texture.image")
+    get image(): string {
+        return this.getPrivateValue("image", "");
+    }
+    set image(value: string) {
+        this.setProperty("image", value);
+    }
+
+    @Serializer.serialze()
+    get wrapS(): number {
+        return this.getPrivateValue("wrapS", 1000);
+    }
+    set wrapS(value: number) {
+        this.setProperty("wrapS", value);
+    }
+
+    @Serializer.serialze()
+    get wrapT(): number {
+        return this.getPrivateValue("wrapT", 1000);
+    }
+    set wrapT(value: number) {
+        this.setProperty("wrapT", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.texture.rotation")
+    get rotation(): number {
+        return this.getPrivateValue("rotation", 0);
+    }
+    set rotation(value: number) {
+        this.setProperty("rotation", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.texture.offset")
+    get offset(): XY {
+        return this.getPrivateValue("offset", new XY(0, 0));
+    }
+    set offset(value: XY) {
+        this.setProperty("offset", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.texture.repeat")
+    get repeat(): XY {
+        return this.getPrivateValue("repeat", new XY(1, 1));
+    }
+    set repeat(value: XY) {
+        this.setProperty("repeat", value);
+    }
+
+    @Serializer.serialze()
+    center: XY = new XY(0.5, 0.5);
+}
+
+@Serializer.register(["document", "name", "color", "id"])
+export class Material extends HistoryObservable {
+    @Serializer.serialze()
+    vertexColors = false;
+
+    @Serializer.serialze()
+    transparent = true;
+
+    @Serializer.serialze()
+    readonly id: string;
+
+    @Serializer.serialze()
+    @Property.define("common.name")
+    get name(): string {
+        return this.getPrivateValue("name");
+    }
+    set name(value: string) {
+        this.setProperty("name", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("common.color", { type: "color" })
+    get color(): number | string {
+        return this.getPrivateValue("color");
+    }
+    set color(value: number | string) {
+        this.setProperty("color", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("common.opacity")
+    get opacity(): number {
+        return this.getPrivateValue("opacity", 1);
+    }
+    set opacity(value: number) {
+        this.setProperty("opacity", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.map")
+    get map(): Texture {
+        return this.getPrivateValue("map", new Texture(this.document));
+    }
+    set map(value: Texture) {
+        this.setProperty("map", value);
+    }
+
+    constructor(document: IDocument, name: string, color: number | string, id: string = Id.generate()) {
+        super(document);
+        this.id = id;
+        this.setPrivateValue("name", name?.length > 0 ? name : "unnamed");
+        this.setPrivateValue("color", color);
+    }
+
+    clone(): Material {
+        const material = new Material(this.document, `${this.name} clone`, this.color);
+        material.setPrivateValue("map", this.map);
+
+        return material;
+    }
+}
+
+@Serializer.register(["document", "name", "color", "id"])
+export class PhongMaterial extends Material {
+    @Serializer.serialze()
+    @Property.define("material.specular", { type: "color" })
+    get specular(): number | string {
+        return this.getPrivateValue("specular", 0x111111);
+    }
+    set specular(value: number | string) {
+        this.setProperty("specular", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.shininess")
+    get shininess(): number {
+        return this.getPrivateValue("shininess", 30);
+    }
+    set shininess(value: number) {
+        this.setProperty("shininess", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.emissive", { type: "color" })
+    get emissive(): number | string {
+        return this.getPrivateValue("emissive", 0x000000);
+    }
+    set emissive(value: number | string) {
+        this.setProperty("emissive", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.specularMap")
+    get specularMap(): Texture {
+        return this.getPrivateValue("specularMap", new Texture(this.document));
+    }
+    set specularMap(value: Texture) {
+        this.setProperty("specularMap", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.bumpMap")
+    get bumpMap(): Texture {
+        return this.getPrivateValue("bumpMap", new Texture(this.document));
+    }
+    set bumpMap(value: Texture) {
+        this.setProperty("bumpMap", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.normalMap")
+    get normalMap(): Texture {
+        return this.getPrivateValue("normalMap", new Texture(this.document));
+    }
+    set normalMap(value: Texture) {
+        this.setProperty("normalMap", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.emissiveMap")
+    get emissiveMap(): Texture {
+        return this.getPrivateValue("emissiveMap", new Texture(this.document));
+    }
+    set emissiveMap(value: Texture) {
+        this.setProperty("emissiveMap", value);
+    }
+}
+
+@Serializer.register(["document", "name", "color", "id"])
+export class PhysicalMaterial extends Material {
+    @Serializer.serialze()
+    @Property.define("material.metalness")
+    get metalness(): number {
+        return this.getPrivateValue("metalness", 0);
+    }
+    set metalness(value: number) {
+        this.setProperty("metalness", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.metalnessMap")
+    get metalnessMap(): Texture {
+        return this.getPrivateValue("metalnessMap", new Texture(this.document));
+    }
+    set metalnessMap(value: Texture) {
+        this.setProperty("metalnessMap", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.roughness")
+    get roughness(): number {
+        return this.getPrivateValue("roughness", 1);
+    }
+    set roughness(value: number) {
+        this.setProperty("roughness", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.roughnessMap")
+    get roughnessMap(): Texture {
+        return this.getPrivateValue("roughnessMap", new Texture(this.document));
+    }
+    set roughnessMap(value: Texture) {
+        this.setProperty("roughnessMap", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.emissive", { type: "color" })
+    get emissive(): number | string {
+        return this.getPrivateValue("emissive", 0x000000);
+    }
+    set emissive(value: number | string) {
+        this.setProperty("emissive", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.bumpMap")
+    get bumpMap(): Texture {
+        return this.getPrivateValue("bumpMap", new Texture(this.document));
+    }
+    set bumpMap(value: Texture) {
+        this.setProperty("bumpMap", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.normalMap")
+    get normalMap(): Texture {
+        return this.getPrivateValue("normalMap", new Texture(this.document));
+    }
+    set normalMap(value: Texture) {
+        this.setProperty("normalMap", value);
+    }
+
+    @Serializer.serialze()
+    @Property.define("material.emissiveMap")
+    get emissiveMap(): Texture {
+        return this.getPrivateValue("emissiveMap", new Texture(this.document));
+    }
+    set emissiveMap(value: Texture) {
+        this.setProperty("emissiveMap", value);
+    }
+}

package/packages/chili-core/src/math/boundingBox.ts

@@ -0,0 +1,226 @@
+// 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, LineType } from "../shape";
+import type { Matrix4 } from "./matrix4";
+import { XYZ } from "./xyz";
+
+export type PointLike = { x: number; y: number; z: number };
+
+export class BoundingBox {
+    constructor(
+        readonly min: PointLike,
+        readonly max: PointLike,
+    ) {}
+
+    static readonly zero = new BoundingBox(new XYZ(0, 0, 0), new XYZ(0, 0, 0));
+
+    static transformed(box: BoundingBox, matrix: Matrix4) {
+        const min = matrix.ofPoint(box.min);
+        const max = matrix.ofPoint(box.max);
+
+        return new BoundingBox(min, max);
+    }
+
+    static center(box: BoundingBox | undefined) {
+        if (!box) {
+            return XYZ.zero;
+        }
+
+        const x = (box.min.x + box.max.x) / 2;
+        const y = (box.min.y + box.max.y) / 2;
+        const z = (box.min.z + box.max.z) / 2;
+
+        return new XYZ(x, y, z);
+    }
+
+    static expand(box: BoundingBox, value: number) {
+        const min = {
+            x: box.min.x - value,
+            y: box.min.y - value,
+            z: box.min.z - value,
+        };
+        const max = {
+            x: box.max.x + value,
+            y: box.max.y + value,
+            z: box.max.z + value,
+        };
+
+        return new BoundingBox(min, max);
+    }
+
+    static wireframe(box: BoundingBox): EdgeMeshData {
+        const { min, max } = box;
+        const position = [
+            min.x,
+            min.y,
+            min.z,
+            min.x,
+            min.y,
+            max.z, // z
+            min.x,
+            min.y,
+            max.z,
+            min.x,
+            max.y,
+            max.z, // y
+            min.x,
+            max.y,
+            max.z,
+            min.x,
+            max.y,
+            min.z, // z
+            min.x,
+            max.y,
+            min.z,
+            min.x,
+            min.y,
+            min.z, // y
+            max.x,
+            min.y,
+            min.z,
+            max.x,
+            min.y,
+            max.z, // z
+            max.x,
+            min.y,
+            max.z,
+            max.x,
+            max.y,
+            max.z, // y
+            max.x,
+            max.y,
+            max.z,
+            max.x,
+            max.y,
+            min.z, // z
+            max.x,
+            max.y,
+            min.z,
+            max.x,
+            min.y,
+            min.z, // y
+            min.x,
+            min.y,
+            min.z,
+            max.x,
+            min.y,
+            min.z, // x
+            min.x,
+            min.y,
+            max.z,
+            max.x,
+            min.y,
+            max.z, // x
+            min.x,
+            max.y,
+            max.z,
+            max.x,
+            max.y,
+            max.z, // x
+            min.x,
+            max.y,
+            min.z,
+            max.x,
+            max.y,
+            min.z, // x
+        ];
+        return {
+            position: new Float32Array(position),
+            lineType: LineType.Solid,
+            range: [],
+        };
+    }
+
+    static isValid(box: BoundingBox) {
+        return box.min.x <= box.max.x && box.min.y <= box.max.y && box.min.z <= box.max.z;
+    }
+
+    static isIntersect(box1: BoundingBox, box2: BoundingBox, tolerance = 0.001) {
+        return (
+            box1.min.x < box2.max.x + tolerance &&
+            box1.max.x > box2.min.x - tolerance &&
+            box1.min.y < box2.max.y + tolerance &&
+            box1.max.y > box2.min.y - tolerance &&
+            box1.min.z < box2.max.z + tolerance &&
+            box1.max.z > box2.min.z - tolerance
+        );
+    }
+
+    static isInside(box: BoundingBox, point: PointLike, tolerance = 0.001) {
+        return (
+            box.min.x + tolerance <= point.x &&
+            point.x <= box.max.x - tolerance &&
+            box.min.y + tolerance <= point.y &&
+            point.y <= box.max.y - tolerance &&
+            box.min.z + tolerance <= point.z &&
+            point.z <= box.max.z - tolerance
+        );
+    }
+
+    static expandByPoint(box: BoundingBox, point: PointLike) {
+        const { min, max } = box;
+        min.x = Math.min(min.x, point.x);
+        min.y = Math.min(min.y, point.y);
+        min.z = Math.min(min.z, point.z);
+        max.x = Math.max(max.x, point.x);
+        max.y = Math.max(max.y, point.y);
+        max.z = Math.max(max.z, point.z);
+    }
+
+    static combine(box1: BoundingBox | undefined, box2: BoundingBox | undefined) {
+        if (!box2) {
+            return box1;
+        }
+
+        if (!box1) {
+            return box2;
+        }
+
+        const min = {
+            x: Math.min(box1.min.x, box2.min.x),
+            y: Math.min(box1.min.y, box2.min.y),
+            z: Math.min(box1.min.z, box2.min.z),
+        };
+        const max = {
+            x: Math.max(box1.max.x, box2.max.x),
+            y: Math.max(box1.max.y, box2.max.y),
+            z: Math.max(box1.max.z, box2.max.z),
+        };
+        return new BoundingBox(min, max);
+    }
+
+    static fromNumbers(points: ArrayLike<number>): BoundingBox {
+        const min = { x: Infinity, y: Infinity, z: Infinity };
+        const max = { x: -Infinity, y: -Infinity, z: -Infinity };
+
+        for (let i = 0; i < points.length; i += 3) {
+            const x = points[i];
+            const y = points[i + 1];
+            const z = points[i + 2];
+
+            min.x = Math.min(min.x, x);
+            min.y = Math.min(min.y, y);
+            min.z = Math.min(min.z, z);
+            max.x = Math.max(max.x, x);
+            max.y = Math.max(max.y, y);
+            max.z = Math.max(max.z, z);
+        }
+        return new BoundingBox(min, max);
+    }
+
+    static fromPoints(points: PointLike[]): BoundingBox {
+        const min = { x: Infinity, y: Infinity, z: Infinity };
+        const max = { x: -Infinity, y: -Infinity, z: -Infinity };
+
+        for (const point of points) {
+            min.x = Math.min(min.x, point.x);
+            min.y = Math.min(min.y, point.y);
+            min.z = Math.min(min.z, point.z);
+            max.x = Math.max(max.x, point.x);
+            max.y = Math.max(max.y, point.y);
+            max.z = Math.max(max.z, point.z);
+        }
+        return new BoundingBox(min, max);
+    }
+}

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

@@ -0,0 +1,14 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export * from "./boundingBox";
+export * from "./line";
+export * from "./lineSegment";
+export * from "./mathUtils";
+export * from "./matrix4";
+export * from "./plane";
+export * from "./planeAngle";
+export * from "./quaternion";
+export * from "./ray";
+export * from "./xy";
+export * from "./xyz";

package/packages/chili-core/src/math/line.ts

@@ -0,0 +1,55 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Serializer } from "../serialize";
+import { Plane } from "./plane";
+import { XYZ } from "./xyz";
+
+@Serializer.register(["point", "direction"])
+export class Line {
+    @Serializer.serialze()
+    readonly point: XYZ;
+    /**
+     * unit vector
+     */
+    @Serializer.serialze()
+    readonly direction: XYZ;
+
+    constructor(location: XYZ, direction: XYZ) {
+        this.point = location;
+        const n = direction.normalize();
+        if (n === undefined || n.isEqualTo(XYZ.zero)) {
+            throw new Error("direction can not be zero");
+        }
+        this.direction = n;
+    }
+
+    intersect(right: Line, tolerance = 1e-6): XYZ | undefined {
+        if (this.direction.isParallelTo(right.direction, tolerance)) return undefined;
+        const result = this.nearestTo(right);
+        const vec = result.sub(right.point);
+        if (vec.length() < tolerance) return result;
+
+        return vec.isParallelTo(right.direction, tolerance) ? result : undefined;
+    }
+
+    distanceTo(right: Line): number {
+        const neareast1 = this.nearestTo(right);
+        const neareast2 = right.nearestToPoint(neareast1);
+        return neareast1.distanceTo(neareast2);
+    }
+
+    nearestTo(right: Line): XYZ {
+        const n = right.direction.cross(this.direction).normalize();
+        if (n === undefined) return this.nearestToPoint(right.point);
+        const normal = n.cross(right.direction).normalize()!;
+        const plane = new Plane(right.point, normal, n);
+        return plane.intersectLine(this)!;
+    }
+
+    nearestToPoint(point: XYZ): XYZ {
+        const vec = point.sub(this.point);
+        const dot = vec.dot(this.direction);
+        return this.point.add(this.direction.multiply(dot));
+    }
+}