@divinevoxel/vlox 0.0.80 → 0.0.81

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

@@ -1,5 +1,5 @@
 import { TextureProcedure, } from "../TextureProcedure";
-import { VoxelFaceDirections, VoxelFaces } from "../../../../../Math/index.js";
+import { VoxelFaceDirections } from "../../../../../Math/index.js";
 const textureMap = [
     "top",
     "corner-top-right",
@@ -58,7 +58,7 @@ const uvsSets = {
     },
 };
 const CheckSets = {
-    [VoxelFaces.Up]: {
+    [0 /* VoxelFaces.Up */]: {
         north: [
             [0, 0, 1],
             [1, 0, 1],
@@ -72,35 +72,35 @@ const CheckSets = {
         east: [[1, 0, 0]],
         west: [[-1, 0, 0]],
     },
-    [VoxelFaces.Down]: {
+    [1 /* VoxelFaces.Down */]: {
         north: [
             [0, 0, 1],
-            [1, 0, 1],
             [-1, 0, 1],
+            [1, 0, 1],
         ],
         south: [
             [0, 0, -1],
-            [1, 0, -1],
             [-1, 0, -1],
+            [1, 0, -1],
         ],
         east: [[-1, 0, 0]],
         west: [[1, 0, 0]],
     },
-    [VoxelFaces.North]: {
+    [2 /* VoxelFaces.North */]: {
         north: [
             [0, 1, 0],
-            [1, 1, 0],
             [-1, 1, 0],
+            [1, 1, 0],
         ],
         south: [
             [0, -1, 0],
-            [1, -1, 0],
             [-1, -1, 0],
+            [1, -1, 0],
         ],
         east: [[-1, 0, 0]],
         west: [[1, 0, 0]],
     },
-    [VoxelFaces.South]: {
+    [3 /* VoxelFaces.South */]: {
         north: [
             [0, 1, 0],
             [1, 1, 0],
@@ -114,7 +114,7 @@ const CheckSets = {
         east: [[1, 0, 0]],
         west: [[-1, 0, 0]],
     },
-    [VoxelFaces.East]: {
+    [4 /* VoxelFaces.East */]: {
         north: [
             [0, 1, 0],
             [0, 1, 1],
@@ -128,16 +128,16 @@ const CheckSets = {
         east: [[0, 0, 1]],
         west: [[0, 0, -1]],
     },
-    [VoxelFaces.West]: {
+    [5 /* VoxelFaces.West */]: {
         north: [
             [0, 1, 0],
-            [0, 1, 1],
             [0, 1, -1],
+            [0, 1, 1],
         ],
         south: [
             [0, -1, 0],
-            [0, -1, 1],
             [0, -1, -1],
+            [0, -1, 1],
         ],
         east: [[0, 0, -1]],
         west: [[0, 0, 1]],
@@ -146,17 +146,17 @@ const CheckSets = {
 const generateCheck = (direction, tool, normal, sets) => {
     const { x, y, z } = tool.position;
     let key = 0b0;
+    const currentVoxelId = tool.voxel.getVoxelId();
     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);
+        const hashed = tool.space.getHash(tool.nVoxel, cx, cy, cz);
+        const sameLevelCheck = currentVoxelId == tool.space.getTrueVoxelId(hashed);
         let normalCheck = true;
-        const nVoxel = tool.nVoxel.getVoxel(cx + normal[0], cy + normal[1], cz + normal[2]);
-        if (nVoxel && nVoxel.isRenderable() && nVoxel.isOpaque()) {
+        const hashedNormal = tool.space.getHash(tool.nVoxel, cx + normal[0], cy + normal[1], cz + normal[2]);
+        if (tool.space.foundHash[hashedNormal] == 2) {
             normalCheck = false;
         }
         if (sameLevelCheck && normalCheck) {
@@ -180,9 +180,7 @@ export class OutlinedTextureProcedure extends TextureProcedure {
     getOverlayTexture(builder, data, closestFace, primitive, ref) {
         const set = CheckSets[closestFace];
         const normal = VoxelFaceDirections[closestFace];
-        const isTopOrBottom = closestFace === VoxelFaces.Up || closestFace === VoxelFaces.Down;
-        // For top/bottom faces, use north/south/east/west sets.
-        // For side faces (north/south/east/west), use top/bottom/right/left sets.
+        const isTopOrBottom = closestFace === 0 /* VoxelFaces.Up */ || closestFace === 1 /* VoxelFaces.Down */;
         const dirNorth = isTopOrBottom ? "north" : "top";
         const dirSouth = isTopOrBottom ? "south" : "bottom";
         const dirEast = isTopOrBottom ? "east" : "right";

package/Mesher/Voxels/Models/Procedures/Default/PillarTextureProcedure.js

@@ -1,24 +1,23 @@
 import { TextureProcedure, } from "../TextureProcedure";
-import { VoxelFaces } from "../../../../../Math";
 import { VoxelLUT } from "../../../../../Voxels/Data/VoxelLUT";
 export class PillarTextureProcedure extends TextureProcedure {
     getTexture(builder, data, closestFace, primitive) {
         if (data.direction == "up-down") {
-            if (closestFace == VoxelFaces.Up)
+            if (closestFace == 0 /* VoxelFaces.Up */)
                 return data.textureRecrod.upTex;
-            if (closestFace == VoxelFaces.Down)
+            if (closestFace == 1 /* VoxelFaces.Down */)
                 return data.textureRecrod.downTex;
             let sideTexture = data.textureRecrod.sideDisconnectedTex;
-            const currentState = VoxelLUT.voxelIdToModelState[builder.voxel.getId()];
+            const currentState = VoxelLUT.voxelIdToState[builder.voxel.getId()];
             const topVoxel = builder.nVoxel.getVoxel(builder.position.x, builder.position.y + 1, builder.position.z);
             const topSame = topVoxel
                 ? builder.voxel.isSameVoxel(topVoxel) &&
-                    VoxelLUT.voxelIdToModelState[topVoxel.getId()] == currentState
+                    VoxelLUT.voxelIdToState[topVoxel.getId()] == currentState
                 : false;
             const bottomVoxel = builder.nVoxel.getVoxel(builder.position.x, builder.position.y - 1, builder.position.z);
             const bottomSame = bottomVoxel
                 ? builder.voxel.isSameVoxel(bottomVoxel) &&
-                    VoxelLUT.voxelIdToModelState[bottomVoxel.getId()] == currentState
+                    VoxelLUT.voxelIdToState[bottomVoxel.getId()] == currentState
                 : false;
             if (topSame && !bottomSame) {
                 sideTexture = data.textureRecrod.sideDownTex;
@@ -29,28 +28,28 @@ export class PillarTextureProcedure extends TextureProcedure {
             if (topSame && bottomSame) {
                 sideTexture = data.textureRecrod.sideConnectedTex;
             }
-            if (closestFace == VoxelFaces.North ||
-                closestFace == VoxelFaces.South ||
-                closestFace == VoxelFaces.East ||
-                closestFace == VoxelFaces.West)
+            if (closestFace == 2 /* VoxelFaces.North */ ||
+                closestFace == 3 /* VoxelFaces.South */ ||
+                closestFace == 4 /* VoxelFaces.East */ ||
+                closestFace == 5 /* VoxelFaces.West */)
                 return sideTexture;
         }
         if (data.direction == "north-south") {
-            if (closestFace == VoxelFaces.North)
+            if (closestFace == 2 /* VoxelFaces.North */)
                 return data.textureRecrod.upTex;
-            if (closestFace == VoxelFaces.South)
+            if (closestFace == 3 /* VoxelFaces.South */)
                 return data.textureRecrod.downTex;
             let sideTexture = data.textureRecrod.sideDisconnectedTex;
-            const currentState = VoxelLUT.voxelIdToModelState[builder.voxel.getId()];
+            const currentState = VoxelLUT.voxelIdToState[builder.voxel.getId()];
             const northVoxel = builder.nVoxel.getVoxel(builder.position.x, builder.position.y, builder.position.z + 1);
             const northSame = northVoxel
                 ? builder.voxel.isSameVoxel(northVoxel) &&
-                    VoxelLUT.voxelIdToModelState[northVoxel.getId()] == currentState
+                    VoxelLUT.voxelIdToState[northVoxel.getId()] == currentState
                 : false;
             const southVoxel = builder.nVoxel.getVoxel(builder.position.x, builder.position.y, builder.position.z - 1);
             const southSame = southVoxel
                 ? builder.voxel.isSameVoxel(southVoxel) &&
-                    VoxelLUT.voxelIdToModelState[southVoxel.getId()] == currentState
+                    VoxelLUT.voxelIdToState[southVoxel.getId()] == currentState
                 : false;
             if (northSame && !southSame) {
                 sideTexture = data.textureRecrod.sideDownTex;
@@ -61,42 +60,42 @@ export class PillarTextureProcedure extends TextureProcedure {
             if (northSame && southSame) {
                 sideTexture = data.textureRecrod.sideConnectedTex;
             }
-            if (closestFace == VoxelFaces.Up ||
-                closestFace == VoxelFaces.Down ||
-                closestFace == VoxelFaces.East ||
-                closestFace == VoxelFaces.West)
+            if (closestFace == 0 /* VoxelFaces.Up */ ||
+                closestFace == 1 /* VoxelFaces.Down */ ||
+                closestFace == 4 /* VoxelFaces.East */ ||
+                closestFace == 5 /* VoxelFaces.West */)
                 return sideTexture;
         }
         if (data.direction == "east-west") {
-            if (closestFace == VoxelFaces.East)
+            if (closestFace == 4 /* VoxelFaces.East */)
                 return data.textureRecrod.upTex;
-            if (closestFace == VoxelFaces.West)
+            if (closestFace == 5 /* VoxelFaces.West */)
                 return data.textureRecrod.downTex;
             let sideTexture = data.textureRecrod.sideDisconnectedTex;
-            const currentState = VoxelLUT.voxelIdToModelState[builder.voxel.getId()];
+            const currentState = VoxelLUT.voxelIdToState[builder.voxel.getId()];
             const eastVoxel = builder.nVoxel.getVoxel(builder.position.x + 1, builder.position.y, builder.position.z);
-            const northSame = eastVoxel
+            const eastSame = eastVoxel
                 ? builder.voxel.isSameVoxel(eastVoxel) &&
-                    VoxelLUT.voxelIdToModelState[eastVoxel.getId()] == currentState
+                    VoxelLUT.voxelIdToState[eastVoxel.getId()] == currentState
                 : false;
             const westVoxel = builder.nVoxel.getVoxel(builder.position.x - 1, builder.position.y, builder.position.z);
             const westSame = westVoxel
                 ? builder.voxel.isSameVoxel(westVoxel) &&
-                    VoxelLUT.voxelIdToModelState[westVoxel.getId()] == currentState
+                    VoxelLUT.voxelIdToState[westVoxel.getId()] == currentState
                 : false;
-            if (northSame && !westSame) {
+            if (eastSame && !westSame) {
                 sideTexture = data.textureRecrod.sideDownTex;
             }
-            if (!northSame && westSame) {
+            if (!eastSame && westSame) {
                 sideTexture = data.textureRecrod.sideUpTex;
             }
-            if (northSame && westSame) {
+            if (eastSame && westSame) {
                 sideTexture = data.textureRecrod.sideConnectedTex;
             }
-            if (closestFace == VoxelFaces.Up ||
-                closestFace == VoxelFaces.Down ||
-                closestFace == VoxelFaces.North ||
-                closestFace == VoxelFaces.South)
+            if (closestFace == 0 /* VoxelFaces.Up */ ||
+                closestFace == 1 /* VoxelFaces.Down */ ||
+                closestFace == 2 /* VoxelFaces.North */ ||
+                closestFace == 3 /* VoxelFaces.South */)
                 return sideTexture;
         }
         throw new Error(`Invalid direction for pillar box texture procedure | ${data.direction}`);
@@ -105,13 +104,13 @@ export class PillarTextureProcedure extends TextureProcedure {
         return ref;
     }
     transformUVs(builder, data, closestFace, primitive) {
-        if ((data.direction == "north-south" &&
-            (closestFace == VoxelFaces.East || closestFace == VoxelFaces.West)) ||
+        const rotate90 = (data.direction == "north-south" && closestFace == 4 /* VoxelFaces.East */) ||
             (data.direction == "east-west" &&
-                (closestFace == VoxelFaces.North ||
-                    closestFace == VoxelFaces.South ||
-                    closestFace == VoxelFaces.Up ||
-                    closestFace == VoxelFaces.Down))) {
+                (closestFace == 3 /* VoxelFaces.South */ || closestFace == 0 /* VoxelFaces.Up */));
+        const rotate270 = (data.direction == "north-south" && closestFace == 5 /* VoxelFaces.West */) ||
+            (data.direction == "east-west" &&
+                (closestFace == 2 /* VoxelFaces.North */ || closestFace == 1 /* VoxelFaces.Down */));
+        if (rotate90) {
             for (const v of primitive.uvs.vertices) {
                 const oldX = v.x;
                 const oldY = v.y;
@@ -119,5 +118,13 @@ export class PillarTextureProcedure extends TextureProcedure {
                 v.y = oldX;
             }
         }
+        else if (rotate270) {
+            for (const v of primitive.uvs.vertices) {
+                const oldX = v.x;
+                const oldY = v.y;
+                v.x = oldY;
+                v.y = 1 - oldX;
+            }
+        }
     }
 }

package/Mesher/Voxels/Models/RenderedMaterials.d.ts

@@ -2,5 +2,5 @@ import { VoxelModelBuilder } from "./VoxelModelBuilder";
 export declare class RenderedMaterials {
     static meshersMap: Map<string, VoxelModelBuilder>;
     static meshers: VoxelModelBuilder[];
-    static register(materials: string[]): void;
+    static init(): void;
 }

package/Mesher/Voxels/Models/RenderedMaterials.js

@@ -1,12 +1,15 @@
+import { VoxelLUT } from "../../../Voxels/Data/VoxelLUT";
 import { VoxelModelBuilder } from "./VoxelModelBuilder";
 export class RenderedMaterials {
     static meshersMap = new Map();
     static meshers = [];
-    static register(materials) {
-        for (let i = 0; i < materials.length; i++) {
-            const newTool = new VoxelModelBuilder(materials[i], i);
-            this.meshersMap.set(materials[i], newTool);
-            this.meshers[i] = newTool;
+    static init() {
+        const materials = VoxelLUT.material._palette;
+        for (const mat of materials) {
+            const index = VoxelLUT.material.getNumberId(mat);
+            const newTool = new VoxelModelBuilder(mat, index);
+            this.meshersMap.set(mat, newTool);
+            this.meshers[index] = newTool;
         }
     }
 }

package/Mesher/Voxels/Models/VoxelGeometryBuilderCacheSpace.d.ts

@@ -4,16 +4,30 @@ import { VoxelCursor } from "../../../Voxels/Cursor/VoxelCursor";
 export declare class VoxelGeometryBuilderCacheSpace {
     bounds: Vector3Like;
     foundHash: Uint8Array;
-    voxelCache: Uint16Array;
-    trueVoxelCache: Uint16Array;
-    reltionalVoxelCache: Uint16Array;
-    reltionalStateCache: Uint16Array;
+    lightCache: Int32Array;
+    private voxelCache;
+    private trueVoxelCache;
+    private reltionalVoxelCache;
+    private reltionalStateCache;
+    secondaryVoxelCache: Uint16Array;
+    secondaryTrueVoxelCache: Uint16Array;
+    secondaryReltionalVoxelCache: Uint16Array;
+    secondaryReltionalStateCache: Uint16Array;
+    hasSecondary: Uint8Array;
     noCastAO: Uint8Array;
+    secondaryNoCastAO: Uint8Array;
+    fullBlock: Uint8Array;
     offset: Vec3Array;
     voxelCursor: VoxelCursor;
     constructor(bounds: Vector3Like);
     start(x: number, y: number, z: number): void;
     getIndex(x: number, y: number, z: number): number;
     getHash(dataCursor: DataCursorInterface, x: number, y: number, z: number): number;
+    getNoCastAO(index: number, secondary?: boolean): boolean;
+    getTrueVoxelId(index: number, secondary?: boolean): number;
+    getVoxelId(index: number, secondary?: boolean): number;
+    getRelationalState(index: number, secondary?: boolean): number;
+    getRelationalVoxelId(index: number, secondary?: boolean): number;
+    getHasSecondary(index: number): number;
     private hashState;
 }

package/Mesher/Voxels/Models/VoxelGeometryBuilderCacheSpace.js

@@ -5,6 +5,7 @@ import { VoxelLUT } from "../../../Voxels/Data/VoxelLUT";
 export class VoxelGeometryBuilderCacheSpace {
     bounds;
     foundHash;
+    lightCache;
     //cache of the voxel ids
     voxelCache;
     //cache of the true voxel ids
@@ -13,29 +14,56 @@ export class VoxelGeometryBuilderCacheSpace {
     reltionalVoxelCache;
     //cache of the reltional state
     reltionalStateCache;
+    //cache of the secondary voxel ids
+    secondaryVoxelCache;
+    //cache of the true secondary voxel ids
+    secondaryTrueVoxelCache;
+    //cache of the reltional secondary voxel ids
+    secondaryReltionalVoxelCache;
+    //cache of the secondary reltional state
+    secondaryReltionalStateCache;
+    hasSecondary;
     noCastAO;
+    secondaryNoCastAO;
+    fullBlock;
     offset = [0, 0, 0];
     voxelCursor = new VoxelCursor();
     constructor(bounds) {
         this.bounds = bounds;
         const volume = bounds.x * bounds.y * bounds.z;
         this.foundHash = new Uint8Array(volume);
+        this.lightCache = new Int32Array(volume);
         this.voxelCache = new Uint16Array(volume);
         this.trueVoxelCache = new Uint16Array(volume);
         this.reltionalVoxelCache = new Uint16Array(volume);
         this.reltionalStateCache = new Uint16Array(volume);
+        this.secondaryVoxelCache = new Uint16Array(volume);
+        this.secondaryTrueVoxelCache = new Uint16Array(volume);
+        this.secondaryReltionalVoxelCache = new Uint16Array(volume);
+        this.secondaryReltionalStateCache = new Uint16Array(volume);
+        this.fullBlock = new Uint8Array(volume);
+        this.hasSecondary = new Uint8Array(volume);
         this.noCastAO = new Uint8Array(volume);
+        this.secondaryNoCastAO = new Uint8Array(volume);
     }
     start(x, y, z) {
         this.offset[0] = x;
         this.offset[1] = y;
         this.offset[2] = z;
+        this.fullBlock.fill(0);
+        this.lightCache.fill(0);
         this.foundHash.fill(0);
         this.voxelCache.fill(0);
         this.trueVoxelCache.fill(0);
         this.reltionalVoxelCache.fill(0);
         this.reltionalStateCache.fill(0);
+        this.secondaryVoxelCache.fill(0);
+        this.secondaryTrueVoxelCache.fill(0);
+        this.secondaryReltionalVoxelCache.fill(0);
+        this.secondaryReltionalStateCache.fill(0);
+        this.hasSecondary.fill(0);
         this.noCastAO.fill(0);
+        this.secondaryNoCastAO.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);
@@ -47,13 +75,46 @@ export class VoxelGeometryBuilderCacheSpace {
         }
         return hashed;
     }
+    getNoCastAO(index, secondary = false) {
+        return ((secondary ? this.secondaryNoCastAO[index] : this.noCastAO[index]) == 1);
+    }
+    getTrueVoxelId(index, secondary = false) {
+        return secondary
+            ? this.secondaryTrueVoxelCache[index]
+            : this.trueVoxelCache[index];
+    }
+    getVoxelId(index, secondary = false) {
+        return secondary ? this.secondaryVoxelCache[index] : this.voxelCache[index];
+    }
+    getRelationalState(index, secondary = false) {
+        return secondary
+            ? this.secondaryReltionalStateCache[index]
+            : this.reltionalStateCache[index];
+    }
+    getRelationalVoxelId(index, secondary = false) {
+        return secondary
+            ? this.secondaryReltionalVoxelCache[index]
+            : this.reltionalVoxelCache[index];
+    }
+    getHasSecondary(index) {
+        return this.hasSecondary[index];
+    }
     hashState(dataCursor, index, x, y, z) {
-        if (this.foundHash[index] == 1)
-            return;
-        if (this.foundHash[index] == 2)
+        if (this.foundHash[index] > 0)
             return;
         const voxel = dataCursor.getVoxel(x, y, z);
-        if (!voxel || !voxel.isRenderable()) {
+        if (voxel) {
+            this.lightCache[index] = voxel.getLight();
+        }
+        if (!voxel) {
+            this.foundHash[index] = 1;
+            return;
+        }
+        const canHaveSecondary = voxel.canHaveSecondaryVoxel();
+        voxel.setSecondary(true);
+        const hasSecondary = canHaveSecondary && voxel.getStringId() !== "dve_air";
+        voxel.setSecondary(false);
+        if (!voxel.isRenderable() && !hasSecondary) {
             this.foundHash[index] = 1;
             return;
         }
@@ -61,31 +122,83 @@ export class VoxelGeometryBuilderCacheSpace {
         const voxelId = voxel.getId();
         this.trueVoxelCache[index] = trueVoxelId;
         this.voxelCache[index] = voxelId;
-        this.foundHash[index] = 2;
+        let secondaryOpaque = false;
+        let secondaryTrueVoxelId = 0;
+        let secondaryVoxelId = 0;
+        if (hasSecondary) {
+            voxel.setSecondary(true);
+            secondaryOpaque = voxel.isOpaque();
+            secondaryTrueVoxelId = voxel.getVoxelId();
+            secondaryVoxelId = voxel.getId();
+            this.hasSecondary[index] = 1;
+            this.secondaryVoxelCache[index] = secondaryVoxelId;
+            this.secondaryTrueVoxelCache[index] = secondaryTrueVoxelId;
+            voxel.setSecondary(false);
+        }
+        if (voxel.isOpaque() || secondaryOpaque) {
+            this.foundHash[index] = 2;
+        }
+        else {
+            this.foundHash[index] = 3;
+        }
+        this.fullBlock[index] = voxel.tags["dve_full_block"] ? 1 : 0;
         //no ao
         this.noCastAO[index] = voxel.isLightSource() || voxel.noAO() ? 1 : 0;
+        if (hasSecondary) {
+            voxel.setSecondary(true);
+            this.secondaryNoCastAO[index] =
+                voxel.isLightSource() || voxel.noAO() ? 1 : 0;
+            voxel.setSecondary(false);
+        }
         this.voxelCursor.copy(voxel).process();
-        const reltioanlBuilder = VoxelSchemas.reltionalStateBuilder.get(VoxelLUT.models.getStringId(VoxelLUT.modelsIndex[trueVoxelId]));
-        reltioanlBuilder.position.x = x;
-        reltioanlBuilder.position.y = y;
-        reltioanlBuilder.position.z = z;
-        reltioanlBuilder.voxel = this.voxelCursor;
-        reltioanlBuilder.dataCursor = dataCursor;
-        const reltionalState = reltioanlBuilder.buildState();
+        let secondaryRelationalState = 0;
+        let secondaryRelationalMod = 0;
+        const relationalBuilder = VoxelSchemas.reltionalStateBuilderMap[VoxelLUT.modelsIndex[trueVoxelId]];
+        relationalBuilder.position.x = x;
+        relationalBuilder.position.y = y;
+        relationalBuilder.position.z = z;
+        relationalBuilder.voxel = this.voxelCursor;
+        relationalBuilder.dataCursor = dataCursor;
+        const reltionalState = relationalBuilder.buildState();
         this.reltionalStateCache[index] = reltionalState;
-        const reltioanlModBuilder = VoxelSchemas.reltionalModBuilder.get(VoxelLUT.voxelIds.getStringId(trueVoxelId));
+        if (hasSecondary) {
+            const relationalBuilder = VoxelSchemas.reltionalStateBuilderMap[VoxelLUT.modelsIndex[secondaryTrueVoxelId]];
+            relationalBuilder.position.x = x;
+            relationalBuilder.position.y = y;
+            relationalBuilder.position.z = z;
+            relationalBuilder.voxel = this.voxelCursor;
+            relationalBuilder.dataCursor = dataCursor;
+            this.voxelCursor.setSecondary(true);
+            secondaryRelationalState = relationalBuilder.buildState();
+            this.secondaryReltionalStateCache[index] = secondaryRelationalState;
+            this.voxelCursor.setSecondary(false);
+        }
+        const relationalModBuilder = VoxelSchemas.reltionalModBuilderMap[trueVoxelId];
         let reltionalMod = 0;
-        if (reltioanlModBuilder) {
-            reltioanlModBuilder.position.x = x;
-            reltioanlModBuilder.position.y = y;
-            reltioanlModBuilder.position.z = z;
-            reltioanlModBuilder.voxel = this.voxelCursor;
-            reltioanlModBuilder.dataCursor = dataCursor;
-            reltionalMod = reltioanlModBuilder.buildState();
+        if (relationalModBuilder) {
+            relationalModBuilder.position.x = x;
+            relationalModBuilder.position.y = y;
+            relationalModBuilder.position.z = z;
+            relationalModBuilder.voxel = this.voxelCursor;
+            relationalModBuilder.dataCursor = dataCursor;
+            reltionalMod = relationalModBuilder.buildState();
         }
-        else {
-            this.reltionalVoxelCache[index] = 0;
+        if (hasSecondary) {
+            const relationalModBuilder = VoxelSchemas.reltionalModBuilderMap[secondaryTrueVoxelId];
+            if (relationalModBuilder) {
+                relationalModBuilder.position.x = x;
+                relationalModBuilder.position.y = y;
+                relationalModBuilder.position.z = z;
+                relationalModBuilder.voxel = this.voxelCursor;
+                relationalModBuilder.dataCursor = dataCursor;
+                this.voxelCursor.setSecondary(true);
+                secondaryRelationalMod = relationalModBuilder.buildState();
+                this.voxelCursor.setSecondary(false);
+            }
         }
         this.reltionalVoxelCache[index] = VoxelLUT.getReltionalVoxelId(trueVoxelId, reltionalState, reltionalMod);
+        if (hasSecondary) {
+            this.secondaryReltionalVoxelCache[index] = VoxelLUT.getReltionalVoxelId(secondaryTrueVoxelId, secondaryRelationalState, secondaryRelationalMod);
+        }
     }
 }

package/Mesher/Voxels/Models/VoxelGeometryBuilderCacheSpaceN.d.ts

@@ -0,0 +1,33 @@
+import { DataCursorInterface } from "../../../Voxels/Cursor/DataCursor.interface";
+import { Vec3Array, Vector3Like } from "@amodx/math";
+import { VoxelCursor } from "../../../Voxels/Cursor/VoxelCursor";
+export declare class VoxelGeometryBuilderCacheSpace {
+    bounds: Vector3Like;
+    foundHash: Uint8Array;
+    lightCache: Int32Array;
+    private voxelCache;
+    private trueVoxelCache;
+    private reltionalVoxelCache;
+    private reltionalStateCache;
+    secondaryVoxelCache: Uint16Array;
+    secondaryTrueVoxelCache: Uint16Array;
+    secondaryReltionalVoxelCache: Uint16Array;
+    secondaryReltionalStateCache: Uint16Array;
+    hasSecondary: Uint8Array;
+    noCastAO: Uint8Array;
+    secondaryNoCastAO: Uint8Array;
+    fullBlock: Uint8Array;
+    offset: Vec3Array;
+    voxelCursor: VoxelCursor;
+    constructor(bounds: Vector3Like);
+    start(x: number, y: number, z: number): void;
+    getIndex(x: number, y: number, z: number): number;
+    getHash(dataCursor: DataCursorInterface, x: number, y: number, z: number): number;
+    getNoCastAO(index: number, secondary?: boolean): boolean;
+    getTrueVoxelId(index: number, secondary?: boolean): number;
+    getVoxelId(index: number, secondary?: boolean): number;
+    getRelationalState(index: number, secondary?: boolean): number;
+    getRelationalVoxelId(index: number, secondary?: boolean): number;
+    getHasSecondary(index: number): number;
+    private hashState;
+}