@divinevoxel/vlox 0.0.71 → 0.0.73

package/Tasks/Propagation/Flow/FlowManager.js

@@ -1,23 +1,21 @@
 import { BrushTool } from "../../../Tools/Brush/Brush.js";
-import { SubstanceDataTool } from "../../../Tools/Data/SubstanceDataTool.js";
 import { WorldCursor } from "../../../World/index.js";
 export class FlowManager {
     static _brush = new BrushTool();
     static _sDataTool = new WorldCursor();
     static _nDataTool = new WorldCursor();
-    static _substanceTool = new SubstanceDataTool();
     static setVoxel(tasks, vox, level, levelState, x, y, z) {
         /*    this.sunCheck(tasks, x, y, z);
-           SunRemove(tasks);
-           this._brush.setId(vox).setXYZ(x, y, z).paint();
-           this._sDataTool.loadInAt(x, y, z);
-           this._sDataTool
-             .setLevel(level)
-             .setLevelState(levelState)
-             .setLight(this.getAbsorbLight(x, y, z))
-             .commit();
-       
-           SunUpdate(tasks); */
+        SunRemove(tasks);
+        this._brush.setId(vox).setXYZ(x, y, z).paint();
+        this._sDataTool.loadInAt(x, y, z);
+        this._sDataTool
+          .setLevel(level)
+          .setLevelState(levelState)
+          .setLight(this.getAbsorbLight(x, y, z))
+          .commit();
+    
+        SunUpdate(tasks); */
     }
     static setDimension(dimension) {
         // this._sDataTool.setDimension(dimension);
@@ -27,43 +25,44 @@ export class FlowManager {
     }
     static removeVoxel(tasks, x, y, z) {
         /*     for (const n of $3dCardinalNeighbors) {
-              const nx = x + n[0];
-              const ny = y + n[1];
-              const nz = z + n[2];
-              if (!this._nDataTool.loadInAt(nx, ny, nz)) continue;
-        
-              const l = this._nDataTool.getLight();
-        
-              if (l <= 0) continue;
-        
-              if (this.lightData.getS(l) > 0) {
-                tasks.sun.update.push(nx, ny, nz);
-              }
-        
-              if (this.lightData.hasRGBLight(l)) {
-                tasks.rgb.update.push(nx, ny, nz);
-              }
-            }
-            this._nDataTool.loadInAt(x, y, z);
-            const currentLight = this._nDataTool.getLight();
-            this._brush.setXYZ(x, y, z).erase();
-            this._nDataTool.clear().loadInAt(x, y, z);
-            this._nDataTool.setLight(currentLight).commit();
-            tasks.rgb.remove.push(x, y, z);
-            RGBRemove(tasks);
-            SunUpdate(tasks);
-            RGBUpdate(tasks); */
+          const nx = x + n[0];
+          const ny = y + n[1];
+          const nz = z + n[2];
+          if (!this._nDataTool.loadInAt(nx, ny, nz)) continue;
+    
+          const l = this._nDataTool.getLight();
+    
+          if (l <= 0) continue;
+    
+          if (this.lightData.getS(l) > 0) {
+            tasks.sun.update.push(nx, ny, nz);
+          }
+    
+          if (this.lightData.hasRGBLight(l)) {
+            tasks.rgb.update.push(nx, ny, nz);
+          }
+        }
+        this._nDataTool.loadInAt(x, y, z);
+        const currentLight = this._nDataTool.getLight();
+        this._brush.setXYZ(x, y, z).erase();
+        this._nDataTool.clear().loadInAt(x, y, z);
+        this._nDataTool.setLight(currentLight).commit();
+        tasks.rgb.remove.push(x, y, z);
+        RGBRemove(tasks);
+        SunUpdate(tasks);
+        RGBUpdate(tasks); */
     }
     static getFlowRate(substance) {
-        this._substanceTool.setSubstanceFromString(substance);
-        return this._substanceTool.getFlowRate();
+        //  this._substanceTool.setSubstanceFromString(substance);
+        //  return this._substanceTool.getFlowRate();
+        return 0;
     }
     static getVoxel(x, y, z) {
         /*    if (!this._sDataTool.loadInAt(x, y, z)) return false;
-           if (!this._sDataTool.isRenderable()) return false;
-       
-           const substance = this._sDataTool.getSubstnaceData();
-           if (!substance.isLiquid()) return false; */
+        if (!this._sDataTool.isRenderable()) return false;
+    
+        const substance = this._sDataTool.getSubstnaceData();
+        if (!substance.isLiquid()) return false; */
         return this._sDataTool;
     }
     static setLevel(level, x, y, z) {
@@ -72,39 +71,39 @@ export class FlowManager {
     }
     static getLevel(vox, x, y, z) {
         /*    if (!this._nDataTool.loadInAt(x, y, z)) return -2;
-           const voxel = this._nDataTool.getStringId();
-           if (this._nDataTool.isAir()) {
-             return 0;
-           }
-           if (voxel == vox) {
-             return this._nDataTool.getLevel();
-           }
-           return -1; */
+        const voxel = this._nDataTool.getStringId();
+        if (this._nDataTool.isAir()) {
+          return 0;
+        }
+        if (voxel == vox) {
+          return this._nDataTool.getLevel();
+        }
+        return -1; */
     }
     static getLevelState(vox, x, y, z) {
         /*     if (!this._nDataTool.loadInAt(x, y, z)) return -2;
-            const voxel = this._nDataTool.getStringId();
-            if (voxel == vox) {
-              return this._nDataTool.getLevelState();
-            }
-            if (this._nDataTool.isAir()) {
-              return -1;
-            }
-            return -3; */
+        const voxel = this._nDataTool.getStringId();
+        if (voxel == vox) {
+          return this._nDataTool.getLevelState();
+        }
+        if (this._nDataTool.isAir()) {
+          return -1;
+        }
+        return -3; */
     }
     static canFlowOutwardTest(vox, x, y, z) {
         /*    const level = this.getLevel(vox, x, y - 1, z);
-           if (level == -1) {
-             return true;
-           }
-           return false; */
+        if (level == -1) {
+          return true;
+        }
+        return false; */
     }
     static flowDownTest(vox, x, y, z) {
         /*     const level = this.getLevel(vox, x, y - 1, z);
-            if (level >= 0) {
-              return true;
-            }
-            return false; */
+        if (level >= 0) {
+          return true;
+        }
+        return false; */
     }
     static wait(ms) {
         return new Promise((resolve, reject) => setTimeout(resolve, ms));
@@ -114,29 +113,29 @@ export class FlowManager {
     ];
     static getAbsorbLight(x, y, z) {
         /*     for (const n of $3dCardinalNeighbors) {
-              if (!n[0] && !n[1] && !n[2]) continue;
-              if (!this._nDataTool.loadInAt(x + n[0], y + n[1], z + n[2])) continue;
-              let l = this._nDataTool.getLight();
-              if (l <= 0) continue;
-              const v = this.lightData.getLightValues(l);
-              for (let i = 0; i < 4; i++) {
-                if (this._lightValues[i] < v[i]) {
-                  this._lightValues[i] = v[i];
-                }
-              }
+          if (!n[0] && !n[1] && !n[2]) continue;
+          if (!this._nDataTool.loadInAt(x + n[0], y + n[1], z + n[2])) continue;
+          let l = this._nDataTool.getLight();
+          if (l <= 0) continue;
+          const v = this.lightData.getLightValues(l);
+          for (let i = 0; i < 4; i++) {
+            if (this._lightValues[i] < v[i]) {
+              this._lightValues[i] = v[i];
             }
-            let brightest = this.lightData.setLightValues(this._lightValues);
-            for (let i = 0; i < 4; i++) {
-              this._lightValues[i] = 0;
-            } */
+          }
+        }
+        let brightest = this.lightData.setLightValues(this._lightValues);
+        for (let i = 0; i < 4; i++) {
+          this._lightValues[i] = 0;
+        } */
         // return this.lightData.minusOneForAll(2);
     }
     static sunCheck(tasks, x, y, z) {
         /*     if (!this._nDataTool.loadInAt(x, y - 1, z)) return;
-            if (!this._nDataTool.isAir()) return;
-            const l = this._nDataTool.getLight();
-            if (this.lightData.getS(l) == 0xf) {
-              tasks.sun.remove.push(x, y - 1, z);
-            } */
+        if (!this._nDataTool.isAir()) return;
+        const l = this._nDataTool.getLight();
+        if (this.lightData.getS(l) == 0xf) {
+          tasks.sun.remove.push(x, y - 1, z);
+        } */
     }
 }

