@divinevoxel/vlox 0.0.75 → 0.0.77

package/Voxels/Models/Rules/Functions/Compile/Nodes/CompileQuadGeometryNode.js

@@ -1,7 +1,7 @@
 import { Quad } from "../../../../../../Mesher/Geomtry/Primitives/Quad";
 import { getQuadWeights, mapQuadUvs } from "./CalcFunctions";
 import { TransformQuad } from "../../../../../../Mesher/Geomtry/Transform/TransformQuad";
-import { QuadVoxelGometryInputs, } from "../../../../../../Mesher/Models/Nodes/Types/QuadVoxelGometryNodeTypes";
+import { QuadVoxelGometryInputs, } from "../../../../../../Mesher/Voxels/Models/Nodes/Types/QuadVoxelGometryNodeTypes";
 import { OcclusionFaceRegister } from "../../../Classes/OcclusionFaceRegister";
 import { closestVoxelFace } from "../../../../../../Math/UtilFunctions";
 export function CompileQuadGeometryNode(buildRules, input, points, node, transform = {}) {

package/Voxels/Models/Rules/Functions/Compile/Nodes/CompileTriangleGeometryNode.d.ts

@@ -1,6 +1,6 @@
 import { Vec3Array } from "@amodx/math";
 import { VoxelGeometryTransform } from "../../../../../../Mesher/Geomtry/Geometry.types";
-import { CompiledTriangleVoxelGeomtryNode } from "../../../../../../Mesher/Models/Nodes/Types/TriangleVoxelGometryNodeTypes";
+import { CompiledTriangleVoxelGeomtryNode } from "../../../../../../Mesher/Voxels/Models/Nodes/Types/TriangleVoxelGometryNodeTypes";
 import { GeomtryInput } from "../../../Classes/GeomtryInput";
 import { BaseVoxelTriangleData } from "../../../../VoxelModel.types";
 export declare function CompileTriangleGeometryNode(buildRules: boolean, input: GeomtryInput, points: [Vec3Array, Vec3Array, Vec3Array], node: BaseVoxelTriangleData, transform?: VoxelGeometryTransform): CompiledTriangleVoxelGeomtryNode;

package/Voxels/Models/Rules/Functions/Compile/Nodes/CompileTriangleGeometryNode.js

@@ -1,7 +1,7 @@
 import { Triangle } from "../../../../../../Mesher/Geomtry/Primitives/Triangle";
 import { getVertexWeights } from "./CalcFunctions";
 import { TransformTriangle } from "../../../../../../Mesher/Geomtry/Transform/TransformTriangle";
-import { TriangleVoxelGometryInputs, } from "../../../../../../Mesher/Models/Nodes/Types/TriangleVoxelGometryNodeTypes";
+import { TriangleVoxelGometryInputs, } from "../../../../../../Mesher/Voxels/Models/Nodes/Types/TriangleVoxelGometryNodeTypes";
 import { OcclusionFaceRegister } from "../../../Classes/OcclusionFaceRegister";
 import { closestVoxelFace } from "../../../../../../Math/UtilFunctions";
 export function CompileTriangleGeometryNode(buildRules, input, points, node, transform) {

package/Voxels/Models/VoxelModel.types.d.ts

@@ -51,6 +51,11 @@ export interface VoxelTriangleGeometryNode extends BaseVoxelTriangleData {
 export interface VoxelGeometryTextureArgument {
     type: "texture";
 }
+/**Creates a way to set multiple arguments to the same thing. What ever value is passed in will be passed to the arguments. */
+export interface VoxelGeometryArgumentAliasList {
+    type: "arg-list";
+    arguments: string[];
+}
 export interface VoxelGeometryBooleanArgument {
     type: "boolean";
     default: boolean;
@@ -103,7 +108,7 @@ export interface VoxelGeometryData {
      * Define the culling procedure for faces
      */
     cullingProcedure?: CullingProcedureData;
-    arguments: Record<string, VoxelGeometryTextureArgument | VoxelGeometryBoxUVArgument | VoxelGeometryUVArgument | VoxelGeometryVector3Argument | VoxelGeometryIntArgument | VoxelGeometryBooleanArgument | VoxelGeometryFloatArgument>;
+    arguments: Record<string, VoxelGeometryTextureArgument | VoxelGeometryBoxUVArgument | VoxelGeometryUVArgument | VoxelGeometryVector3Argument | VoxelGeometryIntArgument | VoxelGeometryBooleanArgument | VoxelGeometryFloatArgument | VoxelGeometryArgumentAliasList>;
 }
 export interface VoxelGeometryLinkData {
     geometryId: string;

package/Voxels/State/Schema/BinarySchemaNode.d.ts

@@ -1,7 +1,8 @@
 import { StringPalette } from "../../../Util/StringPalette";
 import { VoxelBinaryStateSchemaNode } from "../State.types";
 export declare class BinarySchemaNode {
-    name: string;
+    readonly data: VoxelBinaryStateSchemaNode;
+    get name(): string;
     valuePalette?: StringPalette;
     bitIndex: number;
     bitMask: number;

package/Voxels/State/Schema/BinarySchemaNode.js

@@ -1,11 +1,14 @@
 import { StringPalette } from "../../../Util/StringPalette";
 export class BinarySchemaNode {
-    name;
+    data;
+    get name() {
+        return this.data.name;
+    }
     valuePalette;
     bitIndex = 0;
     bitMask = 0;
     constructor(data) {
-        this.name = data.name;
+        this.data = data;
         this.bitIndex = data.bitIndex;
         this.bitMask = (1 << data.bitSize) - 1;
         if (data.values)

package/Voxels/State/Schema/Conditions/SameVoxelConditions.js

@@ -9,6 +9,8 @@ export class SameVoxelCondition extends ShapeStateSchemaRelationsCondition {
         const nx = this.schema.position.x + this.data.direction[0];
         const ny = this.schema.position.y + this.data.direction[1];
         const nz = this.schema.position.z + this.data.direction[2];
+        if (!this.schema.dataCursor.inBounds(nx, ny, nz))
+            return false;
         const nVoxel = this.schema.dataCursor.getVoxel(nx, ny, nz);
         if (!nVoxel)
             return false;

package/Voxels/Types/PaintVoxelData.d.ts

@@ -2,16 +2,28 @@ import { RawVoxelData } from "./Voxel.types";
 export declare class PaintVoxelData {
     id: string;
     name: string;
-    mod: number;
     state: number;
+    stateString: string;
+    mod: number;
+    modString: string;
     level: number;
     levelState: number;
     secondaryVoxelId: string;
     secondaryName: string;
     secondaryMod: number;
+    secondaryModString: string;
     secondaryState: number;
+    secondaryStateString: string;
     static Create(data?: Partial<PaintVoxelData>): PaintVoxelData;
+    /**Transforms numeric voxel data into a PaintVoxelData object */
     static FromRaw(data: RawVoxelData, paintData?: PaintVoxelData): PaintVoxelData;
+    /**Transforms the voxel data into numeric voxel data */
     static ToRaw(data: Partial<PaintVoxelData>, light?: number): RawVoxelData;
+    /**Restores the data to the default state of being dve_air */
+    static Clear(data: PaintVoxelData): PaintVoxelData;
+    /**Clears the target data and then copies properties from source to target. */
+    static Set(target: PaintVoxelData, source: Partial<PaintVoxelData>): PaintVoxelData;
+    /**Takes PaintVoxelData and convert mod and state strings to numbers and then */
+    static Populate(data: Partial<PaintVoxelData>): Partial<PaintVoxelData>;
     private constructor();
 }

package/Voxels/Types/PaintVoxelData.js

@@ -1,19 +1,25 @@
 import { VoxelPalettesRegister } from "../Data/VoxelPalettesRegister";
 import { VoxelLevelReader } from "../Cursor/VoxelLevelReader";
+import { SchemaRegister } from "../../Voxels/State/SchemaRegister";
 export class PaintVoxelData {
     id;
     name;
-    mod;
     state;
+    stateString;
+    mod;
+    modString;
     level;
     levelState;
     secondaryVoxelId;
     secondaryName;
     secondaryMod;
+    secondaryModString;
     secondaryState;
+    secondaryStateString;
     static Create(data = {}) {
-        return new PaintVoxelData(data.id, data.name, data.mod, data.state, data.level, data.levelState, data.secondaryVoxelId, data.secondaryName, data.secondaryMod, data.secondaryState);
+        return new PaintVoxelData(data.id, data.name, data.state, data.stateString, data.mod, data.modString, data.level, data.levelState, data.secondaryVoxelId, data.secondaryName, data.secondaryMod, data.secondaryModString, data.secondaryState, data.secondaryModString);
     }
+    /**Transforms numeric voxel data into a PaintVoxelData object */
     static FromRaw(data, paintData = PaintVoxelData.Create()) {
         const [trueVoxelId, state, mod] = VoxelPalettesRegister.voxels[data[0]];
         paintData.id = VoxelPalettesRegister.voxelIds.getStringId(trueVoxelId);
@@ -34,23 +40,48 @@ export class PaintVoxelData {
         paintData.levelState = VoxelLevelReader.getLevel(data[2]);
         return paintData;
     }
+    /**Transforms the voxel data into numeric voxel data */
     static ToRaw(data, light = 0) {
         let stringId = data.id
             ? data.id
             : data.name
                 ? VoxelPalettesRegister.voxelNametoIdMap.get(data.name)
                 : "dve_air";
-        let secondaryStringId = data.id
-            ? data.id
-            : data.name
-                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.name)
+        let secondaryStringId = data.secondaryName
+            ? data.secondaryVoxelId
+            : data.secondaryName
+                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.secondaryName)
                 : "dve_air";
-        const id = (stringId !== "dve_air" &&
-            VoxelPalettesRegister.getVoxelIdFromString(stringId, data.state || 0, data.mod || 0)) ||
-            0;
-        const secondaryId = (secondaryStringId !== "dve_air" &&
-            VoxelPalettesRegister.getVoxelIdFromString(secondaryStringId, data.secondaryState || 0, data.secondaryMod || 0)) ||
-            0;
+        let state = data.state || 0;
+        let mod = data.mod || 0;
+        let secondaryState = data.secondaryState || 0;
+        let secondaryMod = data.secondaryMod || 0;
+        if (SchemaRegister.hasVoxelSchema(stringId)) {
+            const schema = SchemaRegister.getVoxelSchemas(stringId);
+            if (data.stateString && data.stateString !== "") {
+                state = schema.state.readString(data.stateString);
+            }
+            if (data.modString && data.modString !== "") {
+                mod = schema.mod.readString(data.modString);
+            }
+        }
+        if (secondaryStringId && SchemaRegister.hasVoxelSchema(secondaryStringId)) {
+            const schema = SchemaRegister.getVoxelSchemas(secondaryStringId);
+            if (data.secondaryStateString && data.secondaryStateString !== "") {
+                secondaryState = schema.state.readString(data.secondaryStateString);
+            }
+            if (data.secondaryModString && data.secondaryModString !== "") {
+                secondaryMod = schema.mod.readString(data.secondaryModString);
+            }
+        }
+        const id = stringId !== "dve_air"
+            ? VoxelPalettesRegister.getVoxelIdFromString(stringId, state || 0, mod || 0)
+            : 0;
+        const secondaryId = secondaryStringId !== "dve_air"
+            ? secondaryStringId
+                ? VoxelPalettesRegister.getVoxelIdFromString(secondaryStringId, secondaryState || 0, secondaryMod || 0)
+                : 0
+            : 0;
         let levleData = 0;
         if (data.level !== undefined)
             levleData = VoxelLevelReader.setLevel(levleData, data.level);
@@ -58,16 +89,122 @@ export class PaintVoxelData {
             levleData = VoxelLevelReader.setLevelState(levleData, data.levelState);
         return [id, light, levleData, secondaryId];
     }
-    constructor(id = "dve_air", name = "", mod = 0, state = 0, level = 0, levelState = 0, secondaryVoxelId = "dve_air", secondaryName = "", secondaryMod = 0, secondaryState = 0) {
+    /**Restores the data to the default state of being dve_air */
+    static Clear(data) {
+        data.id = "dve_air";
+        data.name = "";
+        data.state = 0;
+        data.stateString = "";
+        data.mod = 0;
+        data.modString = "";
+        data.level = 0;
+        data.levelState = 0;
+        data.secondaryVoxelId = "dve_air";
+        data.secondaryName = "";
+        data.secondaryMod = 0;
+        data.secondaryModString = "";
+        data.secondaryState = 0;
+        data.secondaryStateString = "";
+        return data;
+    }
+    /**Clears the target data and then copies properties from source to target. */
+    static Set(target, source) {
+        PaintVoxelData.Clear(target);
+        if (source.id !== undefined)
+            target.id = source.id;
+        if (source.name !== undefined)
+            target.name = source.name;
+        if (source.state !== undefined)
+            target.state = source.state;
+        if (source.stateString !== undefined)
+            target.stateString = source.stateString;
+        if (source.mod !== undefined)
+            target.mod = source.mod;
+        if (source.modString !== undefined)
+            target.modString = source.modString;
+        if (source.level !== undefined)
+            target.level = source.level;
+        if (source.levelState !== undefined)
+            target.levelState = source.levelState;
+        if (source.secondaryVoxelId !== undefined)
+            target.secondaryVoxelId = source.secondaryVoxelId;
+        if (source.secondaryName !== undefined)
+            target.secondaryName = source.secondaryName;
+        if (source.secondaryMod !== undefined)
+            target.secondaryMod = source.secondaryMod;
+        if (source.secondaryModString !== undefined)
+            target.secondaryModString = source.secondaryModString;
+        if (source.secondaryState !== undefined)
+            target.secondaryState = source.secondaryState;
+        if (source.secondaryStateString !== undefined)
+            target.secondaryStateString = source.secondaryStateString;
+        return target;
+    }
+    /**Takes PaintVoxelData and convert mod and state strings to numbers and then */
+    static Populate(data) {
+        let stringId = data.id
+            ? data.id
+            : data.name
+                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.name)
+                : "dve_air";
+        let secondaryStringId = data.secondaryName
+            ? data.secondaryVoxelId
+            : data.secondaryName
+                ? VoxelPalettesRegister.voxelNametoIdMap.get(data.secondaryName)
+                : "dve_air";
+        if (data.name && !data.id) {
+            data.id = VoxelPalettesRegister.voxelNametoIdMap.get(data.name);
+        }
+        if (!data.name && !data.id) {
+            data.id = "dve_air";
+        }
+        delete data.name;
+        let state = data.state || 0;
+        let mod = data.mod || 0;
+        if (SchemaRegister.hasVoxelSchema(stringId)) {
+            const schema = SchemaRegister.getVoxelSchemas(stringId);
+            if (data.stateString && data.stateString !== "") {
+                state = schema.state.readString(data.stateString);
+            }
+            if (data.modString && data.modString !== "") {
+                mod = schema.mod.readString(data.modString);
+            }
+        }
+        data.state = state;
+        data.mod = mod;
+        delete data.stateString;
+        delete data.modString;
+        let secondaryState = data.secondaryState || 0;
+        let secondaryMod = data.secondaryMod || 0;
+        if (secondaryStringId && SchemaRegister.hasVoxelSchema(secondaryStringId)) {
+            const schema = SchemaRegister.getVoxelSchemas(secondaryStringId);
+            if (data.secondaryStateString && data.secondaryStateString !== "") {
+                secondaryState = schema.state.readString(data.secondaryStateString);
+            }
+            if (data.secondaryModString && data.secondaryModString !== "") {
+                secondaryMod = schema.mod.readString(data.secondaryModString);
+            }
+        }
+        data.secondaryState = secondaryState;
+        data.secondaryMod = secondaryMod;
+        delete data.secondaryModString;
+        delete data.secondaryStateString;
+        return data;
+    }
+    constructor(id = "dve_air", name = "", state = 0, stateString = "", mod = 0, modString = "", level = 0, levelState = 0, secondaryVoxelId = "dve_air", secondaryName = "", secondaryMod = 0, secondaryModString = "", secondaryState = 0, secondaryStateString = "") {
         this.id = id;
         this.name = name;
-        this.mod = mod;
         this.state = state;
+        this.stateString = stateString;
+        this.mod = mod;
+        this.modString = modString;
         this.level = level;
         this.levelState = levelState;
         this.secondaryVoxelId = secondaryVoxelId;
         this.secondaryName = secondaryName;
         this.secondaryMod = secondaryMod;
+        this.secondaryModString = secondaryModString;
         this.secondaryState = secondaryState;
+        this.secondaryStateString = secondaryStateString;
     }
 }

package/World/Archive/Functions/Shared/LightSegments.d.ts

@@ -2,4 +2,4 @@ import { ArchivedLightSegments } from "../../Types/Archive.types";
 export declare const lightSegments: ArchivedLightSegments[];
 export declare const lightSemgnetGet: Record<ArchivedLightSegments, (value: number) => number>;
 export declare const lightSemgnetSet: Record<ArchivedLightSegments, (value: number, source: number) => number>;
-export declare function getLightBuffer(light: ArchivedLightSegments, buffer: Uint16Array): Uint8Array;
+export declare function getLightBuffer(light: ArchivedLightSegments, buffer: Uint16Array): Uint8Array<ArrayBuffer>;

package/World/Cursor/SectionCursor.d.ts

@@ -3,12 +3,16 @@ import { Vector3Like } from "@amodx/math";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
 import type { Section } from "../Section/index";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export declare class SectionCursor implements WorldSectionCursorInterface, DataCursorInterface {
     _section: Section | null;
     private voxel;
     _voxelIndex: number;
     _voxelPosition: Vector3Like;
     _sectionPosition: Vector3Like;
+    volumeBounds: BoundingBox;
+    get volumePosition(): Vector3Like;
+    constructor();
     inBounds(x: number, y: number, z: number): boolean;
     setSection(section: Section): void;
     loadSection(dimension: number, x: number, y: number, z: number): boolean;

package/World/Cursor/SectionCursor.js

@@ -2,29 +2,26 @@ import { WorldRegister } from "../WorldRegister";
 import { WorldVoxelCursor } from "./WorldVoxelCursor";
 import { WorldSpaces } from "../WorldSpaces";
 import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+const point = Vector3Like.Create();
 export class SectionCursor {
     _section;
     voxel = new WorldVoxelCursor(this);
     _voxelIndex = 0;
     _voxelPosition = Vector3Like.Create();
     _sectionPosition = Vector3Like.Create();
+    volumeBounds = new BoundingBox();
+    get volumePosition() {
+        return this._sectionPosition;
+    }
+    constructor() {
+        this.volumeBounds.setMinMax(Vector3Like.Create(0, 0, 0), Vector3Like.Create(WorldSpaces.section.bounds.x, WorldSpaces.section.bounds.y, WorldSpaces.section.bounds.z));
+    }
     inBounds(x, y, z) {
-        const maxX = this._sectionPosition.x + WorldSpaces.section.bounds.x;
-        const maxY = this._sectionPosition.y + WorldSpaces.section.bounds.y;
-        const maxZ = this._sectionPosition.z + WorldSpaces.section.bounds.z;
-        if (x < this._sectionPosition.x)
-            return false;
-        if (y < this._sectionPosition.y)
-            return false;
-        if (z < this._sectionPosition.z)
-            return false;
-        if (x > maxX)
-            return false;
-        if (y > maxY)
-            return false;
-        if (z > maxZ)
-            return false;
-        return true;
+        point.x = x - this._sectionPosition.x + 0.5;
+        point.y = y - this._sectionPosition.y + 0.5;
+        point.z = z - this._sectionPosition.z + 0.5;
+        return this.volumeBounds.intersectsPoint(point);
     }
     setSection(section) {
         this._section = section;

package/World/Cursor/SectorCursor.d.ts

@@ -4,6 +4,7 @@ import { WorldVoxelCursor } from "./WorldVoxelCursor";
 import { Vector3Like } from "@amodx/math";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { WorldSectionCursorInterface } from "./WorldSectionCursor.interface";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export declare class SectorCursor implements DataCursorInterface, WorldSectionCursorInterface {
     _current: Sector | null;
     _section: Section | null;
@@ -11,6 +12,9 @@ export declare class SectorCursor implements DataCursorInterface, WorldSectionCu
     _voxelIndex: number;
     _voxelPosition: Vector3Like;
     _sectorPosition: Vector3Like;
+    volumeBounds: BoundingBox;
+    get volumePosition(): Vector3Like;
+    constructor();
     inBounds(x: number, y: number, z: number): boolean;
     setSector(sector: Sector): boolean;
     loadSector(dimension: number, x: number, y: number, z: number): boolean;

package/World/Cursor/SectorCursor.js

@@ -2,6 +2,8 @@ import { WorldRegister } from "../WorldRegister";
 import { WorldVoxelCursor } from "./WorldVoxelCursor";
 import { WorldSpaces } from "../WorldSpaces";
 import { Vector3Like } from "@amodx/math";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
+const point = Vector3Like.Create();
 export class SectorCursor {
     _current = null;
     _section;
@@ -9,23 +11,18 @@ export class SectorCursor {
     _voxelIndex = 0;
     _voxelPosition = Vector3Like.Create();
     _sectorPosition = Vector3Like.Create();
+    volumeBounds = new BoundingBox();
+    get volumePosition() {
+        return this._sectorPosition;
+    }
+    constructor() {
+        this.volumeBounds.setMinMax(Vector3Like.Create(0, 0, 0), Vector3Like.Create(WorldSpaces.sector.bounds.x, WorldSpaces.sector.bounds.y, WorldSpaces.sector.bounds.z));
+    }
     inBounds(x, y, z) {
-        const maxX = this._sectorPosition.x + WorldSpaces.sector.bounds.x;
-        const maxY = this._sectorPosition.y + WorldSpaces.sector.bounds.y;
-        const maxZ = this._sectorPosition.z + WorldSpaces.sector.bounds.z;
-        if (x < this._sectorPosition.x)
-            return false;
-        if (y < this._sectorPosition.y)
-            return false;
-        if (z < this._sectorPosition.z)
-            return false;
-        if (x > maxX)
-            return false;
-        if (y > maxY)
-            return false;
-        if (z > maxZ)
-            return false;
-        return true;
+        point.x = x - this._sectorPosition.x + 0.5;
+        point.y = y - this._sectorPosition.y + 0.5;
+        point.z = z - this._sectorPosition.z + 0.5;
+        return this.volumeBounds.intersectsPoint(point);
     }
     setSector(sector) {
         this._current = sector;

package/World/Cursor/WorldCursor.d.ts

@@ -1,11 +1,15 @@
 import { Vector3Like } from "@amodx/math";
 import { SectorCursor } from "./SectorCursor";
 import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export declare class WorldCursor implements DataCursorInterface {
+    volumeBounds: BoundingBox;
     sectorCursors: Record<number, Record<number, SectorCursor | null>>;
     origin: Vector3Like;
     dimension: number;
     _lastPosition: Vector3Like;
+    constructor();
+    private updateBounds;
     setFocalPoint(dimension: number, x: number, y: number, z: number): void;
     inBounds(x: number, y: number, z: number): boolean;
     getSector(x: number, y: number, z: number): SectorCursor | null;

package/World/Cursor/WorldCursor.js

@@ -1,13 +1,21 @@
 import { Vector3Like } from "@amodx/math";
 import { SectorCursor } from "./SectorCursor";
 import { WorldSpaces } from "../WorldSpaces";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 let cursorCache = [];
 const tempPosition = Vector3Like.Create();
 export class WorldCursor {
+    volumeBounds = new BoundingBox();
     sectorCursors = {};
     origin = Vector3Like.Create();
     dimension = 0;
     _lastPosition = Vector3Like.Create();
+    constructor() {
+        this.updateBounds();
+    }
+    updateBounds() {
+        this.volumeBounds.setMinMax(Vector3Like.Create(WorldSpaces.world.bounds.MinX, WorldSpaces.world.bounds.MinY, WorldSpaces.world.bounds.MinZ), Vector3Like.Create(WorldSpaces.world.bounds.MaxX, WorldSpaces.world.bounds.MaxY, WorldSpaces.world.bounds.MaxZ));
+    }
     setFocalPoint(dimension, x, y, z) {
         const sectorPos = WorldSpaces.sector.getPosition(x, y, z, tempPosition);
         for (const row in this.sectorCursors) {

package/World/Sector/Sector.d.ts

@@ -16,7 +16,7 @@ export declare class Sector {
     static TimeStampIds: typeof import("./SectorState.js").SectorStateDefaultTimeStamps;
     static GetHeaderSize(): number;
     static GetBufferSize(): number;
-    static CreateNewBuffer(): ArrayBuffer;
+    static CreateNewBuffer(): ArrayBuffer | SharedArrayBuffer;
     sections: Section[];
     bufferView: Uint8Array;
     position: Vec3Array;

package/World/Sector/SectorHeightMap.d.ts

@@ -1,5 +1,11 @@
 import { LocationData } from "../../Math";
 export declare class SectorHeightMap {
+    /**
+     * Gets the relative height of the sector. Meaning will get the tallest sector in a square around it.
+     */
     static getRelative(location: LocationData): number;
+    /**
+     * Gets the exact heigh of the single sector.
+     */
     static getAbsolute(dimension: number, x: number, sy: number, z: number): number;
 }

package/World/Sector/SectorHeightMap.js

@@ -2,6 +2,9 @@ import { MooreNeighborhood2D } from "../../Math/CardinalNeighbors";
 import { WorldRegister } from "../WorldRegister";
 import { WorldSpaces } from "../WorldSpaces";
 export class SectorHeightMap {
+    /**
+     * Gets the relative height of the sector. Meaning will get the tallest sector in a square around it.
+     */
     static getRelative(location) {
         location = [...location];
         const sectionWidth = WorldSpaces.section.bounds.x;
@@ -18,6 +21,9 @@ export class SectorHeightMap {
         }
         return maxHeight;
     }
+    /**
+     * Gets the exact heigh of the single sector.
+     */
     static getAbsolute(dimension, x, sy, z) {
         const sector = WorldRegister.sectors.get(dimension, x, sy, z);
         if (!sector)

package/World/SnapShot/SectionSnapShotCursor.d.ts

@@ -4,14 +4,17 @@ import { SectionSnapShot } from "./SectionSnapShot";
 import { Sector } from "../Sector";
 import { SectorCursor } from "../Cursor/SectorCursor";
 import { SectionCursor } from "../Cursor/SectionCursor";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 export declare class SectionSnapshotCursor implements DataCursorInterface {
     origin: Vector3Like;
     sectorOrigin: Vector3Like;
     dimension: number;
+    volumeBounds: BoundingBox;
     sectors: Sector[];
     cursors: SectorCursor[];
     index: Flat3DIndex;
     constructor();
+    private updateBounds;
     private _snapShot;
     private _centeralCursor;
     getCenteralCursor(): SectionCursor | null;

package/World/SnapShot/SectionSnapShotCursor.js

@@ -3,11 +3,13 @@ import { WorldSpaces } from "../WorldSpaces";
 import { Sector } from "../Sector";
 import { SectorCursor } from "../Cursor/SectorCursor";
 import { SectionCursor } from "../Cursor/SectionCursor";
+import { BoundingBox } from "@amodx/math/Geomtry/Bounds/BoundingBox";
 const tempPosition = Vector3Like.Create();
 export class SectionSnapshotCursor {
     origin = Vector3Like.Create();
     sectorOrigin = Vector3Like.Create();
     dimension = 0;
+    volumeBounds = new BoundingBox();
     sectors = [];
     cursors = [];
     index = Flat3DIndex.GetXYZOrder();
@@ -29,6 +31,10 @@ export class SectionSnapshotCursor {
                 }
             }
         }
+        this.updateBounds();
+    }
+    updateBounds() {
+        this.volumeBounds.setMinMax(Vector3Like.Create(WorldSpaces.world.bounds.MinX, WorldSpaces.world.bounds.MinY, WorldSpaces.world.bounds.MinZ), Vector3Like.Create(WorldSpaces.world.bounds.MaxX, WorldSpaces.world.bounds.MaxY, WorldSpaces.world.bounds.MaxZ));
     }
     _snapShot;
     _centeralCursor = new SectionCursor();

package/World/WorldSpaces.js

@@ -137,13 +137,13 @@ class VoxelSpace {
 }
 class Hash {
     static hashVec3(vector3) {
-        return `${vector3.x}-${vector3.y}-${vector3.z}`;
+        return `${vector3.x}_${vector3.y}_${vector3.z}`;
     }
     static hashVec3Array(vector3) {
-        return `${vector3[0]}-${vector3[1]}-${vector3[2]}`;
+        return `${vector3[0]}_${vector3[1]}_${vector3[2]}`;
     }
     static hashXYZ(x, y, z) {
-        return `${x}-${y}-${z}`;
+        return `${x}_${y}_${z}`;
     }
 }
 export class WorldSpaces {

package/WorldSimulation/Dimensions/DimensionSimulation.d.ts

@@ -1,22 +1,26 @@
+import { VoxelFaces } from "../../Math";
 import { WorldCursor } from "../../World/Cursor/WorldCursor";
 import { DimensionSegment } from "./DimensionSegment";
 import { Vector3Like } from "@amodx/math";
 import { PriorityQueue } from "../../Util/PriorityQueue";
 import { VoxelUpdate } from "../Voxels/Behaviors";
+import { SimulationBrush } from "../Tools/SimulationBrush";
 declare class UpdatedBounds {
     displayMin: Vector3Like;
     displayMax: Vector3Like;
     dimension: number;
     start(dimension?: number): void;
     updateDisplay(x: number, y: number, z: number): void;
-    markDisplayDirty(): false | undefined;
+    markDisplayDirty(): boolean;
 }
 export declare class DimensionSimulation {
     dimension: DimensionSegment;
     private cursor;
     nDataCursor: WorldCursor;
     sDataCursor: WorldCursor;
+    tickCursor: Record<VoxelFaces, WorldCursor>;
     bounds: UpdatedBounds;
+    brush: SimulationBrush;
     updateQueue: PriorityQueue<VoxelUpdate>;
     constructor(dimension: DimensionSegment);
     setOrigin(x: number, y: number, z: number): void;