@divinevoxel/vlox 0.0.79 → 0.0.81

package/Voxels/Functions/BuildLUTs.js

@@ -4,6 +4,7 @@ import { VoxelSchemas } from "../State/VoxelSchemas";
 import { EngineStats } from "../../Stats/EngineStats";
 import { BuildGeomeetryLUT } from "./Geometry/BuildGeometryLUT";
 import { ReltionalStateBuilder } from "../State/Reltional/ReltionalStateBuilder";
+import { EngineSettings } from "../../Settings/EngineSettings";
 function recurse(index, current, result, valuePairs) {
     if (index === valuePairs.length) {
         result.push(current.join(","));
@@ -22,10 +23,17 @@ function getAllCombinations(valuePairs) {
     return result;
 }
 function buildScehmas(voxels, models) {
+    const totalModelStates = new Map();
+    const totalModelRelationalStates = new Map();
+    VoxelLUT.models.register("dve_air");
+    VoxelLUT.modelsIndex[0] = 0;
+    VoxelLUT.modelStateMaps[0] = new Map([[0, 0]]);
+    VoxelLUT.modelRelationalStateMaps[0] = new Map([[0, 0]]);
+    VoxelLUT.voxelModMaps[0] = new Map([[0, 0]]);
+    VoxelLUT.voxelRelationalModMaps[0] = new Map([[0, 0]]);
     //build state schemas
     for (const model of models) {
         VoxelLUT.models.register(model.id);
-        //build state schema
         const schemaNodes = [];
         for (const schemaNode of model.stateSchema) {
             const node = {
@@ -40,6 +48,7 @@ function buildScehmas(voxels, models) {
         }
         const stateSchema = new BinarySchema(schemaNodes);
         VoxelSchemas.state.set(model.id, stateSchema);
+        totalModelStates.set(model.id, stateSchema.totalStates());
         //build reltional state schema
         const reltionalSchemaNodes = [];
         let bitIndex = 0;
@@ -54,7 +63,8 @@ function buildScehmas(voxels, models) {
             reltionalSchemaNodes.push(node);
         }
         const reltionalStateSchema = new BinarySchema(reltionalSchemaNodes);
-        VoxelSchemas.reltioanlState.set(model.id, reltionalStateSchema);
+        VoxelSchemas.relationalState.set(model.id, reltionalStateSchema);
+        totalModelRelationalStates.set(model.id, stateSchema.totalStates());
         const reltionalStateBuilder = new ReltionalStateBuilder(reltionalStateSchema, model.relationsSchema);
         VoxelSchemas.reltionalStateBuilder.set(model.id, reltionalStateBuilder);
     }
@@ -62,8 +72,10 @@ function buildScehmas(voxels, models) {
     for (const voxel of voxels) {
         const modelData = voxel.properties["dve_model_data"];
         const trueVoxelId = VoxelLUT.voxelIds.register(voxel.id);
+        VoxelLUT.voxelIdToNameMap.set(voxel.id, voxel.name || voxel.id);
+        VoxelLUT.voxelNametoIdMap.set(voxel.name || voxel.id, voxel.id);
         VoxelLUT.materialMap[trueVoxelId] = VoxelLUT.material.getNumberId(voxel.properties["dve_rendered_material"] || "dve_solid");
-        VoxelLUT.substanceMap[trueVoxelId] = VoxelLUT.material.getNumberId(voxel.properties["dve_substance"] || "dve_solid");
+        VoxelLUT.substanceMap[trueVoxelId] = VoxelLUT.substance.getNumberId(voxel.properties["dve_substance"] || "dve_solid");
         if (!modelData)
             continue;
         VoxelLUT.modelsIndex[trueVoxelId] = VoxelLUT.models.getNumberId(modelData.id);
@@ -84,6 +96,9 @@ function buildScehmas(voxels, models) {
         }
         const stateSchema = new BinarySchema(schemaNodes);
         VoxelSchemas.mod.set(voxel.id, stateSchema);
+        VoxelLUT.totalVoxelIds +=
+            (totalModelStates.get(modelData.id) || 1) *
+                (stateSchema.totalStates() || 1);
         //build reltional mod schema
         const reltionalSchemaNodes = [];
         if (modelData.modRelationSchema) {
@@ -100,13 +115,29 @@ function buildScehmas(voxels, models) {
             }
         }
         const reltionalStateSchema = new BinarySchema(reltionalSchemaNodes);
-        VoxelSchemas.reltioanlMod.set(voxel.id, reltionalStateSchema);
+        VoxelSchemas.relationalMod.set(voxel.id, reltionalStateSchema);
+        VoxelLUT.totalRelationalVoxelIds +=
+            (totalModelRelationalStates.get(modelData.id) || 1) *
+                (reltionalStateSchema.totalStates() || 1);
         const reltionalModBuilder = new ReltionalStateBuilder(reltionalStateSchema, modelData.modRelationSchema || []);
         VoxelSchemas.reltionalModBuilder.set(voxel.id, reltionalModBuilder);
     }
+    VoxelSchemas.buildMaps();
+}
+function getUint16Buffer(size) {
+    if (EngineSettings.settings.memoryAndCPU.useSharedMemory)
+        return new SharedArrayBuffer(size * 2);
+    return new ArrayBuffer(size * 2);
 }
 function buildStatePalette(voxels, models) {
     const modelStateArray = new Map();
+    VoxelLUT.totalMods = new Uint16Array(getUint16Buffer(VoxelLUT.voxelIds.size));
+    VoxelLUT.totalStates = new Uint16Array(getUint16Buffer(VoxelLUT.voxelIds.size));
+    VoxelLUT.voxelIdToTrueId = new Uint16Array(getUint16Buffer(VoxelLUT.totalVoxelIds));
+    VoxelLUT.voxelIdToState = new Uint16Array(getUint16Buffer(VoxelLUT.totalVoxelIds));
+    VoxelLUT.voxelIdToMod = new Uint16Array(getUint16Buffer(VoxelLUT.totalVoxelIds));
+    VoxelLUT.voxelRecordStartIndex = new Uint16Array(getUint16Buffer(VoxelLUT.voxelIds.size));
+    VoxelLUT.voxelRecord = new Uint16Array(getUint16Buffer(VoxelLUT.totalVoxelIds));
     for (const model of models) {
         const schema = VoxelSchemas.state.get(model.id);
         const valuePairs = [];
@@ -125,10 +156,15 @@ function buildStatePalette(voxels, models) {
             statePalette.push(value);
         }
         modelStateArray.set(model.id, statePalette);
+        const stateMap = new Map();
+        for (let i = 0; i < statePalette.length; i++) {
+            stateMap.set(statePalette[i], i);
+        }
+        const modelId = VoxelLUT.models.getNumberId(model.id);
+        VoxelLUT.modelStateMaps[modelId] = stateMap;
     }
-    const finalPalette = [[0, 0, 0]];
-    const finalPaletteRecord = [[[0]]];
     let voxelIdCount = 1;
+    let voxelRecordStateIndex = 0;
     for (const voxel of voxels) {
         const modelData = voxel.properties["dve_model_data"];
         if (!modelData)
@@ -157,32 +193,41 @@ function buildStatePalette(voxels, models) {
             modPalette.push(0);
         }
         const voxelId = VoxelLUT.voxelIds.getNumberId(voxel.id);
+        const modMap = new Map();
+        for (let i = 0; i < modPalette.length; i++) {
+            modMap.set(modPalette[i], i);
+        }
+        VoxelLUT.voxelModMaps[voxelId] = modMap;
         const statePalette = modelStateArray.get(modelData.id);
         VoxelLUT.totalStates[voxelId] = statePalette.length;
         VoxelLUT.totalMods[voxelId] = modPalette.length;
-        finalPaletteRecord[voxelId] = new Array(modPalette.length).fill(-1);
+        VoxelLUT.voxelRecordStartIndex[voxelId] = voxelRecordStateIndex;
         for (let modIndex = 0; modIndex < modPalette.length; modIndex++) {
-            finalPaletteRecord[voxelId][modPalette[modIndex]] = new Array(statePalette.length).fill(-1);
             for (let stateIndex = 0; stateIndex < statePalette.length; stateIndex++) {
-                finalPalette[voxelIdCount] = [
-                    voxelId,
-                    statePalette[stateIndex],
-                    modPalette[modIndex],
-                ];
-                finalPaletteRecord[voxelId][modPalette[modIndex]][statePalette[stateIndex]] = voxelIdCount;
-                VoxelLUT.voxelIdToModelState[voxelIdCount] = statePalette[stateIndex];
+                VoxelLUT.voxelIdToTrueId[voxelIdCount] = voxelId;
+                VoxelLUT.voxelIdToState[voxelIdCount] = statePalette[stateIndex];
+                VoxelLUT.voxelIdToMod[voxelIdCount] = modPalette[modIndex];
+                VoxelLUT.voxelRecord[voxelRecordStateIndex +
+                    VoxelLUT.getStateIndex(stateIndex, modIndex, statePalette.length)] = voxelIdCount;
                 voxelIdCount++;
             }
         }
+        voxelRecordStateIndex +=
+            (modPalette.length || 1) * (statePalette.length || 1);
     }
-    EngineStats.palette.paletteSize = finalPalette.length;
-    VoxelLUT.voxels = finalPalette;
-    VoxelLUT.voxelRecord = finalPaletteRecord;
+    EngineStats.palette.paletteSize = VoxelLUT.totalVoxelIds;
 }
 function buildReltionalStatePalette(voxels, models) {
     const modelStateArray = new Map();
+    VoxelLUT.totalReltionalMods = new Uint16Array(getUint16Buffer(VoxelLUT.voxelIds.size));
+    VoxelLUT.totalReltionalStates = new Uint16Array(getUint16Buffer(VoxelLUT.voxelIds.size));
+    VoxelLUT.relationalVoxelIdToTrueId = new Uint16Array(getUint16Buffer(VoxelLUT.totalVoxelIds));
+    VoxelLUT.relationalVoxelIdToState = new Uint16Array(getUint16Buffer(VoxelLUT.totalVoxelIds));
+    VoxelLUT.relationalVoxelIdToMod = new Uint16Array(getUint16Buffer(VoxelLUT.totalVoxelIds));
+    VoxelLUT.relationalVoxelRecordStartIndex = new Uint16Array(getUint16Buffer(VoxelLUT.voxelIds.size));
+    VoxelLUT.relationalVoxelRecord = new Uint16Array(getUint16Buffer(VoxelLUT.totalVoxelIds));
     for (const model of models) {
-        const schema = VoxelSchemas.reltioanlState.get(model.id);
+        const schema = VoxelSchemas.relationalState.get(model.id);
         const valuePairs = [];
         for (const node of schema.nodes) {
             valuePairs.push([node.name, ["false", "true"]]);
@@ -194,15 +239,20 @@ function buildReltionalStatePalette(voxels, models) {
             statePalette.push(value);
         }
         modelStateArray.set(model.id, statePalette);
+        const stateMap = new Map();
+        for (let i = 0; i < statePalette.length; i++) {
+            stateMap.set(statePalette[i], i);
+        }
+        const modelId = VoxelLUT.models.getNumberId(model.id);
+        VoxelLUT.modelRelationalStateMaps[modelId] = stateMap;
     }
-    const finalPalette = [[0, 0, 0]];
-    const finalPaletteRecord = [[[0]]];
     let voxelIdCount = 1;
+    let voxelRecordStateIndex = 0;
     for (const voxel of voxels) {
         const modelData = voxel.properties["dve_model_data"];
         if (!modelData)
             continue;
-        const schema = VoxelSchemas.reltioanlMod.get(voxel.id);
+        const schema = VoxelSchemas.relationalMod.get(voxel.id);
         const valuePairs = [];
         if (schema) {
             for (const node of schema.nodes) {
@@ -221,26 +271,30 @@ function buildReltionalStatePalette(voxels, models) {
             modPalette.push(0);
         }
         const voxelId = VoxelLUT.voxelIds.getNumberId(voxel.id);
+        const modMap = new Map();
+        for (let i = 0; i < modPalette.length; i++) {
+            modMap.set(modPalette[i], i);
+        }
+        VoxelLUT.voxelRelationalModMaps[voxelId] = modMap;
         const statePalette = modelStateArray.get(modelData.id);
         VoxelLUT.totalReltionalStates[voxelId] = statePalette.length;
         VoxelLUT.totalReltionalMods[voxelId] = modPalette.length;
-        finalPaletteRecord[voxelId] = new Array(modPalette.length).fill(-1);
+        VoxelLUT.relationalVoxelRecordStartIndex[voxelId] = voxelRecordStateIndex;
         for (let modIndex = 0; modIndex < modPalette.length; modIndex++) {
-            finalPaletteRecord[voxelId][modPalette[modIndex]] = new Array(statePalette.length).fill(-1);
             for (let stateIndex = 0; stateIndex < statePalette.length; stateIndex++) {
-                finalPalette[voxelIdCount] = [
-                    voxelId,
-                    statePalette[stateIndex],
-                    modPalette[modIndex],
-                ];
-                finalPaletteRecord[voxelId][modPalette[modIndex]][statePalette[stateIndex]] = voxelIdCount;
+                VoxelLUT.relationalVoxelIdToTrueId[voxelIdCount] = voxelId;
+                VoxelLUT.relationalVoxelIdToState[voxelIdCount] =
+                    statePalette[stateIndex];
+                VoxelLUT.relationalVoxelIdToMod[voxelIdCount] = modPalette[modIndex];
+                VoxelLUT.relationalVoxelRecord[voxelRecordStateIndex +
+                    VoxelLUT.getStateIndex(stateIndex, modIndex, statePalette.length)] = voxelIdCount;
                 voxelIdCount++;
             }
         }
+        voxelRecordStateIndex +=
+            (modPalette.length || 1) * (statePalette.length || 1);
     }
-    EngineStats.palette.reltionalPaletteSize = finalPalette.length;
-    VoxelLUT.reltioanlVoxels = finalPalette;
-    VoxelLUT.reltionalVoxelRecord = finalPaletteRecord;
+    EngineStats.palette.reltionalPaletteSize = VoxelLUT.totalRelationalVoxelIds;
 }
 export function BuildLUTs(materials, substances, voxels, geometry, models) {
     for (const material of materials) {
@@ -252,6 +306,10 @@ export function BuildLUTs(materials, substances, voxels, geometry, models) {
     buildScehmas(voxels, models);
     buildStatePalette(voxels, models);
     buildReltionalStatePalette(voxels, models);
+    VoxelLUT.totalCombinedIds =
+        VoxelLUT.totalVoxelIds * VoxelLUT.totalRelationalVoxelIds;
+    VoxelLUT.geometryIndex = new Uint16Array(getUint16Buffer(VoxelLUT.totalCombinedIds));
+    VoxelLUT.geometryInputsIndex = new Uint16Array(getUint16Buffer(VoxelLUT.totalCombinedIds));
     const { finalModelStateMap, finalModelConditionalMap, finalVoxelStateInputMap, finalVoxelConditionalInputMap, } = BuildGeomeetryLUT(voxels, geometry, models);
     for (const voxel of voxels) {
         const voxelModelData = voxel.properties["dve_model_data"];
@@ -261,9 +319,9 @@ export function BuildLUTs(materials, substances, voxels, geometry, models) {
         const modelStateMap = finalModelStateMap.get(voxelModelData.id);
         const modelConditonalMap = finalModelConditionalMap.get(voxelModelData.id);
         const stateSchema = VoxelSchemas.state.get(voxelModelData.id);
-        const reltionalStateSchema = VoxelSchemas.reltioanlState.get(voxelModelData.id);
+        const reltionalStateSchema = VoxelSchemas.relationalState.get(voxelModelData.id);
         const modSchema = VoxelSchemas.mod.get(voxel.id);
-        const reltionalModSchema = VoxelSchemas.reltioanlMod.get(voxel.id);
+        const reltionalModSchema = VoxelSchemas.relationalMod.get(voxel.id);
         const inputs = finalVoxelStateInputMap.get(voxel.id);
         const conditonalInputs = finalVoxelConditionalInputMap.get(voxel.id);
         for (const modKey in voxelModelData.inputs) {
@@ -282,22 +340,18 @@ export function BuildLUTs(materials, substances, voxels, geometry, models) {
                     : 0;
                 const voxelId = VoxelLUT.getVoxelId(trueVoxelId, stateValue, modValue);
                 const reltionalVoxelId = VoxelLUT.getReltionalVoxelId(trueVoxelId, reltionalStateValue, reltionalModValue);
-                VoxelLUT.geometryIndex[voxelId] ??= [];
-                VoxelLUT.geometryInputsIndex[voxelId] ??= [];
                 const totalReltionalStates = reltionalStateSchema
                     ? Math.pow(2, reltionalStateSchema.nodes.length)
                     : 0;
                 if (!totalReltionalStates) {
-                    VoxelLUT.geometryIndex[voxelId][reltionalVoxelId] =
-                        modelStateMap[stateKey];
-                    VoxelLUT.geometryInputsIndex[voxelId][reltionalVoxelId] =
-                        inputs[modKey][stateKey];
+                    VoxelLUT.geometryIndex[VoxelLUT.getStateIndex(voxelId, reltionalVoxelId, VoxelLUT.totalVoxelIds)] = modelStateMap[stateKey];
+                    VoxelLUT.geometryInputsIndex[VoxelLUT.getStateIndex(voxelId, reltionalVoxelId, VoxelLUT.totalVoxelIds)] = inputs[modKey][stateKey];
                 }
                 else {
                     const baseReltionalVoxelId = VoxelLUT.getReltionalVoxelId(trueVoxelId, 0, 0);
                     for (let i = baseReltionalVoxelId; i < baseReltionalVoxelId + totalReltionalStates; i++) {
-                        VoxelLUT.geometryIndex[voxelId][i] = modelStateMap[stateKey];
-                        VoxelLUT.geometryInputsIndex[voxelId][i] = inputs[modKey][stateKey];
+                        VoxelLUT.geometryIndex[VoxelLUT.getStateIndex(voxelId, i, VoxelLUT.totalVoxelIds)] = modelStateMap[stateKey];
+                        VoxelLUT.geometryInputsIndex[VoxelLUT.getStateIndex(voxelId, i, VoxelLUT.totalVoxelIds)] = inputs[modKey][stateKey];
                     }
                 }
             }
@@ -350,8 +404,9 @@ export function BuildLUTs(materials, substances, voxels, geometry, models) {
                     }
                 }
             }
-            VoxelLUT.conditionalGeometryIndex[trueVoxelId] ??= [];
-            VoxelLUT.conditionalGeometryIndex[trueVoxelId].push([
+            const modelId = VoxelLUT.models.getNumberId(voxelModelData.id);
+            VoxelLUT.conditionalGeometryIndex[modelId] ??= [];
+            VoxelLUT.conditionalGeometryIndex[modelId].push([
                 modelConditonalMap[stateKey],
                 stateValue,
                 enabledArray,

package/Voxels/Functions/Geometry/CalcFunctions.js

@@ -1,4 +1,3 @@
-import { VoxelFaces } from "../../../Math";
 import { QuadVerticiesArray, } from "../../../Mesher/Geometry/Geometry.types";
 import { Matrix2x2Like, Vec2ArrayLike, AMath, } from "@amodx/math";
 function getInterpolationWeights(x, y, flip = false) {
@@ -14,29 +13,29 @@ export function getVertexWeights(face, x, y, z) {
     let flip = false;
     let u, v;
     switch (face) {
-        case VoxelFaces.Up:
+        case 0 /* VoxelFaces.Up */:
             u = x;
             v = z;
             break;
-        case VoxelFaces.Down:
+        case 1 /* VoxelFaces.Down */:
             u = x;
             v = z;
             flip = true;
             break;
-        case VoxelFaces.North:
+        case 2 /* VoxelFaces.North */:
             u = x;
             v = y;
             flip = true;
             break;
-        case VoxelFaces.South:
+        case 3 /* VoxelFaces.South */:
             u = x;
             v = y;
             break;
-        case VoxelFaces.East:
+        case 4 /* VoxelFaces.East */:
             u = z;
             v = y;
             break;
-        case VoxelFaces.West:
+        case 5 /* VoxelFaces.West */:
             u = z;
             v = y;
             flip = true;

package/Voxels/Functions/Geometry/Compile/BuildCompiled.d.ts

@@ -1,4 +1,4 @@
-import { VoxelGeometryLinkData } from "../../..//Models/VoxelModel.types";
+import { VoxelGeometryLinkData } from "../../../Models/VoxelModel.types";
 import { VoxelGeometryData } from "../../../Geometry/VoxelGeometry.types";
 import { CompiledGeometryNodes } from "../../../../Mesher/Voxels/Models/Nodes/Types/GeometryNode.types";
 export declare function BuildCompiled(geoLink: VoxelGeometryLinkData, geometry: VoxelGeometryData): CompiledGeometryNodes[];

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

@@ -1,4 +1,4 @@
-import { VoxelModelData } from "../../..//Models/VoxelModel.types";
+import { VoxelModelData } from "../../../Models/VoxelModel.types";
 import { VoxelModelInputs } from "../GeometryLUT.types";
 import { VoxelBoxGeometryNode, VoxelGeometryData } from "../../../Geometry/VoxelGeometry.types";
 import { VoxelGeometryTransform } from "../../../../Mesher/Geometry/Geometry.types";

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

@@ -1,4 +1,4 @@
-import { VoxelModelData } from "../../..//Models/VoxelModel.types";
+import { VoxelModelData } from "../../../Models/VoxelModel.types";
 import { VoxelModelInputs } from "../GeometryLUT.types";
 import { VoxelCustomGeometryNode, VoxelGeometryData } from "../../../Geometry/VoxelGeometry.types";
 import { VoxelGeometryTransform } from "../../../../Mesher/Geometry/Geometry.types";

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

@@ -1,4 +1,4 @@
-import { VoxelModelData } from "../../..//Models/VoxelModel.types";
+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";

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

@@ -1,4 +1,4 @@
-import { VoxelModelData } from "../../..//Models/VoxelModel.types";
+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";

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

@@ -93,6 +93,9 @@ export function BuildTriangleInputs(args, transform, data, tri, model, geometry)
             }
         }
     }
+    else if (Array.isArray(tri.uv)) {
+        uvs = tri.uv;
+    }
     inputs[ArgIndexes.UVs] = uvs;
     /**@TODO updae the tri uvs if it is rotated or transformed */
     if (inputs[ArgIndexes.Rotation]) {

package/Voxels/Indexes/VoxelIndex.js

@@ -115,7 +115,9 @@ export class VoxelIndex {
     }
     getStateFromRawData(data) {
         const [id, light, secondary] = data;
-        const [trueId, state, mod] = VoxelLUT.voxels[id];
+        const trueId = VoxelLUT.voxelIdToTrueId[id];
+        const state = VoxelLUT.voxelIdToState[id];
+        const mod = VoxelLUT.voxelIdToMod[id];
         const conatiner = this.states.get(VoxelLUT.voxelIds.getStringId(trueId));
         if (!conatiner)
             return false;

package/Voxels/InitVoxelData.js

@@ -1,4 +1,4 @@
-import { candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, candlesModel, carpetGeometry, carpetModel, chainGeometry, chainModel, fence, fenceEastWest, fenceNorthsouth, fencePost, leverGeometry, leverModel, } from "./Models/Defaults/Examples";
+import { candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, candlesModel, carpetGeometry, carpetModel, chainGeometry, chainModel, fence, fenceEastWest, fenceNorthsouth, fencePost, leverGeometry, leverModel, diamondGeometry, diamondModel } from "./Models/Defaults/Examples";
 import { cube, halfDownCube, eighthCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, halfSouthCube, halfWestCube, } from "./Models/Defaults/CubeVoxelGeometry";
 import { orientedCube, pillarCube, simpleCube, simpleNoCulledCube, simpleHalfCube, simpleTransparentCube, fullTextureCube, } from "./Models/Defaults/CubeVoxelModels";
 import { diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, thinPanel, } from "./Models/Defaults/PanelVoxelGeometry";
@@ -36,6 +36,7 @@ const geometry = [
     liquidGeometry,
     ...leverGeometry,
     ...farmGeometry,
+    diamondGeometry
 ];
 const models = [
     simpleCube,
@@ -56,6 +57,7 @@ const models = [
     fence,
     liquidModel,
     ...farmModels,
+    diamondModel
 ];
 export function InitVoxelData(data) {
     const lightData = new VoxelLightData();

package/Voxels/Interaction/Functions/PickVoxel.js

@@ -2,7 +2,6 @@ import { Vector3Like } from "@amodx/math";
 import { VoxelPickResult } from "../VoxelPickResult";
 import { closestUnitNormal, closestVoxelFace, } from "../../../Math/UtilFunctions";
 import { BoundingBox } from "@amodx/math/Geometry/Bounds/BoundingBox";
-const epsilon = 1e-5;
 const bounds = new BoundingBox();
 export default function PickVoxel(cursor, rayStart, rayDirection, rayLength) {
     const rayDir = Vector3Like.Create(...rayDirection);
@@ -11,10 +10,9 @@ export default function PickVoxel(cursor, rayStart, rayDirection, rayLength) {
         ? cursor.volumePosition
         : Vector3Like.Create();
     bounds.setMinMax(Vector3Like.Add(cursor.volumeBounds.min, offset), Vector3Like.Add(cursor.volumeBounds.max, offset));
-    const safeDirection = Vector3Like.Create(Math.abs(rayDir.x) < epsilon ? epsilon : rayDir.x, Math.abs(rayDir.y) < epsilon ? epsilon : rayDir.y, Math.abs(rayDir.z) < epsilon ? epsilon : rayDir.z);
-    const invDir = Vector3Like.Divide(Vector3Like.Create(1, 1, 1), safeDirection);
+    const invDir = Vector3Like.Divide(Vector3Like.Create(1, 1, 1), rayDir);
     const tDelta = Vector3Like.Create(Math.abs(invDir.x), Math.abs(invDir.y), Math.abs(invDir.z));
-    const tEnter = bounds.rayIntersection(rayOrigin, safeDirection);
+    const tEnter = bounds.rayIntersection(rayOrigin, rayDir);
     if (!isFinite(tEnter)) {
         return null;
     }
@@ -66,7 +64,7 @@ export default function PickVoxel(cursor, rayStart, rayDirection, rayLength) {
             normal.y = 0;
             normal.z = -step.z;
         }
-        if (traveled - tEnter > maxDist) {
+        if (traveled > maxDist) {
             break;
         }
     }

package/Voxels/Interaction/Functions/PickVoxelWorld.js

@@ -3,7 +3,6 @@ import PickVoxel from "./PickVoxel";
 import { WorldSpaces } from "../../../World/WorldSpaces";
 import { WorldRegister } from "../../../World/WorldRegister";
 import { SectorCursor } from "../../../World/Cursor/SectorCursor";
-const epsilon = 1e-5;
 /**# PickVoxelWorld
  * Will pick the voxel world and make sure each sector is available before picking it.
  *
@@ -11,16 +10,15 @@ const epsilon = 1e-5;
  */
 export default async function PickVoxelWorld(cursor, rayStart, rayDirection, rayLength) {
     let t = 0;
-    const d = 8;
+    const d = 4;
     const rayDir = Vector3Like.Create(...rayDirection);
     const rayPosition = Vector3Like.Create();
     const visited = new Set();
     const sectorCursor = new SectorCursor();
-    const safeDirection = Vector3Like.Create(Math.abs(rayDir.x) < epsilon ? epsilon : rayDir.x, Math.abs(rayDir.y) < epsilon ? epsilon : rayDir.y, Math.abs(rayDir.z) < epsilon ? epsilon : rayDir.z);
     while (t < rayLength) {
-        rayPosition.x = rayStart[0] + t * safeDirection.x;
-        rayPosition.y = rayStart[1] + t * safeDirection.y;
-        rayPosition.z = rayStart[2] + t * safeDirection.z;
+        rayPosition.x = rayStart[0] + t * rayDir.x;
+        rayPosition.y = rayStart[1] + t * rayDir.y;
+        rayPosition.z = rayStart[2] + t * rayDir.z;
         t += d;
         const { x, y, z } = WorldSpaces.sector.transformPosition(rayPosition);
         if (!WorldSpaces.world.inBounds(x, y, z))

package/Voxels/Models/Defaults/Examples.d.ts

@@ -17,3 +17,5 @@ export declare const leverGeometryBase: VoxelGeometryData;
 export declare const leverGeometryDown: VoxelGeometryData;
 export declare const leverGeometry: VoxelGeometryData[];
 export declare const leverModel: VoxelModelData;
+export declare const diamondGeometry: VoxelGeometryData;
+export declare const diamondModel: VoxelModelData;

package/Voxels/Models/Defaults/Examples.js

@@ -796,7 +796,7 @@ export const candlesGeometry4 = {
                 [9, 3, 7],
                 [7, 3, 9],
             ],
-            uv: [14, 14, 1, 1],
+            uv: [14, 14, 16, 16],
             texture: "@candleTexture",
             doubleSided: true,
         },
@@ -808,7 +808,7 @@ export const candlesGeometry4 = {
                 [7, 3, 7],
                 [9, 3, 9],
             ],
-            uv: [14, 14, 1, 1],
+            uv: [14, 14, 16, 16],
             texture: "@candleTexture",
             doubleSided: true,
         },
@@ -2073,3 +2073,152 @@ export const leverModel = {
         ],
     },
 };
+export const diamondGeometry = {
+    id: "dve_diamond",
+    doNotBuildRules: true,
+    arguments: {
+        texture: {
+            type: "texture",
+        },
+    },
+    nodes: [
+        //top
+        {
+            type: "triangle",
+            points: [
+                [0.5, 0.5, 0],
+                [0.5, 1, 0.5],
+                [0, 0.5, 0.5],
+            ],
+            texture: "@texture",
+            uv: [
+                [0.5, 0.5],
+                [0.5, 1],
+                [0, 0.5],
+            ],
+        },
+        {
+            type: "triangle",
+            points: [
+                [1, 0.5, 0.5],
+                [0.5, 1, 0.5],
+                [0.5, 0.5, 0],
+            ],
+            texture: "@texture",
+            uv: [
+                [1, 0.5],
+                [0.5, 1],
+                [0.5, 0.5],
+            ],
+        },
+        {
+            type: "triangle",
+            points: [
+                [0.5, 0.5, 1],
+                [0.5, 1, 0.5],
+                [1, 0.5, 0.5],
+            ],
+            texture: "@texture",
+            uv: [
+                [0.5, 0.5],
+                [1, 0.5],
+                [0.5, 1],
+            ],
+        },
+        {
+            type: "triangle",
+            points: [
+                [0, 0.5, 0.5],
+                [0.5, 1, 0.5],
+                [0.5, 0.5, 1],
+            ],
+            texture: "@texture",
+            uv: [
+                [0, 0.5],
+                [0.5, 1],
+                [0.5, 0.5],
+            ],
+        },
+        //bottom
+        {
+            type: "triangle",
+            points: [
+                [0, 0.5, 0.5],
+                [0.5, 0, 0.5],
+                [0.5, 0.5, 0],
+            ],
+            texture: "@texture",
+            uv: [
+                [0, 0.5],
+                [0.5, 1],
+                [0.5, 0.5],
+            ],
+        },
+        {
+            type: "triangle",
+            points: [
+                [0.5, 0.5, 0],
+                [0.5, 0, 0.5],
+                [1, 0.5, 0.5],
+            ],
+            texture: "@texture",
+            uv: [
+                [0.5, 0.5],
+                [0.5, 1],
+                [1, 0.5],
+            ],
+        },
+        {
+            type: "triangle",
+            points: [
+                [1, 0.5, 0.5],
+                [0.5, 0, 0.5],
+                [0.5, 0.5, 1],
+            ],
+            texture: "@texture",
+            uv: [
+                [0.5, 1],
+                [1, 0.5],
+                [0.5, 0.5],
+            ],
+        },
+        {
+            type: "triangle",
+            points: [
+                [0.5, 0.5, 1],
+                [0.5, 0, 0.5],
+                [0, 0.5, 0.5],
+            ],
+            texture: "@texture",
+            uv: [
+                [0.5, 0.5],
+                [0.5, 1],
+                [0, 0.5],
+            ],
+        },
+    ],
+};
+export const diamondModel = {
+    id: "dve_diamond",
+    relationsSchema: [],
+    stateSchema: [],
+    arguments: {
+        texture: {
+            type: "texture",
+        },
+    },
+    conditonalNodes: {},
+    properties: {
+        dve_placing_strategy: "*",
+    },
+    stateNodes: {
+        "*": [
+            {
+                geometryId: "dve_diamond",
+                inputs: {
+                    texture: "@texture",
+                },
+            },
+        ],
+    },
+};

package/Voxels/State/Reltional/ReltionalStateBuilder.js

@@ -22,6 +22,8 @@ export class ReltionalStateBuilder {
         }
     }
     buildState() {
+        if (!this.nodes.size)
+            return 0;
         this.binarySchema.startEncoding(0);
         for (const [nodeId, conditions] of this.nodes) {
             let value = 1;