@divinevoxel/vlox 0.0.75 → 0.0.77

package/Voxels/InitVoxelData.js

@@ -1,14 +1,14 @@
 import { candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, candlesModel, carpetGeometry, carpetModel, chainGeometry, chainModel, fence, fenceEastWest, fenceNorthsouth, fencePost, leverGeometry, leverModel, } from "./Models/Defaults/Examples";
 import { cube, halfDownCube, eighthCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, halfSouthCube, halfWestCube, } from "./Models/Defaults/CubeVoxelGeometry";
 import { orientedCube, pillarCube, simpleCube, simpleNoCulledCube, simpleHalfCube, simpleTransparentCube, } from "./Models/Defaults/CubeVoxelModels";
-import { diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, thinPanelDown, thinPanelSouth, thinPanelWest, } from "./Models/Defaults/PanelVoxelGeometry";
+import { diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, thinPanel, } from "./Models/Defaults/PanelVoxelGeometry";
 import { stair } from "./Models/Defaults/StairVoxelModel";
 import { liquidGeometry, liquidModel, } from "./Models/Defaults/LiquidVoxelModel";
 import { VoxelModelRuleBuilderRegister } from "./Models/Rules/VoxelModelRuleBuilderRegister";
 import { BuildStateData } from "./Functions/BuildStateData";
 import { BuildFinalInputs } from "./Models/Rules/Functions/BuildFinalInputs";
 import { SchemaRegister } from "../Voxels/State/SchemaRegister";
-import { simpleCrossedPannel, simpleThinPannel, } from "./Models/Defaults/PanelVoxelModels";
+import { simpleCrossedPannel, simpleThinPannel, simpleTransparentThinPannel, } from "./Models/Defaults/PanelVoxelModels";
 import { VoxelIndex } from "../Voxels/Indexes/VoxelIndex";
 import { CacheManager } from "../Cache/CacheManager";
 import { VoxelLightData } from "./Cursor/VoxelLightData";
