@divinevoxel/vlox 0.0.0

package/Templates/Functions/CreateTemplate.js

@@ -0,0 +1,113 @@
+import { Flat3DIndex, Traverse } from "@amodx/math";
+import { StringPalette } from "../../Interfaces/Data/StringPalette";
+import { VoxelTemplate } from "../VoxelTemplate";
+import { NumberPalette } from "../../Interfaces/Data/NumberPalette";
+import { DataTool } from "../../Tools/Data/DataTool";
+import { convertToPaletteBuffer } from "../../Archive/Functions/Palettes";
+export default function CreateTemplate(dimension, start, end) {
+    const dataTool = new DataTool();
+    const index = Flat3DIndex.GetXZYOrder();
+    const [sx, sy, sz] = [
+        end[0] - start[0],
+        end[1] - start[1],
+        end[2] - start[2],
+    ];
+    index.setBounds(sx, sy, sz);
+    const idPalette = new StringPalette();
+    const secondaryIdPalette = new StringPalette();
+    const statePalette = new NumberPalette();
+    const modPalette = new NumberPalette();
+    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);
+    let idsAllTheSame = true;
+    let stateAllTheSame = true;
+    let modAllTheSame = true;
+    let secondaryAllTheSame = true;
+    let firstId = -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))
+            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 voxelId = !idPalette.isRegistered(stringId)
+            ? idPalette.register(stringId)
+            : idPalette.getNumberId(stringId);
+        let secondaryData = 0;
+        if (dataTool.canHaveSecondaryVoxel()) {
+            dataTool.setSecondary(true);
+            let secondaryId = dataTool.hasSecondaryVoxel()
+                ? dataTool.getStringId()
+                : "dve_air";
+            dataTool.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]);
+        }
+        if (firstId == -1)
+            firstId = voxelId;
+        if (firstState == -1)
+            firstState = stateId;
+        if (firstMod == -1)
+            firstMod = modId;
+        if (firstSecondary == -1)
+            firstSecondary = secondaryData;
+        ids[vindex] = voxelId;
+        mod[vindex] = modId;
+        state[vindex] = stateId;
+        secondary[vindex] = secondaryData;
+        if (firstId != voxelId)
+            idsAllTheSame = false;
+        if (firstState != stateId)
+            stateAllTheSame = false;
+        if (firstMod != modId)
+            modAllTheSame = false;
+        if (firstSecondary != secondaryData)
+            secondaryAllTheSame = false;
+    }
+    console.log("CREATE VOXEL TEMPLATE", { modPalette, mod });
+    return new VoxelTemplate({
+        templatorVersion: 0,
+        version: 0,
+        size: [sx, sy, sz],
+        palettes: {
+            id: idPalette._palette,
+            secondaryId: secondaryIdPalette._palette,
+            state: Uint16Array.from(statePalette._palette),
+            mod: Uint16Array.from(modPalette._palette),
+            secondaryState: Uint16Array.from(secondaryStatePalette._palette),
+        },
+        buffers: {
+            ids: !idsAllTheSame
+                ? convertToPaletteBuffer(idPalette.size, Uint16Array.from(ids), true)
+                : ids[0],
+            mod: !modAllTheSame
+                ? convertToPaletteBuffer(modPalette.size, Uint16Array.from(mod), true)
+                : mod[0],
+            state: !stateAllTheSame
+                ? convertToPaletteBuffer(statePalette.size, Uint16Array.from(state), true)
+                : state[0],
+            secondary: !secondaryAllTheSame
+                ? convertToPaletteBuffer(Math.max(secondaryIdPalette.size, secondaryStatePalette.size), Uint16Array.from(secondary), true)
+                : secondary[0],
+        },
+    });
+}

package/Templates/Functions/FlipTemplate.d.ts

@@ -0,0 +1,3 @@
+import { VoxelTemplate } from "../VoxelTemplate";
+export type TemplateFlipDirections = "x" | "z" | "y";
+export default function FlipTemplate(template: VoxelTemplate, direction: TemplateFlipDirections): void;

package/Templates/Functions/FlipTemplate.js

