@divinevoxel/vlox 0.0.74 → 0.0.75

package/Templates/VoxelTempateRegister.js

@@ -0,0 +1,30 @@
+import { ArchivedVoxelTemplate } from "./Archive/ArchivedVoxelTemplate";
+import { FullVoxelTemplate } from "./Full/FullVoxelTemplate";
+import { BoxVoxelTemplate } from "./Shapes/BoxVoxelTemplate";
+import { ConeVoxelTemplate } from "./Shapes/ConeVoxelTemplate";
+import { CylinderVoxelTemplate } from "./Shapes/CylinderVoxelTemplate";
+import { OctahedronVoxelTemplate } from "./Shapes/OctahedronVoxelTemplate";
+import { PyramidVoxelTemplate } from "./Shapes/PyramidVoxelTemplate";
+import { SphereVoxelTemplate } from "./Shapes/SphereVoxelTemplate";
+import { TorusVoxelTemplate } from "./Shapes/TorusVoxelTemplate";
+export class VoxelTemplateRegister {
+    static _templates = new Map();
+    static register(id, constructor) {
+        this._templates.set(id, constructor);
+    }
+    static create(data) {
+        const TemplateClass = this._templates.get(data.type);
+        if (!TemplateClass)
+            throw new Error(`Voxel template with type id [${data.type}] does not exist`);
+        return new TemplateClass(data);
+    }
+}
+VoxelTemplateRegister.register("full", FullVoxelTemplate);
+VoxelTemplateRegister.register("archived", ArchivedVoxelTemplate);
+VoxelTemplateRegister.register("box-shape", BoxVoxelTemplate);
+VoxelTemplateRegister.register("sphere-shape", SphereVoxelTemplate);
+VoxelTemplateRegister.register("pyramid-shape", PyramidVoxelTemplate);
+VoxelTemplateRegister.register("cylinder-shape", CylinderVoxelTemplate);
+VoxelTemplateRegister.register("cone-shape", ConeVoxelTemplate);
+VoxelTemplateRegister.register("octahedron-shape", OctahedronVoxelTemplate);
+VoxelTemplateRegister.register("torus-shape", TorusVoxelTemplate);

package/Templates/VoxelTemplates.types.d.ts

@@ -1,29 +1,26 @@
-import { Vec3Array } from "@amodx/math";
-import { VoxelDataArrays } from "../Voxels";
-export interface VoxelTemplateBuffers {
-    ids: Uint16Array | Uint8Array | number;
-    state: Uint16Array | Uint8Array | number;
-    level: Uint8Array | number;
-    mod: Uint16Array | Uint8Array | number;
-    secondary: Uint16Array | Uint8Array | number;
+import { Flat3DIndex, Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+import { RawVoxelData } from "../Voxels/Types/Voxel.types";
+export interface IVoxelTemplate<Type extends string = "", Data extends IVoxelTemplateData<Type> = any> {
+    position: Vector3Like;
+    bounds: BoundingBox;
+    index: Flat3DIndex;
+    setPosition(x: number, y: number, z: number): void;
+    getIndex(x: number, y: number, z: number): number;
+    isAir(index: number): boolean;
+    isIncluded(index: number): boolean;
+    getId(index: number): number;
+    getLevel(index: number): number;
+    getLight(index: number): number;
+    getSecondary(index: number): number;
+    getRaw(index: number, rawRef?: RawVoxelData): RawVoxelData;
+    toJSON(): Data;
 }
-export interface FullVoxelTemplateData extends VoxelDataArrays {
-    size: Vec3Array;
+export interface IVoxelTemplateData<Type extends string> {
+    type: Type;
+    position: Vector3Like;
+    bounds: Vector3Like;
 }
-export interface VoxelTemplatePaletteData {
-    id: string[];
-    level: Uint8Array;
-    state: Uint16Array;
-    mod: Uint16Array;
-    secondaryId: string[];
-    secondaryState: Uint16Array;
-}
-export interface VoxelTemplateData {
-    /** Number representing the version of the templator used. */
-    templatorVersion: number;
-    /** Number representing the version of the voxel data. */
-    version: number;
-    size: Vec3Array;
-    palettes: VoxelTemplatePaletteData;
-    buffers: VoxelTemplateBuffers;
+export interface IVoxelTemplateConstructor<Type extends string, Data extends IVoxelTemplateData<Type> = any> {
+    new (data: Data): IVoxelTemplate<Type, Data>;
 }

package/Templates/index.d.ts

@@ -1 +1 @@
-export * from "./Functions/CreateTemplate";
+export * from "./Archive/Functions/CreateArchivedTemplate";

package/Templates/index.js

@@ -1 +1 @@
-export * from "./Functions/CreateTemplate";
+export * from "./Archive/Functions/CreateArchivedTemplate";

package/Textures/Classes/CompiledTexture.d.ts

@@ -7,9 +7,12 @@ export declare class CompiledTexture {
     static GetAtlasIndex: (x: number, y: number, boundsX: number) => number;
     static GetAtlasPosition: (index: number, boundsX: number, position?: Vec2Array) => Vec2Array;
     images: HTMLImageElement[];
+    /**Maps texture ids to their atlas sizes  */
     atlasSizeMap: Record<string, [width: number, height: number]>;
+    /**Maps texture ids to their index */
     textureMap: Record<string, number>;
     animations: CompiledTextureAnimation[];
+    /**To be used by the renderer to store a refernce to the actual texture used for rendering */
     shaderTexture: any;
     animatedTexture: TextureAnimationTexture;
     constructor(id: string);

package/Textures/Classes/CompiledTexture.js

@@ -8,9 +8,12 @@ export class CompiledTexture {
         return position;
     };
     images = [];
+    /**Maps texture ids to their atlas sizes  */
     atlasSizeMap = {};
+    /**Maps texture ids to their index */
     textureMap = {};
     animations = [];
+    /**To be used by the renderer to store a refernce to the actual texture used for rendering */
     shaderTexture;
     animatedTexture;
     constructor(id) {

package/Textures/Classes/CompiledTextureAnimation.d.ts

@@ -7,6 +7,6 @@ export declare class CompiledTextureAnimation {
     _current: number;
     _animatedTextureIndex: number;
     constructor(textureIndex: number);
-    tick(delta: number): boolean;
+    tick(delta: number): boolean | undefined;
     getIndex(): number;
 }

package/Textures/Classes/CompiledTextureAnimation.js

@@ -4,13 +4,19 @@ export class CompiledTextureAnimation {
     _times = [];
     _currentTime = 0;
     _frameIndex = 0;
-    _current = Infinity;
+    _current = -1;
     _animatedTextureIndex = -1;
     constructor(textureIndex) {
         this.textureIndex = textureIndex;
     }
     tick(delta) {
-        if (this._current == Infinity)
+        if (!this._frames.length || !this._times.length)
+            return;
+        if (Number.isNaN(this._current)) {
+            console.error("ERROR NAN", this._current, this._frameIndex, delta);
+            return;
+        }
+        if (this._current == -1)
             this._current = this._times[0];
         this._current -= delta;
         if (this._current <= 0) {

package/Textures/Functions/BuildTextureData.d.ts

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

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;