@divinevoxel/vlox 0.0.1 → 0.0.3

package/Tools/Data/DataTool.js

@@ -1,21 +1,22 @@
 import { DimensionsRegister } from "../../Data/World/DimensionsRegister.js";
-import { VoxelStateReader } from "../../Data/VoxelStateReader.js";
-import { VoxelStruct } from "../../Data/Voxel/VoxelStruct.js";
-import { VoxelPalette } from "../../Data/Voxel/VoxelPalette.js";
+import { VoxelStateReader } from "../../Voxels/VoxelStateReader.js";
+import { VoxelStruct } from "../../Data/Structs/VoxelStruct.js";
+import { VoxelPalette } from "../../Data/Palettes/VoxelPalette.js";
 import { ChunkDataTool } from "./WorldData/ChunkDataTool.js";
 import { HeightMapTool } from "./WorldData/HeightMapTool.js";
 import { DataToolBase } from "../Classes/DataToolBase.js";
 import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
 import { ColumnDataTool } from "./WorldData/ColumnDataTool.js";
-import { LightData } from "../../Data/LightData.js";
-import { VoxelStructProperties } from "../../Data/Constants/Structs/VoxelStructProperties.js";
+import { LightData } from "../../Voxels/LightData.js";
+import { VoxelStructIds } from "../../Voxels/Voxel.types";
 import { MappedDataRegister } from "../../Data/Register/MappedDataRegister.js";
 import { SubstanceDataTool } from "./SubstanceDataTool.js";
 import { SafeInterval } from "@amodx/core/Intervals/SafeInterval.js";
 import { SafePromise } from "@amodx/core/Promises/SafePromise.js";
 import { WorldRegister } from "../../Data/World/WorldRegister.js";
