@divinevoxel/vlox 0.0.74 → 0.0.76

package/Mesher/Geomtry/Primitives/Triangle.js

@@ -0,0 +1,148 @@
+import { Matrix2x2Like, Vec2ArrayLike, Vec3ArrayLike, Vector3Like, } from "@amodx/math";
+import { TriangleVector2VertexData, TriangleVector3VertexData, } from "./TriangleVertexData";
+import { GetBounds } from "../Functions/GetBounds";
+// You would import the triangle-based vertex-data classes here, e.g.:
+// import { TriVector3VertexData, TriVector2VertexData } from "./TriVertexData";
+// or however you have named them and placed them in your codebase.
+//
+// For example:
+// import { TriUVData, TriVertexVec3Data } from "../Geometry.types";
+/**
+ * Example "TriUVData" type for clarity:
+ * export type TriUVData = [Vec2Array, Vec2Array, Vec2Array];
+ *
+ * Example "TriVertexVec3Data" type:
+ * export type TriVertexVec3Data = [Vec3Array, Vec3Array, Vec3Array];
+ */
+export class Triangle {
+    /**
+     * A simple set of "full" UVs for a triangle, in whichever ordering convention you prefer.
+     * Adapt this to your own standard. Below is just a quick example:
+     */
+    static FullUVs = Object.freeze([
+        [0, 0], // p1
+        [1, 0], // p2
+        [0, 1], // p3
+    ]);
+    /**
+     * Rotate triangle UVs about a pivot, defaulting to [0.5, 0.5] if you wish (or you can adapt).
+     * This example matches the style of the Quad rotation.
+     */
+    static RotateUvs(uvs, rotation) {
+        const rotationMatrix = Matrix2x2Like.Rotation(rotation);
+        const pivot = [0.5, 0.5];
+        return [
+            Vec2ArrayLike.RotateAroundPivot(rotationMatrix, uvs[0], pivot),
+            Vec2ArrayLike.RotateAroundPivot(rotationMatrix, uvs[1], pivot),
+            Vec2ArrayLike.RotateAroundPivot(rotationMatrix, uvs[2], pivot),
+        ];
+    }
+    /**
+     * Factory method for creating a Tri instance.
+     */
+    static Create(positions, uvs, doubleSided) {
+        return new Triangle({ positions, uvs, doubleSided });
+    }
+    /**
+     * Computes a right-handed normal for a triangle given three points p1, p2, p3.
+     * The cross product is (p2 - p1) x (p3 - p1).
+     * This returns a single normal, but we place it in a triple for each vertex
+     * in case you want distinct normal per vertex.
+     */
+    static GetNormalRightHanded(p1, p2, p3) {
+        const v1 = Vec3ArrayLike.Subtract(p2, p1);
+        const v2 = Vec3ArrayLike.Subtract(p3, p1);
+        const normal = Vec3ArrayLike.Normalize(Vec3ArrayLike.Cross(v1, v2));
+        // By default, each vertex gets the same face-normal (flat shading).
+        return [normal, normal, normal];
+    }
+    /**
+     * Computes a left-handed normal for a triangle. This is simply flipping the sign
+     * of the right-handed normal (or reversing the cross).
+     */
+    static GetNormalLeftHanded(p1, p2, p3) {
+        const v1 = Vec3ArrayLike.Subtract(p2, p1);
+        const v2 = Vec3ArrayLike.Subtract(p3, p1);
+        // Multiply by -1 for a left-handed version
+        const normal = Vec3ArrayLike.MultiplyScalar(Vec3ArrayLike.Normalize(Vec3ArrayLike.Cross(v1, v2)), -1);
+        return [normal, normal, normal];
+    }
+    // If you need an equivalent "OrderTriVertices" or any other specialized
+    // re-ordering method, you can add it here. For many triangle uses, you
+    // might not need a sorting or "direction" function as in the Quad.
+    // Replace these with your own triangle-based vertex-data classes:
+    // e.g. TriVector3VertexData, TriVector2VertexData, etc.
+    positions /*: TriVector3VertexData*/;
+    normals /*: TriVector3VertexData*/;
+    uvs /*: TriVector2VertexData*/;
+    doubleSided = false;
+    bounds = [
+        [0, 0, 0],
+        [0, 0, 0],
+    ];
+    constructor(data) {
+        // Replace these with your Tri* vertex data:
+        // (The code below assumes you have classes like TriVector3VertexData, TriVector2VertexData
+        //  that behave similarly to your Quad-based classes.)
+        this.positions = new TriangleVector3VertexData();
+        this.normals = new TriangleVector3VertexData();
+        this.uvs = new TriangleVector2VertexData();
+        if (data.positions)
+            this.setPositions(data.positions);
+        if (data.uvs)
+            this.setUVs(data.uvs);
+        if (data.doubleSided)
+            this.doubleSided = data.doubleSided;
+    }
+    setUVs([uv1, uv2, uv3]) {
+        this.uvs.vertices[0].x = uv1[0];
+        this.uvs.vertices[0].y = uv1[1];
+        this.uvs.vertices[0].x = uv1[0];
+        this.uvs.vertices[0].y = uv1[1];
+        // e.g. this.uvs.set(Vector2Like.FromArray(uv1), Vector2Like.FromArray(uv2), Vector2Like.FromArray(uv3));
+        // Adapt to however your TriVector2VertexData sets 3 corners.
+        return this;
+    }
+    /**
+     * Scales all positions of the triangle by the given x, y, z factors.
+     */
+    scale(x, y, z) {
+        const scale = Vector3Like.Create(x, y, z);
+        for (const position of this.positions) {
+            Vector3Like.MultiplyInPlace(position, scale);
+        }
+        return this;
+    }
+    /**
+     * Translates all positions by (x, y, z).
+     */
+    transform(x, y, z) {
+        const shift = Vector3Like.Create(x, y, z);
+        for (const position of this.positions) {
+            Vector3Like.AddInPlace(position, shift);
+        }
+        return this;
+    }
+    /**
+     * Sets positions, computing a left-handed normal by default (matching your Quad).
+     * Adapt if you need right-handed or detect it automatically.
+     */
+    setPositions(positions) {
+        // Compute normals
+        const [n1, n2, n3] = Triangle.GetNormalLeftHanded(...positions);
+        this.positions.set(Vector3Like.FromArray(positions[0]), Vector3Like.FromArray(positions[1]), Vector3Like.FromArray(positions[2]));
+        this.normals.set(Vector3Like.FromArray(n1), Vector3Like.FromArray(n2), Vector3Like.FromArray(n3));
+        this.bounds = GetBounds(...this.positions);
+        return this;
+    }
+    /**
+     * Clones the triangle, copying position and UV data.
+     */
+    clone() {
+        const cloned = Triangle.Create(this.positions.toVec3Array(), this.uvs.toVec2Array(), this.doubleSided);
+        // if needed, set those data explicitly:
+        // cloned.positions.setFromTriData(this.positions);
+        // cloned.uvs.setFromTriData(this.uvs);
+        return cloned;
+    }
+}

