@divinevoxel/vlox 0.0.73 → 0.0.74

package/Contexts/Base/Remote/InitDataSync.js

@@ -5,6 +5,7 @@ import { SchemaRegister } from "../../../Voxels/State/SchemaRegister";
 import { VoxelTagStates } from "../../../Voxels/Data/VoxelTagStates";
 import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
 import { VoxelTagsRegister } from "../../../Voxels/Data/VoxelTagsRegister";
+import { VoxelLogicRegister } from "../../../Voxels/Logic/VoxelLogicRegister";
 export default function InitDataSync(props) {
     Threads.registerTask("sync-data", (data) => {
         EngineSettings.syncSettings(data.settings);
@@ -23,6 +24,9 @@ export default function InitDataSync(props) {
             SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
         }
         VoxelTagStates.load(modelData.tagState);
+        for (const id in data.voxels.data.logic) {
+            VoxelLogicRegister.register(id, data.voxels.data.logic[id]);
+        }
         props.onSync(data);
     });
 }

package/Contexts/Base/Remote/InitWorldDataSync.js

@@ -3,7 +3,7 @@ import { WorldDataSyncIds } from "../../../World/Types/WorldDataSyncIds.js";
 import { WorldRegister } from "../../../World/WorldRegister.js";
 export default function () {
     Threads.registerTask(WorldDataSyncIds.SyncDimension, (data) => {
-        WorldRegister.dimensions.add(data.id);
+        WorldRegister.dimensions.add(data.index, data.id);
     });
     Threads.registerTask(WorldDataSyncIds.UnSyncDimension, (data) => {
         //  register.dimensions.re(data.id);

package/Contexts/Render/DivineVoxelEngineRender.d.ts

@@ -24,6 +24,7 @@ export declare class DivineVoxelEngineRender {
         readonly doRGBPropagation: boolean;
         readonly doLight: boolean;
         readonly doFlow: boolean;
+        readonly doPower: boolean;
         getSettings(): EngineSettingsData;
         syncSettings(data: EngineSettingsData): void;
         getSettingsCopy(): any;

package/Contexts/World/DivineVoxelEngineWorld.d.ts

@@ -16,6 +16,7 @@ export declare class DivineVoxelEngineWorld {
         readonly doRGBPropagation: boolean;
         readonly doLight: boolean;
         readonly doFlow: boolean;
+        readonly doPower: boolean;
         getSettings(): import("../../Settings/EngineSettings.types.js").EngineSettingsData;
         syncSettings(data: import("../../Settings/EngineSettings.types.js").EngineSettingsData): void;
         getSettingsCopy(): any;

package/Init/StartConstructor.js

@@ -3,6 +3,7 @@ import { DivineVoxelEngineConstructor } from "../Contexts/Constructor/DivineVoxe
 import { Threads } from "@amodx/threads";
 import { Environment } from "../Util/Environment";
 import { WorldRegister } from "../World/WorldRegister";
+import InitLogicTasks from "../Tasks/Logic/InitTasks";
 import InitUpdateTasks from "../Tasks/Update/InitTasks";
 import InitPropagationTasks from "../Tasks/Propagation/InitTasks";
 import InitMesherTasks from "../Mesher/InitTask";
@@ -42,6 +43,7 @@ export async function StartContrusctor(data = {}) {
     InitWorldDataSync();
     InitPropagationTasks();
     InitMesherTasks(DVEC.threads.parent);
+    InitLogicTasks();
     InitUpdateTasks({
         onDone(tasks, origin) {
             tasks.bounds.markSectionsAsDirty();

package/Math/index.d.ts

@@ -1,8 +1,12 @@
 export * from "./VoxelFaces.js";
 export * from "./VoxelFaces.js";
 export type LocationData = [
-    dimensionId: string,
+    /**Index for the dimension */
+    dimensionIndex: number,
+    /**x position */
     x: number,
+    /**y position */
     y: number,
+    /**z position */
     z: number
 ];

package/Mesher/Functions/CompactVoxelSectionMesh.d.ts

@@ -0,0 +1,4 @@
+import { SetSectionMeshTask } from "../Types/Mesher.types";
+import { VoxelModelBuilder } from "../Models/VoxelModelBuilder";
+import { LocationData } from "../../Math";
+export declare function CompactVoxelSectionMesh(location: LocationData, tools: VoxelModelBuilder[], transfers?: any[]): SetSectionMeshTask;

package/Mesher/Functions/CompactVoxelSectionMesh.js

@@ -0,0 +1,112 @@
+import { VoxelMeshVertexStructCursor } from "../Geomtry/VoxelMeshVertexStructCursor";
+import { CompactedSectionVoxelMesh, CompactedMeshData, } from "../Geomtry/CompactedSectionVoxelMesh";
+const meshData = new CompactedMeshData();
+const compactedMesh = new CompactedSectionVoxelMesh();
+/** Utility to ensure a value is aligned to 4 bytes. */
+function align4(value) {
+    return (value + 3) & ~3;
+}
+export function CompactVoxelSectionMesh(location, tools, transfers = []) {
+    // 1) First compute how large the final buffer needs to be (with 4-byte alignment).
+    let headerSize = CompactedSectionVoxelMesh.GetHeaderByteSize(tools.length);
+    // Make the header itself 4-byte aligned
+    headerSize = align4(headerSize);
+    let totalByteCount = headerSize;
+    for (let i = 0; i < tools.length; i++) {
+        const tool = tools[i];
+        // Add the vertex data
+        const vertexByteSize = tool.mesh.vertexCount * VoxelMeshVertexStructCursor.VertexByteSize;
+        totalByteCount += vertexByteSize;
+        // Align after writing vertex data
+        totalByteCount = align4(totalByteCount);
+        // Add the index data
+        const indexByteSize = tool.mesh.indicieCount > 65535
+            ? tool.mesh.indicieCount * 4
+            : tool.mesh.indicieCount * 2;
+        totalByteCount += indexByteSize;
+        // Align after writing index data
+        totalByteCount = align4(totalByteCount);
+    }
+    // 2) Allocate the final buffer
+    const buffer = new ArrayBuffer(totalByteCount);
+    compactedMesh.setData(buffer);
+    compactedMesh.setLocation(...location);
+    compactedMesh.setTotalMeshes(tools.length);
+    // We'll track our position in the buffer here
+    let byteCount = headerSize;
+    for (let i = 0; i < tools.length; i++) {
+        const tool = tools[i];
+        // Fill out the meshData structure
+        meshData.material = tool.id;
+        const minBounds = tool.mesh.minBounds;
+        const maxBounds = tool.mesh.maxBounds;
+        meshData.minBounds[0] = minBounds.x;
+        meshData.minBounds[1] = minBounds.y;
+        meshData.minBounds[2] = minBounds.z;
+        meshData.maxBounds[0] = maxBounds.x;
+        meshData.maxBounds[1] = maxBounds.y;
+        meshData.maxBounds[2] = maxBounds.z;
+        // Vertex info
+        const totalVertFloats = tool.mesh.vertexCount * VoxelMeshVertexStructCursor.VertexFloatSize;
+        const vertexByteCount = totalVertFloats * 4;
+        meshData.vertexIndex[0] = byteCount;
+        meshData.vertexIndex[1] = totalVertFloats;
+        // Now move the pointer
+        byteCount += vertexByteCount;
+        // Align to 4 bytes again before writing indices
+        byteCount = align4(byteCount);
+        // Index info
+        meshData.indiceIndex[0] = byteCount;
+        meshData.indiceIndex[1] = tool.mesh.indicieCount;
+        const indexByteCount = tool.mesh.indicieCount > 65535
+            ? tool.mesh.indicieCount * 4
+            : tool.mesh.indicieCount * 2;
+        byteCount += indexByteCount;
+        // Align to 4 bytes for the next iteration (or final)
+        byteCount = align4(byteCount);
+        // Store the meta info
+        compactedMesh.setMeshData(i, meshData);
+        // Write vertex data
+        const vertexArray = new Float32Array(buffer, meshData.vertexIndex[0], totalVertFloats);
+        const vertexBuffers = tool.mesh.buffer._buffers;
+        let start = 0;
+        let done = false;
+        for (let b = 0; b < vertexBuffers.length; b++) {
+            const buf = vertexBuffers[b];
+            for (let j = 0; j < buf.length; j++) {
+                vertexArray[start] = buf[j];
+                start++;
+                if (start >= totalVertFloats) {
+                    done = true;
+                    break;
+                }
+            }
+            if (done)
+                break;
+        }
+        // Write index data
+        const indicesArray = tool.mesh.indicieCount > 65535
+            ? new Uint32Array(buffer, meshData.indiceIndex[0], tool.mesh.indicieCount)
+            : new Uint16Array(buffer, meshData.indiceIndex[0], tool.mesh.indicieCount);
+        const indiceBuffers = tool.mesh.indices._buffers;
+        start = 0;
+        done = false;
+        for (let b = 0; b < indiceBuffers.length; b++) {
+            const buf = indiceBuffers[b];
+            for (let j = 0; j < buf.length; j++) {
+                indicesArray[start] = buf[j];
+                start++;
+                if (start >= tool.mesh.indicieCount) {
+                    done = true;
+                    break;
+                }
+            }
+            if (done)
+                break;
+        }
+    }
+    // Transfer the ArrayBuffer to your worker if needed
+    transfers.push(buffer);
+    // Return the buffer or the task object as needed
+    return buffer;
+}

package/Mesher/Functions/MeshSection.d.ts

@@ -1,3 +1,3 @@
 import { LocationData } from "../../Math";
-import type { SetSectionMeshTask } from "../../Renderer/Renderer.types.js";
+import type { SetSectionMeshTask } from "../Types/Mesher.types";
 export declare function MeshSection(location: LocationData, transfers?: any[]): SetSectionMeshTask | null;

package/Mesher/Functions/MeshSection.js

@@ -2,7 +2,6 @@
 import { WorldSpaces } from "../../World/WorldSpaces.js";
 //tools
 import { VoxelGeometryBuilderCacheSpace } from "../Models/VoxelGeometryBuilderCacheSpace.js";
-import { CompactVoxelMesh } from "./CompactVoxelMesh.js";
 import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
 import { SectionCursor } from "../../World/Cursor/SectionCursor.js";
 import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
@@ -10,6 +9,7 @@ import { WorldRegister } from "../../World/WorldRegister.js";
 import { VoxelMeshBVHBuilder } from "../Geomtry/VoxelMeshBVHBuilder";
 import { Vector3Like } from "@amodx/math";
 import { RenderedMaterials } from "../Models/RenderedMaterials";
+import { CompactVoxelSectionMesh } from "./CompactVoxelSectionMesh";
 const sectionCursor = new SectionCursor();
 const worldCursor = new WorldCursor();
 let space;
@@ -48,7 +48,7 @@ export function MeshSection(location, transfers = []) {
     sectionCursor.setSection(...location);
     let [minY, maxY] = section.getMinMax();
     if (minY == Infinity && maxY == -Infinity) {
-        section.setDirty(false);
+        section.setDisplayDirty(false);
         section.setInProgress(false);
         return null;
     }
@@ -61,10 +61,10 @@ export function MeshSection(location, transfers = []) {
         mesher.bvhTool = bvhTool;
         mesher.effects = effects;
     }
-    const volume = WorldSpaces.section.volumne;
     const slice = WorldSpaces.section.bounds.x * WorldSpaces.section.bounds.z;
-    //const t = performance.now();
-    for (let i = 0; i < volume; i++) {
+    const startY = minY * slice;
+    const endY = (maxY + 1) * slice;
+    for (let i = startY; i < endY; i++) {
         if (!(i % slice)) {
             const y = i / slice;
             if (!section.getHasVoxel(y) && !section.getHasVoxelDirty(y)) {
@@ -91,36 +91,29 @@ export function MeshSection(location, transfers = []) {
         }
         section.setBuried(i, !addedVoxel);
     }
-    // console.log(performance.now() - t);
-    const sectionEffects = [];
-    const sections = [
-        [location[0], ...section.getPosition()],
-        [],
-        sectionEffects,
-        0,
-    ];
     const meshed = [];
     for (let i = 0; i < RenderedMaterials.meshers.length; i++) {
         const mesher = RenderedMaterials.meshers[i];
-        for (const e in mesher.effects) {
-            const float = Float32Array.from(mesher.effects[e]);
-            transfers.push(float.buffer);
-            sectionEffects.push([e, float]);
-        }
         if (!mesher.mesh.vertexCount) {
             mesher.clear();
             mesher.bvhTool = null;
             continue;
         }
+        const { min, max } = mesher.bvhTool.getMeshBounds();
+        mesher.mesh.minBounds.x = min[0];
+        mesher.mesh.minBounds.y = min[1];
+        mesher.mesh.minBounds.z = min[2];
+        mesher.mesh.maxBounds.x = max[0];
+        mesher.mesh.maxBounds.y = max[1];
+        mesher.mesh.maxBounds.z = max[2];
         meshed.push(mesher);
     }
-    const compactMesh = CompactVoxelMesh(meshed, transfers);
-    sections[1] = compactMesh;
+    const compactMesh = CompactVoxelSectionMesh(location, meshed, transfers);
     for (let i = 0; i < meshed.length; i++) {
         meshed[i].clear();
         meshed[i].bvhTool = null;
     }
-    section.setDirty(false);
+    section.setDisplayDirty(false);
     section.setInProgress(false);
-    return sections;
+    return compactMesh;
 }

package/Mesher/Geomtry/CompactedSectionVoxelMesh.d.ts

@@ -0,0 +1,23 @@
+import { Vec3Array } from "@amodx/math";
+import { LocationData } from "../../Math";
+export declare class CompactedMeshData {
+    material: string;
+    minBounds: Vec3Array;
+    maxBounds: Vec3Array;
+    vertexIndex: [start: number, length: number];
+    indiceIndex: [start: number, length: number];
+    verticies: Float32Array;
+    indices: Uint16Array | Uint32Array;
+}
+export declare class CompactedSectionVoxelMesh {
+    static GetHeaderByteSize(totalMeshes?: number): number;
+    static GetMeshHeaderByteSize(): number;
+    data: DataView;
+    setData(data: ArrayBuffer): void;
+    setTotalMeshes(amount: number): void;
+    getTotalMeshes(): number;
+    setLocation(dimesion: number, x: number, y: number, z: number): void;
+    getLocation(location?: LocationData): LocationData;
+    setMeshData(index: number, mesh: CompactedMeshData): void;
+    getMeshData(index: number, mesh: CompactedMeshData): CompactedMeshData;
+}

package/Mesher/Geomtry/CompactedSectionVoxelMesh.js

@@ -0,0 +1,144 @@
+import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+export class CompactedMeshData {
+    material = "dve_solid";
+    minBounds = [0, 0, 0];
+    maxBounds = [0, 0, 0];
+    vertexIndex = [0, 0];
+    indiceIndex = [0, 0];
+    verticies;
+    indices;
+}
+export class CompactedSectionVoxelMesh {
+    static GetHeaderByteSize(totalMeshes = 0) {
+        return (
+        //dimension index 2 bytes uint16
+        2 +
+            //position x 4 bytes int32
+            4 +
+            //position y 4 bytes int32
+            4 +
+            //position z 4 bytes int32
+            4 +
+            //total meshes
+            1 +
+            //other mehes
+            totalMeshes * this.GetMeshHeaderByteSize());
+    }
+    static GetMeshHeaderByteSize() {
+        return (
+        //material index 1 byte
+        1 +
+            //min x 4 bytes Float32
+            4 +
+            //min y 4 bytes Float32
+            4 +
+            //min z 4 bytes Float32
+            4 +
+            //max x 4 bytes Float32
+            4 +
+            //max y 4 bytes Float32
+            4 +
+            //max z 4 bytes Float32
+            4 +
+            //Vertex Start Byte uint32
+            4 +
+            //Vertex Length
+            4 +
+            //Indice Start Byte uint32
+            4 +
+            //Indice Length
+            4);
+    }
+    data;
+    setData(data) {
+        this.data = new DataView(data);
+    }
+    setTotalMeshes(amount) {
+        this.data.setUint8(14, amount);
+    }
+    getTotalMeshes() {
+        return this.data.getUint8(14);
+    }
+    setLocation(dimesion, x, y, z) {
+        this.data.setInt16(0, dimesion);
+        this.data.setInt32(2, x);
+        this.data.setInt32(6, y);
+        this.data.setInt32(10, z);
+    }
+    getLocation(location = [0, 0, 0, 0]) {
+        location[0] = this.data.getInt16(0);
+        location[1] = this.data.getInt32(2);
+        location[2] = this.data.getInt32(6);
+        location[3] = this.data.getInt32(10);
+        return location;
+    }
+    setMeshData(index, mesh) {
+        const { material, minBounds, maxBounds, vertexIndex, indiceIndex } = mesh;
+        let startByte = CompactedSectionVoxelMesh.GetHeaderByteSize(0) +
+            CompactedSectionVoxelMesh.GetMeshHeaderByteSize() * index;
+        //material index
+        this.data.setUint8(startByte, VoxelPalettesRegister.material.getNumberId(material));
+        startByte++;
+        //min bounds
+        this.data.setFloat32(startByte, minBounds[0]);
+        startByte += 4;
+        this.data.setFloat32(startByte, minBounds[1]);
+        startByte += 4;
+        this.data.setFloat32(startByte, minBounds[2]);
+        startByte += 4;
+        //max bounds
+        this.data.setFloat32(startByte, maxBounds[0]);
+        startByte += 4;
+        this.data.setFloat32(startByte, maxBounds[1]);
+        startByte += 4;
+        this.data.setFloat32(startByte, maxBounds[2]);
+        startByte += 4;
+        //vertex index
+        this.data.setUint32(startByte, vertexIndex[0]);
+        startByte += 4;
+        this.data.setUint32(startByte, vertexIndex[1]);
+        startByte += 4;
+        //indice index
+        this.data.setUint32(startByte, indiceIndex[0]);
+        startByte += 4;
+        this.data.setUint32(startByte, indiceIndex[1]);
+        startByte += 4;
+    }
+    getMeshData(index, mesh) {
+        let startByte = CompactedSectionVoxelMesh.GetHeaderByteSize(0) +
+            CompactedSectionVoxelMesh.GetMeshHeaderByteSize() * index;
+        // material index
+        mesh.material = VoxelPalettesRegister.material.getStringId(this.data.getUint8(startByte));
+        startByte++;
+        // min bounds
+        mesh.minBounds[0] = this.data.getFloat32(startByte);
+        startByte += 4;
+        mesh.minBounds[1] = this.data.getFloat32(startByte);
+        startByte += 4;
+        mesh.minBounds[2] = this.data.getFloat32(startByte);
+        startByte += 4;
+        // max bounds
+        mesh.maxBounds[0] = this.data.getFloat32(startByte);
+        startByte += 4;
+        mesh.maxBounds[1] = this.data.getFloat32(startByte);
+        startByte += 4;
+        mesh.maxBounds[2] = this.data.getFloat32(startByte);
+        startByte += 4;
+        // vertex index
+        mesh.vertexIndex[0] = this.data.getUint32(startByte);
+        startByte += 4;
+        mesh.vertexIndex[1] = this.data.getUint32(startByte);
+        startByte += 4;
+        // indice index
+        mesh.indiceIndex[0] = this.data.getUint32(startByte);
+        startByte += 4;
+        mesh.indiceIndex[1] = this.data.getUint32(startByte);
+        startByte += 4;
+        mesh.verticies = new Float32Array(this.data.buffer, ...mesh.vertexIndex);
+        mesh.indices =
+            mesh.indiceIndex[1] > 65535
+                ? new Uint32Array(this.data.buffer, ...mesh.indiceIndex)
+                : new Uint16Array(this.data.buffer, ...mesh.indiceIndex);
+        return mesh;
+    }
+}

package/Mesher/Geomtry/VoxelGeometryBuilder.d.ts

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