@divinevoxel/vlox 0.0.0

package/Textures/TextureType.js

@@ -0,0 +1,287 @@
+import { URIShader } from "@amodx/uri/Shaders/Classes/URIShader";
+import { TextureManager } from "./TextureManager.js";
+import { TextureAnimationCreator } from "./TextureAnimations.js";
+import { TextureBuilder } from "./TextureBuilder.js";
+class TextureSegment {
+    parentID;
+    id;
+    mode;
+    attributeID;
+    totalTextures = 0;
+    textureMap = new Map();
+    textures = [];
+    textureIndex = {};
+    animationsMap = [];
+    animationTimes = [];
+    animations = [];
+    varyingID = "";
+    animationUniforID = "";
+    animationUniform = new Float32Array();
+    paths = new Map();
+    shaderTexture = null;
+    textureID = "";
+    constructor(parentID, id, mode, attributeID) {
+        this.parentID = parentID;
+        this.id = id;
+        this.mode = mode;
+        this.attributeID = attributeID;
+        this.textureID = `${parentID}_${id}`.replace("#", "");
+    }
+    /**# clearData
+     * ---
+     * Clear all un-needed data.
+     */
+    clearData() {
+        this.paths.clear();
+        this.textures = [];
+        this.textureMap.clear();
+        this.textureIndex = {};
+        this.shaderTexture = null;
+        this.animationsMap = [];
+        this.animationTimes = [];
+    }
+    /**# flush
+     * ---
+     * Clear all data.
+     */
+    flush() {
+        this.clearData();
+        this.shaderTexture?.dispose();
+        this.shaderTexture = null;
+        this.animations = [];
+        this.animationTimes = [];
+        this.animationsMap = [];
+        this.textureIndex = {};
+        this.totalTextures = 0;
+    }
+}
+export class TextureType {
+    id;
+    extension = "png";
+    segments;
+    materials = new Map();
+    shader;
+    constructor(id) {
+        this.id = id;
+        const main = new TextureSegment(id, "main", "sampler", "textureIndex");
+        const overlay = new TextureSegment(id, "overlay", "overlay", "textureIndex");
+        this.segments = new Map([
+            ["main", main],
+            ["overlay", overlay],
+        ]);
+    }
+    flushAll() {
+        this.segments.forEach((_, key) => _.flush());
+        this.materials.clear();
+    }
+    async build() {
+        this.buildTextureIndex();
+        this.shader = new URIShader(this.id);
+        for (const [id, segment] of this.segments) {
+            segment.shaderTexture = await TextureBuilder.createMaterialTexture(id, segment.paths);
+            this.shader.addTextures([
+                [segment.textureID, { type: "sampler2DArray" }],
+            ]);
+        }
+        TextureAnimationCreator.createAnimations(this);
+    }
+    getTextureIndex(textureId, varation = "", segment = "main") {
+        const textureSegment = this.segments.get(segment);
+        let id = textureId;
+        if (varation) {
+            id = `${textureId}:${varation}`;
+        }
+        let uv = -1;
+        uv = textureSegment.textureIndex[id];
+        if (uv == -1) {
+            throw new Error(`Texture with id: ${id} does not exists.typeId : ${this.id}  segment : ${segment}`);
+        }
+        return uv;
+    }
+    clearSegmentData() {
+        this.segments.forEach((_) => _.clearData());
+    }
+    removeSegment(id) {
+        const segment = this.segments.get(id);
+        if (!segment)
+            return false;
+        if (this.shader)
+            this.shader.data.textures.delete(segment.textureID);
+        this.segments.delete(id);
+    }
+    addTexture(data) {
+        const segment = this.segments.get(data.segment ? data.segment : "main");
+        if (!segment)
+            return false;
+        segment.textures.push(data);
+        segment.textureMap.set(data.id, data);
+    }
+    addToShader(shader) {
+        const main = this.segments.get("main");
+        const overlay = this.segments.get("overlay");
+        if (overlay) {
+            shader.setArgumentOverride("function", "getBaseColor", {
+                textureID: main.textureID,
+                overlayTextureID: overlay.textureID,
+                mainVarying: main.varyingID,
+                overlayVarying: overlay.varyingID,
+            });
+        }
+        shader.setArgumentOverride("function", "getMainColor", {
+            textureID: main.textureID,
+            mainVarying: main.varyingID,
+        });
+        return this.shader.merge(shader, false);
+    }
+    addToMaterial(material) {
+        for (const [key, segment] of this.segments) {
+            if (!segment.shaderTexture)
+                continue;
+            material.setTexture(segment.textureID, segment.shaderTexture);
+            material.setNumberArray(segment.animationUniforID, segment.animationUniform);
+        }
+        this.materials.set(material.id, material);
+    }
+    runAnimations() {
+        for (const [key, segment] of this.segments) {
+            for (let i = 0; i < segment.animations.length; i++) {
+                const anim = segment.animations[i];
+                if (anim.currentCount <= anim.keyCounts[anim.currentFrame]) {
+                    anim.currentCount++;
+                    continue;
+                }
+                anim.currentCount = 0;
+                if (anim.currentFrame < anim.keys.length - 1) {
+                    anim.currentFrame++;
+                }
+                else {
+                    anim.currentFrame = 0;
+                }
+                segment.animationUniform[anim.uniformIndex] =
+                    anim.keys[anim.currentFrame];
+                for (const [key, material] of this.materials) {
+                    material.setNumberArray(segment.animationUniforID, segment.animationUniform);
+                }
+            }
+        }
+    }
+    getTextureIndexMap() {
+        const segmentMap = {};
+        for (const [key, segment] of this.segments) {
+            segmentMap[key] ??= {};
+            segmentMap[key] = segment.textureIndex;
+        }
+        return segmentMap;
+    }
+    _processVariations(textureData, paths, map, animations, textureAnimatioTimes, extension, count) {
+        if (!textureData.variations)
+            return count;
+        for (const varation of Object.keys(textureData.variations)) {
+            const data = textureData.variations[varation];
+            if (data.frames == 0) {
+                map[`${textureData.id}:${varation}`] = count;
+                const assetPath = this._getPath(textureData, varation, extension);
+                let raw = false;
+                if (data.rawData && !Array.isArray(data.rawData)) {
+                    raw = data.rawData;
+                }
+                if (data.base64 && !Array.isArray(data.base64)) {
+                    raw = data.base64;
+                }
+                paths.set(assetPath, raw);
+                count++;
+            }
+            else {
+                if (!data.animKeys)
+                    throw new Error("Texture Varation must have supplied animKeys if frames are greater than 0.");
+                for (let i = 1; i <= data.frames; i++) {
+                    map[`${textureData.id}:${varation}-${i}`] = count;
+                    const assetPath = this._getPath(textureData, `${varation}-${i}`, extension);
+                    let raw = false;
+                    if (data.rawData) {
+                        raw = data.rawData[i - 1];
+                    }
+                    if (data.base64) {
+                        raw = data.base64[i - 1];
+                    }
+                    paths.set(assetPath, raw);
+                    count++;
+                }
+                const trueKeys = [];
+                for (let i = 0; i < data.animKeys.length; i++) {
+                    trueKeys.push(map[`${textureData.id}:${varation}-${data.animKeys[i]}`]);
+                }
+                if (data.animKeyFrameTimes) {
+                    textureAnimatioTimes.push(data.animKeyFrameTimes);
+                }
+                if (data.globalFrameTime) {
+                    textureAnimatioTimes.push([data.globalFrameTime]);
+                }
+                animations.push(trueKeys);
+            }
+        }
+        return count;
+    }
+    _getPath(textureData, varation = "default", extension) {
+        return `${textureData.path ? textureData.path : TextureManager.defaultTexturePath}/${textureData.id}/${varation}.${extension}`;
+    }
+    buildTextureIndex() {
+        const texture = this;
+        if (!texture)
+            return false;
+        const extension = texture.extension;
+        for (const [key, segment] of texture.segments) {
+            let count = 1;
+            const map = segment.textureIndex;
+            const paths = segment.paths;
+            const animationTimes = segment.animationTimes;
+            const animations = segment.animationsMap;
+            for (const textureData of segment.textures) {
+                if (textureData.frames == 0) {
+                    segment.textureIndex[`${textureData.id}`] = count;
+                    const assetPath = this._getPath(textureData, "default", extension);
+                    let raw = false;
+                    if (textureData.rawData && !Array.isArray(raw)) {
+                        raw = textureData.rawData;
+                    }
+                    if (textureData.base64 && !Array.isArray(textureData.base64)) {
+                        raw = textureData.base64;
+                    }
+                    paths.set(assetPath, raw);
+                    count++;
+                    count = this._processVariations(textureData, paths, map, animations, animationTimes, extension, count);
+                }
+                else {
+                    if (!textureData.animKeys)
+                        throw new Error("Texture must have supplied animKeys if frames are greater than 0.");
+                    const rawData = textureData.rawData;
+                    for (let i = 1; i <= textureData.frames; i++) {
+                        const assetPath = this._getPath(textureData, `default-${i}`, extension);
+                        let raw = false;
+                        if (rawData) {
+                            raw = rawData[i - 1];
+                        }
+                        if (textureData.base64) {
+                            raw = textureData.base64[i - 1];
+                        }
+                        paths.set(assetPath, raw);
+                        count++;
+                    }
+                    const trueKeys = [];
+                    for (let i = 0; i < textureData.animKeys.length; i++) {
+                        trueKeys.push(map[`${textureData.id}:default-${textureData.animKeys[i]}`]);
+                    }
+                    if (textureData.animKeyFrameTimes) {
+                        animationTimes.push(textureData.animKeyFrameTimes);
+                    }
+                    if (textureData.globalFrameTime) {
+                        animationTimes.push([textureData.globalFrameTime]);
+                    }
+                    animations.push(trueKeys);
+                    count = this._processVariations(textureData, paths, map, animations, animationTimes, extension, count);
+                }
+            }
+            segment.totalTextures = count;
+        }
+    }
+}

