@divinevoxel/vlox 0.0.74 → 0.0.75

package/Mesher/Models/Nodes/VoxelGeometryConstructor.js

@@ -1,68 +1,32 @@
-import { VoxelFaceCullResultsIndex } from "../../../Models/Indexing/VoxelFaceCullResultsIndex";
-import { VoxelAOResultsIndex } from "../../../Models/Indexing/VoxelAOResultsIndex";
-import { BoxVoxelGometryNode } from "./Ruled/BoxVoxelGeometryNode";
-import { QuadVoxelGometryNode } from "./Ruled/QuadVoxelGeometryNode";
-import { RulelessQuadVoxelGeometryNode } from "./Ruleless/RulelessQuadVoxelGeometryNode";
-import { RulelessBoxVoxelGeometryNode } from "./Ruleless/RulelessBoxVoxelGeometryNode";
+import { QuadVoxelGometryNode } from "./Default/QuadVoxelGeometryNode";
+import { TriangleVoxelGeometryNode } from "./Default/TriangleVoxelGeometryNode";
 import { VoxelModelConstructorRegister } from "../VoxelModelConstructorRegister";
 export class VoxelGeometryConstructor {
     geometryPaletteId;
     nodes = [];
-    faceCullMap;
-    vertexHitMap;
-    cullIndex;
-    aoIndex;
+    cullingProcedure;
     constructor(geometryPaletteId, data) {
         this.geometryPaletteId = geometryPaletteId;
+        this.cullingProcedure = data.cullingProcedure;
         for (const node of data.nodes) {
-            if (node.node.type == "custom") {
-                const nodeClass = VoxelModelConstructorRegister.getCustomNode(node.node.id);
-                const newNode = new nodeClass(geometryPaletteId, this, node.node, node.tranform);
+            if (node.type == "custom") {
+                const nodeClass = VoxelModelConstructorRegister.getCustomNode(node.id);
+                const newNode = new nodeClass(geometryPaletteId, this, node);
                 newNode.init();
                 this.nodes.push(newNode);
             }
         }
-        if (data?.ruleless) {
-            data = data;
-            for (const node of data.nodes) {
-                if (node.node.type == "box") {
-                    const newNode = new RulelessBoxVoxelGeometryNode(geometryPaletteId, this, node.node, node.tranform);
-                    newNode.init();
-                    this.nodes.push(newNode);
-                }
-                if (node.node.type == "quad") {
-                    const newNode = new RulelessQuadVoxelGeometryNode(geometryPaletteId, this, node.node, node.tranform);
-                    newNode.init();
-                    this.nodes.push(newNode);
-                }
+        for (const node of data.nodes) {
+            if (node.type == "quad") {
+                const newNode = new QuadVoxelGometryNode(geometryPaletteId, this, node);
+                newNode.init();
+                this.nodes.push(newNode);
             }
-        }
-        else {
-            data = data;
-            this.faceCullMap = data.faceCullMap;
-            this.vertexHitMap = data.vertexHitMap;
-            this.cullIndex = new VoxelFaceCullResultsIndex(data.cullIndex);
-            this.aoIndex = new VoxelAOResultsIndex(data.aoIndex);
-            for (const node of data.nodes) {
-                if (node.node.type == "box") {
-                    const newNode = new BoxVoxelGometryNode(geometryPaletteId, this, node.node, node.tranform);
-                    newNode.init();
-                    this.nodes.push(newNode);
-                }
-                if (node.node.type == "quad") {
-                    const newNode = new QuadVoxelGometryNode(geometryPaletteId, this, node.node, node.tranform);
-                    newNode.init();
-                    this.nodes.push(newNode);
-                }
+            if (node.type == "triangle") {
+                const newNode = new TriangleVoxelGeometryNode(geometryPaletteId, this, node);
+                newNode.init();
+                this.nodes.push(newNode);
             }
         }
-        let faceCount = 0;
-        let vertexCount = 0;
-        for (const node of this.nodes) {
-            node.faceIndex = faceCount;
-            node.vertexIndex = vertexCount;
-            faceCount += node.faceCount;
-            vertexCount += node.vertexCount;
-        }
     }
 }

package/Mesher/Models/Procedures/Default/ConsistentRotationTextureProcedure.d.ts

@@ -0,0 +1,25 @@
+import { Vec3Array, Vector4Like } from "@amodx/math";
+import type { Quad } from "../../../Geomtry";
+import { VoxelModelBuilder } from "Mesher/Models/VoxelModelBuilder";
+import { TextureProcedure, BaseVoxelGeomtryTextureProcedureData } from "../TextureProcedure";
+import { TextureId } from "Textures";
+import { VoxelFaces } from "Math";
+/**
+ * Extend your data type so we can add a seed if we want, and define
+ * the rotations we can choose from.
+ */
+interface VoxelGeometryConsistentRotationTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
+    type: "consistent-rotation";
+    texture: TextureId | number;
+    /**
+     * You can allow (0 | 90 | 180 | 270), or remove 0 if you don’t want an unrotated option
+     */
+    rotations: (0 | 90 | 180 | 270)[];
+    rotationBounds?: Vec3Array;
+}
+export declare class ConsistentRotationTextureProcedure extends TextureProcedure<VoxelGeometryConsistentRotationTextureProcedureData> {
+    getTexture(builder: VoxelModelBuilder, data: VoxelGeometryConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): number;
+    getOverlayTexture(builder: VoxelModelBuilder, data: VoxelGeometryConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad, ref: Vector4Like): Vector4Like;
+    transformUVs(builder: VoxelModelBuilder, data: VoxelGeometryConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): void;
+}
+export {};

package/Mesher/Models/Procedures/Default/ConsistentRotationTextureProcedure.js

@@ -0,0 +1,44 @@
+import { Vector3Like } from "@amodx/math";
+import { TextureProcedure, } from "../TextureProcedure";
+import { WorldSpaces } from "../../../../World/WorldSpaces";
+import { GetYXZOrderArrayIndex } from "../../../../Math/Indexing";
+const voxelPos = Vector3Like.Create();
+const defaultBounds = [4, 4, 4];
+export class ConsistentRotationTextureProcedure extends TextureProcedure {
+    getTexture(builder, data, closestFace, primitive) {
+        return data.texture;
+    }
+    getOverlayTexture(builder, data, closestFace, primitive, ref) {
+        return ref;
+    }
+    transformUVs(builder, data, closestFace, primitive) {
+        const bounds = data.rotationBounds ? data.rotationBounds : defaultBounds;
+        WorldSpaces.voxel.getPositionFromIndex(builder.voxel._index, voxelPos);
+        const x = voxelPos.x - Math.floor(voxelPos.x / bounds[0]) * bounds[0];
+        const y = voxelPos.y - Math.floor(voxelPos.y / bounds[1]) * bounds[1];
+        const z = voxelPos.z - Math.floor(voxelPos.z / bounds[2]) * bounds[2];
+        const rotationIndex = GetYXZOrderArrayIndex(x, y, z, ...bounds) % data.rotations.length;
+        const rotation = data.rotations[rotationIndex];
+        for (const v of primitive.uvs.vertices) {
+            const oldX = v.x;
+            const oldY = v.y;
+            switch (rotation) {
+                case 90:
+                    v.x = 1 - oldY;
+                    v.y = oldX;
+                    break;
+                case 180:
+                    v.x = 1 - oldX;
+                    v.y = 1 - oldY;
+                    break;
+                case 270:
+                    v.x = oldY;
+                    v.y = 1 - oldX;
+                    break;
+                case 0:
+                default:
+                    break;
+            }
+        }
+    }
+}

package/Mesher/Models/Procedures/Default/OutlinedTextureProcedure.d.ts

@@ -0,0 +1,28 @@
+import { Vector4Like } from "@amodx/math";
+import type { Quad } from "../../../Geomtry";
+import { VoxelModelBuilder } from "Mesher/Models/VoxelModelBuilder";
+import { TextureProcedure, BaseVoxelGeomtryTextureProcedureData } from "../TextureProcedure";
+import { TextureId } from "Textures";
+import { VoxelFaces } from "../../../../Math/index.js";
+interface OutlinedTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
+    type: "outlined";
+    texture: TextureId | number;
+    textureRecrod: {
+        top: TextureId | number;
+        "corner-top-right": TextureId | number;
+        "corner-top-left": TextureId | number;
+        "corner-top-left-top-right": TextureId | number;
+        bottom: TextureId | number;
+        "corner-bottom-right": TextureId | number;
+        "corner-bottom-left": TextureId | number;
+        "corner-bottom-left-bottom-right": TextureId | number;
+        right: TextureId | number;
+        left: TextureId | number;
+    };
+}
+export declare class OutlinedTextureProcedure extends TextureProcedure<OutlinedTextureProcedureData> {
+    getTexture(builder: VoxelModelBuilder, data: OutlinedTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): number;
+    getOverlayTexture(builder: VoxelModelBuilder, data: OutlinedTextureProcedureData, closestFace: VoxelFaces, primitive: Quad, ref: Vector4Like): Vector4Like;
+    transformUVs(builder: VoxelModelBuilder, data: OutlinedTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): void;
+}
+export {};

package/Mesher/Models/Procedures/Default/OutlinedTextureProcedure.js

@@ -0,0 +1,162 @@
+import { TextureProcedure } from "../TextureProcedure";
+import { VoxelFaces } from "../../../../Math/index.js";
+const textureMap = [
+    "top",
+    "corner-top-right",
+    "corner-top-left",
+    "corner-top-left-top-right",
+    "bottom",
+    "corner-bottom-right",
+    "corner-bottom-left",
+    "corner-bottom-left-bottom-right",
+    "right",
+    "left",
+];
+/*
+0 -> normal direction
+1 -> top right
+2 -> top left
+*/
+const uvsSets = {
+    //top bottom faces
+    north: {
+        0b0: 0,
+        0b101: 1,
+        0b011: 2,
+        0b001: 3,
+    },
+    south: {
+        0b0: 4,
+        0b101: 5,
+        0b011: 6,
+        0b001: 7,
+    },
+    east: {
+        0b0: 8,
+    },
+    west: {
+        0b0: 9,
+    },
+    //side faces
+    top: {
+        0b0: 0,
+        0b101: 1,
+        0b011: 2,
+        0b001: 3,
+    },
+    bottom: {
+        0b0: 4,
+        0b101: 5,
+        0b011: 6,
+        0b001: 7,
+    },
+    right: {
+        0b0: 8,
+    },
+    left: {
+        0b0: 9,
+    },
+};
+const topAndDown = {
+    north: [
+        [0, 0, 1],
+        [1, 0, 1],
+        [-1, 0, 1],
+    ],
+    south: [
+        [0, 0, -1],
+        [1, 0, -1],
+        [-1, 0, -1],
+    ],
+    east: [[1, 0, 0]],
+    west: [[-1, 0, 0]],
+};
+const eastAndWest = {
+    top: [
+        [0, 1, 0],
+        [0, 1, 1],
+        [0, 1, -1],
+    ],
+    bottom: [
+        [0, -1, 0],
+        [0, -1, 1],
+        [0, -1, -1],
+    ],
+    right: [[0, 0, 1]],
+    left: [[0, 0, -1]],
+};
+const northAndSouth = {
+    top: [
+        [0, 1, 0],
+        [1, 1, 0],
+        [-1, 1, 0],
+    ],
+    bottom: [
+        [0, -1, 0],
+        [1, -1, 0],
+        [-1, -1, 0],
+    ],
+    right: [[1, 0, 0]],
+    left: [[-1, 0, 0]],
+};
+const CheckSets = {
+    [VoxelFaces.Up]: topAndDown,
+    [VoxelFaces.Down]: topAndDown,
+    [VoxelFaces.North]: northAndSouth,
+    [VoxelFaces.South]: northAndSouth,
+    [VoxelFaces.East]: eastAndWest,
+    [VoxelFaces.West]: eastAndWest,
+};
+const generateCheck = (direction, tool, normal, sets) => {
+    const { x, y, z } = tool.position;
+    let key = 0b0;
+    for (let i = 0; i < sets.length; i++) {
+        const set = sets[i];
+        const cx = x + set[0];
+        const cy = y + set[1];
+        const cz = z + set[2];
+        const sameLevelCheck = tool.nVoxel
+            .getVoxel(cx, cy, cz)
+            ?.isSameVoxel(tool.voxel);
+        let normalCheck = true;
+        const nVoxel = tool.nVoxel.getVoxel(cx + normal[0], cy + normal[1], cz + normal[2]);
+        if (nVoxel && nVoxel.isRenderable() && nVoxel.isOpaque()) {
+            normalCheck = false;
+        }
+        if (sameLevelCheck && normalCheck) {
+            key |= 0b1 << i;
+        }
+        else {
+            key |= 0b0 << i;
+            if (i == 0)
+                break;
+        }
+    }
+    if (uvsSets[direction][key] == undefined)
+        return 0;
+    const index = uvsSets[direction][key];
+    return textureMap[index];
+};
+const normal = [0, 0, 0];
+export class OutlinedTextureProcedure extends TextureProcedure {
+    getTexture(builder, data, closestFace, primitive) {
+        return data.texture;
+    }
+    getOverlayTexture(builder, data, closestFace, primitive, ref) {
+        const set = CheckSets[closestFace];
+        const x = generateCheck("north", builder, normal, set.north);
+        if (x)
+            ref.x = data.textureRecrod[x];
+        const y = generateCheck("south", builder, normal, set.south);
+        if (y)
+            ref.y = data.textureRecrod[y];
+        const z = generateCheck("east", builder, normal, set.east);
+        if (z)
+            ref.z = data.textureRecrod[z];
+        const w = generateCheck("west", builder, normal, set.west);
+        if (w)
+            ref.w = data.textureRecrod[w];
+        return ref;
+    }
+    transformUVs(builder, data, closestFace, primitive) { }
+}

package/Mesher/Models/Procedures/TextureProcedure.d.ts

@@ -0,0 +1,16 @@
+import { Vector4Like } from "@amodx/math";
+import { Quad, Triangle } from "../../Geomtry";
+import { VoxelModelBuilder } from "../VoxelModelBuilder";
+import { VoxelFaces } from "../../../Math";
+import { TextureId } from "../../../Textures";
+export interface BaseVoxelGeomtryTextureProcedureData {
+    type: string;
+    texture?: TextureId | number;
+    textureRecrod?: Record<string, TextureId | number>;
+    [key: string]: any;
+}
+export declare abstract class TextureProcedure<Data = any> {
+    abstract getTexture(builder: VoxelModelBuilder, data: Data, closestFace: VoxelFaces, primitive: Quad | Triangle): number;
+    abstract getOverlayTexture(builder: VoxelModelBuilder, data: Data, closestFace: VoxelFaces, primitive: Quad | Triangle, ref: Vector4Like): Vector4Like;
+    abstract transformUVs(builder: VoxelModelBuilder, data: Data, closestFace: VoxelFaces, primitive: Quad | Triangle): void;
+}

package/Mesher/Models/Procedures/TextureProcedure.js

@@ -0,0 +1,2 @@
+export class TextureProcedure {
+}

package/Mesher/Models/Procedures/TextureProcedureRegister.d.ts

@@ -0,0 +1,6 @@
+import { TextureProcedure } from "./TextureProcedure";
+export declare class TextureProcedureRegister {
+    static procedures: Map<string, TextureProcedure<any>>;
+    static register(id: string, procedure: TextureProcedure): void;
+    static get(id: string): TextureProcedure<any>;
+}

package/Mesher/Models/Procedures/TextureProcedureRegister.js

@@ -0,0 +1,16 @@
+import { ConsistentRotationTextureProcedure } from "./Default/ConsistentRotationTextureProcedure";
+import { OutlinedTextureProcedure } from "./Default/OutlinedTextureProcedure";
+export class TextureProcedureRegister {
+    static procedures = new Map();
+    static register(id, procedure) {
+        this.procedures.set(id, procedure);
+    }
+    static get(id) {
+        const procedure = this.procedures.get(id);
+        if (!procedure)
+            throw new Error(`Procedure with id ${id} does not exist`);
+        return procedure;
+    }
+}
+TextureProcedureRegister.register("consistent-rotation", new ConsistentRotationTextureProcedure());
+TextureProcedureRegister.register("outlined", new OutlinedTextureProcedure());

package/Mesher/Models/VoxelConstructor.d.ts

@@ -1,8 +1,7 @@
 import { VoxelModelBuilder } from "./VoxelModelBuilder";
-import { CompiledVoxelModelInputData, CompiledVoxelModelData } from "../../Voxels/Types/VoxelModelCompiledData.types";
+import { CompiledVoxelModelInputData, CompiledVoxelModelData } from "../../Voxels/Models/CompiledVoxelModel.types";
 import { StateSchema } from "../../Voxels/State/Schema/StateSchema";
 import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
-import { VoxelFaceTransparentResultsIndex } from "../../Models/Indexing/VoxelFaceTransparentResultsIndex";
 import { VoxelModelEffect } from "./VoxelModelEffect";
 import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
 export declare class VoxelConstructor {
@@ -13,7 +12,6 @@ export declare class VoxelConstructor {
     geometries: number[][];
     modSchema: StateSchema;
     modTree: StateTreeReader;
-    transparentIndex: VoxelFaceTransparentResultsIndex;
     baseInputMap: any[];
     conditonalInputMap: any[];
     schema: StateSchema;
@@ -21,7 +19,5 @@ export declare class VoxelConstructor {
     stateTree: StateTreeReader;
     condtioanlShapeStateTree: CondtionalTreeReader;
     constructor(id: string, builder: VoxelModelBuilder, data: CompiledVoxelModelData, voxleData: CompiledVoxelModelInputData);
-    isShapeStateFaceTransparent(modState: number, stateTree: number, geoId: number, faceIndex: number): boolean;
-    isCondtionalStateFaceTransparent(modState: number, state: number, geoId: number, faceIndex: number): boolean;
     process(): boolean;
 }

package/Mesher/Models/VoxelConstructor.js

@@ -1,7 +1,6 @@
 import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
 import { StateSchema } from "../../Voxels/State/Schema/StateSchema";
 import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
-import { VoxelFaceTransparentResultsIndex } from "../../Models/Indexing/VoxelFaceTransparentResultsIndex";
 import { VoxelModelEffect } from "./VoxelModelEffect";
 import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
 export class VoxelConstructor {
@@ -12,7 +11,6 @@ export class VoxelConstructor {
     geometries = [];
     modSchema;
     modTree;
-    transparentIndex;
     baseInputMap;
     conditonalInputMap;
     schema;
@@ -25,7 +23,6 @@ export class VoxelConstructor {
         this.data = data;
         this.baseInputMap = voxleData.baseGeometryInputMap;
         this.conditonalInputMap = voxleData.condiotnalGeometryInputMap;
-        this.transparentIndex = new VoxelFaceTransparentResultsIndex(voxleData.transparentFaceIndex);
         this.schema = new StateSchema(data.schema);
         this.stateTree = new StateTreeReader(this.schema, 0, data.stateTree);
         this.condtioanlShapeStateTree = new CondtionalTreeReader(this.schema, data.condiotnalStatements, data.condiotnalStateTree);
@@ -33,12 +30,6 @@ export class VoxelConstructor {
         this.modTree = new StateTreeReader(this.modSchema, 0, voxleData.modStateTree);
         this.effects = new VoxelModelEffect(this);
     }
-    isShapeStateFaceTransparent(modState, stateTree, geoId, faceIndex) {
-        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.stateRelativeGeometryMap[stateTree][geoId]], faceIndex) == 1);
-    }
-    isCondtionalStateFaceTransparent(modState, state, geoId, faceIndex) {
-        return (this.transparentIndex.getValue(modState, this.data.relativeGeometryByteIndexMap[this.data.condiotnalShapeStateRelativeGeometryMap[state][geoId]], faceIndex) == 1);
-    }
     process() {
         let added = false;
         const builder = this.builder;
@@ -73,9 +64,8 @@ export class VoxelConstructor {
                 const geometriesLength = geometries.length;
                 const inputs = this.conditonalInputMap[modState][c];
                 for (let i = 0; i < geometriesLength; i++) {
-                    const nodeId = geometries[i];
                     const geoInputs = inputs[i];
-                    const geomtry = VoxelModelConstructorRegister.geometry[this.data.geoLinkMap[nodeId]];
+                    const geomtry = VoxelModelConstructorRegister.geometry[geometries[i]];
                     const nodesLength = geomtry.nodes.length;
                     for (let k = 0; k < nodesLength; k++) {
                         const geo = geomtry.nodes[k];

package/Mesher/Models/VoxelGeometryBuilderCacheSpace.js

@@ -48,7 +48,7 @@ export class VoxelGeometryBuilderCacheSpace {
     getConditionalGeomtry(index) {
         if (this.foundHash[index] < 2)
             return null;
-        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.condiotnalShapeStateGeometryMap[this.conditonalStateCache[index]];
+        return VoxelModelConstructorRegister.constructorsPaltte[this.voxelCache[index]].data.condiotanlGeometryStatePalette[this.conditonalStateCache[index]];
     }
     getHash(dataCursor, x, y, z) {
         const hashed = this.getIndex(x, y, z);
@@ -67,7 +67,7 @@ export class VoxelGeometryBuilderCacheSpace {
             this.foundHash[index] = 1;
             return;
         }
-        const voxelId = voxel.getId();
+        const voxelId = voxel.getVoxelId();
         const voxelConstructor = VoxelModelConstructorRegister.constructorsPaltte[voxelId];
         if (!voxelConstructor) {
             this.foundHash[index] = 1;

package/Mesher/Models/VoxelModelBuilder.d.ts

@@ -8,7 +8,6 @@ import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface.
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface.js";
 import { VoxelGeometryBuilderCacheSpace } from "./VoxelGeometryBuilderCacheSpace";
 declare class VoxelVars {
-    faceFlipped: boolean;
     textureIndex: number;
     overlayTextures: Vector4Like;
     light: QuadScalarVertexData;

package/Mesher/Models/VoxelModelBuilder.js

@@ -7,7 +7,6 @@ import calculateFaceData from "./Common/Calc/FaceDataCalc.js";
 import { VoxelMesh } from "../Geomtry/VoxelMesh";
 import { Vector3Like, Vector4Like } from "@amodx/math";
 class VoxelVars {
-    faceFlipped = false;
     textureIndex = 0;
     overlayTextures = Vector4Like.Create();
     light = new QuadScalarVertexData();
@@ -15,11 +14,11 @@ class VoxelVars {
     animation = new QuadScalarVertexData();
     level = new QuadScalarVertexData();
     reset() {
-        this.faceFlipped = false;
         this.textureIndex = 0;
         this.overlayTextures.x = 0;
         this.overlayTextures.y = 0;
         this.overlayTextures.z = 0;
+        this.overlayTextures.w = 0;
     }
 }
 export class VoxelModelBuilder {

package/Mesher/Models/VoxelModelConstructorRegister.d.ts

@@ -1,12 +1,18 @@
 import { StringPalette } from "../../Util/StringPalette";
-import { CompiledVoxelGeometryRulessData, CompiledVoxelGeometrySyncData, CompiledVoxelModelData } from "../../Voxels/Types/VoxelModelCompiledData.types";
+import { CompiledVoxelGeometrySyncData, CompiledVoxelModelData } from "../../Voxels/Models/CompiledVoxelModel.types";
 import { GeoemtryNodeConstructor } from "./Nodes/GeometryNode";
 import { VoxelConstructor } from "./VoxelConstructor";
 import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
+import { AOOcclusionFaceIndex } from "../../Voxels/Models/Indexing/AOOcclusionFaceIndex";
+import { CulledOcclusionFaceIndex } from "../../Voxels/Models/Indexing/CulledOcclusionFaceIndex";
 export declare class VoxelModelConstructorRegister {
     static geometryPalette: StringPalette;
     static geometry: VoxelGeometryConstructor[];
     static rulesless: boolean[];
+    static aoIndex: AOOcclusionFaceIndex;
+    static faceCullIndex: CulledOcclusionFaceIndex;
+    static vertexHitMap: number[][][];
+    static faceCullMap: number[][];
     static setGeometryPalette(palette: string[]): void;
     static modelData: Map<string, CompiledVoxelModelData>;
     static customNodes: Map<string, GeoemtryNodeConstructor<any, any>>;
@@ -17,5 +23,5 @@ export declare class VoxelModelConstructorRegister {
     static constructors: Map<string, VoxelConstructor>;
     static getConstructor(id: string): VoxelConstructor;
     static registerVoxel(voxel: VoxelConstructor | VoxelConstructor[]): void;
-    static registerGeometry(geometries: (CompiledVoxelGeometrySyncData | CompiledVoxelGeometryRulessData)[]): void;
+    static registerGeometry(geometries: CompiledVoxelGeometrySyncData[]): void;
 }

package/Mesher/Models/VoxelModelConstructorRegister.js

@@ -5,6 +5,10 @@ export class VoxelModelConstructorRegister {
     static geometryPalette;
     static geometry = [];
     static rulesless = [];
+    static aoIndex;
+    static faceCullIndex;
+    static vertexHitMap;
+    static faceCullMap;
     static setGeometryPalette(palette) {
         this.geometryPalette = new StringPalette(palette);
     }
@@ -31,23 +35,17 @@ export class VoxelModelConstructorRegister {
         if (Array.isArray(voxel)) {
             for (const vox of voxel) {
                 this.constructors.set(vox.id, vox);
-                this.constructorsPaltte[VoxelPalettesRegister.voxels.getNumberId(vox.id)] = vox;
+                this.constructorsPaltte[VoxelPalettesRegister.voxelIds.getNumberId(vox.id)] = vox;
             }
             return;
         }
-        this.constructorsPaltte[VoxelPalettesRegister.voxels.getNumberId(voxel.id)] = voxel;
+        this.constructorsPaltte[VoxelPalettesRegister.voxelIds.getNumberId(voxel.id)] = voxel;
         this.constructors.set(voxel.id, voxel);
     }
     static registerGeometry(geometries) {
         for (const geometry of geometries) {
             const paletteId = this.geometryPalette.getNumberId(geometry.id);
             this.geometry[paletteId] = new VoxelGeometryConstructor(paletteId, geometry);
-            if (geometry.ruleless == true) {
-                this.rulesless[paletteId] = true;
-            }
-            else {
-                this.rulesless[paletteId] = false;
-            }
         }
     }
 }

package/Renderer/Classes/SectionMesh.d.ts

@@ -2,11 +2,10 @@ import { VoxelEffect } from "../../Voxels/Effects/VoxelEffect";
 import { SectorMesh } from "./SectorMesh";
 import { Vec3Array } from "@amodx/math";
 export declare class SectionMesh {
-    sector: SectorMesh;
-    index: number;
     meshes: Map<string, any>;
     effects: Map<string, VoxelEffect>;
-    constructor(sector: SectorMesh, index: number);
+    sector: SectorMesh;
+    index: number;
     getPosition(): Vec3Array;
     dispose(): void;
 }

package/Renderer/Classes/SectionMesh.js

@@ -1,23 +1,26 @@
 import { WorldSpaces } from "../../World/WorldSpaces";
+import { MeshManager } from "../MeshManager";
 export class SectionMesh {
-    sector;
-    index;
     meshes = new Map();
     effects = new Map();
-    constructor(sector, index) {
-        this.sector = sector;
-        this.index = index;
-    }
+    sector;
+    index = 0;
     getPosition() {
         return [
-            this.sector.location[1],
-            this.sector.location[1] + WorldSpaces.section.bounds.y * this.index,
-            this.sector.location[2],
+            this.sector.position[0],
+            this.sector.position[1] + WorldSpaces.section.bounds.y * this.index,
+            this.sector.position[2],
         ];
     }
     dispose() {
-        for (const [key, effect] of this.effects) {
+        MeshManager._sectionPool.push(this);
+        for (const [, mesh] of this.meshes) {
+            MeshManager.sectorMeshes.returnMesh(mesh);
+        }
+        this.meshes.clear();
+        for (const [, effect] of this.effects) {
             effect.dispose();
         }
+        this.effects.clear();
     }
 }

package/Renderer/Classes/SectorMesh.d.ts

@@ -1,10 +1,10 @@
-import { LocationData } from "../../Math";
 import { SectionMesh } from "./SectionMesh";
+import { Vec3Array } from "@amodx/math";
 export declare class SectorMesh {
-    location: LocationData;
-    sections: SectionMesh[];
-    constructor(location: LocationData);
-    getSection(x: number, y: number, z: number): SectionMesh;
+    sections: (SectionMesh | null)[];
+    position: Vec3Array;
+    dipose(): void;
+    getSection(x: number, y: number, z: number): SectionMesh | null;
     addSection(x: number, y: number, z: number): SectionMesh;
     removeSection(x: number, y: number, z: number): false | SectionMesh;
 }