@divinevoxel/vlox 0.0.2 → 0.0.4

package/Textures/TextureManager.js

@@ -1,15 +1,15 @@
-import { EngineSettings } from "../Data/Settings/EngineSettings.js";
+import { EngineSettings } from "../Settings/EngineSettings.js";
 import { TextureBuilder } from "./TextureBuilder.js";
-import { TextureType } from "./TextureType.js";
+import { TextureArray } from "./TextureArray.js";
 export class TextureManager {
     static defaultTexturePath = "assets/textures";
     static textureTypes = new Map();
-    static getTextureIndex(data, overlay = false) {
+    static getTextureIndex(data) {
         const [textureType, textureId, varation] = data;
         const type = this.getTextureType(textureType);
         if (!type)
             return NaN;
-        return type.getTextureIndex(textureId, varation, overlay ? "overlay" : "main");
+        return type.getTextureIndex(textureId, varation);
     }
     static _ready = false;
     static isReady() {
@@ -22,13 +22,6 @@ export class TextureManager {
         }
         this._ready = true;
     }
-    static $START_ANIMATIONS() {
-        setInterval(() => {
-            for (const [key, type] of this.textureTypes) {
-                type.runAnimations();
-            }
-        }, 50);
-    }
     static generateTextureUVMap() {
         const uvMap = {};
         for (const [key, type] of this.textureTypes) {
@@ -43,10 +36,7 @@ export class TextureManager {
         const t = this.getTextureType(type);
         if (!t)
             return undefined;
-        let s = segment ? t.segments.get(segment) : t.segments.get("main");
-        if (!s)
-            return undefined;
-        return s.textureMap.get(id);
+        return t.textureMap.get(id);
     }
     static getTextureType(id) {
         const texture = this.textureTypes.get(id);
@@ -61,12 +51,13 @@ export class TextureManager {
         return texture;
     }
     static addTextureType(id) {
-        const newType = new TextureType(id);
+        const newType = new TextureArray(id);
         this.textureTypes.set(id, newType);
         return newType;
     }
     static clearTextureData() {
-        this.textureTypes.forEach((_) => _.clearSegmentData());
+        //
+        //  this.textureTypes.forEach((_) => _.clearSegmentData());
     }
     static registerTexture(textureData) {
         if (Array.isArray(textureData)) {
@@ -95,55 +86,81 @@ export class TextureManager {
         const type = this.textureTypes.get(textureType);
         return type._getPath(data, varation, type.extension);
     }
-    static async createRawDataMap() {
-        const map = new Map();
+    static async createCached() {
+        const cachedTextureData = [];
         for (const [typeKey, type] of this.textureTypes) {
-            for (const [segKey, segment] of type.segments) {
-                for (const data of segment.textures) {
-                    if (!data.includeInRawDataMap)
-                        continue;
-                    if (!data.path && !data.rawData)
-                        continue;
-                    const key = `${type.id}|${data.id}|default`;
-                    if (data.frames) {
-                        for (let i = 1; i <= data.frames; i++) {
-                            const rawData = await TextureBuilder.loadImage(data.rawData
-                                ? data.rawData[i - 1]
-                                : type._getPath(data, `${key}-${i}`, type.extension), TextureBuilder._textureSize, TextureBuilder._textureSize);
-                            data.rawData = rawData;
-                            map.set(`${key}-${i}`, rawData);
+            for (const baseData of type.textures) {
+                const data = structuredClone(baseData);
+                const id = baseData.id;
+                if (data.frames) {
+                    const images = [];
+                    for (let i = 1; i <= data.frames; i++) {
+                        images.push(await TextureBuilder.getBase64(type._getPath(data, `${id}-${i}`, type.extension)));
+                    }
+                    data.base64 = images;
+                }
+                else {
+                    data.base64 = await TextureBuilder.getBase64(type._getPath(data, "default", type.extension));
+                }
+                if (data.variations) {
+                    for (const varId in data.variations) {
+                        const varation = data.variations[varId];
+                        if (varation.frames) {
+                            const images = [];
+                            for (let i = 1; i <= varation.frames; i++) {
+                                images.push(await TextureBuilder.getBase64(type._getPath(data, `${varId}-${i}`, type.extension)));
+                            }
+                            varation.base64 = images;
+                        }
+                        else {
+                            varation.base64 = await TextureBuilder.getBase64(type._getPath(data, varId, type.extension));
                         }
                     }
-                    else {
-                        const rawData = await TextureBuilder.loadImage(data.rawData
-                            ? data.rawData
-                            : type._getPath(data, "default", type.extension), TextureBuilder._textureSize, TextureBuilder._textureSize);
+                }
+                cachedTextureData.push(data);
+            }
+        }
+        return cachedTextureData;
+    }
+    static async createRawDataMap() {
+        const map = new Map();
+        for (const [typeKey, type] of this.textureTypes) {
+            for (const data of type.textures) {
+                if (!data.includeInRawDataMap)
+                    continue;
+                if (!data.path && !data.rawData)
+                    continue;
+                const key = `${type.id}|${data.id}|default`;
+                if (data.frames) {
+                    for (let i = 1; i <= data.frames; i++) {
+                        const rawData = await TextureBuilder.getRawData(type._getPath(data, `${key}-${i}`, type.extension));
                         data.rawData = rawData;
-                        map.set(key, rawData);
+                        map.set(`${key}-${i}`, rawData);
                     }
-                    if (data.variations) {
-                        for (const varId in data.variations) {
-                            const varation = data.variations[varId];
-                            if (!varation.includeInRawDataMap)
-                                continue;
-                            const key = `${type.id}|${data.id}|${varId}`;
-                            if (data.frames) {
-                                for (let i = 1; i <= data.frames; i++) {
-                                    const rawData = await TextureBuilder.loadImage(data.rawData
-                                        ? data.rawData[i - 1]
-                                        : type._getPath(data, `${key}-${i}`, type.extension), TextureBuilder._textureSize, TextureBuilder._textureSize);
-                                    data.rawData = rawData;
-                                    map.set(`${key}-${i}`, rawData);
-                                }
-                            }
-                            else {
-                                const rawData = await TextureBuilder.loadImage(data.rawData
-                                    ? data.rawData
-                                    : type._getPath(data, varId, type.extension), TextureBuilder._textureSize, TextureBuilder._textureSize);
+                }
+                else {
+                    const rawData = await TextureBuilder.getRawData(type._getPath(data, "default", type.extension));
+                    data.rawData = rawData;
+                    map.set(key, rawData);
+                }
+                if (data.variations) {
+                    for (const varId in data.variations) {
+                        const varation = data.variations[varId];
+                        if (!varation.includeInRawDataMap)
+                            continue;
+                        const key = `${type.id}|${data.id}|${varId}`;
+                        if (data.frames) {
+                            for (let i = 1; i <= data.frames; i++) {
+                                const rawData = await TextureBuilder.getRawData(type._getPath(data, `${key}-${i}`, type.extension));
                                 data.rawData = rawData;
-                                map.set(key, rawData);
+                                map.set(`${key}-${i}`, rawData);
                             }
                         }
+                        else {
+                            const rawData = await TextureBuilder.getRawData(type._getPath(data, varId, type.extension));
+                            data.rawData = rawData;
+                            map.set(key, rawData);
+                        }
                     }
                 }
             }
@@ -151,3 +168,5 @@ export class TextureManager {
         return map;
     }
 }
+TextureManager.getOrAddTextureType("dve_voxel");
+TextureManager.getOrAddTextureType("dve_node");

package/Textures/TextureRegister.d.ts

@@ -3,7 +3,7 @@ import type { TextureTypeUVMap } from "./Texture.types";
 export declare const TextureRegister: {
     textureDataHasBeenSet: boolean;
     data: TextureTypeUVMap;
-    getTextureUV(data: ConstructorTextureData, overlay?: boolean): number;
+    getTextureUV(data: ConstructorTextureData): number;
     setTextureIndex(data: TextureTypeUVMap): void;
     releaseTextureData(): void;
     isReady(): boolean;

package/Textures/TextureRegister.js

@@ -1,21 +1,16 @@
 export const TextureRegister = {
     textureDataHasBeenSet: false,
     data: {},
-    getTextureUV(data, overlay = false) {
+    getTextureUV(data) {
         const [textureType, textureId, varation] = data;
         let id = textureId;
         if (varation) {
             id = `${textureId}:${varation}`;
         }
         let uv = -1;
-        if (!overlay) {
-            uv = this.data[textureType]["main"][id];
-        }
-        else {
-            uv = this.data[textureType]["overlay"][id];
-        }
+        uv = this.data[textureType][id];
         if (uv == -1) {
-            throw new Error(`Texture with id: ${id} does not exists. Overlay : ${overlay}`);
+            throw new Error(`Texture with id: ${id} does not exists.`);
         }
         return uv;
     },

package/Tools/Brush/AdvancedBrushTool.d.ts

@@ -1,8 +1,11 @@
 import { BrushTool } from "./Brush.js";
 import { TaskRunModes, TaskTool } from "../Tasks/TasksTool.js";
+import { LocationData } from "Math/index.js";
 export declare class AdvancedBrush extends BrushTool {
+    _location: LocationData;
     tasks: TaskTool;
     mode: TaskRunModes;
+    _mapLocation(): void;
     setMode(mode: TaskRunModes): this;
     paintAndAwaitUpdate(): Promise<unknown>;
     eraseAndAwaitUpdate(): Promise<unknown>;

package/Tools/Brush/AdvancedBrushTool.js

@@ -3,8 +3,15 @@
 import { BrushTool } from "./Brush.js";
 import { TaskTool } from "../Tasks/TasksTool.js";
 export class AdvancedBrush extends BrushTool {
+    _location = ["main", 0, 0, 0];
     tasks = new TaskTool();
     mode = "async";
+    _mapLocation() {
+        this._location[0] = this.dimension;
+        this._location[1] = this.x;
+        this._location[2] = this.y;
+        this._location[3] = this.z;
+    }
     setMode(mode) {
         this.mode = mode;
         return this;
@@ -25,22 +32,25 @@ export class AdvancedBrush extends BrushTool {
         });
     }
     paintAndUpdate(onDone) {
-        this.tasks.setFocalPoint(this.location);
-        this.tasks.voxelUpdate.paint.run(this.location, this.getRaw(), () => {
+        this._mapLocation();
+        this.tasks.setFocalPoint(this._location);
+        this.tasks.voxelUpdate.paint.run(this._location, this.getRaw(), () => {
             if (onDone)
                 onDone();
         }, this.mode);
     }
     eraseAndUpdate(onDone) {
-        this.tasks.setFocalPoint(this.location);
-        this.tasks.voxelUpdate.erase.run(this.location, () => {
+        this._mapLocation();
+        this.tasks.setFocalPoint(this._location);
+        this.tasks.voxelUpdate.erase.run(this._location, () => {
             if (onDone)
                 onDone();
         }, this.mode);
     }
     update(onDone) {
-        this.tasks.setFocalPoint(this.location);
-        this.tasks.voxelUpdate.update.run(this.location, this.getRaw(), () => {
+        this._mapLocation();
+        this.tasks.setFocalPoint(this._location);
+        this.tasks.voxelUpdate.update.run(this._location, this.getRaw(), () => {
             if (onDone)
                 onDone();
         }, this.mode);
@@ -53,8 +63,9 @@ export class AdvancedBrush extends BrushTool {
         });
     }
     explode(radius = 6, onDone) {
-        this.tasks.setFocalPoint(this.location);
-        this.tasks.explosion.run(this.location, radius, () => {
+        this._mapLocation();
+        this.tasks.setFocalPoint(this._location);
+        this.tasks.explosion.run(this._location, radius, () => {
             if (onDone)
                 onDone();
         });

package/Tools/Brush/Brush.d.ts

@@ -1,28 +1,35 @@
-import { DataTool } from "../../Tools/Data/DataTool.js";
-import type { RawVoxelData } from "../../Data/Types/VoxelData.types.js";
-import { WorldPainter } from "../../Data/World/WorldPainter.js";
-import { LocationBoundTool } from "../Classes/LocationBoundTool.js";
-import { AddVoxelData } from "../../Data/Types/WorldData.types.js";
-export declare class BrushTool extends LocationBoundTool {
-    data: AddVoxelData;
+import type { RawVoxelData } from "../../Voxels/Voxel.types.js";
+import { PaintVoxelData } from "../../Data/Types/WorldData.types.js";
+import { WorldCursor } from "../../Data/Cursor/World/WorldCursor.js";
+import { VoxelCursor } from "../../Data/Cursor/VoxelCursor.js";
+import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+export declare class BrushTool {
+    data: PaintVoxelData;
+    dimension: string;
+    x: number;
+    y: number;
+    z: number;
     name: string;
-    _worldPainter: WorldPainter;
-    _dt: DataTool;
-    setData(data: Partial<AddVoxelData>): this;
+    voxelCursor: VoxelCursor;
+    dataCursor: WorldCursor;
+    substanceData: SubstanceDataTool;
+    setXYZ(x: number, y: number, z: number): this;
+    setData(data: Partial<PaintVoxelData>): this;
+    getData(): PaintVoxelData;
+    setRaw(data: RawVoxelData): this;
+    getRaw(): RawVoxelData;
     setId(id: string): this;
     setName(name: string): this;
-    setDimension(dimensionId: string): this;
     setSecondaryId(id: string): this;
     setShapeState(state: number): this;
     setLevel(level: number): this;
     setLevelState(levelState: number): this;
     setMod(mod: number): this;
     clear(): void;
-    setRaw(data: RawVoxelData): this;
-    getRaw(): RawVoxelData;
-    getData(): AddVoxelData;
+    _paint(): false | undefined;
+    _erase(): void;
     paint(): this;
     erase(): this;
-    start(): this;
+    start(dimension: string, x: number, y: number, z: number): this;
     stop(): this;
 }

package/Tools/Brush/Brush.js

@@ -1,32 +1,63 @@
-import { DataTool } from "../../Tools/Data/DataTool.js";
-import { WorldPainter } from "../../Data/World/WorldPainter.js";
-import { WorldRegister } from "../../Data/World/WorldRegister.js";
-import { VoxelPalette } from "../../Data/Voxel/VoxelPalette.js";
-import { LocationBoundTool } from "../Classes/LocationBoundTool.js";
-const air = "dve_air";
-export class BrushTool extends LocationBoundTool {
+import { VoxelPalette } from "../../Data/Palettes/VoxelPalette.js";
+import { WorldCursor } from "../../Data/Cursor/World/WorldCursor.js";
+import { VoxelCursor } from "../../Data/Cursor/VoxelCursor.js";
+import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+const airId = "dve_air";
+const air = [0, 0, 0, 0, 0];
+export class BrushTool {
     data = {
-        id: air,
+        id: airId,
         shapeState: 0,
-        secondaryVoxelId: air,
+        secondaryVoxelId: airId,
         level: 0,
         levelState: 0,
         mod: 0,
     };
-    name = air;
-    _worldPainter = new WorldPainter();
-    _dt = new DataTool();
+    dimension;
+    x = 0;
+    y = 0;
+    z = 0;
+    name = airId;
+    voxelCursor = new VoxelCursor();
+    dataCursor = new WorldCursor();
+    substanceData = new SubstanceDataTool();
+    setXYZ(x, y, z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
     setData(data) {
-        this.data.id = data.id ? data.id : air;
+        this.data.id = data.id ? data.id : airId;
         this.data.shapeState = data.shapeState ? data.shapeState : 0;
         this.data.secondaryVoxelId = data.secondaryVoxelId
             ? data.secondaryVoxelId
-            : air;
+            : airId;
         this.data.level = data.level ? data.level : 0;
         this.data.levelState = data.levelState ? data.levelState : 0;
         this.data.mod = data.mod ? data.mod : 0;
         return this;
     }
+    getData() {
+        return this.data;
+    }
+    setRaw(data) {
+        this.voxelCursor.copyRaw(data).process();
+        this.data.id = this.voxelCursor.getStringId();
+        this.data.shapeState = this.voxelCursor.getShapeState();
+        this.data.levelState = this.voxelCursor.getLevelState();
+        this.data.level = this.voxelCursor.getLevel();
+        this.voxelCursor.setSecondary(true);
+        if (this.voxelCursor.secondaryId >= 2) {
+            this.data.secondaryVoxelId = this.voxelCursor.getStringId();
+        }
+        this.voxelCursor.setSecondary(false);
+        this.data.mod = this.voxelCursor.getMod();
+        return this;
+    }
+    getRaw() {
+        return VoxelCursor.VoxelDataToRaw(this.data);
+    }
     setId(id) {
         this.data.id = id;
         return this;
@@ -36,11 +67,6 @@ export class BrushTool extends LocationBoundTool {
         this.name = name;
         return this;
     }
-    setDimension(dimensionId) {
-        this.dimension = dimensionId;
-        this._dt.setDimension(dimensionId);
-        return this;
-    }
     setSecondaryId(id) {
         this.data.secondaryVoxelId = id;
         return this;
@@ -72,53 +98,66 @@ export class BrushTool extends LocationBoundTool {
         this.y = 0;
         this.z = 0;
     }
-    setRaw(data) {
-        this._dt.loadInRaw(data);
-        this.data.id = this._dt.getStringId();
-        this.data.shapeState = this._dt.getShapeState();
-        this.data.levelState = this._dt.getLevelState();
-        this.data.level = this._dt.getLevel();
-        this._dt.setSecondary(true);
-        if (this._dt.data.secondaryId >= 2) {
-            this.data.secondaryVoxelId = this._dt.getStringId();
+    _paint() {
+        const voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
+        if (!voxel)
+            return;
+        const id = VoxelPalette.ids.getNumberId(this.data.id);
+        if (id < 0)
+            return false;
+        voxel.setId(id);
+        voxel.setShapeState(this.data.shapeState ? this.data.shapeState : 0);
+        const substance = voxel.getSubstance();
+        if (substance > -1 && !voxel.isAir()
+            ? this.substanceData.setSubstance(voxel.getSubstance()).isLiquid()
+            : false) {
+            voxel.setLevel(7);
         }
-        this._dt.setSecondary(false);
-        this.data.mod = this._dt.getMod();
-        return this;
-    }
-    getRaw() {
-        this._dt.setId(VoxelPalette.ids.getNumberId(this.data.id));
-        this._dt
-            .setSecondary(true)
-            .setId(VoxelPalette.ids.getNumberId(this.data.secondaryVoxelId))
-            .setSecondary(false);
-        this._dt.setLevel(this.data.level);
-        this._dt.setLevelState(this.data.levelState);
-        this._dt.setShapeState(this.data.shapeState);
-        this._dt.data.raw[3] == -1 ? (this._dt.data.raw[3] = 0) : false;
-        this._dt.data.raw[4] = this.data.mod;
-        return this._dt.data.raw;
-    }
-    getData() {
-        return this.data;
+        voxel.setMod(this.data.mod);
+        if (this.data.secondaryVoxelId &&
+            this.data.secondaryVoxelId != "dve_air" &&
+            voxel.canHaveSecondaryVoxel()) {
+            const vid = VoxelPalette.ids.getNumberId(this.data.secondaryVoxelId);
+            if (vid > 0) {
+                voxel.setSecondary(true);
+                voxel.setId(vid);
+                voxel.setSecondary(false);
+            }
+        }
+        if (voxel.isLightSource() && voxel.getLightSourceValue()) {
+            voxel.setLight(voxel.getLightSourceValue());
+        }
+        /*    if (this.voxelCursor.isRich()) {
+          DataHooks.paint.onRichVoxelPaint.notify([
+            this.voxelCursor.getStringId(),
+            [this.dimenion, x, y, z],
+          ]);
+        } */
+        voxel.updateHeightMap(0);
+    }
+    _erase() {
+        const voxel = this.dataCursor.getVoxel(this.x, this.y, this.z);
+        if (!voxel)
+            return;
+        voxel.copyRaw(air).updateHeightMap(1);
     }
     paint() {
-        this._worldPainter.dimenion = this.dimension;
-        this._worldPainter.data = this.data;
-        this._worldPainter.paintVoxel(this.x, this.y, this.z);
+        this._paint();
         return this;
     }
     erase() {
-        this._worldPainter.dimenion = this.dimension;
-        this._worldPainter.eraseVoxel(this.x, this.y, this.z);
+        this._erase();
         return this;
     }
-    start() {
-        WorldRegister.instance.cache.enable();
+    start(dimension, x, y, z) {
+        this.dataCursor.setFocalPoint(dimension, x, y, z);
+        this.dimension = dimension;
+        this.x = x;
+        this.y = y;
+        this.z = z;
         return this;
     }
     stop() {
-        WorldRegister.instance.cache.disable();
         return this;
     }
 }

package/Tools/Classes/DataToolBase.js

@@ -1,7 +1,7 @@
 ;
 import { DimensionsRegister } from "../../Data/World/DimensionsRegister.js";
 import { LocationBoundTool } from "./LocationBoundTool.js";
-import { WorldDataStructProperties } from "../../Data/Constants/Structs/WorldDataStructProperties.js";
+import { WorldDataStructProperties } from "../../Data/Structs/Constants/WorldDataStructProperties.js";
 import { arrayBufferToSharedArrayBuffer } from "@amodx/core/Buffers/arrayBufferToSharedArrayBuffer.js";
 export class DataToolBase extends LocationBoundTool {
     struct;

package/Tools/Data/DataTool.d.ts

@@ -1,11 +1,11 @@
-import type { RawVoxelData } from "../../Data/Types/VoxelData.types";
-import { VoxelStruct } from "../../Data/Voxel/VoxelStruct.js";
+import type { RawVoxelData } from "../../Voxels/Voxel.types";
+import { VoxelStruct } from "../../Data/Structs/VoxelStruct.js";
 import { ChunkDataTool } from "./WorldData/ChunkDataTool.js";
 import { HeightMapTool } from "./WorldData/HeightMapTool.js";
 import { DataToolBase } from "../Classes/DataToolBase.js";
 import { ColumnDataTool } from "./WorldData/ColumnDataTool.js";
 import { SubstanceDataTool } from "./SubstanceDataTool.js";
-import { AddVoxelData } from "../../Data/Types/WorldData.types.js";
+import { PaintVoxelData } from "../../Data/Types/WorldData.types.js";
 export declare enum DataToolModes {
     /**# World Data Mode
      * ---
@@ -27,7 +27,7 @@ export declare class DataTool extends DataToolBase {
     static GetVoxelIDFromString(id: string): number;
     static GetVoxelIDFromNumber(id: number): string;
     static IsSameVoxel(dataTool1: DataTool, dataTool2: DataTool): boolean;
-    static VoxelDataToRaw(data: Partial<AddVoxelData>, light?: number): RawVoxelData;
+    static VoxelDataToRaw(data: Partial<PaintVoxelData>, light?: number): RawVoxelData;
     static Modes: typeof DataToolModes;
     static _heightMapTool: HeightMapTool;
     static _columntool: ColumnDataTool;
@@ -54,7 +54,7 @@ export declare class DataTool extends DataToolBase {
     getRaw(): RawVoxelData;
     waitTillCanLoad(maxWaitTime?: number): Promise<boolean>;
     loadInRaw(rawData: RawVoxelData): this;
-    loadInData(data: Partial<AddVoxelData>, light?: number): void;
+    loadInData(data: Partial<PaintVoxelData>, light?: number): void;
     __struct: VoxelStruct;
     private __process;
     loadIn(): boolean;
@@ -74,14 +74,15 @@ export declare class DataTool extends DataToolBase {
     setShapeState(state: number): this;
     hasSecondaryVoxel(): boolean;
     canHaveSecondaryVoxel(): boolean;
-    getShapeId(): number;
-    getShapeStringId(): string | null;
     isLightSource(): boolean;
     noAO(): boolean;
     getLightSourceValue(): number;
     getSubstanceStringId(): string;
     getSubstance(): number;
-    getMaterial(): string | null;
+    getRenderedMaterial(): number;
+    getRenderedMaterialStringId(): string;
+    getMaterial(): number;
+    getMaterialStringId(): string;
     getHardness(): number;
     getCollider(): string | null;
     checkCollisions(): boolean;