@divinevoxel/vlox 0.0.78 → 0.0.79

package/Voxels/Functions/Geometry/Inputs/BuildCustomInputs.js

@@ -0,0 +1,41 @@
+import { cleanArgString, isArgString, processTexture } from "./BaseFunctions";
+export function BuildCustomInputs(args, transform, data, custom, model, geometry) {
+    const customArgs = {};
+    for (const inputKey in custom.inputs) {
+        const inputValue = custom.inputs[inputKey];
+        if (isArgString(inputValue) && typeof inputValue == "string") {
+            const geometryArgumentId = cleanArgString(inputValue);
+            if (isArgString(data.modelInputs[geometryArgumentId]) &&
+                typeof inputValue == "string") {
+                const modelArgumentId = cleanArgString(inputValue);
+                const modelArgument = model.arguments[modelArgumentId];
+                const voxelInputValue = data.voxelInputs[modelArgumentId];
+                if (modelArgument.type == "texture") {
+                    if (typeof voxelInputValue == "string") {
+                        customArgs[geometryArgumentId] = processTexture(voxelInputValue);
+                        continue;
+                    }
+                    if (typeof voxelInputValue == "object") {
+                        const textureProcedure = voxelInputValue;
+                        if (typeof textureProcedure.texture == "string") {
+                            textureProcedure.texture = processTexture(textureProcedure.texture);
+                        }
+                        if (textureProcedure.textureRecrod) {
+                            for (const key in textureProcedure.textureRecrod) {
+                                textureProcedure.textureRecrod[key] = processTexture(textureProcedure.textureRecrod[key]);
+                            }
+                        }
+                        customArgs[geometryArgumentId] = textureProcedure;
+                    }
+                }
+                else {
+                    customArgs[geometryArgumentId] = voxelInputValue;
+                }
+            }
+        }
+        else {
+            customArgs[inputKey] = inputValue;
+        }
+    }
+    args.push(customArgs);
+}

package/Voxels/Functions/Geometry/Inputs/BuildQuadInputs.d.ts

@@ -0,0 +1,5 @@
+import { VoxelModelData } from "../../..//Models/VoxelModel.types";
+import { VoxelModelInputs } from "../GeometryLUT.types";
+import { BaseVoxelQuadData, VoxelGeometryData } from "../../../Geometry/VoxelGeometry.types";
+import { VoxelGeometryTransform } from "../../../../Mesher/Geometry/Geometry.types";
+export declare function BuildQuadInputs(args: any[], transform: VoxelGeometryTransform, data: VoxelModelInputs, quad: BaseVoxelQuadData, model: VoxelModelData, geometry: VoxelGeometryData): void;

package/Voxels/Functions/Geometry/Inputs/BuildQuadInputs.js