@@ -21,8 +21,8 @@ import { BuildRules } from "./Models/Rules/Functions/BuildRules";
 import { VoxelTagsRegister } from "./Data/VoxelTagsRegister";
 import { farmGeomtry, farmModels } from "./Models/Defaults/FarmVoxelModels";
 function RegisterModels(data) {
-    VoxelModelRuleBuilderRegister.registerGeometry(cube, halfDownCube, halfSouthCube, halfWestCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, eighthCube, thinPanelDown, thinPanelSouth, thinPanelWest, diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, fencePost, fenceEastWest, fenceNorthsouth, chainGeometry, carpetGeometry, candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, liquidGeometry, ...leverGeometry, ...farmGeomtry, ...(data.geometry || []));
-    VoxelModelRuleBuilderRegister.registerModels(simpleCube, simpleTransparentCube, simpleNoCulledCube, orientedCube, simpleHalfCube, pillarCube, simpleThinPannel, stair, simpleCrossedPannel, chainModel, carpetModel, candlesModel, leverModel, fence, liquidModel, ...farmModels, ...(data.models || []));
+    VoxelModelRuleBuilderRegister.registerGeometry(cube, halfDownCube, halfSouthCube, halfWestCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, eighthCube, thinPanel, diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, fencePost, fenceEastWest, fenceNorthsouth, chainGeometry, carpetGeometry, candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, liquidGeometry, ...leverGeometry, ...farmGeomtry, ...(data.geometry || []));
+    VoxelModelRuleBuilderRegister.registerModels(simpleCube, simpleTransparentCube, simpleNoCulledCube, orientedCube, simpleHalfCube, pillarCube, simpleThinPannel, simpleTransparentThinPannel, stair, simpleCrossedPannel, chainModel, carpetModel, candlesModel, leverModel, fence, liquidModel, ...farmModels, ...(data.models || []));
 }
 function GetModelData(data) {
     if (CacheManager.cacheLoadEnabled && CacheManager.cachedData) {
@@ -149,16 +149,6 @@ export function InitVoxelData(data) {
                 dve_flow_rate: 0,
             },
         },
-        {
-            id: "dve_glow",
-            properties: {
-                dve_parent_substance: "dve_solid",
-                dve_is_solid: true,
-                dve_is_liquid: false,
-                dve_is_transparent: false,
-                dve_flow_rate: 0,
-            },
-        },
         {
             id: "dve_translucent",
             properties: {
@@ -237,6 +227,7 @@ export function InitVoxelData(data) {
         substances,
         materials,
     });
+    console.warn("FINAL", structuredClone(voxelData), voxelData.data.tags.filter((_) => _["dve_substance"] == "dve_glow"));
     let models = GetModelData(data);
     BuildPaletteData({ models });
     voxelData.data.palette = VoxelPalettesRegister.voxels;

package/Voxels/Interaction/Functions/PickVoxel.d.ts

@@ -1,9 +1,4 @@
 import { Vec3Array } from "@amodx/math";
 import { DataCursorInterface } from "../../Cursor/DataCursor.interface";
 import { VoxelPickResult } from "../VoxelPickResult";
-/**
- * # PickVoxel
- * Used to a pick a voxel from any data cursor interface.
- * The function assumes the data that is loaded into the cursor is available
- */
 export default function PickVoxel(cursor: DataCursorInterface, rayStart: Vec3Array, rayDirection: Vec3Array, rayLength: number): VoxelPickResult | null;

package/Voxels/Interaction/Functions/PickVoxel.js

@@ -1,94 +1,73 @@
-import { Vec3ArrayLike, Vector3Like } from "@amodx/math";
+import { Vector3Like } from "@amodx/math";
 import { VoxelPickResult } from "../VoxelPickResult";
 import { closestUnitNormal, closestVoxelFace, } from "../../../Math/UtilFunctions";
-const step = (val) => (val > 0 ? 1 : val < 0 ? -1 : 0);
-const calculateNormal = (intersectPoint, voxelMin, voxelMax) => {
-    const epsilon = 1e-4;
-    let normal = [0, 0, 0];
-    if (Math.abs(intersectPoint[0] - voxelMin[0]) < epsilon)
-        normal = [1, 0, 0];
-    else if (Math.abs(intersectPoint[0] - voxelMax[0]) < epsilon)
-        normal = [-1, 0, 0];
-    else if (Math.abs(intersectPoint[1] - voxelMin[1]) < epsilon)
-        normal = [0, 1, 0];
-    else if (Math.abs(intersectPoint[1] - voxelMax[1]) < epsilon)
-        normal = [0, -1, 0];
-    else if (Math.abs(intersectPoint[2] - voxelMin[2]) < epsilon)
-        normal = [0, 0, 1];
-    else if (Math.abs(intersectPoint[2] - voxelMax[2]) < epsilon)
-        normal = [0, 0, -1];
-    return normal;
-};
-/**
- * # PickVoxel
- * Used to a pick a voxel from any data cursor interface.
- * The function assumes the data that is loaded into the cursor is available
- */
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+const epsilon = 1e-5;
+const bounds = new BoundingBox();
 export default function PickVoxel(cursor, rayStart, rayDirection, rayLength) {
-    const invDir = [
-        1 / rayDirection[0],
-        1 / rayDirection[1],
-        1 / rayDirection[2],
-    ];
-    const voxelSize = 1.0;
-    const tDelta = [
-        Math.abs(invDir[0]) * voxelSize,
-        Math.abs(invDir[1]) * voxelSize,
-        Math.abs(invDir[2]) * voxelSize,
-    ];
-    const tMax = [
-        (Math.floor(rayStart[0]) - rayStart[0] + (rayDirection[0] > 0 ? 1 : 0)) *
-            invDir[0],
-        (Math.floor(rayStart[1]) - rayStart[1] + (rayDirection[1] > 0 ? 1 : 0)) *
-            invDir[1],
-        (Math.floor(rayStart[2]) - rayStart[2] + (rayDirection[2] > 0 ? 1 : 0)) *
-            invDir[2],
-    ];
-    const pos = [
-        Math.floor(rayStart[0]),
-        Math.floor(rayStart[1]),
-        Math.floor(rayStart[2]),
-    ];
-    const stepDir = [
-        step(rayDirection[0]),
-        step(rayDirection[1]),
-        step(rayDirection[2]),
-    ];
-    for (let i = 0; i < rayLength; i++) {
-        const [tx, ty, tz] = tMax;
-        let axis = 0;
-        if (tx < ty) {
-            if (tx < tz)
-                axis = 0;
-            else
-                axis = 2;
+    const rayDir = Vector3Like.Create(...rayDirection);
+    const rayOrigin = Vector3Like.Create(...rayStart);
+    const offset = cursor.volumePosition
+        ? cursor.volumePosition
+        : Vector3Like.Create();
+    bounds.setMinMax(Vector3Like.Add(cursor.volumeBounds.min, offset), Vector3Like.Add(cursor.volumeBounds.max, offset));
+    const safeDirection = Vector3Like.Create(Math.abs(rayDir.x) < epsilon ? epsilon : rayDir.x, Math.abs(rayDir.y) < epsilon ? epsilon : rayDir.y, Math.abs(rayDir.z) < epsilon ? epsilon : rayDir.z);
+    const invDir = Vector3Like.Divide(Vector3Like.Create(1, 1, 1), safeDirection);
+    const tDelta = Vector3Like.Create(Math.abs(invDir.x), Math.abs(invDir.y), Math.abs(invDir.z));
+    const tEnter = bounds.rayIntersection(rayOrigin, safeDirection);
+    if (!isFinite(tEnter)) {
+        return null;
+    }
+    let traveled = Math.max(tEnter - 0.5, 0.0);
+    const pos = Vector3Like.Add(rayOrigin, Vector3Like.MultiplyScalar(rayDir, traveled));
+    const voxel = Vector3Like.FloorInPlace(Vector3Like.Clone(pos));
+    const step = Vector3Like.Create(rayDir.x >= 0.0 ? 1 : -1, rayDir.y >= 0.0 ? 1 : -1, rayDir.z >= 0.0 ? 1 : -1);
+    const tMax = Vector3Like.Create((rayDir.x >= 0 ? voxel.x + 1 - pos.x : pos.x - voxel.x) * tDelta.x +
+        traveled, (rayDir.y >= 0 ? voxel.y + 1 - pos.y : pos.y - voxel.y) * tDelta.y +
+        traveled, (rayDir.z >= 0 ? voxel.z + 1 - pos.z : pos.z - voxel.z) * tDelta.z +
+        traveled);
+    const normal = Vector3Like.Create();
+    const maxDist = rayLength;
+    while (true) {
+        let cursorX = voxel.x;
+        let cursorY = voxel.y;
+        let cursorZ = voxel.z;
+        if (cursor.inBounds(cursorX, cursorY, cursorZ)) {
+            const voxel = cursor.getVoxel(cursorX, cursorY, cursorZ);
+            if (voxel && voxel.isRenderable()) {
+                const urd = Vector3Like.FromArray(closestUnitNormal(rayDir));
+                const n = Vector3Like.Clone(normal);
+                const pos = Vector3Like.Create(cursorX, cursorY, cursorZ);
+                const un = Vector3Like.FromArray(closestUnitNormal(n));
+                return new VoxelPickResult(rayOrigin, rayDir, rayLength, voxel.getRaw(), Vector3Like.Clone(pos), n, traveled, Vector3Like.Add(pos, normal), Vector3Like.FromArray(closestUnitNormal(rayDir)), closestVoxelFace(urd), Vector3Like.FromArray(closestUnitNormal(n)), closestVoxelFace(un), 0);
+            }
+        }
+        if (tMax.x < tMax.y && tMax.x < tMax.z) {
+            traveled = tMax.x;
+            tMax.x += tDelta.x;
+            voxel.x += step.x;
+            normal.x = -step.x;
+            normal.y = 0;
+            normal.z = 0;
+        }
+        else if (tMax.y < tMax.z) {
+            traveled = tMax.y;
+            tMax.y += tDelta.y;
+            voxel.y += step.y;
+            normal.x = 0;
+            normal.y = -step.y;
+            normal.z = 0;
         }
         else {
-            if (ty < tz)
-                axis = 1;
-            else
-                axis = 2;
+            traveled = tMax.z;
+            tMax.z += tDelta.z;
+            voxel.z += step.z;
+            normal.x = 0;
+            normal.y = 0;
+            normal.z = -step.z;
         }
-        pos[axis] += stepDir[axis];
-        tMax[axis] += tDelta[axis];
-        if (!cursor.inBounds(...pos))
-            continue;
-        const voxel = cursor.getVoxel(...pos);
-        if (voxel && voxel.isRenderable()) {
-            const normal = calculateNormal([
-                rayStart[0] + rayDirection[0] * tMax[axis],
-                rayStart[1] + rayDirection[1] * tMax[axis],
-                rayStart[2] + rayDirection[2] * tMax[axis],
-            ], [pos[0] * voxelSize, pos[1] * voxelSize, pos[2] * voxelSize], [
-                pos[0] * voxelSize + voxelSize,
-                pos[1] * voxelSize + voxelSize,
-                pos[2] * voxelSize + voxelSize,
-            ]);
-            const rd = Vector3Like.Create(...rayDirection);
-            const urd = Vector3Like.FromArray(closestUnitNormal(rd));
-            const n = Vector3Like.Create(...normal);
-            const un = Vector3Like.FromArray(closestUnitNormal(n));
-            return new VoxelPickResult(Vector3Like.Create(...rayStart), rd, rayLength, voxel.getRaw(), Vector3Like.Create(...pos), n, tMax[axis], Vector3Like.Create(...Vec3ArrayLike.Add(pos, normal)), Vector3Like.FromArray(closestUnitNormal(rd)), closestVoxelFace(urd), Vector3Like.FromArray(closestUnitNormal(n)), closestVoxelFace(un), 0);
+        if (traveled - tEnter > maxDist) {
+            break;
         }
     }
     return null;

package/Voxels/Interaction/Functions/PickVoxelWorld.js

@@ -1,9 +1,9 @@
 import { Vector3Like } from "@amodx/math";
 import PickVoxel from "./PickVoxel";
-import { Axes } from "@amodx/math/Vectors/Axes";
 import { WorldSpaces } from "../../../World/WorldSpaces";
 import { WorldRegister } from "../../../World/WorldRegister";
 import { SectorCursor } from "../../../World/Cursor/SectorCursor";
+const epsilon = 1e-5;
 /**# PickVoxelWorld
  * Will pick the voxel world and make sure each sector is available before picking it.
  *
@@ -12,55 +12,30 @@ import { SectorCursor } from "../../../World/Cursor/SectorCursor";
 export default async function PickVoxelWorld(cursor, rayStart, rayDirection, rayLength) {
     let t = 0;
     const d = 8;
-    const rayPosition = Vector3Like.Create(...rayStart);
-    const rd = Vector3Like.Create(...rayDirection);
-    const rayRight = Vector3Like.Cross(rd, Axes.UpReadOnly());
-    const rayUp = Vector3Like.Cross(rayRight, rd);
-    const cubeSize = 16.0;
-    const halfSize = cubeSize / 2.0;
-    const rayDirectionScaled = Vector3Like.MultiplyScalar(rd, halfSize);
-    const rayRightScaled = Vector3Like.MultiplyScalar(rayRight, halfSize);
-    const rayUpScaled = Vector3Like.MultiplyScalar(rayUp, halfSize);
-    const finalRayCubeDirection = Vector3Like.Subtract(Vector3Like.Subtract(rayDirectionScaled, rayRightScaled), rayUpScaled);
-    const finalMin = Vector3Like.Create();
-    const finalMax = Vector3Like.Create();
-    const { x: sectorSizeX, y: sectorSizeY, z: sectorSizeZ, } = WorldSpaces.sector.bounds;
+    const rayDir = Vector3Like.Create(...rayDirection);
+    const rayPosition = Vector3Like.Create();
     const visited = new Set();
     const sectorCursor = new SectorCursor();
+    const safeDirection = Vector3Like.Create(Math.abs(rayDir.x) < epsilon ? epsilon : rayDir.x, Math.abs(rayDir.y) < epsilon ? epsilon : rayDir.y, Math.abs(rayDir.z) < epsilon ? epsilon : rayDir.z);
     while (t < rayLength) {
-        rayPosition.x = rayStart[0] + t * rayDirection[0];
-        rayPosition.y = rayStart[1] + t * rayDirection[1];
-        rayPosition.z = rayStart[2] + t * rayDirection[2];
+        rayPosition.x = rayStart[0] + t * safeDirection.x;
+        rayPosition.y = rayStart[1] + t * safeDirection.y;
+        rayPosition.z = rayStart[2] + t * safeDirection.z;
         t += d;
-        const min = WorldSpaces.sector.getPosition(...Vector3Like.ToArray(Vector3Like.Subtract(rayPosition, finalRayCubeDirection)));
-        const max = WorldSpaces.sector.getPosition(...Vector3Like.ToArray(Vector3Like.Add(rayPosition, finalRayCubeDirection)));
-        max.x < min.x ? (finalMin.x = max.x) : (finalMin.x = min.x);
-        max.y < min.y ? (finalMin.y = max.y) : (finalMin.y = min.y);
-        max.z < min.z ? (finalMin.z = max.z) : (finalMin.z = min.z);
-        min.x > max.x ? (finalMax.x = min.x) : (finalMax.x = max.x);
-        min.y > max.y ? (finalMax.y = min.y) : (finalMax.y = max.y);
-        min.z > max.z ? (finalMax.z = min.z) : (finalMax.z = max.z);
-        const { x: sx, y: sy, z: sz } = finalMin;
-        const { x: ex, y: ey, z: ez } = finalMax;
-        for (let x = sx - sectorSizeX; x < ex + sectorSizeX; x += sectorSizeX) {
-            for (let z = sz - sectorSizeZ; z < ez + sectorSizeZ; z += sectorSizeZ) {
-                for (let y = sy - sectorSizeY; y < ey + sectorSizeY; y += sectorSizeY) {
-                    if (!WorldSpaces.world.inBounds(x, y, z))
-                        continue;
-                    const sector = WorldRegister.sectors.get(cursor.dimension, x, y, z);
-                    if (!sector)
-                        continue;
-                    if (visited.has(sector))
-                        continue;
-                    visited.add(sector);
-                    await sector.waitTillCheckedIn();
-                    sectorCursor.loadSector(cursor.dimension, x, y, z);
-                    const result = PickVoxel(sectorCursor, rayStart, rayDirection, rayLength);
-                    if (result !== null)
-                        return result;
-                }
-            }
-        }
+        const { x, y, z } = WorldSpaces.sector.transformPosition(rayPosition);
+        if (!WorldSpaces.world.inBounds(x, y, z))
+            continue;
+        const sector = WorldRegister.sectors.get(cursor.dimension, x, y, z);
+        if (!sector)
+            continue;
+        if (visited.has(sector))
+            continue;
+        visited.add(sector);
+        await sector.waitTillCheckedIn();
+        sectorCursor.loadSector(cursor.dimension, x, y, z);
+        const result = PickVoxel(sectorCursor, rayStart, rayDirection, rayLength);
+        if (result !== null)
+            return result;
     }
     return null;
 }

package/Voxels/Interaction/VoxelPickResult.d.ts

@@ -46,5 +46,6 @@ export declare class VoxelPickResult implements VoxelPickResultData {
     voxel: VoxelCursor;
     static FromJSON(data: VoxelPickResultData): VoxelPickResult;
     constructor(rayOrigin: Vector3Like, rayDirection: Vector3Like, rayLength: number, voxelData: RawVoxelData, position: Vector3Like, normal: Vector3Like, distance: number, normalPosition: Vector3Like, unitRayDirection: Vector3Like, unitRayVoxelFace: VoxelFaces, unitNormal: Vector3Like, unitNormalFace: VoxelFaces, delta: number);
+    clone(): VoxelPickResult;
     toJSON(): VoxelPickResultData;
 }

package/Voxels/Interaction/VoxelPickResult.js

@@ -35,6 +35,9 @@ export class VoxelPickResult {
         this.voxel.setRaw(voxelData);
         this.voxel.loadIn();
     }
+    clone() {
+        return VoxelPickResult.FromJSON(this.toJSON());
+    }
     toJSON() {
         return {
             rayOrigin: { ...this.rayOrigin },

package/Voxels/Models/CompiledVoxelModel.types.d.ts

@@ -3,7 +3,7 @@ import { CulledOcclusionFaceIndexData } from "../Models/Indexing/CulledOcclusion
 import { VoxelStateSchemaData, StateLogicStatement } from "../State/State.types";
 import { CullingProcedureData } from "../Models/VoxelModel.types";
 import { VoxelEffectSyncData } from "../Effects/VoxelEffects.types";
-import { CompiledGeomtryNodes } from "../../Mesher/Models/Nodes/Types/GeomtryNode.types";
+import { CompiledGeomtryNodes } from "../../Mesher/Voxels/Models/Nodes/Types/GeomtryNode.types";
 export type CompiledVoxelGeometrySyncData = {
     id: string;
     cullingProcedure: CullingProcedureData;

package/Voxels/Models/Defaults/CubeVoxelGeometry.js

@@ -1,6 +1,17 @@
 export const cube = {
     id: "dve_cube",
     arguments: {
+        allTexs: {
+            type: "arg-list",
+            arguments: [
+                "upTex",
+                "downTex",
+                "northTex",
+                "southTex",
+                "eastTex",
+                "westTex",
+            ],
+        },
         upTex: {
             type: "texture",
         },

package/Voxels/Models/Defaults/CubeVoxelModels.js

@@ -765,68 +765,13 @@ export const simpleHalfCube = {
 };
 export const pillarCube = {
     id: "dve_pillar_cube",
-    relationsSchema: [
-        {
-            name: "same-down",
-            conditions: [
-                {
-                    type: "same-voxel",
-                    direction: [0, -1, 0],
-                },
-            ],
-        },
-        {
-            name: "same-up",
-            conditions: [
-                {
-                    type: "same-voxel",
-                    direction: [0, 1, 0],
-                },
-            ],
-        },
-        {
-            name: "same-east",
-            conditions: [
-                {
-                    type: "same-voxel",
-                    direction: [1, 0, 0],
-                },
-            ],
-        },
-        {
-            name: "same-west",
-            conditions: [
-                {
-                    type: "same-voxel",
-                    direction: [-1, 0, 0],
-                },
-            ],
-        },
-        {
-            name: "same-north",
-            conditions: [
-                {
-                    type: "same-voxel",
-                    direction: [0, 0, 1],
-                },
-            ],
-        },
-        {
-            name: "same-south",
-            conditions: [
-                {
-                    type: "same-voxel",
-                    direction: [0, 0, -1],
-                },
-            ],
-        },
-    ],
+    relationsSchema: [],
     stateSchema: [
         {
             name: "direction",
             bitIndex: 0,
             bitSize: 2,
-            values: ["down-up", "south-north", "west-east"],
+            values: ["up-down", "north-south", "east-west"],
         },
     ],
     arguments: {
@@ -854,65 +799,65 @@ export const pillarCube = {
         dve_placing_strategy: "*",
     },
     stateNodes: {
-        "direction=down-up,same-down=false,same-up=false": [
+        "direction=up-down": [
             {
                 geometryId: "dve_cube",
                 inputs: {
-                    upTex: "@upTex",
-                    downTex: "@downTex",
-                    northTex: "@sideDisconnectedTex",
-                    southTex: "@sideDisconnectedTex",
-                    eastTex: "@sideDisconnectedTex",
-                    westTex: "@sideDisconnectedTex",
+                    allTexs: {
+                        type: "pillar",
+                        texture: "@sideDisconnectedTex",
+                        textureRecrod: {
+                            sideConnectedTex: "@sideConnectedTex",
+                            sideDisconnectedTex: "@sideDisconnectedTex",
+                            sideUpTex: "@sideUpTex",
+                            sideDownTex: "@sideDownTex",
+                            upTex: "@upTex",
+                            downTex: "@downTex",
+                        },
+                        direction: "up-down",
+                    },
                 },
             },
         ],
-        "direction=down-up,same-down=true,same-up=false": [
+        "direction=east-west": [
             {
                 geometryId: "dve_cube",
                 inputs: {
-                    upTex: "@upTex",
-                    downTex: "@downTex",
-                    northTex: "@sideUpTex",
-                    southTex: "@sideUpTex",
-                    eastTex: "@sideUpTex",
-                    westTex: "@sideUpTex",
+                    allTexs: {
+                        type: "pillar",
+                        texture: "@sideDisconnectedTex",
+                        textureRecrod: {
+                            sideConnectedTex: "@sideConnectedTex",
+                            sideDisconnectedTex: "@sideDisconnectedTex",
+                            sideUpTex: "@sideUpTex",
+                            sideDownTex: "@sideDownTex",
+                            upTex: "@upTex",
+                            downTex: "@downTex",
+                        },
+                        direction: "east-west",
+                    },
                 },
             },
         ],
-        "direction=down-up,same-down=false,same-up=true": [
+        "direction=north-south": [
             {
                 geometryId: "dve_cube",
                 inputs: {
-                    upTex: "@upTex",
-                    downTex: "@downTex",
-                    northTex: "@sideDownTex",
-                    southTex: "@sideDownTex",
-                    eastTex: "@sideDownTex",
-                    westTex: "@sideDownTex",
-                },
-            },
-        ],
-        "direction=down-up,same-down=true,same-up=true": [
-            {
-                geometryId: "dve_cube",
-                inputs: {
-                    upTex: "@upTex",
-                    downTex: "@downTex",
-                    northTex: "@sideConnectedTex",
-                    southTex: "@sideConnectedTex",
-                    eastTex: "@sideConnectedTex",
-                    westTex: "@sideConnectedTex",
+                    allTexs: {
+                        type: "pillar",
+                        texture: "@sideDisconnectedTex",
+                        textureRecrod: {
+                            sideConnectedTex: "@sideConnectedTex",
+                            sideDisconnectedTex: "@sideDisconnectedTex",
+                            sideUpTex: "@sideUpTex",
+                            sideDownTex: "@sideDownTex",
+                            upTex: "@upTex",
+                            downTex: "@downTex",
+                        },
+                        direction: "north-south",
+                    },
                 },
             },
         ],
-        "direction=south-north,same-south=false,same-north=false": [],
-        "direction=south-north,same-south=true,same-north=false": [],
-        "direction=south-north,same-south=false,same-north=true": [],
-        "direction=south-north,same-south=true,same-north=true": [],
-        "direction=west-east,same-west=false,same-east=false": [],
-        "direction=west-east,same-west=true,same-east=false": [],
-        "direction=west-east,same-west=false,same-east=true": [],
-        "direction=west-east,same-west=true,same-east=true": [],
     },
 };

package/Voxels/Models/Defaults/PanelVoxelGeometry.d.ts

@@ -1,6 +1,4 @@
 import { VoxelGeometryData } from "../VoxelModel.types";
 export declare const diagonalFlatPanelWestEast: VoxelGeometryData;
 export declare const diagonalFlatPanelEastWest: VoxelGeometryData;
-export declare const thinPanelDown: VoxelGeometryData;
-export declare const thinPanelSouth: VoxelGeometryData;
-export declare const thinPanelWest: VoxelGeometryData;
+export declare const thinPanel: VoxelGeometryData;