package/Tasks/Propagation/Flow/WorldFlow.js

@@ -1,6 +1,5 @@
 import { WorldSpaces } from "../../../World/WorldSpaces";
 import { WorldRegister } from "../../../World/WorldRegister";
-import { SectionHeightMap } from "../../../World/Section/SectionHeightMap";
 import { EngineSettings } from "../../../Settings/EngineSettings";
 import { SunRemove, SunUpdate } from "../Illumanation/SunUpdate";
 import { RGBRemove, RGBUpdate } from "../Illumanation/RGBUpdate";
@@ -118,7 +117,7 @@ export function WorldFlow(task) {
         const section = sector.sections[i];
         if (!section)
             continue;
-        let [minY, maxY] = SectionHeightMap.setSection(section).getMinMax();
+        let [minY, maxY] = section.getMinMax();
         const cx = sector.position[0];
         const cy = sector.position[1] + i * WorldSpaces.section.bounds.y;
         const cz = sector.position[2];
@@ -130,7 +129,7 @@ export function WorldFlow(task) {
                     const voxel = task.nDataCursor.getVoxel(x, y, z);
                     if (!voxel || voxel.isAir())
                         continue;
-                    if (voxel.getSubstanceData().isLiquid()) {
+                    if (voxel.getSubstanceData()["dve_is_liquid"]) {
                         for (let i = 0; i < 5; i++) {
                             const nVoxel = task.nDataCursor.getVoxel(x + flowUpdateChecks[i][0], y + flowUpdateChecks[i][1], z + flowUpdateChecks[i][2]);
                             if (nVoxel && nVoxel.isAir()) {

package/Tasks/Propagation/Illumanation/WorldRGB.js

@@ -1,7 +1,6 @@
 import { WorldSpaces } from "../../../World/WorldSpaces";
 import { WorldRegister } from "../../../World/WorldRegister";
 import { SectionCursor } from "../../../World/Cursor/SectionCursor";
-import { SectionHeightMap } from "../../../World/Section/SectionHeightMap";
 import { EngineSettings } from "../../../Settings/EngineSettings";
 import { RGBUpdate } from "./RGBUpdate";
 const sectionCursor = new SectionCursor();
@@ -20,7 +19,7 @@ export function WorldRGB(task) {
         if (!section)
             continue;
         sectionCursor.setSection(section);
-        let [minY, maxY] = SectionHeightMap.setSection(section).getMinMax();
+        let [minY, maxY] = section.getMinMax();
         const cx = sector.position[0];
         const cy = sector.position[1] + i * WorldSpaces.section.bounds.y;
         const cz = sector.position[2];

package/Tasks/Update/InitTasks.d.ts

@@ -1,4 +1,5 @@
+import { Thread } from "@amodx/threads";
 import { UpdateTask } from "./UpdateTask";
 export default function (props: {
-    onDone(taks: UpdateTask): void;
+    onDone(taks: UpdateTask, origin: Thread): void;
 }): void;

package/Tasks/Update/InitTasks.js

@@ -2,22 +2,22 @@ import { Threads } from "@amodx/threads";
 import { TasksIds } from "../TasksIds";
 import { VoxelUpdate, EreaseAndUpdate, PaintAndUpdate } from "./VoxelUpdate";
 export default function (props) {
-    Threads.registerTask(TasksIds.VoxelUpdate, async (data) => {
+    Threads.registerTask(TasksIds.VoxelUpdate, async (data, origin) => {
         const tasks = await VoxelUpdate(data);
         if (!tasks)
             return;
-        props.onDone(tasks);
+        props.onDone(tasks, origin);
     });
-    Threads.registerTask(TasksIds.VoxelErease, async (data) => {
+    Threads.registerTask(TasksIds.VoxelErease, async (data, origin) => {
         const tasks = await EreaseAndUpdate(data);
         if (!tasks)
             return;
-        props.onDone(tasks);
+        props.onDone(tasks, origin);
     });
-    Threads.registerTask(TasksIds.VoxelPaint, async (data) => {
+    Threads.registerTask(TasksIds.VoxelPaint, async (data, origin) => {
         const tasks = await PaintAndUpdate(data);
         if (!tasks)
             return;
-        props.onDone(tasks);
+        props.onDone(tasks, origin);
     });
 }

package/Tasks/Update/UpdateTask.d.ts

@@ -15,10 +15,12 @@ declare class UpdatedBounds {
     _task: UpdateTask;
     min: Vector3Like;
     max: Vector3Like;
+    dimension: string;
     constructor(_task: UpdateTask);
-    reset(): void;
+    start(dimension?: string): void;
     update(x: number, y: number, z: number): void;
     getSections(): Vec3Array[];
+    markSectionsAsDirty(): void;
 }
 export declare class UpdateTask {
     flow: FlowQueues;

package/Tasks/Update/UpdateTask.js

@@ -1,6 +1,7 @@
 import { WorldCursor } from "../../World/Cursor/WorldCursor";
 import { Vector3Like } from "@amodx/math";
 import { WorldSpaces } from "../../World/WorldSpaces";
+import { WorldRegister } from "../../World/WorldRegister";
 export class TaskMap {
     _map = [];
     get size() {
@@ -34,10 +35,12 @@ class UpdatedBounds {
     _task;
     min = Vector3Like.Clone(InfinityVec3);
     max = Vector3Like.Clone(NegativeInfinityVec3);
+    dimension = "main";
     constructor(_task) {
         this._task = _task;
     }
-    reset() {
+    start(dimension) {
+        this.dimension = dimension || "main";
         Vector3Like.Copy(this.min, InfinityVec3);
         Vector3Like.Copy(this.max, NegativeInfinityVec3);
     }
@@ -76,6 +79,29 @@ class UpdatedBounds {
         }
         return sectionPositions;
     }
+    markSectionsAsDirty() {
+        const minSectionPos = WorldSpaces.section.getPosition(this.min.x - 1, this.min.y - 1, this.min.z - 1, tempPosition);
+        const minX = minSectionPos.x;
+        const minY = minSectionPos.y;
+        const minZ = minSectionPos.z;
+        const maxSectionPos = WorldSpaces.section.getPosition(this.max.x + 1, this.max.y + 1, this.max.z + 1, tempPosition);
+        const maxX = maxSectionPos.x;
+        const maxY = maxSectionPos.y;
+        const maxZ = maxSectionPos.z;
+        for (let x = minX; x <= maxX; x += WorldSpaces.section.bounds.x) {
+            for (let z = minZ; z <= maxZ; z += WorldSpaces.section.bounds.z) {
+                for (let y = minY; y <= maxY; y += WorldSpaces.section.bounds.y) {
+                    if (!WorldSpaces.world.inBounds(x, y, z))
+                        continue;
+                    const sector = WorldRegister.sectors.get(this.dimension, x, y, z);
+                    if (!sector)
+                        continue;
+                    const section = sector.getSection(x, y, z);
+                    section.setDirty(true);
+                }
+            }
+        }
+    }
 }
 export class UpdateTask {
     flow = new FlowQueues();
@@ -96,13 +122,13 @@ export class UpdateTask {
         this.flow.update.map.start(origin[1], origin[2], origin[3]);
         this.flow.remove.map.start(origin[1], origin[2], origin[3]);
         this.flow.remove.noRemoveMap.start(origin[1], origin[2], origin[3]);
+        this.bounds.start(origin[0]);
         this.clear();
     }
     clear() {
         this.rgb.clear();
         this.sun.clear();
         this.flow.clear();
-        this.bounds.reset();
     }
 }
 class FlowQueues {

package/Tasks/Update/VoxelUpdate.js

@@ -1,13 +1,11 @@
 import { EngineSettings as ES } from "../../Settings/EngineSettings.js";
 import { $3dCardinalNeighbors } from "../../Math/CardinalNeighbors.js";
 import { UpdateTask } from "./UpdateTask.js";
-import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
 import { RGBRemove, RGBUpdate } from "../Propagation/Illumanation/RGBUpdate.js";
 import { SunRemove, SunUpdate } from "../Propagation/Illumanation/SunUpdate.js";
 import { FlowUpdate } from "../Propagation/Flow/FlowUpdate.js";
 import { FlowRemove } from "../Propagation/Flow/FlowRemove.js";
 const tasks = new UpdateTask();
-const substanceData = new SubstanceDataTool();
 const updateLightTask = (tasks) => {
     let doRGB = ES.doRGBPropagation;
     let doSun = ES.doSunPropagation;
@@ -38,9 +36,9 @@ export async function EreaseAndUpdate(location) {
     let voxel = tasks.sDataCursor.getVoxel(x, y, z);
     if (!voxel)
         return false;
-    substanceData.setSubstance(voxel.getSubstance());
+    const substanceData = voxel.getSubstanceData();
     if (!voxel.isAir() && ES.doFlow && voxel.isRenderable()) {
-        if (substanceData.isLiquid()) {
+        if (substanceData["dve_is_liquid"]) {
             FlowRemove(tasks);
             return tasks;
         }
@@ -70,6 +68,13 @@ export async function EreaseAndUpdate(location) {
             SunUpdate(tasks);
         }
     }
+    tasks.bounds.update(x, y, z);
+    tasks.bounds.update(x + 1, y + 1, z + 1);
+    for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
+        tasks.sDataCursor
+            .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
+            ?.updateVoxel(2);
+    }
     return tasks;
 }
 export async function PaintAndUpdate(data) {
@@ -107,6 +112,7 @@ export async function PaintAndUpdate(data) {
     voxel.setLevel(raw[2]);
     voxel.setState(raw[3]);
     voxel.setMod(raw[4]);
+    voxel.process();
     if (raw[3] > 0 && voxel.canHaveSecondaryVoxel()) {
         voxel.setSecondary(true);
         voxel.setId(raw[5]);
@@ -128,11 +134,17 @@ export async function PaintAndUpdate(data) {
     }
     voxel = tasks.sDataCursor.getVoxel(x, y, z);
     if (ES.doFlow) {
-        if (!voxel.isAir() &&
-            substanceData.setSubstance(voxel.getSubstance()).isLiquid()) {
+        if (!voxel.isAir() && voxel.getSubstanceData()["dve_is_liquid"]) {
             FlowUpdate(tasks);
         }
     }
+    tasks.bounds.update(x, y, z);
+    tasks.bounds.update(x + 1, y + 1, z + 1);
+    for (let i = 0; i < $3dCardinalNeighbors.length; i++) {
+        tasks.sDataCursor
+            .getVoxel($3dCardinalNeighbors[i][0] + x, $3dCardinalNeighbors[i][1] + y, $3dCardinalNeighbors[i][2] + z)
+            ?.updateVoxel(2);
+    }
     return tasks;
 }
 export async function VoxelUpdate(data) {
@@ -155,9 +167,11 @@ export async function VoxelUpdate(data) {
         }
     }
     if (ES.doFlow) {
-        if (substanceData.setSubstance(voxel.getSubstance()).isLiquid()) {
+        if (voxel.getSubstanceData()["dve_is_solid"]) {
             FlowUpdate(tasks);
         }
     }
+    tasks.bounds.update(x, y, z);
+    tasks.bounds.update(x + 1, y + 1, z + 1);
     return tasks;
 }

package/Tasks/WorldGeneration/WorldGenBrush.js

@@ -56,7 +56,7 @@ export class WorldGenBrush extends BrushTool {
     }
     getUpdatedSections() {
         const queue = this.tasks.bounds.getSections();
-        this.tasks.bounds.reset();
+        this.tasks.bounds.start();
         return queue;
     }
     update() {
@@ -64,6 +64,7 @@ export class WorldGenBrush extends BrushTool {
         if (!voxel)
             return false;
         const sl = voxel.getLight();
+        voxel.updateVoxel(2);
         if (lightData.hasRGBLight(sl)) {
             this.tasks.rgb.update.push(this.x, this.y, this.z);
             //    Propagation.instance.rgbUpdate(this.tasks);

package/Templates/Cursor/TemplateCursor.d.ts

@@ -1,7 +1,7 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
-import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { FullVoxelTemplate } from "Templates/FullVoxelTemplate";
-export declare class TemplateCursor extends DataCursorInterface {
+export declare class TemplateCursor implements DataCursorInterface {
     _voxelIndex: number;
     _template: FullVoxelTemplate | null;
     private voxel;

package/Templates/Cursor/TemplateCursor.js

@@ -1,6 +1,5 @@
 import { TemplateVoxelCursor } from "./TemplateVoxelCursor";
-import { DataCursorInterface } from "../../Data/Cursor/DataCursor.interface";
-export class TemplateCursor extends DataCursorInterface {
+export class TemplateCursor {
     _voxelIndex = 0;
     _template = null;
     voxel = new TemplateVoxelCursor(this);

package/Templates/Functions/CreateTemplate.js

@@ -2,7 +2,7 @@ import { Flat3DIndex, Traverse } from "@amodx/math";
 import { StringPalette } from "../../Util/StringPalette";
 import { VoxelTemplate } from "../VoxelTemplate";
 import { NumberPalette } from "../../Util/NumberPalette";
-import { convertToPaletteBuffer } from "../../Data/Functions/Palettes";
+import { convertToPaletteBuffer } from "../../Util/Binary/Palettes";
 import { WorldCursor } from "../../World";
 export default function CreateTemplate(dimension, start, end) {
     const dataTool = new WorldCursor();

package/Templates/VoxelTemplate.js

@@ -1,10 +1,9 @@
 import { Flat3DIndex, Traverse } from "@amodx/math";
 import { StringPalette } from "../Util/StringPalette";
 import { NumberPalette } from "../Util/NumberPalette";
-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";
+import { getPaletteArray } from "../Util/Binary/Palettes";
+import { VoxelPalettesRegister } from "../Voxels/Data/VoxelPalettesRegister";
+import { VoxelTagsRegister } from "../Voxels/Data/VoxelTagsRegister";
 export class VoxelTemplate {
     index = Flat3DIndex.GetXZYOrder();
     size;
@@ -49,7 +48,7 @@ export class VoxelTemplate {
     }
     getId(index) {
         const ids = this.ids;
-        return VoxelPalette.ids.getNumberId(this.idPalette.getStringId(typeof ids == "number" ? ids : ids[index]));
+        return VoxelPalettesRegister.voxels.getNumberId(this.idPalette.getStringId(typeof ids == "number" ? ids : ids[index]));
     }
     getState(index) {
         const state = this.state;
@@ -65,9 +64,8 @@ export class VoxelTemplate {
     }
     getSecondary(id, index) {
         const secondary = this.secondary;
-        VoxelStruct.setVoxel(id);
-        if (VoxelStruct.instance[VoxelStructIds.canHaveSecondary] == 1) {
-            return VoxelPalette.ids.getNumberId(this.secondaryIdPalette.getStringId(typeof secondary == "number" ? secondary : secondary[index]));
+        if (VoxelTagsRegister.VoxelTags[id]["dve_can_have_secondary"]) {
+            return VoxelPalettesRegister.voxels.getNumberId(this.secondaryIdPalette.getStringId(typeof secondary == "number" ? secondary : secondary[index]));
         }
         return this.secondaryStatePalette.getValue(typeof secondary == "number" ? secondary : secondary[index]);
     }

package/Templates/VoxelTemplates.types.d.ts

@@ -1,5 +1,5 @@
 import { Vec3Array } from "@amodx/math";
-import { VoxelDataArrays } from "../World";
+import { VoxelDataArrays } from "../Voxels";
 export interface VoxelTemplateBuffers {
     ids: Uint16Array | Uint8Array | number;
     state: Uint16Array | Uint8Array | number;

package/Textures/Classes/CompiledTexture.d.ts

@@ -0,0 +1,18 @@
+import { Vec2Array } from "@amodx/math";
+import { TextureId } from "../../Textures/Texture.types";
+import { CompiledTextureAnimation } from "./CompiledTextureAnimation";
+import { TextureAnimationTexture } from "./TextureAnimationTexture";
+export declare class CompiledTexture {
+    id: string;
+    static GetAtlasIndex: (x: number, y: number, boundsX: number) => number;
+    static GetAtlasPosition: (index: number, boundsX: number, position?: Vec2Array) => Vec2Array;
+    images: HTMLImageElement[];
+    atlasSizeMap: Record<string, [width: number, height: number]>;
+    textureMap: Record<string, number>;
+    animations: CompiledTextureAnimation[];
+    shaderTexture: any;
+    animatedTexture: TextureAnimationTexture;
+    constructor(id: string);
+    getTextureIndex(id: TextureId): number;
+    getTexturePath(id: TextureId): string;
+}

package/Textures/Classes/CompiledTexture.js

@@ -0,0 +1,50 @@
+import { TextureAnimationTexture } from "./TextureAnimationTexture";
+export class CompiledTexture {
+    id;
+    static GetAtlasIndex = (x, y, boundsX) => x + y * boundsX;
+    static GetAtlasPosition = (index, boundsX, position = [0, 0]) => {
+        position[1] = Math.floor(index / boundsX);
+        position[0] = Math.floor(index % boundsX);
+        return position;
+    };
+    images = [];
+    atlasSizeMap = {};
+    textureMap = {};
+    animations = [];
+    shaderTexture;
+    animatedTexture;
+    constructor(id) {
+        this.id = id;
+        this.animatedTexture = new TextureAnimationTexture(this);
+    }
+    getTextureIndex(id) {
+        let finalId = "";
+        let frameIndex = 0;
+        if (!Array.isArray(id)) {
+            finalId = id;
+        }
+        if (Array.isArray(id)) {
+            finalId = id[0];
+            if (typeof id[1] == "number")
+                frameIndex = id[1];
+            if (Array.isArray(id[1]))
+                frameIndex = CompiledTexture.GetAtlasIndex(id[1][0], id[1][1], this.atlasSizeMap[finalId][0]);
+            if (typeof id[1] == "string") {
+                finalId = `${id[0]}:${id[1]}`;
+                if (typeof id[2] == "number")
+                    frameIndex = id[2];
+                if (Array.isArray(id[2]))
+                    frameIndex = CompiledTexture.GetAtlasIndex(id[2][0], id[2][1], this.atlasSizeMap[finalId][0]);
+            }
+        }
+        const index = this.textureMap[finalId];
+        if (index === undefined) {
+            console.warn(`Texture with id [passed in: ${id.toString()}] [final: ${finalId}] does not exist on compiled texture [${this.id}]`);
+            return 0;
+        }
+        return index + frameIndex;
+    }
+    getTexturePath(id) {
+        return this.images[this.getTextureIndex(id)].src;
+    }
+}

package/Textures/Classes/CompiledTextureAnimation.d.ts

@@ -0,0 +1,12 @@
+export declare class CompiledTextureAnimation {
+    textureIndex: number;
+    _frames: number[];
+    _times: number[];
+    _currentTime: number;
+    _frameIndex: number;
+    _current: number;
+    _animatedTextureIndex: number;
+    constructor(textureIndex: number);
+    tick(delta: number): boolean;
+    getIndex(): number;
+}