@@ -0,0 +1,47 @@
+import { Flat3DIndex } from "@amodx/math";
+const flipArray = ([sizeX, sizeY, sizeZ], array, direction, index) => {
+    const newArray = new Array(array.length);
+    for (let x = 0; x < sizeX; x++) {
+        for (let y = 0; y < sizeY; y++) {
+            for (let z = 0; z < sizeZ; z++) {
+                const oldIndex = index.getIndexXYZ(x, y, z);
+                let newCoords = [x, y, z];
+                if (direction === "x") {
+                    newCoords[0] = sizeX - 1 - x;
+                }
+                else if (direction === "y") {
+                    newCoords[1] = sizeY - 1 - y;
+                }
+                else if (direction === "z") {
+                    newCoords[2] = sizeZ - 1 - z;
+                }
+                const newIndexFlat = index.getIndexXYZ(...newCoords);
+                newArray[newIndexFlat] = array[oldIndex];
+            }
+        }
+    }
+    for (let i = 0; i < array.length; i++) {
+        array[i] = newArray[i];
+    }
+};
+export default function FlipTemplate(template, direction) {
+    const [sizeX, sizeY, sizeZ] = template.size;
+    const index = Flat3DIndex.GetXZYOrder();
+    index.setBounds(sizeX, sizeY, sizeZ);
+    if (typeof template.ids === "object") {
+        const ids = template.ids;
+        flipArray([sizeX, sizeY, sizeZ], ids, direction, index);
+    }
+    if (typeof template.state === "object") {
+        const state = template.state;
+        flipArray([sizeX, sizeY, sizeZ], state, direction, index);
+    }
+    if (typeof template.mod === "object") {
+        const mod = template.mod;
+        flipArray([sizeX, sizeY, sizeZ], mod, direction, index);
+    }
+    if (typeof template.secondary === "object") {
+        const secondary = template.secondary;
+        flipArray([sizeX, sizeY, sizeZ], secondary, direction, index);
+    }
+}

package/Templates/Functions/RotateTemplate.d.ts

@@ -0,0 +1,4 @@
+import { VoxelTemplate } from "../VoxelTemplate";
+export type TemplateRotationAxes = "x" | "y" | "z";
+export type TemplateRotationAngles = 90 | 180 | 270 | -90 | -180 | -270;
+export default function RotateTemplate(template: VoxelTemplate, angle: TemplateRotationAngles, axes?: TemplateRotationAxes): void;

package/Templates/Functions/RotateTemplate.js

@@ -0,0 +1,110 @@
+import { Flat3DIndex } from "@amodx/math";
+const rotateX = (angle, x, y, z, sizeX, sizeY, sizeZ) => {
+    switch (angle) {
+        case 90:
+        case -270:
+            return [x, z, sizeY - 1 - y];
+        case 180:
+        case -180:
+            return [x, sizeY - 1 - y, sizeZ - 1 - z];
+        case 270:
+        case -90:
+            return [x, sizeZ - 1 - z, y];
+    }
+};
+const rotateY = (angle, x, y, z, sizeX, sizeY, sizeZ) => {
+    switch (angle) {
+        case 90:
+        case -270:
+            return [sizeZ - 1 - z, y, x];
+        case 180:
+        case -180:
+            return [sizeX - 1 - x, y, sizeZ - 1 - z];
+        case 270:
+        case -90:
+            return [z, y, sizeX - 1 - x];
+    }
+};
+const rotateZ = (angle, x, y, z, sizeX, sizeY, sizeZ) => {
+    switch (angle) {
+        case 90:
+        case -270:
+            return [sizeY - 1 - y, x, z];
+        case 180:
+        case -180:
+            return [sizeX - 1 - x, sizeY - 1 - y, z];
+        case 270:
+        case -90:
+            return [y, sizeX - 1 - x, z];
+    }
+};
+const rotateArray = ([sizeX, sizeY, sizeZ], array, angle, axes, index, newIndex) => {
+    const newArray = new Array(array.length);
+    for (let x = 0; x < sizeX; x++) {
+        for (let y = 0; y < sizeY; y++) {
+            for (let z = 0; z < sizeZ; z++) {
+                const oldIndex = index.getIndexXYZ(x, y, z);
+                let newCoords;
+                switch (axes) {
+                    case "x":
+                        newCoords = rotateX(angle, x, y, z, sizeX, sizeY, sizeZ);
+                        break;
+                    case "y":
+                        newCoords = rotateY(angle, x, y, z, sizeX, sizeY, sizeZ);
+                        break;
+                    case "z":
+                        newCoords = rotateZ(angle, x, y, z, sizeX, sizeY, sizeZ);
+                        break;
+                }
+                const newIndexFlat = newIndex.getIndexXYZ(...newCoords);
+                newArray[newIndexFlat] = array[oldIndex];
+            }
+        }
+    }
+    for (let i = 0; i < array.length; i++) {
+        array[newIndex.getIndex(newIndex.getXYZ(i))] = newArray[i];
+    }
+};
+export default function RotateTemplate(template, angle, axes = "y") {
+    const [sizeX, sizeY, sizeZ] = template.size;
+    const index = Flat3DIndex.GetXZYOrder();
+    index.setBounds(sizeX, sizeY, sizeZ);
+    let newSizeX = sizeX;
+    let newSizeY = sizeY;
+    let newSizeZ = sizeZ;
+    if (axes === "x") {
+        if (angle === 90 || angle === 270 || angle === -90 || angle === -270) {
+            [newSizeY, newSizeZ] = [sizeZ, sizeY];
+        }
+    }
+    else if (axes === "y") {
+        if (angle === 90 || angle === 270 || angle === -90 || angle === -270) {
+            [newSizeX, newSizeZ] = [sizeZ, sizeX];
+        }
+    }
+    else if (axes === "z") {
+        if (angle === 90 || angle === 270 || angle === -90 || angle === -270) {
+            [newSizeX, newSizeY] = [sizeY, sizeX];
+        }
+    }
+    const newIndex = Flat3DIndex.GetXZYOrder();
+    newIndex.setBounds(newSizeX, newSizeY, newSizeZ);
+    if (typeof template.ids === "object") {
+        const ids = template.ids;
+        rotateArray([sizeX, sizeY, sizeZ], ids, angle, axes, index, newIndex);
+    }
+    if (typeof template.state === "object") {
+        const state = template.state;
+        rotateArray([sizeX, sizeY, sizeZ], state, angle, axes, index, newIndex);
+    }
+    if (typeof template.mod === "object") {
+        const mod = template.mod;
+        rotateArray([sizeX, sizeY, sizeZ], mod, angle, axes, index, newIndex);
+    }
+    if (typeof template.secondary === "object") {
+        const secondary = template.secondary;
+        rotateArray([sizeX, sizeY, sizeZ], secondary, angle, axes, index, newIndex);
+    }
+    template.index = newIndex;
+    template.size = [newSizeX, newSizeY, newSizeZ];
+}

