@divinevoxel/vlox 0.0.1 → 0.0.3

package/Tasks/WorldGeneration/WorldGenBrush.js

@@ -0,0 +1,115 @@
+import { WorldGenRegister } from "./WorldGenRegister.js";
+import { BrushTool } from "../../Tools/Brush/Brush.js";
+import { LightData } from "../../Voxels/LightData.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";
+export class WorldGenBrush extends BrushTool {
+    constructor() {
+        super();
+        WorldGeneration._brushes.push(this);
+    }
+    requestsId;
+    tasks = new UpdateTask();
+    start(dimension, x, y, z) {
+        this.dataCursor.setFocalPoint(dimension, x, y, z);
+        this.tasks.setOrigin([dimension, x, y, z]);
+        this.dimension = dimension;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+    paint() {
+        let voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
+        if (!voxel) {
+            if (this.requestsId != "") {
+                WorldGenRegister.addToRequest(this.requestsId, [this.dimension, this.x, this.y, this.z], this.voxelCursor.getRaw());
+                return this;
+            }
+            throw new Error(`Tried painting in an unloaded location ${[
+                this.dimension,
+                this.x,
+                this.y,
+                this.z,
+            ].toString()}`);
+        }
+        const sl = voxel.getLight();
+        if (sl > 0 || !voxel.isAir()) {
+            this._erase();
+            voxel.setLight(sl < 0 ? 0 : sl);
+            if (LightData.hasRGBLight(sl)) {
+                this.tasks.rgb.remove.push(this.x, this.y, this.z);
+                Propagation.instance.rgbRemove(this.tasks);
+            }
+            if (LightData.hasSunLight(sl)) {
+                this.tasks.sun.remove.push(this.x, this.y, this.z);
+                Propagation.instance.sunRemove(this.tasks);
+            }
+        }
+        this._paint();
+        this.tasks.bounds.update(this.x, this.y, this.z);
+        return this;
+    }
+    getUpdatedChunks() {
+        const queue = this.tasks.bounds.getChunks();
+        this.tasks.bounds.reset();
+        return queue;
+    }
+    update() {
+        let voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
+        if (!voxel)
+            return false;
+        const sl = voxel.getLight();
+        if (LightData.hasRGBLight(sl)) {
+            this.tasks.rgb.update.push(this.x, this.y, this.z);
+            //    Propagation.instance.rgbUpdate(this.tasks);
+        }
+        if (LightData.hasSunLight(sl)) {
+            this.tasks.sun.update.push(this.x, this.y, this.z);
+            //  Propagation.instance.sunUpdate(this.tasks);
+        }
+        this.tasks.bounds.update(this.x, this.y, this.z);
+    }
+    erase() {
+        let voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
+        if (!voxel)
+            return this;
+        const sl = voxel.getLight();
+        this._erase();
+        voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
+        voxel.setLight(sl > 0 ? sl : 0);
+        if (LightData.hasRGBLight(sl)) {
+            this.tasks.rgb.remove.push(this.x, this.y, this.z);
+            Propagation.instance.rgbRemove(this.tasks);
+        }
+        if (LightData.hasSunLight(sl)) {
+            this.tasks.sun.remove.push(this.x, this.y, this.z);
+            Propagation.instance.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);
+        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();
+    }
+    worldDealloc(start, end) {
+        return new SafePromise("worldDealloc", (resolve) => {
+            DivineVoxelEngineConstructor.instance.threads.world.runPromiseTasks("world-dealloc", [this.dimension, start, end], [], () => {
+                resolve(true);
+            });
+        }).run();
+    }
+}

package/{WorldGeneration → Tasks/WorldGeneration}/WorldGenRegister.d.ts

@@ -1,5 +1,5 @@
-import type { LocationData } from "../Math";
-import { RawVoxelData } from "../Data/Types/VoxelData.types";
+import type { LocationData } from "../../Math";
+import { RawVoxelData } from "../../Voxels/Voxel.types";
 export declare class WorldGenRegister {
     static MAX_ATTEMPTS: number;
     static _requests: Map<string, {

package/{WorldGeneration → Tasks/WorldGeneration}/WorldGenRegister.js

@@ -1,10 +1,10 @@
-import { WorldSpaces } from "../Data/World/WorldSpaces.js";
-import { BrushTool } from "../Tools/Brush/Brush";
-import { ChunkDataTool } from "../Tools/Data/WorldData/ChunkDataTool";
-import { WorldBounds } from "../Data/World/WorldBounds";
-import { DivineVoxelEngineConstructor } from "Contexts/Constructor";
+import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
+import { BrushTool } from "../../Tools/Brush/Brush";
+import { ChunkDataTool } from "../../Tools/Data/WorldData/ChunkDataTool";
+import { WorldBounds } from "../../Data/World/WorldBounds";
+import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor";
 const brush = new BrushTool();
-const dataTool = brush._dt;
+const dataTool = brush.voxelCursor;
 const chunkTool = new ChunkDataTool();
 export class WorldGenRegister {
     static MAX_ATTEMPTS = 100;
@@ -76,17 +76,16 @@ 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();
-        }
+        /*     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();
+            } */
         brush.stop();
         this._requests.delete(registerId);
         return true;

package/{WorldGeneration → Tasks/WorldGeneration}/WorldGeneration.d.ts

@@ -1,8 +1,8 @@
-import { WorldBounds } from "../Data/World/WorldBounds.js";
+import { WorldBounds } from "../../Data/World/WorldBounds.js";
 import { WorldGenRegister } from "./WorldGenRegister.js";
 import { WorldGenBrush } from "./WorldGenBrush.js";
-import { WorldGenInterface } from "../Interfaces/WorldGen/WorldGen.types.js";
-import { GenerateTasks } from "../Types/Tasks.types.js";
+import { WorldGenInterface } from "./WorldGen.types.js";
+import { GenerateTasks } from "../Tasks.types.js";
 export declare class WorldGeneration {
     static worldGen: WorldGenInterface | null;
     static register: typeof WorldGenRegister;

package/{WorldGeneration → Tasks/WorldGeneration}/WorldGeneration.js

@@ -1,12 +1,10 @@
 //types
 //objects
-import { WorldBounds } from "../Data/World/WorldBounds.js";
+import { WorldBounds } from "../../Data/World/WorldBounds.js";
 import { WorldGenRegister } from "./WorldGenRegister.js";
 //tools
 import { WorldGenBrush } from "./WorldGenBrush.js";
 import { SafeInterval } from "@amodx/core/Intervals/SafeInterval.js";
-import { Threads } from "@amodx/threads";
-import { ConstructorTasksIds } from "Contexts/Constructor/ConstructorTasksIds.js";
 export class WorldGeneration {
     static worldGen = null;
     static register = WorldGenRegister;
@@ -42,13 +40,3 @@ export class WorldGeneration {
         return brush;
     }
 }
-Threads.registerTasks(ConstructorTasksIds.Generate, (data, onDone) => {
-    if (!onDone)
-        return;
-    WorldGeneration.generate(data, "generate", onDone);
-}, "deferred");
-Threads.registerTasks(ConstructorTasksIds.Decorate, (data, onDone) => {
-    if (!onDone)
-        return;
-    WorldGeneration.generate(data, "decorate", onDone);
-}, "deferred");

package/Templates/FullVoxelTemplate.d.ts

@@ -0,0 +1,13 @@
+import { Flat3DIndex, Vec3Array } from "@amodx/math";
+import { FullVoxelTemplateData } from "./VoxelTemplates.types";
+export declare class FullVoxelTemplate {
+    static CreateNew(size: Vec3Array, baseLightValue?: number): FullVoxelTemplateData;
+    index: Flat3DIndex;
+    size: Vec3Array;
+    ids: Uint16Array;
+    state: Uint16Array;
+    light: Uint16Array;
+    mod: Uint16Array;
+    secondary: Uint16Array;
+    constructor(data: FullVoxelTemplateData);
+}

package/Templates/FullVoxelTemplate.js

@@ -0,0 +1,54 @@
+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(
+        //ids
+        voxelSize * 2 +
+            //light
+            voxelSize * 2 +
+            //state
+            voxelSize * 2 +
+            //mod
+            voxelSize * 2 +
+            //secondary
+            voxelSize * 2);
+        let bufferStart = 0;
+        const ids = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        const light = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        if (baseLightValue)
+            light.fill(baseLightValue);
+        const state = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        const mod = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        const secondary = new Uint16Array(chunkBuffer, bufferStart, voxelSize);
+        bufferStart += voxelSize * 2;
+        return {
+            size,
+            ids,
+            light,
+            state,
+            secondary,
+            mod,
+        };
+    }
+    index = Flat3DIndex.GetXZYOrder();
+    size;
+    ids;
+    state;
+    light;
+    mod;
+    secondary;
+    constructor(data) {
+        this.size = [...data.size];
+        this.index.setBounds(...data.size);
+        this.ids = data.ids;
+        this.state = data.state;
+        this.light = data.light;
+        this.mod = data.mod;
+        this.secondary = data.secondary;
+    }
+}

package/Templates/Functions/CreateTemplate.js

@@ -1,7 +1,7 @@
 import { Flat3DIndex, Traverse } from "@amodx/math";
-import { StringPalette } from "../../Interfaces/Data/StringPalette";
+import { StringPalette } from "../../Util/StringPalette";
 import { VoxelTemplate } from "../VoxelTemplate";
-import { NumberPalette } from "../../Interfaces/Data/NumberPalette";
+import { NumberPalette } from "../../Util/NumberPalette";
 import { DataTool } from "../../Tools/Data/DataTool";
 import { convertToPaletteBuffer } from "../../Archive/Functions/Palettes";
 export default function CreateTemplate(dimension, start, end) {

package/Templates/VoxelTemplate.d.ts

@@ -1,8 +1,8 @@
 import { Flat3DIndex, Vec3Array } from "@amodx/math";
 import { VoxelTemplateData } from "./VoxelTemplates.types";
-import type { RawVoxelData } from "../Data/Types/VoxelData.types";
-import { StringPalette } from "../Interfaces/Data/StringPalette";
-import { NumberPalette } from "../Interfaces/Data/NumberPalette";
+import type { RawVoxelData } from "../Voxels/Voxel.types";
+import { StringPalette } from "../Util/StringPalette";
+import { NumberPalette } from "../Util/NumberPalette";
 type TemplateCursor = {
     position: Vec3Array;
     raw: RawVoxelData;

package/Templates/VoxelTemplate.js

@@ -1,9 +1,9 @@
 import { Flat3DIndex, Traverse } from "@amodx/math";
-import { StringPalette } from "../Interfaces/Data/StringPalette";
-import { NumberPalette } from "../Interfaces/Data/NumberPalette";
-import { VoxelPalette } from "../Data/Voxel/VoxelPalette";
-import { VoxelStruct } from "../Data/Voxel/VoxelStruct";
-import { VoxelTagIDs } from "../Data/Constants/VoxelTagIds";
+import { StringPalette } from "../Util/StringPalette";
+import { NumberPalette } from "../Util/NumberPalette";
+import { VoxelPalette } from "../Data/Palettes/VoxelPalette";
+import { VoxelStruct } from "../Data/Structs/VoxelStruct";
+import { VoxelStructIds } from "../Voxels/Voxel.types";
 import { getPaletteArray } from "../Archive/Functions/Palettes";
 export class VoxelTemplate {
     index = Flat3DIndex.GetXZYOrder();
@@ -56,7 +56,7 @@ export class VoxelTemplate {
     getSecondary(id, index) {
         const secondary = this.secondary;
         VoxelStruct.setVoxel(id);
-        if (VoxelStruct.instance[VoxelTagIDs.canHaveSecondary] == 1) {
+        if (VoxelStruct.instance[VoxelStructIds.canHaveSecondary] == 1) {
             return VoxelPalette.ids.getNumberId(this.secondaryIdPalette.getStringId(typeof secondary == "number" ? secondary : secondary[index]));
         }
         return this.secondaryStatePalette.getValue(typeof secondary == "number" ? secondary : secondary[index]);

package/Templates/VoxelTemplates.types.d.ts

@@ -5,6 +5,14 @@ export interface VoxelTemplateBuffers {
     mod: Uint16Array | Uint8Array | number;
     secondary: Uint16Array | Uint8Array | number;
 }
+export interface FullVoxelTemplateData {
+    size: Vec3Array;
+    ids: Uint16Array;
+    state: Uint16Array;
+    light: Uint16Array;
+    mod: Uint16Array;
+    secondary: Uint16Array;
+}
 export interface VoxelTemplatePaletteData {
     id: string[];
     secondaryId: string[];

package/Textures/Texture.types.d.ts

@@ -1,5 +1,5 @@
 export type TextureTypes = string;
-export type TextureTypeUVMap = Record<string, Record<string, Record<string, number>>>;
+export type TextureTypeUVMap = Record<string, Record<string, number>>;
 export type TextureAnimationData = {
     /**# Frames
      * If the texture has animation frames the number of frames must be set to the number
@@ -56,10 +56,6 @@ export type TextureData = {
      * If the texture is not in the default path specify it here.
      */
     path?: string;
-    /**# Segment
-     * Define the segmetn of the texutre. By default it is main.
-     */
-    segment?: string;
     /**# normalMap
      * If the texture is an overlay specify it here.
      */

package/Textures/TextureAnimations.d.ts

@@ -1,4 +1,4 @@
-import type { TextureType } from "./TextureType";
+import type { TextureArray } from "./TextureArray";
 export declare const TextureAnimationCreator: {
-    createAnimations(texture: TextureType): void;
+    createAnimations(texture: TextureArray): void;
 };

package/Textures/TextureAnimations.js

@@ -1,135 +1,35 @@
 export const TextureAnimationCreator = {
     createAnimations(texture) {
-        for (const [key, segment] of texture.segments) {
-            const animaitonUniform = [];
-            let i = 0;
-            for (const anim of segment.animationsMap) {
-                animaitonUniform[anim[0]] = anim[0];
-                let keyCounts = [];
-                const animTime = segment.animationTimes[i];
-                if (animTime.length == 1) {
-                    for (let k = 0; k < anim.length; k++) {
-                        keyCounts.push(animTime[0]);
-                    }
-                }
-                else {
-                    keyCounts = segment.animationTimes[i];
-                }
-                segment.animations.push({
-                    uniformIndex: anim[0],
-                    keys: anim,
-                    currentFrame: 0,
-                    currentCount: 0,
-                    keyCounts: keyCounts,
-                });
-                i++;
-            }
-            for (let i = 0; i < segment.totalTextures; i++) {
-                if (!animaitonUniform[i]) {
-                    animaitonUniform[i] = 0;
+        if (!texture.paths.size)
+            return;
+        const animaitonUniform = [];
+        let i = 0;
+        for (const anim of texture.animationsMap) {
+            animaitonUniform[anim[0]] = anim[0];
+            let keyCounts = [];
+            const animTime = texture.animationTimes[i];
+            if (animTime.length == 1) {
+                for (let k = 0; k < anim.length; k++) {
+                    keyCounts.push(animTime[0]);
                 }
             }
-            texture.shader.addConstants([
-                {
-                    id: "textureMasks",
-                    body: {
-                        GLSL: /* glsl  */ `
-const uint textureIndexMask = uint(0xffff);
-const uint mainTexutreIndex =uint(0);
-const uint secondaryTextureIndex = uint(0xf + 0x1);
-`,
-                    },
-                },
-            ]);
-            segment.animationUniforID =
-                `${texture.id}_${key}_texture_animations`.replace("#", "");
-            segment.varyingID = `${texture.id}_${key}_texture_index`.replace("#", "");
-            const functionName = `get_${texture.id}_${key}_texture_animation_frame`.replace("#", "");
-            texture.shader.addUniform([
-                [segment.animationUniforID, "float", animaitonUniform.length],
-            ]);
-            if (segment.mode == "sampler") {
-                texture.shader.addFunction(functionName, "vertex", {
-                    inputs: [["index", "int"]],
-                    output: "float",
-                    arguments: {},
-                    body: {
-                        GLSL: () => /* glsl  */ `    
-        float animatedIndex = ${segment.animationUniforID}[index];
-        if(animatedIndex == 0.){
-            return float(index);
-        }
-        if(animatedIndex != 0.){
-          return float(animatedIndex);
-        }
-        return float(index);`,
-                    },
-                });
-                texture.shader.addVarying([
-                    {
-                        id: segment.varyingID,
-                        type: "vec3",
-                        body: {
-                            GLSL: () => /* glsl  */ `
-        ${segment.varyingID}.x = uv.x;
-        ${segment.varyingID}.y = uv.y;
-        ${segment.varyingID}.z = ${functionName}( int( uint( ${segment.attributeID}.x)  & textureIndexMask)  );
-       `,
-                        },
-                    },
-                ]);
+            else {
+                keyCounts = texture.animationTimes[i];
             }
-            if (segment.mode == "overlay") {
-                texture.shader.addFunction(functionName, "vertex", {
-                    inputs: [],
-                    output: "vec4",
-                    arguments: {
-                        attributeID: segment.attributeID,
-                    },
-                    body: {
-                        GLSL: (args) => /* glsl  */ `
-        vec4 frames = vec4(0., 0., 0., 0.);
-        int texture1Index =  int(((textureIndexMask << secondaryTextureIndex) & uint(${args.attributeID}.x)) >> secondaryTextureIndex);
-        if( ${segment.animationUniforID}[texture1Index] != 0.) {
-            frames.x =  ${segment.animationUniforID}[texture1Index];
-        } else {
-            frames.x = float(texture1Index);
-        }
-
-        int texture2Index =  int(((textureIndexMask << mainTexutreIndex) & uint(${args.attributeID}.y)) >> mainTexutreIndex);
-        if( ${segment.animationUniforID}[texture2Index] != 0.) {
-            frames.y =  ${segment.animationUniforID}[texture2Index];
-        } else {
-            frames.y = float(texture2Index);
-        }
-
-        int texture3Index =  int(((textureIndexMask << secondaryTextureIndex) & uint(${args.attributeID}.y)) >> secondaryTextureIndex);
-        if( ${segment.animationUniforID}[texture3Index] != 0.) {
-            frames.z =  ${segment.animationUniforID}[texture3Index];
-        } else {
-            frames.z = float(texture3Index);
-        }
-
-        int texture4Index =  int(((textureIndexMask << mainTexutreIndex) & uint(${args.attributeID}.z)) >> mainTexutreIndex);
-        if( ${segment.animationUniforID}[texture4Index] != 0.) {
-            frames.w =  ${segment.animationUniforID}[texture4Index];
-        } else {
-            frames.w = float(texture4Index);
-        }
-        return frames;`,
-                    },
-                });
-                texture.shader.addVarying([
-                    {
-                        id: segment.varyingID,
-                        type: "vec4",
-                        body: {
-                            GLSL: () => `${segment.varyingID} = ${functionName}();`,
-                        },
-                    },
-                ]);
+            texture.animations.push({
+                uniformIndex: anim[0],
+                keys: anim,
+                currentFrame: 0,
+                currentCount: 0,
+                keyCounts: keyCounts,
+            });
+            i++;
+        }
+        for (let i = 0; i < texture.totalTextures; i++) {
+            if (!animaitonUniform[i]) {
+                animaitonUniform[i] = 0;
             }
-            segment.animationUniform = new Float32Array(animaitonUniform);
         }
+        texture.animationUniform = new Float32Array(animaitonUniform);
     },
 };

package/Textures/TextureArray.d.ts

@@ -0,0 +1,47 @@
+import type { TextureData } from "./Texture.types";
+export declare class TextureArray {
+    id: string;
+    extension: string;
+    totalTextures: number;
+    textureMap: Map<string, TextureData>;
+    textures: TextureData[];
+    textureIndex: Record<string, number>;
+    animationsMap: number[][];
+    animationTimes: number[][];
+    animations: {
+        uniformIndex: number;
+        overlay?: boolean;
+        keys: number[];
+        currentFrame: number;
+        currentCount: number;
+        keyCounts: number[];
+    }[];
+    varyingID: string;
+    animationUniforID: string;
+    animationUniform: Float32Array;
+    paths: Map<string, HTMLImageElement | string | false>;
+    images: HTMLImageElement[];
+    shaderTexture: any | null;
+    textureID: string;
+    attributeID: string;
+    constructor(id: string);
+    /**# clearData
+     * ---
+     * Clear all un-needed data.
+     */
+    clearData(): void;
+    /**# flush
+     * ---
+     * Clear all data.
+     */
+    flush(): void;
+    flushAll(): void;
+    build(): Promise<void>;
+    getTextureIndex(textureId: string, varation?: string): number;
+    addTexture(data: TextureData): void;
+    runAnimations(): void;
+    getTextureIndexMap(): Record<string, number>;
+    _processVariations(textureData: TextureData, paths: Map<string, HTMLImageElement | string | false>, map: Record<string, number>, animations: number[][], textureAnimatioTimes: number[][], extension: string, count: number): number;
+    _getPath(textureData: TextureData, varation: string | undefined, extension: string): string;
+    buildTextureIndex(): false | undefined;
+}