-import { VoxelTagIDs } from "../../Data/Constants/VoxelTagIds.js";
-import { SubstancePaletteReader } from "../../Data/Substance/SubstancePalette.js";
+import { SubstancePalette } from "../../Data/Palettes/SubstancePalette.js";
+import { VoxelTagStates } from "../../Voxels/State/VoxelTagStates";
+import { MaterialPalette } from "../../Data/Palettes/MaterialPalette";
 export var DataToolModes;
 (function (DataToolModes) {
     /**# World Data Mode
@@ -176,6 +177,8 @@ export class DataTool extends DataToolBase {
             return false;
         }
         if (this._mode == DataTool.Modes.VOXEL_DATA) {
+            if (this.x == 0 && this.y == 0 && this.z == 0)
+                return true;
             this.data.raw[0] = 0;
             this.data.raw[1] = LightData.getS(0xff);
             this.data.raw[2] = 0;
@@ -238,16 +241,16 @@ export class DataTool extends DataToolBase {
             return this.data.raw[1];
         if (vID < 2)
             return -1;
-        const lightValue = this.__struct[VoxelTagIDs.lightValue];
+        const lightValue = this.__struct[VoxelStructIds.lightValue];
         if (this.isOpaque()) {
-            if (this.__struct[VoxelTagIDs.isLightSource] && lightValue) {
+            if (this.isLightSource() && lightValue) {
                 return lightValue;
             }
             else {
                 return -1;
             }
         }
-        if (this.__struct[VoxelTagIDs.isLightSource] && lightValue) {
+        if (this.isLightSource() && lightValue) {
             return LightData.mixLight(this.data.raw[1], lightValue);
         }
         return this.data.raw[1];
@@ -257,7 +260,7 @@ export class DataTool extends DataToolBase {
         return this;
     }
     isOpaque() {
-        return this.__struct[VoxelTagIDs.isTransparent] == 0;
+        return this.__struct[VoxelStructIds.isTransparent] == 0;
     }
     getMod() {
         return this.data.raw[4];
@@ -291,66 +294,62 @@ export class DataTool extends DataToolBase {
         return this.data.secondaryId > 1;
     }
     canHaveSecondaryVoxel() {
-        return this.__struct[VoxelTagIDs.canHaveSecondary] == 1;
+        return this.__struct[VoxelStructIds.canHaveSecondary] == 1;
     }
     //voxel data
-    getShapeId() {
-        const vID = this._loadedId;
-        if (vID < 2)
-            return -1;
-        return this.__struct[VoxelTagIDs.shapeID];
-    }
-    getShapeStringId() {
-        const vID = this._loadedId;
-        if (vID < 2)
-            return "";
-        return MappedDataRegister.stringMaps.get("voxel", VoxelStructProperties.shapeID, this.__struct[VoxelTagIDs.shapeID]);
-    }
     isLightSource() {
         const vID = this._loadedId;
         if (vID < 2)
             return false;
-        return this.__struct[VoxelTagIDs.isLightSource] == 1;
+        return VoxelTagStates.isRegistered(this._loadedId, VoxelStructIds.isLightSource)
+            ? VoxelTagStates.getValue(this._loadedId, VoxelStructIds.isLightSource, this.getShapeState()) === true
+            : this.__struct[VoxelStructIds.isLightSource] == 1;
     }
     noAO() {
         const vID = this._loadedId;
         if (vID < 2)
             return false;
-        return this.__struct[VoxelTagIDs.noAO] == 1;
+        return this.__struct[VoxelStructIds.noAO] == 1;
     }
     getLightSourceValue() {
         const vID = this._loadedId;
         if (vID < 2)
             return 0;
-        return this.__struct[VoxelTagIDs.lightValue];
+        return this.__struct[VoxelStructIds.lightValue];
     }
     getSubstanceStringId() {
         const vID = this._loadedId;
         if (vID < 2)
-            return "#dve_transparent";
-        return SubstancePaletteReader.id.stringFromNumber(this.getSubstance());
+            return "dve_transparent";
+        return SubstancePalette.id.stringFromNumber(this.getSubstance());
     }
     getSubstance() {
         const vID = this._loadedId;
         if (vID < 2)
             return -1;
-        return this.__struct[VoxelTagIDs.substance];
+        return this.__struct[VoxelStructIds.substance];
+    }
+    getRenderedMaterial() {
+        return this.__struct[VoxelStructIds.renderedMaterial];
+    }
+    getRenderedMaterialStringId() {
+        return MaterialPalette.id.stringFromNumber(this.__struct[VoxelStructIds.renderedMaterial]);
     }
     getMaterial() {
-        const vID = this._loadedId;
-        if (vID < 2)
-            return "none";
-        return MappedDataRegister.stringMaps.get("voxel", VoxelStructProperties.material, this.__struct[VoxelTagIDs.material]);
+        return this.__struct[VoxelStructIds.voxelMaterial];
+    }
+    getMaterialStringId() {
+        return MaterialPalette.id.stringFromNumber(this.__struct[VoxelStructIds.voxelMaterial]);
     }
     getHardness() {
         const vID = this._loadedId;
         if (vID < 2)
             return 0;
-        return this.__struct[VoxelTagIDs.hardness];
+        return this.__struct[VoxelStructIds.hardness];
     }
     getCollider() {
         const vID = this._loadedId;
-        return MappedDataRegister.stringMaps.get("voxel", VoxelStructProperties.colliderID, this.__struct[VoxelTagIDs.colliderID]);
+        return MappedDataRegister.stringMaps.get("voxel", VoxelStructIds.colliderID, this.__struct[VoxelStructIds.colliderID]);
     }
     checkCollisions() {
         const vID = this._loadedId;
@@ -358,13 +357,13 @@ export class DataTool extends DataToolBase {
             return false;
         if (vID == 1)
             return true;
-        return this.__struct[VoxelTagIDs.checkCollisions] == 1;
+        return this.__struct[VoxelStructIds.checkCollisions] == 1;
     }
     isRich() {
         const vID = this._loadedId;
         if (vID < 2)
             return 0;
-        return this.__struct[VoxelTagIDs.isRich] == 1;
+        return this.__struct[VoxelStructIds.isRich] == 1;
     }
     //util
     setAir() {

package/Tools/Data/SubstanceDataTool.d.ts

@@ -1,16 +1,12 @@
-import { SubstanceStruct } from "../../Data/Substance/SubstanceStruct.js";
+import { SubstanceStruct } from "../../Data/Structs/SubstanceStruct.js";
 export declare class SubstanceDataTool {
     static tags: typeof SubstanceStruct;
     substanceTagIndex: number;
-    setSubstanceFromString(substance: string): void;
-    setSubstance(substance: number): void;
+    setSubstanceFromString(substance: string): this;
+    setSubstance(substance: number): this;
     getSubstanceStringId(): string;
     isLiquid(): boolean;
     isWindAffected(): boolean;
-    isBackFaceCulled(): boolean;
-    cullDense(): boolean;
     getParent(): string;
-    getRendered(): string;
-    getCulled(): string[];
     getFlowRate(): number;
 }

package/Tools/Data/SubstanceDataTool.js

@@ -1,44 +1,38 @@
-import { SubstanceStructProperties } from "../../Data/Constants/Structs/SubstanceStructProperties.js";
-import { SubstancePaletteReader } from "../../Data/Substance/SubstancePalette.js";
-import { SubstanceStruct } from "../../Data/Substance/SubstanceStruct.js";
+import { SubstancePalette } from "../../Data/Palettes/SubstancePalette.js";
+import { SubstanceStruct } from "../../Data/Structs/SubstanceStruct.js";
 import { MappedDataRegister } from "../../Data/Register/MappedDataRegister.js";
-import { SubstanceTagIds } from "../../Data/Constants/SubstanceTagIds.js";
+import { SubstanceStructIds } from "../../Voxels/VoxelSubstances.types.js";
 export class SubstanceDataTool {
     static tags = SubstanceStruct;
     //substance = "";
     substanceTagIndex = 0;
     setSubstanceFromString(substance) {
         //   this.substance = substance;
-        this.substanceTagIndex =
-            SubstancePaletteReader.id.numberFromString(substance);
+        this.substanceTagIndex = SubstancePalette.id.numberFromString(substance);
         SubstanceStruct.setSubstance(this.substanceTagIndex);
+        return this;
     }
     setSubstance(substance) {
         //  this.substance = substance;
         this.substanceTagIndex = substance;
         SubstanceStruct.setSubstance(this.substanceTagIndex);
+        return this;
     }
     getSubstanceStringId() {
-        return SubstancePaletteReader.id.stringFromNumber(this.substanceTagIndex);
+        return SubstancePalette.id.stringFromNumber(this.substanceTagIndex);
     }
     /*   isTransparent() {
-      return SubstanceStruct.instance[SubstanceTagIds.isTransparent] == 1;
+      return SubstanceStruct.instance[SubstanceStructIds.isTransparent] == 1;
     }
   
     isSolid() {
-      return SubstanceStruct.instance[SubstanceTagIds.isSolid] == 1;
+      return SubstanceStruct.instance[SubstanceStructIds.isSolid] == 1;
     } */
     isLiquid() {
-        return SubstanceStruct.instance[SubstanceTagIds.isLiquid] == 1;
+        return SubstanceStruct.instance[SubstanceStructIds.isLiquid] == 1;
     }
     isWindAffected() {
-        return SubstanceStruct.instance[SubstanceTagIds.isWindAffected] == 1;
-    }
-    isBackFaceCulled() {
-        return SubstanceStruct.instance[SubstanceTagIds.isBackFaceCulled] == 1;
-    }
-    cullDense() {
-        return SubstanceStruct.instance[SubstanceTagIds.cullDense] == 1;
+        return SubstanceStruct.instance[SubstanceStructIds.isWindAffected] == 1;
     }
     /*   isOpaque() {
       return this.isSolid() && !this.isTransparent();
@@ -48,15 +42,9 @@ export class SubstanceDataTool {
       return this.isTransparent();
     } */
     getParent() {
-        return MappedDataRegister.stringMaps.get("substance", SubstanceStructProperties.parent, SubstanceStruct.instance[SubstanceTagIds.parent]);
-    }
-    getRendered() {
-        return MappedDataRegister.stringMaps.get("substance", SubstanceStructProperties.rendered, SubstanceStruct.instance[SubstanceTagIds.rendered]);
-    }
-    getCulled() {
-        return MappedDataRegister.objectMaps.get("substance", SubstanceStructProperties.culledSubstnaces, SubstanceStruct.instance[SubstanceTagIds.culledSubstnaces]);
+        return MappedDataRegister.stringMaps.get("substance", SubstanceStructIds.parent, SubstanceStruct.instance[SubstanceStructIds.parent]);
     }
     getFlowRate() {
-        return SubstanceStruct.instance[SubstanceTagIds.flowRate];
+        return SubstanceStruct.instance[SubstanceStructIds.flowRate];
     }
 }

package/Tools/Data/WorldData/ChunkDataTool.d.ts

@@ -1,6 +1,6 @@
 import { DataToolBase } from "../../Classes/DataToolBase.js";
 import { Chunk } from "../../../Data/World/Classes/Chunk.js";
-import { RawVoxelData } from "../../../Data/Types/VoxelData.types.js";
+import { RawVoxelData } from "../../../Voxels/Voxel.types.js";
 export declare class ChunkDataTool extends DataToolBase {
     struct: import("@amodx/binary").RemoteBinaryStruct;
     _chunk: Chunk;

package/Tools/Data/WorldData/ColumnDataTool.js

@@ -32,50 +32,50 @@ export class ColumnDataTool extends DataToolBase {
             Column.StateStruct.structSize * this.getNumChunks());
     }
     isStored() {
-        return this.getStructValue("#dve_is_stored") == 1;
+        return this.getStructValue("dve_is_stored") == 1;
     }
     markAsNotStored() {
-        this.setTagValue("#dve_is_stored", 0);
+        this.setTagValue("dve_is_stored", 0);
         return this;
     }
     markAsStored() {
-        this.setTagValue("#dve_is_stored", 1);
+        this.setTagValue("dve_is_stored", 1);
         return this;
     }
     isPersistent() {
-        return this.getStructValue("#dve_persistent") == 1;
+        return this.getStructValue("dve_persistent") == 1;
     }
     setPersistence(value) {
-        this.setTagValue("#dve_persistent", value ? 1 : 0);
+        this.setTagValue("dve_persistent", value ? 1 : 0);
     }
     isDirty() {
-        return this.getStructValue("#dve_is_dirty") == 1;
+        return this.getStructValue("dve_is_dirty") == 1;
     }
     setDirty(value) {
-        this.setTagValue("#dve_is_dirty", value ? 1 : 0);
+        this.setTagValue("dve_is_dirty", value ? 1 : 0);
     }
     getLastSaveTimestamp() {
-        return this.getStructValue("#dve_last_save_timestamp");
+        return this.getStructValue("dve_last_save_timestamp");
     }
     setLastSaveTimestamp() {
-        return this.setTagValue("#dve_last_save_timestamp", Date.now());
+        return this.setTagValue("dve_last_save_timestamp", Date.now());
     }
     getLastAnalyzerUpdateTimestamp() {
-        return this.getStructValue("#dve_last_analyzer_update_timestamp");
+        return this.getStructValue("dve_last_analyzer_update_timestamp");
     }
     setLastAnalyzerUpdateTimestamp() {
-        return this.setTagValue("#dve_last_analyzer_update_timestamp", Date.now());
+        return this.setTagValue("dve_last_analyzer_update_timestamp", Date.now());
     }
     hasRichData() {
-        return this.getStructValue("#dve_has_rich_data") == 1;
+        return this.getStructValue("dve_has_rich_data") == 1;
     }
     setRichData(value) {
-        this.setTagValue("#dve_has_rich_data", value ? 1 : 0);
+        this.setTagValue("dve_has_rich_data", value ? 1 : 0);
     }
     hasEntityData() {
-        return this.getStructValue("#dve_has_entity_data") == 1;
+        return this.getStructValue("dve_has_entity_data") == 1;
     }
     setEntityData(value) {
-        this.setTagValue("#dve_has_entity_data", value ? 1 : 0);
+        this.setTagValue("dve_has_entity_data", value ? 1 : 0);
     }
 }

