@divinevoxel/vlox 0.0.80 → 0.0.81

package/Mesher/Geometry/Primitives/TriangleVertexData.js

@@ -1,5 +1,4 @@
 import { Vector3Like, Vector2Like } from "@amodx/math";
-import { TriangleVerticies } from "../Geometry.types";
 export class TriangleVertexData {
     vertices;
     constructor(vertices) {
@@ -7,9 +6,9 @@ export class TriangleVertexData {
     }
     toArray() {
         return [
-            this.vertices[TriangleVerticies.One],
-            this.vertices[TriangleVerticies.Two],
-            this.vertices[TriangleVerticies.Three],
+            this.vertices[0 /* TriangleVerticies.One */],
+            this.vertices[1 /* TriangleVerticies.Two */],
+            this.vertices[2 /* TriangleVerticies.Three */],
         ];
     }
     setVertex(vertex, value) {
@@ -19,39 +18,39 @@ export class TriangleVertexData {
         return this.vertices[vertex];
     }
     setAll(value) {
-        this.vertices[TriangleVerticies.One] = value;
-        this.vertices[TriangleVerticies.Two] = value;
-        this.vertices[TriangleVerticies.Three] = value;
+        this.vertices[0 /* TriangleVerticies.One */] = value;
+        this.vertices[1 /* TriangleVerticies.Two */] = value;
+        this.vertices[2 /* TriangleVerticies.Three */] = value;
     }
     set(v1, v2, v3) {
-        this.vertices[TriangleVerticies.One] = v1;
-        this.vertices[TriangleVerticies.Two] = v2;
-        this.vertices[TriangleVerticies.Three] = v3;
+        this.vertices[0 /* TriangleVerticies.One */] = v1;
+        this.vertices[1 /* TriangleVerticies.Two */] = v2;
+        this.vertices[2 /* TriangleVerticies.Three */] = v3;
     }
     isEqualTo(v1, v2, v3) {
-        if (this.vertices[TriangleVerticies.One] != v1)
+        if (this.vertices[0 /* TriangleVerticies.One */] != v1)
             return false;
-        if (this.vertices[TriangleVerticies.Two] != v2)
+        if (this.vertices[1 /* TriangleVerticies.Two */] != v2)
             return false;
-        if (this.vertices[TriangleVerticies.Three] != v3)
+        if (this.vertices[2 /* TriangleVerticies.Three */] != v3)
             return false;
         return true;
     }
     isAllEqualTo(value) {
-        if (this.vertices[TriangleVerticies.One] != value)
+        if (this.vertices[0 /* TriangleVerticies.One */] != value)
             return false;
-        if (this.vertices[TriangleVerticies.Two] != value)
+        if (this.vertices[1 /* TriangleVerticies.Two */] != value)
             return false;
-        if (this.vertices[TriangleVerticies.Three] != value)
+        if (this.vertices[2 /* TriangleVerticies.Three */] != value)
             return false;
         return true;
     }
     [Symbol.iterator]() {
-        let index = TriangleVerticies.One;
+        let index = 0 /* TriangleVerticies.One */;
         const items = this.vertices;
         return {
             next() {
-                if (index < TriangleVerticies.Three) {
+                if (index < 2 /* TriangleVerticies.Three */) {
                     return { value: items[index++], done: false };
                 }
                 else {
@@ -62,9 +61,9 @@ export class TriangleVertexData {
     }
     clone() {
         return new TriangleVertexData([
-            structuredClone(this.vertices[TriangleVerticies.One]),
-            structuredClone(this.vertices[TriangleVerticies.Two]),
-            structuredClone(this.vertices[TriangleVerticies.Three]),
+            structuredClone(this.vertices[0 /* TriangleVerticies.One */]),
+            structuredClone(this.vertices[1 /* TriangleVerticies.Two */]),
+            structuredClone(this.vertices[2 /* TriangleVerticies.Three */]),
         ]);
     }
 }
@@ -79,9 +78,9 @@ export class TriangleVector3VertexData extends TriangleVertexData {
         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]);
+        Vector3Like.Copy(this.vertices[0 /* TriangleVerticies.One */], vertexData.vertices[0 /* TriangleVerticies.One */]);
+        Vector3Like.Copy(this.vertices[1 /* TriangleVerticies.Two */], vertexData.vertices[1 /* TriangleVerticies.Two */]);
+        Vector3Like.Copy(this.vertices[2 /* TriangleVerticies.Three */], vertexData.vertices[2 /* TriangleVerticies.Three */]);
     }
     addToVertex(vertex, value) {
         Vector3Like.AddInPlace(this.vertices[vertex], value);
@@ -90,30 +89,30 @@ export class TriangleVector3VertexData extends TriangleVertexData {
         Vector3Like.SubtractInPlace(this.vertices[vertex], value);
     }
     addAll(value) {
-        this.addToVertex(TriangleVerticies.One, value);
-        this.addToVertex(TriangleVerticies.Two, value);
-        this.addToVertex(TriangleVerticies.Three, value);
+        this.addToVertex(0 /* TriangleVerticies.One */, value);
+        this.addToVertex(1 /* TriangleVerticies.Two */, value);
+        this.addToVertex(2 /* TriangleVerticies.Three */, value);
     }
     subtractAll(value) {
-        this.subtractFromVertex(TriangleVerticies.One, value);
-        this.subtractFromVertex(TriangleVerticies.Two, value);
-        this.subtractFromVertex(TriangleVerticies.Three, value);
+        this.subtractFromVertex(0 /* TriangleVerticies.One */, value);
+        this.subtractFromVertex(1 /* TriangleVerticies.Two */, value);
+        this.subtractFromVertex(2 /* 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));
+        return (Vector3Like.Equals(this.vertices[0 /* TriangleVerticies.One */], v1) &&
+            Vector3Like.Equals(this.vertices[1 /* TriangleVerticies.Two */], v2) &&
+            Vector3Like.Equals(this.vertices[2 /* 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));
+        return (Vector3Like.Equals(this.vertices[0 /* TriangleVerticies.One */], v1) &&
+            Vector3Like.Equals(this.vertices[1 /* TriangleVerticies.Two */], v1) &&
+            Vector3Like.Equals(this.vertices[2 /* 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]),
+            Vector3Like.Clone(this.vertices[0 /* TriangleVerticies.One */]),
+            Vector3Like.Clone(this.vertices[1 /* TriangleVerticies.Two */]),
+            Vector3Like.Clone(this.vertices[2 /* TriangleVerticies.Three */]),
         ]);
     }
     toVec3Array() {
@@ -135,9 +134,9 @@ export class TriangleVector2VertexData extends TriangleVertexData {
         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]);
+        Vector2Like.Copy(this.vertices[0 /* TriangleVerticies.One */], vertexData.vertices[0 /* TriangleVerticies.One */]);
+        Vector2Like.Copy(this.vertices[1 /* TriangleVerticies.Two */], vertexData.vertices[1 /* TriangleVerticies.Two */]);
+        Vector2Like.Copy(this.vertices[2 /* TriangleVerticies.Three */], vertexData.vertices[2 /* TriangleVerticies.Three */]);
     }
     addToVertex(vertex, value) {
         Vector2Like.AddInPlace(this.vertices[vertex], value);
@@ -146,24 +145,24 @@ export class TriangleVector2VertexData extends TriangleVertexData {
         Vector2Like.SubtractInPlace(this.vertices[vertex], value);
     }
     addAll(value) {
-        this.addToVertex(TriangleVerticies.One, value);
-        this.addToVertex(TriangleVerticies.Two, value);
-        this.addToVertex(TriangleVerticies.Three, value);
+        this.addToVertex(0 /* TriangleVerticies.One */, value);
+        this.addToVertex(1 /* TriangleVerticies.Two */, value);
+        this.addToVertex(2 /* TriangleVerticies.Three */, value);
     }
     subtractAll(value) {
-        this.subtractFromVertex(TriangleVerticies.One, value);
-        this.subtractFromVertex(TriangleVerticies.Two, value);
-        this.subtractFromVertex(TriangleVerticies.Three, value);
+        this.subtractFromVertex(0 /* TriangleVerticies.One */, value);
+        this.subtractFromVertex(1 /* TriangleVerticies.Two */, value);
+        this.subtractFromVertex(2 /* 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));
+        return (Vector2Like.Equals(this.vertices[0 /* TriangleVerticies.One */], v1) &&
+            Vector2Like.Equals(this.vertices[1 /* TriangleVerticies.Two */], v2) &&
+            Vector2Like.Equals(this.vertices[2 /* 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));
+        return (Vector2Like.Equals(this.vertices[0 /* TriangleVerticies.One */], v1) &&
+            Vector2Like.Equals(this.vertices[1 /* TriangleVerticies.Two */], v1) &&
+            Vector2Like.Equals(this.vertices[2 /* TriangleVerticies.Three */], v1));
     }
     toVec2Array() {
         return [
@@ -174,9 +173,9 @@ export class TriangleVector2VertexData extends TriangleVertexData {
     }
     clone() {
         return new TriangleVector2VertexData([
-            Vector2Like.Clone(this.vertices[TriangleVerticies.One]),
-            Vector2Like.Clone(this.vertices[TriangleVerticies.Two]),
-            Vector2Like.Clone(this.vertices[TriangleVerticies.Three]),
+            Vector2Like.Clone(this.vertices[0 /* TriangleVerticies.One */]),
+            Vector2Like.Clone(this.vertices[1 /* TriangleVerticies.Two */]),
+            Vector2Like.Clone(this.vertices[2 /* TriangleVerticies.Three */]),
         ]);
     }
 }
@@ -187,77 +186,77 @@ export class TriangleScalarVertexData extends TriangleVertexData {
         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];
+        this.vertices[0 /* TriangleVerticies.One */] =
+            vertexData.vertices[0 /* TriangleVerticies.One */];
+        this.vertices[1 /* TriangleVerticies.Two */] =
+            vertexData.vertices[1 /* TriangleVerticies.Two */];
+        this.vertices[2 /* TriangleVerticies.Three */] =
+            vertexData.vertices[2 /* 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;
+        this.vertices[0 /* TriangleVerticies.One */] += value;
+        this.vertices[1 /* TriangleVerticies.Two */] += value;
+        this.vertices[2 /* TriangleVerticies.Three */] += value;
     }
     add(v1, v2, v3, v4) {
-        this.vertices[TriangleVerticies.One] += v1;
-        this.vertices[TriangleVerticies.Two] += v2;
-        this.vertices[TriangleVerticies.Three] += v3;
+        this.vertices[0 /* TriangleVerticies.One */] += v1;
+        this.vertices[1 /* TriangleVerticies.Two */] += v2;
+        this.vertices[2 /* TriangleVerticies.Three */] += v3;
     }
     subtractAll(value) {
-        this.vertices[TriangleVerticies.One] -= value;
-        this.vertices[TriangleVerticies.Two] -= value;
-        this.vertices[TriangleVerticies.Three] -= value;
+        this.vertices[0 /* TriangleVerticies.One */] -= value;
+        this.vertices[1 /* TriangleVerticies.Two */] -= value;
+        this.vertices[2 /* TriangleVerticies.Three */] -= value;
     }
     subtract(v1, v2, v3, v4) {
-        this.vertices[TriangleVerticies.One] += v1;
-        this.vertices[TriangleVerticies.Two] += v2;
-        this.vertices[TriangleVerticies.Three] += v3;
+        this.vertices[0 /* TriangleVerticies.One */] += v1;
+        this.vertices[1 /* TriangleVerticies.Two */] += v2;
+        this.vertices[2 /* TriangleVerticies.Three */] += v3;
     }
     isGreaterThan(v1, v2, v3, v4) {
-        if (this.vertices[TriangleVerticies.One] < v1)
+        if (this.vertices[0 /* TriangleVerticies.One */] < v1)
             return false;
-        if (this.vertices[TriangleVerticies.Two] < v2)
+        if (this.vertices[1 /* TriangleVerticies.Two */] < v2)
             return false;
-        if (this.vertices[TriangleVerticies.Three] < v3)
+        if (this.vertices[2 /* TriangleVerticies.Three */] < v3)
             return false;
         return true;
     }
     isAllGreaterThan(value) {
-        if (this.vertices[TriangleVerticies.One] < value)
+        if (this.vertices[0 /* TriangleVerticies.One */] < value)
             return false;
-        if (this.vertices[TriangleVerticies.Two] < value)
+        if (this.vertices[1 /* TriangleVerticies.Two */] < value)
             return false;
-        if (this.vertices[TriangleVerticies.Three] < value)
+        if (this.vertices[2 /* TriangleVerticies.Three */] < value)
             return false;
         return true;
     }
     isLessThan(v1, v2, v3, v4) {
-        if (this.vertices[TriangleVerticies.One] > v1)
+        if (this.vertices[0 /* TriangleVerticies.One */] > v1)
             return false;
-        if (this.vertices[TriangleVerticies.Two] > v2)
+        if (this.vertices[1 /* TriangleVerticies.Two */] > v2)
             return false;
-        if (this.vertices[TriangleVerticies.Three] > v3)
+        if (this.vertices[2 /* TriangleVerticies.Three */] > v3)
             return false;
         return true;
     }
     isAllLessThan(value) {
-        if (this.vertices[TriangleVerticies.One] > value)
+        if (this.vertices[0 /* TriangleVerticies.One */] > value)
             return false;
-        if (this.vertices[TriangleVerticies.Two] > value)
+        if (this.vertices[1 /* TriangleVerticies.Two */] > value)
             return false;
-        if (this.vertices[TriangleVerticies.Three] > value)
+        if (this.vertices[2 /* TriangleVerticies.Three */] > value)
             return false;
         return true;
     }
     clone() {
         return new TriangleScalarVertexData([
-            this.vertices[TriangleVerticies.One],
-            this.vertices[TriangleVerticies.Two],
-            this.vertices[TriangleVerticies.Three],
+            this.vertices[0 /* TriangleVerticies.One */],
+            this.vertices[1 /* TriangleVerticies.Two */],
+            this.vertices[2 /* TriangleVerticies.Three */],
         ]);
     }
 }

