@divinevoxel/vlox 0.0.4 → 0.0.5

package/Templates/Functions/CreateTemplate.js

@@ -2,10 +2,11 @@ import { Flat3DIndex, Traverse } from "@amodx/math";
 import { StringPalette } from "../../Util/StringPalette";
 import { VoxelTemplate } from "../VoxelTemplate";
 import { NumberPalette } from "../../Util/NumberPalette";
-import { DataTool } from "../../Tools/Data/DataTool";
-import { convertToPaletteBuffer } from "../../Archive/Functions/Palettes";
+import { convertToPaletteBuffer } from "../../Data/Functions/Palettes";
+import { WorldCursor } from "../../World";
 export default function CreateTemplate(dimension, start, end) {
-    const dataTool = new DataTool();
+    const dataTool = new WorldCursor();
+    dataTool.setFocalPoint(dimension, start[0], start[1], start[2]);
     const index = Flat3DIndex.GetXZYOrder();
     const [sx, sy, sz] = [
         end[0] - start[0],
@@ -14,56 +15,69 @@ export default function CreateTemplate(dimension, start, end) {
     ];
     index.setBounds(sx, sy, sz);
     const idPalette = new StringPalette();
-    const secondaryIdPalette = new StringPalette();
+    const levelPalette = new NumberPalette();
     const statePalette = new NumberPalette();
     const modPalette = new NumberPalette();
+    const secondaryIdPalette = new StringPalette();
     const secondaryStatePalette = new NumberPalette();
-    const ids = new Array(index.size);
-    const state = new Array(index.size);
-    const mod = new Array(index.size);
-    const secondary = new Array(index.size);
-    dataTool.setDimension(dimension);
+    const ids = new Uint16Array(index.size);
+    const levels = new Uint8Array(index.size);
+    const states = new Uint16Array(index.size);
+    const mods = new Uint16Array(index.size);
+    const secondarys = new Uint16Array(index.size);
     let idsAllTheSame = true;
+    let levelAllTheSame = true;
     let stateAllTheSame = true;
     let modAllTheSame = true;
     let secondaryAllTheSame = true;
     let firstId = -1;
+    let firstLevel = -1;
     let firstState = -1;
     let firstMod = -1;
     let firstSecondary = -1;
     for (const { x, y, z } of Traverse.FromToVec3(start, [end[0] - 1, end[1] - 1, end[2] - 1], 1)) {
-        if (!dataTool.loadInAt(x, y, z))
+        const voxel = dataTool.getVoxel(x, y, x);
+        if (!voxel)
             continue;
         const vindex = index.getIndexXYZ(x - start[0], y - start[1], z - start[2]);
-        const raw = dataTool.getRaw();
-        const stringId = dataTool.getStringId();
-        const stateId = !statePalette.isRegistered(raw[2])
-            ? statePalette.register(raw[2])
-            : statePalette.getId(raw[2]);
-        const modId = !modPalette.isRegistered(raw[4])
-            ? modPalette.register(raw[4])
-            : modPalette.getId(raw[4]);
+        const rawData = voxel.getRaw();
+        const level = rawData[2];
+        const state = rawData[3];
+        const mod = rawData[4];
+        const seoncdary = rawData[5];
+        const stringId = voxel.getStringId();
         const voxelId = !idPalette.isRegistered(stringId)
             ? idPalette.register(stringId)
             : idPalette.getNumberId(stringId);
+        const levelId = !levelPalette.isRegistered(level)
+            ? levelPalette.register(level)
+            : levelPalette.getId(level);
+        const stateId = !statePalette.isRegistered(state)
+            ? statePalette.register(state)
+            : statePalette.getId(state);
+        const modId = !modPalette.isRegistered(mod)
+            ? modPalette.register(mod)
+            : modPalette.getId(mod);
         let secondaryData = 0;
-        if (dataTool.canHaveSecondaryVoxel()) {
-            dataTool.setSecondary(true);
-            let secondaryId = dataTool.hasSecondaryVoxel()
-                ? dataTool.getStringId()
+        if (voxel.canHaveSecondaryVoxel()) {
+            voxel.setSecondary(true);
+            let secondaryId = voxel.hasSecondaryVoxel()
+                ? voxel.getStringId()
                 : "dve_air";
-            dataTool.setSecondary(false);
+            voxel.setSecondary(false);
             secondaryData = !secondaryIdPalette.isRegistered(secondaryId)
                 ? secondaryIdPalette.register(secondaryId)
                 : secondaryIdPalette.getNumberId(secondaryId);
         }
         else {
-            secondaryData = !secondaryStatePalette.isRegistered(raw[3])
-                ? secondaryStatePalette.register(raw[3])
-                : secondaryStatePalette.getId(raw[3]);
+            secondaryData = !secondaryStatePalette.isRegistered(seoncdary)
+                ? secondaryStatePalette.register(seoncdary)
+                : secondaryStatePalette.getId(seoncdary);
         }
         if (firstId == -1)
             firstId = voxelId;
+        if (firstLevel == -1)
+            firstLevel = stateId;
         if (firstState == -1)
             firstState = stateId;
         if (firstMod == -1)
@@ -71,11 +85,14 @@ export default function CreateTemplate(dimension, start, end) {
         if (firstSecondary == -1)
             firstSecondary = secondaryData;
         ids[vindex] = voxelId;
-        mod[vindex] = modId;
-        state[vindex] = stateId;
-        secondary[vindex] = secondaryData;
+        levels[vindex] = voxelId;
+        mods[vindex] = modId;
+        states[vindex] = stateId;
+        secondarys[vindex] = secondaryData;
         if (firstId != voxelId)
             idsAllTheSame = false;
+        if (firstLevel != levelId)
+            levelAllTheSame = false;
         if (firstState != stateId)
             stateAllTheSame = false;
         if (firstMod != modId)
@@ -83,31 +100,35 @@ export default function CreateTemplate(dimension, start, end) {
         if (firstSecondary != secondaryData)
             secondaryAllTheSame = false;
     }
-    console.log("CREATE VOXEL TEMPLATE", { modPalette, mod });
+    console.log("CREATE VOXEL TEMPLATE", { modPalette, mod: mods });
     return new VoxelTemplate({
         templatorVersion: 0,
         version: 0,
         size: [sx, sy, sz],
         palettes: {
             id: idPalette._palette,
-            secondaryId: secondaryIdPalette._palette,
+            level: Uint8Array.from(levelPalette._palette),
             state: Uint16Array.from(statePalette._palette),
             mod: Uint16Array.from(modPalette._palette),
+            secondaryId: secondaryIdPalette._palette,
             secondaryState: Uint16Array.from(secondaryStatePalette._palette),
         },
         buffers: {
             ids: !idsAllTheSame
                 ? convertToPaletteBuffer(idPalette.size, Uint16Array.from(ids), true)
                 : ids[0],
+            level: !levelAllTheSame
+                ? convertToPaletteBuffer(modPalette.size, levels, true)
+                : levels[0],
             mod: !modAllTheSame
-                ? convertToPaletteBuffer(modPalette.size, Uint16Array.from(mod), true)
-                : mod[0],
+                ? convertToPaletteBuffer(modPalette.size, Uint16Array.from(mods), true)
+                : mods[0],
             state: !stateAllTheSame
-                ? convertToPaletteBuffer(statePalette.size, Uint16Array.from(state), true)
-                : state[0],
+                ? convertToPaletteBuffer(statePalette.size, Uint16Array.from(states), true)
+                : states[0],
             secondary: !secondaryAllTheSame
-                ? convertToPaletteBuffer(Math.max(secondaryIdPalette.size, secondaryStatePalette.size), Uint16Array.from(secondary), true)
-                : secondary[0],
+                ? convertToPaletteBuffer(Math.max(secondaryIdPalette.size, secondaryStatePalette.size), Uint16Array.from(secondarys), true)
+                : secondarys[0],
         },
     });
 }

package/Templates/Functions/FlipTemplate.js

@@ -32,6 +32,10 @@ export default function FlipTemplate(template, direction) {
         const ids = template.ids;
         flipArray([sizeX, sizeY, sizeZ], ids, direction, index);
     }
+    if (typeof template.level === "object") {
+        const level = template.level;
+        flipArray([sizeX, sizeY, sizeZ], level, direction, index);
+    }
     if (typeof template.state === "object") {
         const state = template.state;
         flipArray([sizeX, sizeY, sizeZ], state, direction, index);

package/Templates/Functions/RotateTemplate.js

@@ -93,6 +93,10 @@ export default function RotateTemplate(template, angle, axes = "y") {
         const ids = template.ids;
         rotateArray([sizeX, sizeY, sizeZ], ids, angle, axes, index, newIndex);
     }
+    if (typeof template.level === "object") {
+        const level = template.level;
+        rotateArray([sizeX, sizeY, sizeZ], level, angle, axes, index, newIndex);
+    }
     if (typeof template.state === "object") {
         const state = template.state;
         rotateArray([sizeX, sizeY, sizeZ], state, angle, axes, index, newIndex);

package/Templates/VoxelTemplate.d.ts

@@ -1,6 +1,6 @@
 import { Flat3DIndex, Vec3Array } from "@amodx/math";
 import { VoxelTemplateData } from "./VoxelTemplates.types";
-import type { RawVoxelData } from "../Voxels/Voxel.types";
+import type { RawVoxelData } from "../Voxels/Types/Voxel.types";
 import { StringPalette } from "../Util/StringPalette";
 import { NumberPalette } from "../Util/NumberPalette";
 type TemplateCursor = {
@@ -11,18 +11,21 @@ export declare class VoxelTemplate {
     index: Flat3DIndex;
     size: Vec3Array;
     ids: Uint8Array | Uint16Array | number;
+    level: Uint8Array | number;
     state: Uint8Array | Uint16Array | number;
     mod: Uint8Array | Uint16Array | number;
     secondary: Uint8Array | Uint16Array | number;
     idPalette: StringPalette;
-    secondaryIdPalette: StringPalette;
+    levelPalette: NumberPalette;
     statePalette: NumberPalette;
     modPalette: NumberPalette;
+    secondaryIdPalette: StringPalette;
     secondaryStatePalette: NumberPalette;
     constructor(data: VoxelTemplateData);
     getIndex(x: number, y: number, z: number): number;
     getId(index: number): number;
     getState(index: number): number;
+    getLevel(index: number): number;
     getMod(index: number): number;
     getSecondary(id: number, index: number): number;
     traverse(): Generator<TemplateCursor>;

package/Templates/VoxelTemplate.js

@@ -1,33 +1,39 @@
 import { Flat3DIndex, Traverse } from "@amodx/math";
 import { StringPalette } from "../Util/StringPalette";
 import { NumberPalette } from "../Util/NumberPalette";
-import { VoxelPalette } from "../Data/Palettes/VoxelPalette";
-import { VoxelStruct } from "../Data/Structs/VoxelStruct";
-import { VoxelStructIds } from "../Voxels/Voxel.types";
-import { getPaletteArray } from "../Archive/Functions/Palettes";
+import { VoxelPalette } from "../Voxels/Palettes/VoxelPalette";
+import { VoxelStruct } from "../Voxels/Structs/VoxelStruct";
+import { VoxelStructIds } from "../Voxels/Types/Voxel.types";
+import { getPaletteArray } from "../Data/Functions/Palettes";
 export class VoxelTemplate {
     index = Flat3DIndex.GetXZYOrder();
     size;
     ids;
+    level;
     state;
     mod;
     secondary;
-    idPalette = new StringPalette();
-    secondaryIdPalette = new StringPalette();
-    statePalette = new NumberPalette();
-    modPalette = new NumberPalette();
-    secondaryStatePalette = new NumberPalette();
+    idPalette;
+    levelPalette;
+    statePalette;
+    modPalette;
+    secondaryIdPalette;
+    secondaryStatePalette;
     constructor(data) {
         this.size = [...data.size];
         this.index.setBounds(...data.size);
-        data.palettes.id.forEach((_) => this.idPalette.register(_));
-        data.palettes.state.forEach((_) => this.statePalette.register(_));
-        data.palettes.mod.forEach((_) => this.modPalette.register(_));
-        data.palettes.secondaryId.forEach((_) => this.secondaryIdPalette.register(_));
-        data.palettes.secondaryState.forEach((_) => this.secondaryStatePalette.register(_));
+        this.idPalette = new StringPalette(data.palettes.id);
+        this.levelPalette = new NumberPalette(data.palettes.level);
+        this.statePalette = new NumberPalette(data.palettes.state);
+        this.modPalette = new NumberPalette(data.palettes.mod);
+        this.secondaryIdPalette = new StringPalette(data.palettes.secondaryId);
+        this.secondaryStatePalette = new NumberPalette(data.palettes.secondaryState);
         typeof data.buffers.ids == "object"
             ? (this.ids = getPaletteArray(data.palettes.id.length, data.buffers.ids))
             : (this.ids = data.buffers.ids);
+        typeof data.buffers.level == "object"
+            ? (this.level = getPaletteArray(data.palettes.level.length, data.buffers.level))
+            : (this.level = data.buffers.level);
         typeof data.buffers.state == "object"
             ? (this.state = getPaletteArray(data.palettes.state.length, data.buffers.state))
             : (this.state = data.buffers.state);
@@ -49,6 +55,10 @@ export class VoxelTemplate {
         const state = this.state;
         return this.statePalette.getValue(typeof state == "number" ? state : state[index]);
     }
+    getLevel(index) {
+        const mod = this.mod;
+        return this.modPalette.getValue(typeof mod == "number" ? mod : mod[index]);
+    }
     getMod(index) {
         const mod = this.mod;
         return this.modPalette.getValue(typeof mod == "number" ? mod : mod[index]);
@@ -63,7 +73,7 @@ export class VoxelTemplate {
     }
     *traverse() {
         const end = this.size;
-        const raw = [0, 0, 0, 0, 0];
+        const raw = [0, 0, 0, 0, 0, 0];
         const curosr = {
             position: [0, 0, 0],
             raw,
@@ -75,9 +85,10 @@ export class VoxelTemplate {
             curosr.position[2] = z;
             raw[0] = this.getId(vindex);
             raw[1] = 0;
-            raw[2] = this.getState(vindex);
-            raw[3] = this.getSecondary(raw[0], vindex);
+            raw[2] = this.getLevel(vindex);
+            raw[3] = this.getState(vindex);
             raw[4] = this.getMod(vindex);
+            raw[5] = this.getSecondary(raw[0], vindex);
             if (raw[0] < 1 && raw[3] < 1)
                 continue;
             yield curosr;
@@ -90,9 +101,10 @@ export class VoxelTemplate {
             size: this.size,
             palettes: {
                 id: this.idPalette._palette,
-                secondaryId: this.secondaryIdPalette._palette,
+                level: Uint8Array.from(this.statePalette._palette),
                 state: Uint16Array.from(this.statePalette._palette),
                 mod: Uint16Array.from(this.modPalette._palette),
+                secondaryId: this.secondaryIdPalette._palette,
                 secondaryState: Uint16Array.from(this.secondaryStatePalette._palette),
             },
             buffers: {
@@ -101,6 +113,9 @@ export class VoxelTemplate {
                     typeof this.ids == "number"
                     ? this.ids
                     : new Uint8Array(this.ids.buffer),
+                level: this.level instanceof Uint8Array || typeof this.level == "number"
+                    ? this.level
+                    : new Uint8Array(this.level.buffer),
                 mod: this.mod instanceof Uint16Array ||
                     this.mod instanceof Uint8Array ||
                     typeof this.mod == "number"

package/Templates/VoxelTemplates.types.d.ts

@@ -1,23 +1,21 @@
 import { Vec3Array } from "@amodx/math";
+import { VoxelDataArrays } from "../World";
 export interface VoxelTemplateBuffers {
     ids: Uint16Array | Uint8Array | number;
     state: Uint16Array | Uint8Array | number;
+    level: Uint8Array | number;
     mod: Uint16Array | Uint8Array | number;
     secondary: Uint16Array | Uint8Array | number;
 }
-export interface FullVoxelTemplateData {
+export interface FullVoxelTemplateData extends VoxelDataArrays {
     size: Vec3Array;
-    ids: Uint16Array;
-    state: Uint16Array;
-    light: Uint16Array;
-    mod: Uint16Array;
-    secondary: Uint16Array;
 }
 export interface VoxelTemplatePaletteData {
     id: string[];
-    secondaryId: string[];
+    level: Uint8Array;
     state: Uint16Array;
     mod: Uint16Array;
+    secondaryId: string[];
     secondaryState: Uint16Array;
 }
 export interface VoxelTemplateData {

package/Textures/Texture.types.d.ts

@@ -1,3 +1,4 @@
+export type TextureId = [type: string, id: string, varation?: string];
 export type TextureTypes = string;
 export type TextureTypeUVMap = Record<string, Record<string, number>>;
 export type TextureAnimationData = {

package/Textures/TextureManager.d.ts

@@ -1,16 +1,15 @@
-import type { TextureData, TextureTypeUVMap } from "./Texture.types";
+import type { TextureData, TextureTypeUVMap, TextureId } from "./Texture.types";
 import { TextureArray } from "./TextureArray.js";
-import { ConstructorTextureData } from "./Constructor.types";
 export declare class TextureManager {
     static defaultTexturePath: string;
     static textureTypes: Map<string, TextureArray>;
-    static getTextureIndex(data: ConstructorTextureData): number;
+    static getTextureIndex(data: TextureId): number;
     static _ready: boolean;
     static isReady(): boolean;
-    static $INIT(): Promise<void>;
+    static init(): Promise<void>;
     static generateTextureUVMap(): TextureTypeUVMap;
     static defineDefaultTexturePath(path: string): void;
-    static getTextureData([type, id, segment]: ConstructorTextureData): TextureData | undefined;
+    static getTextureData([type, id, segment]: TextureId): TextureData | undefined;
     static getTextureType(id: string): false | TextureArray;
     static getOrAddTextureType(id: string): TextureArray;
     static addTextureType(id: string): TextureArray;

package/Textures/TextureManager.js

@@ -1,6 +1,7 @@
 import { EngineSettings } from "../Settings/EngineSettings.js";
 import { TextureBuilder } from "./TextureBuilder.js";
 import { TextureArray } from "./TextureArray.js";
+import { TextureRegister } from "./TextureRegister.js";
 export class TextureManager {
     static defaultTexturePath = "assets/textures";
     static textureTypes = new Map();
@@ -15,11 +16,12 @@ export class TextureManager {
     static isReady() {
         return this._ready;
     }
-    static async $INIT() {
+    static async init() {
         TextureBuilder.defineTextureDimensions(EngineSettings.settings.textures.textureSize, EngineSettings.settings.textures.mipMapSizes);
         for (const [key, type] of this.textureTypes) {
             await type.build();
         }
+        TextureRegister.setTextureIndex(this.generateTextureUVMap());
         this._ready = true;
     }
     static generateTextureUVMap() {

package/Textures/TextureRegister.d.ts

@@ -1,10 +1,9 @@
-import type { ConstructorTextureData } from "./Constructor.types";
-import type { TextureTypeUVMap } from "./Texture.types";
-export declare const TextureRegister: {
-    textureDataHasBeenSet: boolean;
-    data: TextureTypeUVMap;
-    getTextureUV(data: ConstructorTextureData): number;
-    setTextureIndex(data: TextureTypeUVMap): void;
-    releaseTextureData(): void;
-    isReady(): boolean;
-};
+import type { TextureTypeUVMap, TextureId } from "./Texture.types";
+export declare class TextureRegister {
+    static textureDataHasBeenSet: boolean;
+    static data: TextureTypeUVMap;
+    static getTextureUV(data: TextureId): number;
+    static setTextureIndex(data: TextureTypeUVMap): void;
+    static releaseTextureData(): void;
+    static isReady(): boolean;
+}

package/Textures/TextureRegister.js

@@ -1,7 +1,7 @@
-export const TextureRegister = {
-    textureDataHasBeenSet: false,
-    data: {},
-    getTextureUV(data) {
+export class TextureRegister {
+    static textureDataHasBeenSet = false;
+    static data;
+    static getTextureUV(data) {
         const [textureType, textureId, varation] = data;
         let id = textureId;
         if (varation) {
@@ -13,16 +13,16 @@ export const TextureRegister = {
             throw new Error(`Texture with id: ${id} does not exists.`);
         }
         return uv;
-    },
-    setTextureIndex(data) {
+    }
+    static setTextureIndex(data) {
         this.textureDataHasBeenSet = true;
         this.data = data;
-    },
-    releaseTextureData() {
+    }
+    static releaseTextureData() {
         this.data = null;
         delete this["data"];
-    },
-    isReady() {
+    }
+    static isReady() {
         return this.textureDataHasBeenSet;
-    },
-};
+    }
+}

package/Textures/index.d.ts

@@ -0,0 +1 @@
+export * from "./Texture.types";

package/Textures/index.js

@@ -0,0 +1 @@
+export * from "./Texture.types";

package/Tools/Brush/AdvancedBrushTool.d.ts

@@ -2,8 +2,9 @@ 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;
+    _location: LocationData;
+    constructor(tasks: TaskTool);
     mode: TaskRunModes;
     _mapLocation(): void;
     setMode(mode: TaskRunModes): this;

package/Tools/Brush/AdvancedBrushTool.js

@@ -1,10 +1,11 @@
-//util
-//tools
 import { BrushTool } from "./Brush.js";
-import { TaskTool } from "../Tasks/TasksTool.js";
 export class AdvancedBrush extends BrushTool {
+    tasks;
     _location = ["main", 0, 0, 0];
-    tasks = new TaskTool();
+    constructor(tasks) {
+        super();
+        this.tasks = tasks;
+    }
     mode = "async";
     _mapLocation() {
         this._location[0] = this.dimension;
@@ -33,27 +34,24 @@ export class AdvancedBrush extends BrushTool {
     }
     paintAndUpdate(onDone) {
         this._mapLocation();
-        this.tasks.setFocalPoint(this._location);
-        this.tasks.voxelUpdate.paint.run(this._location, this.getRaw(), () => {
+        this.tasks.voxel.paint.run([this._location, this.getRaw()], null, () => {
             if (onDone)
                 onDone();
-        }, this.mode);
+        });
     }
     eraseAndUpdate(onDone) {
         this._mapLocation();
-        this.tasks.setFocalPoint(this._location);
-        this.tasks.voxelUpdate.erase.run(this._location, () => {
+        this.tasks.voxel.erease.run(this._location, null, () => {
             if (onDone)
                 onDone();
-        }, this.mode);
+        });
     }
     update(onDone) {
         this._mapLocation();
-        this.tasks.setFocalPoint(this._location);
-        this.tasks.voxelUpdate.update.run(this._location, this.getRaw(), () => {
+        this.tasks.voxel.update.run([this._location, this.getRaw()], null, () => {
             if (onDone)
                 onDone();
-        }, this.mode);
+        });
     }
     updateAndAwait() {
         return new Promise((resolve) => {
@@ -64,8 +62,7 @@ export class AdvancedBrush extends BrushTool {
     }
     explode(radius = 6, onDone) {
         this._mapLocation();
-        this.tasks.setFocalPoint(this._location);
-        this.tasks.explosion.run(this._location, radius, () => {
+        this.tasks.explosion.run([this._location, radius], null, () => {
             if (onDone)
                 onDone();
         });

package/Tools/Brush/Brush.d.ts

@@ -1,8 +1,7 @@
-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 type { PaintVoxelData, RawVoxelData } from "../../Voxels/Types/Voxel.types.js";
+import { WorldCursor } from "../../World/Cursor/WorldCursor.js";
 import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor.js";
 export declare class BrushTool {
     data: PaintVoxelData;
     dimension: string;
@@ -14,6 +13,7 @@ export declare class BrushTool {
     dataCursor: WorldCursor;
     substanceData: SubstanceDataTool;
     setXYZ(x: number, y: number, z: number): this;
+    newSector(): void;
     setData(data: Partial<PaintVoxelData>): this;
     getData(): PaintVoxelData;
     setRaw(data: RawVoxelData): this;