@divinevoxel/vlox 0.0.72 → 0.0.73

package/Tasks/IWG/IWG.js

@@ -29,10 +29,11 @@ export class IWG {
         IWGTools.taskTool = new TaskTool(data.threads);
         if (data.worldStorage)
             IWGTools.worldStorage = data.worldStorage;
-        console.warn("load the thing", IWGTools.worldStorage, data.worldStorage);
     }
     static createGenerator(data) {
-        return new Generator({
+        if (!initalized)
+            throw new Error(`IWG must be initalized first before creating generator`);
+        return new Generator(IWGTools.taskTool, {
             dimension: data.dimension ? data.dimension : "main",
             position: data.position ? data.position : Vector3Like.Create(),
             renderRadius: data.renderRadius ? data.renderRadius : 150,
@@ -53,6 +54,11 @@ export class IWG {
         }
         return false;
     }
+    static tick() {
+        for (const gen of this._generators) {
+            gen.tick();
+        }
+    }
     static update() {
         if (!initalized) {
             throw new Error(`IWG must be initalized.`);
@@ -77,7 +83,7 @@ export class IWG {
             }
         }
         runBuildUpdate(this._generators);
-        IWGTasks.buildTasks.runTask();
+        //  IWGTasks.buildTasks.runTask();
         runWorldUpdate(this._generators);
         IWGTasks.worldLoadTasks.runTask();
         IWGTasks.worldGenTasks.runTask();

package/Tasks/IWG/Internal/Classes/BuildQueue.d.ts

@@ -0,0 +1,11 @@
+import { LocationData } from "../../../../Math";
+import { TaskTool } from "../../../../Tools/Tasks/TasksTool";
+export declare class BuildQueue {
+    tasks: TaskTool;
+    hash: Set<unknown>;
+    sections: LocationData[];
+    constructor(tasks: TaskTool);
+    add(data: LocationData): false | undefined;
+    sort(x: number, y: number, z: number): void;
+    run(limit?: number): void;
+}

package/Tasks/IWG/Internal/Classes/BuildQueue.js

@@ -0,0 +1,49 @@
+import { WorldSpaces } from "../../../../World/WorldSpaces";
+export class BuildQueue {
+    tasks;
+    hash = new Set();
+    sections = [];
+    constructor(tasks) {
+        this.tasks = tasks;
+    }
+    add(data) {
+        const key = WorldSpaces.hash.hashXYZ(data[1], data[2], data[3]);
+        if (this.hash.has(key))
+            return false;
+        this.hash.add(key);
+        this.sections.push(data);
+    }
+    sort(x, y, z) {
+        const sections = this.sections;
+        const sx = x, sy = y, sz = z;
+        let i = sections.length, j, temp, ax, ay, az, bx, by, bz, distA, distB;
+        while (i > 1) {
+            for (j = 1; j < i; j++) {
+                (ax = sections[j - 1][1]),
+                    (ay = sections[j - 1][2]),
+                    (az = sections[j - 1][3]);
+                (bx = sections[j][1]), (by = sections[j][2]), (bz = sections[j][3]);
+                distA = (ax - sx) ** 2 + (ay - sy) ** 2 + (az - sz) ** 2;
+                distB = (bx - sx) ** 2 + (by - sy) ** 2 + (bz - sz) ** 2;
+                if (distA > distB) {
+                    temp = sections[j - 1];
+                    sections[j - 1] = sections[j];
+                    sections[j] = temp;
+                }
+            }
+            i--;
+        }
+    }
+    run(limit = 25) {
+        let count = 0;
+        while (this.sections.length) {
+            const vec = this.sections.shift();
+            const [dimension, x, y, z] = vec;
+            this.tasks.build.section.run([dimension, x, y, z]);
+            this.hash.delete(WorldSpaces.hash.hashXYZ(x, y, z));
+            count++;
+            if (count > limit)
+                break;
+        }
+    }
+}

package/Tasks/IWG/Internal/Classes/Generator.d.ts

@@ -1,5 +1,7 @@
 import { Vector3Like } from "@amodx/math";
 import { Circle } from "@amodx/math/Shapes";
+import { BuildQueue } from "./BuildQueue";
+import { TaskTool } from "../../../../Tools/Tasks/TasksTool";
 export interface GeneratorData {
     dimension: string;
     building?: boolean;
@@ -10,6 +12,7 @@ export interface GeneratorData {
     maxRadius: number;
 }
 export declare class Generator {
+    taskTool: TaskTool;
     position: Vector3Like;
     _dimension: string;
     _building: boolean;
@@ -22,6 +25,8 @@ export declare class Generator {
     _genCircle: Circle;
     _renderCircle: Circle;
     _maxCircle: Circle;
-    constructor(data: GeneratorData);
+    buildQueue: BuildQueue;
+    constructor(taskTool: TaskTool, data: GeneratorData);
     update(): void;
+    tick(): void;
 }

package/Tasks/IWG/Internal/Classes/Generator.js

@@ -1,7 +1,9 @@
 import { Vector3Like } from "@amodx/math";
 import { Circle } from "@amodx/math/Shapes";
 import { WorldSpaces } from "../../../../World/WorldSpaces";
+import { BuildQueue } from "./BuildQueue";
 export class Generator {
+    taskTool;
     position;
     _dimension = "main";
     _building = true;
@@ -14,7 +16,10 @@ export class Generator {
     _genCircle = new Circle({ x: 0, y: 0 }, 0);
     _renderCircle = new Circle({ x: 0, y: 0 }, 0);
     _maxCircle = new Circle({ x: 0, y: 0 }, 10);
-    constructor(data) {
+    buildQueue;
+    constructor(taskTool, data) {
+        this.taskTool = taskTool;
+        console.warn("make generator", taskTool);
         this._dimension = data.dimension;
         this.position = data.position;
         this._building =
@@ -23,6 +28,7 @@ export class Generator {
         this._renderCircle.radius = data.renderRadius;
         this._genCircle.radius = data.generationRadius;
         this._maxCircle.radius = data.maxRadius;
+        this.buildQueue = new BuildQueue(taskTool);
     }
     update() {
         this._positonChanged = false;
@@ -38,4 +44,10 @@ export class Generator {
         this._maxCircle.center.x = this._sectorPosition.x;
         this._maxCircle.center.y = this._sectorPosition.z;
     }
+    tick() {
+        if (this._building) {
+            this.buildQueue.sort(this.position.x, this.position.y, this.position.z);
+            this.buildQueue.run(25);
+        }
+    }
 }

package/Tasks/IWG/Internal/Classes/IWGTaskBase.js

@@ -47,12 +47,12 @@ export class IWGTaskBase {
                 const z = task.queue.shift();
                 task.waitingFor++;
                 if (this.data.propagationBlocking) {
-                    dimension.inProgress.add(x, 0, z);
+                    dimension.inProgress.add(x, y, z);
                 }
                 this.data.run([dimension.id, x, y, z], () => {
                     task.vistedMap.remove(x, y, z);
                     if (this.data.propagationBlocking) {
-                        dimension.inProgress.remove(x, 0, z);
+                        dimension.inProgress.remove(x, y, z);
                     }
                     task.waitingFor--;
                 }, dimension);

package/Tasks/IWG/Internal/Functions/runBuildUpdate.js

@@ -3,10 +3,25 @@ import { WorldSpaces } from "../../../../World/WorldSpaces";
 import { SectorState } from "../Classes/SectorState";
 import { WorldRegister } from "../../../../World/WorldRegister";
 import { getSectorState } from "./getSectorState";
-import { IWGTasks } from "../IWGTasks";
 import { IWGDimensions } from "../IWGDimensions";
 const stateCursor = new SectorState();
 const sectorSquare = new Square();
+function run(dimenion, sector, location, generator) {
+    let rendered = true;
+    if (!dimenion.rendered.has(location[1], location[2], location[3])) {
+        rendered = false;
+        dimenion.rendered.add(location[1], location[2], location[3]);
+    }
+    for (const section of sector.getRenerableSections()) {
+        if (rendered && (section.isInProgress() || !section.isDirty()))
+            continue;
+        section.setInProgress(true);
+        generator.buildQueue.add([
+            location[0],
+            ...section.getPosition(),
+        ]);
+    }
+}
 export function runBuildUpdate(generators) {
     for (const generator of generators) {
         if (!generator._building)
@@ -39,9 +54,13 @@ export function runBuildUpdate(generators) {
             if (state.nWorldGenAllDone &&
                 state.nSunAllDone &&
                 state.nPropagtionAllDone) {
+                if (sector.anySectionDirty()) {
+                    run(segment, sector, [generator._dimension, cx, cy, cz], generator);
+                    continue;
+                }
                 if (segment.rendered.has(cx, cy, cz))
                     continue;
-                IWGTasks.buildTasks.add(generator._dimension, cx, cy, cz);
+                run(segment, sector, [generator._dimension, cx, cy, cz], generator);
             }
         }
     }

package/Tasks/IWG/Internal/IWGTasks.d.ts

@@ -27,8 +27,4 @@ export declare class IWGTasks {
      * ---
      */
     static readonly saveAndUnloadTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
-    /**# Build Task
-     * ---
-     */
-    static readonly buildTasks: import("./Classes/IWGTaskBase").IWGTaskBase;
 }

package/Tasks/IWG/Internal/IWGTasks.js

@@ -126,14 +126,4 @@ export class IWGTasks {
             onDone();
         },
     });
-    /**# Build Task
-     * ---
-     */
-    static buildTasks = TaskRegister.addTasks({
-        id: "build_tasks",
-        async run(location, onDone, dimenion) {
-            dimenion.rendered.add(location[1], location[2], location[3]);
-            IWGTools.taskTool.build.sector.run(location, null, onDone);
-        },
-    });
 }

package/Tasks/IWG/Internal/IWGTools.d.ts

@@ -1,6 +1,6 @@
 import { Thread } from "@amodx/threads";
 import { TaskTool } from "../../../Tools/Tasks/TasksTool";
-import { WorldStorageInterface } from "../../../World/Storage/WorldStorage.interface";
+import { WorldStorageInterface } from "../../../World/Types/WorldStorage.interface";
 export declare class IWGTools {
     static taskTool: TaskTool;
     static worldStorage: WorldStorageInterface | null;

package/Tasks/IWG/Procedures/SaveAllSectors.js

@@ -13,6 +13,8 @@ export default async function SaveAllSectors() {
     for (const [dimensionId] of IWGDimensions._dimensions) {
         const dimension = WorldRegister.dimensions.get(dimensionId);
         for (const [key, sector] of dimension.sectors) {
+            if (sector.isStored())
+                continue;
             proms.push(worldStorage.saveSector([dimensionId, ...sector.position]));
         }
     }

package/Tasks/Update/UpdateTask.d.ts

@@ -15,10 +15,12 @@ declare class UpdatedBounds {
     _task: UpdateTask;
     min: Vector3Like;
     max: Vector3Like;
+    dimension: string;
     constructor(_task: UpdateTask);
-    reset(): void;
+    start(dimension?: string): void;
     update(x: number, y: number, z: number): void;
     getSections(): Vec3Array[];
+    markSectionsAsDirty(): void;
 }
 export declare class UpdateTask {
     flow: FlowQueues;

package/Tasks/Update/UpdateTask.js

@@ -1,6 +1,7 @@
 import { WorldCursor } from "../../World/Cursor/WorldCursor";
 import { Vector3Like } from "@amodx/math";
 import { WorldSpaces } from "../../World/WorldSpaces";
+import { WorldRegister } from "../../World/WorldRegister";
 export class TaskMap {
     _map = [];
     get size() {
@@ -34,10 +35,12 @@ class UpdatedBounds {
     _task;
     min = Vector3Like.Clone(InfinityVec3);
     max = Vector3Like.Clone(NegativeInfinityVec3);
+    dimension = "main";
     constructor(_task) {
         this._task = _task;
     }
-    reset() {
+    start(dimension) {
+        this.dimension = dimension || "main";
         Vector3Like.Copy(this.min, InfinityVec3);
         Vector3Like.Copy(this.max, NegativeInfinityVec3);
     }
@@ -76,6 +79,29 @@ class UpdatedBounds {
         }
         return sectionPositions;
     }
+    markSectionsAsDirty() {
+        const minSectionPos = WorldSpaces.section.getPosition(this.min.x - 1, this.min.y - 1, this.min.z - 1, tempPosition);
+        const minX = minSectionPos.x;
+        const minY = minSectionPos.y;
+        const minZ = minSectionPos.z;
+        const maxSectionPos = WorldSpaces.section.getPosition(this.max.x + 1, this.max.y + 1, this.max.z + 1, tempPosition);
+        const maxX = maxSectionPos.x;
+        const maxY = maxSectionPos.y;
+        const maxZ = maxSectionPos.z;
+        for (let x = minX; x <= maxX; x += WorldSpaces.section.bounds.x) {
+            for (let z = minZ; z <= maxZ; z += WorldSpaces.section.bounds.z) {
+                for (let y = minY; y <= maxY; y += WorldSpaces.section.bounds.y) {
+                    if (!WorldSpaces.world.inBounds(x, y, z))
+                        continue;
+                    const sector = WorldRegister.sectors.get(this.dimension, x, y, z);
+                    if (!sector)
+                        continue;
+                    const section = sector.getSection(x, y, z);
+                    section.setDirty(true);
+                }
+            }
+        }
+    }
 }
 export class UpdateTask {
     flow = new FlowQueues();
@@ -96,13 +122,13 @@ export class UpdateTask {
         this.flow.update.map.start(origin[1], origin[2], origin[3]);
         this.flow.remove.map.start(origin[1], origin[2], origin[3]);
         this.flow.remove.noRemoveMap.start(origin[1], origin[2], origin[3]);
+        this.bounds.start(origin[0]);
         this.clear();
     }
     clear() {
         this.rgb.clear();
         this.sun.clear();
         this.flow.clear();
-        this.bounds.reset();
     }
 }
 class FlowQueues {

package/Tasks/Update/VoxelUpdate.js

@@ -68,6 +68,8 @@ export async function EreaseAndUpdate(location) {
             SunUpdate(tasks);
         }
     }
+    tasks.bounds.update(x, y, z);
+    tasks.bounds.update(x + 1, y + 1, z + 1);
     for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
         tasks.sDataCursor
             .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
@@ -136,6 +138,8 @@ export async function PaintAndUpdate(data) {
             FlowUpdate(tasks);
         }
     }
+    tasks.bounds.update(x, y, z);
+    tasks.bounds.update(x + 1, y + 1, z + 1);
     for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
         tasks.sDataCursor
             .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
@@ -167,5 +171,7 @@ export async function VoxelUpdate(data) {
             FlowUpdate(tasks);
         }
     }
+    tasks.bounds.update(x, y, z);
+    tasks.bounds.update(x + 1, y + 1, z + 1);
     return tasks;
 }

package/Tasks/WorldGeneration/WorldGenBrush.js

@@ -56,7 +56,7 @@ export class WorldGenBrush extends BrushTool {
     }
     getUpdatedSections() {
         const queue = this.tasks.bounds.getSections();
-        this.tasks.bounds.reset();
+        this.tasks.bounds.start();
         return queue;
     }
     update() {

package/Templates/Cursor/TemplateCursor.d.ts

@@ -1,7 +1,7 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
-import { DataCursorInterface } from "../../Tools/DataCursor.interface";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { FullVoxelTemplate } from "Templates/FullVoxelTemplate";
-export declare class TemplateCursor extends DataCursorInterface {
+export declare class TemplateCursor implements DataCursorInterface {
     _voxelIndex: number;
     _template: FullVoxelTemplate | null;
     private voxel;

package/Templates/Cursor/TemplateCursor.js

@@ -1,6 +1,5 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
-import { DataCursorInterface } from "../../Tools/DataCursor.interface";
-export class TemplateCursor extends DataCursorInterface {
+export class TemplateCursor {
     _voxelIndex = 0;
     _template = null;
     voxel = new TemplateVoxelCursor(this);

package/Templates/VoxelTemplates.types.d.ts

@@ -1,5 +1,5 @@
 import { Vec3Array } from "@amodx/math";
-import { VoxelDataArrays } from "../World";
+import { VoxelDataArrays } from "../Voxels";
 export interface VoxelTemplateBuffers {
     ids: Uint16Array | Uint8Array | number;
     state: Uint16Array | Uint8Array | number;

package/Textures/Classes/CompiledTexture.d.ts

@@ -0,0 +1,18 @@
+import { Vec2Array } from "@amodx/math";
+import { TextureId } from "../../Textures/Texture.types";
+import { CompiledTextureAnimation } from "./CompiledTextureAnimation";
+import { TextureAnimationTexture } from "./TextureAnimationTexture";
+export declare class CompiledTexture {
+    id: string;
+    static GetAtlasIndex: (x: number, y: number, boundsX: number) => number;
+    static GetAtlasPosition: (index: number, boundsX: number, position?: Vec2Array) => Vec2Array;
+    images: HTMLImageElement[];
+    atlasSizeMap: Record<string, [width: number, height: number]>;
+    textureMap: Record<string, number>;
+    animations: CompiledTextureAnimation[];
+    shaderTexture: any;
+    animatedTexture: TextureAnimationTexture;
+    constructor(id: string);
+    getTextureIndex(id: TextureId): number;
+    getTexturePath(id: TextureId): string;
+}

package/Textures/Classes/CompiledTexture.js

@@ -0,0 +1,50 @@
+import { TextureAnimationTexture } from "./TextureAnimationTexture";
+export class CompiledTexture {
+    id;
+    static GetAtlasIndex = (x, y, boundsX) => x + y * boundsX;
+    static GetAtlasPosition = (index, boundsX, position = [0, 0]) => {
+        position[1] = Math.floor(index / boundsX);
+        position[0] = Math.floor(index % boundsX);
+        return position;
+    };
+    images = [];
+    atlasSizeMap = {};
+    textureMap = {};
+    animations = [];
+    shaderTexture;
+    animatedTexture;
+    constructor(id) {
+        this.id = id;
+        this.animatedTexture = new TextureAnimationTexture(this);
+    }
+    getTextureIndex(id) {
+        let finalId = "";
+        let frameIndex = 0;
+        if (!Array.isArray(id)) {
+            finalId = id;
+        }
+        if (Array.isArray(id)) {
+            finalId = id[0];
+            if (typeof id[1] == "number")
+                frameIndex = id[1];
+            if (Array.isArray(id[1]))
+                frameIndex = CompiledTexture.GetAtlasIndex(id[1][0], id[1][1], this.atlasSizeMap[finalId][0]);
+            if (typeof id[1] == "string") {
+                finalId = `${id[0]}:${id[1]}`;
+                if (typeof id[2] == "number")
+                    frameIndex = id[2];
+                if (Array.isArray(id[2]))
+                    frameIndex = CompiledTexture.GetAtlasIndex(id[2][0], id[2][1], this.atlasSizeMap[finalId][0]);
+            }
+        }
+        const index = this.textureMap[finalId];
+        if (index === undefined) {
+            console.warn(`Texture with id [passed in: ${id.toString()}] [final: ${finalId}] does not exist on compiled texture [${this.id}]`);
+            return 0;
+        }
+        return index + frameIndex;
+    }
+    getTexturePath(id) {
+        return this.images[this.getTextureIndex(id)].src;
+    }
+}

package/Textures/Classes/CompiledTextureAnimation.d.ts

@@ -0,0 +1,12 @@
+export declare class CompiledTextureAnimation {
+    textureIndex: number;
+    _frames: number[];
+    _times: number[];
+    _currentTime: number;
+    _frameIndex: number;
+    _current: number;
+    _animatedTextureIndex: number;
+    constructor(textureIndex: number);
+    tick(delta: number): boolean;
+    getIndex(): number;
+}

package/Textures/Classes/CompiledTextureAnimation.js

@@ -0,0 +1,27 @@
+export class CompiledTextureAnimation {
+    textureIndex;
+    _frames = [];
+    _times = [];
+    _currentTime = 0;
+    _frameIndex = 0;
+    _current = Infinity;
+    _animatedTextureIndex = -1;
+    constructor(textureIndex) {
+        this.textureIndex = textureIndex;
+    }
+    tick(delta) {
+        if (this._current == Infinity)
+            this._current = this._times[0];
+        this._current -= delta;
+        if (this._current <= 0) {
+            this._frameIndex++;
+            this._frameIndex %= this._frames.length;
+            this._current = this._times[this._frameIndex];
+            return true;
+        }
+        return false;
+    }
+    getIndex() {
+        return this._frames[this._frameIndex] + this.textureIndex;
+    }
+}

package/Textures/Classes/TextureAnimationTexture.d.ts

@@ -0,0 +1,10 @@
+import { CompiledTexture } from "./CompiledTexture";
+export declare class TextureAnimationTexture {
+    _texture: CompiledTexture;
+    _buffer: Uint16Array;
+    _size: number;
+    shaderTexture: any;
+    constructor(_texture: CompiledTexture);
+    build(): Uint16Array;
+    tick(delta: number): boolean;
+}

package/Textures/Classes/TextureAnimationTexture.js

@@ -0,0 +1,32 @@
+import { CompiledTexture } from "./CompiledTexture";
+export class TextureAnimationTexture {
+    _texture;
+    _buffer;
+    _size = 0;
+    shaderTexture;
+    constructor(_texture) {
+        this._texture = _texture;
+    }
+    build() {
+        const totalTexture = this._texture.images.length;
+        const size = Math.pow(2, Math.ceil(Math.log2(Math.ceil(Math.sqrt(totalTexture)))));
+        this._size = size;
+        this._buffer = new Uint16Array(size * size);
+        for (let i = 0; i < this._texture.animations.length; i++) {
+            const anim = this._texture.animations[i];
+            anim._animatedTextureIndex = CompiledTexture.GetAtlasIndex(...CompiledTexture.GetAtlasPosition(anim.textureIndex, this._size), this._size);
+        }
+        return this._buffer;
+    }
+    tick(delta) {
+        let update = false;
+        for (let i = 0; i < this._texture.animations.length; i++) {
+            const anim = this._texture.animations[i];
+            if (anim.tick(delta)) {
+                update = true;
+                this._buffer[anim._animatedTextureIndex] = anim.getIndex();
+            }
+        }
+        return update;
+    }
+}

package/Textures/Functions/BuildTextureData.d.ts

@@ -0,0 +1,10 @@
+import { CompiledTexture } from "../Classes/CompiledTexture";
+import { TextureData } from "../../Textures/Texture.types";
+export type BuildTextureDataProps = {
+    type: string;
+    baseURL?: string;
+    createCache?: boolean;
+    textures: TextureData[];
+    finalSize?: [width: number, height: number];
+};
+export declare function BuildTextureData({ type, baseURL: currentBaseURL, textures, finalSize: currentFinalSize, createCache, }: BuildTextureDataProps): Promise<CompiledTexture>;