@divinevoxel/vlox 0.0.78 → 0.0.79

package/Mesher/Voxels/Models/VoxelConstructor.js

@@ -1,74 +1,64 @@
 import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
-import { StateSchema } from "../../../Voxels/State/Schema/StateSchema";
-import { StateTreeReader } from "../../../Voxels/State/StateTreeReader";
-import { VoxelModelEffect } from "./VoxelModelEffect";
-import { CondtionalTreeReader } from "../../../Voxels/State/CondiotnalTreeReader";
+import { VoxelLUT } from "../../../Voxels/Data/VoxelLUT";
+import { GeometryLUT } from "../../../Voxels/Data/GeometryLUT";
 export class VoxelConstructor {
     id;
     builder;
-    data;
     isModel = true;
-    geometries = [];
-    modSchema;
-    modTree;
-    baseInputMap;
-    conditonalInputMap;
-    schema;
-    effects;
-    stateTree;
-    condtioanlShapeStateTree;
-    constructor(id, builder, data, voxleData) {
+    // effects: VoxelModelEffect;
+    constructor(id, builder) {
         this.id = id;
         this.builder = builder;
-        this.data = data;
-        this.baseInputMap = voxleData.baseGeometryInputMap;
-        this.conditonalInputMap = voxleData.condiotnalGeometryInputMap;
-        this.schema = new StateSchema(data.schema);
-        this.stateTree = new StateTreeReader(this.schema, 0, data.stateTree);
-        this.condtioanlShapeStateTree = new CondtionalTreeReader(this.schema, data.condiotnalStatements, data.condiotnalStateTree);
-        this.modSchema = new StateSchema(voxleData.modSchema);
-        this.modTree = new StateTreeReader(this.modSchema, 0, voxleData.modStateTree);
-        this.effects = new VoxelModelEffect(this);
+        //  this.effects = new VoxelModelEffect(this);
     }
     process() {
         let added = false;
         const builder = this.builder;
         const hashed = builder.space.getHash(builder.nVoxel, builder.position.x, builder.position.y, builder.position.z);
-        const treeState = builder.space.stateCache[hashed];
-        const modState = builder.space.modCache[hashed];
-        if (treeState > -1) {
-            const geoLinks = this.data.stateMap[treeState];
-            const geometries = this.data.stateGeometryMap[treeState];
-            const geometriesLength = geoLinks.length;
-            const inputs = this.baseInputMap[modState][treeState];
-            for (let i = 0; i < geometriesLength; i++) {
-                const nodeId = geoLinks[i];
-                const geoInputs = inputs[nodeId];
-                const geomtry = VoxelModelConstructorRegister.geometry[geometries[i]];
-                const nodesLength = geomtry.nodes.length;
-                for (let k = 0; k < nodesLength; k++) {
-                    const geo = geomtry.nodes[k];
-                    geo.builder = this.builder;
-                    const addedGeo = geo.add(geoInputs[k]);
-                    if (addedGeo)
-                        added = true;
-                }
+        const trueVoxelId = builder.voxel.getVoxelId();
+        const voxelId = builder.space.voxelCache[hashed];
+        const reltionalVoxelId = builder.space.reltionalVoxelCache[hashed];
+        const geomtriesIndex = VoxelLUT.getGeometryIndex(voxelId, reltionalVoxelId);
+        const geomtries = GeometryLUT.geometryIndex[geomtriesIndex];
+        const inputsIndex = VoxelLUT.getGeometryInputIndex(voxelId, reltionalVoxelId);
+        const inputs = GeometryLUT.geometryInputsIndex[inputsIndex];
+        const geometriesLength = geomtries.length;
+        for (let i = 0; i < geometriesLength; i++) {
+            const nodeId = geomtries[i];
+            const inputsIndex = inputs[i];
+            const geoInputs = GeometryLUT.geometryInputs[inputsIndex];
+            const geometry = VoxelModelConstructorRegister.geometry[nodeId];
+            const nodesLength = geometry.nodes.length;
+            for (let k = 0; k < nodesLength; k++) {
+                const geo = geometry.nodes[k];
+                geo.builder = this.builder;
+                const addedGeo = geo.add(geoInputs[k]);
+                if (addedGeo)
+                    added = true;
             }
         }
-        const conditonalTreeState = builder.space.conditonalStateCache[hashed];
-        if (conditonalTreeState > -1) {
-            const condiotnalNodes = this.data.condiotnalShapeStateMap[conditonalTreeState];
-            const condiotnalNodesLength = condiotnalNodes.length;
-            for (let c = 0; c < condiotnalNodesLength; c++) {
-                const geometries = condiotnalNodes[c];
-                const geometriesLength = geometries.length;
-                const inputs = this.conditonalInputMap[modState][c];
+        const conditioanlNodes = VoxelLUT.getConditionalGeometryNodes(trueVoxelId);
+        if (conditioanlNodes) {
+            const modelState = VoxelLUT.voxelIdToModelState[voxelId];
+            const reltionalState = builder.space.reltionalStateCache[hashed];
+            const nodesLength = conditioanlNodes.length;
+            for (let i = 0; i < nodesLength; i++) {
+                const [geoId, requiredModelState, requiredModelReltionalState] = conditioanlNodes[i];
+                if (requiredModelState !== modelState ||
+                    !requiredModelReltionalState[reltionalState])
+                    continue;
+                const geomtries = GeometryLUT.geometryIndex[geoId];
+                const inputsIndex = VoxelLUT.getConditionalGeometryInputIndex(geoId, voxelId, reltionalVoxelId);
+                const inputs = GeometryLUT.geometryInputsIndex[inputsIndex];
+                const geometriesLength = geomtries.length;
                 for (let i = 0; i < geometriesLength; i++) {
-                    const geoInputs = inputs[i];
-                    const geomtry = VoxelModelConstructorRegister.geometry[geometries[i]];
-                    const nodesLength = geomtry.nodes.length;
+                    const nodeId = geomtries[i];
+                    const inputsIndex = inputs[i];
+                    const geoInputs = GeometryLUT.geometryInputs[inputsIndex];
+                    const geometry = VoxelModelConstructorRegister.geometry[nodeId];
+                    const nodesLength = geometry.nodes.length;
                     for (let k = 0; k < nodesLength; k++) {
-                        const geo = geomtry.nodes[k];
+                        const geo = geometry.nodes[k];
                         geo.builder = this.builder;
                         const addedGeo = geo.add(geoInputs[k]);
                         if (addedGeo)
@@ -77,7 +67,11 @@ export class VoxelConstructor {
                 }
             }
         }
-        this.effects.addEffects(builder.voxel.getState(), builder.origin, builder.effects);
+        /*     this.effects.addEffects(
+          builder.voxel.getState(),
+          builder.origin,
+          builder.effects
+        ); */
         builder.clearCalculatedData();
         return added;
     }

package/Mesher/Voxels/Models/VoxelGeometryBuilderCacheSpace.d.ts

@@ -5,18 +5,15 @@ export declare class VoxelGeometryBuilderCacheSpace {
     bounds: Vector3Like;
     foundHash: Uint8Array;
     voxelCache: Uint16Array;
-    modCache: Int32Array;
-    stateCache: Int32Array;
-    conditonalStateCache: Int32Array;
+    trueVoxelCache: Uint16Array;
+    reltionalVoxelCache: Uint16Array;
+    reltionalStateCache: Uint16Array;
     noCastAO: Uint8Array;
     offset: Vec3Array;
     voxelCursor: VoxelCursor;
     constructor(bounds: Vector3Like);
     start(x: number, y: number, z: number): void;
     getIndex(x: number, y: number, z: number): number;
-    getConstructor(index: number): import("./VoxelConstructor").VoxelConstructor | null;
-    getGeomtry(index: number): number[] | null;
-    getConditionalGeomtry(index: number): number[][] | null;
     getHash(dataCursor: DataCursorInterface, x: number, y: number, z: number): number;
     private hashState;
 }

package/Mesher/Voxels/Models/VoxelGeometryBuilderCacheSpace.js

@@ -1,13 +1,18 @@
-import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
 import { VoxelCursor } from "../../../Voxels/Cursor/VoxelCursor";
 import { GetYXZOrderArrayIndex } from "../../../Math/Indexing";
+import { VoxelSchemas } from "../../../Voxels/State/VoxelSchemas";
+import { VoxelLUT } from "../../../Voxels/Data/VoxelLUT";
 export class VoxelGeometryBuilderCacheSpace {
     bounds;
     foundHash;
+    //cache of the voxel ids
     voxelCache;
-    modCache;
-    stateCache;
-    conditonalStateCache;
+    //cache of the true voxel ids
+    trueVoxelCache;
+    //cache of the reltional voxel ids
+    reltionalVoxelCache;
+    //cache of the reltional state
+    reltionalStateCache;
     noCastAO;
     offset = [0, 0, 0];
     voxelCursor = new VoxelCursor();
@@ -16,9 +21,9 @@ export class VoxelGeometryBuilderCacheSpace {
         const volume = bounds.x * bounds.y * bounds.z;
         this.foundHash = new Uint8Array(volume);
         this.voxelCache = new Uint16Array(volume);
-        this.modCache = new Int32Array(volume);
-        this.stateCache = new Int32Array(volume);
-        this.conditonalStateCache = new Int32Array(volume);
+        this.trueVoxelCache = new Uint16Array(volume);
+        this.reltionalVoxelCache = new Uint16Array(volume);
+        this.reltionalStateCache = new Uint16Array(volume);
         this.noCastAO = new Uint8Array(volume);
     }
     start(x, y, z) {
@@ -27,29 +32,14 @@ export class VoxelGeometryBuilderCacheSpace {
         this.offset[2] = z;
         this.foundHash.fill(0);
         this.voxelCache.fill(0);
-        this.modCache.fill(-1);
-        this.stateCache.fill(-1);
-        this.conditonalStateCache.fill(-1);
+        this.trueVoxelCache.fill(0);
+        this.reltionalVoxelCache.fill(0);
+        this.reltionalStateCache.fill(0);
         this.noCastAO.fill(0);
     }
     getIndex(x, y, z) {
         return GetYXZOrderArrayIndex(x - this.offset[0], y - this.offset[1], z - this.offset[2], this.bounds.x, this.bounds.y, this.bounds.z);
     }
-    getConstructor(index) {
-        if (this.foundHash[index] < 2)
-            return null;
-        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]];
-    }
-    getGeomtry(index) {
-        if (this.foundHash[index] < 2)
-            return null;
-        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.stateGeometryMap[this.stateCache[index]];
-    }
-    getConditionalGeomtry(index) {
-        if (this.foundHash[index] < 2)
-            return null;
-        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.condiotanlGeometryStatePalette[this.conditonalStateCache[index]];
-    }
     getHash(dataCursor, x, y, z) {
         const hashed = this.getIndex(x, y, z);
         if (this.foundHash[hashed] == 0) {
@@ -67,29 +57,35 @@ export class VoxelGeometryBuilderCacheSpace {
             this.foundHash[index] = 1;
             return;
         }
-        const voxelId = voxel.getVoxelId();
-        const voxelConstructor = VoxelModelConstructorRegister.constructorsPaltte[voxelId];
-        if (!voxelConstructor) {
-            this.foundHash[index] = 1;
-            return;
-        }
+        const trueVoxelId = voxel.getVoxelId();
+        const voxelId = voxel.getId();
+        this.trueVoxelCache[index] = trueVoxelId;
         this.voxelCache[index] = voxelId;
         this.foundHash[index] = 2;
         //no ao
         this.noCastAO[index] = voxel.isLightSource() || voxel.noAO() ? 1 : 0;
-        //state
-        const state = voxelConstructor.stateTree.getState(voxel.getState());
-        this.stateCache[index] = state;
-        //mod
-        const mod = voxelConstructor.modTree.getState(voxel.getMod());
-        this.modCache[index] = mod;
         this.voxelCursor.copy(voxel).process();
-        voxelConstructor.schema.position.x = x;
-        voxelConstructor.schema.position.y = y;
-        voxelConstructor.schema.position.z = z;
-        voxelConstructor.schema.voxel = this.voxelCursor;
-        voxelConstructor.schema.dataCursor = dataCursor;
-        const conditonalState = voxelConstructor.condtioanlShapeStateTree.getState();
-        this.conditonalStateCache[index] = conditonalState;
+        const reltioanlBuilder = VoxelSchemas.reltionalStateBuilder.get(VoxelLUT.models.getStringId(VoxelLUT.modelsIndex[trueVoxelId]));
+        reltioanlBuilder.position.x = x;
+        reltioanlBuilder.position.y = y;
+        reltioanlBuilder.position.z = z;
+        reltioanlBuilder.voxel = this.voxelCursor;
+        reltioanlBuilder.dataCursor = dataCursor;
+        const reltionalState = reltioanlBuilder.buildState();
+        this.reltionalStateCache[index] = reltionalState;
+        const reltioanlModBuilder = VoxelSchemas.reltionalModBuilder.get(VoxelLUT.voxelIds.getStringId(trueVoxelId));
+        let reltionalMod = 0;
+        if (reltioanlModBuilder) {
+            reltioanlModBuilder.position.x = x;
+            reltioanlModBuilder.position.y = y;
+            reltioanlModBuilder.position.z = z;
+            reltioanlModBuilder.voxel = this.voxelCursor;
+            reltioanlModBuilder.dataCursor = dataCursor;
+            reltionalMod = reltioanlModBuilder.buildState();
+        }
+        else {
+            this.reltionalVoxelCache[index] = 0;
+        }
+        this.reltionalVoxelCache[index] = VoxelLUT.getReltionalVoxelId(trueVoxelId, reltionalState, reltionalMod);
     }
 }

package/Mesher/Voxels/Models/VoxelModelBuilder.d.ts

@@ -1,8 +1,8 @@
-import { QuadScalarVertexData } from "../../Geomtry/Primitives/QuadVertexData";
+import { QuadScalarVertexData } from "../../Geometry/Primitives/QuadVertexData";
 import { VoxelFaces } from "../../../Math";
-import { QuadVerticies } from "../../Geomtry/Geometry.types";
-import { ProtoMesh } from "../../Geomtry/Proto/ProtoMesh";
-import { VoxelMeshBVHBuilder } from "../Geomtry/VoxelMeshBVHBuilder";
+import { QuadVerticies } from "../../Geometry/Geometry.types";
+import { ProtoMesh } from "../../Geometry/Proto/ProtoMesh";
+import { VoxelMeshBVHBuilder } from "../Geometry/VoxelMeshBVHBuilder";
 import { Vec3Array, Vector3Like, Vector4Like } from "@amodx/math";
 import { VoxelCursorInterface } from "../../../Voxels/Cursor/VoxelCursor.interface.js";
 import { DataCursorInterface } from "../../../Voxels/Cursor/DataCursor.interface.js";

package/Mesher/Voxels/Models/VoxelModelBuilder.js

@@ -1,12 +1,12 @@
 //tools
 //data
-import { QuadScalarVertexData } from "../../Geomtry/Primitives/QuadVertexData";
+import { QuadScalarVertexData } from "../../Geometry/Primitives/QuadVertexData";
 import { VoxelFaces, VoxelFacesArray } from "../../../Math";
-import { QuadVerticies } from "../../Geomtry/Geometry.types";
+import { QuadVerticies } from "../../Geometry/Geometry.types";
 import calculateFaceData from "./Common/Calc/FaceDataCalc.js";
-import { ProtoMesh } from "../../Geomtry/Proto/ProtoMesh";
+import { ProtoMesh } from "../../Geometry/Proto/ProtoMesh";
 import { Vector3Like, Vector4Like } from "@amodx/math";
-import { VoxelMeshVertexStructCursor } from "../Geomtry/VoxelMeshVertexStructCursor";
+import { VoxelMeshVertexStructCursor } from "../Geometry/VoxelMeshVertexStructCursor";
 class VoxelVars {
     textureIndex = 0;
     overlayTextures = Vector4Like.Create();

package/Mesher/Voxels/Models/VoxelModelConstructorRegister.d.ts

@@ -1,27 +1,14 @@
-import { StringPalette } from "../../../Util/StringPalette";
-import { CompiledVoxelGeometrySyncData, CompiledVoxelModelData } from "../../../Voxels/Models/CompiledVoxelModel.types";
 import { GeoemtryNodeConstructor } from "./Nodes/GeometryNode";
 import { VoxelConstructor } from "./VoxelConstructor";
 import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
-import { AOOcclusionFaceIndex } from "../../../Voxels/Models/Indexing/AOOcclusionFaceIndex";
-import { CulledOcclusionFaceIndex } from "../../../Voxels/Models/Indexing/CulledOcclusionFaceIndex";
 export declare class VoxelModelConstructorRegister {
-    static geometryPalette: StringPalette;
     static geometry: VoxelGeometryConstructor[];
-    static rulesless: boolean[];
-    static aoIndex: AOOcclusionFaceIndex;
-    static faceCullIndex: CulledOcclusionFaceIndex;
-    static vertexHitMap: number[][][];
-    static faceCullMap: number[][];
-    static setGeometryPalette(palette: string[]): void;
-    static modelData: Map<string, CompiledVoxelModelData>;
     static customNodes: Map<string, GeoemtryNodeConstructor<any, any>>;
-    static registerModels(models: CompiledVoxelModelData[]): void;
     static registerCustomNode(id: string, node: GeoemtryNodeConstructor<any, any>): void;
     static getCustomNode(id: string): GeoemtryNodeConstructor<any, any>;
     static constructorsPaltte: VoxelConstructor[];
     static constructors: Map<string, VoxelConstructor>;
     static getConstructor(id: string): VoxelConstructor;
     static registerVoxel(voxel: VoxelConstructor | VoxelConstructor[]): void;
-    static registerGeometry(geometries: CompiledVoxelGeometrySyncData[]): void;
+    static init(): void;
 }

package/Mesher/Voxels/Models/VoxelModelConstructorRegister.js

@@ -1,22 +1,9 @@
-import { StringPalette } from "../../../Util/StringPalette";
 import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
-import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelLUT } from "../../../Voxels/Data/VoxelLUT";
+import { GeometryLUT } from "../../../Voxels/Data/GeometryLUT";
 export class VoxelModelConstructorRegister {
-    static geometryPalette;
     static geometry = [];
-    static rulesless = [];
-    static aoIndex;
-    static faceCullIndex;
-    static vertexHitMap;
-    static faceCullMap;
-    static setGeometryPalette(palette) {
-        this.geometryPalette = new StringPalette(palette);
-    }
-    static modelData = new Map();
     static customNodes = new Map();
-    static registerModels(models) {
-        models.forEach((_) => this.modelData.set(_.id, _));
-    }
     static registerCustomNode(id, node) {
         this.customNodes.set(id, node);
     }
@@ -35,17 +22,16 @@ export class VoxelModelConstructorRegister {
         if (Array.isArray(voxel)) {
             for (const vox of voxel) {
                 this.constructors.set(vox.id, vox);
-                this.constructorsPaltte[VoxelPalettesRegister.voxelIds.getNumberId(vox.id)] = vox;
+                this.constructorsPaltte[VoxelLUT.voxelIds.getNumberId(vox.id)] = vox;
             }
             return;
         }
-        this.constructorsPaltte[VoxelPalettesRegister.voxelIds.getNumberId(voxel.id)] = voxel;
+        this.constructorsPaltte[VoxelLUT.voxelIds.getNumberId(voxel.id)] = voxel;
         this.constructors.set(voxel.id, voxel);
     }
-    static registerGeometry(geometries) {
-        for (const geometry of geometries) {
-            const paletteId = this.geometryPalette.getNumberId(geometry.id);
-            this.geometry[paletteId] = new VoxelGeometryConstructor(paletteId, geometry);
+    static init() {
+        for (let i = 0; i < GeometryLUT.compiledGeometry.length; i++) {
+            this.geometry[i] = new VoxelGeometryConstructor(i);
         }
     }
 }

package/Mesher/Voxels/Models/VoxelModelEffect.d.ts

@@ -1,13 +1,7 @@
 import { VoxelConstructor } from "./VoxelConstructor";
-import { StateTreeReader } from "../../../Voxels/State/StateTreeReader";
-import { Vec3Array, Vector3Like } from "@amodx/math";
+import { Vector3Like } from "@amodx/math";
 export declare class VoxelModelEffect {
     model: VoxelConstructor;
-    effects: {
-        id: string;
-        reader: StateTreeReader;
-        palette: Vec3Array[][];
-    }[];
     constructor(model: VoxelConstructor);
     addEffects(state: number, origin: Vector3Like, effects: Record<string, number[]>): void;
 }

package/Mesher/Voxels/Models/VoxelModelEffect.js

@@ -1,43 +1,40 @@
-import { StateTreeReader } from "../../../Voxels/State/StateTreeReader";
 export class VoxelModelEffect {
     model;
-    effects = [];
+    /*   effects: { id: string; reader: StateTreeReader; palette: Vec3Array[][] }[] =
+        []; */
     constructor(model) {
         this.model = model;
-        for (const effect of model.data.effects) {
+        /*   for (const effect of model.data.effects) {
             if (effect.type == "fx-points") {
-                this.effects.push({
-                    id: effect.effectId,
-                    reader: new StateTreeReader(model.schema, 0, effect.tree),
-                    palette: effect.treePalette,
-                });
+              this.effects.push({
+                id: effect.effectId,
+                reader: new StateTreeReader(model.schema, 0, effect.tree),
+                palette: effect.treePalette,
+              });
             }
-        }
+          } */
     }
     addEffects(state, origin, effects) {
-        if (!this.effects.length)
-            return;
-        for (let i = 0; i < this.effects.length; i++) {
-            const e = this.effects[i];
-            let array = effects[e.id];
-            if (!array) {
+        /*     if (!this.effects.length) return;
+            for (let i = 0; i < this.effects.length; i++) {
+              const e = this.effects[i];
+              let array = effects[e.id];
+              if (!array) {
                 array = [];
                 effects[e.id] = array;
-            }
-            const effectState = e.reader.getState(state);
-            if (effectState == -1)
-                continue;
-            const v = e.palette[effectState];
-            if (!v)
-                continue;
-            let start = array.length;
-            for (let i = 0; i < v.length; i++) {
+              }
+              const effectState = e.reader.getState(state);
+              if (effectState == -1) continue;
+              const v = e.palette[effectState];
+              if (!v) continue;
+              let start = array.length;
+              for (let i = 0; i < v.length; i++) {
                 const point = v[i];
                 array[start] = origin.x + point[0];
                 array[start + 1] = origin.y + point[1];
                 array[start + 2] = origin.z + point[2];
                 start += 3;
-            }
-        }
+              }
+            } */
     }
 }

package/Renderer/Classes/DVESectionMeshes.d.ts

@@ -1,5 +1,5 @@
 import { SectionMesh } from "./SectionMesh";
-import { CompactedSectionVoxelMesh } from "../../Mesher/Voxels/Geomtry/CompactedSectionVoxelMesh";
+import { CompactedSectionVoxelMesh } from "../../Mesher/Voxels/Geometry/CompactedSectionVoxelMesh";
 export declare abstract class DVESectionMeshes {
     abstract updateVertexData(section: SectionMesh, data: CompactedSectionVoxelMesh): SectionMesh;
     abstract returnMesh(mesh: any): void;

package/Renderer/MeshManager.js

@@ -1,5 +1,5 @@
 import { MeshRegister } from "./MeshRegister.js";
-import { CompactedSectionVoxelMesh } from "../Mesher/Voxels/Geomtry/CompactedSectionVoxelMesh";
+import { CompactedSectionVoxelMesh } from "../Mesher/Voxels/Geometry/CompactedSectionVoxelMesh";
 const added = new Set();
 const compacted = new CompactedSectionVoxelMesh();
 const location = [0, 0, 0, 0];

package/Settings/EngineSettings.types.d.ts

@@ -1,4 +1,4 @@
-import { Vector3Like } from "@amodx/math";
+import { Vec2Array, Vector3Like } from "@amodx/math";
 export interface MesherSettingsData {
 }
 export declare class MesherSettingsData {
@@ -16,6 +16,7 @@ export declare class RenderSettingsData {
     /**Renderer will not dispose of buffers to keep them renderering. */
     cpuBound: boolean;
     bufferMode: "single" | "multi";
+    textureSize: Vec2Array;
 }
 export interface UpdatingSettings {
 }

package/Settings/EngineSettings.types.js

@@ -13,6 +13,7 @@ export class RenderSettingsData {
     cpuBound = false;
     /* Single buffer mode will store vertex and indicies in single big buffer. While multi will store a buffer for each section mesh.*/
     bufferMode = "multi";
+    textureSize = [16, 16];
 }
 export class UpdatingSettings {
     /**Sector sections are marked as dirty so they can be processed later. */

package/Stats/EngineStats.d.ts

@@ -1,17 +1,19 @@
-declare class GeomtryStats {
-    /**The total geomtry faces */
+declare class GeometryStats {
+    /**The total geometry faces */
     faces: number;
 }
 declare class PaletteStats {
     /**The final voxel palette id size. */
     paletteSize: number;
+    /**The final reltional voxel palette id size. */
+    reltionalPaletteSize: number;
 }
 /**
  * Stores data from the results of the engine building data and other things.
  */
 export declare class EngineStats {
     /** Stats to do with the vlox model system. */
-    static geomtry: GeomtryStats;
+    static geometry: GeometryStats;
     /** Stats to do with the vloxel palette system. */
     static palette: PaletteStats;
     static log(): string;

package/Stats/EngineStats.js

@@ -1,24 +1,26 @@
-class GeomtryStats {
-    /**The total geomtry faces */
+class GeometryStats {
+    /**The total geometry faces */
     faces = 0;
 }
 class PaletteStats {
     /**The final voxel palette id size. */
     paletteSize = 0;
+    /**The final reltional voxel palette id size. */
+    reltionalPaletteSize = 0;
 }
 /**
  * Stores data from the results of the engine building data and other things.
  */
 export class EngineStats {
     /** Stats to do with the vlox model system. */
-    static geomtry = new GeomtryStats();
+    static geometry = new GeometryStats();
     /** Stats to do with the vloxel palette system. */
     static palette = new PaletteStats();
     static log() {
         let output = "DVE Stats\n";
-        //geomtry
-        output += "Geomtry\n";
-        output += `Faces: ${this.geomtry.faces}\n`;
+        //geometry
+        output += "Geometry\n";
+        output += `Faces: ${this.geometry.faces}\n`;
         //palettes
         output += "Palette\n";
         output += `Paltte Size: ${this.palette.paletteSize}\n`;

package/Templates/Archive/ArchivedVoxelTemplate.d.ts

@@ -5,7 +5,7 @@ import { NumberPalette } from "../../Util/NumberPalette";
 import { IVoxelTemplate } from "../../Templates/VoxelTemplates.types";
 import { BinaryBuffer } from "../../Util/BinaryBuffer/index";
 import { VoxelPaletteArchiveReader } from "../../Voxels/Archive/VoxelPaletteArchiveReader";
-import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { BoundingBox } from "@amodx/math/Geometry/Bounds/BoundingBox";
 type TemplateCursor = {
     position: Vec3Array;
     raw: RawVoxelData;

package/Templates/Archive/ArchivedVoxelTemplate.js

@@ -1,10 +1,10 @@
 import { Flat3DIndex, Vector3Like } from "@amodx/math";
 import { NumberPalette } from "../../Util/NumberPalette";
-import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelLUT } from "../../Voxels/Data/VoxelLUT";
 import { VoxelTagsRegister } from "../../Voxels/Data/VoxelTagsRegister";
 import { BinaryBuffer, BinaryBufferFormat, } from "../../Util/BinaryBuffer/index";
 import { VoxelPaletteArchiveReader } from "../../Voxels/Archive/VoxelPaletteArchiveReader";
-import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { BoundingBox } from "@amodx/math/Geometry/Bounds/BoundingBox";
 const point = Vector3Like.Create();
 export class ArchivedVoxelTemplate {
     index = Flat3DIndex.GetXZYOrder();
@@ -35,7 +35,7 @@ export class ArchivedVoxelTemplate {
         return this.index.getIndexXYZ(x, y, z);
     }
     getId(index) {
-        return VoxelPalettesRegister.getVoxelIdFromString(...this.voxelPalette.getVoxelData(this.ids.getValue(index)));
+        return VoxelLUT.getVoxelIdFromString(...this.voxelPalette.getVoxelData(this.ids.getValue(index)));
     }
     getLevel(index) {
         return this.levelPalette.getValue(this.level.getValue(index));
@@ -45,9 +45,9 @@ export class ArchivedVoxelTemplate {
     }
     getSecondary(index) {
         const id = this.getId(index);
-        const trueId = VoxelPalettesRegister.voxels[id][0];
+        const trueId = VoxelLUT.voxels[id][0];
         if (VoxelTagsRegister.VoxelTags[trueId]["dve_can_have_secondary"]) {
-            return VoxelPalettesRegister.getVoxelIdFromString(...this.voxelPalette.getVoxelData(this.secondaryPalette.getValue(this.secondary.getValue(index))));
+            return VoxelLUT.getVoxelIdFromString(...this.voxelPalette.getVoxelData(this.secondaryPalette.getValue(this.secondary.getValue(index))));
         }
         return 0;
     }

package/Templates/Archive/Functions/CreateArchivedTemplate.d.ts

@@ -1,6 +1,6 @@
 import { ArchivedVoxelTemplate } from "../ArchivedVoxelTemplate";
 import { DataCursorInterface } from "../../../Voxels/Cursor/DataCursor.interface";
-import { BoundsMinMaxData } from "@amodx/math/Geomtry/Bounds/BoundsInterface";
+import { BoundsMinMaxData } from "@amodx/math/Geometry/Bounds/BoundsInterface";
 /**
  * Creates an archived template using the passed in the data cursor.
  * @param dimension