@divinevoxel/vlox 0.0.72 → 0.0.74

package/Contexts/Base/Remote/InitDataSync.js

@@ -5,6 +5,7 @@ import { SchemaRegister } from "../../../Voxels/State/SchemaRegister";
 import { VoxelTagStates } from "../../../Voxels/Data/VoxelTagStates";
 import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
 import { VoxelTagsRegister } from "../../../Voxels/Data/VoxelTagsRegister";
+import { VoxelLogicRegister } from "../../../Voxels/Logic/VoxelLogicRegister";
 export default function InitDataSync(props) {
     Threads.registerTask("sync-data", (data) => {
         EngineSettings.syncSettings(data.settings);
@@ -23,6 +24,9 @@ export default function InitDataSync(props) {
             SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
         }
         VoxelTagStates.load(modelData.tagState);
+        for (const id in data.voxels.data.logic) {
+            VoxelLogicRegister.register(id, data.voxels.data.logic[id]);
+        }
         props.onSync(data);
     });
 }

package/Contexts/Base/Remote/InitWorldDataSync.js

@@ -3,7 +3,7 @@ import { WorldDataSyncIds } from "../../../World/Types/WorldDataSyncIds.js";
 import { WorldRegister } from "../../../World/WorldRegister.js";
 export default function () {
     Threads.registerTask(WorldDataSyncIds.SyncDimension, (data) => {
-        WorldRegister.dimensions.add(data.id);
+        WorldRegister.dimensions.add(data.index, data.id);
     });
     Threads.registerTask(WorldDataSyncIds.UnSyncDimension, (data) => {
         //  register.dimensions.re(data.id);

package/Contexts/Render/DivineVoxelEngineRender.d.ts

@@ -19,11 +19,12 @@ export declare class DivineVoxelEngineRender {
     settings: {
         enviorment: "node" | "browser";
         settings: EngineSettingsData;
+        version: string;
         readonly doSunPropagation: boolean;
         readonly doRGBPropagation: boolean;
         readonly doLight: boolean;
         readonly doFlow: boolean;
-        readonly isClient: boolean;
+        readonly doPower: boolean;
         getSettings(): EngineSettingsData;
         syncSettings(data: EngineSettingsData): void;
         getSettingsCopy(): any;

package/Contexts/World/DivineVoxelEngineWorld.d.ts

@@ -11,11 +11,12 @@ export declare class DivineVoxelEngineWorld {
     settings: {
         enviorment: "node" | "browser";
         settings: import("../../Settings/EngineSettings.types.js").EngineSettingsData;
+        version: string;
         readonly doSunPropagation: boolean;
         readonly doRGBPropagation: boolean;
         readonly doLight: boolean;
         readonly doFlow: boolean;
-        readonly isClient: boolean;
+        readonly doPower: boolean;
         getSettings(): import("../../Settings/EngineSettings.types.js").EngineSettingsData;
         syncSettings(data: import("../../Settings/EngineSettings.types.js").EngineSettingsData): void;
         getSettingsCopy(): any;

package/Init/StartConstructor.js

@@ -3,6 +3,7 @@ import { DivineVoxelEngineConstructor } from "../Contexts/Constructor/DivineVoxe
 import { Threads } from "@amodx/threads";
 import { Environment } from "../Util/Environment";
 import { WorldRegister } from "../World/WorldRegister";
+import InitLogicTasks from "../Tasks/Logic/InitTasks";
 import InitUpdateTasks from "../Tasks/Update/InitTasks";
 import InitPropagationTasks from "../Tasks/Propagation/InitTasks";
 import InitMesherTasks from "../Mesher/InitTask";
@@ -42,12 +43,15 @@ export async function StartContrusctor(data = {}) {
     InitWorldDataSync();
     InitPropagationTasks();
     InitMesherTasks(DVEC.threads.parent);
+    InitLogicTasks();
     InitUpdateTasks({
         onDone(tasks, origin) {
-            origin.runTask("build-queue", [
-                tasks.origin[0],
-                tasks.bounds.getSections(),
-            ]);
+            tasks.bounds.markSectionsAsDirty();
+            /*
+                  origin.runTask("build-queue", [
+                    tasks.origin[0],
+                    tasks.bounds.getSections(),
+                  ]); */
         },
     });
     InitWorldGenerationTasks();

package/Init/StartWorld.d.ts

@@ -1,5 +1,5 @@
 import { DivineVoxelEngineWorld } from "../Contexts/World/DivineVoxelEngineWorld";
-import { WorldStorageInterface } from "World/Storage/WorldStorage.interface";
+import { WorldStorageInterface } from "World/Types/WorldStorage.interface";
 type StartWorldProps = {
     worldStorage?: WorldStorageInterface;
 };

package/Math/index.d.ts

@@ -1,8 +1,12 @@
 export * from "./VoxelFaces.js";
 export * from "./VoxelFaces.js";
 export type LocationData = [
-    dimensionId: string,
+    /**Index for the dimension */
+    dimensionIndex: number,
+    /**x position */
     x: number,
+    /**y position */
     y: number,
+    /**z position */
     z: number
 ];

package/Mesher/Functions/CompactVoxelMesh.d.ts

@@ -1,3 +1,3 @@
 import { CompactMeshData } from "../Types/Mesher.types";
-import { VoxelMesherDataTool } from "Mesher/Tools/VoxelMesherDataTool";
-export declare function CompactVoxelMesh(tools: VoxelMesherDataTool[], transfers?: any[]): CompactMeshData;
+import { VoxelModelBuilder } from "Mesher/Models/VoxelModelBuilder";
+export declare function CompactVoxelMesh(tools: VoxelModelBuilder[], transfers?: any[]): CompactMeshData;

package/Mesher/Functions/CompactVoxelMesh.js

@@ -1,4 +1,4 @@
-import { VoxelMeshVertexStructCursor } from "../Tools/VoxelMeshVertexStructCursor";
+import { VoxelMeshVertexStructCursor } from "../Geomtry/VoxelMeshVertexStructCursor";
 const structCursor = new VoxelMeshVertexStructCursor();
 /*
 function MakeWebGPUMesh(tool: VoxelMesherDataTool): CompactMeshData {

package/Mesher/Functions/CompactVoxelSectionMesh.d.ts

@@ -0,0 +1,4 @@
+import { SetSectionMeshTask } from "../Types/Mesher.types";
+import { VoxelModelBuilder } from "../Models/VoxelModelBuilder";
+import { LocationData } from "../../Math";
+export declare function CompactVoxelSectionMesh(location: LocationData, tools: VoxelModelBuilder[], transfers?: any[]): SetSectionMeshTask;

package/Mesher/Functions/CompactVoxelSectionMesh.js

@@ -0,0 +1,112 @@
+import { VoxelMeshVertexStructCursor } from "../Geomtry/VoxelMeshVertexStructCursor";
+import { CompactedSectionVoxelMesh, CompactedMeshData, } from "../Geomtry/CompactedSectionVoxelMesh";
+const meshData = new CompactedMeshData();
+const compactedMesh = new CompactedSectionVoxelMesh();
+/** Utility to ensure a value is aligned to 4 bytes. */
+function align4(value) {
+    return (value + 3) & ~3;
+}
+export function CompactVoxelSectionMesh(location, tools, transfers = []) {
+    // 1) First compute how large the final buffer needs to be (with 4-byte alignment).
+    let headerSize = CompactedSectionVoxelMesh.GetHeaderByteSize(tools.length);
+    // Make the header itself 4-byte aligned
+    headerSize = align4(headerSize);
+    let totalByteCount = headerSize;
+    for (let i = 0; i < tools.length; i++) {
+        const tool = tools[i];
+        // Add the vertex data
+        const vertexByteSize = tool.mesh.vertexCount * VoxelMeshVertexStructCursor.VertexByteSize;
+        totalByteCount += vertexByteSize;
+        // Align after writing vertex data
+        totalByteCount = align4(totalByteCount);
+        // Add the index data
+        const indexByteSize = tool.mesh.indicieCount > 65535
+            ? tool.mesh.indicieCount * 4
+            : tool.mesh.indicieCount * 2;
+        totalByteCount += indexByteSize;
+        // Align after writing index data
+        totalByteCount = align4(totalByteCount);
+    }
+    // 2) Allocate the final buffer
+    const buffer = new ArrayBuffer(totalByteCount);
+    compactedMesh.setData(buffer);
+    compactedMesh.setLocation(...location);
+    compactedMesh.setTotalMeshes(tools.length);
+    // We'll track our position in the buffer here
+    let byteCount = headerSize;
+    for (let i = 0; i < tools.length; i++) {
+        const tool = tools[i];
+        // Fill out the meshData structure
+        meshData.material = tool.id;
+        const minBounds = tool.mesh.minBounds;
+        const maxBounds = tool.mesh.maxBounds;
+        meshData.minBounds[0] = minBounds.x;
+        meshData.minBounds[1] = minBounds.y;
+        meshData.minBounds[2] = minBounds.z;
+        meshData.maxBounds[0] = maxBounds.x;
+        meshData.maxBounds[1] = maxBounds.y;
+        meshData.maxBounds[2] = maxBounds.z;
+        // Vertex info
+        const totalVertFloats = tool.mesh.vertexCount * VoxelMeshVertexStructCursor.VertexFloatSize;
+        const vertexByteCount = totalVertFloats * 4;
+        meshData.vertexIndex[0] = byteCount;
+        meshData.vertexIndex[1] = totalVertFloats;
+        // Now move the pointer
+        byteCount += vertexByteCount;
+        // Align to 4 bytes again before writing indices
+        byteCount = align4(byteCount);
+        // Index info
+        meshData.indiceIndex[0] = byteCount;
+        meshData.indiceIndex[1] = tool.mesh.indicieCount;
+        const indexByteCount = tool.mesh.indicieCount > 65535
+            ? tool.mesh.indicieCount * 4
+            : tool.mesh.indicieCount * 2;
+        byteCount += indexByteCount;
+        // Align to 4 bytes for the next iteration (or final)
+        byteCount = align4(byteCount);
+        // Store the meta info
+        compactedMesh.setMeshData(i, meshData);
+        // Write vertex data
+        const vertexArray = new Float32Array(buffer, meshData.vertexIndex[0], totalVertFloats);
+        const vertexBuffers = tool.mesh.buffer._buffers;
+        let start = 0;
+        let done = false;
+        for (let b = 0; b < vertexBuffers.length; b++) {
+            const buf = vertexBuffers[b];
+            for (let j = 0; j < buf.length; j++) {
+                vertexArray[start] = buf[j];
+                start++;
+                if (start >= totalVertFloats) {
+                    done = true;
+                    break;
+                }
+            }
+            if (done)
+                break;
+        }
+        // Write index data
+        const indicesArray = tool.mesh.indicieCount > 65535
+            ? new Uint32Array(buffer, meshData.indiceIndex[0], tool.mesh.indicieCount)
+            : new Uint16Array(buffer, meshData.indiceIndex[0], tool.mesh.indicieCount);
+        const indiceBuffers = tool.mesh.indices._buffers;
+        start = 0;
+        done = false;
+        for (let b = 0; b < indiceBuffers.length; b++) {
+            const buf = indiceBuffers[b];
+            for (let j = 0; j < buf.length; j++) {
+                indicesArray[start] = buf[j];
+                start++;
+                if (start >= tool.mesh.indicieCount) {
+                    done = true;
+                    break;
+                }
+            }
+            if (done)
+                break;
+        }
+    }
+    // Transfer the ArrayBuffer to your worker if needed
+    transfers.push(buffer);
+    // Return the buffer or the task object as needed
+    return buffer;
+}

package/Mesher/Functions/MeshSection.d.ts

@@ -1,3 +1,3 @@
 import { LocationData } from "../../Math";
-import type { SetSectionMeshTask } from "../../Renderer/Renderer.types.js";
+import type { SetSectionMeshTask } from "../Types/Mesher.types";
 export declare function MeshSection(location: LocationData, transfers?: any[]): SetSectionMeshTask | null;

package/Mesher/Functions/MeshSection.js

@@ -2,14 +2,14 @@
 import { WorldSpaces } from "../../World/WorldSpaces.js";
 //tools
 import { VoxelGeometryBuilderCacheSpace } from "../Models/VoxelGeometryBuilderCacheSpace.js";
-import { CompactVoxelMesh } from "./CompactVoxelMesh.js";
 import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
 import { SectionCursor } from "../../World/Cursor/SectionCursor.js";
 import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
 import { WorldRegister } from "../../World/WorldRegister.js";
-import { VoxelMeshBVHBuilder } from "../Tools/VoxelMeshBVHBuilder";
+import { VoxelMeshBVHBuilder } from "../Geomtry/VoxelMeshBVHBuilder";
 import { Vector3Like } from "@amodx/math";
-import { RenderedMaterials } from "../../Mesher/RenderedMaterials";
+import { RenderedMaterials } from "../Models/RenderedMaterials";
+import { CompactVoxelSectionMesh } from "./CompactVoxelSectionMesh";
 const sectionCursor = new SectionCursor();
 const worldCursor = new WorldCursor();
 let space;
@@ -39,16 +39,19 @@ export function MeshSection(location, transfers = []) {
             y: WorldSpaces.section.bounds.y + padding.y,
             z: WorldSpaces.section.bounds.z + padding.z,
         });
-    const [dimension, cx, cy, cz] = location;
-    const sector = WorldRegister.sectors.get(dimension, cx, cy, cz);
+    const sector = WorldRegister.sectors.getAt(location);
     if (!sector)
         return null;
-    const section = sector.getSection(cy);
+    const section = sector.getSection(location[1], location[2], location[3]);
+    const [cx, cy, cz] = section.getPosition();
     worldCursor.setFocalPoint(...location);
     sectionCursor.setSection(...location);
     let [minY, maxY] = section.getMinMax();
-    if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
+    if (minY == Infinity && maxY == -Infinity) {
+        section.setDisplayDirty(false);
+        section.setInProgress(false);
         return null;
+    }
     space.start(cx - (padding.x - 1), cy - (padding.y - 1), cz - (padding.z - 1));
     bvhTool.reset();
     const effects = {};
@@ -58,17 +61,19 @@ export function MeshSection(location, transfers = []) {
         mesher.bvhTool = bvhTool;
         mesher.effects = effects;
     }
-    const volume = WorldSpaces.section.volumne;
     const slice = WorldSpaces.section.bounds.x * WorldSpaces.section.bounds.z;
-    //const t = performance.now();
-    for (let i = 0; i < volume; i++) {
+    const startY = minY * slice;
+    const endY = (maxY + 1) * slice;
+    for (let i = startY; i < endY; i++) {
         if (!(i % slice)) {
             const y = i / slice;
             if (!section.getHasVoxel(y) && !section.getHasVoxelDirty(y)) {
-                i += slice;
+                i += slice - 1;
                 continue;
             }
         }
+        if (!section.ids[i])
+            continue;
         if (!section.ids[i] || section.getBuried(i))
             continue;
         const voxel = sectionCursor.getVoxelAtIndex(i);
@@ -86,29 +91,29 @@ export function MeshSection(location, transfers = []) {
         }
         section.setBuried(i, !addedVoxel);
     }
-    // console.log(performance.now() - t);
-    const sectionEffects = [];
-    const sections = [location, [], sectionEffects, 0];
     const meshed = [];
     for (let i = 0; i < RenderedMaterials.meshers.length; i++) {
         const mesher = RenderedMaterials.meshers[i];
-        for (const e in mesher.effects) {
-            const float = Float32Array.from(mesher.effects[e]);
-            transfers.push(float.buffer);
-            sectionEffects.push([e, float]);
-        }
         if (!mesher.mesh.vertexCount) {
             mesher.clear();
             mesher.bvhTool = null;
             continue;
         }
+        const { min, max } = mesher.bvhTool.getMeshBounds();
+        mesher.mesh.minBounds.x = min[0];
+        mesher.mesh.minBounds.y = min[1];
+        mesher.mesh.minBounds.z = min[2];
+        mesher.mesh.maxBounds.x = max[0];
+        mesher.mesh.maxBounds.y = max[1];
+        mesher.mesh.maxBounds.z = max[2];
         meshed.push(mesher);
     }
-    const compactMesh = CompactVoxelMesh(meshed, transfers);
-    sections[1] = compactMesh;
+    const compactMesh = CompactVoxelSectionMesh(location, meshed, transfers);
     for (let i = 0; i < meshed.length; i++) {
         meshed[i].clear();
         meshed[i].bvhTool = null;
     }
-    return sections;
+    section.setDisplayDirty(false);
+    section.setInProgress(false);
+    return compactMesh;
 }

package/Mesher/Functions/MeshTexture.d.ts

@@ -1 +1 @@
-export declare function MeshTexture(textureId: number, textureData: number[]): import("../Geomtry/VoxelMesh").VoxelMesh | null;
+export declare function MeshTexture(textureId: number, textureData: number[]): void;

package/Mesher/Functions/MeshTexture.js

@@ -1,4 +1,3 @@
-import { MesherDataTool } from "../Geomtry/Tools/MesherDataTools";
 import { Quad } from "../Geomtry/Primitives/Quad";
 const Quads = {
     north: Quad.Create([
@@ -10,8 +9,8 @@ const Quads = {
         [1, 1, 0],
     ], Quad.FullUVs, false, 0),
 };
-const tool = new MesherDataTool();
-tool.startNewMesh();
+//const tool = new MesherDataTool();
+//tool.startNewMesh();
 //tool.mesh!.attributes.set("uv", [[], 2, BinaryNumberTypes.Float32]);
 //tool.mesh!.attributes.set("textureIndex", [[], 3, BinaryNumberTypes.Float32]);
 export function MeshTexture(textureId, textureData) {
@@ -271,5 +270,5 @@ export function MeshTexture(textureId, textureData) {
     
       const compacted = CompactMesh("dve_node", tool);
      */
-    return tool.mesh;
+    //  return tool.mesh;
 }

package/Mesher/Geomtry/CompactedSectionVoxelMesh.d.ts

@@ -0,0 +1,23 @@
+import { Vec3Array } from "@amodx/math";
+import { LocationData } from "../../Math";
+export declare class CompactedMeshData {
+    material: string;
+    minBounds: Vec3Array;
+    maxBounds: Vec3Array;
+    vertexIndex: [start: number, length: number];
+    indiceIndex: [start: number, length: number];
+    verticies: Float32Array;
+    indices: Uint16Array | 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,144 @@
+import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+export class CompactedMeshData {
+    material = "dve_solid";
+    minBounds = [0, 0, 0];
+    maxBounds = [0, 0, 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 { 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 = VoxelPalettesRegister.material.getStringId(this.data.getUint8(startByte));
+        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 =
+            mesh.indiceIndex[1] > 65535
+                ? new Uint32Array(this.data.buffer, ...mesh.indiceIndex)
+                : new Uint16Array(this.data.buffer, ...mesh.indiceIndex);
+        return mesh;
+    }
+}

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

@@ -1,8 +1,9 @@
 import { QuadVerticies } from "../Geometry.types.js";
 import { Vector3Like, Vector2Like, Vec3Array } from "@amodx/math";
+type QuadDataType<Data> = [Data, Data, Data, Data];
 export declare class QuadVertexData<Data> {
-    vertices: Record<QuadVerticies, Data>;
-    constructor(vertices: Record<QuadVerticies, Data>);
+    vertices: QuadDataType<Data>;
+    constructor(vertices: QuadDataType<Data>);
     getAsArray(): Data[];
     setVertex(vertex: QuadVerticies, value: Data): void;
     getVertex(vertex: QuadVerticies): Data;
@@ -14,8 +15,8 @@ export declare class QuadVertexData<Data> {
     clone(): QuadVertexData<Data>;
 }
 export declare class QuadVec3ArrayVertexData extends QuadVertexData<Vec3Array> {
-    vertices: Record<QuadVerticies, Vec3Array>;
-    constructor(vertices?: Record<QuadVerticies, 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;
@@ -26,8 +27,8 @@ export declare class QuadVec3ArrayVertexData extends QuadVertexData<Vec3Array> {
     clone(): QuadVec3ArrayVertexData;
 }
 export declare class QuadVector3VertexData extends QuadVertexData<Vector3Like> {
-    vertices: Record<QuadVerticies, Vector3Like>;
-    constructor(vertices?: Record<QuadVerticies, Vector3Like>);
+    vertices: QuadDataType<Vector3Like>;
+    constructor(vertices?: QuadDataType<Vector3Like>);
     setFromQuadData(vertexData: QuadVertexData<Vector3Like>): void;
     addToVertex(vertex: QuadVerticies, value: Vector3Like): void;
     subtractFromVertex(vertex: QuadVerticies, value: Vector3Like): void;
@@ -38,8 +39,8 @@ export declare class QuadVector3VertexData extends QuadVertexData<Vector3Like> {
     clone(): QuadVector3VertexData;
 }
 export declare class QuadVector2VertexData extends QuadVertexData<Vector2Like> {
-    vertices: Record<QuadVerticies, Vector2Like>;
-    constructor(vertices?: Record<QuadVerticies, Vector2Like>);
+    vertices: QuadDataType<Vector2Like>;
+    constructor(vertices?: QuadDataType<Vector2Like>);
     setFromQuadData(vertexData: QuadVertexData<Vector3Like>): void;
     addToVertex(vertex: QuadVerticies, value: Vector2Like): void;
     subtractFromVertex(vertex: QuadVerticies, value: Vector2Like): void;
@@ -50,8 +51,8 @@ export declare class QuadVector2VertexData extends QuadVertexData<Vector2Like> {
     clone(): QuadVector2VertexData;
 }
 export declare class QuadScalarVertexData extends QuadVertexData<number> {
-    vertices: Record<QuadVerticies, number>;
-    constructor(vertices?: Record<QuadVerticies, number>);
+    vertices: QuadDataType<number>;
+    constructor(vertices?: QuadDataType<number>);
     setFromQuadData(vertexData: QuadVertexData<number>): void;
     subtractFromVertex(vertex: QuadVerticies, value: number): void;
     addAll(value: number): void;
@@ -64,3 +65,4 @@ export declare class QuadScalarVertexData extends QuadVertexData<number> {
     isAllLessThan(value: number): boolean;
     clone(): QuadScalarVertexData;
 }
+export {};