package/Tools/Anaylzer/AnaylzerTool.d.ts

@@ -0,0 +1,6 @@
+import { ColumnDataTool } from "../Data/WorldData/ColumnDataTool.js";
+import { LocationBoundTool } from "../Classes/LocationBoundTool.js";
+export declare class AnaylzerTool extends LocationBoundTool {
+    static columnDataTool: ColumnDataTool;
+    runUpdate(radius: number, onDone: Function): void;
+}

package/Tools/Anaylzer/AnaylzerTool.js

@@ -0,0 +1,31 @@
+import { Distance3D } from "@amodx/math/Vectors/Functions/Distance3d";
+import { ColumnDataTool } from "../Data/WorldData/ColumnDataTool.js";
+import { LocationBoundTool } from "../Classes/LocationBoundTool.js";
+import { WorldRegister } from "../../Data/World/WorldRegister.js";
+import { SafeInterval } from "@amodx/core/Intervals/SafeInterval.js";
+export class AnaylzerTool extends LocationBoundTool {
+    static columnDataTool = new ColumnDataTool();
+    runUpdate(radius, onDone) {
+        const [dimension, sx, sy, sz] = this.location;
+        const dim = WorldRegister.instance.dimensions.get(dimension);
+        if (!dim)
+            return;
+        let totalColumns = 0;
+        for (const [key, region] of dim.regions) {
+            for (const [index, column] of region.columns) {
+                const [cx, cy, cz] = region.getColumnPosition(index);
+                if (Distance3D(sx, sy, sz, cx, cy, cz) > radius) {
+                    totalColumns++;
+                }
+            }
+        }
+        const inte = new SafeInterval().setInterval(1).setOnRun(() => {
+            if (totalColumns == 0) {
+                inte.stop();
+                if (onDone)
+                    onDone();
+            }
+        });
+        inte.start();
+    }
+}