package/Tools/Data/WorldData/HeightMapTool.js

@@ -6,7 +6,7 @@ import { WorldBounds } from "../../../Data/World/WorldBounds.js";
 import { LocationBoundTool } from "../../../Tools/Classes/LocationBoundTool.js";
 import { ChunkDataTool } from "./ChunkDataTool.js";
 //constants
-import { ChunkStructProperties } from "../../../Data/Constants/Structs/ChunkStructProperties.js";
+import { ChunkStructProperties } from "../../../Data/Structs/Constants/ChunkStructProperties.js";
 import { $2dMooreNeighborhood } from "../../../Math/Constants/CardinalNeighbors.js";
 export class HeightMapTool extends LocationBoundTool {
     static _chunkTool = new ChunkDataTool();

package/Tools/Tasks/TasksTool.d.ts

@@ -1,6 +1,6 @@
-import { BuildTasks, GenerateTasks, Priorities } from "../../Types/Tasks.types.js";
+import { BuildTasks, GenerateTasks, Priorities } from "../../Tasks/Tasks.types";
 import { LocationData } from "../../Math";
-import type { RawVoxelData } from "../../Data/Types/VoxelData.types.js";
+import type { RawVoxelData } from "../../Voxels/Voxel.types.js";
 export type TaskRunModes = "async" | "sync";
 export declare class TaskTool {
     _data: {

package/Tools/Tasks/TasksTool.js

@@ -1,8 +1,8 @@
 import { Threads } from "@amodx/threads/";
 import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
-import { ConstructorRemoteThreadTasks } from "../../Contexts/Constructor/ConstructorRemoteThreadTasks.js";
-import { ConstructorTasksIds } from "../../Contexts/Constructor/ConstructorTasksIds.js";
-import { DVEConstructorTasksQueues } from "../../Contexts/Constructor/DVEConstructorTasksQueues.js";
+import { ConstructorRemoteThreadTasks } from "../../Contexts/Constructor/Tasks/ConstructorRemoteThreadTasks.js";
+import { DVEConstructorTasksQueues } from "../../Contexts/Constructor/Tasks/DVEConstructorTasksQueues.js";
+import { TasksIds } from "../../Tasks/TasksIds.js";
 export class TaskTool {
     _data = {
         dimension: "main",
@@ -28,17 +28,17 @@ export class TaskTool {
     voxelUpdate = {
         update: {
             run: (location, raw, onDone, mode = "sync") => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.VoxelUpdate, [location, raw, this._data.queue, this._thread], [], onDone, mode == "sync" ? 0 : undefined);
+                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.VoxelUpdate, [location, raw, this._data.queue, this._thread], [], onDone, mode == "sync" ? 0 : undefined);
             },
         },
         erase: {
             run: (location, onDone, mode = "sync") => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.VoxelErease, [location, this._data.queue, this._thread], [], onDone, mode == "sync" ? 0 : undefined);
+                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.VoxelErease, [location, this._data.queue, this._thread], [], onDone, mode == "sync" ? 0 : undefined);
             },
         },
         paint: {
             run: (location, raw, onDone, mode = "sync") => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.VoxelPaint, [location, raw, this._data.queue, this._thread], [], onDone, mode == "sync" ? 0 : undefined);
+                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.VoxelPaint, [location, raw, this._data.queue, this._thread], [], onDone, mode == "sync" ? 0 : undefined);
             },
         },
     };
