@divinevoxel/vlox 0.0.72 → 0.0.73

package/Contexts/Render/DivineVoxelEngineRender.d.ts

@@ -19,11 +19,11 @@ export declare class DivineVoxelEngineRender {
     settings: {
         enviorment: "node" | "browser";
         settings: EngineSettingsData;
+        version: string;
         readonly doSunPropagation: boolean;
         readonly doRGBPropagation: boolean;
         readonly doLight: boolean;
         readonly doFlow: boolean;
-        readonly isClient: boolean;
         getSettings(): EngineSettingsData;
         syncSettings(data: EngineSettingsData): void;
         getSettingsCopy(): any;

package/Contexts/World/DivineVoxelEngineWorld.d.ts

@@ -11,11 +11,11 @@ export declare class DivineVoxelEngineWorld {
     settings: {
         enviorment: "node" | "browser";
         settings: import("../../Settings/EngineSettings.types.js").EngineSettingsData;
+        version: string;
         readonly doSunPropagation: boolean;
         readonly doRGBPropagation: boolean;
         readonly doLight: boolean;
         readonly doFlow: boolean;
-        readonly isClient: boolean;
         getSettings(): import("../../Settings/EngineSettings.types.js").EngineSettingsData;
         syncSettings(data: import("../../Settings/EngineSettings.types.js").EngineSettingsData): void;
         getSettingsCopy(): any;

package/Init/StartConstructor.js

@@ -44,10 +44,12 @@ export async function StartContrusctor(data = {}) {
     InitMesherTasks(DVEC.threads.parent);
     InitUpdateTasks({
         onDone(tasks, origin) {
-            origin.runTask("build-queue", [
-                tasks.origin[0],
-                tasks.bounds.getSections(),
-            ]);
+            tasks.bounds.markSectionsAsDirty();
+            /*
+                  origin.runTask("build-queue", [
+                    tasks.origin[0],
+                    tasks.bounds.getSections(),
+                  ]); */
         },
     });
     InitWorldGenerationTasks();

package/Init/StartWorld.d.ts

@@ -1,5 +1,5 @@
 import { DivineVoxelEngineWorld } from "../Contexts/World/DivineVoxelEngineWorld";
-import { WorldStorageInterface } from "World/Storage/WorldStorage.interface";
+import { WorldStorageInterface } from "World/Types/WorldStorage.interface";
 type StartWorldProps = {
     worldStorage?: WorldStorageInterface;
 };

package/Mesher/Functions/CompactVoxelMesh.d.ts

@@ -1,3 +1,3 @@
 import { CompactMeshData } from "../Types/Mesher.types";
-import { VoxelMesherDataTool } from "Mesher/Tools/VoxelMesherDataTool";
-export declare function CompactVoxelMesh(tools: VoxelMesherDataTool[], transfers?: any[]): CompactMeshData;
+import { VoxelModelBuilder } from "Mesher/Models/VoxelModelBuilder";
+export declare function CompactVoxelMesh(tools: VoxelModelBuilder[], transfers?: any[]): CompactMeshData;

package/Mesher/Functions/CompactVoxelMesh.js

@@ -1,4 +1,4 @@
-import { VoxelMeshVertexStructCursor } from "../Tools/VoxelMeshVertexStructCursor";
+import { VoxelMeshVertexStructCursor } from "../Geomtry/VoxelMeshVertexStructCursor";
 const structCursor = new VoxelMeshVertexStructCursor();
 /*
 function MakeWebGPUMesh(tool: VoxelMesherDataTool): CompactMeshData {

package/Mesher/Functions/MeshSection.js

@@ -7,9 +7,9 @@ import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
 import { SectionCursor } from "../../World/Cursor/SectionCursor.js";
 import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
 import { WorldRegister } from "../../World/WorldRegister.js";
-import { VoxelMeshBVHBuilder } from "../Tools/VoxelMeshBVHBuilder";
+import { VoxelMeshBVHBuilder } from "../Geomtry/VoxelMeshBVHBuilder";
 import { Vector3Like } from "@amodx/math";
-import { RenderedMaterials } from "../../Mesher/RenderedMaterials";
+import { RenderedMaterials } from "../Models/RenderedMaterials";
 const sectionCursor = new SectionCursor();
 const worldCursor = new WorldCursor();
 let space;
@@ -39,16 +39,19 @@ export function MeshSection(location, transfers = []) {
             y: WorldSpaces.section.bounds.y + padding.y,
             z: WorldSpaces.section.bounds.z + padding.z,
         });
-    const [dimension, cx, cy, cz] = location;
-    const sector = WorldRegister.sectors.get(dimension, cx, cy, cz);
+    const sector = WorldRegister.sectors.getAt(location);
     if (!sector)
         return null;
-    const section = sector.getSection(cy);
+    const section = sector.getSection(location[1], location[2], location[3]);
+    const [cx, cy, cz] = section.getPosition();
     worldCursor.setFocalPoint(...location);
     sectionCursor.setSection(...location);
     let [minY, maxY] = section.getMinMax();
-    if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
+    if (minY == Infinity && maxY == -Infinity) {
+        section.setDirty(false);
+        section.setInProgress(false);
         return null;
+    }
     space.start(cx - (padding.x - 1), cy - (padding.y - 1), cz - (padding.z - 1));
     bvhTool.reset();
     const effects = {};
@@ -65,10 +68,12 @@ export function MeshSection(location, transfers = []) {
         if (!(i % slice)) {
             const y = i / slice;
             if (!section.getHasVoxel(y) && !section.getHasVoxelDirty(y)) {
-                i += slice;
+                i += slice - 1;
                 continue;
             }
         }
+        if (!section.ids[i])
+            continue;
         if (!section.ids[i] || section.getBuried(i))
             continue;
         const voxel = sectionCursor.getVoxelAtIndex(i);
@@ -88,7 +93,12 @@ export function MeshSection(location, transfers = []) {
     }
     // console.log(performance.now() - t);
     const sectionEffects = [];
-    const sections = [location, [], sectionEffects, 0];
+    const sections = [
+        [location[0], ...section.getPosition()],
+        [],
+        sectionEffects,
+        0,
+    ];
     const meshed = [];
     for (let i = 0; i < RenderedMaterials.meshers.length; i++) {
         const mesher = RenderedMaterials.meshers[i];
@@ -110,5 +120,7 @@ export function MeshSection(location, transfers = []) {
         meshed[i].clear();
         meshed[i].bvhTool = null;
     }
+    section.setDirty(false);
+    section.setInProgress(false);
     return sections;
 }

package/Mesher/Functions/MeshTexture.d.ts

@@ -1 +1 @@
-export declare function MeshTexture(textureId: number, textureData: number[]): import("../Geomtry/VoxelMesh").VoxelMesh | null;
+export declare function MeshTexture(textureId: number, textureData: number[]): void;

package/Mesher/Functions/MeshTexture.js

@@ -1,4 +1,3 @@
-import { MesherDataTool } from "../Geomtry/Tools/MesherDataTools";
 import { Quad } from "../Geomtry/Primitives/Quad";
 const Quads = {
     north: Quad.Create([
@@ -10,8 +9,8 @@ const Quads = {
         [1, 1, 0],
     ], Quad.FullUVs, false, 0),
 };
-const tool = new MesherDataTool();
-tool.startNewMesh();
+//const tool = new MesherDataTool();
+//tool.startNewMesh();
 //tool.mesh!.attributes.set("uv", [[], 2, BinaryNumberTypes.Float32]);
 //tool.mesh!.attributes.set("textureIndex", [[], 3, BinaryNumberTypes.Float32]);
 export function MeshTexture(textureId, textureData) {
@@ -271,5 +270,5 @@ export function MeshTexture(textureId, textureData) {
     
       const compacted = CompactMesh("dve_node", tool);
      */
-    return tool.mesh;
+    //  return tool.mesh;
 }

package/Mesher/Geomtry/Primitives/QuadVertexData.d.ts

@@ -1,8 +1,9 @@
 import { QuadVerticies } from "../Geometry.types.js";
 import { Vector3Like, Vector2Like, Vec3Array } from "@amodx/math";
+type QuadDataType<Data> = [Data, Data, Data, Data];
 export declare class QuadVertexData<Data> {
-    vertices: Record<QuadVerticies, Data>;
-    constructor(vertices: Record<QuadVerticies, Data>);
+    vertices: QuadDataType<Data>;
+    constructor(vertices: QuadDataType<Data>);
     getAsArray(): Data[];
     setVertex(vertex: QuadVerticies, value: Data): void;
     getVertex(vertex: QuadVerticies): Data;
@@ -14,8 +15,8 @@ export declare class QuadVertexData<Data> {
     clone(): QuadVertexData<Data>;
 }
 export declare class QuadVec3ArrayVertexData extends QuadVertexData<Vec3Array> {
-    vertices: Record<QuadVerticies, Vec3Array>;
-    constructor(vertices?: Record<QuadVerticies, Vec3Array>);
+    vertices: QuadDataType<Vec3Array>;
+    constructor(vertices?: QuadDataType<Vec3Array>);
     setFromQuadData(vertexData: QuadVertexData<Vec3Array>): void;
     addToVertex(vertex: QuadVerticies, value: Vec3Array): void;
     subtractFromVertex(vertex: QuadVerticies, value: Vec3Array): void;
@@ -26,8 +27,8 @@ export declare class QuadVec3ArrayVertexData extends QuadVertexData<Vec3Array> {
     clone(): QuadVec3ArrayVertexData;
 }
 export declare class QuadVector3VertexData extends QuadVertexData<Vector3Like> {
-    vertices: Record<QuadVerticies, Vector3Like>;
-    constructor(vertices?: Record<QuadVerticies, Vector3Like>);
+    vertices: QuadDataType<Vector3Like>;
+    constructor(vertices?: QuadDataType<Vector3Like>);
     setFromQuadData(vertexData: QuadVertexData<Vector3Like>): void;
     addToVertex(vertex: QuadVerticies, value: Vector3Like): void;
     subtractFromVertex(vertex: QuadVerticies, value: Vector3Like): void;
@@ -38,8 +39,8 @@ export declare class QuadVector3VertexData extends QuadVertexData<Vector3Like> {
     clone(): QuadVector3VertexData;
 }
 export declare class QuadVector2VertexData extends QuadVertexData<Vector2Like> {
-    vertices: Record<QuadVerticies, Vector2Like>;
-    constructor(vertices?: Record<QuadVerticies, Vector2Like>);
+    vertices: QuadDataType<Vector2Like>;
+    constructor(vertices?: QuadDataType<Vector2Like>);
     setFromQuadData(vertexData: QuadVertexData<Vector3Like>): void;
     addToVertex(vertex: QuadVerticies, value: Vector2Like): void;
     subtractFromVertex(vertex: QuadVerticies, value: Vector2Like): void;
@@ -50,8 +51,8 @@ export declare class QuadVector2VertexData extends QuadVertexData<Vector2Like> {
     clone(): QuadVector2VertexData;
 }
 export declare class QuadScalarVertexData extends QuadVertexData<number> {
-    vertices: Record<QuadVerticies, number>;
-    constructor(vertices?: Record<QuadVerticies, number>);
+    vertices: QuadDataType<number>;
+    constructor(vertices?: QuadDataType<number>);
     setFromQuadData(vertexData: QuadVertexData<number>): void;
     subtractFromVertex(vertex: QuadVerticies, value: number): void;
     addAll(value: number): void;
@@ -64,3 +65,4 @@ export declare class QuadScalarVertexData extends QuadVertexData<number> {
     isAllLessThan(value: number): boolean;
     clone(): QuadScalarVertexData;
 }
+export {};

package/Mesher/Geomtry/Primitives/QuadVertexData.js

@@ -68,22 +68,22 @@ export class QuadVertexData {
         };
     }
     clone() {
-        return new QuadVertexData({
-            [QuadVerticies.TopRight]: structuredClone(this.vertices[QuadVerticies.TopRight]),
-            [QuadVerticies.TopLeft]: structuredClone(this.vertices[QuadVerticies.TopLeft]),
-            [QuadVerticies.BottomLeft]: structuredClone(this.vertices[QuadVerticies.BottomLeft]),
-            [QuadVerticies.BottomRight]: structuredClone(this.vertices[QuadVerticies.BottomRight]),
-        });
+        return new QuadVertexData([
+            structuredClone(this.vertices[QuadVerticies.TopRight]),
+            structuredClone(this.vertices[QuadVerticies.TopLeft]),
+            structuredClone(this.vertices[QuadVerticies.BottomLeft]),
+            structuredClone(this.vertices[QuadVerticies.BottomRight]),
+        ]);
     }
 }
 export class QuadVec3ArrayVertexData extends QuadVertexData {
     vertices;
-    constructor(vertices = {
-        [QuadVerticies.TopRight]: [0, 0, 0],
-        [QuadVerticies.TopLeft]: [0, 0, 0],
-        [QuadVerticies.BottomLeft]: [0, 0, 0],
-        [QuadVerticies.BottomRight]: [0, 0, 0],
-    }) {
+    constructor(vertices = [
+        [0, 0, 0],
+        [0, 0, 0],
+        [0, 0, 0],
+        [0, 0, 0],
+    ]) {
         super(vertices);
         this.vertices = vertices;
     }
@@ -124,24 +124,22 @@ export class QuadVec3ArrayVertexData extends QuadVertexData {
             Vector3Like.EqualsArray(this.vertices[QuadVerticies.BottomRight], v1));
     }
     clone() {
-        return new QuadVec3ArrayVertexData({
-            [QuadVerticies.TopRight]: [...this.vertices[QuadVerticies.TopRight]],
-            [QuadVerticies.TopLeft]: [...this.vertices[QuadVerticies.TopLeft]],
-            [QuadVerticies.BottomLeft]: [...this.vertices[QuadVerticies.BottomLeft]],
-            [QuadVerticies.BottomRight]: [
-                ...this.vertices[QuadVerticies.BottomRight],
-            ],
-        });
+        return new QuadVec3ArrayVertexData([
+            [...this.vertices[QuadVerticies.TopRight]],
+            [...this.vertices[QuadVerticies.TopLeft]],
+            [...this.vertices[QuadVerticies.BottomLeft]],
+            [...this.vertices[QuadVerticies.BottomRight]],
+        ]);
     }
 }
 export class QuadVector3VertexData extends QuadVertexData {
     vertices;
-    constructor(vertices = {
-        [QuadVerticies.TopRight]: Vector3Like.Create(),
-        [QuadVerticies.TopLeft]: Vector3Like.Create(),
-        [QuadVerticies.BottomLeft]: Vector3Like.Create(),
-        [QuadVerticies.BottomRight]: Vector3Like.Create(),
-    }) {
+    constructor(vertices = [
+        Vector3Like.Create(),
+        Vector3Like.Create(),
+        Vector3Like.Create(),
+        Vector3Like.Create(),
+    ]) {
         super(vertices);
         this.vertices = vertices;
     }
@@ -182,22 +180,22 @@ export class QuadVector3VertexData extends QuadVertexData {
             Vector3Like.Equals(this.vertices[QuadVerticies.BottomRight], v1));
     }
     clone() {
-        return new QuadVector3VertexData({
-            [QuadVerticies.TopRight]: Vector3Like.Clone(this.vertices[QuadVerticies.TopRight]),
-            [QuadVerticies.TopLeft]: Vector3Like.Clone(this.vertices[QuadVerticies.TopLeft]),
-            [QuadVerticies.BottomLeft]: Vector3Like.Clone(this.vertices[QuadVerticies.BottomLeft]),
-            [QuadVerticies.BottomRight]: Vector3Like.Clone(this.vertices[QuadVerticies.BottomRight]),
-        });
+        return new QuadVector3VertexData([
+            Vector3Like.Clone(this.vertices[QuadVerticies.TopRight]),
+            Vector3Like.Clone(this.vertices[QuadVerticies.TopLeft]),
+            Vector3Like.Clone(this.vertices[QuadVerticies.BottomLeft]),
+            Vector3Like.Clone(this.vertices[QuadVerticies.BottomRight]),
+        ]);
     }
 }
 export class QuadVector2VertexData extends QuadVertexData {
     vertices;
-    constructor(vertices = {
-        [QuadVerticies.TopRight]: Vector2Like.Create(),
-        [QuadVerticies.TopLeft]: Vector2Like.Create(),
-        [QuadVerticies.BottomLeft]: Vector2Like.Create(),
-        [QuadVerticies.BottomRight]: Vector2Like.Create(),
-    }) {
+    constructor(vertices = [
+        Vector2Like.Create(),
+        Vector2Like.Create(),
+        Vector2Like.Create(),
+        Vector2Like.Create(),
+    ]) {
         super(vertices);
         this.vertices = vertices;
     }
@@ -238,22 +236,17 @@ export class QuadVector2VertexData extends QuadVertexData {
             Vector2Like.Equals(this.vertices[QuadVerticies.BottomRight], v1));
     }
     clone() {
-        return new QuadVector2VertexData({
-            [QuadVerticies.TopRight]: Vector2Like.Clone(this.vertices[QuadVerticies.TopRight]),
-            [QuadVerticies.TopLeft]: Vector2Like.Clone(this.vertices[QuadVerticies.TopLeft]),
-            [QuadVerticies.BottomLeft]: Vector2Like.Clone(this.vertices[QuadVerticies.BottomLeft]),
-            [QuadVerticies.BottomRight]: Vector2Like.Clone(this.vertices[QuadVerticies.BottomRight]),
-        });
+        return new QuadVector2VertexData([
+            Vector2Like.Clone(this.vertices[QuadVerticies.TopRight]),
+            Vector2Like.Clone(this.vertices[QuadVerticies.TopLeft]),
+            Vector2Like.Clone(this.vertices[QuadVerticies.BottomLeft]),
+            Vector2Like.Clone(this.vertices[QuadVerticies.BottomRight]),
+        ]);
     }
 }
 export class QuadScalarVertexData extends QuadVertexData {
     vertices;
-    constructor(vertices = {
-        [QuadVerticies.TopRight]: 0,
-        [QuadVerticies.TopLeft]: 0,
-        [QuadVerticies.BottomLeft]: 0,
-        [QuadVerticies.BottomRight]: 0,
-    }) {
+    constructor(vertices = [0, 0, 0, 0]) {
         super(vertices);
         this.vertices = vertices;
     }
@@ -339,11 +332,11 @@ export class QuadScalarVertexData extends QuadVertexData {
         return true;
     }
     clone() {
-        return new QuadScalarVertexData({
-            [QuadVerticies.TopRight]: this.vertices[QuadVerticies.TopRight],
-            [QuadVerticies.TopLeft]: this.vertices[QuadVerticies.TopLeft],
-            [QuadVerticies.BottomLeft]: this.vertices[QuadVerticies.BottomLeft],
-            [QuadVerticies.BottomRight]: this.vertices[QuadVerticies.BottomRight],
-        });
+        return new QuadScalarVertexData([
+            this.vertices[QuadVerticies.TopRight],
+            this.vertices[QuadVerticies.TopLeft],
+            this.vertices[QuadVerticies.BottomLeft],
+            this.vertices[QuadVerticies.BottomRight],
+        ]);
     }
 }

package/Mesher/Geomtry/VoxelGeometryBuilder.d.ts

@@ -1,6 +1,6 @@
 import { Vector3Like } from "@amodx/math";
-import { VoxelMesherDataTool } from "../Tools/VoxelMesherDataTool";
+import { VoxelModelBuilder } from "../Models/VoxelModelBuilder";
 import { Quad } from "./Primitives/Quad";
 export declare class VoxelGeometryBuilder {
-    static addQuad(tool: VoxelMesherDataTool, origin: Vector3Like, quad: Quad): void;
+    static addQuad(tool: VoxelModelBuilder, origin: Vector3Like, quad: Quad): void;
 }

package/Mesher/Geomtry/VoxelGeometryBuilder.js

@@ -1,6 +1,6 @@
-import { VoxelShaderData } from "../VoxelShaderData";
+import { VoxelShaderData } from "./VoxelShaderData";
 import { QuadVerticies } from "./Geometry.types";
-import { VoxelMeshVertexConstants, VoxelMeshVertexStructCursor, } from "../../Mesher/Tools/VoxelMeshVertexStructCursor";
+import { VoxelMeshVertexConstants, VoxelMeshVertexStructCursor, } from "./VoxelMeshVertexStructCursor";
 const empty = [];
 const structCursor = new VoxelMeshVertexStructCursor();
 export class VoxelGeometryBuilder {

package/Mesher/Geomtry/VoxelMesh.d.ts

@@ -1,5 +1,5 @@
 import { Vector3Like } from "@amodx/math";
-import { VoxelVertexBuffer, VoxelIndiceBuffer } from "./Buffers";
+import { VoxelVertexBuffer, VoxelIndiceBuffer } from "./VoxelMeshBuffers";
 export declare class VoxelMesh {
     indicieCount: number;
     vertexCount: number;

package/Mesher/Geomtry/VoxelMesh.js

@@ -1,6 +1,6 @@
 import { Vector3Like } from "@amodx/math";
-import { VoxelVertexBuffer, VoxelIndiceBuffer } from "./Buffers";
-import { VoxelMeshVertexStructCursor } from "../Tools/VoxelMeshVertexStructCursor";
+import { VoxelVertexBuffer, VoxelIndiceBuffer } from "./VoxelMeshBuffers";
+import { VoxelMeshVertexStructCursor } from "./VoxelMeshVertexStructCursor";
 export class VoxelMesh {
     indicieCount = 0;
     vertexCount = 0;

package/Mesher/Geomtry/index.d.ts

@@ -1,2 +1 @@
 export * from "./Primitives/index";
-export * from "./Tools/index.js";

package/Mesher/Geomtry/index.js

@@ -1,2 +1 @@
 export * from "./Primitives/index";
-export * from "./Tools/index.js";

package/Mesher/InitMesher.js

@@ -1,4 +1,4 @@
-import { RenderedMaterials } from "./RenderedMaterials";
+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";

package/Mesher/InitTask.js

@@ -1,6 +1,5 @@
 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) {
@@ -12,35 +11,18 @@ export default function (rendererThread) {
         rendererThread.runTask("set-section", section, transfers);
     });
     Threads.registerTask(TasksIds.BuildSector, (location) => {
-        const sectorPosition = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
-        const sector = WorldRegister.sectors.get(location[0], sectorPosition.x, sectorPosition.y, sectorPosition.z);
+        const sector = WorldRegister.sectors.getAt(location);
         if (!sector) {
-            console.warn("Tried building a sector that does not exists.", [
-                sectorPosition.x,
-                sectorPosition.y,
-                sectorPosition.z,
-            ]);
+            console.warn("Tried building a sector that does not exists.", location);
             return;
         }
-        if (sector.sections.length == 0) {
-            console.warn("Tried building a sector with no sections.", sector.position);
-            return;
-        }
-        const transfers = [];
         for (let i = 0; i < sector.sections.length; i++) {
             const section = sector.sections[i];
-            if (!section)
-                continue;
             let [minY, maxY] = section.getMinMax();
             if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
                 continue;
-            transfers.length = 0;
-            const sectionMesh = MeshSection([
-                location[0],
-                sector.position[0],
-                sector.position[1] + i * WorldSpaces.section.bounds.y,
-                sector.position[2],
-            ], transfers);
+            const transfers = [];
+            const sectionMesh = MeshSection([location[0], ...section.getPosition()], transfers);
             if (!sectionMesh)
                 continue;
             rendererThread.runTask("set-section", sectionMesh, transfers);

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

@@ -1,3 +1,3 @@
-import type { VoxelMesherDataTool } from "../../../../Mesher/Tools/VoxelMesherDataTool.js";
+import type { VoxelModelBuilder } from "../../VoxelModelBuilder.js";
 import { VoxelFaces } from "../../../../Math/index.js";
-export default function calculateFaceData(face: VoxelFaces, builder: VoxelMesherDataTool): void;
+export default function calculateFaceData(face: VoxelFaces, builder: VoxelModelBuilder): void;

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

@@ -2,47 +2,54 @@ 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]);
 export default function calculateFaceData(face, builder) {
-    let light = builder.voxel.getLight();
-    const faceNormal = VoxelFaceDirections[face];
     const x = builder.position.x;
     const y = builder.position.y;
     const z = builder.position.z;
     const vertexData = builder.lightData[face];
     const nVoxel = builder.nVoxel;
     const checkSet = GradientCheckSets[face];
-    const otherLight = builder.space.getLight(builder.nVoxel, x + faceNormal[0], y + faceNormal[1], z + faceNormal[2]) || 0;
-    light = otherLight >= 0 ? otherLight : light >= 0 ? light : 0;
+    let startLight = 0;
+    if (builder.voxel.isLightSource()) {
+        startLight = builder.voxel.getLightSourceValue();
+    }
+    else {
+        startLight =
+            nVoxel
+                .getVoxel(x + VoxelFaceDirections[face][0], y + VoxelFaceDirections[face][1], z + VoxelFaceDirections[face][2])
+                ?.getLight() || 0;
+    }
+    if (startLight < 0)
+        startLight = 0;
+    const startS = lightData.getS(startLight);
+    const startR = lightData.getR(startLight);
+    const startG = lightData.getG(startLight);
+    const startB = lightData.getB(startLight);
     for (let vertex = 0; vertex < 4; vertex++) {
-        vertexData[vertex] = light;
-        lightData.getLightValuesArrayToRef(light, currentLightValues);
+        vertexData[vertex] = startLight;
+        let s = startS;
+        let r = startR;
+        let g = startG;
+        let b = startB;
         for (let i = 0; i < 9; i += 3) {
-            const nl = builder.space.getLight(nVoxel, checkSet[vertex][i] + x, checkSet[vertex][i + 1] + y, checkSet[vertex][i + 2] + z);
+            const nl = nVoxel
+                .getVoxel(checkSet[vertex][i] + x, checkSet[vertex][i + 1] + y, checkSet[vertex][i + 2] + z)
+                ?.getLight() || -1;
             if (nl <= 0)
                 continue;
-            /*
-            Do Light
-            */
-            lightData.getLightValuesArrayToRef(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];
+            let ns = lightData.getS(nl);
+            let nr = lightData.getR(nl);
+            let ng = lightData.getG(nl);
+            let nb = lightData.getB(nl);
+            if (s < ns)
+                s = ns;
+            if (r < nr)
+                r = nr;
+            if (g < ng)
+                g = ng;
+            if (b < nb)
+                b = nb;
         }
-        vertexData[vertex] = lightData.setLightValues(currentLightValues);
+        vertexData[vertex] = lightData.createLightValue(s, r, g, b);
     }
 }

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

@@ -1,4 +1,4 @@
-import type { VoxelMesherDataTool } from "../../../../../Mesher/Tools/VoxelMesherDataTool";
+import type { VoxelModelBuilder } from "../../../VoxelModelBuilder";
 import { QuadScalarVertexData } from "../../../../Geomtry/Primitives/QuadVertexData";
 import { CompassAngles } from "@amodx/math";
 export declare enum FlowVerticies {
@@ -8,4 +8,4 @@ export declare enum FlowVerticies {
     SouthEsat = 3
 }
 export declare function getFlowAngle(vertexLevel: QuadScalarVertexData): [angle: CompassAngles, flow: number];
-export declare function getFlowGradient(tool: VoxelMesherDataTool, flowStates: QuadScalarVertexData): QuadScalarVertexData;
+export declare function getFlowGradient(tool: VoxelModelBuilder, flowStates: QuadScalarVertexData): QuadScalarVertexData;

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.None;
+        returnData[1] = FlowStates.Up;
         return returnData;
     }
     const upRight = vertexLevel.vertices[QuadVerticies.TopRight];