@divinevoxel/vlox 0.0.3 → 0.0.5

package/Mesher/InitTask.js

@@ -0,0 +1,44 @@
+import { Threads } from "@amodx/threads";
+import { WorldRegister } from "../World/WorldRegister";
+import { WorldSpaces } from "../World/WorldSpaces";
+import { MeshSection } from "./Functions/MeshSection";
+import { TasksIds } from "../Tasks/TasksIds";
+export default function (rendererThread) {
+    Threads.registerTask(TasksIds.BuildSection, (location) => {
+        const section = MeshSection(location);
+        if (!section)
+            return;
+        rendererThread.runTask("set-section", section[0], section[1]);
+    });
+    Threads.registerTask(TasksIds.BuildSector, (location) => {
+        WorldRegister.setDimension(location[0]);
+        const sectorPosition = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
+        const sector = WorldRegister.sectors.get(sectorPosition.x, sectorPosition.y, sectorPosition.z);
+        if (!sector) {
+            console.warn("Tried building a sector that does not exists.", [
+                sectorPosition.x,
+                sectorPosition.y,
+                sectorPosition.z,
+            ]);
+            return;
+        }
+        if (sector.sections.length == 0) {
+            console.warn("Tried building a sector with no sections.", sector.position);
+            return;
+        }
+        for (let i = 0; i < sector.sections.length; i++) {
+            const section = sector.sections[i];
+            if (!section)
+                continue;
+            const sectionMesh = MeshSection([
+                location[0],
+                sector.position[0],
+                sector.position[1] + i * WorldSpaces.section.bounds.y,
+                sector.position[2],
+            ]);
+            if (!sectionMesh)
+                continue;
+            rendererThread.runTask("set-section", sectionMesh[0], sectionMesh[1]);
+        }
+    });
+}

package/Mesher/Models/Common/BoxGeometryNode.d.ts

@@ -1,8 +1,8 @@
 import { Vec3Array } from "@amodx/math";
 import { VoxelFaces } from "../../../Math";
-import { Quad } from "@amodx/meshing/Primitives/Quad";
+import { Quad } from "../../Geomtry/Primitives/Quad";
 import { QuadVertexWeights } from "./Calc/CalcConstants";