package/Tools/Brush/AdvancedBrushTool.d.ts

@@ -0,0 +1,15 @@
+import { BrushTool } from "./Brush.js";
+import { TaskRunModes, TaskTool } from "../Tasks/TasksTool.js";
+export declare class AdvancedBrush extends BrushTool {
+    tasks: TaskTool;
+    mode: TaskRunModes;
+    setMode(mode: TaskRunModes): this;
+    paintAndAwaitUpdate(): Promise<unknown>;
+    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

@@ -0,0 +1,69 @@
+//util
+//tools
+import { BrushTool } from "./Brush.js";
+import { TaskTool } from "../Tasks/TasksTool.js";
+export class AdvancedBrush extends BrushTool {
+    tasks = new TaskTool();
+    mode = "async";
+    setMode(mode) {
+        this.mode = mode;
+        return this;
+    }
+    paintAndAwaitUpdate() {
+        return new Promise((resolve) => {
+            this.paintAndUpdate(() => {
+                resolve(true);
+            });
+        });
+    }
+    eraseAndAwaitUpdate() {
+        const self = this;
+        return new Promise((resolve) => {
+            self.eraseAndUpdate(() => {
+                resolve(true);
+            });
+        });
+    }
+    paintAndUpdate(onDone) {
+        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, () => {
+            if (onDone)
+                onDone();
+        }, this.mode);
+    }
+    update(onDone) {
+        this.tasks.setFocalPoint(this.location);
+        this.tasks.voxelUpdate.update.run(this.location, this.getRaw(), () => {
+            if (onDone)
+                onDone();
+        }, this.mode);
+    }
+    updateAndAwait() {
+        return new Promise((resolve) => {
+            this.update(() => {
+                resolve(true);
+            });
+        });
+    }
+    explode(radius = 6, onDone) {
+        this.tasks.setFocalPoint(this.location);
+        this.tasks.explosion.run(this.location, radius, () => {
+            if (onDone)
+                onDone();
+        });
+    }
+    explodeAwaitUpdate(radius = 6) {
+        return new Promise((resolve) => {
+            this.explode(radius, () => {
+                resolve(true);
+            });
+        });
+    }
+}

