@divinevoxel/vlox 0.0.73 → 0.0.75

package/Mesher/Geomtry/CompactedSectionVoxelMesh.d.ts

@@ -0,0 +1,26 @@
+import { Vec3Array } from "@amodx/math";
+import { LocationData } from "../../Math";
+export declare class CompactedMeshData {
+    material: number;
+    materialId: string;
+    minBounds: Vec3Array;
+    maxBounds: Vec3Array;
+    vertexCount: number;
+    indexCount: number;
+    vertexIndex: [start: number, length: number];
+    indiceIndex: [start: number, length: number];
+    verticies: Float32Array;
+    indices: Uint32Array;
+}
+export declare class CompactedSectionVoxelMesh {
+    static GetHeaderByteSize(totalMeshes?: number): number;
+    static GetMeshHeaderByteSize(): number;
+    data: DataView;
+    setData(data: ArrayBuffer): void;
+    setTotalMeshes(amount: number): void;
+    getTotalMeshes(): number;
+    setLocation(dimesion: number, x: number, y: number, z: number): void;
+    getLocation(location?: LocationData): LocationData;
+    setMeshData(index: number, mesh: CompactedMeshData): void;
+    getMeshData(index: number, mesh: CompactedMeshData): CompactedMeshData;
+}

package/Mesher/Geomtry/CompactedSectionVoxelMesh.js

@@ -0,0 +1,149 @@
+import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelMeshVertexStructCursor } from "./VoxelMeshVertexStructCursor";
+export class CompactedMeshData {
+    material;
+    materialId = "dve_solid";
+    minBounds = [0, 0, 0];
+    maxBounds = [0, 0, 0];
+    vertexCount = 0;
+    indexCount = 0;
+    vertexIndex = [0, 0];
+    indiceIndex = [0, 0];
+    verticies;
+    indices;
+}
+export class CompactedSectionVoxelMesh {
+    static GetHeaderByteSize(totalMeshes = 0) {
+        return (
+        //dimension index 2 bytes uint16
+        2 +
+            //position x 4 bytes int32
+            4 +
+            //position y 4 bytes int32
+            4 +
+            //position z 4 bytes int32
+            4 +
+            //total meshes
+            1 +
+            //other mehes
+            totalMeshes * this.GetMeshHeaderByteSize());
+    }
+    static GetMeshHeaderByteSize() {
+        return (
+        //material index 1 byte
+        1 +
+            //min x 4 bytes Float32
+            4 +
+            //min y 4 bytes Float32
+            4 +
+            //min z 4 bytes Float32
+            4 +
+            //max x 4 bytes Float32
+            4 +
+            //max y 4 bytes Float32
+            4 +
+            //max z 4 bytes Float32
+            4 +
+            //Vertex Start Byte uint32
+            4 +
+            //Vertex Length
+            4 +
+            //Indice Start Byte uint32
+            4 +
+            //Indice Length
+            4);
+    }
+    data;
+    setData(data) {
+        this.data = new DataView(data);
+    }
+    setTotalMeshes(amount) {
+        this.data.setUint8(14, amount);
+    }
+    getTotalMeshes() {
+        return this.data.getUint8(14);
+    }
+    setLocation(dimesion, x, y, z) {
+        this.data.setInt16(0, dimesion);
+        this.data.setInt32(2, x);
+        this.data.setInt32(6, y);
+        this.data.setInt32(10, z);
+    }
+    getLocation(location = [0, 0, 0, 0]) {
+        location[0] = this.data.getInt16(0);
+        location[1] = this.data.getInt32(2);
+        location[2] = this.data.getInt32(6);
+        location[3] = this.data.getInt32(10);
+        return location;
+    }
+    setMeshData(index, mesh) {
+        const { materialId: material, minBounds, maxBounds, vertexIndex, indiceIndex, } = mesh;
+        let startByte = CompactedSectionVoxelMesh.GetHeaderByteSize(0) +
+            CompactedSectionVoxelMesh.GetMeshHeaderByteSize() * index;
+        //material index
+        this.data.setUint8(startByte, VoxelPalettesRegister.material.getNumberId(material));
+        startByte++;
+        //min bounds
+        this.data.setFloat32(startByte, minBounds[0]);
+        startByte += 4;
+        this.data.setFloat32(startByte, minBounds[1]);
+        startByte += 4;
+        this.data.setFloat32(startByte, minBounds[2]);
+        startByte += 4;
+        //max bounds
+        this.data.setFloat32(startByte, maxBounds[0]);
+        startByte += 4;
+        this.data.setFloat32(startByte, maxBounds[1]);
+        startByte += 4;
+        this.data.setFloat32(startByte, maxBounds[2]);
+        startByte += 4;
+        //vertex index
+        this.data.setUint32(startByte, vertexIndex[0]);
+        startByte += 4;
+        this.data.setUint32(startByte, vertexIndex[1]);
+        startByte += 4;
+        //indice index
+        this.data.setUint32(startByte, indiceIndex[0]);
+        startByte += 4;
+        this.data.setUint32(startByte, indiceIndex[1]);
+        startByte += 4;
+    }
+    getMeshData(index, mesh) {
+        let startByte = CompactedSectionVoxelMesh.GetHeaderByteSize(0) +
+            CompactedSectionVoxelMesh.GetMeshHeaderByteSize() * index;
+        // material index
+        mesh.material = this.data.getUint8(startByte);
+        mesh.materialId = VoxelPalettesRegister.material.getStringId(mesh.material);
+        startByte++;
+        // min bounds
+        mesh.minBounds[0] = this.data.getFloat32(startByte);
+        startByte += 4;
+        mesh.minBounds[1] = this.data.getFloat32(startByte);
+        startByte += 4;
+        mesh.minBounds[2] = this.data.getFloat32(startByte);
+        startByte += 4;
+        // max bounds
+        mesh.maxBounds[0] = this.data.getFloat32(startByte);
+        startByte += 4;
+        mesh.maxBounds[1] = this.data.getFloat32(startByte);
+        startByte += 4;
+        mesh.maxBounds[2] = this.data.getFloat32(startByte);
+        startByte += 4;
+        // vertex index
+        mesh.vertexIndex[0] = this.data.getUint32(startByte);
+        startByte += 4;
+        mesh.vertexIndex[1] = this.data.getUint32(startByte);
+        startByte += 4;
+        // indice index
+        mesh.indiceIndex[0] = this.data.getUint32(startByte);
+        startByte += 4;
+        mesh.indiceIndex[1] = this.data.getUint32(startByte);
+        startByte += 4;
+        mesh.verticies = new Float32Array(this.data.buffer, ...mesh.vertexIndex);
+        mesh.indices = new Uint32Array(this.data.buffer, ...mesh.indiceIndex);
+        mesh.vertexCount =
+            mesh.vertexIndex[1] / VoxelMeshVertexStructCursor.VertexFloatSize;
+        mesh.indexCount = mesh.indiceIndex[1];
+        return mesh;
+    }
+}