@@ -0,0 +1,103 @@
+import { QuadVoxelGometryInputs } from "../../../../Mesher/Voxels/Models/Nodes/Types/QuadVoxelGometryNodeTypes";
+import { cleanArgString, isArgString, processTexture } from "./BaseFunctions";
+import { mapQuadUvs } from "../CalcFunctions";
+export function BuildQuadInputs(args, transform, data, quad, model, geometry) {
+    const ArgIndexes = QuadVoxelGometryInputs.ArgIndexes;
+    const inputs = QuadVoxelGometryInputs.CreateArgs();
+    let enabled = quad.enabled || true;
+    inputs[ArgIndexes.Enabled] = enabled;
+    let texture = 0;
+    if (isArgString(quad.texture)) {
+        const geometryInputId = cleanArgString(quad.texture);
+        let modelInput = data.modelInputs[geometryInputId];
+        if (!modelInput) {
+            for (const argKey in data.modelInputs) {
+                const arg = geometry.arguments[argKey];
+                if (!arg)
+                    continue;
+                if (arg.type == "arg-list" && arg.arguments.includes(geometryInputId)) {
+                    modelInput = data.modelInputs[argKey];
+                }
+            }
+        }
+        if (!modelInput)
+            throw new Error(`Could not find input for ${quad.texture} on geometry ${geometry.id} model ${model.id}`);
+        if (typeof modelInput == "string") {
+            const modelInputId = cleanArgString(modelInput);
+            texture = processTexture(data.voxelInputs[modelInputId]);
+        }
+        if (typeof modelInput == "object") {
+            const procedureData = structuredClone(modelInput);
+            if (typeof procedureData.texture == "string" &&
+                isArgString(procedureData.texture)) {
+                procedureData.texture =
+                    data.voxelInputs[cleanArgString(procedureData.texture)];
+            }
+            if (procedureData.textureRecrod) {
+                for (const key in procedureData.textureRecrod) {
+                    const value = procedureData.textureRecrod[key];
+                    if (typeof value == "string" && isArgString(value)) {
+                        procedureData.textureRecrod[key] =
+                            data.voxelInputs[cleanArgString(value)];
+                    }
+                }
+            }
+            texture = processTexture(procedureData);
+        }
+    }
+    inputs[ArgIndexes.Texture] = texture;
+    let rotation = 0;
+    if (isArgString(quad.rotation) && typeof quad.rotation == "string") {
+        const geoInput = cleanArgString(quad.rotation);
+        const modelInput = data.modelInputs[geoInput];
+        if (isArgString(modelInput) && typeof modelInput == "string") {
+            rotation = data.voxelInputs[cleanArgString(modelInput)];
+        }
+        else {
+            rotation = modelInput;
+        }
+    }
+    else {
+        rotation = quad.rotation;
+    }
+    inputs[ArgIndexes.Rotation] = rotation ? rotation : 0;
+    let doubleSided = false;
+    if (isArgString(quad.doubleSided) && typeof quad.doubleSided == "string") {
+        const geoInput = cleanArgString(quad.doubleSided);
+        const modelInput = data.modelInputs[geoInput];
+        if (isArgString(modelInput) && typeof modelInput == "string") {
+            doubleSided = data.voxelInputs[cleanArgString(modelInput)];
+        }
+        else {
+            doubleSided = modelInput;
+        }
+    }
+    else {
+        doubleSided = quad.doubleSided;
+    }
+    inputs[ArgIndexes.DoubleSided] = doubleSided ? doubleSided : false;
+    let quadUVs = [0, 0, 1, 1];
+    if (isArgString(quad.uv) && typeof quad.uv == "string") {
+        const geoInput = cleanArgString(quad.uv);
+        const modelInput = data.modelInputs[geoInput];
+        if (isArgString(modelInput) && typeof modelInput == "string") {
+            quadUVs = data.voxelInputs[cleanArgString(modelInput)];
+        }
+        else {
+            if (!modelInput) {
+                const input = geometry.arguments[geoInput];
+                if (input.type == "uv") {
+                    quadUVs = input.default;
+                }
+            }
+            else {
+                quadUVs = modelInput;
+            }
+        }
+    }
+    else if (Array.isArray(quad.uv)) {
+        quadUVs = quad.uv;
+    }
+    inputs[ArgIndexes.UVs] = mapQuadUvs(quadUVs, inputs[ArgIndexes.Rotation] || 0, transform);
+    args.push(inputs);
+}

package/Voxels/Functions/Geometry/Inputs/BuildTriangleInputs.d.ts

@@ -0,0 +1,5 @@
+import { VoxelModelData } from "../../..//Models/VoxelModel.types";
+import { VoxelModelInputs } from "../GeometryLUT.types";
+import { BaseVoxelTriangleData, VoxelGeometryData } from "../../../Geometry/VoxelGeometry.types";
+import { VoxelGeometryTransform } from "../../../../Mesher/Geometry/Geometry.types";
+export declare function BuildTriangleInputs(args: any[], transform: VoxelGeometryTransform, data: VoxelModelInputs, tri: BaseVoxelTriangleData, model: VoxelModelData, geometry: VoxelGeometryData): void;