package/Templates/Functions/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./CreateTemplate";
+export * from "./RotateTemplate";
+export * from "./FlipTemplate";

package/Templates/Functions/index.js

@@ -0,0 +1,3 @@
+export * from "./CreateTemplate";
+export * from "./RotateTemplate";
+export * from "./FlipTemplate";

package/Templates/VoxelTemplate.d.ts

@@ -0,0 +1,31 @@
+import { Flat3DIndex, Vec3Array } from "@amodx/math";
+import { VoxelTemplateData } from "./VoxelTemplates.types";
+import type { RawVoxelData } from "../Data/Types/VoxelData.types";
+import { StringPalette } from "../Interfaces/Data/StringPalette";
+import { NumberPalette } from "../Interfaces/Data/NumberPalette";
+type TemplateCursor = {
+    position: Vec3Array;
+    raw: RawVoxelData;
+};
+export declare class VoxelTemplate {
+    index: Flat3DIndex;
+    size: Vec3Array;
+    ids: Uint8Array | Uint16Array | number;
+    state: Uint8Array | Uint16Array | number;
+    mod: Uint8Array | Uint16Array | number;
+    secondary: Uint8Array | Uint16Array | number;
+    idPalette: StringPalette;
+    secondaryIdPalette: StringPalette;
+    statePalette: NumberPalette;
+    modPalette: NumberPalette;
+    secondaryStatePalette: NumberPalette;
+    constructor(data: VoxelTemplateData);
+    getIndex(x: number, y: number, z: number): number;
+    getId(index: number): number;
+    getState(index: number): number;
+    getMod(index: number): number;
+    getSecondary(id: number, index: number): number;
+    traverse(): Generator<TemplateCursor>;
+    toJSON(): VoxelTemplateData;
+}
+export {};

package/Templates/VoxelTemplate.js

