@divinevoxel/vlox 0.0.72 → 0.0.73

package/World/WorldSpaces.js

@@ -1,7 +1,7 @@
 //types
 import { EngineSettings } from "../Settings/EngineSettings.js";
 import { Vector3Like } from "@amodx/math";
-import { CubeHashVec3, CubeHashVec3Array, GetYXZOrderArrayIndex, GetYXZOrderArrayPositionVec3, } from "../Math/Indexing.js";
+import { CubeHashVec3, CubeHashVec3Array, GetYXZOrderArrayIndex, GetYXZOrderArrayPositionVec3, GetYXZOrderArrayPositionVec3Array, } from "../Math/Indexing.js";
 const tempPosition = Vector3Like.Create();
 const tempPosition2 = Vector3Like.Create();
 class WorldBounds {
@@ -57,6 +57,8 @@ class SectorSpace {
     static power2Axes = Vector3Like.Create();
     static bounds = Vector3Like.Create();
     static volumne = 0;
+    static sectionBounds = Vector3Like.Create();
+    static sectionVolumne = 0;
     static getPosition(x, y, z, refPosition = Vector3Like.Create()) {
         CubeHashVec3(x, y, z, SectorSpace.power2Axes.x, SectorSpace.power2Axes.y, SectorSpace.power2Axes.z, refPosition);
         return refPosition;
@@ -81,7 +83,13 @@ class SectionSpace {
     static getIndex(x, y, z) {
         SectionSpace.getPosition(x, y, z, tempPosition);
         SectorSpace.getPosition(x, y, z, tempPosition2);
-        return (tempPosition.y - tempPosition2.y) / SectionSpace.bounds.y;
+        return GetYXZOrderArrayIndex((tempPosition.x - tempPosition2.x) / SectionSpace.bounds.x, (tempPosition.y - tempPosition2.y) / SectionSpace.bounds.y, (tempPosition.z - tempPosition2.z) / SectionSpace.bounds.z, SectorSpace.sectionBounds.x, SectorSpace.sectionBounds.y, SectorSpace.sectionBounds.z);
+    }
+    static getPositionFromIndex(index, refPosition = Vector3Like.Create()) {
+        return GetYXZOrderArrayPositionVec3(index, SectorSpace.sectionBounds.x, SectorSpace.sectionBounds.y, SectorSpace.sectionBounds.z, refPosition);
+    }
+    static getPositionFromIndexVec3Array(index, refPosition = [0, 0, 0]) {
+        return GetYXZOrderArrayPositionVec3Array(index, SectorSpace.sectionBounds.x, SectorSpace.sectionBounds.y, SectorSpace.sectionBounds.z, refPosition);
     }
 }
 class VoxelSpace {
@@ -138,6 +146,8 @@ EngineSettings.addEventListener("synced", (event) => {
     SectorSpace.bounds.x = 1 << SectorSpace.power2Axes.x;
     SectorSpace.bounds.y = 1 << SectorSpace.power2Axes.y;
     SectorSpace.bounds.z = 1 << SectorSpace.power2Axes.z;
+    SectorSpace.volumne =
+        SectorSpace.bounds.x * SectorSpace.bounds.y * SectorSpace.bounds.z;
     SectionSpace.power2Axes.x = settings.sections.power2Size.x;
     SectionSpace.power2Axes.y = settings.sections.power2Size.y;
     SectionSpace.power2Axes.z = settings.sections.power2Size.z;
@@ -146,8 +156,11 @@ EngineSettings.addEventListener("synced", (event) => {
     SectionSpace.bounds.z = 1 << SectionSpace.power2Axes.z;
     SectionSpace.volumne =
         SectionSpace.bounds.x * SectionSpace.bounds.y * SectionSpace.bounds.z;
-    SectorSpace.volumne =
-        (SectorSpace.bounds.x / SectionSpace.bounds.x) *
-            (SectorSpace.bounds.y / SectionSpace.bounds.y) *
-            (SectorSpace.bounds.z / SectionSpace.bounds.z);
+    SectorSpace.sectionBounds.x = SectorSpace.bounds.x / SectionSpace.bounds.x;
+    SectorSpace.sectionBounds.y = SectorSpace.bounds.y / SectionSpace.bounds.y;
+    SectorSpace.sectionBounds.z = SectorSpace.bounds.z / SectionSpace.bounds.z;
+    SectorSpace.sectionVolumne =
+        SectorSpace.sectionBounds.x *
+            SectorSpace.sectionBounds.y *
+            SectorSpace.sectionBounds.z;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@divinevoxel/vlox",
-  "version": "0.0.72",
+  "version": "0.0.73",
   "description": "Vlox a block style voxel engine.",
   "main": "index.js",
   "types": "index.d.ts",

package/Mesher/Functions/CompactMesh.d.ts

@@ -1,2 +0,0 @@
-import { MesherDataTool } from "../Geomtry/Tools/MesherDataTools";
-export declare function CompactMesh(materialId: string, tool: MesherDataTool): void;

package/Mesher/Functions/CompactMesh.js

@@ -1,42 +0,0 @@
-export function CompactMesh(materialId, tool) {
-    /*   let webGPU = EngineSettings.settings.rendererSettings.mode == "webgpu";
-    
-      const mesh = tool.mesh!;
-      const byteRanges: [
-        byteStart: number,
-        length: number,
-        type: BinaryNumberTypes,
-      ][] = [];
-      const dataMap: CompactSubMesh = [materialId, []];
-      let totalSize = 0;
-      for (let [key, [array, stride, type]] of mesh.attributes) {
-        if (key == MeshDefaultAttributes.Indices) {
-          if (array.length > 60_000) {
-            type = BinaryNumberTypes.Uint32;
-          }
-        }
-        let current = totalSize;
-    
-        totalSize += MappedByteCounts[type] * array.length;
-        byteRanges.push([current, array.length, type]);
-        dataMap[1].push([key, array as any, stride]);
-      }
-    
-      const finalBuffer = new ArrayBuffer(totalSize);
-    
-      for (let i = 0; i < dataMap[1].length; i++) {
-        const startByte = byteRanges[i][0];
-        const length = byteRanges[i][1];
-        const type = byteRanges[i][2];
-        const newArray = new TypedArrayClassMap[type](
-          finalBuffer,
-          //@ts-ignore
-          startByte,
-          length
-        ) as Float32Array;
-        newArray.set(dataMap[1][i][0] as any as number[]);
-        dataMap[1][i][1] = newArray;
-      }
-    
-      return [0, finalBuffer, [dataMap]]; */
-}

package/Mesher/Geomtry/GeometryNormals.d.ts

@@ -1,10 +0,0 @@
-import type { Vec3Array } from "@amodx/math";
-export declare class GeometryNormals {
-    static subtract(v1: Vec3Array, v2: Vec3Array): Vec3Array;
-    static cross(v1: Vec3Array, v2: Vec3Array): Vec3Array;
-    static scale(v: Vec3Array, scaleFactor: number): Vec3Array;
-    static add(v1: Vec3Array, v2: Vec3Array): Vec3Array;
-    static normalize(v: Vec3Array): Vec3Array;
-    static getTriangleNormals(p1: Vec3Array, p2: Vec3Array, p3: Vec3Array): Vec3Array;
-    static getQuadNormal(p1: Vec3Array, p2: Vec3Array, p3: Vec3Array, p4: Vec3Array): [n1: Vec3Array, n2: Vec3Array, n3: Vec3Array, n4: Vec3Array];
-}

package/Mesher/Geomtry/GeometryNormals.js

@@ -1,52 +0,0 @@
-export class GeometryNormals {
-    static subtract(v1, v2) {
-        return [v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2]];
-    }
-    static cross(v1, v2) {
-        return [
-            v1[1] * v2[2] - v1[2] * v2[1],
-            v1[2] * v2[0] - v1[0] * v2[2],
-            v1[0] * v2[1] - v1[1] * v2[0],
-        ];
-    }
-    static scale(v, scaleFactor) {
-        return [v[0] * scaleFactor, v[1] * scaleFactor, v[2] * scaleFactor];
-    }
-    static add(v1, v2) {
-        return [v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2]];
-    }
-    static normalize(v) {
-        const length = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-        return length > 0
-            ? [v[0] / length, v[1] / length, v[2] / length]
-            : [0, 0, 0];
-    }
-    static getTriangleNormals(p1, p2, p3) {
-        const a = this.subtract(p2, p1);
-        const b = this.subtract(p3, p1);
-        const substract = this.cross(a, b);
-        const normal = this.scale(substract, -1);
-        return this.normalize(normal);
-    }
-    static getQuadNormal(p1, p2, p3, p4) {
-        const vectorA1 = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
-        const vectorA2 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
-        const normalA = this.normalize(this.cross(vectorA1, vectorA2));
-        const vectorB1 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
-        const vectorB2 = [p4[0] - p1[0], p4[1] - p1[1], p4[2] - p1[2]];
-        const normalB = this.normalize(this.cross(vectorB1, vectorB2));
-        const n1 = this.normalize([
-            (normalA[0] + normalB[0]) / 2,
-            (normalA[1] + normalB[1]) / 2,
-            (normalA[2] + normalB[2]) / 2,
-        ]);
-        const n2 = normalA;
-        const n3 = this.normalize([
-            (normalA[0] + normalB[0]) / 2,
-            (normalA[1] + normalB[1]) / 2,
-            (normalA[2] + normalB[2]) / 2,
-        ]);
-        const n4 = normalB;
-        return [n1, n2, n3, n4];
-    }
-}

package/Mesher/Geomtry/MeshData.types.d.ts

@@ -1,13 +0,0 @@
-import type { TypedArrays } from "@amodx/binary";
-export declare enum MeshDefaultAttributes {
-    Position = "position",
-    Normal = "normal",
-    Indices = "indices"
-}
-export type MeshAttributes = [
-    id: string,
-    data: TypedArrays,
-    stride: number,
-    componentTypes?: number,
-    noramlizer?: number
-][];

package/Mesher/Geomtry/MeshData.types.js

@@ -1,6 +0,0 @@
-export var MeshDefaultAttributes;
-(function (MeshDefaultAttributes) {
-    MeshDefaultAttributes["Position"] = "position";
-    MeshDefaultAttributes["Normal"] = "normal";
-    MeshDefaultAttributes["Indices"] = "indices";
-})(MeshDefaultAttributes || (MeshDefaultAttributes = {}));

package/Mesher/Geomtry/Tools/MesherDataTools.d.ts

@@ -1,7 +0,0 @@
-import { VoxelMesh } from "../VoxelMesh.js";
-export declare class MesherDataTool {
-    segments: Map<string, number[]>;
-    mesh: VoxelMesh | null;
-    startNewMesh(mesh?: VoxelMesh): void;
-    clear(): this;
-}

package/Mesher/Geomtry/Tools/MesherDataTools.js

@@ -1,12 +0,0 @@
-import { VoxelMesh } from "../VoxelMesh.js";
-export class MesherDataTool {
-    segments = new Map();
-    mesh = null;
-    startNewMesh(mesh) {
-        this.mesh = mesh ? mesh : new VoxelMesh();
-    }
-    clear() {
-        this.mesh?.clear();
-        return this;
-    }
-}

package/Mesher/Geomtry/Tools/index.d.ts

@@ -1 +0,0 @@
-export * from "./MesherDataTools.js";

package/Mesher/Geomtry/Tools/index.js

@@ -1 +0,0 @@
-export * from "./MesherDataTools.js";

package/Mesher/RenderedMaterials.d.ts

@@ -1,6 +0,0 @@
-import { VoxelMesherDataTool } from "./Tools/VoxelMesherDataTool";
-export declare class RenderedMaterials {
-    static meshersMap: Map<string, VoxelMesherDataTool>;
-    static meshers: VoxelMesherDataTool[];
-    static register(materials: string[]): void;
-}

package/Models/Rules/VoxelModelManager.js

@@ -1,82 +0,0 @@
-import { StringPalette } from "../../Util/StringPalette";
-import { VoxelRuleGeometry } from "./Classes/VoxelRulesGeometry";
-import { VoxelRulesModoel } from "./Classes/VoxelRulesModel";
-const addGeo = (modelId, stateId, nodes) => {
-    const registred = [];
-    for (const geoLinkNode of nodes) {
-        const geo = VoxelModelManager.geometry.get(geoLinkNode.geometryId);
-        if (!geo)
-            throw new Error(`Geometry ${geoLinkNode.geometryId} is not registered.`);
-        const newId = getGeometryLinkId(geoLinkNode);
-        if (VoxelModelManager.geometry.has(newId))
-            continue;
-        registred.push([stateId, newId]);
-        if (!VoxelModelManager.geometryPalette.isRegistered(newId))
-            VoxelModelManager.geometryPalette.register(newId);
-        const newData = structuredClone(geo.data);
-        newData.nodes = newData.nodes.map((_) => ({
-            ..._,
-            tranform: {
-                ...(geoLinkNode.position ? { position: geoLinkNode.position } : {}),
-                ...(geoLinkNode.scale ? { scale: geoLinkNode.scale } : {}),
-                ...(geoLinkNode.rotation ? { rotation: geoLinkNode.rotation } : {}),
-                ...(geoLinkNode.rotationPivot
-                    ? { rotationPivot: geoLinkNode.rotationPivot }
-                    : {}),
-                ...(geoLinkNode.flip ? { flip: geoLinkNode.flip } : {}),
-            },
-        }));
-        VoxelModelManager.geometry.set(newId, new VoxelRuleGeometry(newId, newData));
-        continue;
-    }
-    return registred;
-};
-const getGeometryLinkId = (node) => {
-    return `${node.geometryId}${node.position ? `-p${node.position.toString()}` : ""}${node.rotation ? `-r${node.rotation.toString()}` : ""}${node.scale ? `-s${node.scale.toString()}` : ""}`.trim();
-};
-export class VoxelModelManager {
-    static geometryPalette = new StringPalette();
-    static getGeometryLinkId = getGeometryLinkId;
-    static voxels = new Map();
-    static geometry = new Map();
-    static models = new Map();
-    static registerGeometry(...geometry) {
-        for (const geo of geometry) {
-            if (!this.geometryPalette.isRegistered(geo.id))
-                this.geometryPalette.register(geo.id);
-            this.geometry.set(geo.id, new VoxelRuleGeometry(geo.id, {
-                ogData: geo,
-                id: geo.id,
-                nodes: geo.nodes.map((node) => ({
-                    node,
-                    tranform: {},
-                })),
-            }));
-        }
-    }
-    static getGeomtryFromLink(link) {
-        return this.geometry.get(getGeometryLinkId(link));
-    }
-    static registerModels(...models) {
-        for (const model of models) {
-            const rulesModel = new VoxelRulesModoel(model);
-            this.models.set(model.id, rulesModel);
-            for (const stateId in model.shapeStatesNodes) {
-                const nodes = model.shapeStatesNodes[stateId];
-                addGeo(model.id, stateId, nodes).forEach((_) => rulesModel.registerShapeState(..._));
-            }
-            for (const stateId in model.shapeStatesConditonalNodes) {
-                const nodes = model.shapeStatesConditonalNodes[stateId];
-                addGeo(model.id, stateId, nodes).forEach((_) => rulesModel.registerCondiotnalNode(..._));
-            }
-        }
-    }
-    static registerVoxel(id, data) {
-        let voxelModels = this.voxels.get(data.id);
-        if (!voxelModels) {
-            voxelModels = [];
-            this.voxels.set(data.id, voxelModels);
-        }
-        voxelModels.push({ id, data });
-    }
-}

package/Textures/TextureAnimations.d.ts

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

package/Textures/TextureAnimations.js

@@ -1,35 +0,0 @@
-export const TextureAnimationCreator = {
-    createAnimations(texture) {
-        if (!texture.paths.size)
-            return;
-        const animaitonUniform = [];
-        let i = 0;
-        for (const anim of texture.animationsMap) {
-            animaitonUniform[anim[0]] = anim[0];
-            let keyCounts = [];
-            const animTime = texture.animationTimes[i];
-            if (animTime.length == 1) {
-                for (let k = 0; k < anim.length; k++) {
-                    keyCounts.push(animTime[0]);
-                }
-            }
-            else {
-                keyCounts = texture.animationTimes[i];
-            }
-            texture.animations.push({
-                uniformIndex: anim[0],
-                keys: anim,
-                currentFrame: 0,
-                currentCount: 0,
-                keyCounts: keyCounts,
-            });
-            i++;
-        }
-        for (let i = 0; i < texture.totalTextures; i++) {
-            if (!animaitonUniform[i]) {
-                animaitonUniform[i] = 0;
-            }
-        }
-        texture.animationUniform = new Float32Array(animaitonUniform);
-    },
-};

package/Textures/TextureArray.d.ts

@@ -1,47 +0,0 @@
-import type { TextureData } from "./Texture.types";
-export declare class TextureArray {
-    id: string;
-    extension: string;
-    totalTextures: number;
-    textureMap: Map<string, TextureData>;
-    textures: TextureData[];
-    textureIndex: Record<string, number>;
-    animationsMap: number[][];
-    animationTimes: number[][];
-    animations: {
-        uniformIndex: number;
-        overlay?: boolean;
-        keys: number[];
-        currentFrame: number;
-        currentCount: number;
-        keyCounts: number[];
-    }[];
-    varyingID: string;
-    animationUniforID: string;
-    animationUniform: Float32Array;
-    paths: Map<string, HTMLImageElement | string | false>;
-    images: HTMLImageElement[];
-    shaderTexture: any | null;
-    textureID: string;
-    attributeID: string;
-    constructor(id: string);
-    /**# clearData
-     * ---
-     * Clear all un-needed data.
-     */
-    clearData(): void;
-    /**# flush
-     * ---
-     * Clear all data.
-     */
-    flush(): void;
-    flushAll(): void;
-    build(): Promise<void>;
-    getTextureIndex(textureId: string, varation?: string): number;
-    addTexture(data: TextureData): void;
-    runAnimations(): void;
-    getTextureIndexMap(): Record<string, number>;
-    _processVariations(textureData: TextureData, paths: Map<string, HTMLImageElement | string | false>, map: Record<string, number>, animations: number[][], textureAnimatioTimes: number[][], extension: string, count: number): number;
-    _getPath(textureData: TextureData, varation: string | undefined, extension: string): string;
-    buildTextureIndex(): false | undefined;
-}

package/Textures/TextureArray.js

@@ -1,202 +0,0 @@
-import { TextureManager } from "./TextureManager.js";
-import { TextureAnimationCreator } from "./TextureAnimations.js";
-import { TextureBuilder } from "./TextureBuilder.js";
-export class TextureArray {
-    id;
-    extension = "png";
-    totalTextures = 0;
-    textureMap = new Map();
-    textures = [];
-    textureIndex = {};
-    animationsMap = [];
-    animationTimes = [];
-    animations = [];
-    varyingID = "";
-    animationUniforID = "";
-    animationUniform = new Float32Array();
-    paths = new Map();
-    images = [];
-    /* actual renderer resource */
-    shaderTexture = null;
-    textureID = "";
-    attributeID = "textureIndex";
-    constructor(id) {
-        this.id = id;
-        this.textureID = id.replace("#", "");
-    }
-    /**# clearData
-     * ---
-     * Clear all un-needed data.
-     */
-    clearData() {
-        this.paths.clear();
-        this.textures = [];
-        this.textureMap.clear();
-        this.textureIndex = {};
-        this.images = [];
-        this.animationsMap = [];
-        this.animationTimes = [];
-    }
-    /**# flush
-     * ---
-     * Clear all data.
-     */
-    flush() {
-        this.clearData();
-        this.images = [];
-        this.animations = [];
-        this.animationTimes = [];
-        this.animationsMap = [];
-        this.textureIndex = {};
-        this.totalTextures = 0;
-    }
-    flushAll() {
-        //  this.materials.clear();
-    }
-    async build() {
-        this.buildTextureIndex();
-        if (this.paths.size) {
-            this.images = await TextureBuilder.createMaterialTexture(this.id, this.paths);
-        }
-        TextureAnimationCreator.createAnimations(this);
-    }
-    getTextureIndex(textureId, varation = "") {
-        let id = textureId;
-        if (varation) {
-            id = `${textureId}:${varation}`;
-        }
-        let uv = -1;
-        uv = this.textureIndex[id];
-        if (uv == -1) {
-            throw new Error(`Texture with id: ${id} does not exists.typeId : ${this.id} `);
-        }
-        return uv;
-    }
-    addTexture(data) {
-        this.textures.push(data);
-        this.textureMap.set(data.id, data);
-    }
-    runAnimations() {
-        for (let i = 0; i < this.animations.length; i++) {
-            const anim = this.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;
-            }
-            this.animationUniform[anim.uniformIndex] = anim.keys[anim.currentFrame];
-            /*       for (const [key, material] of this.materials) {
-                    material!.setNumberArray(
-                      this.animationUniforID,
-                      this.animationUniform as any
-                    );
-                  } */
-        }
-    }
-    getTextureIndexMap() {
-        return this.textureIndex;
-    }
-    _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.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.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;
-        let count = 0;
-        const map = this.textureIndex;
-        const paths = this.paths;
-        const animationTimes = this.animationTimes;
-        const animations = this.animationsMap;
-        for (const textureData of this.textures) {
-            if (textureData.frames == 0) {
-                this.textureIndex[`${textureData.id}`] = count;
-                const assetPath = this._getPath(textureData, "default", extension);
-                let raw = false;
-                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 (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);
-            }
-        }
-        this.totalTextures = count;
-    }
-}

package/Textures/TextureBuilder.d.ts

@@ -1,13 +0,0 @@
-export declare class TextureBuilder {
-    static context: CanvasRenderingContext2D | null;
-    static _textureSize: number;
-    static finalImagWidth: number;
-    static finalImageHeight: number;
-    static _canvas: HTMLCanvasElement;
-    static defineTextureDimensions(textureSize: number): void;
-    static setUpImageCreation(): void;
-    static createMaterialTexture(name: string, images: Map<string, HTMLImageElement | string | false>, width?: number, height?: number): Promise<HTMLImageElement[]>;
-    static getRawData(imageSrc: string): Promise<Uint8ClampedArray>;
-    static getBase64(imageSrc: string): Promise<string>;
-    static loadImage(imgSrcData: string | HTMLImageElement, width?: number, height?: number): Promise<HTMLImageElement>;
-}