@divinevoxel/vlox 0.0.78 → 0.0.80

package/Builder/Tools/Wrench/WrenchTool.js

@@ -1,8 +1,8 @@
 import { PaintVoxelData } from "../../../Voxels";
 import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
 import { BuilderToolBase } from "../BuilderToolBase";
-import { SchemaRegister } from "../../../Voxels/State/SchemaRegister";
-import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelSchemas } from "../../../Voxels/State/VoxelSchemas";
+import { VoxelLUT } from "../../../Voxels/Data/VoxelLUT";
 var WrenchToolModes;
 (function (WrenchToolModes) {
     WrenchToolModes["Pick"] = "Pick";
@@ -64,28 +64,30 @@ export class WrenchTool extends BuilderToolBase {
         if (!this._pickedResult)
             return;
         const trueVoxelId = this._pickedResult.voxel.getVoxelId();
-        const voxelSchemas = SchemaRegister.getVoxelSchemas(this._pickedResult.voxel.getStringId());
-        voxelSchemas.state.startEncoding(this._pickedResult.voxel.getState());
-        voxelSchemas.mod.startEncoding(this._pickedResult.voxel.getMod());
+        const stringId = this._pickedResult.voxel.getStringId();
+        const stateSchema = VoxelSchemas.getStateSchema(stringId);
+        const modSchema = VoxelSchemas.mod.get(stringId);
+        stateSchema.startEncoding(this._pickedResult.voxel.getState());
+        modSchema.startEncoding(this._pickedResult.voxel.getMod());
         for (const node of schema.stateSchema) {
             if (node.type == "string") {
-                voxelSchemas.state.setValue(node.id, node.value);
+                stateSchema.setValue(node.id, node.value);
             }
             else {
-                voxelSchemas.state.setNumber(node.id, node.value);
+                stateSchema.setNumber(node.id, node.value);
             }
         }
         for (const node of schema.modSchema) {
             if (node.type == "string") {
-                voxelSchemas.mod.setValue(node.id, node.value);
+                modSchema.setValue(node.id, node.value);
             }
             else {
-                voxelSchemas.mod.setNumber(node.id, node.value);
+                modSchema.setNumber(node.id, node.value);
             }
         }
         const currentRaw = this._pickedResult.voxel.getRaw();
         const rawVoxelData = [
-            VoxelPalettesRegister.getVoxelId(trueVoxelId, voxelSchemas.state.getEncoded(), voxelSchemas.mod.getEncoded()),
+            VoxelLUT.getVoxelId(trueVoxelId, stateSchema.getEncoded(), modSchema.getEncoded()),
             currentRaw[1],
             currentRaw[2],
             currentRaw[3],
@@ -96,13 +98,16 @@ export class WrenchTool extends BuilderToolBase {
     getPickedSchema() {
         if (!this._pickedResult)
             return null;
-        const id = this._pickedResult.voxel.getStringId();
-        const voxelSchemas = SchemaRegister.getVoxelSchemas(id);
-        voxelSchemas.state.startEncoding(this._pickedResult.voxel.getState());
-        voxelSchemas.mod.startEncoding(this._pickedResult.voxel.getMod());
+        const stringId = this._pickedResult.voxel.getStringId();
+        const stateSchema = VoxelSchemas.getStateSchema(stringId);
+        const modSchema = VoxelSchemas.mod.get(stringId);
+        stateSchema.startEncoding(this._pickedResult.voxel.getState());
+        modSchema.startEncoding(this._pickedResult.voxel.getMod());
+        stateSchema.startEncoding(this._pickedResult.voxel.getState());
+        modSchema.startEncoding(this._pickedResult.voxel.getMod());
         return {
-            stateSchema: this.processSchema(voxelSchemas.state),
-            modSchema: this.processSchema(voxelSchemas.mod),
+            stateSchema: this.processSchema(stateSchema),
+            modSchema: this.processSchema(modSchema),
         };
     }
     /**Get an array of all possible state varations for the current mod of the selected voxel. */
@@ -111,8 +116,8 @@ export class WrenchTool extends BuilderToolBase {
             return null;
         const voxelStates = [];
         const voxelId = this._pickedResult.voxel.id;
-        const [trueId, , mod] = VoxelPalettesRegister.voxels[voxelId];
-        const stateArray = VoxelPalettesRegister.voxelRecord[trueId][mod];
+        const [trueId, , mod] = VoxelLUT.voxels[voxelId];
+        const stateArray = VoxelLUT.voxelRecord[trueId][mod];
         const rawVoxelData = [0, 0, 0, 0];
         for (let i = 0; i < stateArray.length; i++) {
             const value = stateArray[i];
@@ -129,8 +134,8 @@ export class WrenchTool extends BuilderToolBase {
             return null;
         const voxelStates = [];
         const voxelId = this._pickedResult.voxel.id;
-        const [trueId, state] = VoxelPalettesRegister.voxels[voxelId];
-        const modArray = VoxelPalettesRegister.voxelRecord[trueId];
+        const [trueId, state] = VoxelLUT.voxels[voxelId];
+        const modArray = VoxelLUT.voxelRecord[trueId];
         const rawVoxelData = [0, 0, 0, 0];
         for (let i = 0; i < modArray.length; i++) {
             const stateArray = modArray[i];
@@ -138,7 +143,7 @@ export class WrenchTool extends BuilderToolBase {
                 continue;
             let id = -1;
             for (let j = 0; j < stateArray.length; j++) {
-                id = VoxelPalettesRegister.voxelRecord[trueId][i][state];
+                id = VoxelLUT.voxelRecord[trueId][i][state];
                 if (id === undefined || id < 0)
                     continue;
                 rawVoxelData[0] = id;

package/Builder/VoxelBuildSpace.d.ts

@@ -1,5 +1,5 @@
 import { Vec3Array, Vector3Like } from "@amodx/math";
-import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { BoundingBox } from "@amodx/math/Geometry/Bounds/BoundingBox";
 import { DivineVoxelEngineRender } from "../Contexts/Render";
 import { VoxelPathData } from "../Templates/Path/VoxelPath.types";
 import { IVoxelTemplateData } from "../Templates/VoxelTemplates.types";
@@ -7,7 +7,7 @@ import { PaintVoxelData } from "../Voxels";
 import { VoxelPickResult } from "../Voxels/Interaction/VoxelPickResult";
 import { RayProvider } from "./RayProvider";
 import { FullVoxelTemplate } from "../Templates/Full/FullVoxelTemplate";
-import { BoundsMinMaxData } from "@amodx/math/Geomtry/Bounds/BoundsInterface";
+import { BoundsMinMaxData } from "@amodx/math/Geometry/Bounds/BoundsInterface";
 import type { VoxelSurfaceSelectionData } from "../Templates/Selection/VoxelSurfaceSelection";
 import type { VoxelBFSSelectionData } from "../Templates/Selection/VoxelBFSSelection";
 import { IVoxelSelectionData } from "../Templates/Selection/VoxelSelection";

package/Builder/VoxelBuildSpace.js

@@ -1,9 +1,9 @@
 import { Vector3Like } from "@amodx/math";
-import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { BoundingBox } from "@amodx/math/Geometry/Bounds/BoundingBox";
 import { PaintVoxelData } from "../Voxels";
 import { VoxelPlacingStrategyRegister } from "../Voxels/Interaction/Placing/VoxelPlacingStrategyRegister";
 import { VoxelPickResult } from "../Voxels/Interaction/VoxelPickResult";
-import { SchemaRegister } from "../Voxels/State/SchemaRegister";
+import { VoxelSchemas } from "../Voxels/State/VoxelSchemas";
 import { FullVoxelTemplate } from "../Templates/Full/FullVoxelTemplate";
 import { VoxelShapeTemplate } from "../Templates/Shapes/VoxelShapeTemplate";
 import { BoxVoxelShapeSelection } from "../Templates/Shapes/Selections/BoxVoxelShapeSelection";
@@ -80,8 +80,8 @@ export class VoxelBuildSpace {
             data.state = 0;
             return data;
         }
-        const schema = SchemaRegister.getVoxelSchemas(data.id);
-        data.state = schema.state.readString(state);
+        const schema = VoxelSchemas.getStateSchema(data.id);
+        data.state = schema.readString(state);
     }
     async clear() {
         const size = this.bounds.size;

package/Builder/World/InitTasks.js

@@ -7,7 +7,7 @@ import PickVoxelWorld from "../../Voxels/Interaction/Functions/PickVoxelWorld";
 import { WorldCursor } from "../../World";
 import LockSectors from "../../World/Lock/Function/LockSectors";
 import UnLockSectors from "../../World/Lock/Function/UnLockSectors";
-import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { BoundingBox } from "@amodx/math/Geometry/Bounds/BoundingBox";
 import { VoxelSurfaceSelection } from "../../Templates/Selection/VoxelSurfaceSelection";
 import { VoxelBFSSelection } from "../../Templates/Selection/VoxelBFSSelection";
 import CreateFullTemplate from "../../Templates/Full/Functions/CreateFullTemplate";

package/Cache/Cache.types.d.ts

@@ -1,8 +1,5 @@
 import { CompactMeshData } from "../Mesher/Types/Mesher.types";
 import { TextureData } from "../Textures/Texture.types";
-import { FinalCompiledVoxelModelData } from "../Voxels/Models/CompiledVoxelModel.types";
-export interface CachedVoxelModelData extends FinalCompiledVoxelModelData {
-}
 export interface CachedDisplayIndex {
     textures: Record<string, Record<string, string>>;
     meshes: Record<string, Record<string, {
@@ -11,7 +8,6 @@ export interface CachedDisplayIndex {
     }>>;
 }
 export interface CacheData {
-    models: FinalCompiledVoxelModelData;
     textures: TextureData[];
     displayIndex: CachedDisplayIndex;
 }

package/Cache/CacheManager.d.ts

@@ -1,10 +1,9 @@
 import { TextureData } from "Textures/Texture.types";
-import { CacheData, CachedDisplayIndex, CachedVoxelModelData } from "./Cache.types";
+import { CacheData, CachedDisplayIndex } from "./Cache.types";
 export declare class CacheManager {
     static cacheStoreEnabled: boolean;
     static cacheLoadEnabled: boolean;
     static cachedData: CacheData | null;
-    static cachedModelData: CachedVoxelModelData | null;
     static cachedTextureData: TextureData[] | null;
     static cachedDisplayData: CachedDisplayIndex | null;
     static getCachedData(): CacheData;

package/Cache/CacheManager.js

@@ -2,14 +2,12 @@ export class CacheManager {
     static cacheStoreEnabled = false;
     static cacheLoadEnabled = false;
     static cachedData = null;
-    static cachedModelData = null;
     static cachedTextureData = null;
     static cachedDisplayData = null;
     static getCachedData() {
         if (!this.cacheStoreEnabled)
             throw new Error(`cacheStoreEnabled must be set to true`);
         return {
-            models: this.cachedModelData,
             textures: this.cachedTextureData,
             displayIndex: this.cachedDisplayData,
         };

package/Contexts/Base/Main/InitDataGenerator.js

@@ -1,10 +1,18 @@
 import { EngineSettings } from "../../../Settings/EngineSettings";
 import { InitVoxelData } from "../../../Voxels/InitVoxelData";
+import { VoxelLUT } from "../../../Voxels/Data/VoxelLUT";
+import { GeometryLUT } from "../../../Voxels/Data/GeometryLUT";
+import { VoxelSchemas } from "../../../Voxels/State/VoxelSchemas";
 export default function InitDataGenerator(data) {
-    const voxels = InitVoxelData(data);
+    const tags = InitVoxelData(data);
     return {
         settings: EngineSettings.settings,
         threads: data.threads,
-        voxels,
+        tags,
+        luts: {
+            voxel: VoxelLUT.export(),
+            geometry: GeometryLUT.export(),
+        },
+        schemas: VoxelSchemas.export(),
     };
 }

package/Contexts/Base/Remote/DataSync.types.d.ts

@@ -1,13 +1,19 @@
 import { LocationData } from "Math/index.js";
 import { EngineSettingsData } from "../../../Settings/EngineSettings.types";
-import { CachedVoxelModelData } from "../../../Cache/Cache.types";
-import { CompiledVoxelData } from "../../../Voxels/Types/VoxelModelCompiledData.types";
+import { VoxelLUTExport } from "../../../Voxels/Data/VoxelLUT";
+import { GeometryLUTExport } from "../../../Voxels/Data/GeometryLUT";
+import { VoxelSchemasExport } from "../../../Voxels/State/VoxelSchemas";
+import { CompiledvVxelTags } from "Voxels/Types/VoxelModelCompiledData.types";
 export type DataSyncData = {
     settings: EngineSettingsData;
-    voxels: CompiledVoxelData;
-    modelData?: CachedVoxelModelData;
     threads: {
         nexus: boolean;
     };
+    tags: CompiledvVxelTags;
+    luts: {
+        voxel: VoxelLUTExport;
+        geometry: GeometryLUTExport;
+    };
+    schemas: VoxelSchemasExport;
 };
 export type WorldDataSync = [location: LocationData, buffer: SharedArrayBuffer];

package/Contexts/Base/Remote/InitDataSync.js

@@ -1,31 +1,21 @@
 import { Threads } from "@amodx/threads/";
 import { EngineSettings } from "../../../Settings/EngineSettings";
 //objects
-import { SchemaRegister } from "../../../Voxels/State/SchemaRegister";
-import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelLUT } from "../../../Voxels/Data/VoxelLUT";
 import { VoxelTagsRegister } from "../../../Voxels/Data/VoxelTagsRegister";
 import { VoxelLogicRegister } from "../../../Voxels/Logic/VoxelLogicRegister";
+import { GeometryLUT } from "../../../Voxels/Data/GeometryLUT";
+import { VoxelSchemas } from "../../../Voxels/State/VoxelSchemas";
 export default function InitDataSync(props) {
     Threads.registerTask("sync-data", (data) => {
         EngineSettings.syncSettings(data.settings);
-        VoxelPalettesRegister.voxelIds.load(data.voxels.data.idPalette);
-        VoxelTagsRegister.VoxelTags = data.voxels.data.tags;
-        VoxelPalettesRegister.voxelIdToNameMap = new Map(data.voxels.data.idToNameMap);
-        VoxelPalettesRegister.voxelNametoIdMap = new Map(data.voxels.data.nameToIdMap);
-        VoxelPalettesRegister.substance.load(data.voxels.substances.palette);
-        VoxelTagsRegister.SubstanceStags = data.voxels.substances.tags;
-        VoxelPalettesRegister.voxels = data.voxels.data.palette;
-        VoxelPalettesRegister.voxelRecord = data.voxels.data.record;
-        VoxelPalettesRegister.material.load(data.voxels.materials.palette);
-        const modelData = data.voxels.models;
-        for (const model of modelData.models) {
-            SchemaRegister.registerModel(model.id, model.schema);
-        }
-        for (const voxel of modelData.voxels) {
-            SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
-        }
-        for (const id in data.voxels.data.logic) {
-            VoxelLogicRegister.register(id, data.voxels.data.logic[id]);
+        VoxelSchemas.import(data.schemas);
+        VoxelLUT.import(data.luts.voxel);
+        GeometryLUT.import(data.luts.geometry);
+        VoxelTagsRegister.VoxelTags = data.tags.tags;
+        VoxelTagsRegister.SubstanceTags = data.tags.substanceTags;
+        for (const id in data.tags.logic) {
+            VoxelLogicRegister.register(id, data.tags.logic[id]);
         }
         props.onSync(data);
     });

package/Init/StartMesher.js

@@ -20,7 +20,8 @@ export async function StartMesher(data = {}) {
     let ready = false;
     InitDataSync({
         onSync(data) {
-            InitMesher(data.voxels.materials.palette, data.voxels.models);
+            // InitMesher(data.voxels.materials.palette, data.voxels.models);
+            InitMesher();
             ready = true;
         },
     });

package/Init/StartRenderer.js

@@ -72,7 +72,8 @@ export async function StartRenderer(initData) {
     await progress.wait(100);
     InitRendererTasks();
     InitWorldDataSync(DVER.threads.world);
-    InitMesher(syncData.voxels.materials.palette, syncData.voxels.models);
+    InitMesher();
+    //  InitMesher(syncData.voxels.materials.palette, syncData.voxels.models);
     progress.completeWorkItems(1);
     progress.setStatus("Waiting For Threads");
     await Promise.all(proms);

package/Mesher/{Geomtry → Geometry}/Geometry.types.d.ts

@@ -6,6 +6,7 @@ export interface VoxelGeometryTransform {
     rotationPivot?: Vec3Array;
     lockUVs?: true;
     flip?: [flipX: 0 | 1, flipY: 0 | 1, flipZ: 0 | 1];
+    divisor?: Vec3Array;
 }
 export type QuadVertexVec3Data = [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
 export type QuadVertexFloatData = [number, number, number, number];

package/Mesher/InitMesher.d.ts

@@ -1,2 +1 @@
-import { FinalCompiledVoxelModelData } from "../Voxels/Models/CompiledVoxelModel.types";
-export default function (materials: string[], modelData: FinalCompiledVoxelModelData): void;
+export default function (): void;

package/Mesher/InitMesher.js

@@ -1,20 +1,13 @@
 import { RenderedMaterials } from "./Voxels/Models/RenderedMaterials";
 import { VoxelModelConstructorRegister } from "./Voxels/Models/VoxelModelConstructorRegister.js";
-import { LiquidGeometryNode } from "./Voxels/Models/Nodes/Custom/Liquid/LiquidGeomtryNode.js";
+import { LiquidGeometryNode } from "./Voxels/Models/Nodes/Custom/Liquid/LiquidGeometryNode.js";
 import { VoxelConstructor } from "./Voxels/Models/VoxelConstructor.js";
-import { AOOcclusionFaceIndex } from "../Voxels/Models/Indexing/AOOcclusionFaceIndex";
-import { CulledOcclusionFaceIndex } from "../Voxels/Models/Indexing/CulledOcclusionFaceIndex";
-export default function (materials, modelData) {
-    RenderedMaterials.register(materials);
+import { VoxelLUT } from "../Voxels/Data/VoxelLUT";
+export default function () {
+    RenderedMaterials.register(VoxelLUT.material._palette);
     VoxelModelConstructorRegister.registerCustomNode("liquid", LiquidGeometryNode);
-    VoxelModelConstructorRegister.setGeometryPalette(modelData.geometryPalette);
-    VoxelModelConstructorRegister.registerGeometry(modelData.geometry);
-    VoxelModelConstructorRegister.registerModels(modelData.models);
-    VoxelModelConstructorRegister.aoIndex = new AOOcclusionFaceIndex(modelData.aoIndex);
-    VoxelModelConstructorRegister.faceCullIndex = new CulledOcclusionFaceIndex(modelData.faceCullIndex);
-    VoxelModelConstructorRegister.vertexHitMap = modelData.vertexHitMap;
-    VoxelModelConstructorRegister.faceCullMap = modelData.faceCullMap;
-    for (const voxel of modelData.voxels) {
-        VoxelModelConstructorRegister.registerVoxel(new VoxelConstructor(voxel.id, RenderedMaterials.meshersMap.get(voxel.materialId), VoxelModelConstructorRegister.modelData.get(voxel.modelId), voxel));
+    VoxelModelConstructorRegister.init();
+    for (const voxel of VoxelLUT.voxelIds._palette) {
+        VoxelModelConstructorRegister.registerVoxel(new VoxelConstructor(voxel, RenderedMaterials.meshersMap.get(VoxelLUT.material.getStringId(VoxelLUT.materialMap[VoxelLUT.voxelIds.getNumberId(voxel)]))));
     }
 }

package/Mesher/Items/{Geomtry → Geometry}/ItemGeometryBuilder.d.ts

@@ -1,5 +1,5 @@
 import { ItemModelBuilder } from "../Models/ItemModelBuilder";
-import { Quad } from "../../Geomtry/Primitives/Quad";
-import { Triangle } from "../../Geomtry/Primitives";
+import { Quad } from "../../Geometry/Primitives/Quad";
+import { Triangle } from "../../Geometry/Primitives";
 export declare function addItemTriangle(builder: ItemModelBuilder, tri: Triangle): void;
 export declare function addItemQuad(builder: ItemModelBuilder, quad: Quad): void;

package/Mesher/Items/{Geomtry → Geometry}/ItemGeometryBuilder.js

@@ -1,4 +1,4 @@
-import { QuadVerticies } from "../../Geomtry/Geometry.types";
+import { QuadVerticies } from "../../Geometry/Geometry.types";
 import { ItemMeshVertexConstants } from "./ItemMeshVertexStructCursor";
 export function addItemTriangle(builder, tri) {
     if (!builder.mesh)

package/Mesher/Items/MeshTexture.d.ts

@@ -1 +1,2 @@
-export declare function MeshTexture(textureId: number, textureData: number[]): import("../Types").CompactMeshData;
+import { Vector3Like } from "@amodx/math";
+export declare function MeshTexture(textureId: number, textureData: number[], origin?: Vector3Like, thickness?: number | null): import("../Types").CompactMeshData;

package/Mesher/Items/MeshTexture.js

@@ -1,9 +1,9 @@
-import { QuadVerticies } from "../Geomtry/Geometry.types";
-import { Quad } from "../Geomtry/Primitives/Quad";
+import { QuadVerticies } from "../Geometry/Geometry.types";
+import { Quad } from "../Geometry/Primitives/Quad";
 import { ItemModelBuilder } from "./Models/ItemModelBuilder";
-import { addItemQuad } from "./Geomtry/ItemGeometryBuilder";
-import { Flat2DIndex } from "@amodx/math";
-import { Box } from "../Geomtry/Shapes/Box";
+import { addItemQuad } from "./Geometry/ItemGeometryBuilder";
+import { Flat2DIndex, Vector3Like } from "@amodx/math";
+import { Box } from "../Geometry/Shapes/Box";
 import { VoxelFaces } from "../../Math";
 import { CompactItemMesh } from "./Base/CompactItemMesh";
 const { quads: Quads } = Box.Create([
@@ -48,11 +48,12 @@ class TextureVoxelData {
 Quads[VoxelFaces.North].setUVs(Quad.FullUVs);
 Quads[VoxelFaces.South].setUVs(Quad.FullUVs);
 const tool = new ItemModelBuilder("dve_item");
-export function MeshTexture(textureId, textureData) {
+export function MeshTexture(textureId, textureData, origin = Vector3Like.Create(), thickness = null) {
     const width = Math.sqrt(textureData.length / 4);
     const height = Math.sqrt(textureData.length / 4);
     const factor = 1 / width;
     const data = new TextureVoxelData(width, height, textureData);
+    tool.origin = origin;
     {
         //south face
         tool.vars.textureIndex = textureId;

package/Mesher/Items/MeshTextureO.js

@@ -1,4 +1,4 @@
-import { Quad } from "../Geomtry/Primitives/Quad";
+import { Quad } from "../Geometry/Primitives/Quad";
 const Quads = {
     north: Quad.Create([
         [1, 1, 0],

package/Mesher/Items/Models/ItemModelBuilder.d.ts

@@ -1,4 +1,4 @@
-import { ProtoMesh } from "../../Geomtry/Proto/ProtoMesh";
+import { ProtoMesh } from "../../Geometry/Proto/ProtoMesh";
 import { Vec3Array, Vector3Like } from "@amodx/math";
 declare class ItemVars {
     textureIndex: number;

package/Mesher/Items/Models/ItemModelBuilder.js

@@ -1,6 +1,6 @@
-import { ProtoMesh } from "../../Geomtry/Proto/ProtoMesh";
+import { ProtoMesh } from "../../Geometry/Proto/ProtoMesh";
 import { Vector3Like } from "@amodx/math";
-import { ItemMeshVertexStructCursor } from "../Geomtry/ItemMeshVertexStructCursor";
+import { ItemMeshVertexStructCursor } from "../Geometry/ItemMeshVertexStructCursor";
 class ItemVars {
     textureIndex = 0;
     reset() {

package/Mesher/Voxels/Base/CompactTemplateMesh.js

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

package/Mesher/Voxels/Base/CompactVoxelSectionMesh.js

@@ -1,5 +1,5 @@
-import { VoxelMeshVertexStructCursor } from "../Geomtry/VoxelMeshVertexStructCursor";
-import { CompactedSectionVoxelMesh, CompactedMeshData, } from "../Geomtry/CompactedSectionVoxelMesh";
+import { VoxelMeshVertexStructCursor } from "../Geometry/VoxelMeshVertexStructCursor";
+import { CompactedSectionVoxelMesh, CompactedMeshData, } from "../Geometry/CompactedSectionVoxelMesh";
 const meshData = new CompactedMeshData();
 const compactedMesh = new CompactedSectionVoxelMesh();
 /** Utility to ensure a value is aligned to 4 bytes. */

package/Mesher/Voxels/Base/MeshSectionBase.js

@@ -3,7 +3,7 @@ import { WorldSpaces } from "../../../World/WorldSpaces.js";
 //tools
 import { VoxelGeometryBuilderCacheSpace } from "../Models/VoxelGeometryBuilderCacheSpace.js";
 import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
-import { VoxelMeshBVHBuilder } from "../Geomtry/VoxelMeshBVHBuilder";
+import { VoxelMeshBVHBuilder } from "../Geometry/VoxelMeshBVHBuilder";
 import { Vector3Like } from "@amodx/math";
 import { RenderedMaterials } from "../Models/RenderedMaterials";
 import { CompactVoxelSectionMesh } from "./CompactVoxelSectionMesh";
@@ -12,8 +12,6 @@ const bvhTool = new VoxelMeshBVHBuilder();
 function meshVoxel(x, y, z, voxel, worldCursor, sectionCursor) {
     let added = false;
     const constructor = VoxelModelConstructorRegister.constructorsPaltte[voxel.getVoxelId()];
-    constructor.schema.dataCursor = worldCursor;
-    constructor.schema.voxel = voxel;
     const builder = constructor.builder;
     builder.origin.x = sectionCursor._voxelPosition.x;
     builder.origin.y = sectionCursor._voxelPosition.y;

package/Mesher/Voxels/{Geomtry → Geometry}/CompactedSectionVoxelMesh.js

@@ -1,4 +1,4 @@
-import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelLUT } from "../../../Voxels/Data/VoxelLUT";
 import { VoxelMeshVertexStructCursor } from "./VoxelMeshVertexStructCursor";
 export class CompactedMeshData {
     material;
@@ -81,7 +81,7 @@ export class CompactedSectionVoxelMesh {
         let startByte = CompactedSectionVoxelMesh.GetHeaderByteSize(0) +
             CompactedSectionVoxelMesh.GetMeshHeaderByteSize() * index;
         //material index
-        this.data.setUint8(startByte, VoxelPalettesRegister.material.getNumberId(material));
+        this.data.setUint8(startByte, VoxelLUT.material.getNumberId(material));
         startByte++;
         //min bounds
         this.data.setFloat32(startByte, minBounds[0]);
@@ -113,7 +113,7 @@ export class CompactedSectionVoxelMesh {
             CompactedSectionVoxelMesh.GetMeshHeaderByteSize() * index;
         // material index
         mesh.material = this.data.getUint8(startByte);
-        mesh.materialId = VoxelPalettesRegister.material.getStringId(mesh.material);
+        mesh.materialId = VoxelLUT.material.getStringId(mesh.material);
         startByte++;
         // min bounds
         mesh.minBounds[0] = this.data.getFloat32(startByte);

package/Mesher/Voxels/{Geomtry → Geometry}/VoxelGeometryBuilder.d.ts

@@ -1,5 +1,5 @@
 import { VoxelModelBuilder } from "../Models/VoxelModelBuilder";
-import { Quad } from "../../Geomtry/Primitives/Quad";
-import { Triangle } from "../../Geomtry/Primitives";
+import { Quad } from "../../Geometry/Primitives/Quad";
+import { Triangle } from "../../Geometry/Primitives";
 export declare function addVoxelTriangle(builder: VoxelModelBuilder, tri: Triangle): void;
 export declare function addVoxelQuad(builder: VoxelModelBuilder, quad: Quad): void;

package/Mesher/Voxels/{Geomtry → Geometry}/VoxelGeometryBuilder.js

@@ -1,6 +1,6 @@
 import { Vector4Like } from "@amodx/math";
 import { VoxelShaderData } from "./VoxelShaderData";
-import { QuadVerticies } from "../../Geomtry/Geometry.types";
+import { QuadVerticies } from "../../Geometry/Geometry.types";
 import { VoxelMeshVertexConstants } from "./VoxelMeshVertexStructCursor";
 const vector1ShaderData = Vector4Like.Create();
 const vector2ShaderData = Vector4Like.Create();

package/Mesher/Voxels/{Geomtry → Geometry}/VoxelMeshBVHBuilder.js

@@ -36,7 +36,7 @@ export class VoxelMeshBVHBuilder {
         this.structCursor.updateMin(minX, minY, minZ);
         this.structCursor.updateMax(maxX, maxY, maxZ);
         this.structCursor.setVoxelIndex(voxelIndex);
-        this.structCursor.setGeomtryNode();
+        this.structCursor.setGeometryNode();
         let current = leafIndex;
         for (let level = 1; level < 13; level++) {
             let parentNode = this.treeIndex.getParent(current);

package/Mesher/Voxels/{Geomtry → Geometry}/VoxelMeshBVHStructCursor.d.ts

@@ -16,7 +16,7 @@ export declare class VoxelMeshBVHStructCursor {
     setActive(): void;
     setVoxelIndex(value: number): void;
     setInnerNode(): void;
-    setGeomtryNode(): void;
+    setGeometryNode(): void;
     updateMin(x: number, y: number, z: number): void;
     updateMax(x: number, y: number, z: number): void;
 }

package/Mesher/Voxels/{Geomtry → Geometry}/VoxelMeshBVHStructCursor.js

@@ -44,7 +44,7 @@ export class VoxelMeshBVHStructCursor {
     setInnerNode() {
         this.data[this.trueIndex + 7] = 1;
     }
-    setGeomtryNode() {
+    setGeometryNode() {
         this.data[this.trueIndex + 7] = 2;
     }
     updateMin(x, y, z) {

package/Mesher/Voxels/MeshTemplate.js

@@ -14,9 +14,6 @@ function meshVoxel(x, y, z, voxel, templateCursor) {
         return false;
     let added = false;
     const constructor = VoxelModelConstructorRegister.constructorsPaltte[voxel.getVoxelId()];
-    constructor.schema.dataCursor = templateCursor;
-    constructor.schema.dataCursor = templateCursor;
-    constructor.schema.voxel = voxel;
     const builder = constructor.builder;
     builder.origin.x = x;
     builder.origin.y = y;

package/Mesher/Voxels/MeshVoxel.js

@@ -19,8 +19,6 @@ export function MeshVoxel(rawVoxelData) {
     if (!constructor) {
         throw new Error(`Could not find constructor for voxel [id:${voxel.getStringId()} name:${voxel.getName()}] `);
     }
-    constructor.schema.dataCursor = templateCursor;
-    constructor.schema.voxel = voxel;
     const builder = constructor.builder;
     if (!builder) {
         console.error(builder, constructor.id, constructor);

package/Mesher/Voxels/Models/Common/Calc/CalcConstants.d.ts

@@ -1,4 +1,4 @@
-import { QuadVerticies } from "../../../../Geomtry/Geometry.types";
+import { QuadVerticies } from "../../../../Geometry/Geometry.types";
 import { VoxelFaces } from "../../../../../Math";
 import { Vec4Array } from "@amodx/math";
 export declare const GradientCheckSets: Record<VoxelFaces, Record<QuadVerticies, number[]>>;

package/Mesher/Voxels/Models/Common/Calc/CalcConstants.js

@@ -1,6 +1,6 @@
-import { QuadVerticies } from "../../../../Geomtry/Geometry.types";
+import { QuadVerticies } from "../../../../Geometry/Geometry.types";
 import { VoxelFaces, VoxelFacesArray } from "../../../../../Math";
-import { VoxelRelativeCubeIndex } from "../../../../../Voxels/Models/Indexing/VoxelRelativeCubeIndex";
+import { VoxelRelativeCubeIndex } from "../../../../../Voxels/Geometry/VoxelRelativeCubeIndex";
 import { VoxelLightData } from "../../../../../Voxels/Cursor/VoxelLightData";
 export const GradientCheckSets = [];
 GradientCheckSets[VoxelFaces.Up] = [];

package/Mesher/Voxels/Models/Common/Calc/FaceDataCalc.js

@@ -17,7 +17,10 @@ export default function calculateFaceData(face, builder) {
         startLight =
             nVoxel
                 .getVoxel(x + VoxelFaceDirections[face][0], y + VoxelFaceDirections[face][1], z + VoxelFaceDirections[face][2])
-                ?.getLight() || 0;
+                ?.getLight() || -1;
+        if (startLight <= 0) {
+            startLight = nVoxel.getVoxel(x, y, z)?.getLight() || 0;
+        }
     }
     if (startLight < 0)
         startLight = 0;