@divinevoxel/vlox 0.0.73 → 0.0.75

package/Mesher/Geomtry/VoxelMeshBVHStructCursor.d.ts

@@ -0,0 +1,22 @@
+export declare class VoxelMeshBVHStructCursor {
+    data: Float32Array;
+    get minX(): number;
+    get minY(): number;
+    get minZ(): number;
+    get maxX(): number;
+    get maxY(): number;
+    get maxZ(): number;
+    get voxelIndex(): number;
+    get active(): number;
+    get nodeType(): number;
+    trueIndex: number;
+    private index;
+    setIndex(index: number): void;
+    constructor(data: Float32Array);
+    setActive(): void;
+    setVoxelIndex(value: number): void;
+    setInnerNode(): void;
+    setGeomtryNode(): void;
+    updateMin(x: number, y: number, z: number): void;
+    updateMax(x: number, y: number, z: number): void;
+}

package/Mesher/Geomtry/VoxelMeshBVHStructCursor.js

@@ -0,0 +1,78 @@
+export class VoxelMeshBVHStructCursor {
+    data;
+    get minX() {
+        return this.data[this.trueIndex];
+    }
+    get minY() {
+        return this.data[this.trueIndex + 1];
+    }
+    get minZ() {
+        return this.data[this.trueIndex + 2];
+    }
+    get maxX() {
+        return this.data[this.trueIndex + 4];
+    }
+    get maxY() {
+        return this.data[this.trueIndex + 5];
+    }
+    get maxZ() {
+        return this.data[this.trueIndex + 6];
+    }
+    get voxelIndex() {
+        return this.data[this.trueIndex + 3];
+    }
+    get active() {
+        return this.data[this.trueIndex + 3];
+    }
+    get nodeType() {
+        return this.data[this.trueIndex + 7];
+    }
+    trueIndex = 0;
+    index = 0;
+    setIndex(index) {
+        this.trueIndex = index * 8;
+    }
+    constructor(data) {
+        this.data = data;
+    }
+    setActive() {
+        this.data[this.trueIndex + 3] = 1;
+    }
+    setVoxelIndex(value) {
+        this.data[this.trueIndex + 3] = value;
+    }
+    setInnerNode() {
+        this.data[this.trueIndex + 7] = 1;
+    }
+    setGeomtryNode() {
+        this.data[this.trueIndex + 7] = 2;
+    }
+    updateMin(x, y, z) {
+        const ix = this.trueIndex;
+        const iy = this.trueIndex + 1;
+        const iz = this.trueIndex + 2;
+        if (x < this.data[ix] || this.data[ix] == -Infinity) {
+            this.data[ix] = x;
+        }
+        if (y < this.data[iy] || this.data[iy] == -Infinity) {
+            this.data[iy] = y;
+        }
+        if (z < this.data[iz] || this.data[iz] == -Infinity) {
+            this.data[iz] = z;
+        }
+    }
+    updateMax(x, y, z) {
+        const ix = this.trueIndex + 4;
+        const iy = this.trueIndex + 5;
+        const iz = this.trueIndex + 6;
+        if (x > this.data[ix] || this.data[ix] == -Infinity) {
+            this.data[ix] = x;
+        }
+        if (y > this.data[iy] || this.data[iy] == -Infinity) {
+            this.data[iy] = y;
+        }
+        if (z > this.data[iz] || this.data[iz] == -Infinity) {
+            this.data[iz] = z;
+        }
+    }
+}

package/Mesher/Geomtry/VoxelMeshBuffers.js