@@ -0,0 +1,122 @@
+import { Flat3DIndex, Traverse } from "@amodx/math";
+import { StringPalette } from "../Interfaces/Data/StringPalette";
+import { NumberPalette } from "../Interfaces/Data/NumberPalette";
+import { VoxelPalette } from "../Data/Voxel/VoxelPalette";
+import { VoxelStruct } from "../Data/Voxel/VoxelStruct";
+import { VoxelTagIDs } from "../Data/Constants/VoxelTagIds";
+import { getPaletteArray } from "../Archive/Functions/Palettes";
+export class VoxelTemplate {
+    index = Flat3DIndex.GetXZYOrder();
+    size;
+    ids;
+    state;
+    mod;
+    secondary;
+    idPalette = new StringPalette();
+    secondaryIdPalette = new StringPalette();
+    statePalette = new NumberPalette();
+    modPalette = new NumberPalette();
+    secondaryStatePalette = new NumberPalette();
+    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(_));
+        typeof data.buffers.ids == "object"
+            ? (this.ids = getPaletteArray(data.palettes.id.length, data.buffers.ids))
+            : (this.ids = data.buffers.ids);
+        typeof data.buffers.state == "object"
+            ? (this.state = getPaletteArray(data.palettes.state.length, data.buffers.state))
+            : (this.state = data.buffers.state);
+        typeof data.buffers.mod == "object"
+            ? (this.mod = getPaletteArray(data.palettes.mod.length, data.buffers.mod))
+            : (this.mod = data.buffers.mod);
+        typeof data.buffers.secondary == "object"
+            ? (this.secondary = getPaletteArray(Math.max(data.palettes.secondaryState.length, data.palettes.secondaryId.length), data.buffers.secondary))
+            : (this.secondary = data.buffers.secondary);
+    }
+    getIndex(x, y, z) {
+        return this.index.getIndexXYZ(x, y, z);
+    }
+    getId(index) {
+        const ids = this.ids;
+        return VoxelPalette.ids.getNumberId(this.idPalette.getStringId(typeof ids == "number" ? ids : ids[index]));
+    }
+    getState(index) {
+        const state = this.state;
+        return this.statePalette.getValue(typeof state == "number" ? state : state[index]);
+    }
+    getMod(index) {
+        const mod = this.mod;
+        return this.modPalette.getValue(typeof mod == "number" ? mod : mod[index]);
+    }
+    getSecondary(id, index) {
+        const secondary = this.secondary;
+        VoxelStruct.setVoxel(id);
+        if (VoxelStruct.instance[VoxelTagIDs.canHaveSecondary] == 1) {
+            return VoxelPalette.ids.getNumberId(this.secondaryIdPalette.getStringId(typeof secondary == "number" ? secondary : secondary[index]));
+        }
+        return this.secondaryStatePalette.getValue(typeof secondary == "number" ? secondary : secondary[index]);
+    }
+    *traverse() {
+        const end = this.size;
+        const raw = [0, 0, 0, 0, 0];
+        const curosr = {
+            position: [0, 0, 0],
+            raw,
+        };
+        for (const { x, y, z } of Traverse.FromToVec3([0, 0, 0], [end[0] - 1, end[1] - 1, end[2] - 1], 1)) {
+            const vindex = this.index.getIndexXYZ(x, y, z);
+            curosr.position[0] = x;
+            curosr.position[1] = y;
+            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[4] = this.getMod(vindex);
+            if (raw[0] < 1 && raw[3] < 1)
+                continue;
+            yield curosr;
+        }
+    }
+    toJSON() {
+        return {
+            templatorVersion: 0,
+            version: 0,
+            size: this.size,
+            palettes: {
+                id: this.idPalette._palette,
+                secondaryId: this.secondaryIdPalette._palette,
+                state: Uint16Array.from(this.statePalette._palette),
+                mod: Uint16Array.from(this.modPalette._palette),
+                secondaryState: Uint16Array.from(this.secondaryStatePalette._palette),
+            },
+            buffers: {
+                ids: this.ids instanceof Uint16Array ||
+                    this.ids instanceof Uint8Array ||
+                    typeof this.ids == "number"
+                    ? this.ids
+                    : new Uint8Array(this.ids.buffer),
+                mod: this.mod instanceof Uint16Array ||
+                    this.mod instanceof Uint8Array ||
+                    typeof this.mod == "number"
+                    ? this.mod
+                    : new Uint8Array(this.mod.buffer),
+                state: this.state instanceof Uint16Array ||
+                    this.state instanceof Uint8Array ||
+                    typeof this.state == "number"
+                    ? this.state
+                    : new Uint8Array(this.state.buffer),
+                secondary: this.secondary instanceof Uint16Array ||
+                    this.secondary instanceof Uint8Array ||
+                    typeof this.secondary == "number"
+                    ? this.secondary
+                    : new Uint8Array(this.secondary.buffer),
+            },
+        };
+    }
+}

