@divinevoxel/vlox 0.0.6 → 0.0.7

package/Contexts/Render/DivineVoxelEngineRender.d.ts

@@ -19,14 +19,14 @@ export declare class DivineVoxelEngineRender {
     settings: {
         enviorment: "node" | "browser";
         settings: EngineSettingsData;
+        readonly doSunPropagation: boolean;
+        readonly doRGBPropagation: boolean;
+        readonly doLight: boolean;
+        readonly doFlow: boolean;
+        readonly isClient: boolean;
         getSettings(): EngineSettingsData;
         syncSettings(data: EngineSettingsData): void;
         getSettingsCopy(): any;
-        doSunPropagation(): boolean;
-        doRGBPropagation(): boolean;
-        doLight(): boolean;
-        doFlow(): boolean;
-        isClient(): boolean;
         addEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
             synced: {
                 settings: any;

package/Contexts/World/DivineVoxelEngineWorld.d.ts

@@ -11,14 +11,14 @@ export declare class DivineVoxelEngineWorld {
     settings: {
         enviorment: "node" | "browser";
         settings: import("../../Settings/EngineSettings.types.js").EngineSettingsData;
+        readonly doSunPropagation: boolean;
+        readonly doRGBPropagation: boolean;
+        readonly doLight: boolean;
+        readonly doFlow: boolean;
+        readonly isClient: boolean;
         getSettings(): import("../../Settings/EngineSettings.types.js").EngineSettingsData;
         syncSettings(data: import("../../Settings/EngineSettings.types.js").EngineSettingsData): void;
         getSettingsCopy(): any;
-        doSunPropagation(): boolean;
-        doRGBPropagation(): boolean;
-        doLight(): boolean;
-        doFlow(): boolean;
-        isClient(): boolean;
         addEventListener<K extends "synced">(type: K, listener: EventListenerObject | ((event: CustomEvent<{
             synced: {
                 settings: any;

package/Mesher/Functions/MeshSection.js

@@ -68,11 +68,14 @@ export function MeshSection(location) {
     const maxZ = WorldSpaces.section.bounds.z;
     if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
         return null;
-    space.start(cx - padding.x, cy - padding.y, cz - padding.z);
+    space.start(cx - (padding.x - 1), cy - (padding.y - 1), cz - (padding.z - 1));
     VoxelGeometryLookUp.start(space);
     bvhTool.reset();
+    const effects = {};
     for (let i = 0; i < RenderedMaterials.meshers.length; i++) {
-        RenderedMaterials.meshers[i].bvhTool = bvhTool;
+        const mesher = RenderedMaterials.meshers[i];
+        mesher.bvhTool = bvhTool;
+        mesher.effects = effects;
     }
     for (let y = minY; y <= maxY; y++) {
         let foundVoxels = false;

package/Mesher/Functions/MeshVoxel.js

@@ -1,12 +1,10 @@
 import { RenderedMaterials } from "../RenderedMaterials";
 import { VoxelGeometryLookUp } from "../Models/VoxelGeometryLookUp.js";
 import { TemplateCursor } from "../../Templates/Cursor/TemplateCursor.js";
-import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor.js";
 import { FullVoxelTemplate } from "../../Templates/FullVoxelTemplate.js";
 import { CompactVoxelMesh } from "../Functions/CompactVoxelMesh.js";
 import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
 const templateCursor = new TemplateCursor();
-const voxelCursor = new VoxelCursor();
 templateCursor.setTemplate(new FullVoxelTemplate(FullVoxelTemplate.CreateNew([3, 3, 3], 0xf)));
 const space = VoxelGeometryLookUp.createSpace(3, 3, 3);
 export function MeshVoxel(rawVoxelData) {
@@ -25,14 +23,16 @@ export function MeshVoxel(rawVoxelData) {
     }
     mesher.bvhTool = null;
     mesher.resetAll();
+    space.start(0, 0, 0);
     VoxelGeometryLookUp.start(space);
+    mesher.effects = {};
     mesher.origin.x = -0.5;
     mesher.origin.y = -0.5;
     mesher.origin.z = -0.5;
     mesher.position.x = 1;
     mesher.position.y = 1;
     mesher.position.z = 1;
-    mesher.voxel = voxelCursor.copy(voxel);
+    mesher.voxel = voxel;
     mesher.nVoxel = templateCursor;
     constructor.process(mesher);
     mesher.reset();

package/Mesher/Geomtry/VoxelMesh.d.ts

@@ -1,13 +1,12 @@
 import { Vector3Like } from "@amodx/math";
 import { VoxelVertexBuffer, VoxelIndiceBuffer } from "./Buffers";
 export declare class VoxelMesh {
-    indicieIndex: number;
     indicieCount: number;
     vertexCount: number;
     minBounds: Vector3Like;
     maxBounds: Vector3Like;
     readonly buffer: VoxelVertexBuffer;
     readonly indices: VoxelIndiceBuffer;
-    addVerticies(count: number, indicesCount: number): void;
+    addVerticies(vertexCount: number, indicesCount: number): void;
     clear(): void;
 }

package/Mesher/Geomtry/VoxelMesh.js

@@ -2,20 +2,17 @@ import { Vector3Like } from "@amodx/math";
 import { VoxelVertexBuffer, VoxelIndiceBuffer } from "./Buffers";
 import { VoxelMeshVertexStructCursor } from "../Tools/VoxelMeshVertexStructCursor";
 export class VoxelMesh {
-    indicieIndex = 0;
     indicieCount = 0;
     vertexCount = 0;
     minBounds = Vector3Like.Create(Infinity, Infinity, Infinity);
     maxBounds = Vector3Like.Create(-Infinity, -Infinity, -Infinity);
     buffer = new VoxelVertexBuffer(VoxelMeshVertexStructCursor.VertexFloatSize, 1000);
     indices = new VoxelIndiceBuffer(1000);
-    addVerticies(count, indicesCount) {
-        this.vertexCount += count;
+    addVerticies(vertexCount, indicesCount) {
+        this.vertexCount += vertexCount;
         this.indicieCount += indicesCount;
     }
     clear() {
-        // this.buffer.length = 0;
-        //this.indices.length = 0;
         this.indicieCount = 0;
         this.vertexCount = 0;
         this.minBounds.x = Infinity;

package/Mesher/Models/Common/BoxGeometryNode.js

@@ -2,6 +2,7 @@ import { Vector3Like } from "@amodx/math";
 import { VoxelFaces } from "../../../Math";
 import { Quad } from "../../Geomtry/Primitives/Quad";
 import { addQuadWeights } from "./Calc/CalcConstants";
+import { TransformBox } from "../../../Models/Shared/Transform";
 import { GetBounds } from "./BoundsFunctions";
 export function GetBoxGeometryNodeData(points, transform) {
     // const quads: Quad[] = [];
@@ -51,7 +52,7 @@ export function GetBoxGeometryNodeData(points, transform) {
         [start.x, start.y, end.z],
         [start.x, start.y, start.z],
     ]);
-    // TransformBox(quads as any, transform);
+    TransformBox(quads, transform);
     const quadBounds = new Array(quads.length);
     for (let i = 0; i < quads.length; i++) {
         const positions = [];

package/Mesher/Models/Nodes/Ruled/BoxVoxelGeometryNode.js

@@ -33,6 +33,8 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
             const currentIndex = faceIndexes[positionIndex];
             const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
             const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
+            if (VoxelGeometryLookUp.space.foundHash[hashed] < 2)
+                continue;
             const offsetBaseGometry = VoxelGeometryLookUp.space.getGeomtry(hashed);
             const offsetConditonalGeometry = VoxelGeometryLookUp.space.getConditionalGeomtry(hashed);
             if (offsetBaseGometry) {
@@ -83,7 +85,8 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                 const currentIndex = aoIndexes[positionIndex];
                 const p = VoxelRelativeCubeIndexPositionMap[currentIndex];
                 const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x + p[0], tool.position.y + p[1], tool.position.z + p[2]);
-                if (VoxelGeometryLookUp.space.noCastAO[hashed] === 1)
+                if (VoxelGeometryLookUp.space.foundHash[hashed] < 2 ||
+                    VoxelGeometryLookUp.space.noCastAO[hashed] === 1)
                     continue;
                 const baseGeo = VoxelGeometryLookUp.space.getGeomtry(hashed);
                 const conditonalGeo = VoxelGeometryLookUp.space.getConditionalGeomtry(hashed);

package/Mesher/Models/Nodes/VoxelGeometryConstructor.js

@@ -61,7 +61,7 @@ export class VoxelGeometryConstructor {
         for (const node of this.nodes) {
             node.faceIndex = faceCount;
             node.vertexIndex = vertexCount;
-            faceCount += node.faceCount - 1;
+            faceCount += node.faceCount;
             vertexCount += node.vertexCount;
         }
     }

package/Mesher/Models/VoxelConstructor.d.ts

@@ -21,8 +21,6 @@ export declare class VoxelConstructor {
     shapeStateTree: StateTreeReader;
     condtioanlShapeStateTree: CondtionalTreeReader;
     constructor(id: string, data: CompiledVoxelModelData, voxleData: CompiledVoxelModelInputData);
-    getShapeStateTransaprentByteIndex(shapeState: number, geomtryId: number): number;
-    getCondtionalStateTransaprentByteIndex(shapeState: number, geomtryId: number): number;
     isShapeStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;
     isCondtionalStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;
     process(tool: VoxelMesherDataTool): void;

package/Mesher/Models/VoxelConstructor.js

@@ -25,30 +25,24 @@ export class VoxelConstructor {
         this.baseInputMap = voxleData.baseGeometryInputMap;
         this.conditonalInputMap = voxleData.condiotnalGeometryInputMap;
         this.transparentIndex = new VoxelFaceTransparentResultsIndex(voxleData.transparentFaceIndex);
-        this.modSchema = new StateSchema(voxleData.modSchema);
-        this.modTree = new StateTreeReader(this.modSchema, 0, voxleData.modStateTree);
         this.schema = new StateSchema(data.schema);
         this.shapeStateTree = new StateTreeReader(this.schema, 0, data.shapeStateTree);
         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);
     }
-    getShapeStateTransaprentByteIndex(shapeState, geomtryId) {
-        return this.data.relativeGeometryByteIndexMap[this.data.shapeStateRelativeGeometryMap[shapeState][geomtryId]];
-    }
-    getCondtionalStateTransaprentByteIndex(shapeState, geomtryId) {
-        return this.data.relativeGeometryByteIndexMap[this.data.condiotnalShapeStateRelativeGeometryMap[shapeState][geomtryId]];
-    }
     isShapeStateFaceTransparent(modState, shapeState, geoId, faceIndex) {
-        return (this.transparentIndex.getValue(modState, this.getShapeStateTransaprentByteIndex(shapeState, geoId), faceIndex) == 1);
+        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.shapeStateRelativeGeometryMap[shapeState][geoId]], faceIndex) == 1);
     }
     isCondtionalStateFaceTransparent(modState, shapeState, geoId, faceIndex) {
-        return (this.transparentIndex.getValue(modState, this.getCondtionalStateTransaprentByteIndex(shapeState, geoId), faceIndex) == 1);
+        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.condiotnalShapeStateRelativeGeometryMap[shapeState][geoId]], faceIndex) == 1);
     }
     process(tool) {
         const hashed = VoxelGeometryLookUp.getHash(tool.nVoxel, tool.position.x, tool.position.y, tool.position.z);
         const treeState = VoxelGeometryLookUp.space.stateCache[hashed];
         const modState = VoxelGeometryLookUp.space.modCache[hashed];
-        if (treeState !== undefined && treeState > -1) {
+        if (treeState > -1) {
             const geoLinks = this.data.shapeStateMap[treeState];
             const geometries = this.data.shapeStateGeometryMap[treeState];
             const geometriesLength = geoLinks.length;
@@ -64,7 +58,7 @@ export class VoxelConstructor {
             }
         }
         const conditonalTreeState = VoxelGeometryLookUp.space.conditonalStateCache[hashed];
-        if (conditonalTreeState !== undefined && conditonalTreeState > -1) {
+        if (conditonalTreeState > -1) {
             const condiotnalNodes = this.data.condiotnalShapeStateMap[conditonalTreeState];
             const condiotnalNodesLength = condiotnalNodes.length;
             for (let c = 0; c < condiotnalNodesLength; c++) {

package/Mesher/Models/VoxelGeometryLookUp.js

@@ -25,9 +25,11 @@ export class VoxelGeometryLookUpSpace {
         this.offset[1] = y;
         this.offset[2] = z;
         this.foundHash.fill(0);
-        this.conditonalStateCache.fill(-1);
-        this.stateCache.fill(-1);
+        this.voxelHash.fill(0);
         this.modCache.fill(-1);
+        this.stateCache.fill(-1);
+        this.conditonalStateCache.fill(-1);
+        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);
@@ -65,42 +67,40 @@ export class VoxelGeometryLookUp {
     static getHash(dataCursor, x, y, z) {
         if (!this.space)
             throw new Error(`Voxel geomtry look up must have space set`);
-        const hashed = this.space?.getIndex(x, y, z);
-        if (this.space.foundHash[hashed] == 0)
+        const hashed = this.space.getIndex(x, y, z);
+        if (this.space.foundHash[hashed] == 0) {
             this.hashState(dataCursor, hashed, x, y, z);
+        }
         return hashed;
     }
     static hashState(dataCursor, index, x, y, z) {
         if (!this.space)
             throw new Error(`Voxel geomtry look up must have space set`);
+        if (this.space.foundHash[index] == 1)
+            return -1;
         if (this.space.foundHash[index] == 2)
             return this.space.stateCache[index];
         const voxel = dataCursor.getVoxel(x, y, z);
-        if (!voxel) {
-            this.space.foundHash[index] = 1;
-            return -1;
-        }
-        if (!voxel.isRenderable()) {
+        if (!voxel || !voxel.isRenderable()) {
             this.space.foundHash[index] = 1;
             return -1;
         }
-        const voxelConstructor = VoxelModelConstructorRegister.constructorsPaltte[voxel.getId()];
-        this.space.voxelHash[index] = voxel.getId();
-        if (!voxelConstructor || !voxelConstructor.isModel) {
+        const voxelId = voxel.getId();
+        const voxelConstructor = VoxelModelConstructorRegister.constructorsPaltte[voxelId];
+        if (!voxelConstructor) {
             this.space.foundHash[index] = 1;
             return -1;
         }
+        this.space.voxelHash[index] = voxelId;
         this.space.foundHash[index] = 2;
         //no ao
         this.space.noCastAO[index] = voxel.isLightSource() || voxel.noAO() ? 1 : 0;
         //state
-        const shapeState = voxel.getState();
-        const state = voxelConstructor.shapeStateTree.getState(shapeState);
+        const state = voxelConstructor.shapeStateTree.getState(voxel.getState());
         this.space.stateCache[index] = state;
         //mod
-        const mod = voxel.getMod();
-        const modState = voxelConstructor.modTree.getState(mod);
-        this.space.modCache[index] = modState;
+        const mod = voxelConstructor.modTree.getState(voxel.getMod());
+        this.space.modCache[index] = mod;
         this.voxelCursor.copy(voxel).process();
         voxelConstructor.schema.position.x = x;
         voxelConstructor.schema.position.y = y;
@@ -109,6 +109,6 @@ export class VoxelGeometryLookUp {
         voxelConstructor.schema.dataCursor = dataCursor;
         const conditonalState = voxelConstructor.condtioanlShapeStateTree.getState();
         this.space.conditonalStateCache[index] = conditonalState;
-        return state;
+        return 1;
     }
 }

package/Mesher/Tools/VoxelMesherDataTool.d.ts

@@ -44,5 +44,6 @@ export declare class VoxelMesherDataTool extends MesherDataTool {
     calculateFaceData(direction: VoxelFaces): true | undefined;
     clearCalculatedData(): void;
     reset(): void;
+    resetAll(): this;
 }
 export {};

package/Mesher/Tools/VoxelMesherDataTool.js

@@ -112,4 +112,9 @@ export class VoxelMesherDataTool extends MesherDataTool {
     reset() {
         this.vars.reset();
     }
+    resetAll() {
+        this.vars.reset();
+        this.mesh.clear();
+        return this;
+    }
 }

package/Renderer/InitTasks.js

@@ -2,6 +2,7 @@ import { Threads } from "@amodx/threads/";
 import { MeshManager } from "./MeshManager";
 import { MeshRegister } from "./MeshRegister";
 import { TaskTool } from "../Tools/Tasks/TasksTool";
+import { EngineSettings } from "../Settings/EngineSettings";
 export default function RendererTasks(threads) {
     const tasks = new TaskTool(threads);
     Threads.registerTask("set-section", (data, origin) => {
@@ -15,7 +16,9 @@ export default function RendererTasks(threads) {
                 tranfers.push(mesh[2]);
             }
         }
-        origin.sendMessage(data, tranfers);
+        if (!EngineSettings.settings.rendererSettings.cpuBound) {
+            origin.sendMessage(data, tranfers);
+        }
     });
     Threads.registerTask("remove-sector", (data) => {
         MeshManager.removeSector(data);

package/Settings/EngineSettings.d.ts

@@ -12,14 +12,14 @@ type EngineSettingsEvents = {
 declare class EngineSettingsClass extends TypedEventTarget<EngineSettingsEvents> {
     enviorment: "node" | "browser";
     settings: EngineSettingsData;
+    get doSunPropagation(): boolean;
+    get doRGBPropagation(): boolean;
+    get doLight(): boolean;
+    get doFlow(): boolean;
+    get isClient(): boolean;
     getSettings(): EngineSettingsData;
     syncSettings(data: EngineSettingsData): void;
     getSettingsCopy(): any;
-    doSunPropagation(): boolean;
-    doRGBPropagation(): boolean;
-    doLight(): boolean;
-    doFlow(): boolean;
-    isClient(): boolean;
 }
 export declare const EngineSettings: EngineSettingsClass;
 export {};

package/Settings/EngineSettings.js

@@ -8,6 +8,21 @@ import { TypedEventTarget } from "../Util/TypedEventTarget.js";
 class EngineSettingsClass extends TypedEventTarget {
     enviorment = Environment.isNode() ? "node" : "browser";
     settings = new EngineSettingsData();
+    get doSunPropagation() {
+        return this.settings.lighting.autoSunLight == true;
+    }
+    get doRGBPropagation() {
+        return this.settings.lighting.autoRGBLight == true;
+    }
+    get doLight() {
+        return this.doRGBPropagation || this.doSunPropagation;
+    }
+    get doFlow() {
+        return this.settings.flow.enable;
+    }
+    get isClient() {
+        return this.enviorment != "browser";
+    }
     getSettings() {
         return this.settings;
     }
@@ -34,20 +49,5 @@ class EngineSettingsClass extends TypedEventTarget {
     getSettingsCopy() {
         return JSON.parse(JSON.stringify(this.settings));
     }
-    doSunPropagation() {
-        return this.settings.lighting.autoSunLight == true;
-    }
-    doRGBPropagation() {
-        return this.settings.lighting.autoRGBLight == true;
-    }
-    doLight() {
-        return this.doRGBPropagation() || this.doSunPropagation();
-    }
-    doFlow() {
-        return this.settings.flow.enable;
-    }
-    isClient() {
-        return this.enviorment != "browser";
-    }
 }
 export const EngineSettings = new EngineSettingsClass();

package/Settings/EngineSettings.types.d.ts

@@ -1,46 +1,64 @@
+import { Vector3Like } from "@amodx/math";
+export interface RenderSettingsData {
+}
+export declare class RenderSettingsData {
+    mode: "webgl" | "webgpu";
+    cpuBound: boolean;
+}
+export interface TextureSettings {
+}
+export declare class TextureSettings {
+    textureSize: number;
+}
+export interface UpdatingSettings {
+}
+export declare class UpdatingSettings {
+    autoRebuild: boolean;
+}
+export interface WorldSettings {
+}
+export declare class WorldSettings {
+    min: Vector3Like;
+    max: Vector3Like;
+}
+export interface SectorSettings {
+}
+export declare class SectorSettings {
+    power2Size: Vector3Like;
+}
+export interface SectionSettings {
+}
+export declare class SectionSettings {
+    power2Size: Vector3Like;
+}
+export interface VoxelSettings {
+}
+export declare class VoxelSettings {
+    doColors: boolean;
+}
+export interface FlowSettings {
+}
+export declare class FlowSettings {
+    enable: boolean;
+    baseFlowLimit: number;
+}
+export interface LightingSettings {
+}
+export declare class LightingSettings {
+    doAO: boolean;
+    doSunLight: boolean;
+    doRGBLight: boolean;
+    autoRGBLight: boolean;
+    autoSunLight: boolean;
+}
 export declare class EngineSettingsData {
-    rendererSettings: {
-        mode: "webgl" | "webgpu";
-    };
-    textures: {
-        animationTime: number;
-        textureSize: number;
-        mipMapSizes: number[];
-    };
-    updating: {
-        autoRebuild: boolean;
-    };
-    world: {
-        maxX: number;
-        minX: number;
-        maxZ: number;
-        minZ: number;
-        maxY: number;
-        minY: number;
-    };
-    sectors: {
-        sectorXPow2: number;
-        sectorYPow2: number;
-        sectorZPow2: number;
-    };
-    sections: {
-        autoHeightMap: boolean;
-        sectionXPow2: number;
-        sectionYPow2: number;
-        sectionZPow2: number;
-    };
-    voxels: {
-        doColors: boolean;
-    };
-    flow: {
-        enable: boolean;
-        baseFlowLimit: number;
-    };
-    lighting: {
-        doAO: boolean;
-        doSunLight: boolean;
-        doRGBLight: boolean;
-        autoRGBLight: boolean;
-        autoSunLight: boolean;
-    };
+    rendererSettings: RenderSettingsData;
+    textures: TextureSettings;
+    updating: UpdatingSettings;
+    world: WorldSettings;
+    sectors: SectorSettings;
+    sections: SectionSettings;
+    voxels: VoxelSettings;
+    flow: FlowSettings;
+    lighting: LightingSettings;
 }

package/Settings/EngineSettings.types.js

@@ -1,44 +1,46 @@
+import { Vector3Like } from "@amodx/math";
+export class RenderSettingsData {
+    mode = "webgl";
+    cpuBound = false;
+}
+export class TextureSettings {
+    textureSize = 16;
+}
+export class UpdatingSettings {
+    autoRebuild = true;
+}
+export class WorldSettings {
+    min = Vector3Like.Create(-Number.MAX_SAFE_INTEGER, 0, -Number.MAX_SAFE_INTEGER);
+    max = Vector3Like.Create(Number.MAX_SAFE_INTEGER, 256, Number.MAX_SAFE_INTEGER);
+}
+export class SectorSettings {
+    power2Size = Vector3Like.Create(4, 8, 4);
+}
+export class SectionSettings {
+    power2Size = Vector3Like.Create(4, 4, 4);
+}
+export class VoxelSettings {
+    doColors = true;
+}
+export class FlowSettings {
+    enable = true;
+    baseFlowLimit = 200;
+}
+export class LightingSettings {
+    doAO = true;
+    doSunLight = true;
+    doRGBLight = true;
+    autoRGBLight = true;
+    autoSunLight = true;
+}
 export class EngineSettingsData {
-    rendererSettings = { mode: "webgl" };
-    textures = {
-        animationTime: 20,
-        textureSize: 16,
-        mipMapSizes: [16, 12, 8, 4],
-    };
-    updating = {
-        autoRebuild: true,
-    };
-    world = {
-        maxX: Number.MAX_SAFE_INTEGER,
-        minX: -Number.MAX_SAFE_INTEGER,
-        maxZ: Number.MAX_SAFE_INTEGER,
-        minZ: -Number.MAX_SAFE_INTEGER,
-        maxY: 256,
-        minY: 0,
-    };
-    sectors = {
-        sectorXPow2: 4,
-        sectorYPow2: 8,
-        sectorZPow2: 4,
-    };
-    sections = {
-        autoHeightMap: true,
-        sectionXPow2: 4,
-        sectionYPow2: 4,
-        sectionZPow2: 4,
-    };
-    voxels = {
-        doColors: true,
-    };
-    flow = {
-        enable: true,
-        baseFlowLimit: 200,
-    };
-    lighting = {
-        doAO: true,
-        doSunLight: true,
-        doRGBLight: true,
-        autoRGBLight: true,
-        autoSunLight: true,
-    };
+    rendererSettings = new RenderSettingsData();
+    textures = new TextureSettings();
+    updating = new UpdatingSettings();
+    world = new WorldSettings();
+    sectors = new SectorSettings();
+    sections = new SectionSettings();
+    voxels = new VoxelSettings();
+    flow = new FlowSettings();
+    lighting = new LightingSettings();
 }

package/Tasks/IWG/IWG.d.ts

@@ -8,6 +8,9 @@ interface IWGInitData {
     threads: Thread | ThreadPool;
     worldStorage?: WorldStorageInterface;
 }
+/**# Infinite World Generation IWG
+ * Object to handle the loading and generating the world around a created generator.
+ */
 export declare class IWG {
     private static _cullGenerators;
     static readonly _generators: Generator[];

package/Tasks/IWG/IWG.js

@@ -10,6 +10,9 @@ import { Vector3Like } from "@amodx/math";
 import { InitalLoad } from "./Procedures/InitalLoad";
 import SaveAllSectors from "./Procedures/SaveAllSectors";
 let initalized = false;
+/**# Infinite World Generation IWG
+ * Object to handle the loading and generating the world around a created generator.
+ */
 export class IWG {
     static _cullGenerators = [];
     static _generators = [];

package/Tasks/Propagation/Explosion/ExplosionManager.js

@@ -104,7 +104,7 @@ export const ExplosionManager = {
                               ) {
                                 continue;
                               } */
-                    voxel.setAir().updateHeightMap(1);
+                    voxel.setAir().updateVoxel(1);
                 }
             }
         }

package/Tasks/Propagation/Flow/WorldFlow.js

@@ -50,13 +50,13 @@ function Flood(task, voxel) {
                     nState == 0) {
                     if (downAir && !downSameVoxel) {
                         nVoxel.setId(voxelId);
-                        nVoxel.updateHeightMap(0);
+                        nVoxel.updateVoxel(0);
                         nVoxel.setLevel(7);
                         nVoxel.setLevelState(1);
                     }
                     else if (!downSameVoxel) {
                         nVoxel.setId(voxelId);
-                        nVoxel.updateHeightMap(0);
+                        nVoxel.updateVoxel(0);
                         nVoxel.setLevel(level - 1);
                         nVoxel.setLevelState(0);
                     }
@@ -98,14 +98,14 @@ function Flood(task, voxel) {
             task.rgb.remove.push(x, y - 1, z);
         }
         nVoxel.setId(voxelId);
-        nVoxel.updateHeightMap(0);
+        nVoxel.updateVoxel(0);
         nVoxel.setLevel(7);
         nVoxel.setLevelState(state);
         queue.push(x, y - 1, z);
     }
 }
 export function WorldFlow(task) {
-    if (!EngineSettings.doFlow())
+    if (!EngineSettings.doFlow)
         return false;
     const sector = WorldRegister.sectors.get(task.origin[0], task.origin[1], task.origin[2], task.origin[3]);
     if (!sector) {

package/Tasks/Propagation/Illumanation/RGBUpdate.js

@@ -1,5 +1,5 @@
 import { $3dCardinalNeighbors } from "../../../Math/CardinalNeighbors";
-import { getMinusOneForRGB, isGreaterOrEqualThanForRGBRemove, isLessThanForRGBAdd, isLessThanForRGBRemove, removeSunLight, } from "./CommonFunctions";
+import { getMinusOneForRGB, isGreaterOrEqualThanForRGBRemove, isLessThanForRGBAdd, isLessThanForRGBRemove, removeRGBLight, } from "./CommonFunctions";
 //@todo change array to not use push and shift
 export function RGBUpdate(tasks) {
     const queue = tasks.rgb.update;
@@ -76,7 +76,7 @@ export function RGBRemove(tasks) {
             }
         }
         tasks.bounds.update(x, y, z);
-        voxel.setLight(removeSunLight(sl));
+        voxel.setLight(removeRGBLight(sl));
     }
     removeMap.clear();
 }

package/Tasks/Propagation/Illumanation/WorldRGB.js

@@ -6,7 +6,7 @@ import { EngineSettings } from "../../../Settings/EngineSettings";
 import { RGBUpdate } from "./RGBUpdate";
 const sectionCursor = new SectionCursor();
 export function WorldRGB(task) {
-    if (!EngineSettings.doLight())
+    if (!EngineSettings.doLight)
         return false;
     const sector = WorldRegister.sectors.get(task.origin[0], task.origin[1], task.origin[2], task.origin[3]);
     if (!sector) {

package/Tasks/Propagation/Illumanation/WorldSun.js

@@ -27,8 +27,10 @@ export function RunWorldSun(tasks) {
         return;
     }
     const minY = AmaxY - 1 < 0 ? 0 : AmaxY;
+    const section = sectorCursor.getSection(cx, minY, cz);
+    const sectionY = section.getPosition()[1] + WorldSpaces.section.bounds.y;
     //fill
-    for (let iy = minY; iy < maxY; iy++) {
+    for (let iy = minY; iy < sectionY; iy++) {
         for (let ix = cx; ix < maxX; ix++) {
             for (let iz = cz; iz < maxZ; iz++) {
                 const voxel = sectorCursor.getVoxel(ix, iy, iz);
@@ -41,6 +43,13 @@ export function RunWorldSun(tasks) {
             }
         }
     }
+    for (let iy = sectionY; iy < maxY; iy += WorldSpaces.section.bounds.y) {
+        const section = sectorCursor.getSection(cx, iy, cz);
+        const length = section.light.length;
+        for (let i = 0; i < length; i++) {
+            section.light[i] = lightData.setS(0xf, section.light[i]);
+        }
+    }
     const maxAcculamteY = AmaxY == RmaxY ? RmaxY + 1 : RmaxY;
     let index = queue.length;
     //accumulate

package/Tasks/Update/VoxelUpdate.js

@@ -9,8 +9,8 @@ import { FlowRemove } from "../Propagation/Flow/FlowRemove.js";
 const tasks = new UpdateTask();
 const substanceData = new SubstanceDataTool();
 const updateLightTask = (tasks) => {
-    let doRGB = ES.doRGBPropagation();
-    let doSun = ES.doSunPropagation();
+    let doRGB = ES.doRGBPropagation;
+    let doSun = ES.doSunPropagation;
     const [dimension, x, y, z] = tasks.origin;
     tasks.nDataCursor.setFocalPoint(dimension, x, y, z);
     for (const n of $3dCardinalNeighbors) {
@@ -39,7 +39,7 @@ export async function EreaseAndUpdate(location) {
     if (!voxel)
         return false;
     substanceData.setSubstance(voxel.getSubstance());
-    if (!voxel.isAir() && ES.doFlow() && voxel.isRenderable()) {
+    if (!voxel.isAir() && ES.doFlow && voxel.isRenderable()) {
         if (substanceData.isLiquid()) {
             FlowRemove(tasks);
             return tasks;
@@ -56,17 +56,17 @@ export async function EreaseAndUpdate(location) {
         .setLevelState(0)
         .setState(0)
         .setMod(0)
-        .updateHeightMap(1);
-    if (ES.doLight()) {
-        if (ES.doRGBPropagation() && isLightSource) {
+        .updateVoxel(1);
+    if (ES.doLight) {
+        if (ES.doRGBPropagation && isLightSource) {
             tasks.rgb.remove.push(x, y, z);
             RGBRemove(tasks);
         }
         updateLightTask(tasks);
-        if (ES.doRGBPropagation()) {
+        if (ES.doRGBPropagation) {
             RGBUpdate(tasks);
         }
-        if (ES.doSunPropagation()) {
+        if (ES.doSunPropagation) {
             SunUpdate(tasks);
         }
     }
@@ -80,9 +80,9 @@ export async function PaintAndUpdate(data) {
         return false;
     const raw = data[1];
     const isOpaque = voxel.isOpaque();
-    let doRGB = ES.doRGBPropagation();
-    let doSun = ES.doSunPropagation();
-    lighttest: if (ES.doLight()) {
+    let doRGB = ES.doRGBPropagation;
+    let doSun = ES.doSunPropagation;
+    lighttest: if (ES.doLight) {
         const light = voxel.getLight();
         if (light <= 0)
             break lighttest;
@@ -104,24 +104,19 @@ export async function PaintAndUpdate(data) {
     if (id < 0)
         return false;
     voxel.setId(id);
-    voxel.setState(raw[2]);
-    const substance = voxel.getSubstance();
-    if (substance > -1 && !voxel.isAir()
-        ? substanceData.setSubstance(voxel.getSubstance()).isLiquid()
-        : false) {
-        voxel.setLevel(7);
-    }
+    voxel.setLevel(raw[2]);
+    voxel.setState(raw[3]);
     voxel.setMod(raw[4]);
     if (raw[3] > 0 && voxel.canHaveSecondaryVoxel()) {
         voxel.setSecondary(true);
-        voxel.setId(raw[3]);
+        voxel.setId(raw[5]);
         voxel.setSecondary(false);
     }
     if (voxel.isLightSource() && voxel.getLightSourceValue()) {
         voxel.setLight(voxel.getLightSourceValue());
     }
-    voxel.updateHeightMap(0);
-    if (ES.doLight()) {
+    voxel.updateVoxel(0);
+    if (ES.doLight) {
         updateLightTask(tasks);
         if (doRGB) {
             tasks.rgb.update.push(x, y, z);
@@ -132,7 +127,7 @@ export async function PaintAndUpdate(data) {
         }
     }
     voxel = tasks.sDataCursor.getVoxel(x, y, z);
-    if (ES.doFlow()) {
+    if (ES.doFlow) {
         if (!voxel.isAir() &&
             substanceData.setSubstance(voxel.getSubstance()).isLiquid()) {
             FlowUpdate(tasks);
@@ -146,9 +141,9 @@ export async function VoxelUpdate(data) {
     const voxel = tasks.sDataCursor.getVoxel(x, y, z);
     if (!voxel)
         return false;
-    let doRGB = ES.doRGBPropagation();
-    let doSun = ES.doSunPropagation();
-    if (ES.doLight()) {
+    let doRGB = ES.doRGBPropagation;
+    let doSun = ES.doSunPropagation;
+    if (ES.doLight) {
         updateLightTask(tasks);
         if (doRGB) {
             tasks.rgb.update.push(x, y, z);
@@ -159,7 +154,7 @@ export async function VoxelUpdate(data) {
             SunUpdate(tasks);
         }
     }
-    if (ES.doFlow()) {
+    if (ES.doFlow) {
         if (substanceData.setSubstance(voxel.getSubstance()).isLiquid()) {
             FlowUpdate(tasks);
         }

package/Templates/Cursor/TemplateVoxelCursor.d.ts

@@ -11,4 +11,5 @@ export declare class TemplateVoxelCursor extends VoxelCursorInterface {
     get mod(): Uint16Array;
     constructor(dataCursor: TemplateCursor);
     loadIn(): void;
+    updateVoxel(mode: 0 | 1): void;
 }

package/Templates/Cursor/TemplateVoxelCursor.js

@@ -31,4 +31,5 @@ export class TemplateVoxelCursor extends VoxelCursorInterface {
         this._index = this.dataCursor._voxelIndex;
         this.process();
     }
+    updateVoxel(mode) { }
 }

package/Textures/TextureBuilder.d.ts

@@ -4,7 +4,7 @@ export declare class TextureBuilder {
     static finalImagWidth: number;
     static finalImageHeight: number;
     static _canvas: HTMLCanvasElement;
-    static defineTextureDimensions(textureSize: number, mipMapSizes: number[]): void;
+    static defineTextureDimensions(textureSize: number): void;
     static setUpImageCreation(): void;
     static createMaterialTexture(name: string, images: Map<string, HTMLImageElement | string | false>, width?: number, height?: number): Promise<HTMLImageElement[]>;
     static getRawData(imageSrc: string): Promise<Uint8ClampedArray>;

package/Textures/TextureBuilder.js

@@ -4,7 +4,7 @@ export class TextureBuilder {
     static finalImagWidth = 16;
     static finalImageHeight = 16;
     static _canvas = document.createElement("canvas");
-    static defineTextureDimensions(textureSize, mipMapSizes) {
+    static defineTextureDimensions(textureSize) {
         this.finalImagWidth = textureSize < 256 ? 256 : textureSize;
         this.finalImageHeight = textureSize < 256 ? 256 : textureSize;
         this._textureSize = textureSize;

package/Textures/TextureManager.js

@@ -17,7 +17,7 @@ export class TextureManager {
         return this._ready;
     }
     static async init() {
-        TextureBuilder.defineTextureDimensions(EngineSettings.settings.textures.textureSize, EngineSettings.settings.textures.mipMapSizes);
+        TextureBuilder.defineTextureDimensions(EngineSettings.settings.textures.textureSize);
         for (const [key, type] of this.textureTypes) {
             await type.build();
         }

package/Tools/Brush/Brush.d.ts

@@ -26,6 +26,7 @@ export declare class BrushTool {
     setLevelState(levelState: number): this;
     setMod(mod: number): this;
     clear(): void;
+    _debug: boolean;
     _paint(): false | undefined;
     _erase(): void;
     paint(): this;

package/Tools/Brush/Brush.js

@@ -102,6 +102,7 @@ export class BrushTool {
         this.y = 0;
         this.z = 0;
     }
+    _debug = false;
     _paint() {
         if (!this.dataCursor.inBounds(this.x, this.y, this.z))
             return false;
@@ -112,7 +113,10 @@ export class BrushTool {
         if (id < 0)
             return false;
         voxel.setId(id);
-        voxel.setState(this.data.state ? this.data.state : 0);
+        if (this._debug) {
+            console.warn(this.x, this.y, this.z, this.data.state);
+        }
+        voxel.setState(this.data.state);
         voxel.setLevel(this.data.level);
         voxel.setMod(this.data.mod);
         if (this.data.secondaryVoxelId) {
@@ -126,19 +130,13 @@ export class BrushTool {
         if (voxel.isLightSource() && voxel.getLightSourceValue()) {
             voxel.setLight(voxel.getLightSourceValue());
         }
-        /*    if (this.voxelCursor.isRich()) {
-          DataHooks.paint.onRichVoxelPaint.notify([
-            this.voxelCursor.getStringId(),
-            [this.dimenion, x, y, z],
-          ]);
-        } */
-        voxel.updateHeightMap(0);
+        voxel.updateVoxel(0);
     }
     _erase() {
         const voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
         if (!voxel)
             return;
-        voxel.copyRaw(air).updateHeightMap(1);
+        voxel.copyRaw(air).updateVoxel(1);
     }
     paint() {
         this._paint();

package/Voxels/Cursor/VoxelCursor.d.ts

@@ -9,4 +9,5 @@ export declare class VoxelCursor extends VoxelCursorInterface {
     secondary: number[];
     mod: number[];
     loadIn(): void;
+    updateVoxel(mode: 0 | 1): void;
 }

package/Voxels/Cursor/VoxelCursor.interface.d.ts

@@ -19,6 +19,11 @@ export declare abstract class VoxelCursorInterface {
     abstract state: WritableArrayLike<number>;
     abstract secondary: WritableArrayLike<number>;
     abstract mod: WritableArrayLike<number>;
+    /**
+     *
+     * @param mode 0 for add 1 for remove
+     */
+    abstract updateVoxel(mode: 0 | 1): void;
     _lightData: VoxelLightData;
     _substanceData: SubstanceDataTool;
     process(): void;

package/Voxels/Cursor/VoxelCursor.interface.js

@@ -2,7 +2,7 @@ import { VoxelStructIds } from "../Types/Voxel.types";
 import { VoxelLightData } from "./VoxelLightData";
 import { MappedDataRegister } from "../../Data/Register/MappedDataRegister";
 import { VoxelStruct } from "../Structs/VoxelStruct";
-import { VoxelStateReader } from "../VoxelStateReader";
+import { VoxelLevelReader } from "../VoxelLevelReader";
 import { VoxelTagStates } from "../State/VoxelTagStates";
 import { VoxelPalette } from "../Palettes/VoxelPalette";
 import { SubstancePalette } from "../Palettes/SubstancePalette";
@@ -84,17 +84,17 @@ export class VoxelCursorInterface {
         return this;
     }
     getLevel() {
-        return VoxelStateReader.getLevel(this.level[this._index]);
+        return VoxelLevelReader.getLevel(this.level[this._index]);
     }
     setLevel(level) {
-        this.level[this._index] = VoxelStateReader.setLevel(this.level[this._index], level);
+        this.level[this._index] = VoxelLevelReader.setLevel(this.level[this._index], level);
         return this;
     }
     getLevelState() {
-        return VoxelStateReader.getLevelState(this.level[this._index]);
+        return VoxelLevelReader.getLevelState(this.level[this._index]);
     }
     setLevelState(state) {
-        this.level[this._index] = VoxelStateReader.setLevelState(this.level[this._index], state);
+        this.level[this._index] = VoxelLevelReader.setLevelState(this.level[this._index], state);
         return this;
     }
     getState() {

package/Voxels/Cursor/VoxelCursor.js

@@ -1,6 +1,6 @@
 import { VoxelCursorInterface } from "./VoxelCursor.interface";
 import { VoxelPalette } from "../../Voxels/Palettes/VoxelPalette";
-import { VoxelStateReader } from "../../Voxels/VoxelStateReader";
+import { VoxelLevelReader } from "../VoxelLevelReader";
 export class VoxelCursor extends VoxelCursorInterface {
     static VoxelDataToRaw(data, light = 0) {
         const id = (data.id !== undefined && VoxelPalette.ids.getNumberId(data.id)) || 0;
@@ -9,9 +9,9 @@ export class VoxelCursor extends VoxelCursorInterface {
             0;
         let levleData = 0;
         if (data.level !== undefined)
-            levleData = VoxelStateReader.setLevel(levleData, data.level);
+            levleData = VoxelLevelReader.setLevel(levleData, data.level);
         if (data.levelState !== undefined)
-            levleData = VoxelStateReader.setLevelState(levleData, data.levelState);
+            levleData = VoxelLevelReader.setLevelState(levleData, data.levelState);
         return [id, light, levleData, data.state || 0, data.mod || 0, secondaryId];
     }
     ids = [0];
@@ -21,4 +21,6 @@ export class VoxelCursor extends VoxelCursorInterface {
     secondary = [0];
     mod = [0];
     loadIn() { }
+    updateVoxel(mode) {
+    }
 }

package/Voxels/VoxelLevelReader.d.ts

@@ -0,0 +1,10 @@
+/**# Voxel Reader
+ * ---
+ * Used to decode voxel state data.
+ */
+export declare class VoxelLevelReader {
+    static getLevel(levelData: number): number;
+    static setLevel(levelData: number, level: number): number;
+    static getLevelState(levelData: number): number;
+    static setLevelState(levelData: number, levelState: number): number;
+}

package/Voxels/VoxelLevelReader.js

@@ -0,0 +1,20 @@
+const LEVEL_MASK = 0b0000_1111;
+const LEVEL_STATE_MASK = 0b1111_0000;
+/**# Voxel Reader
+ * ---
+ * Used to decode voxel state data.
+ */
+export class VoxelLevelReader {
+    static getLevel(levelData) {
+        return levelData & LEVEL_MASK;
+    }
+    static setLevel(levelData, level) {
+        return (levelData & ~LEVEL_MASK) | level;
+    }
+    static getLevelState(levelData) {
+        return (levelData & LEVEL_STATE_MASK) >> 4;
+    }
+    static setLevelState(levelData, levelState) {
+        return (levelData & ~LEVEL_STATE_MASK) | (levelState << 4);
+    }
+}

package/World/Cursor/SectorCursor.d.ts

@@ -13,5 +13,6 @@ export declare class SectorCursor extends DataCursorInterface implements WorldSe
     _sectorPosition: Vector3Like;
     inBounds(x: number, y: number, z: number): boolean;
     setSector(dimension: string, x: number, y: number, z: number): boolean;
+    getSection(x: number, y: number, z: number): Section | null;
     getVoxel(x: number, y: number, z: number): WorldVoxelCursor | null;
 }

package/World/Cursor/SectorCursor.js

@@ -38,7 +38,7 @@ export class SectorCursor extends DataCursorInterface {
         this._sectorPosition.z = sector.position[2];
         return true;
     }
-    getVoxel(x, y, z) {
+    getSection(x, y, z) {
         if (!this._current)
             return null;
         const section = this._current.sections[WorldSpaces.section.getIndex(x, y, z)];
@@ -48,6 +48,12 @@ export class SectorCursor extends DataCursorInterface {
             this._section = null;
             return null;
         }
+        return section;
+    }
+    getVoxel(x, y, z) {
+        if (!this._current)
+            return null;
+        const section = this.getSection(x, y, z);
         this._section = section;
         this._voxelIndex = WorldSpaces.voxel.getIndex(x, y, z);
         WorldSpaces.voxel.getPosition(x, y, z, this._voxelPosition);

package/World/Cursor/WorldVoxelCursor.d.ts

@@ -14,10 +14,6 @@ export declare class WorldVoxelCursor extends VoxelCursorInterface {
     /**
      *
      * @param mode 0 for add 1 for remove
-     * @param x
-     * @param y
-     * @param z
-     * @returns
      */
-    updateHeightMap(mode: 0 | 1): boolean;
+    updateVoxel(mode: 0 | 1): boolean;
 }

package/World/Cursor/WorldVoxelCursor.js

@@ -36,12 +36,8 @@ export class WorldVoxelCursor extends VoxelCursorInterface {
     /**
      *
      * @param mode 0 for add 1 for remove
-     * @param x
-     * @param y
-     * @param z
-     * @returns
      */
-    updateHeightMap(mode) {
+    updateVoxel(mode) {
         Section.StateStruct.setData(this._section.sectionState);
         const voxelPos = this.dataCursor._voxelPosition;
         if (mode == 0) {

package/World/WorldSpaces.d.ts

@@ -8,7 +8,7 @@ declare class WorldBounds {
         MinY: number;
         MaxY: number;
     };
-    static setWorldBounds(minX: number, maxX: number, minZ: number, maxZ: number, minY: number, maxY: number): void;
+    static setWorldBounds(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number): void;
     static inBounds(x: number, y: number, z: number): boolean;
     static getWorldWidth(): number;
     static getWorldDepth(): number;

package/World/WorldSpaces.js

@@ -13,7 +13,7 @@ class WorldBounds {
         MinY: 0,
         MaxY: 256,
     };
-    static setWorldBounds(minX, maxX, minZ, maxZ, minY, maxY) {
+    static setWorldBounds(minX, minY, minZ, maxX, maxY, maxZ) {
         this.bounds.MinX = minX;
         this.bounds.MaxX = maxX;
         this.bounds.MinX = minZ;
@@ -125,16 +125,16 @@ export class WorldSpaces {
 }
 EngineSettings.addEventListener("synced", (event) => {
     const { settings } = event.detail.settings;
-    WorldBounds.setWorldBounds(settings.world.minX, settings.world.maxX, settings.world.minZ, settings.world.maxZ, settings.world.minY, settings.world.maxY);
-    SectorSpace.power2Axes.x = settings.sectors.sectorXPow2;
-    SectorSpace.power2Axes.y = settings.sectors.sectorYPow2;
-    SectorSpace.power2Axes.z = settings.sectors.sectorZPow2;
+    WorldBounds.setWorldBounds(settings.world.min.x, settings.world.min.y, settings.world.min.z, settings.world.max.x, settings.world.max.y, settings.world.max.z);
+    SectorSpace.power2Axes.x = settings.sectors.power2Size.x;
+    SectorSpace.power2Axes.y = settings.sectors.power2Size.y;
+    SectorSpace.power2Axes.z = settings.sectors.power2Size.z;
     SectorSpace.bounds.x = 1 << SectorSpace.power2Axes.x;
     SectorSpace.bounds.y = 1 << SectorSpace.power2Axes.y;
     SectorSpace.bounds.z = 1 << SectorSpace.power2Axes.z;
-    SectionSpace.power2Axes.x = settings.sections.sectionXPow2;
-    SectionSpace.power2Axes.y = settings.sections.sectionYPow2;
-    SectionSpace.power2Axes.z = settings.sections.sectionZPow2;
+    SectionSpace.power2Axes.x = settings.sections.power2Size.x;
+    SectionSpace.power2Axes.y = settings.sections.power2Size.y;
+    SectionSpace.power2Axes.z = settings.sections.power2Size.z;
     SectionSpace.bounds.x = 1 << SectionSpace.power2Axes.x;
     SectionSpace.bounds.y = 1 << SectionSpace.power2Axes.y;
     SectionSpace.bounds.z = 1 << SectionSpace.power2Axes.z;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@divinevoxel/vlox",
-  "version": "0.0.06",
+  "version": "0.0.07",
   "description": "Vlox a block style voxel engine.",
   "main": "index.js",
   "types": "index.d.ts",

package/Voxels/VoxelStateReader.d.ts

@@ -1,12 +0,0 @@
-/**# Voxel Reader
- * ---
- * Used to decode voxel state data.
- */
-export declare class VoxelStateReader {
-    static getLevel(stateData: number): number;
-    static setLevel(stateData: number, level: number): number;
-    static getLevelState(stateData: number): number;
-    static setLevelState(stateData: number, levelState: number): number;
-    static getShapeState(voxelData: number): number;
-    static setShapeState(voxelData: number, shapeState: number): number;
-}

package/Voxels/VoxelStateReader.js

@@ -1,30 +0,0 @@
-var StateMasks;
-(function (StateMasks) {
-    StateMasks[StateMasks["Level"] = 15] = "Level";
-    StateMasks[StateMasks["LevelState"] = 48] = "LevelState";
-    StateMasks[StateMasks["ShapeState"] = 65472] = "ShapeState";
-})(StateMasks || (StateMasks = {}));
-/**# Voxel Reader
- * ---
- * Used to decode voxel state data.
- */
-export class VoxelStateReader {
-    static getLevel(stateData) {
-        return stateData & StateMasks.Level;
-    }
-    static setLevel(stateData, level) {
-        return (stateData & ~StateMasks.Level) | level;
-    }
-    static getLevelState(stateData) {
-        return (stateData & StateMasks.LevelState) >> 4;
-    }
-    static setLevelState(stateData, levelState) {
-        return (stateData & ~StateMasks.LevelState) | (levelState << 4);
-    }
-    static getShapeState(voxelData) {
-        return (voxelData & StateMasks.ShapeState) >> 6;
-    }
-    static setShapeState(voxelData, shapeState) {
-        return (voxelData & ~StateMasks.ShapeState) | (shapeState << 6);
-    }
-}