@divinevoxel/vlox 0.0.71 → 0.0.73

package/Models/Indexing/VoxelAOResultsIndex.d.ts

@@ -1,12 +1,12 @@
 export type VoxelAOResultsIndexData = {
-    buffer: SharedArrayBuffer;
+    buffer: ArrayBufferLike;
     vertexByteCount: number;
 };
 export declare class VoxelAOResultsIndex {
-    data: VoxelAOResultsIndexData;
-    view: DataView;
+    view: Uint8Array;
+    readonly vertexByteCount: number;
     constructor(data: VoxelAOResultsIndexData);
-    getByteIndex(otherId: number, directionIndex: number): number;
     getValue(otherId: number, directionIndex: number, vertexIndex: number): number;
     setValue(otherId: number, directionIndex: number, vertexIndex: number, value?: number): void;
+    getData(): VoxelAOResultsIndexData;
 }

package/Models/Indexing/VoxelAOResultsIndex.js

@@ -1,20 +1,26 @@
 import { BinaryArrays } from "@amodx/binary/Util/BinaryArrays";
 import { VoxelRelativeCubeIndex } from "./VoxelRelativeCubeIndex";
+const flatIndexSize = VoxelRelativeCubeIndex.flatIndex.size;
+function getByteIndex(otherId, directionIndex, vertexByteCount) {
+    return (otherId * vertexByteCount * flatIndexSize + directionIndex * vertexByteCount);
+}
 export class VoxelAOResultsIndex {
-    data;
     view;
+    vertexByteCount;
     constructor(data) {
-        this.data = data;
-        this.view = new DataView(data.buffer);
-    }
-    getByteIndex(otherId, directionIndex) {
-        return (otherId * this.data.vertexByteCount * VoxelRelativeCubeIndex.flatIndex.size +
-            directionIndex * this.data.vertexByteCount);
+        this.vertexByteCount = data.vertexByteCount;
+        this.view = new Uint8Array(data.buffer);
     }
     getValue(otherId, directionIndex, vertexIndex) {
-        return BinaryArrays.getBitArrayIndex(this.view, this.getByteIndex(otherId, directionIndex), vertexIndex);
+        return BinaryArrays.getBitArrayIndex(this.view, getByteIndex(otherId, directionIndex, this.vertexByteCount), vertexIndex);
     }
     setValue(otherId, directionIndex, vertexIndex, value = 1) {
-        BinaryArrays.setBitArrayIndex(this.view, this.getByteIndex(otherId, directionIndex), vertexIndex, value);
+        BinaryArrays.setBitArrayIndex(this.view, getByteIndex(otherId, directionIndex, this.vertexByteCount), vertexIndex, value);
+    }
+    getData() {
+        return {
+            buffer: this.view.buffer,
+            vertexByteCount: this.vertexByteCount,
+        };
     }
 }

package/Models/Indexing/VoxelFaceCullResultsIndex.d.ts

@@ -1,12 +1,12 @@
 export type VoxelFaceCullResultsIndexData = {
-    buffer: SharedArrayBuffer;
+    buffer: ArrayBufferLike;
     faceByteCount: number;
 };
 export declare class VoxelFaceCullResultsIndex {
-    data: VoxelFaceCullResultsIndexData;
     view: Uint16Array;
+    readonly faceByteCount: number;
     constructor(data: VoxelFaceCullResultsIndexData);
-    getByteIndex(otherId: number, directionIndex: number): number;
     getValue(otherId: number, directionIndex: number, faceIndex: number): number;
     setValue(otherId: number, directionIndex: number, faceIndex: number, value?: number): number;
+    getData(): VoxelFaceCullResultsIndexData;
 }

package/Models/Indexing/VoxelFaceCullResultsIndex.js

@@ -1,21 +1,26 @@
 import { VoxelRelativeCubeIndex } from "./VoxelRelativeCubeIndex";
+const flatIndexSize = VoxelRelativeCubeIndex.flatIndex.size;
+function getByteIndex(otherId, directionIndex, faceByteCount) {
+    return (otherId * faceByteCount * flatIndexSize + directionIndex * faceByteCount);
+}
 export class VoxelFaceCullResultsIndex {
-    data;
     view;
+    faceByteCount;
     constructor(data) {
-        this.data = data;
         this.view = new Uint16Array(data.buffer);
-    }
-    getByteIndex(otherId, directionIndex) {
-        return (otherId * this.data.faceByteCount * VoxelRelativeCubeIndex.flatIndex.size +
-            directionIndex * this.data.faceByteCount);
+        this.faceByteCount = data.faceByteCount;
     }
     getValue(otherId, directionIndex, faceIndex) {
-        const v = this.view[this.getByteIndex(otherId, directionIndex) + faceIndex];
+        const v = this.view[getByteIndex(otherId, directionIndex, this.faceByteCount) + faceIndex];
         return v == 65535 ? -1 : v;
     }
     setValue(otherId, directionIndex, faceIndex, value = -1) {
-        return (this.view[this.getByteIndex(otherId, directionIndex) + faceIndex] =
-            value);
+        return (this.view[getByteIndex(otherId, directionIndex, this.faceByteCount) + faceIndex] = value);
+    }
+    getData() {
+        return {
+            buffer: this.view.buffer,
+            faceByteCount: this.faceByteCount,
+        };
     }
 }

package/Models/Indexing/VoxelFaceTransparentResultsIndex.d.ts

@@ -4,7 +4,7 @@ export type VoxelFaceTransparentResultsIndexData = {
 };
 export declare class VoxelFaceTransparentResultsIndex {
     data: VoxelFaceTransparentResultsIndexData;
-    view: DataView;
+    view: Uint8Array;
     constructor(data: VoxelFaceTransparentResultsIndexData);
     getValue(modState: number, faceByteIndex: number, faceIndex: number): number;
     setValue(modState: number, faceByteIndex: number, faceIndex: number, value?: number): void;

package/Models/Indexing/VoxelFaceTransparentResultsIndex.js

@@ -4,7 +4,7 @@ export class VoxelFaceTransparentResultsIndex {
     view;
     constructor(data) {
         this.data = data;
-        this.view = new DataView(data.buffer);
+        this.view = new Uint8Array(data.buffer);
     }
     getValue(modState, faceByteIndex, faceIndex) {
         return BinaryArrays.getBitArrayIndex(this.view, this.data.resultsSize * modState + faceByteIndex, faceIndex);

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)
@@ -179,8 +179,8 @@ export function BuildRules(main, geoPalette) {
         }
     }
     return {
-        aoIndex: aoIndex.data,
-        cullIndex: cullIndex.data,
+        aoIndex: aoIndex.getData(),
+        cullIndex: cullIndex.getData(),
         faceCullMap,
         vertexHitMap,
     };

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;
     }