@divinevoxel/vlox 0.0.0

package/Mesher/Calc/CalcConstants.js

@@ -0,0 +1,375 @@
+import { QuadVerticies, QuadVerticiesArray, } from "@amodx/meshing/Geometry.types";
+import { VoxelFaces, VoxelFacesArray } from "../../Math";
+import { VoxelRelativeCubeIndex } from "../../VoxelModels/Indexing/VoxelRelativeCubeIndex";
+import { LightData } from ".../../Data/LightData";
+export const GradientCheckSets = [];
+GradientCheckSets[VoxelFaces.Up] = [];
+GradientCheckSets[VoxelFaces.Up][QuadVerticies.TopRight] = [
+    //1
+    1, 1, 0,
+    //2
+    0, 1, 1,
+    //3
+    1, 1, 1,
+];
+GradientCheckSets[VoxelFaces.Up][QuadVerticies.TopLeft] = [
+    //1
+    -1, 1, 0,
+    //2
+    0, 1, 1,
+    //3
+    -1, 1, 1,
+];
+GradientCheckSets[VoxelFaces.Up][QuadVerticies.BottomLeft] = [
+    //1
+    -1, 1, 0,
+    //2
+    0, 1, -1,
+    //3
+    -1, 1, -1,
+];
+GradientCheckSets[VoxelFaces.Up][QuadVerticies.BottomRight] = [
+    //1
+    1, 1, 0,
+    //2
+    0, 1, -1,
+    //3
+    1, 1, -1,
+];
+GradientCheckSets[VoxelFaces.Down] = [];
+GradientCheckSets[VoxelFaces.Down][QuadVerticies.TopRight] = [
+    //1
+    -1, -1, 0,
+    //2
+    0, -1, 1,
+    //3
+    -1, -1, 1,
+];
+GradientCheckSets[VoxelFaces.Down][QuadVerticies.TopLeft] = [
+    //1
+    1, -1, 0,
+    //2
+    0, -1, 1,
+    //3
+    1, -1, 1,
+];
+GradientCheckSets[VoxelFaces.Down][QuadVerticies.BottomLeft] = [
+    //1
+    1, -1, 0,
+    //2
+    0, -1, -1,
+    //3
+    1, -1, -1,
+];
+GradientCheckSets[VoxelFaces.Down][QuadVerticies.BottomRight] = [
+    //1
+    -1, -1, 0,
+    //2
+    0, -1, -1,
+    //3
+    -1, -1, -1,
+];
+GradientCheckSets[VoxelFaces.East] = [];
+GradientCheckSets[VoxelFaces.East][QuadVerticies.TopRight] = [
+    //1
+    1, 0, 1,
+    //2
+    1, 1, 0,
+    //3
+    1, 1, 1,
+];
+GradientCheckSets[VoxelFaces.East][QuadVerticies.TopLeft] = [
+    //1
+    1, 0, -1,
+    //2
+    1, 1, 0,
+    //3
+    1, 1, -1,
+];
+GradientCheckSets[VoxelFaces.East][QuadVerticies.BottomLeft] = [
+    //1
+    1, 0, -1,
+    //2
+    1, -1, 0,
+    //3
+    1, -1, -1,
+];
+GradientCheckSets[VoxelFaces.East][QuadVerticies.BottomRight] = [
+    //1
+    1, 0, 1,
+    //2
+    1, -1, 0,
+    //3
+    1, -1, 1,
+];
+GradientCheckSets[VoxelFaces.West] = [];
+GradientCheckSets[VoxelFaces.West][QuadVerticies.TopRight] = [
+    //1
+    -1, 0, -1,
+    //2
+    -1, 1, 0,
+    //3
+    -1, 1, -1,
+];
+GradientCheckSets[VoxelFaces.West][QuadVerticies.TopLeft] = [
+    //1
+    -1, 0, 1,
+    //2
+    -1, 1, 0,
+    //3
+    -1, 1, 1,
+];
+GradientCheckSets[VoxelFaces.West][QuadVerticies.BottomLeft] = [
+    //1
+    -1, 0, 1,
+    //2
+    -1, -1, 0,
+    //3
+    -1, -1, 1,
+];
+GradientCheckSets[VoxelFaces.West][QuadVerticies.BottomRight] = [
+    //1
+    -1, 0, -1,
+    //2
+    -1, -1, 0,
+    //3
+    -1, -1, -1,
+];
+GradientCheckSets[VoxelFaces.South] = [];
+GradientCheckSets[VoxelFaces.South][QuadVerticies.TopRight] = [
+    //1
+    1, 0, -1,
+    //2
+    0, 1, -1,
+    //3
+    1, 1, -1,
+];
+GradientCheckSets[VoxelFaces.South][QuadVerticies.TopLeft] = [
+    //1
+    -1, 0, -1,
+    //2
+    0, 1, -1,
+    //3
+    -1, 1, -1,
+];
+GradientCheckSets[VoxelFaces.South][QuadVerticies.BottomLeft] = [
+    //1
+    -1, 0, -1,
+    //2
+    0, -1, -1,
+    //3
+    -1, -1, -1,
+];
+GradientCheckSets[VoxelFaces.South][QuadVerticies.BottomRight] = [
+    //1
+    1, 0, -1,
+    //2
+    0, -1, -1,
+    //3
+    1, -1, -1,
+];
+GradientCheckSets[VoxelFaces.North] = [];
+GradientCheckSets[VoxelFaces.North][QuadVerticies.TopRight] = [
+    //1
+    -1, 0, 1,
+    //2
+    0, 1, 1,
+    //3
+    -1, 1, 1,
+];
+GradientCheckSets[VoxelFaces.North][QuadVerticies.TopLeft] = [
+    //1
+    1, 0, 1,
+    //2
+    0, 1, 1,
+    //3
+    1, 1, 1,
+];
+GradientCheckSets[VoxelFaces.North][QuadVerticies.BottomLeft] = [
+    //1
+    1, 0, 1,
+    //2
+    0, -1, 1,
+    //3
+    1, -1, 1,
+];
+GradientCheckSets[VoxelFaces.North][QuadVerticies.BottomRight] = [
+    //1
+    -1, 0, 1,
+    //2
+    0, -1, 1,
+    //3
+    -1, -1, 1,
+];
+export const GradientCheckSetsArray = new Int8Array(6 * 4 * 9);
+const verts = [
+    QuadVerticies.TopRight,
+    QuadVerticies.TopLeft,
+    QuadVerticies.BottomLeft,
+    QuadVerticies.BottomRight,
+];
+const faceLength = 9 * 4;
+for (const face of VoxelFacesArray) {
+    for (let v = 0; v < verts.length; v++) {
+        for (let i = 0; i < 9; i++) {
+            GradientCheckSetsArray[face * faceLength + verts[v] * 9 + i] =
+                GradientCheckSets[face][verts[v]][i];
+        }
+    }
+}
+export const GeometryCheckSetIndexes = [];
+for (const face of VoxelFacesArray) {
+    GeometryCheckSetIndexes[face] ??= [];
+    for (let v = 0; v < verts.length; v++) {
+        GeometryCheckSetIndexes[face][verts[v]] ??= [];
+        let checkSetIndex = 0;
+        for (let i = 0; i < 9; i += 3) {
+            const x = GradientCheckSets[face][verts[v]][i];
+            const y = GradientCheckSets[face][verts[v]][i + 1];
+            const z = GradientCheckSets[face][verts[v]][i + 2];
+            GeometryCheckSetIndexes[face][verts[v]][checkSetIndex] =
+                VoxelRelativeCubeIndex.getIndex(x, y, z);
+            checkSetIndex++;
+        }
+    }
+}
+export const CenterDirectionIndex = VoxelRelativeCubeIndex.getIndex(0, 0, 0);
+export const DirectionIndexes = [];
+DirectionIndexes[VoxelFaces.Up] = VoxelRelativeCubeIndex.getIndex(0, 1, 0);
+DirectionIndexes[VoxelFaces.Down] = VoxelRelativeCubeIndex.getIndex(0, -1, 0);
+DirectionIndexes[VoxelFaces.North] = VoxelRelativeCubeIndex.getIndex(0, 0, 1);
+DirectionIndexes[VoxelFaces.South] = VoxelRelativeCubeIndex.getIndex(0, 0, -1);
+DirectionIndexes[VoxelFaces.East] = VoxelRelativeCubeIndex.getIndex(1, 0, 0);
+DirectionIndexes[VoxelFaces.West] = VoxelRelativeCubeIndex.getIndex(-1, 0, 0);
+/**
+quad flip
+2       1
+|    /  |
+|   /   |
+|  /    |
+| /     |
+3       4
+*/
+function isMax3(num, v1, v2, v3) {
+    return num > v1 && num > v2 && num > v3;
+}
+function isAllEqual(num, v1, v2, v3) {
+    return num == v1 && v1 == v2 && v2 == v3;
+}
+export function shouldCauseFlip(topRight, topLeft, bottomLeft, bottomRight) {
+    if (isAllEqual(topRight, topLeft, bottomRight, bottomLeft))
+        return false;
+    if (isMax3(bottomRight, topLeft, bottomLeft, topRight) ||
+        isMax3(topLeft, bottomLeft, bottomRight, topRight))
+        return false;
+    if (isMax3(topRight, topLeft, bottomLeft, bottomRight) ||
+        isMax3(bottomLeft, topLeft, bottomRight, topRight))
+        return true;
+    return (topRight + bottomLeft) / 2 > (topLeft + bottomRight) / 2;
+}
+function getInterpolationWeights(x, y, flip = false) {
+    x = Math.max(0, Math.min(1, x));
+    y = Math.max(0, Math.min(1, y));
+    let w1 = (1 - x) * (1 - y); // Weight for v1 = (0, 0)
+    let w2 = x * (1 - y); // Weight for v2 = (1, 0)
+    let w3 = x * y; // Weight for v3 = (1, 1)
+    let w4 = (1 - x) * y; // Weight for v4 = (0, 1)
+    return flip ? [w4, w3, w2, w1] : [w3, w4, w1, w2];
+}
+export function getVertexWeights(face, x, y, z) {
+    let flip = false;
+    let u, v;
+    switch (face) {
+        case VoxelFaces.Up:
+            u = x;
+            v = z;
+            break;
+        case VoxelFaces.Down:
+            u = x;
+            v = z;
+            flip = true;
+            break;
+        case VoxelFaces.North:
+            u = x;
+            v = y;
+            flip = true;
+            break;
+        case VoxelFaces.South:
+            u = x;
+            v = y;
+            break;
+        case VoxelFaces.East:
+            u = z;
+            v = y;
+            break;
+        case VoxelFaces.West:
+            u = z;
+            v = y;
+            flip = true;
+            break;
+    }
+    return getInterpolationWeights(u, v, flip);
+}
+const lightValues1 = [0, 0, 0, 0];
+const lightValues2 = [0, 0, 0, 0];
+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);
+    lightValues5[0] =
+        lightValues1[0] * weights[0] +
+            lightValues2[0] * weights[1] +
+            lightValues3[0] * weights[2] +
+            lightValues4[0] * weights[3];
+    lightValues5[1] =
+        lightValues1[1] * weights[0] +
+            lightValues2[1] * weights[1] +
+            lightValues3[1] * weights[2] +
+            lightValues4[1] * weights[3];
+    lightValues5[2] =
+        lightValues1[2] * weights[0] +
+            lightValues2[2] * weights[1] +
+            lightValues3[2] * weights[2] +
+            lightValues4[2] * weights[3];
+    lightValues5[3] =
+        lightValues1[3] * weights[0] +
+            lightValues2[3] * weights[1] +
+            lightValues3[3] * weights[2] +
+            lightValues4[3] * weights[3];
+    return LightData.setLightValues(lightValues5);
+}
+export const addQuadWeights = (quad, direction) => {
+    const returnArray = [];
+    for (const vertex of QuadVerticiesArray) {
+        const { x, y, z } = quad.positions.vertices[vertex];
+        returnArray[vertex] = getVertexWeights(direction, x, y, z);
+    }
+    return returnArray;
+};
+export function closestUnitNormal(v) {
+    const [x, y, z] = v;
+    let maxDotOverMagnitude = -Infinity;
+    let bestS = [0, 0, 0];
+    for (const sx of [-1, 0, 1]) {
+        for (const sy of [-1, 0, 1]) {
+            for (const sz of [-1, 0, 1]) {
+                if (sx === 0 && sy === 0 && sz === 0)
+                    continue; // Skip the zero vector
+                const sMagnitude = Math.sqrt(sx * sx + sy * sy + sz * sz);
+                const vDotS = x * sx + y * sy + z * sz;
+                const dotOverMagnitude = vDotS / sMagnitude;
+                if (dotOverMagnitude > maxDotOverMagnitude) {
+                    maxDotOverMagnitude = dotOverMagnitude;
+                    bestS = [sx, sy, sz];
+                }
+            }
+        }
+    }
+    // Normalize the best vector to unit length
+    const sMagnitude = Math.sqrt(bestS[0] * bestS[0] + bestS[1] * bestS[1] + bestS[2] * bestS[2]);
+    return [bestS[0] / sMagnitude, bestS[1] / sMagnitude, bestS[2] / sMagnitude];
+}