package/Tools/Brush/Brush.d.ts

@@ -0,0 +1,28 @@
+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;
+    name: string;
+    _worldPainter: WorldPainter;
+    _dt: DataTool;
+    setData(data: Partial<AddVoxelData>): this;
+    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(): this;
+    erase(): this;
+    start(): this;
+    stop(): this;
+}

package/Tools/Brush/Brush.js

@@ -0,0 +1,124 @@
+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 {
+    data = {
+        id: air,
+        shapeState: 0,
+        secondaryVoxelId: air,
+        level: 0,
+        levelState: 0,
+        mod: 0,
+    };
+    name = air;
+    _worldPainter = new WorldPainter();
+    _dt = new DataTool();
+    setData(data) {
+        this.data.id = data.id ? data.id : air;
+        this.data.shapeState = data.shapeState ? data.shapeState : 0;
+        this.data.secondaryVoxelId = data.secondaryVoxelId
+            ? data.secondaryVoxelId
+            : air;
+        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;
+    }
+    setId(id) {
+        this.data.id = id;
+        return this;
+    }
+    setName(name) {
+        this.data.id = VoxelPalette.name.getId(name);
+        this.name = name;
+        return this;
+    }
+    setDimension(dimensionId) {
+        this.dimension = dimensionId;
+        this._dt.setDimension(dimensionId);
+        return this;
+    }
+    setSecondaryId(id) {
+        this.data.secondaryVoxelId = id;
+        return this;
+    }
+    setShapeState(state) {
+        this.data.shapeState = state;
+        return this;
+    }
+    setLevel(level) {
+        this.data.level = level;
+        return this;
+    }
+    setLevelState(levelState) {
+        this.data.levelState = levelState;
+        return this;
+    }
+    setMod(mod) {
+        this.data.mod = mod;
+        return this;
+    }
+    clear() {
+        this.data.id = "dve_air";
+        this.data.secondaryVoxelId = "dve_air";
+        this.data.level = 0;
+        this.data.levelState = 0;
+        this.data.shapeState = 0;
+        this.data.mod = 0;
+        this.x = 0;
+        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();
+        }
+        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;
+    }
+    paint() {
+        this._worldPainter.dimenion = this.dimension;
+        this._worldPainter.data = this.data;
+        this._worldPainter.paintVoxel(this.x, this.y, this.z);
+        return this;
+    }
+    erase() {
+        this._worldPainter.dimenion = this.dimension;
+        this._worldPainter.eraseVoxel(this.x, this.y, this.z);
+        return this;
+    }
+    start() {
+        WorldRegister.instance.cache.enable();
+        return this;
+    }
+    stop() {
+        WorldRegister.instance.cache.disable();
+        return this;
+    }
+}

package/Tools/Classes/DataToolBase.d.ts