@@ -46,7 +46,7 @@ export class TaskTool {
         chunk: {
             deferred: {
                 run: (buildTasks, onDone) => {
-                    DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.BuildChunk, {
+                    DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.BuildChunk, {
                         data: buildTasks,
                         priority: this._priority,
                     }, [], onDone, undefined, 0);
@@ -78,27 +78,27 @@ export class TaskTool {
             queued: {},
             deferred: {
                 run: (location, onDone) => {
-                    DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.BuildColumn, [location, 1], [], onDone, undefined, 0);
+                    DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.BuildColumn, [location, 1], [], onDone, undefined, 0);
                 },
             },
         },
     };
     explosion = {
         run: (location, radius, onDone) => {
-            DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.Explosion, [location, radius, "", ""], [], onDone, undefined, 0);
+            DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.Explosion, [location, radius, "", ""], [], onDone, undefined, 0);
         },
     };
     anaylzer = {
         update: {
             run: (location, onDone) => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.AnalyzerUpdate, [location, this._data.queue, this._thread], [], onDone, undefined, 0);
+                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.AnalyzerUpdate, [location, this._data.queue, this._thread], [], onDone, undefined, 0);
             },
         },
     };
     propagation = {
         deferred: {
             run: (location, onDone) => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.AnalyzerPropagation, [location, this._data.queue, this._thread], [], onDone, undefined, 0);
+                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.AnalyzerPropagation, [location, this._data.queue, this._thread], [], onDone, undefined, 0);
             },
         },
         queued: {
@@ -125,7 +125,7 @@ export class TaskTool {
     generate = {
         deferred: {
             run(location, data, onDone) {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.Generate, [location, data], [], onDone, undefined, 0);
+                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.Generate, [location, data], [], onDone, undefined, 0);
             },
         },
         queued: {
@@ -152,7 +152,7 @@ export class TaskTool {
     decorate = {
         deferred: {
             run: (location, data, onDone) => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.Decorate, [location, data], [], onDone, undefined, 0);
+                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.Decorate, [location, data], [], onDone, undefined, 0);
             },
         },
         queued: {
@@ -179,7 +179,7 @@ export class TaskTool {
     worldSun = {
         deferred: {
             run: (location, onDone) => {
-                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(ConstructorTasksIds.WorldSun, [location, this._thread], [], onDone, undefined, 0);
+                DVEConstructorTasksQueues.instance.constructors.runPromiseTasks(TasksIds.WorldSun, [location, this._thread], [], onDone, undefined, 0);
             },
         },
         queued: {
@@ -204,11 +204,11 @@ export class TaskTool {
         },
     };
 }
-DVEConstructorTasksQueues.onCreated.subscribe(TaskTool, () => {
-    DVEConstructorTasksQueues.instance.registerTasks("world-sun", ConstructorTasksIds.WorldSun);
-    DVEConstructorTasksQueues.instance.registerTasks("decorate", ConstructorTasksIds.Decorate);
-    DVEConstructorTasksQueues.instance.registerTasks("generate", ConstructorTasksIds.Generate);
-    DVEConstructorTasksQueues.instance.registerTasks("propagation", ConstructorTasksIds.AnalyzerPropagation);
+DVEConstructorTasksQueues.onCreated.subscribe("TaskTool", () => {
+    DVEConstructorTasksQueues.instance.registerTasks("world-sun", TasksIds.WorldSun);
+    DVEConstructorTasksQueues.instance.registerTasks("decorate", TasksIds.Decorate);
+    DVEConstructorTasksQueues.instance.registerTasks("generate", TasksIds.Generate);
+    DVEConstructorTasksQueues.instance.registerTasks("propagation", TasksIds.AnalyzerPropagation);
     const tasks = new TaskTool();
     Threads.registerTasks(ConstructorRemoteThreadTasks.BuildChunk, (data) => {
         tasks.setPriority(data.priority);

package/Voxels/Effects/VoxelEffect.d.ts

@@ -0,0 +1,12 @@
+import { ChunkMesh } from "../../Renderer/Classes/ChunkMesh";
+export interface VoxelEffectConstructor {
+    id: string;
+    new (mesh: ChunkMesh): VoxelEffect;
+}
+export declare abstract class VoxelEffect {
+    mesh: ChunkMesh;
+    constructor(mesh: ChunkMesh);
+    abstract init(): void;
+    abstract setPoints(pointss: Float32Array): void;
+    abstract dispose(): void;
+}

package/Voxels/Effects/VoxelEffect.js

@@ -0,0 +1,6 @@
+export class VoxelEffect {
+    mesh;
+    constructor(mesh) {
+        this.mesh = mesh;
+    }
+}

package/Voxels/Effects/VoxelEffectRegister.d.ts

@@ -0,0 +1,6 @@
+import { VoxelEffectConstructor } from "./VoxelEffect";
+export declare class VoxelEffectRegister {
+    static _effects: Map<string, VoxelEffectConstructor>;
+    static register(...effects: VoxelEffectConstructor[]): void;
+    static get(id: string): VoxelEffectConstructor;
+}

package/Voxels/Effects/VoxelEffectRegister.js

@@ -0,0 +1,15 @@
+export class VoxelEffectRegister {
+    static _effects = new Map();
+    static register(...effects) {
+        for (const e of effects) {
+            this._effects.set(e.id, e);
+        }
+    }
+    static get(id) {
+        const effect = this._effects.get(id);
+        if (!effect) {
+            throw new Error(`Effect with id ${id} does not exist`);
+        }
+        return effect;
+    }
+}

package/Voxels/Effects/VoxelEffects.types.d.ts

@@ -0,0 +1,21 @@
+import { Vec3Array } from "@amodx/math";
+export type VoxelEffectData = {
+    type: "fx-points";
+    effectId: string;
+    values: Record<string, Vec3Array[]>;
+} | {
+    type: "tag";
+    values: Record<string, any>;
+    tagId: string;
+};
+export type VoxelEffectSyncData = {
+    type: "fx-points";
+    effectId: string;
+    tree: any[];
+    treePalette: Vec3Array[][];
+} | {
+    type: "tag";
+    tagId: string;
+    tree: any[];
+    treePalette: any[];
+};

package/{VoxelModels/Rules → Voxels}/Functions/BuildStateData.d.ts

@@ -1,8 +1,10 @@
-import { BinarySchemaNodeData, VoxelRelationsScehmaNodeData, StateLogicStatement } from "../../State/State.types";
-import { VoxelRulesModoel } from "../Classes/VoxelRulesModel";
-import { StringPalette } from "../../../Interfaces/Data/StringPalette";
+import { BinarySchemaNodeData, VoxelRelationsScehmaNodeData, StateLogicStatement } from "../State/State.types";
+import { VoxelRulesModoel } from "../../Models/Rules/Classes/VoxelRulesModel";
+import { StringPalette } from "../../Util/StringPalette";
+import { VoxelEffectSyncData } from "../Effects/VoxelEffects.types";
 export declare function BuildStateData(model: VoxelRulesModoel, geoPalette: StringPalette): {
     schema: (BinarySchemaNodeData | VoxelRelationsScehmaNodeData)[];
+    effects: VoxelEffectSyncData[];
     shapeStateGeometryPalette: number[][];
     condiotnalShapeStateGeometryPalette: number[][];
     shapeStateTree: any[];