@divinevoxel/vlox 0.0.74 → 0.0.76

package/Textures/Functions/BuildTextureData.js

@@ -6,6 +6,50 @@ let context;
 let atlasCanvas;
 let atlasContext;
 const finalSize = [256, 256];
+function getNearestColor(x, y, data) {
+    const searchRadius = 5; // Radius to search for a valid pixel
+    for (let r = 1; r <= searchRadius; r++) {
+        for (let dx = -r; dx <= r; dx++) {
+            for (let dy = -r; dy <= r; dy++) {
+                const nx = x + dx;
+                const ny = y + dy;
+                if (nx >= 0 && nx < canvas.width && ny >= 0 && ny < canvas.height) {
+                    const index = (ny * canvas.width + nx) * 4;
+                    if (data[index + 3] > 0) {
+                        // If pixel is not fully transparent
+                        return [data[index], data[index + 1], data[index + 2]];
+                    }
+                }
+            }
+        }
+    }
+    return [0, 0, 0]; // Default to black if no nearby pixel is found
+}
+function applyAlphaBleeding(image) {
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d", { willReadFrequently: true });
+    if (!ctx)
+        throw new Error("Could not get 2D context");
+    canvas.width = image.width;
+    canvas.height = image.height;
+    ctx.drawImage(image, 0, 0);
+    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+    const data = imageData.data;
+    for (let y = 0; y < canvas.height; y++) {
+        for (let x = 0; x < canvas.width; x++) {
+            const index = (y * canvas.width + x) * 4;
+            const alpha = data[index + 3];
+            if (alpha === 0) {
+                const [r, g, b] = getNearestColor(x, y, data);
+                data[index] = r;
+                data[index + 1] = g;
+                data[index + 2] = b;
+            }
+        }
+    }
+    ctx.putImageData(imageData, 0, 0);
+    return canvas;
+}
 async function getImageBase64(url) {
     const response = await fetch(url);
     const blob = await response.blob();
@@ -26,15 +70,17 @@ function loadImage(src) {
 }
 async function sliceImageIntoTiles(src, tilesX, tilesY) {
     const image = await loadImage(src);
-    const tileWidth = image.width / tilesX;
-    const tileHeight = image.height / tilesY;
+    // Apply alpha bleeding before slicing into tiles
+    const processedCanvas = applyAlphaBleeding(image);
+    const tileWidth = processedCanvas.width / tilesX;
+    const tileHeight = processedCanvas.height / tilesY;
     atlasCanvas.width = tileWidth;
     atlasCanvas.height = tileHeight;
     const tiles = [];
     for (let x = 0; x < tilesX; x++) {
         for (let y = 0; y < tilesY; y++) {
             atlasContext.clearRect(0, 0, tileWidth, tileHeight);
-            atlasContext.drawImage(image, x * tileWidth, y * tileHeight, tileWidth, tileHeight, 0, 0, tileWidth, tileHeight);
+            atlasContext.drawImage(processedCanvas, x * tileWidth, y * tileHeight, tileWidth, tileHeight, 0, 0, tileWidth, tileHeight);
             tiles[CompiledTexture.GetAtlasIndex(x, y, tilesX)] =
                 atlasCanvas.toDataURL("image/png");
         }
@@ -43,31 +89,30 @@ async function sliceImageIntoTiles(src, tilesX, tilesY) {
 }
 async function loadImageForShader(imgSrcData) {
     if (!context)
-        throw new Error("");
+        throw new Error("Canvas context is not available");
     canvas.width = finalSize[0];
     canvas.height = finalSize[1];
-    const prom = new Promise((resolve, reject) => {
-        const image = typeof imgSrcData == "string" ? new Image() : imgSrcData;
-        image.onerror = (error) => reject(error);
-        if (typeof imgSrcData == "string")
+    return new Promise((resolve, reject) => {
+        const image = typeof imgSrcData === "string" ? new Image() : imgSrcData;
+        image.onerror = reject;
+        if (typeof imgSrcData === "string")
             image.src = imgSrcData;
         image.onload = () => {
+            // Apply alpha bleeding before drawing
+            const processedCanvas = applyAlphaBleeding(image);
             context.clearRect(0, 0, canvas.width, canvas.height);
             context.imageSmoothingEnabled = false;
             context.save();
             context.translate(0, canvas.height);
             context.scale(1, -1);
-            context.drawImage(image, 0, 0, canvas.width, canvas.height);
+            context.drawImage(processedCanvas, 0, 0, canvas.width, canvas.height);
             context.restore();
             const dataUrl = canvas.toDataURL("image/png");
             const returnImage = new Image(canvas.width, canvas.height);
             returnImage.src = dataUrl;
-            returnImage.onload = () => {
-                resolve(returnImage);
-            };
+            returnImage.onload = () => resolve(returnImage);
         };
     });
-    return prom;
 }
 function getImagePath(data, parentId = null) {
     if (data.base64)
@@ -143,18 +188,22 @@ async function process(compiled, data, textureIndex, parent, cache = false) {
     }
     return textureIndex + tiles.length;
 }
-export async function BuildTextureData({ type, baseURL: currentBaseURL, textures, finalSize: currentFinalSize, createCache, }) {
-    baseURL = currentBaseURL || "assets/textures";
+export async function BuildTextureData({ type, baseURL: currentBaseURL, textures, finalSize: currentFinalSize, createCache, }, progress) {
+    const defaultBaseURL = currentBaseURL || "assets/textures";
     finalSize[0] = currentFinalSize ? currentFinalSize[0] : 256;
     finalSize[1] = currentFinalSize ? currentFinalSize[1] : 256;
     if (!canvas) {
         canvas = document.createElement("canvas");
         canvas.width = finalSize[0];
         canvas.height = finalSize[1];
-        context = canvas.getContext("2d", { willReadFrequently: true });
+        context = canvas.getContext("2d", {
+            willReadFrequently: true,
+        });
         context.imageSmoothingEnabled = false;
         atlasCanvas = document.createElement("canvas");
-        atlasContext = atlasCanvas.getContext("2d", { willReadFrequently: true });
+        atlasContext = atlasCanvas.getContext("2d", {
+            willReadFrequently: true,
+        });
         // atlasContext.imageSmoothingEnabled = false;
         if (!context)
             throw new Error(`Error could not create CanvasRenderingContext2D`);
@@ -162,6 +211,14 @@ export async function BuildTextureData({ type, baseURL: currentBaseURL, textures
     const compiled = new CompiledTexture(type);
     let count = 0;
     for (const texture of textures) {
+        progress.completeWorkItems(1);
+        progress.setStatus(`Building Texture ${type} | ${texture.id}`);
+        if (texture.basePath) {
+            baseURL = texture.basePath;
+        }
+        else {
+            baseURL = defaultBaseURL;
+        }
         if (!texture.variations?.length) {
             try {
                 count = await process(compiled, texture, count, null, createCache);
@@ -176,6 +233,12 @@ export async function BuildTextureData({ type, baseURL: currentBaseURL, textures
         if (texture.variations) {
             for (let i = 0; i < texture.variations.length; i++) {
                 const vara = texture.variations[i];
+                if (texture.basePath) {
+                    baseURL = texture.basePath;
+                }
+                else {
+                    baseURL = defaultBaseURL;
+                }
                 if (typeof vara == "string") {
                     const newData = { type: texture.type, id: vara };
                     try {
@@ -191,6 +254,12 @@ export async function BuildTextureData({ type, baseURL: currentBaseURL, textures
                     }
                 }
                 try {
+                    if (vara.basePath) {
+                        baseURL = vara.basePath;
+                    }
+                    else {
+                        baseURL = defaultBaseURL;
+                    }
                     count = await process(compiled, vara, count, texture.id, createCache);
                 }
                 catch (error) {

package/Textures/Texture.types.d.ts

@@ -7,7 +7,11 @@ export type TextureDataBase = {
      */
     id: string;
     /**
-     * If the texture is not in the default path specify it here.
+     * Specify the base path to look for the texture in.
+     */
+    basePath?: string;
+    /**
+     * Specify the directy path to the texture
      */
     path?: string;
     /**

package/Textures/TextureManager.d.ts

@@ -1,3 +1,4 @@
+import { WorkItemProgress } from "../Util/WorkItemProgress.js";
 import { CompiledTexture } from "./Classes/CompiledTexture.js";
 import { BuildTextureDataProps } from "./Functions/BuildTextureData.js";
 import type { TextureData } from "./Texture.types";
@@ -6,5 +7,5 @@ export declare class TextureManager {
     static _compiledTextures: Map<string, CompiledTexture>;
     static registerTexture(textureData: TextureData[]): void;
     static getTexture(id: string): CompiledTexture;
-    static compiledTextures(props?: Omit<BuildTextureDataProps, "textures" | "type">): Promise<void>;
+    static compiledTextures(props?: Omit<BuildTextureDataProps, "textures" | "type">, progress?: WorkItemProgress): Promise<void>;
 }

package/Textures/TextureManager.js

@@ -1,3 +1,4 @@
+import { WorkItemProgress } from "../Util/WorkItemProgress.js";
 import { BuildTextureData, } from "./Functions/BuildTextureData.js";
 const missingTexture = {
     id: "dve_missing",
@@ -23,13 +24,15 @@ export class TextureManager {
             throw new Error(`Compiled texture with id ${id} does not exist`);
         return type;
     }
-    static async compiledTextures(props = {}) {
+    static async compiledTextures(props = {}, progress = new WorkItemProgress()) {
         for (const [type, data] of this._textureTypes) {
+            progress.setStatus(`Building Texture Type ${type}`);
+            progress.setWorkLoad(data.length);
             const compiled = await BuildTextureData({
                 type,
                 textures: data,
                 ...props,
-            });
+            }, progress);
             this._compiledTextures.set(type, compiled);
         }
     }

package/Tools/Brush/AdvancedBrushTool.d.ts

@@ -1,6 +1,6 @@
 import { BrushTool } from "./Brush.js";
 import { TaskRunModes, TaskTool } from "../Tasks/TasksTool.js";
-import { LocationData } from "Math/index.js";
+import { LocationData } from "../../Math/index.js";
 export declare class AdvancedBrush extends BrushTool {
     tasks: TaskTool;
     _location: LocationData;
@@ -12,8 +12,4 @@ export declare class AdvancedBrush extends BrushTool {
     eraseAndAwaitUpdate(): Promise<unknown>;
     paintAndUpdate(onDone?: Function): void;
     eraseAndUpdate(onDone?: Function): void;
-    update(onDone?: Function): void;
-    updateAndAwait(): Promise<unknown>;
-    explode(radius?: number, onDone?: Function): void;
-    explodeAwaitUpdate(radius?: number): Promise<unknown>;
 }

package/Tools/Brush/AdvancedBrushTool.js

@@ -34,44 +34,16 @@ export class AdvancedBrush extends BrushTool {
     }
     paintAndUpdate(onDone) {
         this._mapLocation();
-        this.tasks.voxel.paint.run([this._location, this.getRaw()], null, () => {
+        this.tasks.voxel.paint.run([this._location, this.getRaw(), {}], null, () => {
             if (onDone)
                 onDone();
         });
     }
     eraseAndUpdate(onDone) {
         this._mapLocation();
-        this.tasks.voxel.erease.run(this._location, null, () => {
+        this.tasks.voxel.erase.run([this._location, {}], null, () => {
             if (onDone)
                 onDone();
         });
     }
-    update(onDone) {
-        this._mapLocation();
-        this.tasks.voxel.update.run([this._location, this.getRaw()], null, () => {
-            if (onDone)
-                onDone();
-        });
-    }
-    updateAndAwait() {
-        return new Promise((resolve) => {
-            this.update(() => {
-                resolve(true);
-            });
-        });
-    }
-    explode(radius = 6, onDone) {
-        this._mapLocation();
-        this.tasks.explosion.run([this._location, radius], null, () => {
-            if (onDone)
-                onDone();
-        });
-    }
-    explodeAwaitUpdate(radius = 6) {
-        return new Promise((resolve) => {
-            this.explode(radius, () => {
-                resolve(true);
-            });
-        });
-    }
 }

package/Tools/Brush/Brush.d.ts

@@ -1,6 +1,9 @@
-import type { PaintVoxelData, RawVoxelData } from "../../Voxels/Types/Voxel.types.js";
+import type { RawVoxelData } from "../../Voxels/Types/Voxel.types.js";
 import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
 import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor.js";
+import { IVoxelTemplate } from "../../Templates/VoxelTemplates.types.js";
+import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData.js";
+import { VoxelPathData } from "../../Templates/Path/VoxelPath.types.js";
 export declare class BrushTool {
     data: PaintVoxelData;
     dimension: number;
@@ -24,11 +27,14 @@ export declare class BrushTool {
     setLevelState(levelState: number): this;
     setMod(mod: number): this;
     clear(): void;
-    _debug: boolean;
     _paint(): false | undefined;
     _erase(): void;
     paint(): this;
+    paintTemplate(voxelTemplate: IVoxelTemplate): void;
+    paintPath(data: VoxelPathData): void;
     erase(): this;
+    eraseTemplate(voxelTemplate: IVoxelTemplate): void;
+    erasePath(data: VoxelPathData): void;
     start(dimension: number, x: number, y: number, z: number): this;
     stop(): this;
 }

package/Tools/Brush/Brush.js

@@ -2,19 +2,11 @@ import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
 import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor.js";
 import { WorldRegister } from "../../World/WorldRegister.js";
 import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister.js";
-const airId = "dve_air";
-const air = [0, 0, 0, 0, 0, 0];
+import { PaintVoxelData } from "../../Voxels/Types/PaintVoxelData.js";
+const air = [0, 0, 0, 0];
+const temp = [0, 0, 0, 0];
 export class BrushTool {
-    data = {
-        id: airId,
-        name: "",
-        state: 0,
-        secondaryVoxelId: "",
-        secondaryVoxeName: "",
-        level: 0,
-        levelState: 0,
-        mod: 0,
-    };
+    data = PaintVoxelData.Create();
     dimension = 0;
     x = 0;
     y = 0;
@@ -39,8 +31,8 @@ export class BrushTool {
             if (data.id)
                 this.setId(data.id);
         }
-        if (data.secondaryVoxeName) {
-            this.setSecondaryName(data.secondaryVoxeName);
+        if (data.secondaryName) {
+            this.setSecondaryName(data.secondaryName);
         }
         else {
             if (data.secondaryVoxelId)
@@ -56,7 +48,7 @@ export class BrushTool {
         return this.data;
     }
     setRaw(data) {
-        this.voxelCursor.copyRaw(data).process();
+        this.voxelCursor.setRaw(data).process();
         this.data.id = this.voxelCursor.getStringId();
         this.data.state = this.voxelCursor.getState();
         this.data.levelState = this.voxelCursor.getLevelState();
@@ -85,11 +77,10 @@ export class BrushTool {
     setSecondaryId(id) {
         this.data.secondaryVoxelId = id;
         if (id) {
-            this.data.secondaryVoxeName =
-                VoxelPalettesRegister.voxelIdToNameMap.get(id);
+            this.data.secondaryName = VoxelPalettesRegister.voxelIdToNameMap.get(id);
         }
         else {
-            this.data.secondaryVoxeName = "";
+            this.data.secondaryName = "";
         }
         return this;
     }
@@ -101,7 +92,7 @@ export class BrushTool {
         else {
             this.data.secondaryVoxelId = "";
         }
-        this.data.secondaryVoxeName = name;
+        this.data.secondaryName = name;
         return this;
     }
     setShapeState(state) {
@@ -132,30 +123,20 @@ export class BrushTool {
         this.y = 0;
         this.z = 0;
     }
-    _debug = false;
     _paint() {
         if (!this.dataCursor.inBounds(this.x, this.y, this.z))
             return false;
         const voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
         if (!voxel)
             return;
-        const id = VoxelPalettesRegister.voxels.getNumberId(this.data.id);
-        if (id < 0)
+        if (!this.data.id || this.data.id == "dve_air")
             return false;
-        voxel.setId(id);
-        if (this._debug) {
-            console.warn(this.x, this.y, this.z, this.data.state);
-        }
-        voxel.setState(this.data.state);
+        voxel.setStringId(this.data.id, this.data.state, this.data.mod);
         voxel.setLevel(this.data.level);
-        voxel.setMod(this.data.mod);
-        if (this.data.secondaryVoxelId) {
-            const vid = VoxelPalettesRegister.voxels.getNumberId(this.data.secondaryVoxelId);
-            if (vid > 0) {
-                voxel.setSecondary(true);
-                voxel.setId(vid);
-                voxel.setSecondary(false);
-            }
+        if (this.data.secondaryVoxelId && this.data.secondaryVoxelId != "dve_air") {
+            voxel.setSecondary(true);
+            voxel.setStringId(this.data.secondaryVoxelId);
+            voxel.setSecondary(false);
         }
         voxel.process();
         if (voxel.isLightSource() && voxel.getLightSourceValue()) {
@@ -167,16 +148,60 @@ export class BrushTool {
         const voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
         if (!voxel)
             return;
-        voxel.copyRaw(air).updateVoxel(1);
+        voxel.setRaw(air).updateVoxel(1);
     }
     paint() {
         this._paint();
         return this;
     }
+    paintTemplate(voxelTemplate) {
+        const { x: ox, y: oy, z: oz } = this;
+        const { x: sx, y: sy, z: sz } = voxelTemplate.bounds.size;
+        for (let x = 0; x < sx; x++) {
+            for (let y = 0; y < sy; y++) {
+                for (let z = 0; z < sz; z++) {
+                    const tx = ox + x;
+                    const ty = oy + y;
+                    const tz = oz + z;
+                    if (!this.dataCursor.inBounds(tx, ty, tz))
+                        continue;
+                    if (voxelTemplate.isAir(voxelTemplate.getIndex(x, y, z)))
+                        continue;
+                    voxelTemplate.getRaw(voxelTemplate.getIndex(x, y, z), temp);
+                    this.setRaw(temp);
+                    this.setXYZ(tx, ty, tz).paint();
+                }
+            }
+        }
+    }
+    paintPath(data) {
+        throw new Error("Paint path not implemented.");
+    }
     erase() {
         this._erase();
         return this;
     }
+    eraseTemplate(voxelTemplate) {
+        const { x: ox, y: oy, z: oz } = this;
+        const { x: sx, y: sy, z: sz } = voxelTemplate.bounds.size;
+        for (let x = 0; x < sx; x++) {
+            for (let y = 0; y < sy; y++) {
+                for (let z = 0; z < sz; z++) {
+                    const tx = ox + x;
+                    const ty = oy + y;
+                    const tz = oz + z;
+                    if (!this.dataCursor.inBounds(tx, ty, tz))
+                        continue;
+                    if (voxelTemplate.isAir(voxelTemplate.getIndex(x, y, z)))
+                        continue;
+                    this.setXYZ(x, y, z).erase();
+                }
+            }
+        }
+    }
+    erasePath(data) {
+        throw new Error("Erase path not implemented.");
+    }
     start(dimension, x, y, z) {
         this.dataCursor.setFocalPoint(dimension, x, y, z);
         this.dimension = dimension;

package/Tools/Tasks/TasksTool.d.ts

@@ -1,48 +1,77 @@
 import { Thread, ThreadPool } from "@amodx/threads/";
-import { ExplosionTasks, GenerateTasks, VoxelUpdateTasks } from "../../Tasks/Tasks.types";
+import { PaintVoxelTemplateTask, PaintVoxelTask, EraseVoxelTask, EraseVoxelTemplateTask, PaintVoxelPathTask, EraseVoxelPathTask } from "../../Tasks/Tasks.types";
 import { LocationData } from "../../Math";
+import { SectionSnapShotTransferData } from "../../World/SnapShot/SectionSnapShot";
 export type TaskRunModes = "async" | "sync";
+interface ITask<Data> {
+    run(data: Data, transfer: any[] | null, onDone?: (data: any) => void): void;
+}
 declare class TaskQueue<Data extends any = any, ReturnData extends any = void> {
     private _task;
     private _queue;
-    constructor(_task: TaskToolTask<Data, ReturnData>);
+    constructor(_task: ITask<Data>);
     add(data: Data): void;
     clear(): void;
     run(): Promise<unknown>;
 }
-export declare class TaskToolTask<Data extends any = any, ReturnData extends any = void> {
-    id: string | number;
+export declare class LocationTaskToolTask implements ITask<LocationData> {
+    id: string;
     private _count;
     _threads: Thread[];
-    constructor(id: string | number, threads: Thread | ThreadPool);
+    constructor(id: string, threads: Thread | ThreadPool);
+    run(location: LocationData, transfer?: any[] | null, onDone?: (data: any) => void, thread?: Thread): void;
+    runAsync(location: LocationData): Promise<void>;
+    createQueue(): TaskQueue<LocationData, void>;
+}
+export declare class TaskToolTask<Data extends any = any, ReturnData extends any = void> implements ITask<Data> {
+    id: string;
+    private _count;
+    _threads: Thread[];
+    constructor(id: string, threads: Thread | ThreadPool);
     run(data: Data, transfer?: any[] | null, onDone?: (returnData: ReturnData) => void | null): void;
     runAsync(data: Data, transfer?: any[] | null): Promise<ReturnData>;
-    createQueue(): TaskQueue<Data, ReturnData>;
+    createQueue(): TaskQueue<Data, void>;
 }
 declare class VoxelTasks {
     tool: TaskTool;
-    update: TaskToolTask<VoxelUpdateTasks>;
-    paint: TaskToolTask<VoxelUpdateTasks>;
-    erease: TaskToolTask<LocationData>;
-    logic: TaskToolTask<LocationData>;
+    paint: TaskToolTask<PaintVoxelTask>;
+    paintTemplate: TaskToolTask<PaintVoxelTemplateTask>;
+    paintPath: TaskToolTask<PaintVoxelPathTask>;
+    erase: TaskToolTask<EraseVoxelTask>;
+    eraseTemplate: TaskToolTask<EraseVoxelTemplateTask>;
+    erasePath: TaskToolTask<EraseVoxelPathTask>;
     constructor(tool: TaskTool);
 }
 declare class BuildTask {
     tool: TaskTool;
-    section: TaskToolTask<LocationData>;
-    sector: TaskToolTask<LocationData>;
+    sectionSnapShot: TaskToolTask<SectionSnapShotTransferData>;
+    section: LocationTaskToolTask;
+    sector: LocationTaskToolTask;
+    constructor(tool: TaskTool);
+}
+declare class SimulationTasks {
+    tool: TaskTool;
+    logic: LocationTaskToolTask;
+    propagation: LocationTaskToolTask;
+    constructor(tool: TaskTool);
+}
+declare class GenerationTasks {
+    tool: TaskTool;
+    propagation: LocationTaskToolTask;
+    generate: LocationTaskToolTask;
+    decorate: LocationTaskToolTask;
+    worldSun: LocationTaskToolTask;
     constructor(tool: TaskTool);
 }
 export declare class TaskTool {
-    threads: Thread | ThreadPool;
+    meshers: Thread | ThreadPool;
+    generators: Thread | ThreadPool;
     voxel: VoxelTasks;
     build: BuildTask;
-    explosion: TaskToolTask<ExplosionTasks>;
-    anaylzer: TaskToolTask<LocationData>;
-    propagation: TaskToolTask<LocationData>;
-    generate: TaskToolTask<GenerateTasks>;
-    decorate: TaskToolTask<GenerateTasks>;
-    worldSun: TaskToolTask<LocationData>;
-    constructor(threads: Thread | ThreadPool);
+    generation: GenerationTasks;
+    simulation: SimulationTasks;
+    constructor(meshers: Thread | ThreadPool, generators: Thread | ThreadPool);
+    getMesher(): Thread;
+    getGenerator(): Thread;
 }
 export {};