package/Templates/VoxelTemplates.types.d.ts

@@ -0,0 +1,23 @@
+import { Vec3Array } from "@amodx/math";
+export interface VoxelTemplateBuffers {
+    ids: Uint16Array | Uint8Array | number;
+    state: Uint16Array | Uint8Array | number;
+    mod: Uint16Array | Uint8Array | number;
+    secondary: Uint16Array | Uint8Array | number;
+}
+export interface VoxelTemplatePaletteData {
+    id: string[];
+    secondaryId: string[];
+    state: Uint16Array;
+    mod: Uint16Array;
+    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;
+}

package/Templates/VoxelTemplates.types.js

@@ -0,0 +1 @@
+export {};

package/Templates/index.d.ts

@@ -0,0 +1 @@
+export * from "./Functions/CreateTemplate";

package/Templates/index.js

@@ -0,0 +1 @@
+export * from "./Functions/CreateTemplate";

package/Textures/Constructor.types.d.ts

@@ -0,0 +1,5 @@
+export type ConstructorTextureData = [
+    type: string,
+    id: string,
+    varation?: string
+];

package/Textures/Constructor.types.js

@@ -0,0 +1 @@
+export {};

package/Textures/Texture.types.d.ts

@@ -0,0 +1,79 @@
+export type TextureTypes = string;
+export type TextureTypeUVMap = Record<string, Record<string, Record<string, number>>>;
+export type TextureAnimationData = {
+    /**# Frames
+     * If the texture has animation frames the number of frames must be set to the number
+     * texture animatoin images. This number must be greater than 1.
+     *
+     * The number will be used to locate all the associated frames.
+     *
+     * Example: If you specify 3 frames for a texture with the ID **dreamstone** the folder would look like this:
+     * - dreamstone/default-1.png
+     * - dreamstone/default-2.png
+     * - dreamstone/default-3.png
+     */
+    frames: number;
+    /**# Anim Keys
+     * If the texture is animated you must supply the anim key frames which
+     * is just the order of the frames.
+     */
+    animKeys?: number[];
+    /**# Global Frame Time
+     * ---
+     * Specifies how many frames every anim key should be display.
+     */
+    globalFrameTime?: number;
+    /**# Anim Key Frame Time
+     * ---
+     * If set globalFrameTime will be ignored.
+     * Specifies how many frames every anim should be displayed.
+     * You must supply a number for every animKey.
+     */
+    animKeyFrameTimes?: number[];
+};
+export type TextureDataBase = {
+    /**# rawData
+     * Provide a Uint8ClampedArray or an array of Uint8ClampedArray's instead of downloading
+     */
+    rawData?: Uint8ClampedArray | Uint8ClampedArray[];
+    /**# base64
+     * Provide a base64 encoded string to use instead of downloading
+     */
+    base64?: string | string[];
+    /**# includeInRawDataMap
+     * Will keep a Uint8ClampedArray of the loaded texture if set to true.
+     */
+    includeInRawDataMap?: boolean;
+};
+export type TextureData = {
+    type: TextureTypes;
+    /**# ID
+     * The id of the texture.
+     * This will be used to locate the file.
+     */
+    id: string;
+    /**# Path
+     * If the texture is not in the default path specify it here.
+     */
+    path?: string;
+    /**# Segment
+     * Define the segmetn of the texutre. By default it is main.
+     */
+    segment?: string;
+    /**# normalMap
+     * If the texture is an overlay specify it here.
+     */
+    normalMap?: boolean;
+    /**# Varations
+     * The name of the texture must be default with the folder being its ID.
+     * Variations allow you to add variations to the same texture.
+     *
+     * If you add a variation of "grassy-up" you must you include in the
+     * folder of the texture one with the name 'grassy-up'.
+     *
+     * So the files in that folder would be for a texture with the ID **dreamstone**
+     * - dreamstone/default.png
+     * - dreamstone/grassy-up.png
+     */
+    variations?: Record<string, TextureAnimationData & TextureDataBase>;
+} & TextureAnimationData & TextureDataBase;

package/Textures/Texture.types.js

@@ -0,0 +1 @@
+export {};

package/Textures/TextureAnimations.d.ts

@@ -0,0 +1,4 @@
+import type { TextureType } from "./TextureType";
+export declare const TextureAnimationCreator: {
+    createAnimations(texture: TextureType): void;
+};