@divinevoxel/vlox 0.0.72 → 0.0.73

package/Models/Rules/Functions/BuildFinalInputs.js

@@ -1,5 +1,5 @@
 import { VoxelFaceTransparentResultsIndex } from "../../Indexing/VoxelFaceTransparentResultsIndex";
-import { VoxelModelManager } from "../VoxelModelManager";
+import { VoxelModelRuleBuilderRegister } from "../VoxelModelRuleBuilderRegister";
 const isArgString = (data) => {
     if (typeof data !== "string")
         return;
@@ -24,21 +24,22 @@ export function BuildFinalInputs(model) {
                 const geoNodes = [];
                 const shapeStateNodes = model.data.shapeStatesNodes[state];
                 for (const node of shapeStateNodes) {
-                    const geo = VoxelModelManager.getGeomtryFromLink(node);
+                    const geo = VoxelModelRuleBuilderRegister.getGeomtryFromLink(node);
                     if (!geo)
                         throw new Error(`Geometry does not exist`);
                     geo.inputs.resetDefaults();
                     for (const geoArg in node.inputs) {
                         const constructorArg = node.inputs[geoArg];
                         if (isArgString(constructorArg)) {
-                            geo.inputs[geoArg] = modVoxelInput[constructorArg];
+                            geo.inputs[geoArg] =
+                                modVoxelInput[constructorArg.replace("@", "")];
                             continue;
                         }
                         geo.inputs[geoArg] = constructorArg;
                     }
                     geoNodes[model.stateData.geometryLinkPalette[node.id]] =
                         geo.inputs.cloneArgs();
-                    const byteIndex = model.stateData.relativeGeometryByteIndexMap[model.stateData.shapeStateRelativeGeometryMap[model.stateData.shapeStateRecord[state]][VoxelModelManager.geometryPalette.getNumberId(VoxelModelManager.getGeometryLinkId(node))]];
+                    const byteIndex = model.stateData.relativeGeometryByteIndexMap[model.stateData.shapeStateRelativeGeometryMap[model.stateData.shapeStateRecord[state]][VoxelModelRuleBuilderRegister.geometryPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))]];
                     if (geo.data.ogData.doNotBuildRules !== true) {
                         for (let i = 0; i < geo.inputs.faceTransparentIndex.length; i++) {
                             transparentIndex.setValue(modIndex, byteIndex, i, geo.inputs.faceTransparentIndex[i] ? 1 : 0);
@@ -56,20 +57,21 @@ export function BuildFinalInputs(model) {
                 const shapeStateNodes = model.data.shapeStatesConditonalNodes[state];
                 for (let i = 0; i < shapeStateNodes.length; i++) {
                     const node = shapeStateNodes[i];
-                    const geo = VoxelModelManager.getGeomtryFromLink(node);
+                    const geo = VoxelModelRuleBuilderRegister.getGeomtryFromLink(node);
                     if (!geo)
                         throw new Error(`Geometry does not exist`);
                     //   geo.inputs.resetDefaults();
                     for (const geoArg in node.inputs) {
                         const constructorArg = node.inputs[geoArg];
                         if (isArgString(constructorArg)) {
-                            geo.inputs[geoArg] = modVoxelInput[constructorArg];
+                            geo.inputs[geoArg] =
+                                modVoxelInput[constructorArg.replace("@", "")];
                             continue;
                         }
                         geo.inputs[geoArg] = constructorArg;
                     }
                     geoNodes[i] = geo.inputs.cloneArgs();
-                    const byteIndex = model.stateData.relativeGeometryByteIndexMap[model.stateData.condiotnalShapeStateRelativeGeometryMap[model.stateData.condiotnalShapeStateRecord[state]][VoxelModelManager.geometryPalette.getNumberId(VoxelModelManager.getGeometryLinkId(node))]];
+                    const byteIndex = model.stateData.relativeGeometryByteIndexMap[model.stateData.condiotnalShapeStateRelativeGeometryMap[model.stateData.condiotnalShapeStateRecord[state]][VoxelModelRuleBuilderRegister.geometryPalette.getNumberId(VoxelModelRuleBuilderRegister.getGeometryLinkId(node))]];
                     if (geo.data.ogData.doNotBuildRules !== true) {
                         for (let i = 0; i < geo.inputs.faceTransparentIndex.length; i++) {
                             transparentIndex.setValue(modIndex, byteIndex, i, geo.inputs.faceTransparentIndex[i] ? 1 : 0);

package/Models/Rules/Functions/BuildGeomtryInputs.js

@@ -63,6 +63,7 @@ const mapQuadUvs = (uvs, rotation = 0, transform) => {
 export function BuildGeomtryInputs(geomtry) {
     const inputObservers = new Map();
     const onInput = (id, subscribe) => {
+        id = id.replace("@", "");
         let obs = inputObservers.get(id);
         if (!obs) {
             obs = [];
@@ -109,6 +110,7 @@ export function BuildGeomtryInputs(geomtry) {
                         value));
                 }
                 if (isArgString(faceData.transparent)) {
+                    faceTransparentIndex[relativeFaceCount + face] = false;
                     onInput(String(faceData.transparent), (value) => {
                         args[argsIndex][face][BoxVoxelGometryInputs.ArgIndexes.Transparent] = value;
                         faceTransparentIndex[relativeFaceCount + face] = Boolean(value);
@@ -228,15 +230,16 @@ export function BuildGeomtryInputs(geomtry) {
         },
     };
     for (const arg in geomtry.data.ogData.arguments) {
-        const argKey = `@${arg}`;
-        if (!inputObservers.has(argKey))
+        if (!inputObservers.has(arg))
             continue;
-        const obs = inputObservers.get(argKey);
+        const obs = inputObservers.get(arg);
         const data = geomtry.data.ogData.arguments[arg];
-        Object.defineProperty(finalGeoInputs, argKey, {
+        Object.defineProperty(finalGeoInputs, arg, {
             set(value) {
                 if (data.type == "texture") {
-                    value = TextureManager.getTextureIndex(value);
+                    const textureId = value;
+                    value =
+                        TextureManager.getTexture("dve_voxel")?.getTextureIndex(textureId);
                 }
                 for (const func of obs) {
                     func(value);

package/Models/Rules/Functions/BuildRules.js

@@ -1,7 +1,7 @@
 import { VoxelRelativeCubeIndex } from "../../Indexing/VoxelRelativeCubeIndex";
 import { Vector3Like } from "@amodx/math";
 import { VoxelAOResultsIndex } from "../../Indexing/VoxelAOResultsIndex";
-import { VoxelModelManager } from "../VoxelModelManager";
+import { VoxelModelRuleBuilderRegister } from "../VoxelModelRuleBuilderRegister";
 import { VoxelFaceCullResultsIndex } from "../../Indexing/VoxelFaceCullResultsIndex";
 class OcculsionBox {
     p1;
@@ -132,7 +132,7 @@ export function BuildRules(main, geoPalette) {
         faceByteCount: main.faceCount,
     });
     for (let otherNumberId = 0; otherNumberId < geoPalette.size; otherNumberId++) {
-        let other = VoxelModelManager.geometry.get(geoPalette._palette[otherNumberId]);
+        let other = VoxelModelRuleBuilderRegister.geometry.get(geoPalette._palette[otherNumberId]);
         if (other.data.ogData.doNotBuildRules !== undefined)
             continue;
         if (other.id == main.id)

package/Models/Rules/{VoxelModelManager.d.ts → VoxelModelRuleBuilderRegister.d.ts}

@@ -2,7 +2,7 @@ import { StringPalette } from "../../Util/StringPalette";
 import { VoxelGeometryData, VoxelGeometryLinkData, VoxelModelConstructorData, VoxelModelData } from "../VoxelModel.types";
 import { VoxelRuleGeometry } from "./Classes/VoxelRulesGeometry";
 import { VoxelRulesModoel } from "./Classes/VoxelRulesModel";
-export declare class VoxelModelManager {
+export declare class VoxelModelRuleBuilderRegister {
     static geometryPalette: StringPalette;
     static getGeometryLinkId: (node: VoxelGeometryLinkData) => string;
     static voxels: Map<string, {

package/Models/Rules/VoxelModelRuleBuilderRegister.js

@@ -0,0 +1,178 @@
+import { VoxelFaceNameArray } from "../../Math";
+import { StringPalette } from "../../Util/StringPalette";
+import { VoxelRuleGeometry } from "./Classes/VoxelRulesGeometry";
+import { VoxelRulesModoel } from "./Classes/VoxelRulesModel";
+const addGeo = (model, stateId, nodes) => {
+    const registred = [];
+    for (const geoLinkNode of nodes) {
+        const geo = VoxelModelRuleBuilderRegister.geometry.get(geoLinkNode.geometryId);
+        if (!geo)
+            throw new Error(`Geometry ${geoLinkNode.geometryId} is not registered.`);
+        const newId = getGeometryLinkId(geoLinkNode);
+        if (VoxelModelRuleBuilderRegister.geometry.has(newId))
+            continue;
+        registred.push([stateId, newId]);
+        if (!VoxelModelRuleBuilderRegister.geometryPalette.isRegistered(newId))
+            VoxelModelRuleBuilderRegister.geometryPalette.register(newId);
+        const newData = structuredClone(geo.data);
+        for (const node of newData.nodes) {
+            node.tranform = {
+                ...(geoLinkNode.position ? { position: geoLinkNode.position } : {}),
+                ...(geoLinkNode.scale ? { scale: geoLinkNode.scale } : {}),
+                ...(geoLinkNode.rotation ? { rotation: geoLinkNode.rotation } : {}),
+                ...(geoLinkNode.rotationPivot
+                    ? { rotationPivot: geoLinkNode.rotationPivot }
+                    : {}),
+                ...(geoLinkNode.flip ? { flip: geoLinkNode.flip } : {}),
+            };
+        }
+        VoxelModelRuleBuilderRegister.geometry.set(newId, new VoxelRuleGeometry(newId, newData));
+        continue;
+    }
+    return registred;
+};
+const getGeometryLinkId = (node) => {
+    return `${node.geometryId}${node.position ? `-p${node.position.toString()}` : ""}${node.rotation ? `-r${node.rotation.toString()}` : ""}${node.scale ? `-s${node.scale.toString()}` : ""}`.trim();
+};
+export class VoxelModelRuleBuilderRegister {
+    static geometryPalette = new StringPalette();
+    static getGeometryLinkId = getGeometryLinkId;
+    static voxels = new Map();
+    static geometry = new Map();
+    static models = new Map();
+    static registerGeometry(...geometry) {
+        for (const geo of geometry) {
+            if (!this.geometryPalette.isRegistered(geo.id))
+                this.geometryPalette.register(geo.id);
+            const divisor = geo.divisor ? geo.divisor : false;
+            if (divisor) {
+                for (const node of geo.nodes) {
+                    if (node.type == "box") {
+                        let d = node.divisor ? node.divisor : divisor;
+                        node.points[0][0] /= d[0];
+                        node.points[0][1] /= d[1];
+                        node.points[0][2] /= d[2];
+                        node.points[1][0] /= d[0];
+                        node.points[1][1] /= d[1];
+                        node.points[1][2] /= d[2];
+                        for (const faceName of VoxelFaceNameArray) {
+                            const data = node.faces[faceName];
+                            if (Array.isArray(data.uv)) {
+                                data.uv[0] /= d[0];
+                                data.uv[1] /= d[1];
+                                data.uv[2] /= d[0];
+                                data.uv[3] /= d[1];
+                            }
+                        }
+                    }
+                    if (node.type == "quad") {
+                        let d = node.divisor ? node.divisor : divisor;
+                        for (let i = 0; i < 4; i++) {
+                            const point = node.points[i];
+                            point[0] /= d[0];
+                            point[1] /= d[1];
+                            point[2] /= d[2];
+                        }
+                        if (Array.isArray(node.uv)) {
+                            if (Array.isArray(node.uv[0])) {
+                                let uvs = node.uv;
+                                for (let i = 0; i < node.uv.length; i++) {
+                                    uvs[i][0] /= d[0];
+                                    uvs[i][1] /= d[1];
+                                }
+                            }
+                            else {
+                                let uvs = node.uv;
+                                uvs[0] /= d[0];
+                                uvs[1] /= d[1];
+                                uvs[2] /= d[0];
+                                uvs[3] /= d[1];
+                            }
+                        }
+                    }
+                }
+            }
+            this.geometry.set(geo.id, new VoxelRuleGeometry(geo.id, {
+                ogData: geo,
+                id: geo.id,
+                nodes: geo.nodes.map((node) => ({
+                    node,
+                    tranform: {},
+                })),
+            }));
+        }
+    }
+    static getGeomtryFromLink(link) {
+        return this.geometry.get(getGeometryLinkId(link));
+    }
+    static registerModels(...models) {
+        for (const model of models) {
+            const rulesModel = new VoxelRulesModoel(model);
+            this.models.set(model.id, rulesModel);
+            const divisor = model.divisor ? model.divisor : null;
+            if (divisor) {
+                for (const stateId in model.shapeStatesNodes) {
+                    const nodes = model.shapeStatesNodes[stateId];
+                    for (const node of nodes) {
+                        const d = "divisor" in node ? node.divisor : divisor;
+                        if (node.position) {
+                            node.position[0] /= d[0];
+                            node.position[1] /= d[1];
+                            node.position[2] /= d[2];
+                        }
+                        if (node.rotationPivot) {
+                            node.rotationPivot[0] /= d[0];
+                            node.rotationPivot[1] /= d[1];
+                            node.rotationPivot[2] /= d[2];
+                        }
+                    }
+                }
+                for (const stateId in model.shapeStatesConditonalNodes) {
+                    const nodes = model.shapeStatesConditonalNodes[stateId];
+                    for (const node of nodes) {
+                        const d = "divisor" in node ? node.divisor : divisor;
+                        if (node.position) {
+                            node.position[0] /= d[0];
+                            node.position[1] /= d[1];
+                            node.position[2] /= d[2];
+                        }
+                        if (node.rotationPivot) {
+                            node.rotationPivot[0] /= d[0];
+                            node.rotationPivot[1] /= d[1];
+                            node.rotationPivot[2] /= d[2];
+                        }
+                    }
+                }
+                if (model.effects) {
+                    for (const effect of model.effects) {
+                        if (effect.type == "fx-points") {
+                            for (const state in effect.values) {
+                                for (const point of effect.values[state]) {
+                                    point[0] /= divisor[0];
+                                    point[1] /= divisor[1];
+                                    point[2] /= divisor[2];
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            for (const stateId in model.shapeStatesNodes) {
+                const nodes = model.shapeStatesNodes[stateId];
+                addGeo(model, stateId, nodes).forEach((_) => rulesModel.registerShapeState(..._));
+            }
+            for (const stateId in model.shapeStatesConditonalNodes) {
+                const nodes = model.shapeStatesConditonalNodes[stateId];
+                addGeo(model, stateId, nodes).forEach((_) => rulesModel.registerCondiotnalNode(..._));
+            }
+        }
+    }
+    static registerVoxel(id, data) {
+        let voxelModels = this.voxels.get(data.id);
+        if (!voxelModels) {
+            voxelModels = [];
+            this.voxels.set(data.id, voxelModels);
+        }
+        voxelModels.push({ id, data });
+    }
+}

package/Models/VoxelModel.types.d.ts

@@ -22,6 +22,8 @@ export interface VoxelCustomGeomtryNode {
 }
 export interface VoxelBoxGeometryNode {
     type: "box";
+    /**Divisor used for transform of this specific node.*/
+    divisor?: Vec3Array;
     noShade?: boolean;
     points: [start: Vec3Array, end: Vec3Array];
     rotation?: Vec3Array;
@@ -37,6 +39,8 @@ export interface VoxelBoxFaceData {
 }
 export interface VoxelQuadGeometryNode {
     type: "quad";
+    /**Divisor used for transform of this specific node.*/
+    divisor?: Vec3Array;
     doubleSided?: boolean | string;
     points: [p1: Vec3Array, p2: Vec3Array, p3: Vec3Array, p4: Vec3Array];
     transparent?: boolean | string;
@@ -46,6 +50,8 @@ export interface VoxelQuadGeometryNode {
 }
 export interface VoxelTriangleGeometryNode {
     type: "triangle";
+    /**Divisor used for transform of this specific node.*/
+    divisor?: Vec3Array;
     orientation?: 0 | 1;
     doubleSided?: boolean;
     points: [p1: Vec3Array, p2: Vec3Array, p3: Vec3Array];
@@ -91,6 +97,7 @@ export type VoxelGeometryNodes = VoxelCustomGeomtryNode | VoxelBoxGeometryNode |
 export interface VoxelGeometryData {
     id: string;
     nodes: VoxelGeometryNodes[];
+    divisor?: Vec3Array;
     /**
      * If this is set the voxel geometry will not be included in the
      * geometry rules and will be fall back to custom inputs.
@@ -99,7 +106,11 @@ export interface VoxelGeometryData {
     doNotBuildRules?: true;
     arguments: Record<string, VoxelGeometryTextureArgument | VoxelGeometryBoxUVArgument | VoxelGeometryVector3Argument | VoxelGeometryIntArgument | VoxelGeometryBooleanArgument | VoxelGeometryFloatArgument>;
 }
-export interface VoxelGeometryBaseLinkData {
+export interface VoxelGeometryLinkData {
+    id: string;
+    geometryId: string;
+    /**Divisor used for transform of this specific node.*/
+    divisor?: Vec3Array;
     inputs: Record<string, any>;
     scale?: Vec3Array;
     position?: Vec3Array;
@@ -107,12 +118,10 @@ export interface VoxelGeometryBaseLinkData {
     rotationPivot?: Vec3Array;
     flip?: [flipX: 0 | 1, flipY: 0 | 1, flipZ: 0 | 1];
 }
-export interface VoxelGeometryLinkData extends VoxelGeometryBaseLinkData {
-    id: string;
-    geometryId: string;
-}
 export interface VoxelModelData {
     id: string;
+    /**Divisor used all transforms of geometry nodes. */
+    divisor?: Vec3Array;
     arguments: Record<string, VoxelGeometryTextureArgument | VoxelGeometryBoxUVArgument | VoxelGeometryVector3Argument | VoxelGeometryIntArgument | VoxelGeometryBooleanArgument | VoxelGeometryFloatArgument>;
     shapeStateSchema: (VoxelStateStringSchemaData | VoxelStateNumberSchemaData)[];
     effects?: VoxelEffectData[];

package/Renderer/Classes/SectorMesh.d.ts

@@ -4,8 +4,7 @@ export declare class SectorMesh {
     location: LocationData;
     sections: SectionMesh[];
     constructor(location: LocationData);
-    getIndex(y: number): number;
-    getSection(y: number): SectionMesh;
-    addSection(y: number): SectionMesh;
-    removeSection(y: number): false | SectionMesh;
+    getSection(x: number, y: number, z: number): SectionMesh;
+    addSection(x: number, y: number, z: number): SectionMesh;
+    removeSection(x: number, y: number, z: number): false | SectionMesh;
 }

package/Renderer/Classes/SectorMesh.js

@@ -6,24 +6,19 @@ export class SectorMesh {
     constructor(location) {
         this.location = location;
     }
-    getIndex(y) {
-        const ry = y - this.location[2];
-        const index = ry / WorldSpaces.section.bounds.y;
-        return index;
+    getSection(x, y, z) {
+        return this.sections[WorldSpaces.section.getIndex(x, y, z)];
     }
-    getSection(y) {
-        return this.sections[this.getIndex(y)];
-    }
-    addSection(y) {
-        const index = this.getIndex(y);
+    addSection(x, y, z) {
+        const index = WorldSpaces.section.getIndex(x, y, z);
         if (this.sections[index])
             return this.sections[index];
         const section = new SectionMesh(this, index);
         this.sections[index] = section;
         return section;
     }
-    removeSection(y) {
-        const index = this.getIndex(y);
+    removeSection(x, y, z) {
+        const index = WorldSpaces.section.getIndex(x, y, z);
         if (!this.sections[index])
             return false;
         const section = this.sections[index];

package/Renderer/InitTasks.js

@@ -8,16 +8,15 @@ export default function RendererTasks(threads) {
     Threads.registerTask("set-section", (data, origin) => {
         MeshManager.updateSection(data);
         const tranfers = [];
-        for (const comp of data[1]) {
-            if (comp[0] !== 0)
-                continue;
-            for (const mesh of comp[1]) {
-                tranfers.push(mesh[1]);
-                tranfers.push(mesh[2]);
+        if (data[1][0] == 0) {
+            const comp = data[1][1];
+            for (const mesh of comp) {
+                tranfers.push(mesh[1].buffer);
+                tranfers.push(mesh[2].buffer);
             }
         }
         if (!EngineSettings.settings.rendererSettings.cpuBound) {
-            origin.sendMessage(data, tranfers);
+            origin.sendMessage([], tranfers);
         }
     });
     Threads.registerTask("remove-sector", (data) => {

package/Renderer/MeshManager.js

@@ -12,9 +12,9 @@ export class MeshManager {
         if (!sector) {
             sector = MeshRegister.sectors.add(location);
         }
-        let section = sector.getSection(location[2]);
+        let section = sector.getSection(location[1], location[2], location[3]);
         if (!section) {
-            section = sector.addSection(location[2]);
+            section = sector.addSection(location[1], location[2], location[3]);
         }
         added.clear();
         for (const [id, points] of effects) {

package/Renderer/MeshRegister.js

@@ -9,7 +9,7 @@ class Sectors {
             location[0],
             ...WorldSpaces.sector.getPositionVec3Array(location[1], location[2], location[3]),
         ]);
-        dimension.set(WorldSpaces.hash.hashXYZ(location[1], location[2], location[3]), sector);
+        dimension.set(WorldSpaces.hash.hashVec3(WorldSpaces.sector.getPosition(location[1], location[2], location[3])), sector);
         return sector;
     }
     static remove(location) {
@@ -90,3 +90,4 @@ export class MeshRegister {
         this._dimensions.set("main", new Map());
     }
 }
+window.MeshRegister = MeshRegister;

package/Settings/EngineSettings.d.ts

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

package/Settings/EngineSettings.js

@@ -8,11 +8,12 @@ import { TypedEventTarget } from "../Util/TypedEventTarget.js";
 class EngineSettingsClass extends TypedEventTarget {
     enviorment = Environment.isNode() ? "node" : "browser";
     settings = new EngineSettingsData();
+    version = "0.0.72";
     get doSunPropagation() {
-        return this.settings.lighting.autoSunLight == true;
+        return this.settings.lighting.sunLightEnabled == true;
     }
     get doRGBPropagation() {
-        return this.settings.lighting.autoRGBLight == true;
+        return this.settings.lighting.rgbLightEnabled == true;
     }
     get doLight() {
         return this.doRGBPropagation || this.doSunPropagation;
@@ -20,9 +21,6 @@ class EngineSettingsClass extends TypedEventTarget {
     get doFlow() {
         return this.settings.flow.enable;
     }
-    get isClient() {
-        return this.enviorment != "browser";
-    }
     getSettings() {
         return this.settings;
     }

package/Settings/EngineSettings.types.d.ts

@@ -1,18 +1,27 @@
 import { Vector3Like } from "@amodx/math";
+export interface MesherSettingsData {
+}
+export declare class MesherSettingsData {
+    /**Tell the mesher to shade voxel faces with sun light data. Disable if you are using a custom renderering pipeline. */
+    doSunLight: boolean;
+    /**Tell the mesher to use the built in AO system. Disable if you are using a custom renderering pipeline. */
+    doAO: boolean;
+    doColors: boolean;
+}
 export interface RenderSettingsData {
 }
 export declare class RenderSettingsData {
+    /**Set the mode to change how mesh data is generated based on the underlying rendering API. */
     mode: "webgl" | "webgpu";
+    /**If set to try the engine will not try to send vertex buffers to woerks for GC. */
     cpuBound: boolean;
 }
-export interface TextureSettings {
-}
-export declare class TextureSettings {
-    textureSize: number;
-}
 export interface UpdatingSettings {
 }
 export declare class UpdatingSettings {
+    /**Sector sections are marked as dirty so they can be processed later. */
+    dirtyMechanism: boolean;
+    /**Updated sector sections are auto rebuilt */
     autoRebuild: boolean;
 }
 export interface WorldSettings {
@@ -31,34 +40,24 @@ 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;
+    rgbLightEnabled: boolean;
+    sunLightEnabled: boolean;
 }
 export declare class EngineSettingsData {
+    mesher: MesherSettingsData;
     rendererSettings: RenderSettingsData;
-    textures: TextureSettings;
     updating: UpdatingSettings;
     world: WorldSettings;
     sectors: SectorSettings;
     sections: SectionSettings;
-    voxels: VoxelSettings;
     flow: FlowSettings;
     lighting: LightingSettings;
 }

package/Settings/EngineSettings.types.js

@@ -1,13 +1,22 @@
 import { Vector3Like } from "@amodx/math";
+export class MesherSettingsData {
+    /**Tell the mesher to shade voxel faces with sun light data. Disable if you are using a custom renderering pipeline. */
+    doSunLight = true;
+    /**Tell the mesher to use the built in AO system. Disable if you are using a custom renderering pipeline. */
+    doAO = true;
+    doColors = true;
+}
 export class RenderSettingsData {
+    /**Set the mode to change how mesh data is generated based on the underlying rendering API. */
     mode = "webgl";
+    /**If set to try the engine will not try to send vertex buffers to woerks for GC. */
     cpuBound = false;
 }
-export class TextureSettings {
-    textureSize = 16;
-}
 export class UpdatingSettings {
-    autoRebuild = true;
+    /**Sector sections are marked as dirty so they can be processed later. */
+    dirtyMechanism = true;
+    /**Updated sector sections are auto rebuilt */
+    autoRebuild = false;
 }
 export class WorldSettings {
     min = Vector3Like.Create(-Number.MAX_SAFE_INTEGER, 0, -Number.MAX_SAFE_INTEGER);
@@ -19,28 +28,20 @@ export class SectorSettings {
 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;
+    rgbLightEnabled = true;
+    sunLightEnabled = true;
 }
 export class EngineSettingsData {
+    mesher = new MesherSettingsData();
     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

@@ -1,5 +1,5 @@
 import { Thread, ThreadPool } from "@amodx/threads";
-import { WorldStorageInterface } from "../../World/Storage/WorldStorage.interface";
+import { WorldStorageInterface } from "../../World/Types/WorldStorage.interface";
 import { Generator, GeneratorData } from "./Internal/Classes/Generator";
 import { InitalLoad } from "./Procedures/InitalLoad";
 import SaveAllSectors from "./Procedures/SaveAllSectors";
@@ -23,6 +23,7 @@ export declare class IWG {
     static createGenerator(data: Partial<GeneratorData>): Generator;
     static addGenerator(generator: Generator): void;
     static removeGenerator(generator: Generator): boolean;
+    static tick(): void;
     static update(): void;
 }
 export {};