package/Voxels/Functions/Geometry/Inputs/BuildTriangleInputs.js

@@ -0,0 +1,101 @@
+import { TriangleVoxelGometryInputs } from "../../../../Mesher/Voxels/Models/Nodes/Types/TriangleVoxelGometryNodeTypes";
+import { cleanArgString, isArgString, processTexture } from "./BaseFunctions";
+export function BuildTriangleInputs(args, transform, data, tri, model, geometry) {
+    const ArgIndexes = TriangleVoxelGometryInputs.ArgIndexes;
+    const inputs = TriangleVoxelGometryInputs.CreateArgs();
+    inputs[ArgIndexes.Enabled] = true;
+    let texture = 0;
+    if (isArgString(tri.texture)) {
+        const geometryInputId = cleanArgString(tri.texture);
+        let modelInput = data.modelInputs[geometryInputId];
+        if (!modelInput) {
+            for (const argKey in data.modelInputs) {
+                const arg = geometry.arguments[argKey];
+                if (!arg)
+                    continue;
+                if (arg.type == "arg-list" && arg.arguments.includes(geometryInputId)) {
+                    modelInput = data.modelInputs[argKey];
+                }
+            }
+        }
+        if (!modelInput)
+            throw new Error(`Could not find input for ${tri.texture} on geometry ${geometry.id} model ${model.id}`);
+        if (typeof modelInput == "string") {
+            const modelInputId = cleanArgString(tri.texture);
+            texture = processTexture(data.voxelInputs[modelInputId]);
+        }
+        if (typeof modelInput == "object") {
+            const procedureData = structuredClone(modelInput);
+            if (typeof procedureData.texture == "string" &&
+                isArgString(procedureData.texture)) {
+                procedureData.texture =
+                    data.voxelInputs[cleanArgString(procedureData.texture)];
+            }
+            if (procedureData.textureRecrod) {
+                for (const key in procedureData.textureRecrod) {
+                    const value = procedureData.textureRecrod[key];
+                    if (typeof value == "string" && isArgString(value)) {
+                        procedureData.textureRecrod[key] =
+                            data.voxelInputs[cleanArgString(value)];
+                    }
+                }
+            }
+            texture = processTexture(procedureData);
+        }
+    }
+    inputs[ArgIndexes.Texture] = texture;
+    let rotation = 0;
+    if (isArgString(tri.rotation) && typeof tri.rotation == "string") {
+        const geoInput = cleanArgString(tri.rotation);
+        const modelInput = data.modelInputs[geoInput];
+        if (isArgString(modelInput) && typeof modelInput == "string") {
+            rotation = data.voxelInputs[cleanArgString(modelInput)];
+        }
+        else {
+            rotation = modelInput;
+        }
+    }
+    else {
+        rotation = tri.rotation;
+    }
+    inputs[ArgIndexes.Rotation] = rotation;
+    let doubleSided = false;
+    if (isArgString(tri.doubleSided) && typeof tri.doubleSided == "string") {
+        const geoInput = cleanArgString(tri.doubleSided);
+        const modelInput = data.modelInputs[geoInput];
+        if (isArgString(modelInput) && typeof modelInput == "string") {
+            doubleSided = data.voxelInputs[cleanArgString(modelInput)];
+        }
+        else {
+            doubleSided = modelInput;
+        }
+    }
+    else {
+        doubleSided = tri.doubleSided;
+    }
+    inputs[ArgIndexes.DoubleSided] = doubleSided;
+    let uvs = inputs[ArgIndexes.UVs];
+    if (isArgString(tri.uv) && typeof tri.uv == "string") {
+        const geoInput = cleanArgString(tri.uv);
+        const modelInput = data.modelInputs[geoInput];
+        if (isArgString(modelInput) && typeof modelInput == "string") {
+            uvs = data.voxelInputs[cleanArgString(modelInput)];
+        }
+        else {
+            if (!modelInput) {
+                const input = geometry.arguments[geoInput];
+                if (input.type == "uv") {
+                    uvs = input.default;
+                }
+            }
+            else {
+                uvs = modelInput;
+            }
+        }
+    }
+    inputs[ArgIndexes.UVs] = uvs;
+    /**@TODO updae the tri uvs if it is rotated or transformed */
+    if (inputs[ArgIndexes.Rotation]) {
+    }
+    args.push(inputs);
+}