@@ -0,0 +1,43 @@
+import type { RemoteBinaryStruct } from "@amodx/binary/";
+import type { LocationData } from "../../Math";
+import { DimensionsRegister } from "../../Data/World/DimensionsRegister.js";
+import { LocationBoundTool } from "./LocationBoundTool.js";
+import { Vector3Like, Vec3Array } from "@amodx/math";
+export declare abstract class DataToolBase extends LocationBoundTool {
+    struct: RemoteBinaryStruct;
+    _c: ArrayBuffer | SharedArrayBuffer | DataView;
+    _dimensionRegister: DimensionsRegister;
+    constructor();
+    getStructValue(id: string): number;
+    setTagValue(id: string, value: number): boolean;
+    getArrayTagValue(id: string, index: number): number;
+    setArrayTagValue(id: string, index: number, value: number): number | void;
+    setBuffer(buffer: ArrayBuffer | DataView | SharedArrayBuffer): void;
+    getBuffer(): ArrayBuffer;
+    getAsArrayBuffer(): ArrayBuffer;
+    getBufferSize(): number;
+    abstract loadIn(): boolean;
+    loadInAt(x: number, y: number, z: number): boolean;
+    loadInVec3Array(vec3: Vec3Array): boolean;
+    loadInVec3(vec3: Vector3Like): boolean;
+    loadInAtLocation(location: LocationData): boolean;
+}
+export declare abstract class EncodedPositionDataTool extends DataToolBase {
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    constructor();
+    getPositionData(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    setPositionData(x: number, y: number, z: number): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    getLocationData(): LocationData;
+}

package/Tools/Classes/DataToolBase.js

@@ -0,0 +1,85 @@
+;
+import { DimensionsRegister } from "../../Data/World/DimensionsRegister.js";
+import { LocationBoundTool } from "./LocationBoundTool.js";
+import { WorldDataStructProperties } from "../../Data/Constants/Structs/WorldDataStructProperties.js";
+import { arrayBufferToSharedArrayBuffer } from "@amodx/core/Buffers/arrayBufferToSharedArrayBuffer.js";
+export class DataToolBase extends LocationBoundTool {
+    struct;
+    _c;
+    _dimensionRegister = new DimensionsRegister();
+    constructor() {
+        super();
+    }
+    getStructValue(id) {
+        this.struct.setBuffer(this._c);
+        return this.struct.getProperty(id);
+    }
+    setTagValue(id, value) {
+        this.struct.setBuffer(this._c);
+        return this.struct.setProperty(id, value);
+    }
+    getArrayTagValue(id, index) {
+        this.struct.setBuffer(this._c);
+        return this.struct.getArrayPropertyValue(id, index);
+    }
+    setArrayTagValue(id, index, value) {
+        this.struct.setBuffer(this._c);
+        return this.struct.setArrayPropertyValue(id, index, value);
+    }
+    setBuffer(buffer) {
+        this._c = buffer;
+        this.struct.setBuffer(this._c);
+    }
+    getBuffer() {
+        if (this._c instanceof DataView)
+            return this._c.buffer;
+        return this._c;
+    }
+    getAsArrayBuffer() {
+        const buffer = this.getBuffer();
+        if (buffer instanceof ArrayBuffer)
+            return buffer;
+        return arrayBufferToSharedArrayBuffer(this.getBuffer());
+    }
+    getBufferSize() {
+        return this.struct.getBuffer().byteLength;
+    }
+    loadInAt(x, y, z) {
+        this.setXYZ(x, y, z);
+        return this.loadIn();
+    }
+    loadInVec3Array(vec3) {
+        this.setXYZ(vec3[0], vec3[1], vec3[2]);
+        return this.loadIn();
+    }
+    loadInVec3(vec3) {
+        this.setXYZ(vec3.x, vec3.y, vec3.z);
+        return this.loadIn();
+    }
+    loadInAtLocation(location) {
+        this.setLocation(location);
+        return this.loadIn();
+    }
+}
+export class EncodedPositionDataTool extends DataToolBase {
+    position = { x: 0, y: 0, z: 0 };
+    constructor() {
+        super();
+    }
+    getPositionData() {
+        this.position.x = this.getStructValue(WorldDataStructProperties.positionX);
+        this.position.y = this.getStructValue(WorldDataStructProperties.positionY);
+        this.position.z = this.getStructValue(WorldDataStructProperties.positionZ);
+        return this.position;
+    }
+    setPositionData(x, y, z) {
+        this.setTagValue(WorldDataStructProperties.positionX, x);
+        this.setTagValue(WorldDataStructProperties.positionY, y);
+        this.setTagValue(WorldDataStructProperties.positionZ, z);
+        return this.position;
+    }
+    getLocationData() {
+        const pos = this.getPositionData();
+        return [this.dimension, pos.x, pos.y, pos.z];
+    }
+}