package/Mesher/Geometry/Proto/ProtoMesh.d.ts

@@ -11,7 +11,7 @@ export declare class ProtoMesh {
     constructor(vertexFloatSize: number);
     create(): {
         vertexArray: Float32Array<ArrayBuffer>;
-        indiciesArray: Uint32Array<ArrayBuffer> | Uint16Array<ArrayBuffer>;
+        indiciesArray: Uint16Array<ArrayBuffer> | Uint32Array<ArrayBuffer>;
     };
     addVerticies(vertexCount: number, indicesCount: number): void;
     clear(): void;

package/Mesher/Geometry/Proto/ProtoMesh.js

@@ -14,47 +14,40 @@ export class ProtoMesh {
         this.indices = new ProtoIndiceBuffer(1024);
     }
     create() {
-        const totalVerticies = this.vertexCount * this.vertexFloatSize;
-        const vertexArray = new Float32Array(totalVerticies);
-        const vertexBuffers = this.buffer._buffers;
-        let start = 0;
-        let done = false;
-        for (let i = 0; i < vertexBuffers.length; i++) {
+        const totalVertices = this.vertexCount * this.vertexFloatSize;
+        const vertexArray = new Float32Array(totalVertices);
+        const vertexBuffers = this.buffer._float32Views;
+        let offset = 0;
+        for (let i = 0; i < vertexBuffers.length && offset < totalVertices; i++) {
             const buffer = vertexBuffers[i];
-            for (let j = 0; j < buffer.length; j++) {
-                vertexArray[start] = buffer[j];
-                start++;
-                if (start > totalVerticies) {
-                    done = true;
-                    break;
-                }
+            const remaining = totalVertices - offset;
+            if (buffer.length <= remaining) {
+                vertexArray.set(buffer, offset);
+                offset += buffer.length;
             }
-            if (done)
+            else {
+                vertexArray.set(buffer.subarray(0, remaining), offset);
                 break;
+            }
         }
         const indiciesArray = this.indicieCount > 65535
             ? new Uint32Array(this.indicieCount)
             : new Uint16Array(this.indicieCount);
         const indiceBuffers = this.indices._buffers;
-        start = 0;
-        done = false;
-        for (let i = 0; i < indiceBuffers.length; i++) {
+        offset = 0;
+        for (let i = 0; i < indiceBuffers.length && offset < this.indicieCount; i++) {
             const buffer = indiceBuffers[i];
-            for (let j = 0; j < buffer.length; j++) {
-                indiciesArray[start] = buffer[j];
-                start++;
-                if (start > this.indicieCount) {
-                    done = true;
-                    break;
-                }
+            const remaining = this.indicieCount - offset;
+            if (buffer.length <= remaining) {
+                indiciesArray.set(buffer, offset);
+                offset += buffer.length;
             }
-            if (done)
+            else {
+                indiciesArray.set(buffer.subarray(0, remaining), offset);
                 break;
+            }
         }
-        return {
-            vertexArray,
-            indiciesArray,
-        };
+        return { vertexArray, indiciesArray };
     }
     addVerticies(vertexCount, indicesCount) {
         this.vertexCount += vertexCount;

package/Mesher/Geometry/Proto/ProtoMeshBuffer.d.ts

@@ -1,10 +1,12 @@
 export declare class ProtoVertexBuffer {
     vertexFloatSize: number;
     sectorVertexSize: number;
-    _buffers: Float32Array[];
+    _float32Views: Float32Array[];
+    _uint32Views: Uint32Array[];
     sectorSize: number;
     constructor(vertexFloatSize: number, sectorVertexSize: number, startingSectorSize?: number);
-    currentArray: Float32Array;
+    currentFloat32Array: Float32Array;
+    currentUint32Array: Uint32Array;
     curentIndex: number;
     _index: number;
     setIndex(index: number): void;

package/Mesher/Geometry/Proto/ProtoMeshBuffer.js

@@ -1,28 +1,36 @@
 export class ProtoVertexBuffer {
     vertexFloatSize;
     sectorVertexSize;
-    _buffers = [];
+    _float32Views = [];
+    _uint32Views = [];
     sectorSize = 0;
     constructor(vertexFloatSize, sectorVertexSize, startingSectorSize = 8) {
         this.vertexFloatSize = vertexFloatSize;
         this.sectorVertexSize = sectorVertexSize;
         this.sectorSize = vertexFloatSize * sectorVertexSize;
         for (let i = 0; i < startingSectorSize; i++) {
-            this._buffers.push(new Float32Array(this.sectorSize));
+            const float32Array = new Float32Array(this.sectorSize);
+            this._float32Views[i] = float32Array;
+            this._uint32Views[i] = new Uint32Array(float32Array.buffer);
         }
     }
-    currentArray;
+    currentFloat32Array;
+    currentUint32Array;
     curentIndex = 0;
     _index = 0;
     setIndex(index) {
         this._index = index;
         const bufferIndex = Math.floor((index * this.vertexFloatSize) / this.sectorSize);
-        if (!this._buffers[bufferIndex])
-            this._buffers[bufferIndex] = new Float32Array(this.sectorSize);
+        if (!this._float32Views[bufferIndex]) {
+            const float32Array = new Float32Array(this.sectorSize);
+            this._float32Views[bufferIndex] = float32Array;
+            this._uint32Views[bufferIndex] = new Uint32Array(float32Array.buffer);
+        }
         this.curentIndex =
             (index * this.vertexFloatSize - bufferIndex * this.sectorSize) /
                 this.vertexFloatSize;
-        this.currentArray = this._buffers[bufferIndex];
+        this.currentFloat32Array = this._float32Views[bufferIndex];
+        this.currentUint32Array = this._uint32Views[bufferIndex];
     }
 }
 export class ProtoIndiceBuffer {

package/Mesher/Geometry/Shapes/Box.js

@@ -1,5 +1,4 @@
 import { Quad } from "../Primitives";
-import { VoxelFaces } from "../../../Math";
 export class Box {
     static Create(points = [
         [0, 0, 0],
@@ -24,37 +23,37 @@ export class Box {
     setPoints(points) {
         const [startX, startY, startZ] = points[0];
         const [endX, endY, endZ] = points[1];
-        this.quads[VoxelFaces.Up].setPositions([
+        this.quads[0 /* VoxelFaces.Up */].setPositions([
             [endX, endY, endZ],
             [startX, endY, endZ],
             [startX, endY, startZ],
             [endX, endY, startZ],
         ]);
-        this.quads[VoxelFaces.Down].setPositions([
+        this.quads[1 /* VoxelFaces.Down */].setPositions([
             [startX, startY, endZ],
             [endX, startY, endZ],
             [endX, startY, startZ],
             [startX, startY, startZ],
         ]);
-        this.quads[VoxelFaces.North].setPositions([
+        this.quads[2 /* VoxelFaces.North */].setPositions([
             [startX, endY, endZ],
             [endX, endY, endZ],
             [endX, startY, endZ],
             [startX, startY, endZ],
         ]);
-        this.quads[VoxelFaces.South].setPositions([
+        this.quads[3 /* VoxelFaces.South */].setPositions([
             [endX, endY, startZ],
             [startX, endY, startZ],
             [startX, startY, startZ],
             [endX, startY, startZ],
         ]);
-        this.quads[VoxelFaces.East].setPositions([
+        this.quads[4 /* VoxelFaces.East */].setPositions([
             [endX, endY, endZ],
             [endX, endY, startZ],
             [endX, startY, startZ],
             [endX, startY, endZ],
         ]);
-        this.quads[VoxelFaces.West].setPositions([
+        this.quads[5 /* VoxelFaces.West */].setPositions([
             [startX, endY, startZ],
             [startX, endY, endZ],
             [startX, startY, endZ],

package/Mesher/Geometry/Transform/TransformBox.js

@@ -1,4 +1,3 @@
-import { QuadVerticies } from "../Geometry.types";
 import { AMath, Vector3Like } from "@amodx/math";
 import { VoxelFacesArray } from "../../../Math";
 export function TransformBox(box, transform) {
@@ -7,10 +6,10 @@ export function TransformBox(box, transform) {
     for (const face of VoxelFacesArray) {
         const quad = box.quads[face];
         const vertices = [
-            quad.positions.vertices[QuadVerticies.TopRight],
-            quad.positions.vertices[QuadVerticies.TopLeft],
-            quad.positions.vertices[QuadVerticies.BottomLeft],
-            quad.positions.vertices[QuadVerticies.BottomRight],
+            quad.positions.vertices[0 /* QuadVerticies.TopRight */],
+            quad.positions.vertices[1 /* QuadVerticies.TopLeft */],
+            quad.positions.vertices[2 /* QuadVerticies.BottomLeft */],
+            quad.positions.vertices[3 /* QuadVerticies.BottomRight */],
         ];
         for (const vertex of vertices) {
             const key = `${vertex.x},${vertex.y},${vertex.z}`;
@@ -128,10 +127,10 @@ export function TransformBox(box, transform) {
     for (const face of VoxelFacesArray) {
         const quad = box.quads[face];
         const originalVertices = [
-            quad.positions.vertices[QuadVerticies.TopRight],
-            quad.positions.vertices[QuadVerticies.TopLeft],
-            quad.positions.vertices[QuadVerticies.BottomLeft],
-            quad.positions.vertices[QuadVerticies.BottomRight],
+            quad.positions.vertices[0 /* QuadVerticies.TopRight */],
+            quad.positions.vertices[1 /* QuadVerticies.TopLeft */],
+            quad.positions.vertices[2 /* QuadVerticies.BottomLeft */],
+            quad.positions.vertices[3 /* QuadVerticies.BottomRight */],
         ];
         const transformedVertices = originalVertices.map((vertex) => {
             const key = `${vertex.x},${vertex.y},${vertex.z}`;

package/Mesher/Geometry/Transform/TransformQuad.js

@@ -1,11 +1,10 @@
-import { QuadVerticies } from "../Geometry.types";
 import { Quad } from "../Primitives";
 import { AMath, Vector3Like } from "@amodx/math";
 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] };
+    const p1 = { ...quad.positions.vertices[0 /* QuadVerticies.TopRight */] };
+    const p2 = { ...quad.positions.vertices[1 /* QuadVerticies.TopLeft */] };
+    const p3 = { ...quad.positions.vertices[2 /* QuadVerticies.BottomLeft */] };
+    const p4 = { ...quad.positions.vertices[3 /* QuadVerticies.BottomRight */] };
     // Create an array of vertices
     const vertices = [p1, p2, p3, p4];
     // Compute the centroid of the quad

package/Mesher/Geometry/Transform/TransformTriangle.js

@@ -1,10 +1,9 @@
-import { TriangleVerticies } from "../Geometry.types";
 import { AMath, Vector3Like } from "@amodx/math";
 import { Triangle } from "../Primitives/Triangle";
 export function TransformTriangle(quad, transform) {
-    const p1 = { ...quad.positions.vertices[TriangleVerticies.One] };
-    const p2 = { ...quad.positions.vertices[TriangleVerticies.Two] };
-    const p3 = { ...quad.positions.vertices[TriangleVerticies.Three] };
+    const p1 = { ...quad.positions.vertices[0 /* TriangleVerticies.One */] };
+    const p2 = { ...quad.positions.vertices[1 /* TriangleVerticies.Two */] };
+    const p3 = { ...quad.positions.vertices[2 /* TriangleVerticies.Three */] };
     // Create an array of vertices
     const vertices = [p1, p2, p3];
     // Compute the centroid of the quad

package/Mesher/InitMesher.js

@@ -1,13 +1,8 @@
 import { RenderedMaterials } from "./Voxels/Models/RenderedMaterials";
-import { VoxelModelConstructorRegister } from "./Voxels/Models/VoxelModelConstructorRegister.js";
+import { VoxelGeometryConstructorRegister } from "./Voxels/Models/VoxelGeometryConstructorRegister.js";
 import { LiquidGeometryNode } from "./Voxels/Models/Nodes/Custom/Liquid/LiquidGeometryNode.js";
-import { VoxelConstructor } from "./Voxels/Models/VoxelConstructor.js";
-import { VoxelLUT } from "../Voxels/Data/VoxelLUT";
 export default function () {
-    RenderedMaterials.register(VoxelLUT.material._palette);
-    VoxelModelConstructorRegister.registerCustomNode("liquid", LiquidGeometryNode);
-    VoxelModelConstructorRegister.init();
-    for (const voxel of VoxelLUT.voxelIds._palette) {
-        VoxelModelConstructorRegister.registerVoxel(new VoxelConstructor(voxel, RenderedMaterials.meshersMap.get(VoxelLUT.material.getStringId(VoxelLUT.materialMap[VoxelLUT.voxelIds.getNumberId(voxel)]))));
-    }
+    RenderedMaterials.init();
+    VoxelGeometryConstructorRegister.registerCustomNode("liquid", LiquidGeometryNode);
+    VoxelGeometryConstructorRegister.init();
 }

package/Mesher/Items/Geometry/ItemGeometryBuilder.js

@@ -1,4 +1,3 @@
-import { QuadVerticies } from "../../Geometry/Geometry.types";
 import { ItemMeshVertexConstants } from "./ItemMeshVertexStructCursor";
 export function addItemTriangle(builder, tri) {
     if (!builder.mesh)
@@ -18,11 +17,11 @@ export function addItemTriangle(builder, tri) {
     while (sides--) {
         const baseIndex = builder.mesh.vertexCount;
         builder.mesh.buffer.setIndex(baseIndex);
-        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, topRightPos, topRightNor, tri.uvs.vertices[QuadVerticies.TopRight], texture);
+        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentFloat32Array, origin, topRightPos, topRightNor, tri.uvs.vertices[0 /* QuadVerticies.TopRight */], texture);
         builder.mesh.buffer.setIndex(baseIndex + 1);
-        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, topLeftPos, topLeftNor, tri.uvs.vertices[QuadVerticies.TopLeft], texture);
+        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentFloat32Array, origin, topLeftPos, topLeftNor, tri.uvs.vertices[1 /* QuadVerticies.TopLeft */], texture);
         builder.mesh.buffer.setIndex(baseIndex + 2);
-        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, bottomLeftPos, bottomLeftNor, tri.uvs.vertices[QuadVerticies.BottomLeft], texture);
+        addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentFloat32Array, origin, bottomLeftPos, bottomLeftNor, tri.uvs.vertices[2 /* QuadVerticies.BottomLeft */], texture);
         builder.mesh.addVerticies(3, 3);
     }
     if (!tri.doubleSided) {
@@ -67,13 +66,13 @@ export function addItemQuad(builder, quad) {
     let indIndex = builder.mesh.indicieCount;
     const baseIndex = builder.mesh.vertexCount;
     builder.mesh.buffer.setIndex(baseIndex);
-    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, topRightPos, topRightNor, quad.uvs.vertices[QuadVerticies.TopRight], texture);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentFloat32Array, origin, topRightPos, topRightNor, quad.uvs.vertices[0 /* QuadVerticies.TopRight */], texture);
     builder.mesh.buffer.setIndex(baseIndex + 1);
-    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, topLeftPos, topLeftNor, quad.uvs.vertices[QuadVerticies.TopLeft], texture);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentFloat32Array, origin, topLeftPos, topLeftNor, quad.uvs.vertices[1 /* QuadVerticies.TopLeft */], texture);
     builder.mesh.buffer.setIndex(baseIndex + 2);
-    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, bottomLeftPos, bottomLeftNor, quad.uvs.vertices[QuadVerticies.BottomLeft], texture);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentFloat32Array, origin, bottomLeftPos, bottomLeftNor, quad.uvs.vertices[2 /* QuadVerticies.BottomLeft */], texture);
     builder.mesh.buffer.setIndex(baseIndex + 3);
-    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentArray, origin, bottomRightPos, bottomRightNor, quad.uvs.vertices[QuadVerticies.BottomRight], texture);
+    addVertex(builder.mesh.buffer.curentIndex, builder.mesh.buffer.currentFloat32Array, origin, bottomRightPos, bottomRightNor, quad.uvs.vertices[3 /* QuadVerticies.BottomRight */], texture);
     if (!quad.doubleSided) {
         let index = baseIndex;
         indices.setIndex(indIndex).currentArray[indices.curentIndex] = index;