package/Mesher/Calc/Flow/FlowGradient.d.ts

@@ -0,0 +1,5 @@
+import type { VoxelMesherDataTool } from "../../Tools/VoxelMesherDataTool";
+export declare const FlowGradient: {
+    getLevel(tool: VoxelMesherDataTool, x: number, y: number, z: number): number;
+    calculate(tool: VoxelMesherDataTool): void;
+};

package/Mesher/Calc/Flow/FlowGradient.js

@@ -0,0 +1,74 @@
+import { QuadScalarVertexData } from "@amodx/meshing/Classes/QuadVertexData";
+import { QuadVerticies } from "@amodx/meshing/Geometry.types";
+const checkSets = {
+    [QuadVerticies.TopRight]: [
+        1, 0, 0, 1,
+        //corner
+        1, 1,
+    ],
+    [QuadVerticies.TopLeft]: [
+        -1, 0, 0, 1,
+        //corner
+        -1, 1,
+    ],
+    [QuadVerticies.BottomLeft]: [
+        -1, 0, 0, -1,
+        //corner
+        -1, -1,
+    ],
+    [QuadVerticies.BottomRight]: [
+        1, 0, 0, -1,
+        //corner
+        1, -1,
+    ],
+};
+const flowStates = new QuadScalarVertexData();
+export const FlowGradient = {
+    getLevel(tool, x, y, z) {
+        if (!tool.nVoxel.loadInAt(x, y, z))
+            return -1;
+        if (!tool.nVoxel.isRenderable())
+            return -1;
+        if (!tool.voxel.isSameVoxel(tool.nVoxel))
+            return -1;
+        const level = tool.nVoxel.getLevel();
+        const levelState = tool.nVoxel.getLevelState();
+        if (levelState > 0)
+            return 7;
+        return level;
+    },
+    calculate(tool) {
+        const cl = tool.voxel.getLevel();
+        const cs = tool.voxel.getLevelState();
+        let log = false;
+        if (tool.voxel.x == -1 && tool.voxel.z == -1) {
+            log = true;
+        }
+        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.voxel.x;
+                const cz = checkSet[i + 1] + tool.voxel.z;
+                const aboveLevel = this.getLevel(tool, cx, tool.voxel.y + 1, cz);
+                if (aboveLevel > 0) {
+                    finalLevel = 9;
+                    break;
+                }
+                const level = this.getLevel(tool, cx, tool.voxel.y, cz);
+                if (level == -1) {
+                    zerCount++;
+                }
+                if (finalLevel < level) {
+                    finalLevel = level;
+                }
+            }
+            if (cl !== 7 && zerCount >= 1 && finalLevel < 7 && finalLevel > 3) {
+                finalLevel = 3;
+            }
+            flowStates.vertices[vertex] = finalLevel;
+        }
+        tool.getWorldLevel().setFromQuadData(flowStates);
+    },
+};