package/Voxels/Functions/Geometry/Inputs/BuldInputs.d.ts

@@ -0,0 +1,4 @@
+import { VoxelGeometryLinkData, VoxelModelData } from "../../..//Models/VoxelModel.types";
+import { VoxelModelInputs } from "../GeometryLUT.types";
+import { VoxelGeometryData } from "../../../Geometry/VoxelGeometry.types";
+export declare function BuildInputs(link: VoxelGeometryLinkData, data: VoxelModelInputs, model: VoxelModelData, geometry: VoxelGeometryData): any[];

package/Voxels/Functions/Geometry/Inputs/BuldInputs.js

@@ -0,0 +1,22 @@
+import { BuildQuadInputs } from "./BuildQuadInputs";
+import { BuildBoxInputs } from "./BuildBoxInputs";
+import { BuildTriangleInputs } from "./BuildTriangleInputs";
+import { BuildCustomInputs } from "./BuildCustomInputs";
+export function BuildInputs(link, data, model, geometry) {
+    const args = [];
+    for (const node of geometry.nodes) {
+        if (node.type == "box") {
+            BuildBoxInputs(args, link, data, node, model, geometry);
+        }
+        if (node.type == "quad") {
+            BuildQuadInputs(args, link, data, node, model, geometry);
+        }
+        if (node.type == "triangle") {
+            BuildTriangleInputs(args, link, data, node, model, geometry);
+        }
+        if (node.type == "custom") {
+            BuildCustomInputs(args, link, data, node, model, geometry);
+        }
+    }
+    return args;
+}

package/Voxels/Functions/Geometry/Rules/BuildRules.d.ts

@@ -0,0 +1 @@
+export declare function BuildRules(): void;

package/Voxels/{Models/Rules/Functions → Functions/Geometry/Rules}/BuildRules.js

@@ -1,13 +1,13 @@
-import { VoxelRelativeCubeIndex } from "../../Indexing/VoxelRelativeCubeIndex";
+import { VoxelRelativeCubeIndex } from "../../../Geometry/VoxelRelativeCubeIndex";
 import { Vec3ArrayLike } from "@amodx/math";
-import { VoxelModelRuleBuilderRegister } from "../VoxelModelRuleBuilderRegister";
-import { OcclusionFaceRegister } from "../Classes/OcclusionFaceRegister";
-import { AOOcclusionFaceIndex } from "../../Indexing/AOOcclusionFaceIndex";
-import { CulledOcclusionFaceIndex } from "../../Indexing/CulledOcclusionFaceIndex";
-import { OcclusionQuadFace } from "../Classes/OcclusionQuadFace";
-import { OcclusionTriangleFace } from "../Classes/OcclusionTriangleFace";
+import { OcclusionFaceRegister } from "./OcclusionFaceRegister";
+import { AOOcclusionFaceIndex } from "../../../Geometry/AOOcclusionFaceIndex";
+import { CulledOcclusionFaceIndex } from "../../../Geometry/CulledOcclusionFaceIndex";
+import { OcclusionQuadFace } from "./OcclusionQuadFace";
+import { OcclusionTriangleFace } from "./OcclusionTriangleFace";
 import { EngineSettings } from "../../../../Settings/EngineSettings";
 import { EngineStats } from "../../../../Stats/EngineStats";