-import { VoxelGeometryTransform } from "../../../Voxels/VoxelSyncData";
+import { VoxelGeometryTransform } from "../../../Voxels/Types/VoxelModelCompiledData.types";
 export declare function GetBoxGeometryNodeData(points: [Vec3Array, Vec3Array], transform: VoxelGeometryTransform): {
     quads: Record<VoxelFaces, Quad>;
     vertexWeights: Record<VoxelFaces, QuadVertexWeights>;

package/Mesher/Models/Common/BoxGeometryNode.js

@@ -1,70 +1,75 @@
 import { Vector3Like } from "@amodx/math";
 import { VoxelFaces } from "../../../Math";
-import { Quad } from "@amodx/meshing/Primitives/Quad";
+import { Quad } from "../../Geomtry/Primitives/Quad";
 import { addQuadWeights } from "./Calc/CalcConstants";
-import { TransformBox } from "../../../Models/Shared/Transform";
 import { GetBounds } from "./BoundsFunctions";
 export function GetBoxGeometryNodeData(points, transform) {
-    const quads = [];
+    // const quads: Quad[] = [];
     const vertexWeights = [];
-    const [start, end] = points.map((_) => Vector3Like.Create(..._));
-    const quadPoints = [
-        //top
-        [
-            [end.x, end.y, end.z],
-            [start.x, end.y, end.z],
-            [start.x, end.y, start.z],
-            [end.x, end.y, start.z],
-        ],
-        //bottom
-        [
-            [start.x, start.y, end.z],
-            [end.x, start.y, end.z],
-            [end.x, start.y, start.z],
-            [start.x, start.y, start.z],
-        ],
-        //north
-        [
-            [start.x, end.y, end.z],
-            [end.x, end.y, end.z],
-            [end.x, start.y, end.z],
-            [start.x, start.y, end.z],
-        ],
-        //south
-        [
-            [end.x, end.y, start.z],
-            [start.x, end.y, start.z],
-            [start.x, start.y, start.z],
-            [end.x, start.y, start.z],
-        ],
-        //east
-        [
-            [end.x, end.y, end.z],
-            [end.x, end.y, start.z],
-            [end.x, start.y, start.z],
-            [end.x, start.y, end.z],
-        ],
-        //west
-        [
-            [start.x, end.y, start.z],
-            [start.x, end.y, end.z],
-            [start.x, start.y, end.z],
-            [start.x, start.y, start.z],
-        ],
-    ];
-    const tranformed = TransformBox(quadPoints.map((_) => Quad.Create(_)), transform);
-    const quadBounds = tranformed.map((_) => GetBounds(_.positions.getAsArray().map((_) => Vector3Like.ToArray(_))));
-    quads[VoxelFaces.Up] = tranformed[VoxelFaces.Up];
+    const start = Vector3Like.Create(...points[0]);
+    const end = Vector3Like.Create(...points[1]);
+    const quads = [];
+    //top
+    quads[VoxelFaces.Up] = Quad.Create([
+        [end.x, end.y, end.z],
+        [start.x, end.y, end.z],
+        [start.x, end.y, start.z],
+        [end.x, end.y, start.z],
+    ]);
+    //bottom
+    quads[VoxelFaces.Down] = Quad.Create([
+        [start.x, start.y, end.z],
+        [end.x, start.y, end.z],
+        [end.x, start.y, start.z],
+        [start.x, start.y, start.z],
+    ]);
+    //north
+    quads[VoxelFaces.North] = Quad.Create([
+        [start.x, end.y, end.z],
+        [end.x, end.y, end.z],
+        [end.x, start.y, end.z],
+        [start.x, start.y, end.z],
+    ]);
+    //south
+    quads[VoxelFaces.South] = Quad.Create([
+        [end.x, end.y, start.z],
+        [start.x, end.y, start.z],
+        [start.x, start.y, start.z],
+        [end.x, start.y, start.z],
+    ]);
+    //east
+    quads[VoxelFaces.East] = Quad.Create([
+        [end.x, end.y, end.z],
+        [end.x, end.y, start.z],
+        [end.x, start.y, start.z],
+        [end.x, start.y, end.z],
+    ]);
+    //west
+    quads[VoxelFaces.West] = Quad.Create([
+        [start.x, end.y, start.z],
+        [start.x, end.y, end.z],
+        [start.x, start.y, end.z],
+        [start.x, start.y, start.z],
+    ]);
+    // TransformBox(quads as any, transform);
+    const quadBounds = new Array(quads.length);
+    for (let i = 0; i < quads.length; i++) {
+        const positions = [];
+        const quadPositions = quads[i].positions.getAsArray();
+        for (let i = 0; i < 4; i++) {
+            positions.push([
+                quadPositions[i].x,
+                quadPositions[i].y,
+                quadPositions[i].z,
+            ]);
+        }
+        quadBounds[i] = GetBounds(positions);
+    }
     vertexWeights[VoxelFaces.Up] = addQuadWeights(quads[VoxelFaces.Up], VoxelFaces.Up);
-    quads[VoxelFaces.Down] = tranformed[VoxelFaces.Down];
     vertexWeights[VoxelFaces.Down] = addQuadWeights(quads[VoxelFaces.Down], VoxelFaces.Down);
-    quads[VoxelFaces.North] = tranformed[VoxelFaces.North];
     vertexWeights[VoxelFaces.North] = addQuadWeights(quads[VoxelFaces.North], VoxelFaces.North);
-    quads[VoxelFaces.South] = tranformed[VoxelFaces.South];
     vertexWeights[VoxelFaces.South] = addQuadWeights(quads[VoxelFaces.South], VoxelFaces.South);
-    quads[VoxelFaces.East] = tranformed[VoxelFaces.East];
     vertexWeights[VoxelFaces.East] = addQuadWeights(quads[VoxelFaces.East], VoxelFaces.East);
-    quads[VoxelFaces.West] = tranformed[VoxelFaces.West];
     vertexWeights[VoxelFaces.West] = addQuadWeights(quads[VoxelFaces.West], VoxelFaces.West);
     return {
         quads,

package/Mesher/Models/Common/Calc/CalcConstants.d.ts

@@ -1,7 +1,7 @@
-import { QuadVerticies } from "@amodx/meshing/Geometry.types";
+import { QuadVerticies } from "../../../Geomtry/Geometry.types";
 import { VoxelFaces } from "../../../../Math";
 import { Vec3Array, Vec4Array } from "@amodx/math";
-import { Quad } from "@amodx/meshing/Primitives/Quad";
+import { Quad } from "../../../Geomtry/Primitives/Quad";
 export declare const GradientCheckSets: Record<VoxelFaces, Record<QuadVerticies, number[]>>;
 export declare const GradientCheckSetsArray: Int8Array;
 export declare const GeometryCheckSetIndexes: Record<VoxelFaces, Record<QuadVerticies, [number, number, number]>>;

package/Mesher/Models/Common/Calc/CalcConstants.js

@@ -1,7 +1,8 @@
-import { QuadVerticies, QuadVerticiesArray, } from "@amodx/meshing/Geometry.types";
+import { QuadVerticies, QuadVerticiesArray, } from "../../../Geomtry/Geometry.types";
 import { VoxelFaces, VoxelFacesArray } from "../../../../Math";
 import { VoxelRelativeCubeIndex } from "../../../../Models/Indexing/VoxelRelativeCubeIndex";
-import { LightData } from "../../../../Voxels/LightData";
+import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
+const lightData = new VoxelLightData();
 export const GradientCheckSets = [];
 GradientCheckSets[VoxelFaces.Up] = [];
 GradientCheckSets[VoxelFaces.Up][QuadVerticies.TopRight] = [
@@ -316,10 +317,10 @@ const lightValues3 = [0, 0, 0, 0];
 const lightValues4 = [0, 0, 0, 0];
 const lightValues5 = [0, 0, 0, 0];
 export function getInterpolationValue(value, weights) {
-    LightData.getLightValuesToRef(value[0], lightValues1);
-    LightData.getLightValuesToRef(value[1], lightValues2);
-    LightData.getLightValuesToRef(value[2], lightValues3);
-    LightData.getLightValuesToRef(value[3], lightValues4);
+    lightData.getLightValuesToRef(value[0], lightValues1);
+    lightData.getLightValuesToRef(value[1], lightValues2);
+    lightData.getLightValuesToRef(value[2], lightValues3);
+    lightData.getLightValuesToRef(value[3], lightValues4);
     lightValues5[0] =
         lightValues1[0] * weights[0] +
             lightValues2[0] * weights[1] +
@@ -340,7 +341,7 @@ export function getInterpolationValue(value, weights) {
             lightValues2[3] * weights[1] +
             lightValues3[3] * weights[2] +
             lightValues4[3] * weights[3];
-    return LightData.setLightValues(lightValues5);
+    return lightData.setLightValues(lightValues5);
 }
 export const addQuadWeights = (quad, direction) => {
     const returnArray = [];

package/Mesher/Models/Common/Calc/FaceDataCalc.js

@@ -1,6 +1,7 @@
-import { LightData } from "../../../../Voxels/LightData.js";
 import { VoxelFaceDirections } from "../../../../Math/index.js";
 import { GradientCheckSets } from "./CalcConstants.js";
+import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData.js";
+const lightData = new VoxelLightData();
 const currentLightValues = new Uint16Array([0, 0, 0, 0]);
 const loadedLightValues = new Uint16Array([0, 0, 0, 0]);
 const faceLength = 9 * 4;
@@ -19,7 +20,7 @@ export const FaceDataCalc = {
         for (let vertex = 0; vertex < 4; vertex++) {
             if (settings.doLight) {
                 tool.lightData[face][vertex] = light;
-                LightData.getLightValuesToRef(light, currentLightValues);
+                lightData.getLightValuesToRef(light, currentLightValues);
             }
             for (let i = 0; i < 9; i += 3) {
                 const loadedVoxel = tool.nVoxel.getVoxel(GradientCheckSets[face][vertex][i] + tool.position.x, GradientCheckSets[face][vertex][i + 1] + tool.position.y, GradientCheckSets[face][vertex][i + 2] + tool.position.z);
@@ -31,7 +32,7 @@ export const FaceDataCalc = {
                 /*
               Do Light
               */
-                LightData.getLightValuesToRef(nl, loadedLightValues);
+                lightData.getLightValuesToRef(nl, loadedLightValues);
                 currentLightValues[0] =
                     currentLightValues[0] < loadedLightValues[0]
                         ? loadedLightValues[0]
@@ -50,7 +51,7 @@ export const FaceDataCalc = {
                         : currentLightValues[3];
             }
             tool.lightData[face][vertex] =
-                LightData.setLightValues(currentLightValues);
+                lightData.setLightValues(currentLightValues);
         }
     },
 };

package/Mesher/Models/Common/QuadGeometryNode.d.ts

@@ -1,8 +1,8 @@
 import { Vec3Array } from "@amodx/math";
 import { VoxelFaces } from "../../../Math";
 import { VoxelQuadGeometryNode } from "../../../Models/VoxelModel.types";
-import { Quad } from "@amodx/meshing/Primitives/Quad";
-import { VoxelGeometryTransform } from "../../../Voxels/VoxelSyncData";
+import { Quad } from "../../Geomtry/Primitives/Quad";
+import { VoxelGeometryTransform } from "../../../Voxels/Types/VoxelModelCompiledData.types";
 export declare function GetQuadGeometryData(data: VoxelQuadGeometryNode, transform: VoxelGeometryTransform): {
     quad: Quad;
     vertexWeights: import("./Calc/CalcConstants").QuadVertexWeights;

package/Mesher/Models/Common/QuadGeometryNode.js

@@ -1,6 +1,6 @@
 import { Vector3Like } from "@amodx/math";
 import { VoxelFaces } from "../../../Math";
-import { Quad } from "@amodx/meshing/Primitives/Quad";
+import { Quad } from "../../Geomtry/Primitives/Quad";
 import { addQuadWeights, closestUnitNormal, } from "./Calc/CalcConstants";
 import { TransformQuad } from "../../../Models/Shared/Transform";
 import { GetBounds } from "./BoundsFunctions";

package/Mesher/Models/Nodes/Custom/Liquid/FlowGradient.d.ts

@@ -1,6 +1,11 @@
 import type { VoxelMesherDataTool } from "../../../../../Mesher/Tools/VoxelMesherDataTool";
-import { QuadScalarVertexData } from "@amodx/meshing/Primitives/QuadVertexData";
-export declare const FlowGradient: {
-    getLevel(tool: VoxelMesherDataTool, x: number, y: number, z: number): number;
-    calculate(tool: VoxelMesherDataTool, flowStates: QuadScalarVertexData): QuadScalarVertexData;
-};
+import { QuadScalarVertexData } from "../../../../Geomtry/Primitives/QuadVertexData";
+import { CompassAngles } from "@amodx/math";
+export declare enum FlowVerticies {
+    NorthEast = 0,
+    NorthWest = 1,
+    SouthWest = 2,
+    SouthEsat = 3
+}
+export declare function getFlowAngle(vertexLevel: QuadScalarVertexData): [angle: CompassAngles, flow: number];
+export declare function getFlowGradient(tool: VoxelMesherDataTool, flowStates: QuadScalarVertexData): QuadScalarVertexData;

package/Mesher/Models/Nodes/Custom/Liquid/FlowGradient.js

@@ -1,71 +1,162 @@
-import { QuadVerticies } from "@amodx/meshing/Geometry.types";
+import { QuadVerticies } from "../../../../Geomtry/Geometry.types";
+import { CompassAngles } from "@amodx/math";
+var FlowStates;
+(function (FlowStates) {
+    FlowStates[FlowStates["None"] = 0] = "None";
+    FlowStates[FlowStates["Down"] = 1] = "Down";
+    FlowStates[FlowStates["Up"] = 2] = "Up";
+})(FlowStates || (FlowStates = {}));
+export var FlowVerticies;
+(function (FlowVerticies) {
+    FlowVerticies[FlowVerticies["NorthEast"] = 0] = "NorthEast";
+    FlowVerticies[FlowVerticies["NorthWest"] = 1] = "NorthWest";
+    FlowVerticies[FlowVerticies["SouthWest"] = 2] = "SouthWest";
+    FlowVerticies[FlowVerticies["SouthEsat"] = 3] = "SouthEsat";
+})(FlowVerticies || (FlowVerticies = {}));
 const checkSets = {
-    [QuadVerticies.TopRight]: [
-        1, 0, 0, 1,
-        //corner
+    [FlowVerticies.NorthEast]: [
+        //1
+        1, 0,
+        //2
+        0, 1,
+        //3
         1, 1,
     ],
-    [QuadVerticies.TopLeft]: [
-        -1, 0, 0, 1,
-        //corner
+    [FlowVerticies.NorthWest]: [
+        //1
+        -1, 0,
+        //2
+        0, 1,
+        //3
         -1, 1,
     ],
-    [QuadVerticies.BottomLeft]: [
-        -1, 0, 0, -1,
-        //corner
+    [FlowVerticies.SouthWest]: [
+        //1
+        -1, 0,
+        //2
+        0, -1,
+        //3
         -1, -1,
     ],
-    [QuadVerticies.BottomRight]: [
-        1, 0, 0, -1,
-        //corner
+    [FlowVerticies.SouthEsat]: [
+        //1
+        1, 0,
+        //2
+        0, -1,
+        //3
         1, -1,
     ],
 };
-export const FlowGradient = {
-    getLevel(tool, x, y, z) {
-        const voxel = tool.nVoxel.getVoxel(x, y, z);
-        if (!voxel || !voxel.isRenderable())
-            return -1;
-        if (!tool.voxel.isSameVoxel(voxel))
-            return -1;
-        const level = voxel.getLevel();
-        const levelState = voxel.getLevelState();
-        if (levelState > 0)
-            return 7;
-        return level;
-    },
-    calculate(tool, flowStates) {
-        const cl = tool.voxel.getLevel();
-        const cs = tool.voxel.getLevelState();
-        let log = false;
-        if (tool.position.x == -1 && tool.position.z == -1) {
-            log = true;
+function getLevel(tool, x, y, z) {
+    const voxel = tool.nVoxel.getVoxel(x, y, z);
+    if (!voxel || !voxel.isRenderable())
+        return -1;
+    if (!tool.voxel.isSameVoxel(voxel))
+        return -1;
+    const level = voxel.getLevel();
+    const levelState = voxel.getLevelState();
+    if (levelState > 0)
+        return 7;
+    return level;
+}
+const returnData = [
+    CompassAngles.East,
+    0,
+];
+export function getFlowAngle(vertexLevel) {
+    if (vertexLevel.isAllEqualTo(7)) {
+        returnData[0] = 0;
+        returnData[1] = FlowStates.None;
+        return returnData;
+    }
+    const upRight = vertexLevel.vertices[QuadVerticies.TopRight];
+    const upLeft = vertexLevel.vertices[QuadVerticies.TopLeft];
+    const downLeft = vertexLevel.vertices[QuadVerticies.BottomLeft];
+    const downRight = vertexLevel.vertices[QuadVerticies.BottomRight];
+    const upEqual = upRight == upLeft;
+    const downEqual = downRight == downLeft;
+    const rightEqual = upRight == downRight;
+    const leftEqual = upLeft == downLeft;
+    if (upEqual && downEqual) {
+        if (upRight < downRight) {
+            returnData[0] = CompassAngles.North;
+            returnData[1] = FlowStates.Up;
+            return returnData;
         }
-        for (let vertex = 0; vertex <= 3; vertex++) {
-            const checkSet = checkSets[vertex];
-            let finalLevel = cl;
-            let zerCount = 0;
-            for (let i = 0; i < 6; i += 2) {
-                const cx = checkSet[i] + tool.position.x;
-                const cz = checkSet[i + 1] + tool.position.z;
-                const aboveLevel = this.getLevel(tool, cx, tool.position.y + 1, cz);
-                if (aboveLevel > 0) {
-                    finalLevel = 9;
-                    break;
-                }
-                const level = this.getLevel(tool, cx, tool.position.y, cz);
-                if (level == -1) {
-                    zerCount++;
-                }
-                if (finalLevel < level) {
-                    finalLevel = level;
-                }
+        if (upRight > downRight) {
+            returnData[0] = CompassAngles.South;
+            returnData[1] = FlowStates.Up;
+            return returnData;
+        }
+    }
+    if (rightEqual && leftEqual) {
+        if (upRight < upLeft) {
+            returnData[0] = CompassAngles.East;
+            returnData[1] = FlowStates.Up;
+            return returnData;
+        }
+        if (upRight > upLeft) {
+            returnData[0] = CompassAngles.West;
+            returnData[1] = FlowStates.Up;
+            return returnData;
+        }
+    }
+    if ((downRight < upRight && downRight < upLeft && downRight < downLeft) ||
+        (upLeft > upRight && upLeft > downRight && upLeft > downLeft)) {
+        returnData[0] = CompassAngles.SouthEast;
+        returnData[1] = FlowStates.Up;
+        return returnData;
+    }
+    if ((upLeft < upRight && upLeft < downRight && upLeft < downLeft) ||
+        (downRight > upRight && downRight > upLeft && downRight > downLeft)) {
+        returnData[0] = CompassAngles.NorthWest;
+        returnData[1] = FlowStates.Up;
+        return returnData;
+    }
+    if ((upRight < downRight && upRight < upLeft && upRight < downLeft) ||
+        (downLeft > downRight && downLeft > upLeft && downLeft > upRight)) {
+        returnData[0] = CompassAngles.NorthEast;
+        returnData[1] = FlowStates.Up;
+        return returnData;
+    }
+    if ((downLeft < downRight && downLeft < upLeft && downLeft < upRight) ||
+        (upRight > downRight && upRight > upLeft && upRight > downLeft)) {
+        returnData[0] = CompassAngles.SouthWest;
+        returnData[1] = FlowStates.Up;
+        return returnData;
+    }
+    returnData[0] = CompassAngles.North;
+    returnData[1] = FlowStates.Up;
+    return returnData;
+}
+export function getFlowGradient(tool, flowStates) {
+    const cl = tool.voxel.getLevel();
+    const cs = tool.voxel.getLevelState();
+    for (let vertex = 0; vertex <= 3; vertex++) {
+        const checkSet = checkSets[vertex];
+        let finalLevel = cl;
+        let zerCount = 0;
+        for (let i = 0; i < 6; i += 2) {
+            const cx = checkSet[i] + tool.position.x;
+            const cz = checkSet[i + 1] + tool.position.z;
+            const aboveLevel = getLevel(tool, cx, tool.position.y + 1, cz);
+            if (aboveLevel > 0) {
+                flowStates.vertices[vertex] = 9;
+                finalLevel = 9;
+                break;
             }
-            if (cl !== 7 && zerCount >= 1 && finalLevel < 7 && finalLevel > 3) {
-                finalLevel = 3;
+            const level = getLevel(tool, cx, tool.position.y, cz);
+            if (level == -1) {
+                zerCount++;
+            }
+            if (finalLevel < level) {
+                finalLevel = level;
             }
-            flowStates.vertices[vertex] = finalLevel;
         }
-        return flowStates;
-    },
-};
+        if (((finalLevel < 7 && finalLevel > 3) || cs == 1) && zerCount >= 2) {
+            finalLevel = 3;
+        }
+        flowStates.vertices[vertex] = finalLevel;
+    }
+    return flowStates;
+}

package/Mesher/Models/Nodes/Custom/Liquid/LiquidGeomtryNode.d.ts

@@ -2,7 +2,7 @@ import { Vector3Like } from "@amodx/math";
 import { VoxelMesherDataTool } from "Mesher/Tools/VoxelMesherDataTool";
 import { GeoemtryNode } from "../../GeometryNode";
 import { VoxelCustomGeomtryNode } from "../../../../../Models/VoxelModel.types";
-import { QuadScalarVertexData } from "@amodx/meshing/Primitives/QuadVertexData";
+import { QuadScalarVertexData } from "../../../../Geomtry/Primitives/QuadVertexData";
 import { VoxelFaces } from "../../../../../Math";
 import type { LiquidVoxelModelArgs } from "../../../../../Models/Defaults/LiquidVoxelModel";
 export declare class LiquidGeometryNode extends GeoemtryNode<VoxelCustomGeomtryNode, LiquidVoxelModelArgs> {