package/Mesher/Calc/Light/FaceDataCalc.d.ts

@@ -0,0 +1,9 @@
+import type { VoxelMesherDataTool } from "../../Tools/VoxelMesherDataTool.js";
+import { VoxelFaces } from "../../../Math";
+export declare const FaceDataCalc: {
+    settings: {
+        doAO: boolean;
+        doLight: boolean;
+    };
+    calculate(face: VoxelFaces, tool: VoxelMesherDataTool): void;
+};

package/Mesher/Calc/Light/FaceDataCalc.js

@@ -0,0 +1,58 @@
+import { LightData } from "../../../Data/LightData.js";
+import { VoxelFaceDirections } from "../../../Math";
+import { GradientCheckSets } from "../CalcConstants.js";
+const currentLightValues = new Uint16Array([0, 0, 0, 0]);
+const loadedLightValues = new Uint16Array([0, 0, 0, 0]);
+const faceLength = 9 * 4;
+const settings = {
+    doAO: true,
+    doLight: true,
+};
+export const FaceDataCalc = {
+    settings,
+    calculate(face, tool) {
+        let light = tool.voxel.getLight();
+        const faceNormal = VoxelFaceDirections[face];
+        tool.nVoxel.loadInAt(tool.voxel.x + faceNormal[0], tool.voxel.y + faceNormal[1], tool.voxel.z + faceNormal[2]);
+        const otherLight = tool.nVoxel.getLight();
+        light = otherLight >= 0 ? otherLight : light >= 0 ? light : 0;
+        const baseIndex = face * faceLength;
+        for (let vertex = 0; vertex < 4; vertex++) {
+            const checkSetIndex = baseIndex + vertex * 9;
+            if (settings.doLight) {
+                tool.lightData[face][vertex] = light;
+                LightData.getLightValuesToRef(light, currentLightValues);
+            }
+            for (let i = 0; i < 9; i += 3) {
+                const didLoad = tool.nVoxel.loadInAt(GradientCheckSets[face][vertex][i] + tool.voxel.x, GradientCheckSets[face][vertex][i + 1] + tool.voxel.y, GradientCheckSets[face][vertex][i + 2] + tool.voxel.z);
+                if (!settings.doLight || !didLoad)
+                    continue;
+                const nl = tool.nVoxel.getLight();
+                if (nl <= 0)
+                    continue;
+                /*
+              Do Light
+              */
+                LightData.getLightValuesToRef(nl, loadedLightValues);
+                currentLightValues[0] =
+                    currentLightValues[0] < loadedLightValues[0]
+                        ? loadedLightValues[0]
+                        : currentLightValues[0];
+                currentLightValues[1] =
+                    currentLightValues[1] < loadedLightValues[1]
+                        ? loadedLightValues[1]
+                        : currentLightValues[1];
+                currentLightValues[2] =
+                    currentLightValues[2] < loadedLightValues[2]
+                        ? loadedLightValues[2]
+                        : currentLightValues[2];
+                currentLightValues[3] =
+                    currentLightValues[3] < loadedLightValues[3]
+                        ? loadedLightValues[3]
+                        : currentLightValues[3];
+            }
+            tool.lightData[face][vertex] =
+                LightData.setLightValues(currentLightValues);
+        }
+    },
+};

package/Mesher/Calc/Light/LightGradient.d.ts

@@ -0,0 +1,13 @@
+import type { VoxelMesherDataTool } from "../../Tools/VoxelMesherDataTool";
+import { VoxelFaces } from "../../../Math";
+import { Vector3Like } from "@amodx/math";
+export declare const LightGradient: {
+    tool: VoxelMesherDataTool;
+    settings: {
+        doAO: boolean;
+        doRGB: boolean;
+        doSun: boolean;
+    };
+    aoOffset: Vector3Like;
+    calculate(face: VoxelFaces, tool: VoxelMesherDataTool, ignoreAO?: boolean): void;
+};