@divinevoxel/vlox 0.0.3 → 0.0.5

package/Tasks/Update/VoxelUpdate.js

@@ -1,8 +1,11 @@
 import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
-import { $3dCardinalNeighbors } from "../../Math/Constants/CardinalNeighbors.js";
-import { Propagation } from "../../Tasks/Propagation/Propagation.js";
+import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors.js";
 import { UpdateTask } from "./UpdateTask.js";
 import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
+import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
+import { FlowUpdate } from "../Propagation/Flow/FlowUpdate.js";
+import { FlowRemove } from "../Propagation/Flow/FlowRemove.js";
 const tasks = new UpdateTask();
 const substanceData = new SubstanceDataTool();
 const updateLightTask = (tasks) => {
@@ -29,16 +32,16 @@ const updateLightTask = (tasks) => {
         }
     }
 };
-export async function EreaseAndUpdate(data) {
-    const [dimension, x, y, z] = data[0];
-    tasks.setOrigin(data[0]);
+export async function EreaseAndUpdate(location) {
+    const [dimension, x, y, z] = location;
+    tasks.setOrigin(location);
     let voxel = tasks.sDataCursor.getVoxel(x, y, z);
     if (!voxel)
         return false;
     substanceData.setSubstance(voxel.getSubstance());
     if (!voxel.isAir() && ES.doFlow() && voxel.isRenderable()) {
         if (substanceData.isLiquid()) {
-            await Propagation.instance.flowRemove(tasks);
+            FlowRemove(tasks);
             return tasks;
         }
     }
@@ -51,20 +54,20 @@ export async function EreaseAndUpdate(data) {
         .setId(0)
         .setLevel(0)
         .setLevelState(0)
-        .setShapeState(0)
+        .setState(0)
         .setMod(0)
         .updateHeightMap(1);
     if (ES.doLight()) {
         if (ES.doRGBPropagation() && isLightSource) {
             tasks.rgb.remove.push(x, y, z);
-            Propagation.instance.rgbRemove(tasks);
+            RGBRemove(tasks);
         }
         updateLightTask(tasks);
         if (ES.doRGBPropagation()) {
-            Propagation.instance.rgbUpdate(tasks);
+            RGBUpdate(tasks);
         }
         if (ES.doSunPropagation()) {
-            Propagation.instance.sunUpdate(tasks);
+            SunUpdate(tasks);
         }
     }
     return tasks;
@@ -86,13 +89,13 @@ export async function PaintAndUpdate(data) {
         if (doSun) {
             if (voxel.hasSunLight()) {
                 tasks.sun.remove.push(x, y, z);
-                Propagation.instance.sunRemove(tasks);
+                SunRemove(tasks);
             }
         }
         if (doRGB) {
             if (voxel.hasRGBLight() && isOpaque) {
                 tasks.rgb.remove.push(x, y, z);
-                Propagation.instance.rgbRemove(tasks);
+                RGBRemove(tasks);
             }
         }
     }
@@ -101,7 +104,7 @@ export async function PaintAndUpdate(data) {
     if (id < 0)
         return false;
     voxel.setId(id);
-    voxel.setShapeState(raw[2]);
+    voxel.setState(raw[2]);
     const substance = voxel.getSubstance();
     if (substance > -1 && !voxel.isAir()
         ? substanceData.setSubstance(voxel.getSubstance()).isLiquid()
@@ -122,17 +125,17 @@ export async function PaintAndUpdate(data) {
         updateLightTask(tasks);
         if (doRGB) {
             tasks.rgb.update.push(x, y, z);
-            Propagation.instance.rgbUpdate(tasks);
+            RGBUpdate(tasks);
         }
         if (doSun) {
-            Propagation.instance.sunUpdate(tasks);
+            SunUpdate(tasks);
         }
     }
     voxel = tasks.sDataCursor.getVoxel(x, y, z);
     if (ES.doFlow()) {
         if (!voxel.isAir() &&
             substanceData.setSubstance(voxel.getSubstance()).isLiquid()) {
-            Propagation.instance.flowUpdate(tasks);
+            FlowUpdate(tasks);
         }
     }
     return tasks;
@@ -149,15 +152,16 @@ export async function VoxelUpdate(data) {
         updateLightTask(tasks);
         if (doRGB) {
             tasks.rgb.update.push(x, y, z);
-            Propagation.instance.rgbUpdate(tasks);
+            RGBUpdate(tasks);
         }
         if (doSun) {
-            Propagation.instance.sunUpdate(tasks);
+            tasks.sun.update.push(x, y, z);
+            SunUpdate(tasks);
         }
     }
     if (ES.doFlow()) {
         if (substanceData.setSubstance(voxel.getSubstance()).isLiquid()) {
-            Propagation.instance.flowUpdate(tasks);
+            FlowUpdate(tasks);
         }
     }
     return tasks;

package/Tasks/WorldGeneration/InitTasks.js

@@ -2,14 +2,6 @@ import { Threads } from "@amodx/threads";
 import { WorldGeneration } from "./WorldGeneration";
 import { TasksIds } from "../../Tasks/TasksIds";
 export default function () {
-    Threads.registerTasks(TasksIds.Generate, (data, onDone) => {
-        if (!onDone)
-            return;
-        WorldGeneration.generate(data, "generate", onDone);
-    }, "deferred");
-    Threads.registerTasks(TasksIds.Decorate, (data, onDone) => {
-        if (!onDone)
-            return;
-        WorldGeneration.generate(data, "decorate", onDone);
-    }, "deferred");
+    Threads.registerTask(TasksIds.Generate, (data) => new Promise((resolve) => WorldGeneration.generate(data, "generate", resolve)));
+    Threads.registerTask(TasksIds.Decorate, (data) => new Promise((resolve) => WorldGeneration.generate(data, "decorate", resolve)));
 }

package/Tasks/WorldGeneration/WorldGenBrush.d.ts

@@ -7,10 +7,10 @@ export declare class WorldGenBrush extends BrushTool {
     tasks: UpdateTask;
     start(dimension: string, x: number, y: number, z: number): this;
     paint(): this;
-    getUpdatedChunks(): Vec3Array[];
+    getUpdatedSections(): Vec3Array[];
     update(): false | undefined;
     erase(): this;
     runUpdates(): void;
-    worldAlloc(start: Vec3Array, end: Vec3Array): Promise<boolean>;
-    worldDealloc(start: Vec3Array, end: Vec3Array): Promise<boolean>;
+    worldAlloc(start: Vec3Array, end: Vec3Array): Promise<any>;
+    worldDealloc(start: Vec3Array, end: Vec3Array): Promise<any>;
 }

package/Tasks/WorldGeneration/WorldGenBrush.js

@@ -1,11 +1,12 @@
 import { WorldGenRegister } from "./WorldGenRegister.js";
 import { BrushTool } from "../../Tools/Brush/Brush.js";
-import { LightData } from "../../Voxels/LightData.js";
+import { VoxelLightData } from "../../Voxels/Cursor/VoxelLightData.js";
 import { WorldGeneration } from "./WorldGeneration.js";
-import { SafePromise } from "@amodx/core/Promises/SafePromise.js";
-import { Propagation } from "../Propagation/Propagation.js";
 import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor/DivineVoxelEngineConstructor.js";
 import { UpdateTask } from "../Update/UpdateTask.js";
+import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
+import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
+const lightData = new VoxelLightData();
 export class WorldGenBrush extends BrushTool {
     constructor() {
         super();
@@ -40,21 +41,21 @@ export class WorldGenBrush extends BrushTool {
         if (sl > 0 || !voxel.isAir()) {
             this._erase();
             voxel.setLight(sl < 0 ? 0 : sl);
-            if (LightData.hasRGBLight(sl)) {
+            if (lightData.hasRGBLight(sl)) {
                 this.tasks.rgb.remove.push(this.x, this.y, this.z);
-                Propagation.instance.rgbRemove(this.tasks);
+                RGBRemove(this.tasks);
             }
-            if (LightData.hasSunLight(sl)) {
+            if (lightData.hasSunLight(sl)) {
                 this.tasks.sun.remove.push(this.x, this.y, this.z);
-                Propagation.instance.sunRemove(this.tasks);
+                SunRemove(this.tasks);
             }
         }
         this._paint();
         this.tasks.bounds.update(this.x, this.y, this.z);
         return this;
     }
-    getUpdatedChunks() {
-        const queue = this.tasks.bounds.getChunks();
+    getUpdatedSections() {
+        const queue = this.tasks.bounds.getSections();
         this.tasks.bounds.reset();
         return queue;
     }
@@ -63,11 +64,11 @@ export class WorldGenBrush extends BrushTool {
         if (!voxel)
             return false;
         const sl = voxel.getLight();
-        if (LightData.hasRGBLight(sl)) {
+        if (lightData.hasRGBLight(sl)) {
             this.tasks.rgb.update.push(this.x, this.y, this.z);
             //    Propagation.instance.rgbUpdate(this.tasks);
         }
-        if (LightData.hasSunLight(sl)) {
+        if (lightData.hasSunLight(sl)) {
             this.tasks.sun.update.push(this.x, this.y, this.z);
             //  Propagation.instance.sunUpdate(this.tasks);
         }
@@ -81,35 +82,27 @@ export class WorldGenBrush extends BrushTool {
         this._erase();
         voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
         voxel.setLight(sl > 0 ? sl : 0);
-        if (LightData.hasRGBLight(sl)) {
+        if (lightData.hasRGBLight(sl)) {
             this.tasks.rgb.remove.push(this.x, this.y, this.z);
-            Propagation.instance.rgbRemove(this.tasks);
+            RGBRemove(this.tasks);
         }
-        if (LightData.hasSunLight(sl)) {
+        if (lightData.hasSunLight(sl)) {
             this.tasks.sun.remove.push(this.x, this.y, this.z);
-            Propagation.instance.sunRemove(this.tasks);
+            SunRemove(this.tasks);
         }
         this.tasks.bounds.update(this.x, this.y, this.z);
         return this;
     }
     runUpdates() {
-        Propagation.instance.rgbUpdate(this.tasks);
-        Propagation.instance.sunUpdate(this.tasks);
+        RGBUpdate(this.tasks);
+        SunUpdate(this.tasks);
         this.tasks.rgb.removeMap.clear();
         this.tasks.sun.removeMap.clear();
     }
     worldAlloc(start, end) {
-        return new SafePromise("worldAlloc", (resolve) => {
-            DivineVoxelEngineConstructor.instance.threads.world.runPromiseTasks("world-alloc", [this.dimension, start, end], [], () => {
-                resolve(true);
-            });
-        }).run();
+        return DivineVoxelEngineConstructor.instance.threads.world.runTaskAsync("world-alloc", [this.dimension, start, end]);
     }
     worldDealloc(start, end) {
-        return new SafePromise("worldDealloc", (resolve) => {
-            DivineVoxelEngineConstructor.instance.threads.world.runPromiseTasks("world-dealloc", [this.dimension, start, end], [], () => {
-                resolve(true);
-            });
-        }).run();
+        return DivineVoxelEngineConstructor.instance.threads.world.runTaskAsync("world-dealloc", [this.dimension, start, end]);
     }
 }

package/Tasks/WorldGeneration/WorldGenRegister.d.ts

@@ -1,11 +1,11 @@
 import type { LocationData } from "../../Math";
-import { RawVoxelData } from "../../Voxels/Voxel.types";
+import { RawVoxelData } from "../../Voxels/Types/Voxel.types";
 export declare class WorldGenRegister {
     static MAX_ATTEMPTS: number;
     static _requests: Map<string, {
         attempts: number;
         dimension: string;
-        chunks: Map<string, [x: number, y: number, z: number]>;
+        sections: Map<string, [x: number, y: number, z: number]>;
         voxels: [x: number, y: number, z: number, data: RawVoxelData][];
     }>;
     static registerRequest(location: LocationData): string;

package/Tasks/WorldGeneration/WorldGenRegister.js

@@ -1,11 +1,10 @@
-import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
+import { WorldSpaces } from "../../World/WorldSpaces.js";
 import { BrushTool } from "../../Tools/Brush/Brush";
-import { ChunkDataTool } from "../../Tools/Data/WorldData/ChunkDataTool";
-import { WorldBounds } from "../../Data/World/WorldBounds";
+import { WorldBounds } from "../../World/WorldBounds";
 import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor";
+import { WorldRegister } from "../../World/WorldRegister";
 const brush = new BrushTool();
 const dataTool = brush.voxelCursor;
-const chunkTool = new ChunkDataTool();
 export class WorldGenRegister {
     static MAX_ATTEMPTS = 100;
     static _requests = new Map();
@@ -13,7 +12,7 @@ export class WorldGenRegister {
         const id = location.toString();
         this._requests.set(id, {
             attempts: 0,
-            chunks: new Map(),
+            sections: new Map(),
             dimension: location[0],
             voxels: [],
         });
@@ -26,17 +25,18 @@ export class WorldGenRegister {
         const requests = this._requests.get(registerId);
         if (!requests)
             return;
-        const chunkPOS = WorldSpaces.chunk.getPositionXYZ(location[1], location[2], location[3]);
-        const chunkKey = WorldSpaces.chunk.getKeyXYZ(location[1], location[2], location[3]);
-        if (!chunkTool.loadInAtLocation(location)) {
-            if (!requests.chunks.has(chunkKey)) {
-                DivineVoxelEngineConstructor.instance.threads.world.runTasks("add-chunk", [
-                    requests.dimension,
-                    chunkPOS.x,
-                    chunkPOS.y,
-                    chunkPOS.z,
+        WorldRegister.setDimension(location[0]);
+        const sector = WorldRegister.sectors.get(location[1], location[2], location[3]);
+        if (!sector) {
+            const sectorPos = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
+            const sectorKey = WorldSpaces.hash.hashVec3(sectorPos);
+            if (!requests.sections.has(sectorKey)) {
+                DivineVoxelEngineConstructor.instance.threads.world.runTask("add-sector", [requests.dimension, sectorPos.x, sectorPos.y, sectorPos.z]);
+                requests.sections.set(sectorKey, [
+                    sectorPos.x,
+                    sectorPos.y,
+                    sectorPos.z,
                 ]);
-                requests.chunks.set(chunkKey, [chunkPOS.x, chunkPOS.y, chunkPOS.z]);
             }
         }
         const [dim, x, y, z] = location;
@@ -46,25 +46,15 @@ export class WorldGenRegister {
         const requests = this._requests.get(registerId);
         if (!requests || !requests.voxels.length)
             return true;
-        chunkTool.setDimension(requests.dimension);
+        WorldRegister.setDimension(requests.dimension);
         let done = true;
-        for (const [key, pos] of requests.chunks) {
-            if (pos[0] < WorldBounds.bounds.MinX ||
-                pos[0] > WorldBounds.bounds.MaxX ||
-                pos[1] < WorldBounds.bounds.MinY ||
-                pos[1] > WorldBounds.bounds.MaxY ||
-                pos[2] < WorldBounds.bounds.MinZ ||
-                pos[2] > WorldBounds.bounds.MaxZ) {
+        for (const [key, pos] of requests.sections) {
+            if (!WorldBounds.inBounds(pos[0], pos[1], pos[2]))
                 continue;
-            }
-            if (!chunkTool.loadInAt(pos[0], pos[1], pos[2])) {
+            const sector = WorldRegister.sectors.get(pos[0], pos[1], pos[2]);
+            if (!sector) {
                 done = false;
-                DivineVoxelEngineConstructor.instance.threads.world.runTasks("add-chunk", [
-                    requests.dimension,
-                    pos[0],
-                    pos[1],
-                    pos[2],
-                ]);
+                DivineVoxelEngineConstructor.instance.threads.world.runTask("add-sector", [requests.dimension, pos[0], pos[1], pos[2]]);
             }
         }
         if (!done) {
@@ -77,15 +67,15 @@ export class WorldGenRegister {
             return false;
         }
         /*     brush.setDimension(requests.dimension);
-            dataTool.setDimension(requests.dimension);
-            const voxels = requests.voxels;
-            brush.start();
-            while (voxels.length) {
-              const data = voxels.shift();
-              if (!data) break;
-              dataTool.loadInAt(data[0], data[1], data[2]);
-              brush.setXYZ(data[0], data[1], data[2]).setRaw(data[3]).paint();
-            } */
+        dataTool.setDimension(requests.dimension);
+        const voxels = requests.voxels;
+        brush.start();
+        while (voxels.length) {
+          const data = voxels.shift();
+          if (!data) break;
+          dataTool.loadInAt(data[0], data[1], data[2]);
+          brush.setXYZ(data[0], data[1], data[2]).setRaw(data[3]).paint();
+        } */
         brush.stop();
         this._requests.delete(registerId);
         return true;

package/Tasks/WorldGeneration/WorldGeneration.d.ts

@@ -1,4 +1,4 @@
-import { WorldBounds } from "../../Data/World/WorldBounds.js";
+import { WorldBounds } from "../../World/WorldBounds.js";
 import { WorldGenRegister } from "./WorldGenRegister.js";
 import { WorldGenBrush } from "./WorldGenBrush.js";
 import { WorldGenInterface } from "./WorldGen.types.js";

package/Tasks/WorldGeneration/WorldGeneration.js

@@ -1,10 +1,9 @@
 //types
 //objects
-import { WorldBounds } from "../../Data/World/WorldBounds.js";
+import { WorldBounds } from "../../World/WorldBounds.js";
 import { WorldGenRegister } from "./WorldGenRegister.js";
 //tools
 import { WorldGenBrush } from "./WorldGenBrush.js";
-import { SafeInterval } from "@amodx/core/Intervals/SafeInterval.js";
 export class WorldGeneration {
     static worldGen = null;
     static register = WorldGenRegister;
@@ -27,16 +26,21 @@ export class WorldGeneration {
         if (mode == "decorate") {
             await this.worldGen.decorate(data);
         }
-        const inte = new SafeInterval().setInterval(100).setOnRun(() => {
-            if (WorldGenRegister.attemptRequestFullFill(requestsId)) {
-                onDone();
-                inte.stop();
-            }
-        });
-        inte.start();
+        if (!WorldGenRegister.attemptRequestFullFill(requestsId)) {
+            const readyCheck = () => {
+                if (WorldGenRegister.attemptRequestFullFill(requestsId)) {
+                    onDone();
+                    return;
+                }
+                setTimeout(readyCheck, 10);
+            };
+            readyCheck();
+        }
+        else {
+            onDone();
+        }
     }
     static getBrush() {
-        const brush = new WorldGenBrush();
-        return brush;
+        return new WorldGenBrush();
     }
 }

package/{Data/Cursor/Template → Templates/Cursor}/TemplateCursor.d.ts

@@ -1,5 +1,5 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
-import { DataCursorInterface } from "../Interfaces/DataCursor.interface";
+import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
 import { FullVoxelTemplate } from "Templates/FullVoxelTemplate";
 export declare class TemplateCursor extends DataCursorInterface {
     _voxelIndex: number;

package/{Data/Cursor/Template → Templates/Cursor}/TemplateCursor.js

@@ -1,5 +1,5 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
-import { DataCursorInterface } from "../Interfaces/DataCursor.interface";
+import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
 export class TemplateCursor extends DataCursorInterface {
     _voxelIndex = 0;
     _template = null;

package/{Data/Cursor/Template → Templates/Cursor}/TemplateVoxelCursor.d.ts

@@ -1,9 +1,10 @@
-import { VoxelCursorInterface } from "../Interfaces/VoxelCursor.interface";
+import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface";
 import { TemplateCursor } from "./TemplateCursor";
 export declare class TemplateVoxelCursor extends VoxelCursorInterface {
     dataCursor: TemplateCursor;
     private _template;
     get ids(): Uint16Array;
+    get level(): Uint8Array;
     get light(): Uint16Array;
     get state(): Uint16Array;
     get secondary(): Uint16Array;

package/{Data/Cursor/Template → Templates/Cursor}/TemplateVoxelCursor.js

@@ -1,10 +1,13 @@
-import { VoxelCursorInterface } from "../Interfaces/VoxelCursor.interface";
+import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface";
 export class TemplateVoxelCursor extends VoxelCursorInterface {
     dataCursor;
     _template;
     get ids() {
         return this._template.ids;
     }
+    get level() {
+        return this._template.level;
+    }
     get light() {
         return this._template.light;
     }

package/Templates/FullVoxelTemplate.d.ts

@@ -5,6 +5,7 @@ export declare class FullVoxelTemplate {
     index: Flat3DIndex;
     size: Vec3Array;
     ids: Uint16Array;
+    level: Uint8Array;
     state: Uint16Array;
     light: Uint16Array;
     mod: Uint16Array;

package/Templates/FullVoxelTemplate.js

@@ -2,7 +2,7 @@ import { Flat3DIndex } from "@amodx/math";
 export class FullVoxelTemplate {
     static CreateNew(size, baseLightValue = 0) {
         const voxelSize = size[0] * size[1] * size[2];
-        const chunkBuffer = new SharedArrayBuffer(
+        const sectionBuffer = new SharedArrayBuffer(
         //ids
         voxelSize * 2 +
             //light
@@ -12,24 +12,29 @@ export class FullVoxelTemplate {
             //mod
             voxelSize * 2 +
             //secondary
-            voxelSize * 2);
+            voxelSize * 2 +
+            //level
+            voxelSize);
         let bufferStart = 0;
-        const ids = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        const ids = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
         bufferStart += voxelSize * 2;
-        const light = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        const light = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
         bufferStart += voxelSize * 2;
         if (baseLightValue)
             light.fill(baseLightValue);
-        const state = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        const state = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
         bufferStart += voxelSize * 2;
-        const mod = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        const mod = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
         bufferStart += voxelSize * 2;
-        const secondary = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        const secondary = new Uint16Array(sectionBuffer, bufferStart, voxelSize);
         bufferStart += voxelSize * 2;
+        const level = new Uint8Array(sectionBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize;
         return {
             size,
             ids,
             light,
+            level,
             state,
             secondary,
             mod,
@@ -38,6 +43,7 @@ export class FullVoxelTemplate {
     index = Flat3DIndex.GetXZYOrder();
     size;
     ids;
+    level;
     state;
     light;
     mod;
@@ -46,6 +52,7 @@ export class FullVoxelTemplate {
         this.size = [...data.size];
         this.index.setBounds(...data.size);
         this.ids = data.ids;
+        this.level = data.level;
         this.state = data.state;
         this.light = data.light;
         this.mod = data.mod;