package/Mesher/Geomtry/Functions/GetBounds.d.ts

@@ -0,0 +1,2 @@
+import { Vec3Array, Vector3Like } from "@amodx/math";
+export declare function GetBounds(...vectors: Vector3Like[]): [Vec3Array, Vec3Array];

package/Mesher/{Models/Common/BoundsFunctions.js → Geomtry/Functions/GetBounds.js}

@@ -1,4 +1,4 @@
-export function GetBounds(vectors) {
+export function GetBounds(...vectors) {
     let minX = Infinity;
     let minY = Infinity;
     let minZ = Infinity;
@@ -7,7 +7,7 @@ export function GetBounds(vectors) {
     let maxZ = -Infinity;
     const EPSILON = 0;
     for (let i = 0; i < vectors.length; i++) {
-        const [x, y, z] = vectors[i];
+        const { x, y, z } = vectors[i];
         if (x < minX)
             minX = x;
         if (y < minY)
@@ -22,17 +22,17 @@ export function GetBounds(vectors) {
             maxZ = z;
     }
     /*   if (maxX - minX < EPSILON) {
-        minX -= EPSILON / 2;
-        maxX += Number.EPSILON / 2;
-      }
-      if (maxY - minY < EPSILON) {
-        maxY -= EPSILON / 2;
-        minY += Number.EPSILON / 2;
-      }
-      if (maxZ - minZ < EPSILON) {
-        maxZ -= EPSILON / 2;
-        minZ += EPSILON / 2;
-      } */
+      minX -= EPSILON / 2;
+      maxX += Number.EPSILON / 2;
+    }
+    if (maxY - minY < EPSILON) {
+      maxY -= EPSILON / 2;
+      minY += Number.EPSILON / 2;
+    }
+    if (maxZ - minZ < EPSILON) {
+      maxZ -= EPSILON / 2;
+      minZ += EPSILON / 2;
+    } */
     return [
         [minX, minY, minZ],
         [maxX, maxY, maxZ],

package/Mesher/Geomtry/Geometry.types.d.ts

@@ -1,4 +1,12 @@
 import type { Vec2Array, Vec3Array } from "@amodx/math";
+export interface VoxelGeometryTransform {
+    position?: Vec3Array;
+    scale?: Vec3Array;
+    rotation?: Vec3Array;
+    rotationPivot?: Vec3Array;
+    lockUVs?: true;
+    flip?: [flipX: 0 | 1, flipY: 0 | 1, flipZ: 0 | 1];
+}
 export type QuadVertexVec3Data = [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
 export type QuadVertexFloatData = [number, number, number, number];
 export type QuadUVData = [Vec2Array, Vec2Array, Vec2Array, Vec2Array];
@@ -9,3 +17,9 @@ export declare enum QuadVerticies {
     BottomRight = 3
 }
 export declare const QuadVerticiesArray: QuadVerticies[];
+export declare enum TriangleVerticies {
+    One = 0,
+    Two = 1,
+    Three = 2
+}
+export declare const TriangleVerticiesArray: TriangleVerticies[];

package/Mesher/Geomtry/Geometry.types.js

@@ -11,3 +11,14 @@ export const QuadVerticiesArray = [
     QuadVerticies.BottomLeft,
     QuadVerticies.BottomRight,
 ];
+export var TriangleVerticies;
+(function (TriangleVerticies) {
+    TriangleVerticies[TriangleVerticies["One"] = 0] = "One";
+    TriangleVerticies[TriangleVerticies["Two"] = 1] = "Two";
+    TriangleVerticies[TriangleVerticies["Three"] = 2] = "Three";
+})(TriangleVerticies || (TriangleVerticies = {}));
+export const TriangleVerticiesArray = [
+    TriangleVerticies.One,
+    TriangleVerticies.Two,
+    TriangleVerticies.Three,
+];

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

@@ -1,29 +1,23 @@
 import { Vec2Array, Vec3Array } from "@amodx/math";
 import { QuadVector2VertexData, QuadVector3VertexData } from "./QuadVertexData";
-import { QuadUVData, QuadVertexVec3Data, QuadVerticies } from "../Geometry.types";
+import { QuadUVData, QuadVerticies } from "../Geometry.types";
 export declare class Quad {
     static FullUVs: Readonly<QuadUVData>;
     static RotateUvs(uvs: QuadUVData | Readonly<QuadUVData>, rotation: number): QuadUVData;
-    static Create(positions?: [Vec3Array, Vec3Array] | [Vec3Array, Vec3Array, Vec3Array, Vec3Array], uvs?: [Vec2Array, Vec2Array, Vec2Array, Vec2Array], doubleSided?: boolean, orientation?: 0 | 1): Quad;
+    static Create(positions?: [Vec3Array, Vec3Array, Vec3Array, Vec3Array], uvs?: [Vec2Array, Vec2Array, Vec2Array, Vec2Array], doubleSided?: boolean): Quad;
     static RotateVertices90Degrees(vertices: [QuadVerticies, QuadVerticies, QuadVerticies, QuadVerticies], times?: number): [QuadVerticies, QuadVerticies, QuadVerticies, QuadVerticies];
-    static GetQuadNormalRightHanded(p1: Vec3Array, p2: Vec3Array, p3: Vec3Array, p4: Vec3Array): [n1: Vec3Array, n2: Vec3Array, n3: Vec3Array, n4: Vec3Array];
-    static GetQuadNormalLeftHanded(p1: Vec3Array, p2: Vec3Array, p3: Vec3Array, p4: Vec3Array): [n1: Vec3Array, n2: Vec3Array, n3: Vec3Array, n4: Vec3Array];
-    static CalculateQuadPoints(start: Vec3Array, end: Vec3Array): {
-        points: QuadVertexVec3Data;
-        normal: Vec3Array;
-    };
+    static GetNormalRightHanded(p1: Vec3Array, p2: Vec3Array, p3: Vec3Array, p4: Vec3Array): [n1: Vec3Array, n2: Vec3Array, n3: Vec3Array, n4: Vec3Array];
+    static GetNormalLeftHanded(p1: Vec3Array, p2: Vec3Array, p3: Vec3Array, p4: Vec3Array): [n1: Vec3Array, n2: Vec3Array, n3: Vec3Array, n4: Vec3Array];
     static OrderQuadVertices(vertices: [Vec3Array, Vec3Array, Vec3Array, Vec3Array], direction: "north" | "south" | "east" | "west" | "up" | "down"): [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
     positions: QuadVector3VertexData;
     normals: QuadVector3VertexData;
     uvs: QuadVector2VertexData;
-    flip: boolean;
+    bounds: [min: Vec3Array, max: Vec3Array];
     doubleSided: boolean;
-    orientation: 0 | 1;
     constructor(data: {
-        positions?: [Vec3Array, Vec3Array] | [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
+        positions?: [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
         uvs?: [Vec2Array, Vec2Array, Vec2Array, Vec2Array];
         doubleSided?: boolean;
-        orientation?: 0 | 1;
     });
     setUVs([v1, v2, v3, v4]: [
         v1: Vec2Array,
@@ -31,8 +25,6 @@ export declare class Quad {
         v3: Vec2Array,
         v4: Vec2Array
     ]): this;
-    scale(x: number, y: number, z: number): this;
-    transform(x: number, y: number, z: number): this;
-    setPositions(positions: [Vec3Array, Vec3Array] | [Vec3Array, Vec3Array, Vec3Array, Vec3Array]): this;
+    setPositions(positions: [Vec3Array, Vec3Array, Vec3Array, Vec3Array]): this;
     clone(): Quad;
 }

package/Mesher/Geomtry/Primitives/Quad.js

@@ -1,5 +1,6 @@
-import { Matrix3x3Like, Vector2Like, Vector3Like, } from "@amodx/math";
+import { Matrix2x2Like, Vec2ArrayLike, Vec3ArrayLike, Vector3Like, } from "@amodx/math";
 import { QuadVector2VertexData, QuadVector3VertexData } from "./QuadVertexData";
+import { GetBounds } from "../Functions/GetBounds";
 export class Quad {
     static FullUVs = Object.freeze([
         [1, 1],
@@ -8,18 +9,18 @@ export class Quad {
         [1, 0],
     ]);
     static RotateUvs(uvs, rotation) {
-        const rotationMatrix = Matrix3x3Like.RotationZ(rotation);
+        const rotationMatrix = Matrix2x2Like.Rotation(rotation);
         const pivot = [0.5, 0.5];
         const rotatedUVs = [
-            Vector2Like.RotateAroundPivotArray(rotationMatrix, uvs[0], pivot),
-            Vector2Like.RotateAroundPivotArray(rotationMatrix, uvs[1], pivot),
-            Vector2Like.RotateAroundPivotArray(rotationMatrix, uvs[2], pivot),
-            Vector2Like.RotateAroundPivotArray(rotationMatrix, uvs[3], pivot),
+            Vec2ArrayLike.RotateAroundPivot(rotationMatrix, uvs[0], pivot),
+            Vec2ArrayLike.RotateAroundPivot(rotationMatrix, uvs[1], pivot),
+            Vec2ArrayLike.RotateAroundPivot(rotationMatrix, uvs[2], pivot),
+            Vec2ArrayLike.RotateAroundPivot(rotationMatrix, uvs[3], pivot),
         ];
         return rotatedUVs;
     }
-    static Create(positions, uvs, doubleSided, orientation) {
-        return new Quad({ positions, uvs, doubleSided, orientation });
+    static Create(positions, uvs, doubleSided) {
+        return new Quad({ positions, uvs, doubleSided });
     }
     static RotateVertices90Degrees(vertices, times = 1) {
         while (times--) {
@@ -27,20 +28,20 @@ export class Quad {
         }
         return vertices;
     }
-    static GetQuadNormalRightHanded(p1, p2, p3, p4) {
+    static GetNormalRightHanded(p1, p2, p3, p4) {
         const vectorA1 = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
         const vectorA2 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
-        const normalA = Vector3Like.NormalizeArray(Vector3Like.CrossArray(vectorA1, vectorA2));
+        const normalA = Vec3ArrayLike.Normalize(Vec3ArrayLike.Cross(vectorA1, vectorA2));
         const vectorB1 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
         const vectorB2 = [p4[0] - p1[0], p4[1] - p1[1], p4[2] - p1[2]];
-        const normalB = Vector3Like.NormalizeArray(Vector3Like.CrossArray(vectorB1, vectorB2));
-        const n1 = Vector3Like.NormalizeArray([
+        const normalB = Vec3ArrayLike.Normalize(Vec3ArrayLike.Cross(vectorB1, vectorB2));
+        const n1 = Vec3ArrayLike.Normalize([
             (normalA[0] + normalB[0]) / 2,
             (normalA[1] + normalB[1]) / 2,
             (normalA[2] + normalB[2]) / 2,
         ]);
         const n2 = normalA;
-        const n3 = Vector3Like.NormalizeArray([
+        const n3 = Vec3ArrayLike.Normalize([
             (normalA[0] + normalB[0]) / 2,
             (normalA[1] + normalB[1]) / 2,
             (normalA[2] + normalB[2]) / 2,
@@ -56,22 +57,22 @@ export class Quad {
         }
         return normals;
     }
-    static GetQuadNormalLeftHanded(p1, p2, p3, p4) {
+    static GetNormalLeftHanded(p1, p2, p3, p4) {
         const vectorA1 = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
         const vectorA2 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
         // Reverse the cross product direction for left-handed system
-        const normalA = Vector3Like.MultiplyScalarArray(Vector3Like.NormalizeArray(Vector3Like.CrossArray(vectorA1, vectorA2)), -1);
+        const normalA = Vec3ArrayLike.MultiplyScalar(Vec3ArrayLike.Normalize(Vec3ArrayLike.Cross(vectorA1, vectorA2)), -1);
         const vectorB1 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
         const vectorB2 = [p4[0] - p1[0], p4[1] - p1[1], p4[2] - p1[2]];
         // Reverse the cross product direction for left-handed system
-        const normalB = Vector3Like.MultiplyScalarArray(Vector3Like.NormalizeArray(Vector3Like.CrossArray(vectorB1, vectorB2)), -1);
-        const n1 = Vector3Like.NormalizeArray([
+        const normalB = Vec3ArrayLike.MultiplyScalar(Vec3ArrayLike.Normalize(Vec3ArrayLike.Cross(vectorB1, vectorB2)), -1);
+        const n1 = Vec3ArrayLike.Normalize([
             (normalA[0] + normalB[0]) / 2,
             (normalA[1] + normalB[1]) / 2,
             (normalA[2] + normalB[2]) / 2,
         ]);
         const n2 = normalA;
-        const n3 = Vector3Like.NormalizeArray([
+        const n3 = Vec3ArrayLike.Normalize([
             (normalA[0] + normalB[0]) / 2,
             (normalA[1] + normalB[1]) / 2,
             (normalA[2] + normalB[2]) / 2,
@@ -87,47 +88,6 @@ export class Quad {
         }
         return normals;
     }
-    static CalculateQuadPoints(start, end) {
-        const plane = start
-            .map((value, index) => (end[index] !== value ? index : -1))
-            .filter((index) => index !== -1);
-        let topLeft, bottomRight;
-        const topRight = end;
-        const bottomLeft = start;
-        if (plane.includes(0) && plane.includes(2)) {
-            // XZ plane
-            topLeft = [start[0], start[1], end[2]];
-            bottomRight = [end[0], start[1], start[2]];
-        }
-        else if (plane.includes(0) && plane.includes(1)) {
-            // XY plane
-            topLeft = [start[0], end[1], start[2]];
-            bottomRight = [end[0], start[1], start[2]];
-        }
-        else if (plane.includes(1) && plane.includes(2)) {
-            // YZ plane
-            topLeft = [start[0], end[1], start[2]];
-            bottomRight = [start[0], start[1], end[2]];
-        }
-        const delta = [end[0] - start[0], end[1] - start[1], end[2] - start[2]];
-        let normal = [0, 0, 0];
-        if (delta[0] === 0) {
-            // Constant X, so normal is along X
-            normal[0] = 1;
-        }
-        else if (delta[1] === 0) {
-            // Constant Y, so normal is along Y
-            normal[1] = 1;
-        }
-        else if (delta[2] === 0) {
-            // Constant Z, so normal is along Z
-            normal[2] = 1;
-        }
-        return {
-            points: [topRight, topLeft, bottomLeft, bottomRight],
-            normal,
-        };
-    }
     static OrderQuadVertices(vertices, direction) {
         const projections = {
             north: (v) => [v[0], v[1]],
@@ -172,9 +132,11 @@ export class Quad {
     positions = new QuadVector3VertexData();
     normals = new QuadVector3VertexData();
     uvs = new QuadVector2VertexData();
-    flip = false;
+    bounds = [
+        [0, 0, 0],
+        [0, 0, 0],
+    ];
     doubleSided = false;
-    orientation = 0;
     constructor(data) {
         if (data.positions)
             this.setPositions(data.positions);
@@ -182,43 +144,26 @@ export class Quad {
             this.setUVs(data.uvs);
         if (data.doubleSided)
             this.doubleSided = data.doubleSided;
-        if (data.orientation !== undefined)
-            this.orientation = data.orientation;
     }
     setUVs([v1, v2, v3, v4]) {
-        this.uvs.set(Vector2Like.FromArray(v1), Vector2Like.FromArray(v2), Vector2Like.FromArray(v3), Vector2Like.FromArray(v4));
-        return this;
-    }
-    scale(x, y, z) {
-        const scale = Vector3Like.Create(x, y, z);
-        for (const position of this.positions) {
-            Vector3Like.MultiplyInPlace(position, scale);
-        }
-        return this;
-    }
-    transform(x, y, z) {
-        const transform = Vector3Like.Create(x, y, z);
-        for (const position of this.positions) {
-            Vector3Like.AddInPlace(position, transform);
-        }
+        this.uvs.vertices[0].x = v1[0];
+        this.uvs.vertices[0].y = v1[1];
+        this.uvs.vertices[1].x = v2[0];
+        this.uvs.vertices[1].y = v2[1];
+        this.uvs.vertices[2].x = v3[0];
+        this.uvs.vertices[2].y = v3[1];
+        this.uvs.vertices[3].x = v4[0];
+        this.uvs.vertices[3].y = v4[1];
         return this;
     }
     setPositions(positions) {
-        if (positions.length == 2) {
-            const { points, normal } = Quad.CalculateQuadPoints(positions[0], positions[1]);
-            this.positions.set(Vector3Like.FromArray(points[0]), Vector3Like.FromArray(points[1]), Vector3Like.FromArray(points[2]), Vector3Like.FromArray(points[3]));
-            this.normals.set(Vector3Like.FromArray(normal), Vector3Like.FromArray(normal), Vector3Like.FromArray(normal), Vector3Like.FromArray(normal));
-        }
-        if (positions.length == 4) {
-            const [n1, n2, n3, n4] = Quad.GetQuadNormalLeftHanded(...positions);
-            this.positions.set(Vector3Like.FromArray(positions[0]), Vector3Like.FromArray(positions[1]), Vector3Like.FromArray(positions[2]), Vector3Like.FromArray(positions[3]));
-            this.normals.set(Vector3Like.FromArray(n1), Vector3Like.FromArray(n2), Vector3Like.FromArray(n3), Vector3Like.FromArray(n4));
-        }
+        const [n1, n2, n3, n4] = Quad.GetNormalLeftHanded(...positions);
+        this.positions.set(Vector3Like.FromArray(positions[0]), Vector3Like.FromArray(positions[1]), Vector3Like.FromArray(positions[2]), Vector3Like.FromArray(positions[3]));
+        this.normals.set(Vector3Like.FromArray(n1), Vector3Like.FromArray(n2), Vector3Like.FromArray(n3), Vector3Like.FromArray(n4));
+        this.bounds = GetBounds(...this.positions);
         return this;
     }
     clone() {
-        return Quad.Create(this.positions
-            .getAsArray()
-            .map((_) => Vector3Like.ToArray(_)), this.uvs.getAsArray().map((_) => Vector2Like.ToArray(_)));
+        return Quad.Create(this.positions.toVec3Array(), this.uvs.toVec2Array());
     }
 }

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

@@ -1,10 +1,10 @@
 import { QuadVerticies } from "../Geometry.types.js";
-import { Vector3Like, Vector2Like, Vec3Array } from "@amodx/math";
+import { Vector3Like, Vector2Like, Vec3Array, Vec2Array } from "@amodx/math";
 type QuadDataType<Data> = [Data, Data, Data, Data];
 export declare class QuadVertexData<Data> {
     vertices: QuadDataType<Data>;
     constructor(vertices: QuadDataType<Data>);
-    getAsArray(): Data[];
+    toArray(): Data[];
     setVertex(vertex: QuadVerticies, value: Data): void;
     getVertex(vertex: QuadVerticies): Data;
     setAll(value: Data): void;
@@ -14,18 +14,6 @@ export declare class QuadVertexData<Data> {
     [Symbol.iterator](): Iterator<Data>;
     clone(): QuadVertexData<Data>;
 }
-export declare class QuadVec3ArrayVertexData extends QuadVertexData<Vec3Array> {
-    vertices: QuadDataType<Vec3Array>;
-    constructor(vertices?: QuadDataType<Vec3Array>);
-    setFromQuadData(vertexData: QuadVertexData<Vec3Array>): void;
-    addToVertex(vertex: QuadVerticies, value: Vec3Array): void;
-    subtractFromVertex(vertex: QuadVerticies, value: Vec3Array): void;
-    addAll(value: Vec3Array): void;
-    subtractAll(value: Vec3Array): void;
-    isEqualTo(v1: Vec3Array, v2: Vec3Array, v3: Vec3Array, v4: Vec3Array): boolean;
-    isAllEqualTo(v1: Vec3Array): boolean;
-    clone(): QuadVec3ArrayVertexData;
-}
 export declare class QuadVector3VertexData extends QuadVertexData<Vector3Like> {
     vertices: QuadDataType<Vector3Like>;
     constructor(vertices?: QuadDataType<Vector3Like>);
@@ -37,6 +25,7 @@ export declare class QuadVector3VertexData extends QuadVertexData<Vector3Like> {
     isEqualTo(v1: Vector3Like, v2: Vector3Like, v3: Vector3Like, v4: Vector3Like): boolean;
     isAllEqualTo(v1: Vector3Like): boolean;
     clone(): QuadVector3VertexData;
+    toVec3Array(): [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
 }
 export declare class QuadVector2VertexData extends QuadVertexData<Vector2Like> {
     vertices: QuadDataType<Vector2Like>;
@@ -48,6 +37,7 @@ export declare class QuadVector2VertexData extends QuadVertexData<Vector2Like> {
     subtractAll(value: Vector2Like): void;
     isEqualTo(v1: Vector2Like, v2: Vector2Like, v3: Vector2Like, v4: Vector2Like): boolean;
     isAllEqualTo(v1: Vector2Like): boolean;
+    toVec2Array(): [Vec2Array, Vec2Array, Vec2Array, Vec2Array];
     clone(): QuadVector2VertexData;
 }
 export declare class QuadScalarVertexData extends QuadVertexData<number> {

package/Mesher/Geomtry/Primitives/QuadVertexData.js

@@ -5,7 +5,7 @@ export class QuadVertexData {
     constructor(vertices) {
         this.vertices = vertices;
     }
-    getAsArray() {
+    toArray() {
         return [
             this.vertices[QuadVerticies.TopRight],
             this.vertices[QuadVerticies.TopLeft],
@@ -76,62 +76,6 @@ export class QuadVertexData {
         ]);
     }
 }
-export class QuadVec3ArrayVertexData extends QuadVertexData {
-    vertices;
-    constructor(vertices = [
-        [0, 0, 0],
-        [0, 0, 0],
-        [0, 0, 0],
-        [0, 0, 0],
-    ]) {
-        super(vertices);
-        this.vertices = vertices;
-    }
-    setFromQuadData(vertexData) {
-        Vector3Like.CopyArray(this.vertices[QuadVerticies.TopRight], vertexData.vertices[QuadVerticies.TopRight]);
-        Vector3Like.CopyArray(this.vertices[QuadVerticies.TopLeft], vertexData.vertices[QuadVerticies.TopLeft]);
-        Vector3Like.CopyArray(this.vertices[QuadVerticies.BottomLeft], vertexData.vertices[QuadVerticies.BottomLeft]);
-        Vector3Like.CopyArray(this.vertices[QuadVerticies.BottomRight], vertexData.vertices[QuadVerticies.BottomRight]);
-    }
-    addToVertex(vertex, value) {
-        Vector3Like.AddArrayInPlace(this.vertices[vertex], value);
-    }
-    subtractFromVertex(vertex, value) {
-        Vector3Like.SubtractArrayInPlace(this.vertices[vertex], value);
-    }
-    addAll(value) {
-        this.addToVertex(QuadVerticies.TopRight, value);
-        this.addToVertex(QuadVerticies.TopLeft, value);
-        this.addToVertex(QuadVerticies.BottomLeft, value);
-        this.addToVertex(QuadVerticies.BottomRight, value);
-    }
-    subtractAll(value) {
-        this.subtractFromVertex(QuadVerticies.TopRight, value);
-        this.subtractFromVertex(QuadVerticies.TopLeft, value);
-        this.subtractFromVertex(QuadVerticies.BottomLeft, value);
-        this.subtractFromVertex(QuadVerticies.BottomRight, value);
-    }
-    isEqualTo(v1, v2, v3, v4) {
-        return (Vector3Like.EqualsArray(this.vertices[QuadVerticies.TopRight], v1) &&
-            Vector3Like.EqualsArray(this.vertices[QuadVerticies.TopLeft], v2) &&
-            Vector3Like.EqualsArray(this.vertices[QuadVerticies.BottomLeft], v3) &&
-            Vector3Like.EqualsArray(this.vertices[QuadVerticies.BottomRight], v4));
-    }
-    isAllEqualTo(v1) {
-        return (Vector3Like.EqualsArray(this.vertices[QuadVerticies.TopRight], v1) &&
-            Vector3Like.EqualsArray(this.vertices[QuadVerticies.TopLeft], v1) &&
-            Vector3Like.EqualsArray(this.vertices[QuadVerticies.BottomLeft], v1) &&
-            Vector3Like.EqualsArray(this.vertices[QuadVerticies.BottomRight], v1));
-    }
-    clone() {
-        return new QuadVec3ArrayVertexData([
-            [...this.vertices[QuadVerticies.TopRight]],
-            [...this.vertices[QuadVerticies.TopLeft]],
-            [...this.vertices[QuadVerticies.BottomLeft]],
-            [...this.vertices[QuadVerticies.BottomRight]],
-        ]);
-    }
-}
 export class QuadVector3VertexData extends QuadVertexData {
     vertices;
     constructor(vertices = [
@@ -187,6 +131,14 @@ export class QuadVector3VertexData extends QuadVertexData {
             Vector3Like.Clone(this.vertices[QuadVerticies.BottomRight]),
         ]);
     }
+    toVec3Array() {
+        return [
+            Vector3Like.ToArray(this.vertices[0]),
+            Vector3Like.ToArray(this.vertices[1]),
+            Vector3Like.ToArray(this.vertices[2]),
+            Vector3Like.ToArray(this.vertices[3]),
+        ];
+    }
 }
 export class QuadVector2VertexData extends QuadVertexData {
     vertices;
@@ -235,6 +187,14 @@ export class QuadVector2VertexData extends QuadVertexData {
             Vector2Like.Equals(this.vertices[QuadVerticies.BottomLeft], v1) &&
             Vector2Like.Equals(this.vertices[QuadVerticies.BottomRight], v1));
     }
+    toVec2Array() {
+        return [
+            Vector2Like.ToArray(this.vertices[0]),
+            Vector2Like.ToArray(this.vertices[1]),
+            Vector2Like.ToArray(this.vertices[2]),
+            Vector2Like.ToArray(this.vertices[3]),
+        ];
+    }
     clone() {
         return new QuadVector2VertexData([
             Vector2Like.Clone(this.vertices[QuadVerticies.TopRight]),