+import { GeometryLUT } from "../../../Data/GeometryLUT";
 class OcculsionBox {
     p1;
     p2;
@@ -115,12 +115,13 @@ function doesBoxIntersectFace(quad) {
     }
     return true;
 }
-export function BuildRules(geoPalette) {
+export function BuildRules() {
     const faceCullMap = [];
     const vertexHitMap = [];
     const cubeIndexSize = VoxelRelativeCubeIndex.flatIndex.size;
     const totalFaces = OcclusionFaceRegister.faces.size;
-    const totalAOReusltsSize = totalFaces * 4 * cubeIndexSize * geoPalette.size;
+    const geometryPaletteSize = GeometryLUT.compiledGeometry.length;
+    const totalAOReusltsSize = totalFaces * 4 * cubeIndexSize * geometryPaletteSize;
     const aoIndexBufferSize = Math.ceil(totalAOReusltsSize / 8);
     const aoIndex = new AOOcclusionFaceIndex({
         buffer: EngineSettings.settings.memoryAndCPU.useSharedMemory
@@ -128,7 +129,7 @@ export function BuildRules(geoPalette) {
             : new ArrayBuffer(aoIndexBufferSize),
         totalFaces,
     });
-    const cullIndexResultsSize = totalFaces * cubeIndexSize * geoPalette.size;
+    const cullIndexResultsSize = totalFaces * cubeIndexSize * geometryPaletteSize;
     const cullIndexBufferSize = Math.ceil(cullIndexResultsSize / 8);
     const cullIndex = new CulledOcclusionFaceIndex({
         buffer: EngineSettings.settings.memoryAndCPU.useSharedMemory
@@ -141,7 +142,8 @@ export function BuildRules(geoPalette) {
     const currentTriangleFace = new OcclusionTriangleFace();
     const otherQuadFace = new OcclusionQuadFace();
     const otherTriangleFace = new OcclusionTriangleFace();
-    EngineStats.geomtry.faces = faces.length;
+    EngineStats.geometry.faces = faces.length;
+    const compiledGeometry = GeometryLUT.compiledGeometry;
     for (let faceIndex = 0; faceIndex < faces.length; faceIndex++) {
         const faceData = OcclusionFaceRegister.faceIndex[faceIndex];
         let currentFace;
@@ -157,11 +159,11 @@ export function BuildRules(geoPalette) {
         vertexHitMap[faceIndex] = [];
         const facePoints = currentFace.points;
         const faceNormal = currentFace.normal;
-        for (let gometryId = 0; gometryId < geoPalette.size; gometryId++) {
-            let geomtry = VoxelModelRuleBuilderRegister.geometry.get(geoPalette._palette[gometryId]);
-            if (geomtry.data.ogData.doNotBuildRules !== undefined)
+        for (let geometryId = 0; geometryId < compiledGeometry.length; geometryId++) {
+            const compiled = compiledGeometry[geometryId];
+            if (GeometryLUT.rulelessIndex[geometryId])
                 continue;
-            for (const otherGeo of geomtry.compiled) {
+            for (const otherGeo of compiled) {
                 if (otherGeo.type == "custom" || otherGeo.trueFaceIndex === undefined)
                     continue;
                 const otherFaceData = OcclusionFaceRegister.faceIndex[otherGeo.trueFaceIndex];
@@ -185,7 +187,7 @@ export function BuildRules(geoPalette) {
                             const directionIndex = VoxelRelativeCubeIndex.getIndex(x, y, z);
                             otherQuadFace.setOffset(x, y, z);
                             if (otherFace.doesCoverFace(currentFace)) {
-                                cullIndex.setValue(gometryId, directionIndex, faceIndex, 1);
+                                cullIndex.setValue(geometryId, directionIndex, faceIndex, 1);
                                 if (!faceCullMap[faceIndex].includes(directionIndex)) {
                                     faceCullMap[faceIndex].push(directionIndex);
                                 }
@@ -196,7 +198,7 @@ export function BuildRules(geoPalette) {
                                 updateOcculsionBox(facePoints[v], faceNormal);
                                 vertexHitMap[faceIndex][v] ??= [];
                                 if (doesBoxIntersectFace(otherFace)) {
-                                    aoIndex.setValue(gometryId, directionIndex, faceIndex, v, 1);
+                                    aoIndex.setValue(geometryId, directionIndex, faceIndex, v, 1);
                                     if (!vertexHitMap[faceIndex][v].includes(directionIndex)) {
                                         vertexHitMap[faceIndex][v].push(directionIndex);
                                     }
@@ -208,10 +210,8 @@ export function BuildRules(geoPalette) {
             }
         }
     }
-    return {
-        aoIndex: aoIndex.toJSON(),
-        faceCullIndex: cullIndex.toJSON(),
-        faceCullMap,
-        vertexHitMap,
-    };
+    GeometryLUT.aoIndex = aoIndex;
+    GeometryLUT.faceCullIndex = cullIndex;
+    GeometryLUT.faceCullMap = faceCullMap;
+    GeometryLUT.aoVertexHitMap = vertexHitMap;
 }

package/Voxels/{Models/Rules/Classes → Functions/Geometry/Rules}/OcclusionFaceRegister.d.ts

@@ -1,7 +1,7 @@
 import { Vec3Array } from "@amodx/math";
-import { Quad } from "../../../../Mesher/Geomtry/Primitives/Quad";
+import { Quad } from "../../../../Mesher/Geometry/Primitives/Quad";
 import { StringPalette } from "../../../../Util/StringPalette";
-import { Triangle } from "../../../../Mesher/Geomtry/Primitives/Triangle";
+import { Triangle } from "../../../../Mesher/Geometry/Primitives/Triangle";
 export declare class OcclusionFaceRegister {
     static faces: StringPalette;
     static faceIndex: ([

package/Voxels/{Models/Rules/Classes → Functions/Geometry/Rules}/OcclusionQuadFace.js

@@ -1,5 +1,5 @@
 import { Vec3ArrayLike } from "@amodx/math";
-import { Quad } from "../../../../Mesher/Geomtry/Primitives/Quad";
+import { Quad } from "../../../../Mesher/Geometry/Primitives/Quad";
 import { IOcclusionFace } from "./OcclusionFace";
 export class OcclusionQuadFace extends IOcclusionFace {
     normals;

package/Voxels/{Models/Rules/Classes → Functions/Geometry/Rules}/OcclusionTriangleFace.js

@@ -1,5 +1,5 @@
 import { Vec3ArrayLike } from "@amodx/math";
-import { Triangle } from "../../../../Mesher/Geomtry/Primitives/Triangle";
+import { Triangle } from "../../../../Mesher/Geometry/Primitives/Triangle";
 import { IOcclusionFace } from "./OcclusionFace";
 export class OcclusionTriangleFace extends IOcclusionFace {
     normals;

package/Voxels/{Models/Indexing → Geometry}/AOOcclusionFaceIndex.d.ts

@@ -6,7 +6,7 @@ export declare class AOOcclusionFaceIndex {
     view: Uint8Array;
     readonly totalFaces: number;
     constructor(data: AOOcclusionFaceIndexData);
-    getValue(geomtryId: number, directionIndex: number, faceIndex: number, vertexIndex: number): number;
-    setValue(geomtryId: number, directionIndex: number, faceIndex: number, vertexIndex: number, value?: number): void;
+    getValue(geometryId: number, directionIndex: number, faceIndex: number, vertexIndex: number): number;
+    setValue(geometryId: number, directionIndex: number, faceIndex: number, vertexIndex: number, value?: number): void;
     toJSON(): AOOcclusionFaceIndexData;
 }

package/Voxels/Geometry/AOOcclusionFaceIndex.js

@@ -0,0 +1,28 @@
+import { getBitArrayIndex, setBitArrayIndex, } from "../../Util/Binary/BinaryArrays";
+import { VoxelRelativeCubeIndex } from "./VoxelRelativeCubeIndex";
+const flatIndexSize = VoxelRelativeCubeIndex.flatIndex.size;
+function getIndex(geometryId, directionIndex, faceIndex, totalFaces, vertexIndex) {
+    const start = totalFaces * 4 * flatIndexSize * geometryId +
+        directionIndex * (totalFaces * 4);
+    return start + faceIndex * 4 + vertexIndex;
+}
+export class AOOcclusionFaceIndex {
+    view;
+    totalFaces;
+    constructor(data) {
+        this.view = new Uint8Array(data.buffer);
+        this.totalFaces = data.totalFaces;
+    }
+    getValue(geometryId, directionIndex, faceIndex, vertexIndex) {
+        return getBitArrayIndex(this.view, getIndex(geometryId, directionIndex, faceIndex, this.totalFaces, vertexIndex));
+    }
+    setValue(geometryId, directionIndex, faceIndex, vertexIndex, value = 0) {
+        return setBitArrayIndex(this.view, getIndex(geometryId, directionIndex, faceIndex, this.totalFaces, vertexIndex), value);
+    }
+    toJSON() {
+        return {
+            buffer: this.view.buffer,
+            totalFaces: this.totalFaces,
+        };
+    }
+}

package/Voxels/{Models/Indexing → Geometry}/CulledOcclusionFaceIndex.d.ts

@@ -6,7 +6,7 @@ export declare class CulledOcclusionFaceIndex {
     view: Uint8Array;
     readonly totalFaces: number;
     constructor(data: CulledOcclusionFaceIndexData);
-    getValue(geomtryId: number, directionIndex: number, faceIndex: number): number;
-    setValue(geomtryId: number, directionIndex: number, faceIndex: number, value?: number): void;
+    getValue(geometryId: number, directionIndex: number, faceIndex: number): number;
+    setValue(geometryId: number, directionIndex: number, faceIndex: number, value?: number): void;
     toJSON(): CulledOcclusionFaceIndexData;
 }

package/Voxels/Geometry/CulledOcclusionFaceIndex.js

@@ -0,0 +1,27 @@
+import { getBitArrayIndex, setBitArrayIndex } from "../../Util/Binary/BinaryArrays";
+import { VoxelRelativeCubeIndex } from "./VoxelRelativeCubeIndex";
+const flatIndexSize = VoxelRelativeCubeIndex.flatIndex.size;
+function getIndex(geometryId, directionIndex, faceIndex, totalFaces) {
+    const start = totalFaces * flatIndexSize * geometryId + directionIndex * totalFaces;
+    return start + faceIndex;
+}
+export class CulledOcclusionFaceIndex {
+    view;
+    totalFaces;
+    constructor(data) {
+        this.view = new Uint8Array(data.buffer);
+        this.totalFaces = data.totalFaces;
+    }
+    getValue(geometryId, directionIndex, faceIndex) {
+        return getBitArrayIndex(this.view, getIndex(geometryId, directionIndex, faceIndex, this.totalFaces));
+    }
+    setValue(geometryId, directionIndex, faceIndex, value = 0) {
+        return setBitArrayIndex(this.view, getIndex(geometryId, directionIndex, faceIndex, this.totalFaces), value);
+    }
+    toJSON() {
+        return {
+            buffer: this.view.buffer,
+            totalFaces: this.totalFaces,
+        };
+    }
+}

package/Voxels/Geometry/VoxelGeometry.types.d.ts

@@ -0,0 +1,105 @@
+import { Vec2Array, Vec3Array } from "@amodx/math";
+import { VoxelFaceNames } from "../../Math";
+/**Define a custom geometry node */
+export interface VoxelCustomGeometryNode {
+    type: "custom";
+    id: string;
+    inputs: Record<string, any>;
+}
+export interface VoxelBoxGeometryNode {
+    type: "box";
+    /**Divisor used for transform of this specific node.*/
+    divisor?: Vec3Array;
+    points: [start: Vec3Array, end: Vec3Array];
+    rotation?: Vec3Array;
+    faces: Record<VoxelFaceNames, BaseVoxelQuadData>;
+}
+export interface BaseVoxelQuadData {
+    doubleSided?: boolean | string;
+    enabled?: boolean;
+    /**Id for an input arg for the texture */
+    texture: string;
+    /**UV for the face or id for an input arg. */
+    uv: [x1: number, y1: number, x2: number, y2: number] | string;
+    /**UV rotation or id for an input arg */
+    rotation?: number | string;
+}
+export interface VoxelQuadGeometryNode extends BaseVoxelQuadData {
+    type: "quad";
+    /**Divisor used for transform of this specific node.*/
+    divisor?: Vec3Array;
+    points: [p1: Vec3Array, p2: Vec3Array, p3: Vec3Array, p4: Vec3Array];
+}
+export interface BaseVoxelTriangleData {
+    doubleSided?: boolean;
+    /**Id for the input arg for the texture */
+    texture: string;
+    /**UV for the triangle or id for the input arg. */
+    uv: [v1: Vec2Array, v2: Vec2Array, v3: Vec2Array] | string;
+    /**UV rotation or id for an input arg */
+    rotation?: number | string;
+}
+export interface VoxelTriangleGeometryNode extends BaseVoxelTriangleData {
+    type: "triangle";
+    /**Divisor used for transform of this specific node.*/
+    divisor?: Vec3Array;
+    points: [p1: Vec3Array, p2: Vec3Array, p3: Vec3Array];
+}
+export interface VoxelGeometryTextureArgument {
+    type: "texture";
+}
+/**Creates a way to set multiple arguments to the same thing. What ever value is passed in will be passed to the arguments. */
+export interface VoxelGeometryArgumentAliasList {
+    type: "arg-list";
+    arguments: string[];
+}
+export interface VoxelGeometryBooleanArgument {
+    type: "boolean";
+    default: boolean;
+}
+export interface VoxelGeometryIntArgument {
+    type: "int";
+    default: number;
+}
+export interface VoxelGeometryFloatArgument {
+    type: "float";
+    default: number;
+}
+export interface VoxelGeometryBoxUVArgument {
+    type: "box-uv";
+    default: [x1: number, y1: number, x2: number, y2: number];
+}
+export interface VoxelGeometryUVArgument {
+    type: "uv";
+    default: Vec2Array[];
+}
+export interface VoxelGeometryVector3Argument {
+    type: "vector3";
+    default?: Vec3Array;
+    min?: Vec3Array;
+    max?: Vec3Array;
+}
+export type VoxelGeometryNodes = VoxelCustomGeometryNode | VoxelBoxGeometryNode | VoxelTriangleGeometryNode | VoxelQuadGeometryNode;
+export type CullingProcedureData = {
+    type: "default";
+} | {
+    type: "none";
+} | {
+    type: "transparent";
+};
+export interface VoxelGeometryData {
+    id: string;
+    nodes: VoxelGeometryNodes[];
+    divisor?: Vec3Array;
+    /**
+     * If this is set the voxel geometry will not be included in the
+     * geometry rules and will be fall back to custom inputs.
+     * Ideal for advanced or non cubic models.
+     * */
+    doNotBuildRules?: true;
+    /**
+     * Define the culling procedure for faces
+     */
+    cullingProcedure?: CullingProcedureData;
+    arguments: Record<string, VoxelGeometryTextureArgument | VoxelGeometryBoxUVArgument | VoxelGeometryUVArgument | VoxelGeometryVector3Argument | VoxelGeometryIntArgument | VoxelGeometryBooleanArgument | VoxelGeometryFloatArgument | VoxelGeometryArgumentAliasList>;
+}

package/Voxels/Geometry/VoxelGeometry.types.js

@@ -0,0 +1 @@
+export {};