package/Mesher/Geomtry/Primitives/TriangleVertexData.d.ts

@@ -0,0 +1,58 @@
+import { Vector3Like, Vector2Like, Vec3Array, Vec2Array } from "@amodx/math";
+import { TriangleVerticies } from "../Geometry.types";
+type TriangleDataType<Data> = [Data, Data, Data];
+export declare class TriangleVertexData<Data> {
+    vertices: TriangleDataType<Data>;
+    constructor(vertices: TriangleDataType<Data>);
+    toArray(): Data[];
+    setVertex(vertex: TriangleVerticies, value: Data): void;
+    getVertex(vertex: TriangleVerticies): Data;
+    setAll(value: Data): void;
+    set(v1: Data, v2: Data, v3: Data): void;
+    isEqualTo(v1: Data, v2: Data, v3: Data): boolean;
+    isAllEqualTo(value: Data): boolean;
+    [Symbol.iterator](): Iterator<Data>;
+    clone(): TriangleVertexData<Data>;
+}
+export declare class TriangleVector3VertexData extends TriangleVertexData<Vector3Like> {
+    vertices: TriangleDataType<Vector3Like>;
+    constructor(vertices?: TriangleDataType<Vector3Like>);
+    setFromQuadData(vertexData: TriangleVertexData<Vector3Like>): void;
+    addToVertex(vertex: TriangleVerticies, value: Vector3Like): void;
+    subtractFromVertex(vertex: TriangleVerticies, value: Vector3Like): void;
+    addAll(value: Vector3Like): void;
+    subtractAll(value: Vector3Like): void;
+    isEqualTo(v1: Vector3Like, v2: Vector3Like, v3: Vector3Like): boolean;
+    isAllEqualTo(v1: Vector3Like): boolean;
+    clone(): TriangleVector3VertexData;
+    toVec3Array(): [Vec3Array, Vec3Array, Vec3Array];
+}
+export declare class TriangleVector2VertexData extends TriangleVertexData<Vector2Like> {
+    vertices: TriangleDataType<Vector2Like>;
+    constructor(vertices?: TriangleDataType<Vector2Like>);
+    setFromQuadData(vertexData: TriangleVertexData<Vector3Like>): void;
+    addToVertex(vertex: TriangleVerticies, value: Vector2Like): void;
+    subtractFromVertex(vertex: TriangleVerticies, value: Vector2Like): void;
+    addAll(value: Vector2Like): void;
+    subtractAll(value: Vector2Like): void;
+    isEqualTo(v1: Vector2Like, v2: Vector2Like, v3: Vector2Like): boolean;
+    isAllEqualTo(v1: Vector2Like): boolean;
+    toVec2Array(): [Vec2Array, Vec2Array, Vec2Array];
+    clone(): TriangleVector2VertexData;
+}
+export declare class TriangleScalarVertexData extends TriangleVertexData<number> {
+    vertices: TriangleDataType<number>;
+    constructor(vertices?: TriangleDataType<number>);
+    setFromQuadData(vertexData: TriangleVertexData<number>): void;
+    subtractFromVertex(vertex: TriangleVerticies, value: number): void;
+    addAll(value: number): void;
+    add(v1: number, v2: number, v3: number, v4: number): void;
+    subtractAll(value: number): void;
+    subtract(v1: number, v2: number, v3: number, v4: number): void;
+    isGreaterThan(v1: number, v2: number, v3: number, v4: number): boolean;
+    isAllGreaterThan(value: number): boolean;
+    isLessThan(v1: number, v2: number, v3: number, v4: number): boolean;
+    isAllLessThan(value: number): boolean;
+    clone(): TriangleScalarVertexData;
+}
+export {};

