@divinevoxel/vlox 0.0.76 → 0.0.77

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

@@ -3,6 +3,7 @@ import PickVoxel from "./PickVoxel";
 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.
  *
@@ -11,13 +12,15 @@ import { SectorCursor } from "../../../World/Cursor/SectorCursor";
 export default async function PickVoxelWorld(cursor, rayStart, rayDirection, rayLength) {
     let t = 0;
     const d = 8;
+    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 { x, y, z } = WorldSpaces.sector.transformPosition(rayPosition);
         if (!WorldSpaces.world.inBounds(x, y, z))

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;

package/Voxels/Models/Defaults/PanelVoxelGeometry.js

@@ -72,120 +72,8 @@ export const diagonalFlatPanelEastWest = {
         },
     ],
 };
-export const thinPanelDown = {
-    id: "dve_thin_panel_down",
-    arguments: {
-        upTex: {
-            type: "texture",
-        },
-        upUvs: {
-            type: "box-uv",
-            default: [0, 0, 1, 1],
-        },
-        upTexRotation: {
-            type: "int",
-            default: 0,
-        },
-        downTex: {
-            type: "texture",
-        },
-        downUvs: {
-            type: "box-uv",
-            default: [0, 0, 1, 1],
-        },
-        downTexRotation: {
-            type: "int",
-            default: 0,
-        },
-        northTex: {
-            type: "texture",
-        },
-        northUvs: {
-            type: "box-uv",
-            default: [0, 0, 1, 3 / 16],
-        },
-        northTexRotation: {
-            type: "int",
-            default: 0,
-        },
-        southTex: {
-            type: "texture",
-        },
-        southUvs: {
-            type: "box-uv",
-            default: [0, 0, 1, 3 / 16],
-        },
-        southTexRotation: {
-            type: "int",
-            default: 0,
-        },
-        eastTex: {
-            type: "texture",
-        },
-        eastUvs: {
-            type: "box-uv",
-            default: [0, 0, 1, 3 / 16],
-        },
-        eastTexRotation: {
-            type: "int",
-            default: 0,
-        },
-        westTex: {
-            type: "texture",
-        },
-        westUvs: {
-            type: "box-uv",
-            default: [0, 0, 1, 3 / 16],
-        },
-        westTexRotation: {
-            type: "int",
-            default: 0,
-        },
-    },
-    nodes: [
-        {
-            type: "box",
-            points: [
-                [0, 0, 0],
-                [1, 3 / 16, 1],
-            ],
-            faces: {
-                up: {
-                    texture: "@upTex",
-                    uv: "@upUvs",
-                    rotation: "@upTexRotation",
-                },
-                down: {
-                    texture: "@downTex",
-                    uv: "@downUvs",
-                    rotation: "@downTexRotation",
-                },
-                north: {
-                    texture: "@northTex",
-                    uv: "@northUvs",
-                    rotation: "@northTexRotation",
-                },
-                south: {
-                    texture: "@southTex",
-                    uv: "@southUvs",
-                    rotation: "@southTexRotation",
-                },
-                east: {
-                    texture: "@eastTex",
-                    uv: "@eastUvs",
-                    rotation: "@eastTexRotation",
-                },
-                west: {
-                    texture: "@westTex",
-                    uv: "@westUvs",
-                    rotation: "@westTexRotation",
-                },
-            },
-        },
-    ],
-};
-export const thinPanelSouth = {
-    id: "dve_thin_panel_south",
+export const thinPanel = {
+    id: "dve_thin_panel",
     arguments: {
         upTex: {
             type: "texture",
@@ -296,115 +184,3 @@ export const thinPanelSouth = {
         },
     ],
 };
-export const thinPanelWest = {
-    id: "dve_thin_panel_west",
-    arguments: {
-        upTex: {
-            type: "texture",
-        },
-        upUvs: {
-            type: "box-uv",
-            default: [0, 0, 3 / 16, 1],
-        },
-        upTexRotation: {
-            type: "int",
-            default: 0,
-        },
-        downTex: {
-            type: "texture",
-        },
-        downUvs: {
-            type: "box-uv",
-            default: [0, 0, 3 / 16, 1],
-        },
-        downTexRotation: {
-            type: "int",
-            default: 0,
-        },
-        northTex: {
-            type: "texture",
-        },
-        northUvs: {
-            type: "box-uv",
-            default: [0, 0, 3 / 16, 1],
-        },
-        northTexRotation: {
-            type: "int",
-            default: 0,
-        },
-        southTex: {
-            type: "texture",
-        },
-        southUvs: {
-            type: "box-uv",
-            default: [0, 0, 3 / 16, 1],
-        },
-        southTexRotation: {
-            type: "int",
-            default: 0,
-        },
-        eastTex: {
-            type: "texture",
-        },
-        eastUvs: {
-            type: "box-uv",
-            default: [0, 0, 1, 1],
-        },
-        eastTexRotation: {
-            type: "int",
-            default: 0,
-        },
-        westTex: {
-            type: "texture",
-        },
-        westUvs: {
-            type: "box-uv",
-            default: [0, 0, 1, 1],
-        },
-        westTexRotation: {
-            type: "int",
-            default: 0,
-        },
-    },
-    nodes: [
-        {
-            type: "box",
-            points: [
-                [0, 0, 0],
-                [3 / 16, 1, 1],
-            ],
-            faces: {
-                up: {
-                    texture: "@upTex",
-                    uv: "@upUvs",
-                    rotation: "@upTexRotation",
-                },
-                down: {
-                    texture: "@downTex",
-                    uv: "@downUvs",
-                    rotation: "@downTexRotation",
-                },
-                north: {
-                    texture: "@northTex",
-                    uv: "@northUvs",
-                    rotation: "@northTexRotation",
-                },
-                south: {
-                    texture: "@southTex",
-                    uv: "@southUvs",
-                    rotation: "@southTexRotation",
-                },
-                east: {
-                    texture: "@eastTex",
-                    uv: "@eastUvs",
-                    rotation: "@eastTexRotation",
-                },
-                west: {
-                    texture: "@westTex",
-                    uv: "@westUvs",
-                    rotation: "@westTexRotation",
-                },
-            },
-        },
-    ],
-};

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

@@ -1,4 +1,5 @@
 import { VoxelModelData } from "../VoxelModel.types";
 export declare const simpleThinPannel: VoxelModelData;
+export declare const simpleTransparentThinPannel: VoxelModelData;
 export declare const simpleCrossedPannel: VoxelModelData;
 export declare const orientedCrossedPannel: VoxelModelData;