@@ -3,7 +3,7 @@ export class VoxelVertexBuffer {
     sectorVertexSize;
     _buffers = [];
     sectorSize = 0;
-    constructor(vertexFloatSize, sectorVertexSize, startingSectorSize = 4) {
+    constructor(vertexFloatSize, sectorVertexSize, startingSectorSize = 8) {
         this.vertexFloatSize = vertexFloatSize;
         this.sectorVertexSize = sectorVertexSize;
         this.sectorSize = vertexFloatSize * sectorVertexSize;
@@ -28,7 +28,7 @@ export class VoxelVertexBuffer {
 export class VoxelIndiceBuffer {
     sectorSize;
     _buffers = [];
-    constructor(sectorSize, startingSectorSize = 4) {
+    constructor(sectorSize, startingSectorSize = 8) {
         this.sectorSize = sectorSize;
         for (let i = 0; i < startingSectorSize; i++) {
             this._buffers.push(new Uint32Array(sectorSize));

package/Mesher/Geomtry/VoxelMeshVertexStructCursor.d.ts

@@ -29,8 +29,14 @@ export declare class VoxelMeshVertexStructCursor {
     set normalY(value: number);
     get normalZ(): number;
     set normalZ(value: number);
-    get voxelData(): number;
-    set voxelData(value: number);
+    get voxelDataX(): number;
+    set voxelDataX(value: number);
+    get voxelDataY(): number;
+    set voxelDataY(value: number);
+    get voxelDataZ(): number;
+    set voxelDataZ(value: number);
+    get voxelDataW(): number;
+    set voxelDataW(value: number);
     get textureIndexX(): number;
     set textureIndexX(value: number);
     get textureIndexY(): number;
@@ -58,7 +64,7 @@ export declare class VoxelMeshVertexStructCursor {
     toJSON(): {
         position: number[];
         normal: number[];
-        voxelData: number;
+        voxelData: number[];
         textureIndex: number[];
         uv: number[];
         color: number[];

package/Mesher/Geomtry/VoxelMeshVertexStructCursor.js

@@ -62,13 +62,31 @@ export class VoxelMeshVertexStructCursor {
             value;
     }
     // voxel data
-    get voxelData() {
+    get voxelDataX() {
         return this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset];
     }
-    set voxelData(value) {
+    set voxelDataX(value) {
         this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset] =
             value;
     }
+    get voxelDataY() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset + 1];
+    }
+    set voxelDataY(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset + 1] = value;
+    }
+    get voxelDataZ() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset + 2];
+    }
+    set voxelDataZ(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset + 2] = value;
+    }
+    get voxelDataW() {
+        return this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset + 3];
+    }
+    set voxelDataW(value) {
+        this.data[this.trueIndex + VoxelMeshVertexStructCursor.VoxelDataOFfset + 3] = value;
+    }
     // texture index
     get textureIndexX() {
         return this.data[this.trueIndex + VoxelMeshVertexStructCursor.TextureIndexOffset];
@@ -142,7 +160,12 @@ export class VoxelMeshVertexStructCursor {
         return {
             position: [this.positionX, this.positionY, this.positionZ],
             normal: [this.normalX, this.normalY, this.normalZ],
-            voxelData: this.voxelData,
+            voxelData: [
+                this.voxelDataX,
+                this.voxelDataY,
+                this.voxelDataZ,
+                this.voxelDataW,
+            ],
             textureIndex: [
                 this.textureIndexX,
                 this.textureIndexY,

package/Mesher/Geomtry/VoxelShaderData.d.ts

@@ -1,3 +1,4 @@
+import { Vector4Like } from "@amodx/math";
 declare enum WindAffectedAnimStates {
     Panel = 1,
     CrossPanel = 2,
@@ -7,11 +8,13 @@ export declare class VoxelShaderData {
     static AnimationStates: {
         WindAffected: typeof WindAffectedAnimStates;
     };
+    static v: number;
     static LightMask: number;
     static AOMask: number;
+    static VertexMask: number;
     static AnimationMask: number;
     static TextureIndexMax: number;
     static createTextureIndex(index1: number, index2: number): number;
-    static createAttribute(light: number, ao: number, animation: number): number;
+    static create(light1: number, light2: number, light3: number, light4: number, ao1: number, ao2: number, ao3: number, ao4: number, animation: number, vertexIndex: number, ref?: Vector4Like): Vector4Like;
 }
 export {};

package/Mesher/Geomtry/VoxelShaderData.js

@@ -1,3 +1,4 @@
+import { Vector4Like } from "@amodx/math";
 var WindAffectedAnimStates;
 (function (WindAffectedAnimStates) {
     WindAffectedAnimStates[WindAffectedAnimStates["Panel"] = 1] = "Panel";
@@ -8,9 +9,11 @@ export class VoxelShaderData {
     static AnimationStates = {
         WindAffected: WindAffectedAnimStates,
     };
+    static v = 0xffff + 0xf + 0xf;
     static LightMask = 0xffff;
-    static AOMask = 0xf;
-    static AnimationMask = 0xfff;
+    static AOMask = 0b11;
+    static VertexMask = 0b11;
+    static AnimationMask = 0b11;
     static TextureIndexMax = 0xffff;
     static createTextureIndex(index1, index2) {
         let value = 0;
@@ -22,13 +25,25 @@ export class VoxelShaderData {
                 ((index2 & this.TextureIndexMax) << 16);
         return value;
     }
-    static createAttribute(light, ao, animation) {
-        let value = 0;
-        value = (value & ~(this.LightMask << 0)) | ((light & this.LightMask) << 0);
-        value = (value & ~(this.AOMask << 16)) | ((ao & this.AOMask) << 16);
-        value =
-            (value & ~(this.AnimationMask << 20)) |
-                ((animation & this.AnimationMask) << 20);
-        return value;
+    static create(light1, light2, light3, light4, ao1, ao2, ao3, ao4, animation, vertexIndex, ref = Vector4Like.Create()) {
+        let x = 0;
+        x |= (light1 & this.LightMask) << 0;
+        x |= (ao1 & this.AOMask) << 16;
+        x |= (ao2 & this.AOMask) << 18;
+        x |= (ao3 & this.AOMask) << 20;
+        x |= (ao4 & this.AOMask) << 22;
+        ref.x = x;
+        let y = 0;
+        y |= (light2 & this.LightMask) << 0;
+        y |= (animation & this.AnimationMask) << 16;
+        ref.y = y;
+        let z = 0;
+        z |= (light3 & this.LightMask) << 0;
+        z |= (vertexIndex & this.VertexMask) << 16;
+        ref.z = z;
+        let w = 0;
+        w |= (light4 & this.LightMask) << 0;
+        ref.w = w;
+        return ref;
     }
 }

package/Mesher/InitMesher.d.ts

@@ -1,2 +1,2 @@
-import { FinalCompiledVoxelModelData } from "../Voxels/Types/VoxelModelCompiledData.types";
+import { FinalCompiledVoxelModelData } from "../Voxels/Models/CompiledVoxelModel.types";
 export default function (materials: string[], modelData: FinalCompiledVoxelModelData): void;

package/Mesher/InitMesher.js

@@ -2,12 +2,18 @@ import { RenderedMaterials } from "./Models/RenderedMaterials";
 import { VoxelModelConstructorRegister } from "./Models/VoxelModelConstructorRegister.js";
 import { LiquidGeometryNode } from "./Models/Nodes/Custom/Liquid/LiquidGeomtryNode.js";
 import { VoxelConstructor } from "./Models/VoxelConstructor.js";
+import { AOOcclusionFaceIndex } from "../Voxels/Models/Indexing/AOOcclusionFaceIndex";
+import { CulledOcclusionFaceIndex } from "../Voxels/Models/Indexing/CulledOcclusionFaceIndex";
 export default function (materials, modelData) {
     RenderedMaterials.register(materials);
     VoxelModelConstructorRegister.registerCustomNode("liquid", LiquidGeometryNode);
     VoxelModelConstructorRegister.setGeometryPalette(modelData.geometryPalette);
     VoxelModelConstructorRegister.registerGeometry(modelData.geometry);
     VoxelModelConstructorRegister.registerModels(modelData.models);
+    VoxelModelConstructorRegister.aoIndex = new AOOcclusionFaceIndex(modelData.aoIndex);
+    VoxelModelConstructorRegister.faceCullIndex = new CulledOcclusionFaceIndex(modelData.faceCullIndex);
+    VoxelModelConstructorRegister.vertexHitMap = modelData.vertexHitMap;
+    VoxelModelConstructorRegister.faceCullMap = modelData.faceCullMap;
     for (const voxel of modelData.voxels) {
         VoxelModelConstructorRegister.registerVoxel(new VoxelConstructor(voxel.id, RenderedMaterials.meshersMap.get(voxel.materialId), VoxelModelConstructorRegister.modelData.get(voxel.modelId), voxel));
     }

package/Mesher/InitTask.js

@@ -2,15 +2,29 @@ import { Threads } from "@amodx/threads";
 import { WorldRegister } from "../World/WorldRegister";
 import { MeshSection } from "./Functions/MeshSection";
 import { TasksIds } from "../Tasks/TasksIds";
+import { getLocationData } from "../Util/LocationData";
+import { MeshSectionSnapShot } from "./Functions/MeshSectionSnapShot";
+import { SectionSnapShot, } from "../World/SnapShot/SectionSnapShot";
 export default function (rendererThread) {
-    Threads.registerTask(TasksIds.BuildSection, (location) => {
+    Threads.registerBinaryTask(TasksIds.BuildSection, (view) => {
         const transfers = [];
-        const section = MeshSection(location, transfers);
+        const section = MeshSection(getLocationData(view), transfers);
         if (!section)
             return;
         rendererThread.runTask("set-section", section, transfers);
     });
-    Threads.registerTask(TasksIds.BuildSector, (location) => {
+    const snapShot = new SectionSnapShot();
+    Threads.registerTask(TasksIds.BuildSectionSnapShot, (data, origin) => {
+        snapShot.restore(data);
+        const transfers = [];
+        const section = MeshSectionSnapShot(snapShot, transfers);
+        origin.runTask("cache-snap-shot", ...snapShot.transfer());
+        if (!section)
+            return;
+        rendererThread.runTask("set-section", section, transfers);
+    });
+    Threads.registerBinaryTask(TasksIds.BuildSector, (view, origin) => {
+        const location = getLocationData(view);
         const sector = WorldRegister.sectors.getAt(location);
         if (!sector) {
             console.warn("Tried building a sector that does not exists.", location);
@@ -21,6 +35,7 @@ export default function (rendererThread) {
             let [minY, maxY] = section.getMinMax();
             if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
                 continue;
+            const t = performance.now();
             const transfers = [];
             const sectionMesh = MeshSection([location[0], ...section.getPosition()], transfers);
             if (!sectionMesh)

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

@@ -1,15 +1,11 @@
 import { QuadVerticies } from "../../../Geomtry/Geometry.types";
 import { VoxelFaces } from "../../../../Math";
-import { Vec3Array, Vec4Array } from "@amodx/math";
-import { Quad } from "../../../Geomtry/Primitives/Quad";
+import { Vec4Array } from "@amodx/math";
 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]>>;
 export declare const CenterDirectionIndex: number;
 export declare const DirectionIndexes: Record<VoxelFaces, number>;
 export declare function shouldCauseFlip(topRight: number, topLeft: number, bottomLeft: number, bottomRight: number): boolean;
-export declare function getVertexWeights(face: VoxelFaces, x: number, y: number, z: number): Vec4Array;
 export declare function getInterpolationValue(value: Vec4Array, weights: Vec4Array): number;
 export type QuadVertexWeights = [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
-export declare const addQuadWeights: (quad: Quad, direction: VoxelFaces) => QuadVertexWeights;
-export declare function closestUnitNormal(v: Vec3Array): Vec3Array;

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

@@ -1,6 +1,6 @@
-import { QuadVerticies, QuadVerticiesArray, } from "../../../Geomtry/Geometry.types";
+import { QuadVerticies, } from "../../../Geomtry/Geometry.types";
 import { VoxelFaces, VoxelFacesArray } from "../../../../Math";
-import { VoxelRelativeCubeIndex } from "../../../../Models/Indexing/VoxelRelativeCubeIndex";
+import { VoxelRelativeCubeIndex } from "../../../../Voxels/Models/Indexing/VoxelRelativeCubeIndex";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
 export const GradientCheckSets = [];
 GradientCheckSets[VoxelFaces.Up] = [];
@@ -267,49 +267,6 @@ export function shouldCauseFlip(topRight, topLeft, bottomLeft, bottomRight) {
         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 lightData = new VoxelLightData();
 export function getInterpolationValue(value, weights) {
     return lightData.createLightValue(lightData.getS(value[0]) * weights[0] +
@@ -326,34 +283,3 @@ export function getInterpolationValue(value, weights) {
         lightData.getB(value[2]) * weights[2] +
         lightData.getB(value[3]) * weights[3]);
 }
-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/Models/Common/Faces/CullRulledFace.d.ts

@@ -0,0 +1,2 @@
+import { VoxelModelBuilder } from "../../VoxelModelBuilder";
+export declare function CullRulledFace(builder: VoxelModelBuilder, trueFaceIndex: number): boolean;

package/Mesher/Models/Common/Faces/CullRulledFace.js

@@ -0,0 +1,60 @@
+import { VoxelRelativeCubeIndexPositionMap } from "../../../../Voxels/Models/Indexing/VoxelRelativeCubeIndex";
+import { VoxelModelConstructorRegister } from "../../VoxelModelConstructorRegister";
+export function CullRulledFace(builder, trueFaceIndex) {
+    const faceIndexes = VoxelModelConstructorRegister.faceCullMap[trueFaceIndex];
+    if (!faceIndexes)
+        return true;
+    for (let i = 0; i < faceIndexes.length; i++) {
+        const directionIndex = faceIndexes[i];
+        const p = VoxelRelativeCubeIndexPositionMap[directionIndex];
+        const hashed = builder.space.getHash(builder.nVoxel, builder.position.x + p[0], builder.position.y + p[1], builder.position.z + p[2]);
+        if (builder.space.foundHash[hashed] < 2)
+            continue;
+        const constructor = builder.space.getConstructor(hashed);
+        const offsetBaseGometry = builder.space.getGeomtry(hashed);
+        if (offsetBaseGometry) {
+            for (let i = 0; i < offsetBaseGometry.length; i++) {
+                const geoId = offsetBaseGometry[i];
+                if (VoxelModelConstructorRegister.rulesless[geoId])
+                    continue;
+                const cullingProcedure = VoxelModelConstructorRegister.geometry[geoId].cullingProcedure;
+                if (cullingProcedure.type == "transparent") {
+                    if (constructor.id != builder.voxel.getStringId())
+                        continue;
+                }
+                else {
+                    if (cullingProcedure.type != "default")
+                        continue;
+                }
+                if (VoxelModelConstructorRegister.faceCullIndex.getValue(geoId, directionIndex, trueFaceIndex) == 1) {
+                    return false;
+                }
+            }
+        }
+        const offsetConditonalGeometry = builder.space.getConditionalGeomtry(hashed);
+        if (offsetConditonalGeometry) {
+            for (let i = 0; i < offsetConditonalGeometry.length; i++) {
+                const cond = offsetConditonalGeometry[i];
+                for (let k = 0; k < cond.length; k++) {
+                    const geoId = cond[k];
+                    if (VoxelModelConstructorRegister.rulesless[geoId])
+                        continue;
+                    const cullingProcedure = VoxelModelConstructorRegister.geometry[geoId].cullingProcedure;
+                    if (cullingProcedure.type == "transparent") {
+                        if (constructor.id != builder.voxel.getStringId())
+                            continue;
+                    }
+                    else {
+                        if (cullingProcedure.type != "default")
+                            continue;
+                    }
+                    if (VoxelModelConstructorRegister.rulesless[geoId])
+                        continue;
+                    if (VoxelModelConstructorRegister.faceCullIndex.getValue(geoId, directionIndex, trueFaceIndex) == 1)
+                        return false;
+                }
+            }
+        }
+    }
+    return true;
+}

package/Mesher/Models/Common/Faces/ShadeRulelessFace.d.ts

@@ -0,0 +1,4 @@
+import { QuadVerticies } from "../../../Geomtry/Geometry.types";
+import { VoxelModelBuilder } from "../../../Models/VoxelModelBuilder";
+import { Vec4Array } from "@amodx/math";
+export declare function ShadeRulelessFace(builder: VoxelModelBuilder, lightData: Record<QuadVerticies, number>, vertexWeights: Vec4Array[], verticesStride: number): void;

package/Mesher/Models/Common/Faces/ShadeRulelessFace.js

@@ -0,0 +1,12 @@
+import { getInterpolationValue } from "../Calc/CalcConstants";
+export function ShadeRulelessFace(builder, lightData, vertexWeights, verticesStride) {
+    const noAO = builder.voxel.isLightSource() || builder.voxel.noAO();
+    const worldLight = builder.vars.light;
+    const worldAO = builder.vars.ao;
+    for (let v = 0; v < verticesStride; v++) {
+        worldAO.vertices[v] = 0;
+        worldLight.vertices[v] = getInterpolationValue(lightData, vertexWeights[v]);
+        if (noAO)
+            continue;
+    }
+}

package/Mesher/Models/Common/Faces/ShadeRulledFace.d.ts

@@ -0,0 +1,4 @@
+import { VoxelModelBuilder } from "../../VoxelModelBuilder";
+import { Vec4Array } from "@amodx/math";
+import { QuadVerticies } from "../../../Geomtry/Geometry.types";
+export declare function ShadeRulledFace(builder: VoxelModelBuilder, trueFaceIndex: number, lightData: Record<QuadVerticies, number>, vertexWeights: Vec4Array[], vertexStride: number): void;

package/Mesher/Models/Common/Faces/ShadeRulledFace.js

@@ -0,0 +1,58 @@
+import { VoxelRelativeCubeIndexPositionMap } from "../../../../Voxels/Models/Indexing/VoxelRelativeCubeIndex";
+import { VoxelModelConstructorRegister } from "../../VoxelModelConstructorRegister";
+import { getInterpolationValue } from "../Calc/CalcConstants";
+export function ShadeRulledFace(builder, trueFaceIndex, lightData, vertexWeights, vertexStride) {
+    const noAO = builder.voxel.isLightSource() || builder.voxel.noAO();
+    const worldLight = builder.vars.light;
+    const worldAO = builder.vars.ao;
+    for (let v = 0; v < vertexStride; v++) {
+        worldAO.vertices[v] = 0;
+        worldLight.vertices[v] = getInterpolationValue(lightData, vertexWeights[v]);
+        if (noAO)
+            continue;
+        const aoIndexes = VoxelModelConstructorRegister.vertexHitMap[trueFaceIndex][v];
+        if (!aoIndexes)
+            continue;
+        for (let i = 0; i < aoIndexes.length; i++) {
+            const directionIndex = aoIndexes[i];
+            const p = VoxelRelativeCubeIndexPositionMap[directionIndex];
+            const hashed = builder.space.getHash(builder.nVoxel, builder.position.x + p[0], builder.position.y + p[1], builder.position.z + p[2]);
+            if (builder.space.foundHash[hashed] < 2 ||
+                builder.space.noCastAO[hashed] === 1)
+                continue;
+            const baseGeo = builder.space.getGeomtry(hashed);
+            const conditonalGeo = builder.space.getConditionalGeomtry(hashed);
+            if (!baseGeo && !conditonalGeo)
+                continue;
+            let length = 0;
+            let shaded = false;
+            if (baseGeo) {
+                length = baseGeo.length;
+                for (let geoIndex = 0; geoIndex < length; geoIndex++) {
+                    if (VoxelModelConstructorRegister.aoIndex.getValue(baseGeo[geoIndex], directionIndex, trueFaceIndex, v)) {
+                        worldAO.vertices[v]++;
+                        if (worldAO.vertices[v] >= 3) {
+                            shaded = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (!conditonalGeo || shaded)
+                continue;
+            length = conditonalGeo.length;
+            for (let condtionsIndex = 0; condtionsIndex < length; condtionsIndex++) {
+                const condiotnalength = conditonalGeo[condtionsIndex].length;
+                for (let geoIndex = 0; geoIndex < condiotnalength; geoIndex++) {
+                    if (VoxelModelConstructorRegister.aoIndex.getValue(conditonalGeo[condtionsIndex][geoIndex], directionIndex, trueFaceIndex, v)) {
+                        worldAO.vertices[v]++;
+                        if (worldAO.vertices[v] >= 3) {
+                            shaded = true;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+import { BaseVoxelGeomtryTextureProcedureData } from "../Procedures/TextureProcedure";
+import { VoxelModelBuilder } from "../VoxelModelBuilder";
+import { Quad } from "../../Geomtry";
+import { VoxelFaces } from "../../../Math";
+import { Triangle } from "../../Geomtry";
+export declare function GetTexture(builder: VoxelModelBuilder, data: number | BaseVoxelGeomtryTextureProcedureData, closestFace: VoxelFaces, primitive: Quad | Triangle): void;

package/Mesher/Models/Common/GetTexture.js

@@ -0,0 +1,12 @@
+import { TextureProcedureRegister } from "../Procedures/TextureProcedureRegister";
+export function GetTexture(builder, data, closestFace, primitive) {
+    if (typeof data == "number") {
+        builder.vars.textureIndex = data;
+    }
+    else {
+        const procedure = TextureProcedureRegister.get(data.type);
+        builder.vars.textureIndex = procedure.getTexture(builder, data, closestFace, primitive);
+        procedure.transformUVs(builder, data, closestFace, primitive);
+        procedure.getOverlayTexture(builder, data, closestFace, primitive, builder.vars.overlayTextures);
+    }
+}

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

@@ -66,7 +66,7 @@ const returnData = [
 export function getFlowAngle(vertexLevel) {
     if (vertexLevel.isAllEqualTo(7)) {
         returnData[0] = 0;
-        returnData[1] = FlowStates.Up;
+        returnData[1] = FlowStates.None;
         return returnData;
     }
     const upRight = vertexLevel.vertices[QuadVerticies.TopRight];

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

@@ -1,11 +1,10 @@
 import { GeoemtryNode } from "../../GeometryNode";
-import { VoxelCustomGeomtryNode } from "../../../../../Models/VoxelModel.types";
+import { VoxelCustomGeomtryNode } from "../../../../../Voxels/Models/VoxelModel.types";
 import { VoxelFaces } from "../../../../../Math";
-import type { LiquidVoxelModelArgs } from "../../../../../Models/Defaults/LiquidVoxelModel";
+import type { LiquidVoxelModelArgs } from "../../../../../Voxels/Models/Defaults/LiquidVoxelModel";
 export declare class LiquidGeometryNode extends GeoemtryNode<VoxelCustomGeomtryNode, LiquidVoxelModelArgs> {
     init(): void;
     isExposed(face: VoxelFaces): boolean;
     determineShading(face: VoxelFaces): void;
-    shouldFlip(): boolean;
     add(args: LiquidVoxelModelArgs): boolean;
 }