@divinevoxel/vlox 0.0.80 → 0.0.81

package/Builder/Tools/Brush/BrushTool.d.ts

@@ -1,9 +1,9 @@
 import { VoxelBuildSpace } from "../../VoxelBuildSpace";
 import { VoxelShapeTemplate } from "../../../Templates/Shapes/VoxelShapeTemplate";
-import { VoxelPickResult } from "../../../Voxels/Interaction/VoxelPickResult";
 import { Vector3Like } from "@amodx/math";
 import { PaintVoxelData } from "../../../Voxels";
 import { BuilderToolBase, ToolOptionsData } from "../BuilderToolBase";
+import { FreePointSelection } from "../../Util/FreePointSelection";
 export declare enum BrushPositionModes {
     Start = "Start",
     Center = "Center",
@@ -14,6 +14,10 @@ export declare enum BrushToolModes {
     Extrude = "Extrude",
     Remove = "Remove"
 }
+export declare enum BrushToolSelectionPositionModes {
+    Surface = "Surface",
+    Free = "Free"
+}
 type BrushVoxelData = {
     fill: PaintVoxelData;
     face: PaintVoxelData;
@@ -26,6 +30,7 @@ interface BrushToolEvents {
 export declare class BrushTool extends BuilderToolBase<BrushToolEvents> {
     static ToolId: string;
     static ModeArray: BrushToolModes[];
+    static PositionTypeModeArray: BrushToolSelectionPositionModes[];
     static PositionModeArray: BrushPositionModes[];
     static get ShapesArray(): string[];
     static ShapeCreators: Record<string, () => VoxelShapeTemplate>;
@@ -36,6 +41,11 @@ export declare class BrushTool extends BuilderToolBase<BrushToolEvents> {
     axisYPositionMode: BrushPositionModes;
     axisZPositionMode: BrushPositionModes;
     mode: BrushToolModes;
+    positionMode: BrushToolSelectionPositionModes;
+    private pointSelection;
+    freeSelection: FreePointSelection;
+    get distance(): number;
+    set distance(distance: number);
     template: VoxelShapeTemplate;
     get selection(): import("../../../Templates/Shapes/Selections/VoxelShapeSelection").IVoxelShapeSelection<any, import("../../../Templates/Shapes/Selections/VoxelShapeSelection").IVoxelShapeSelectionData<any>>;
     voxelData: Partial<BrushVoxelData>;
@@ -46,7 +56,7 @@ export declare class BrushTool extends BuilderToolBase<BrushToolEvents> {
     update(): Promise<void>;
     cancel(): void;
     use(): Promise<void>;
-    protected getPlacePosition(picked: VoxelPickResult): Vector3Like;
+    protected getPlacePosition(position: Vector3Like): Vector3Like;
     updateShape(shape: string): void;
     getOptionValue(property: string): any;
     getCurrentOptions(): ToolOptionsData;

package/Builder/Tools/Brush/BrushTool.js

@@ -5,6 +5,8 @@ import { PyramidVoxelShapeSelection } from "../../../Templates/Shapes/Selections
 import { EllipsoidVoxelShapeSelection } from "../../../Templates/Shapes/Selections/EllipsoidVoxelShapeSelection";
 import { Vector3Like } from "@amodx/math";
 import { BuilderToolBase } from "../BuilderToolBase";
+import { FreePointSelection } from "../../Util/FreePointSelection";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
 export var BrushPositionModes;
 (function (BrushPositionModes) {
     BrushPositionModes["Start"] = "Start";
@@ -17,6 +19,11 @@ export var BrushToolModes;
     BrushToolModes["Extrude"] = "Extrude";
     BrushToolModes["Remove"] = "Remove";
 })(BrushToolModes || (BrushToolModes = {}));
+export var BrushToolSelectionPositionModes;
+(function (BrushToolSelectionPositionModes) {
+    BrushToolSelectionPositionModes["Surface"] = "Surface";
+    BrushToolSelectionPositionModes["Free"] = "Free";
+})(BrushToolSelectionPositionModes || (BrushToolSelectionPositionModes = {}));
 export class BrushTool extends BuilderToolBase {
     static ToolId = "Brush";
     static ModeArray = [
@@ -24,6 +31,10 @@ export class BrushTool extends BuilderToolBase {
         BrushToolModes.Extrude,
         BrushToolModes.Remove,
     ];
+    static PositionTypeModeArray = [
+        BrushToolSelectionPositionModes.Surface,
+        BrushToolSelectionPositionModes.Free,
+    ];
     static PositionModeArray = [
         BrushPositionModes.Start,
         BrushPositionModes.Center,
@@ -198,6 +209,15 @@ export class BrushTool extends BuilderToolBase {
     axisYPositionMode = BrushPositionModes.Center;
     axisZPositionMode = BrushPositionModes.Center;
     mode = BrushToolModes.Fill;
+    positionMode = BrushToolSelectionPositionModes.Surface;
+    pointSelection = new VoxelPointSelection();
+    freeSelection = new FreePointSelection(this.space, this.pointSelection);
+    get distance() {
+        return this.freeSelection.distance;
+    }
+    set distance(distance) {
+        this.freeSelection.distance = distance;
+    }
     template;
     get selection() {
         return this.template.shapeSelection;
@@ -211,23 +231,32 @@ export class BrushTool extends BuilderToolBase {
         this.updateShape(this.shape);
     }
     async update() {
-        this._lastPicked = await this.space.pickWithProvider(this.rayProviderIndex);
-        if (!this._lastPicked)
-            return;
-        if (this.mode == BrushToolModes.Fill ||
-            this.mode == BrushToolModes.Extrude) {
-            if (!this.space.bounds.intersectsPoint(this._lastPicked.normalPosition)) {
-                this._lastPicked = null;
+        let place = null;
+        if (this.positionMode == BrushToolSelectionPositionModes.Surface) {
+            this._lastPicked = await this.space.pickWithProvider(this.rayProviderIndex);
+            if (!this._lastPicked)
                 return;
+            if (this.mode == BrushToolModes.Fill ||
+                this.mode == BrushToolModes.Extrude) {
+                if (!this.space.bounds.intersectsPoint(this._lastPicked.normalPosition)) {
+                    this._lastPicked = null;
+                    return;
+                }
             }
-        }
-        if (this.mode == BrushToolModes.Remove) {
-            if (!this.space.bounds.intersectsPoint(this._lastPicked.position)) {
-                this._lastPicked = null;
-                return;
+            if (this.mode == BrushToolModes.Remove) {
+                if (!this.space.bounds.intersectsPoint(this._lastPicked.position)) {
+                    this._lastPicked = null;
+                    return;
+                }
             }
+            place = this.getPlacePosition(this._lastPicked.normalPosition);
         }
-        const place = this.getPlacePosition(this._lastPicked);
+        if (this.positionMode == BrushToolSelectionPositionModes.Free) {
+            this.freeSelection.update();
+            place = this.getPlacePosition(this.pointSelection.origin);
+        }
+        if (!place)
+            return;
         this.placePosition.x = place.x;
         this.placePosition.y = place.y;
         this.placePosition.z = place.z;
@@ -248,9 +277,9 @@ export class BrushTool extends BuilderToolBase {
                     this.voxelData.fill = newData;
             }
         }
+        const place = this.placePosition;
         if (this.mode == BrushToolModes.Fill && this.voxelData.fill) {
             this.template.setVoxels(this.voxelData.fill);
-            const place = this.getPlacePosition(this._lastPicked);
             await this.space.paintTemplate([place.x, place.y, place.z], this.template.toJSON());
             return;
         }
@@ -262,51 +291,47 @@ export class BrushTool extends BuilderToolBase {
         if (this.mode == BrushToolModes.Remove) {
             const voxel = this._lastPicked.voxel;
             if (voxel && !voxel.isAir()) {
-                const place = this.getPlacePosition(this._lastPicked);
                 await this.space.eraseTemplate([place.x, place.y, place.z], this.template.toJSON());
             }
             return;
         }
     }
-    getPlacePosition(picked) {
+    getPlacePosition(position) {
         //x
         if (this.axisXPositionMode == BrushPositionModes.Center) {
             this._position.x =
-                picked.normalPosition.x -
-                    Math.floor(this.template.shapeSelection.bounds.size.x / 2);
+                position.x - Math.floor(this.template.shapeSelection.bounds.size.x / 2);
         }
         if (this.axisXPositionMode == BrushPositionModes.Start) {
-            this._position.x = picked.normalPosition.x;
+            this._position.x = position.x;
         }
         if (this.axisXPositionMode == BrushPositionModes.End) {
             this._position.x =
-                picked.normalPosition.x - this.template.shapeSelection.bounds.size.x;
+                position.x - this.template.shapeSelection.bounds.size.x;
         }
         //y
         if (this.axisYPositionMode == BrushPositionModes.Center) {
             this._position.y =
-                picked.normalPosition.y -
-                    Math.floor(this.template.shapeSelection.bounds.size.y / 2);
+                position.y - Math.floor(this.template.shapeSelection.bounds.size.y / 2);
         }
         if (this.axisYPositionMode == BrushPositionModes.Start) {
-            this._position.y = picked.normalPosition.y;
+            this._position.y = position.y;
         }
         if (this.axisYPositionMode == BrushPositionModes.End) {
             this._position.y =
-                picked.normalPosition.y - this.template.shapeSelection.bounds.size.y;
+                position.y - this.template.shapeSelection.bounds.size.y;
         }
         //z
         if (this.axisZPositionMode == BrushPositionModes.Center) {
             this._position.z =
-                picked.normalPosition.z -
-                    Math.floor(this.template.shapeSelection.bounds.size.z / 2);
+                position.z - Math.floor(this.template.shapeSelection.bounds.size.z / 2);
         }
         if (this.axisZPositionMode == BrushPositionModes.Start) {
-            this._position.z = picked.normalPosition.z;
+            this._position.z = position.z;
         }
         if (this.axisXPositionMode == BrushPositionModes.End) {
             this._position.z =
-                picked.normalPosition.z - this.template.shapeSelection.bounds.size.z;
+                position.z - this.template.shapeSelection.bounds.size.z;
         }
         return this._position;
     }

package/Builder/Tools/Debug/DebugTool.d.ts

@@ -0,0 +1,18 @@
+import { PaintVoxelData } from "../../../Voxels";
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { BuilderToolBase, ToolOptionsData } from "../BuilderToolBase";
+interface HandToolEvents {
+}
+export declare class DebugTool extends BuilderToolBase<HandToolEvents> {
+    static ToolId: string;
+    selection: VoxelPointSelection;
+    voxelData: PaintVoxelData;
+    usePlacingStrategy: boolean;
+    update(): Promise<void>;
+    cancel(): void;
+    use(): Promise<void>;
+    getOptionValue(id: string): null;
+    getCurrentOptions(): ToolOptionsData;
+    updateOption(property: string, value: any): void;
+}
+export {};

package/Builder/Tools/Debug/DebugTool.js

@@ -0,0 +1,36 @@
+import { VoxelPointSelection } from "../../../Templates/Selection/VoxelPointSelection";
+import { BuilderToolBase } from "../BuilderToolBase";
+export class DebugTool extends BuilderToolBase {
+    static ToolId = "Debug";
+    selection = new VoxelPointSelection();
+    voxelData;
+    usePlacingStrategy = true;
+    async update() {
+        this._lastPicked = await this.space.pickWithProvider(this.rayProviderIndex);
+        if (!this._lastPicked)
+            return;
+        if (!this.space.bounds.intersectsPoint(this._lastPicked.position)) {
+            this._lastPicked = null;
+            return;
+        }
+        this.selection.reConstruct(this._lastPicked.position);
+    }
+    cancel() {
+        this._lastPicked = null;
+    }
+    async use() {
+        if (!this._lastPicked)
+            return;
+        console.warn("USE DEBUG");
+        console.log("PICKED", this._lastPicked.clone());
+        console.log("VOXEL", this._lastPicked.voxel.getStringId(), this._lastPicked.voxel.getId(), this._lastPicked.voxel.getVoxelId());
+        return;
+    }
+    getOptionValue(id) {
+        return null;
+    }
+    getCurrentOptions() {
+        return [];
+    }
+    updateOption(property, value) { }
+}

package/Builder/Tools/Path/PahtTool.d.ts

@@ -8,7 +8,7 @@ export declare enum PathToolModes {
     MovePoints = "Move Points",
     RemovePoints = "Remove Points",
     FillPath = "Fill Path",
-    RemovePath = "Remvoe Path"
+    RemovePath = "Remove Path"
 }
 interface PathToolEvents {
 }

package/Builder/Tools/Path/PahtTool.js

@@ -8,7 +8,7 @@ export var PathToolModes;
     PathToolModes["MovePoints"] = "Move Points";
     PathToolModes["RemovePoints"] = "Remove Points";
     PathToolModes["FillPath"] = "Fill Path";
-    PathToolModes["RemovePath"] = "Remvoe Path";
+    PathToolModes["RemovePath"] = "Remove Path";
 })(PathToolModes || (PathToolModes = {}));
 export class PathTool extends BuilderToolBase {
     static ToolId = "Path";

package/Builder/Tools/Sculpt/SculptTool.js

@@ -44,9 +44,17 @@ export class SculptTool extends BuilderToolBase {
         if (!this._started && !placerMode && picked) {
             if (this.mode == SculptToolModes.Fill ||
                 this.mode == SculptToolModes.Extrude) {
+                if (!this.space.bounds.intersectsPoint(picked.normalPosition)) {
+                    this._lastPicked = null;
+                    return;
+                }
                 this.selection.reConstruct(picked.normalPosition, picked.normal, Vector3Like.Add(picked.normalPosition, Vector3Like.Create(1, 1, 1)), picked.normal);
             }
             if (this.mode == SculptToolModes.Remove) {
+                if (!this.space.bounds.intersectsPoint(picked.position)) {
+                    this._lastPicked = null;
+                    return;
+                }
                 this.selection.reConstruct(picked.position, picked.normal, Vector3Like.Add(picked.position, Vector3Like.Create(1, 1, 1)), picked.normal);
             }
             this._normal = { ...picked.normal };

package/Builder/Tools/Wrench/WrenchTool.js

@@ -116,14 +116,12 @@ export class WrenchTool extends BuilderToolBase {
             return null;
         const voxelStates = [];
         const voxelId = this._pickedResult.voxel.id;
-        const [trueId, , mod] = VoxelLUT.voxels[voxelId];
-        const stateArray = VoxelLUT.voxelRecord[trueId][mod];
+        const trueId = VoxelLUT.voxelIdToTrueId[voxelId];
+        const mod = VoxelLUT.voxelIdToMod[voxelId];
+        const stateMap = VoxelLUT.modelStateMaps[VoxelLUT.modelsIndex[trueId]];
         const rawVoxelData = [0, 0, 0, 0];
-        for (let i = 0; i < stateArray.length; i++) {
-            const value = stateArray[i];
-            if (value === undefined || value <= 0)
-                continue;
-            rawVoxelData[0] = value;
+        for (const [state, index] of stateMap) {
+            rawVoxelData[0] = VoxelLUT.getVoxelId(trueId, state, mod);
             voxelStates.push(PaintVoxelData.FromRaw(rawVoxelData));
         }
         return voxelStates;
@@ -134,23 +132,12 @@ export class WrenchTool extends BuilderToolBase {
             return null;
         const voxelStates = [];
         const voxelId = this._pickedResult.voxel.id;
-        const [trueId, state] = VoxelLUT.voxels[voxelId];
-        const modArray = VoxelLUT.voxelRecord[trueId];
+        const trueId = VoxelLUT.voxelIdToTrueId[voxelId];
+        const state = VoxelLUT.voxelIdToState[voxelId];
         const rawVoxelData = [0, 0, 0, 0];
-        for (let i = 0; i < modArray.length; i++) {
-            const stateArray = modArray[i];
-            if (stateArray === undefined || !stateArray.length)
-                continue;
-            let id = -1;
-            for (let j = 0; j < stateArray.length; j++) {
-                id = VoxelLUT.voxelRecord[trueId][i][state];
-                if (id === undefined || id < 0)
-                    continue;
-                rawVoxelData[0] = id;
-                break;
-            }
-            if (id === undefined || id < 0)
-                continue;
+        const modMap = VoxelLUT.voxelModMaps[trueId];
+        for (const [mod, index] of modMap) {
+            rawVoxelData[0] = VoxelLUT.getVoxelId(trueId, state, mod);
             voxelStates.push(PaintVoxelData.FromRaw(rawVoxelData));
         }
         return voxelStates;

package/Builder/Util/SurfaceBoxSelection.js

@@ -20,6 +20,8 @@ export class SurfaceBoxSelection {
             this.planeNormal.z > 0) {
             offset++;
         }
+        if (!this.space.bounds.intersectsPoint(intersectionPoint))
+            return;
         this.selection.reConstruct(this.planeOrigin, this.planeNormal, intersectionPoint, this.planeNormal, offset);
     }
 }

package/Builder/VoxelBuildSpace.js

@@ -92,9 +92,9 @@ export class VoxelBuildSpace {
             [0, min.x, min.y, min.z],
             VoxelShapeTemplate.CreateNew({
                 shapeSelection: BoxVoxelShapeSelection.CreateNew({
-                    width: this.bounds.size.x,
-                    height: this.bounds.size.y,
-                    depth: this.bounds.size.z,
+                    width: this.bounds.size.x + 1,
+                    height: this.bounds.size.y + 1,
+                    depth: this.bounds.size.z + 1,
                 }),
             }),
         ]);

package/Contexts/Base/Remote/InitDataSync.js

@@ -9,9 +9,9 @@ import { VoxelSchemas } from "../../../Voxels/State/VoxelSchemas";
 export default function InitDataSync(props) {
     Threads.registerTask("sync-data", (data) => {
         EngineSettings.syncSettings(data.settings);
-        VoxelSchemas.import(data.schemas);
         VoxelLUT.import(data.luts.voxel);
         GeometryLUT.import(data.luts.geometry);
+        VoxelSchemas.import(data.schemas);
         VoxelTagsRegister.VoxelTags = data.tags.tags;
         VoxelTagsRegister.SubstanceTags = data.tags.substanceTags;
         for (const id in data.tags.logic) {

package/Math/UtilFunctions.js

@@ -1,5 +1,4 @@
 import { Vec3ArrayLike, Vector3Like } from "@amodx/math";
-import { VoxelFaces } from "./VoxelFaces";
 const unitNormals = [
     [0, 1, 0],
     [0, -1, 0],
@@ -35,18 +34,18 @@ export function closestUnitNormal(v) {
 }
 export function closestVoxelFace(v) {
     const unitNormal = closestUnitNormal(v);
-    let closestFace = VoxelFaces.Up;
+    let closestFace = 0 /* VoxelFaces.Up */;
     if (unitNormal[0] == 1)
-        closestFace = VoxelFaces.East;
+        closestFace = 4 /* VoxelFaces.East */;
     if (unitNormal[0] == -1)
-        closestFace = VoxelFaces.West;
+        closestFace = 5 /* VoxelFaces.West */;
     if (unitNormal[1] == 1)
-        closestFace = VoxelFaces.Up;
+        closestFace = 0 /* VoxelFaces.Up */;
     if (unitNormal[1] == -1)
-        closestFace = VoxelFaces.Down;
+        closestFace = 1 /* VoxelFaces.Down */;
     if (unitNormal[2] == 1)
-        closestFace = VoxelFaces.North;
+        closestFace = 2 /* VoxelFaces.North */;
     if (unitNormal[2] == -1)
-        closestFace = VoxelFaces.South;
+        closestFace = 3 /* VoxelFaces.South */;
     return closestFace;
 }

package/Math/VoxelFaces.d.ts

@@ -3,7 +3,7 @@ export type VoxelFaceNames = "up" | "down" | "north" | "south" | "east" | "west"
 export declare const VoxelFaceNameArray: VoxelFaceNames[];
 export declare const VoxelFaceNameOppoisteRecord: Record<VoxelFaceNames, VoxelFaceNames>;
 export declare const VoxelFaceNameDirectionsRecord: Record<VoxelFaceNames, Vec3Array>;
-export declare enum VoxelFaces {
+export declare const enum VoxelFaces {
     Up = 0,
     Down = 1,
     North = 2,
@@ -12,7 +12,7 @@ export declare enum VoxelFaces {
     West = 5
 }
 export declare const VoxelFacesArray: readonly VoxelFaces[];
-export declare const VoxelFaceDirections: Readonly<Record<VoxelFaces, Vec3Array>>;
+export declare const VoxelFaceDirections: Readonly<Vec3Array[]>;
 export declare const VoxelFaceOpositeDirectionMap: Record<VoxelFaces, VoxelFaces>;
 export declare const VoxelFaceCompassDirectionMap: Record<VoxelFaces, CompassDirections>;
 export declare const CompassDirectionVoxelFaceMap: Record<CompassDirections, VoxelFaces>;

package/Math/VoxelFaces.js

@@ -23,70 +23,61 @@ export const VoxelFaceNameDirectionsRecord = {
     east: [1, 0, 0],
     west: [-1, 0, 0],
 };
-export var VoxelFaces;
-(function (VoxelFaces) {
-    VoxelFaces[VoxelFaces["Up"] = 0] = "Up";
-    VoxelFaces[VoxelFaces["Down"] = 1] = "Down";
-    VoxelFaces[VoxelFaces["North"] = 2] = "North";
-    VoxelFaces[VoxelFaces["South"] = 3] = "South";
-    VoxelFaces[VoxelFaces["East"] = 4] = "East";
-    VoxelFaces[VoxelFaces["West"] = 5] = "West";
-})(VoxelFaces || (VoxelFaces = {}));
 export const VoxelFacesArray = Object.freeze([
-    VoxelFaces.Up,
-    VoxelFaces.Down,
-    VoxelFaces.North,
-    VoxelFaces.South,
-    VoxelFaces.East,
-    VoxelFaces.West,
+    0 /* VoxelFaces.Up */,
+    1 /* VoxelFaces.Down */,
+    2 /* VoxelFaces.North */,
+    3 /* VoxelFaces.South */,
+    4 /* VoxelFaces.East */,
+    5 /* VoxelFaces.West */,
+]);
+export const VoxelFaceDirections = Object.freeze([
+    [0, 1, 0], // 0 = Up
+    [0, -1, 0], // 1 = Down
+    [0, 0, 1], // 2 = North
+    [0, 0, -1], // 3 = South
+    [1, 0, 0], // 4 = East
+    [-1, 0, 0], // 5 = West
 ]);
-export const VoxelFaceDirections = Object.freeze({
-    [VoxelFaces.Up]: [0, 1, 0],
-    [VoxelFaces.Down]: [0, -1, 0],
-    [VoxelFaces.North]: [0, 0, 1],
-    [VoxelFaces.South]: [0, 0, -1],
-    [VoxelFaces.East]: [1, 0, 0],
-    [VoxelFaces.West]: [-1, 0, 0],
-});
 export const VoxelFaceOpositeDirectionMap = {
-    [VoxelFaces.Up]: VoxelFaces.Down,
-    [VoxelFaces.Down]: VoxelFaces.Up,
-    [VoxelFaces.North]: VoxelFaces.South,
-    [VoxelFaces.South]: VoxelFaces.North,
-    [VoxelFaces.East]: VoxelFaces.West,
-    [VoxelFaces.West]: VoxelFaces.East,
+    [0 /* VoxelFaces.Up */]: 1 /* VoxelFaces.Down */,
+    [1 /* VoxelFaces.Down */]: 0 /* VoxelFaces.Up */,
+    [2 /* VoxelFaces.North */]: 3 /* VoxelFaces.South */,
+    [3 /* VoxelFaces.South */]: 2 /* VoxelFaces.North */,
+    [4 /* VoxelFaces.East */]: 5 /* VoxelFaces.West */,
+    [5 /* VoxelFaces.West */]: 4 /* VoxelFaces.East */,
 };
 export const VoxelFaceCompassDirectionMap = {
-    [VoxelFaces.Up]: CompassDirections.North,
-    [VoxelFaces.Down]: CompassDirections.South,
-    [VoxelFaces.North]: CompassDirections.North,
-    [VoxelFaces.South]: CompassDirections.South,
-    [VoxelFaces.East]: CompassDirections.East,
-    [VoxelFaces.West]: CompassDirections.West,
+    [0 /* VoxelFaces.Up */]: CompassDirections.North,
+    [1 /* VoxelFaces.Down */]: CompassDirections.South,
+    [2 /* VoxelFaces.North */]: CompassDirections.North,
+    [3 /* VoxelFaces.South */]: CompassDirections.South,
+    [4 /* VoxelFaces.East */]: CompassDirections.East,
+    [5 /* VoxelFaces.West */]: CompassDirections.West,
 };
 export const CompassDirectionVoxelFaceMap = {
-    [CompassDirections.North]: VoxelFaces.North,
-    [CompassDirections.South]: VoxelFaces.South,
-    [CompassDirections.West]: VoxelFaces.West,
-    [CompassDirections.East]: VoxelFaces.East,
-    [CompassDirections.NorthEast]: VoxelFaces.Up,
-    [CompassDirections.NorthWest]: VoxelFaces.Up,
-    [CompassDirections.SouthEast]: VoxelFaces.Up,
-    [CompassDirections.SouthWest]: VoxelFaces.Up,
+    [CompassDirections.North]: 2 /* VoxelFaces.North */,
+    [CompassDirections.South]: 3 /* VoxelFaces.South */,
+    [CompassDirections.West]: 5 /* VoxelFaces.West */,
+    [CompassDirections.East]: 4 /* VoxelFaces.East */,
+    [CompassDirections.NorthEast]: 0 /* VoxelFaces.Up */,
+    [CompassDirections.NorthWest]: 0 /* VoxelFaces.Up */,
+    [CompassDirections.SouthEast]: 0 /* VoxelFaces.Up */,
+    [CompassDirections.SouthWest]: 0 /* VoxelFaces.Up */,
 };
 export const VoxelFaceNameRecord = {
-    up: VoxelFaces.Up,
-    down: VoxelFaces.Down,
-    north: VoxelFaces.North,
-    south: VoxelFaces.South,
-    east: VoxelFaces.East,
-    west: VoxelFaces.West,
+    up: 0 /* VoxelFaces.Up */,
+    down: 1 /* VoxelFaces.Down */,
+    north: 2 /* VoxelFaces.North */,
+    south: 3 /* VoxelFaces.South */,
+    east: 4 /* VoxelFaces.East */,
+    west: 5 /* VoxelFaces.West */,
 };
 export const VoxelFaceNameMap = {
-    [VoxelFaces.Up]: "up",
-    [VoxelFaces.Down]: "down",
-    [VoxelFaces.North]: "north",
-    [VoxelFaces.South]: "south",
-    [VoxelFaces.East]: "east",
-    [VoxelFaces.West]: "west",
+    [0 /* VoxelFaces.Up */]: "up",
+    [1 /* VoxelFaces.Down */]: "down",
+    [2 /* VoxelFaces.North */]: "north",
+    [3 /* VoxelFaces.South */]: "south",
+    [4 /* VoxelFaces.East */]: "east",
+    [5 /* VoxelFaces.West */]: "west",
 };

package/Math/WorldIndexing.d.ts

@@ -0,0 +1,11 @@
+import { Vec3Array, Vector3Like } from "@amodx/math";
+export declare function CubeHashVec3Array(positionX: number, positionY: number, positionZ: number, xPower2: number, yPower2: number, zPower2: number, positionRef?: Vec3Array): Vec3Array;
+export declare function CubeHashVec3(positionX: number, positionY: number, positionZ: number, xPower2: number, yPower2: number, zPower2: number, positionRef?: Vector3Like): Vector3Like;
+export declare function GetYXZOrderArrayIndex(x: number, y: number, z: number, zPower: number, // log2(boundsZ)
+xzPower: number): number;
+export declare function GetYXZOrderArrayPositionVec3(index: number, zPower: number, xzPower: number, zMask: number, // boundsZ - 1
+xMask: number, // boundsX - 1
+positionRef?: Vector3Like): Vector3Like;
+export declare function GetYXZOrderArrayPositionVec3Array(index: number, zPower: number, xzPower: number, zMask: number, // boundsZ - 1
+xMask: number, // boundsX - 1
+positionRef?: Vec3Array): Vec3Array;

package/Math/WorldIndexing.js

@@ -0,0 +1,34 @@
+import { Vector3Like } from "@amodx/math";
+export function CubeHashVec3Array(positionX, positionY, positionZ, xPower2, yPower2, zPower2, positionRef = [0, 0, 0]) {
+    positionRef[0] = (positionX >> xPower2) << xPower2;
+    positionRef[1] = (positionY >> yPower2) << yPower2;
+    positionRef[2] = (positionZ >> zPower2) << zPower2;
+    return positionRef;
+}
+export function CubeHashVec3(positionX, positionY, positionZ, xPower2, yPower2, zPower2, positionRef = Vector3Like.Create()) {
+    positionRef.x = (positionX >> xPower2) << xPower2;
+    positionRef.y = (positionY >> yPower2) << yPower2;
+    positionRef.z = (positionZ >> zPower2) << zPower2;
+    return positionRef;
+}
+export function GetYXZOrderArrayIndex(x, y, z, zPower, // log2(boundsZ)
+xzPower // log2(boundsX * boundsZ), precomputed
+) {
+    return z | (x << zPower) | (y << xzPower);
+}
+export function GetYXZOrderArrayPositionVec3(index, zPower, xzPower, zMask, // boundsZ - 1
+xMask, // boundsX - 1
+positionRef = Vector3Like.Create()) {
+    positionRef.z = index & zMask;
+    positionRef.x = (index >> zPower) & xMask;
+    positionRef.y = index >> xzPower;
+    return positionRef;
+}
+export function GetYXZOrderArrayPositionVec3Array(index, zPower, xzPower, zMask, // boundsZ - 1
+xMask, // boundsX - 1
+positionRef = [0, 0, 0]) {
+    positionRef[2] = index & zMask;
+    positionRef[0] = (index >> zPower) & xMask;
+    positionRef[1] = index >> xzPower;
+    return positionRef;
+}

package/Mesher/Geometry/Geometry.types.d.ts

@@ -11,14 +11,14 @@ export interface VoxelGeometryTransform {
 export type QuadVertexVec3Data = [Vec3Array, Vec3Array, Vec3Array, Vec3Array];
 export type QuadVertexFloatData = [number, number, number, number];
 export type QuadUVData = [Vec2Array, Vec2Array, Vec2Array, Vec2Array];
-export declare enum QuadVerticies {
+export declare const enum QuadVerticies {
     TopRight = 0,
     TopLeft = 1,
     BottomLeft = 2,
     BottomRight = 3
 }
 export declare const QuadVerticiesArray: QuadVerticies[];
-export declare enum TriangleVerticies {
+export declare const enum TriangleVerticies {
     One = 0,
     Two = 1,
     Three = 2