@divinevoxel/vlox 0.0.74 → 0.0.75

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;

package/{Models/Shared/Transform.js → Mesher/Geomtry/Transform/TransformBox.js}

@@ -1,124 +1,9 @@
-import { Quad } from "../../Mesher/Geomtry/Primitives/Quad";
-import { QuadVerticies } from "../../Mesher/Geomtry/Geometry.types";
-import { Vector3Like } from "@amodx/math";
-// Utility function to convert degrees to radians
-function degreesToRadians(degrees) {
-    return (degrees * Math.PI) / 180;
-}
-export function TransformQuad(quad, transform) {
-    const p1 = { ...quad.positions.vertices[QuadVerticies.TopRight] };
-    const p2 = { ...quad.positions.vertices[QuadVerticies.TopLeft] };
-    const p3 = { ...quad.positions.vertices[QuadVerticies.BottomLeft] };
-    const p4 = { ...quad.positions.vertices[QuadVerticies.BottomRight] };
-    // Create an array of vertices
-    const vertices = [p1, p2, p3, p4];
-    // Compute the centroid of the quad
-    const centroid = {
-        x: (p1.x + p2.x + p3.x + p4.x) / 4,
-        y: (p1.y + p2.y + p3.y + p4.y) / 4,
-        z: (p1.z + p2.z + p3.z + p4.z) / 4,
-    };
-    // Initialize effective scales
-    let effectiveScaleX = 1;
-    let effectiveScaleY = 1;
-    let effectiveScaleZ = 1;
-    // Apply scale if specified
-    if (transform.scale) {
-        const [scaleX, scaleY, scaleZ] = transform.scale;
-        effectiveScaleX = scaleX;
-        effectiveScaleY = scaleY;
-        effectiveScaleZ = scaleZ;
-    }
-    // Apply flips by negating effective scales
-    if (transform.flip) {
-        const [flipX, flipY, flipZ] = transform.flip;
-        if (flipX)
-            effectiveScaleX *= -1;
-        if (flipY)
-            effectiveScaleY *= -1;
-        if (flipZ)
-            effectiveScaleZ *= -1;
-    }
-    // Compute determinant
-    const determinant = effectiveScaleX * effectiveScaleY * effectiveScaleZ;
-    // Apply scaling and flips
-    for (const vertex of vertices) {
-        vertex.x = centroid.x + (vertex.x - centroid.x) * effectiveScaleX;
-        vertex.y = centroid.y + (vertex.y - centroid.y) * effectiveScaleY;
-        vertex.z = centroid.z + (vertex.z - centroid.z) * effectiveScaleZ;
-    }
-    // Rotate vertices around the pivot point if rotation is specified
-    if (transform.rotation) {
-        const [rotXDeg, rotYDeg, rotZDeg] = transform.rotation;
-        const rotX = degreesToRadians(rotXDeg);
-        const rotY = degreesToRadians(rotYDeg);
-        const rotZ = degreesToRadians(rotZDeg);
-        const pivot = transform.rotationPivot
-            ? {
-                x: transform.rotationPivot[0],
-                y: transform.rotationPivot[1],
-                z: transform.rotationPivot[2],
-            }
-            : centroid;
-        for (const vertex of vertices) {
-            // Translate vertex to pivot point
-            let x = vertex.x - pivot.x;
-            let y = vertex.y - pivot.y;
-            let z = vertex.z - pivot.z;
-            // Rotation around X-axis
-            if (rotX) {
-                const cosX = Math.cos(rotX);
-                const sinX = Math.sin(rotX);
-                const y1 = y * cosX - z * sinX;
-                const z1 = y * sinX + z * cosX;
-                y = y1;
-                z = z1;
-            }
-            // Rotation around Y-axis
-            if (rotY) {
-                const cosY = Math.cos(rotY);
-                const sinY = Math.sin(rotY);
-                const x1 = x * cosY + z * sinY;
-                const z1 = -x * sinY + z * cosY;
-                x = x1;
-                z = z1;
-            }
-            // Rotation around Z-axis
-            if (rotZ) {
-                const cosZ = Math.cos(rotZ);
-                const sinZ = Math.sin(rotZ);
-                const x1 = x * cosZ - y * sinZ;
-                const y1 = x * sinZ + y * cosZ;
-                x = x1;
-                y = y1;
-            }
-            // Translate vertex back from pivot point
-            vertex.x = x + pivot.x;
-            vertex.y = y + pivot.y;
-            vertex.z = z + pivot.z;
-        }
-    }
-    // Translate vertices if position is specified
-    if (transform.position) {
-        const [dx, dy, dz] = transform.position;
-        for (const vertex of vertices) {
-            vertex.x += dx;
-            vertex.y += dy;
-            vertex.z += dz;
-        }
-    }
-    // If determinant is negative, reverse vertex order
-    if (determinant < 0) {
-        vertices.reverse();
-    }
-    // Create a new quad with the transformed vertices
-    const transformedQuad = Quad.Create(vertices.map((vertex) => Vector3Like.ToArray(vertex)));
-    return transformedQuad;
-}
-export function TransformBox(quads, transform) {
+import { QuadVerticies } from "../Geometry.types";
+import { AMath, Vector3Like } from "@amodx/math";
+export function TransformBox(box, transform) {
     // Collect all unique vertices from the quads
     const vertexMap = new Map();
-    for (const quad of quads) {
+    for (const quad of box.quads) {
         const vertices = [
             quad.positions.vertices[QuadVerticies.TopRight],
             quad.positions.vertices[QuadVerticies.TopLeft],
@@ -180,9 +65,9 @@ export function TransformBox(quads, transform) {
     // Rotate around a pivot point if specified
     if (transform.rotation) {
         const [rotXDeg, rotYDeg, rotZDeg] = transform.rotation;
-        const rotX = degreesToRadians(rotXDeg);
-        const rotY = degreesToRadians(rotYDeg);
-        const rotZ = degreesToRadians(rotZDeg);
+        const rotX = AMath.DegreesToRadians(rotXDeg);
+        const rotY = AMath.DegreesToRadians(rotYDeg);
+        const rotZ = AMath.DegreesToRadians(rotZDeg);
         const pivot = transform.rotationPivot
             ? {
                 x: transform.rotationPivot[0],
@@ -238,7 +123,7 @@ export function TransformBox(quads, transform) {
         }
     }
     // Update the quads with transformed vertices
-    for (const quad of quads) {
+    for (const quad of box.quads) {
         const originalVertices = [
             quad.positions.vertices[QuadVerticies.TopRight],
             quad.positions.vertices[QuadVerticies.TopLeft],
@@ -255,5 +140,5 @@ export function TransformBox(quads, transform) {
         }
         quad.setPositions(transformedVertices.map((v) => Vector3Like.ToArray(v)));
     }
-    return quads;
+    return box;
 }

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

@@ -0,0 +1,3 @@
+import { VoxelGeometryTransform } from "../Geometry.types";
+import { Quad } from "../Primitives";
+export declare function TransformQuad(quad: Quad, transform: VoxelGeometryTransform): Quad;