package/Mesher/Geomtry/Primitives/TriangleVertexData.js

@@ -0,0 +1,263 @@
+import { Vector3Like, Vector2Like } from "@amodx/math";
+import { TriangleVerticies } from "../Geometry.types";
+export class TriangleVertexData {
+    vertices;
+    constructor(vertices) {
+        this.vertices = vertices;
+    }
+    toArray() {
+        return [
+            this.vertices[TriangleVerticies.One],
+            this.vertices[TriangleVerticies.Two],
+            this.vertices[TriangleVerticies.Three],
+        ];
+    }
+    setVertex(vertex, value) {
+        this.vertices[vertex] = value;
+    }
+    getVertex(vertex) {
+        return this.vertices[vertex];
+    }
+    setAll(value) {
+        this.vertices[TriangleVerticies.One] = value;
+        this.vertices[TriangleVerticies.Two] = value;
+        this.vertices[TriangleVerticies.Three] = value;
+    }
+    set(v1, v2, v3) {
+        this.vertices[TriangleVerticies.One] = v1;
+        this.vertices[TriangleVerticies.Two] = v2;
+        this.vertices[TriangleVerticies.Three] = v3;
+    }
+    isEqualTo(v1, v2, v3) {
+        if (this.vertices[TriangleVerticies.One] != v1)
+            return false;
+        if (this.vertices[TriangleVerticies.Two] != v2)
+            return false;
+        if (this.vertices[TriangleVerticies.Three] != v3)
+            return false;
+        return true;
+    }
+    isAllEqualTo(value) {
+        if (this.vertices[TriangleVerticies.One] != value)
+            return false;
+        if (this.vertices[TriangleVerticies.Two] != value)
+            return false;
+        if (this.vertices[TriangleVerticies.Three] != value)
+            return false;
+        return true;
+    }
+    [Symbol.iterator]() {
+        let index = TriangleVerticies.One;
+        const items = this.vertices;
+        return {
+            next() {
+                if (index < TriangleVerticies.Three) {
+                    return { value: items[index++], done: false };
+                }
+                else {
+                    return { value: undefined, done: true };
+                }
+            },
+        };
+    }
+    clone() {
+        return new TriangleVertexData([
+            structuredClone(this.vertices[TriangleVerticies.One]),
+            structuredClone(this.vertices[TriangleVerticies.Two]),
+            structuredClone(this.vertices[TriangleVerticies.Three]),
+        ]);
+    }
+}
+export class TriangleVector3VertexData extends TriangleVertexData {
+    vertices;
+    constructor(vertices = [
+        Vector3Like.Create(),
+        Vector3Like.Create(),
+        Vector3Like.Create(),
+    ]) {
+        super(vertices);
+        this.vertices = vertices;
+    }
+    setFromQuadData(vertexData) {
+        Vector3Like.Copy(this.vertices[TriangleVerticies.One], vertexData.vertices[TriangleVerticies.One]);
+        Vector3Like.Copy(this.vertices[TriangleVerticies.Two], vertexData.vertices[TriangleVerticies.Two]);
+        Vector3Like.Copy(this.vertices[TriangleVerticies.Three], vertexData.vertices[TriangleVerticies.Three]);
+    }
+    addToVertex(vertex, value) {
+        Vector3Like.AddInPlace(this.vertices[vertex], value);
+    }
+    subtractFromVertex(vertex, value) {
+        Vector3Like.SubtractInPlace(this.vertices[vertex], value);
+    }
+    addAll(value) {
+        this.addToVertex(TriangleVerticies.One, value);
+        this.addToVertex(TriangleVerticies.Two, value);
+        this.addToVertex(TriangleVerticies.Three, value);
+    }
+    subtractAll(value) {
+        this.subtractFromVertex(TriangleVerticies.One, value);
+        this.subtractFromVertex(TriangleVerticies.Two, value);
+        this.subtractFromVertex(TriangleVerticies.Three, value);
+    }
+    isEqualTo(v1, v2, v3) {
+        return (Vector3Like.Equals(this.vertices[TriangleVerticies.One], v1) &&
+            Vector3Like.Equals(this.vertices[TriangleVerticies.Two], v2) &&
+            Vector3Like.Equals(this.vertices[TriangleVerticies.Three], v3));
+    }
+    isAllEqualTo(v1) {
+        return (Vector3Like.Equals(this.vertices[TriangleVerticies.One], v1) &&
+            Vector3Like.Equals(this.vertices[TriangleVerticies.Two], v1) &&
+            Vector3Like.Equals(this.vertices[TriangleVerticies.Three], v1));
+    }
+    clone() {
+        return new TriangleVector3VertexData([
+            Vector3Like.Clone(this.vertices[TriangleVerticies.One]),
+            Vector3Like.Clone(this.vertices[TriangleVerticies.Two]),
+            Vector3Like.Clone(this.vertices[TriangleVerticies.Three]),
+        ]);
+    }
+    toVec3Array() {
+        return [
+            Vector3Like.ToArray(this.vertices[0]),
+            Vector3Like.ToArray(this.vertices[1]),
+            Vector3Like.ToArray(this.vertices[2]),
+        ];
+    }
+}
+export class TriangleVector2VertexData extends TriangleVertexData {
+    vertices;
+    constructor(vertices = [
+        Vector2Like.Create(),
+        Vector2Like.Create(),
+        Vector2Like.Create(),
+    ]) {
+        super(vertices);
+        this.vertices = vertices;
+    }
+    setFromQuadData(vertexData) {
+        Vector2Like.Copy(this.vertices[TriangleVerticies.One], vertexData.vertices[TriangleVerticies.One]);
+        Vector2Like.Copy(this.vertices[TriangleVerticies.Two], vertexData.vertices[TriangleVerticies.Two]);
+        Vector2Like.Copy(this.vertices[TriangleVerticies.Three], vertexData.vertices[TriangleVerticies.Three]);
+    }
+    addToVertex(vertex, value) {
+        Vector2Like.AddInPlace(this.vertices[vertex], value);
+    }
+    subtractFromVertex(vertex, value) {
+        Vector2Like.SubtractInPlace(this.vertices[vertex], value);
+    }
+    addAll(value) {
+        this.addToVertex(TriangleVerticies.One, value);
+        this.addToVertex(TriangleVerticies.Two, value);
+        this.addToVertex(TriangleVerticies.Three, value);
+    }
+    subtractAll(value) {
+        this.subtractFromVertex(TriangleVerticies.One, value);
+        this.subtractFromVertex(TriangleVerticies.Two, value);
+        this.subtractFromVertex(TriangleVerticies.Three, value);
+    }
+    isEqualTo(v1, v2, v3) {
+        return (Vector2Like.Equals(this.vertices[TriangleVerticies.One], v1) &&
+            Vector2Like.Equals(this.vertices[TriangleVerticies.Two], v2) &&
+            Vector2Like.Equals(this.vertices[TriangleVerticies.Three], v3));
+    }
+    isAllEqualTo(v1) {
+        return (Vector2Like.Equals(this.vertices[TriangleVerticies.One], v1) &&
+            Vector2Like.Equals(this.vertices[TriangleVerticies.Two], v1) &&
+            Vector2Like.Equals(this.vertices[TriangleVerticies.Three], v1));
+    }
+    toVec2Array() {
+        return [
+            Vector2Like.ToArray(this.vertices[0]),
+            Vector2Like.ToArray(this.vertices[1]),
+            Vector2Like.ToArray(this.vertices[2]),
+        ];
+    }
+    clone() {
+        return new TriangleVector2VertexData([
+            Vector2Like.Clone(this.vertices[TriangleVerticies.One]),
+            Vector2Like.Clone(this.vertices[TriangleVerticies.Two]),
+            Vector2Like.Clone(this.vertices[TriangleVerticies.Three]),
+        ]);
+    }
+}
+export class TriangleScalarVertexData extends TriangleVertexData {
+    vertices;
+    constructor(vertices = [0, 0, 0]) {
+        super(vertices);
+        this.vertices = vertices;
+    }
+    setFromQuadData(vertexData) {
+        this.vertices[TriangleVerticies.One] =
+            vertexData.vertices[TriangleVerticies.One];
+        this.vertices[TriangleVerticies.Two] =
+            vertexData.vertices[TriangleVerticies.Two];
+        this.vertices[TriangleVerticies.Three] =
+            vertexData.vertices[TriangleVerticies.Three];
+    }
+    subtractFromVertex(vertex, value) {
+        this.vertices[vertex] -= value;
+    }
+    addAll(value) {
+        this.vertices[TriangleVerticies.One] += value;
+        this.vertices[TriangleVerticies.Two] += value;
+        this.vertices[TriangleVerticies.Three] += value;
+    }
+    add(v1, v2, v3, v4) {
+        this.vertices[TriangleVerticies.One] += v1;
+        this.vertices[TriangleVerticies.Two] += v2;
+        this.vertices[TriangleVerticies.Three] += v3;
+    }
+    subtractAll(value) {
+        this.vertices[TriangleVerticies.One] -= value;
+        this.vertices[TriangleVerticies.Two] -= value;
+        this.vertices[TriangleVerticies.Three] -= value;
+    }
+    subtract(v1, v2, v3, v4) {
+        this.vertices[TriangleVerticies.One] += v1;
+        this.vertices[TriangleVerticies.Two] += v2;
+        this.vertices[TriangleVerticies.Three] += v3;
+    }
+    isGreaterThan(v1, v2, v3, v4) {
+        if (this.vertices[TriangleVerticies.One] < v1)
+            return false;
+        if (this.vertices[TriangleVerticies.Two] < v2)
+            return false;
+        if (this.vertices[TriangleVerticies.Three] < v3)
+            return false;
+        return true;
+    }
+    isAllGreaterThan(value) {
+        if (this.vertices[TriangleVerticies.One] < value)
+            return false;
+        if (this.vertices[TriangleVerticies.Two] < value)
+            return false;
+        if (this.vertices[TriangleVerticies.Three] < value)
+            return false;
+        return true;
+    }
+    isLessThan(v1, v2, v3, v4) {
+        if (this.vertices[TriangleVerticies.One] > v1)
+            return false;
+        if (this.vertices[TriangleVerticies.Two] > v2)
+            return false;
+        if (this.vertices[TriangleVerticies.Three] > v3)
+            return false;
+        return true;
+    }
+    isAllLessThan(value) {
+        if (this.vertices[TriangleVerticies.One] > value)
+            return false;
+        if (this.vertices[TriangleVerticies.Two] > value)
+            return false;
+        if (this.vertices[TriangleVerticies.Three] > value)
+            return false;
+        return true;
+    }
+    clone() {
+        return new TriangleScalarVertexData([
+            this.vertices[TriangleVerticies.One],
+            this.vertices[TriangleVerticies.Two],
+            this.vertices[TriangleVerticies.Three],
+        ]);
+    }
+}

package/Mesher/Geomtry/Primitives/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./Quad";
 export * from "./QuadVertexData";
+export * from "./Triangle";
+export * from "./TriangleVertexData";

package/Mesher/Geomtry/Primitives/index.js

@@ -1,2 +1,4 @@
 export * from "./Quad";
 export * from "./QuadVertexData";
+export * from "./Triangle";
+export * from "./TriangleVertexData";

package/Mesher/Geomtry/Shapes/Box.d.ts

@@ -0,0 +1,20 @@
+import { Vec3Array } from "@amodx/math";
+import { Quad } from "../Primitives";
+type BoxPoints = [Vec3Array, Vec3Array];
+type BoxQuads = [
+    up: Quad,
+    down: Quad,
+    north: Quad,
+    south: Quad,
+    east: Quad,
+    west: Quad
+];
+export declare class Box {
+    static Create(points?: BoxPoints): Box;
+    quads: BoxQuads;
+    constructor(data: {
+        points?: BoxPoints;
+    });
+    setPoints(points: BoxPoints): void;
+}
+export {};

package/Mesher/Geomtry/Shapes/Box.js

@@ -0,0 +1,69 @@
+import { Quad } from "../Primitives";
+export class Box {
+    static Create(points = [
+        [0, 0, 0],
+        [1, 1, 1],
+    ]) {
+        return new Box({
+            points,
+        });
+    }
+    quads = [
+        Quad.Create(),
+        Quad.Create(),
+        Quad.Create(),
+        Quad.Create(),
+        Quad.Create(),
+        Quad.Create(),
+    ];
+    constructor(data) {
+        if (data.points)
+            this.setPoints(data.points);
+    }
+    setPoints(points) {
+        const [startX, startY, startZ] = points[0];
+        const [endX, endY, endZ] = points[1];
+        //top
+        this.quads[0].setPositions([
+            [endX, endY, endZ],
+            [startX, endY, endZ],
+            [startX, endY, startZ],
+            [endX, endY, startZ],
+        ]);
+        //bottom
+        this.quads[1].setPositions([
+            [startX, startY, endZ],
+            [endX, startY, endZ],
+            [endX, startY, startZ],
+            [startX, startY, startZ],
+        ]);
+        //north
+        this.quads[2].setPositions([
+            [startX, endY, endZ],
+            [endX, endY, endZ],
+            [endX, startY, endZ],
+            [startX, startY, endZ],
+        ]);
+        //south
+        this.quads[3].setPositions([
+            [endX, endY, startZ],
+            [startX, endY, startZ],
+            [startX, startY, startZ],
+            [endX, startY, startZ],
+        ]);
+        //east
+        this.quads[4].setPositions([
+            [endX, endY, endZ],
+            [endX, endY, startZ],
+            [endX, startY, startZ],
+            [endX, startY, endZ],
+        ]);
+        //west
+        this.quads[5].setPositions([
+            [startX, endY, startZ],
+            [startX, endY, endZ],
+            [startX, startY, endZ],
+            [startX, startY, startZ],
+        ]);
+    }
+}

package/Mesher/Geomtry/Transform/TransformBox.d.ts

@@ -0,0 +1,3 @@
+import { VoxelGeometryTransform } from "../Geometry.types";
+import { Box } from "../Shapes/Box";
+export declare function TransformBox(box: Box, transform: VoxelGeometryTransform): Box;