@divinevoxel/vlox 0.0.73 → 0.0.75

package/Voxels/InitVoxelData.js

@@ -1,21 +1,29 @@
-import { candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, candlesModel, carpetGeometry, carpetModel, chainGeometry, chainModel, fence, fenceEastWest, fenceNorthsouth, fencePost, leverGeometry, leverModel, } from "../Models/Examples";
-import { cube, halfDownCube, eighthCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, halfSouthCube, halfWestCube, } from "../Models/Defaults/CubeVoxelGeometry";
-import { orientedCube, pillarCube, simpleCube, simpleHalfCube, } from "../Models/Defaults/CubeVoxelModels";
-import { diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, thinPanelDown, thinPanelSouth, thinPanelWest, } from "../Models/Defaults/PanelVoxelGeometry";
-import { stair } from "../Models/Defaults/StairVoxelModel";
-import { liquidGeometry, liquidModel, } from "../Models/Defaults/LiquidVoxelModel";
-import { VoxelModelRuleBuilderRegister } from "../Models/Rules/VoxelModelRuleBuilderRegister";
-import { BuildRules } from "../Models/Rules/Functions/BuildRules";
+import { candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, candlesModel, carpetGeometry, carpetModel, chainGeometry, chainModel, fence, fenceEastWest, fenceNorthsouth, fencePost, leverGeometry, leverModel, } from "./Models/Defaults/Examples";
+import { cube, halfDownCube, eighthCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, halfSouthCube, halfWestCube, } from "./Models/Defaults/CubeVoxelGeometry";
+import { orientedCube, pillarCube, simpleCube, simpleNoCulledCube, simpleHalfCube, simpleTransparentCube, } from "./Models/Defaults/CubeVoxelModels";
+import { diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, thinPanelDown, thinPanelSouth, thinPanelWest, } from "./Models/Defaults/PanelVoxelGeometry";
+import { stair } from "./Models/Defaults/StairVoxelModel";
+import { liquidGeometry, liquidModel, } from "./Models/Defaults/LiquidVoxelModel";
+import { VoxelModelRuleBuilderRegister } from "./Models/Rules/VoxelModelRuleBuilderRegister";
 import { BuildStateData } from "./Functions/BuildStateData";
-import { BuildFinalInputs } from "../Models/Rules/Functions/BuildFinalInputs";
+import { BuildFinalInputs } from "./Models/Rules/Functions/BuildFinalInputs";
 import { SchemaRegister } from "../Voxels/State/SchemaRegister";
-import { simpleCrossedPannel, simpleThinPannel, } from "../Models/Defaults/PanelVoxelModels";
-import { VoxelTagStates } from "./Data/VoxelTagStates";
+import { simpleCrossedPannel, simpleThinPannel, } from "./Models/Defaults/PanelVoxelModels";
 import { VoxelIndex } from "../Voxels/Indexes/VoxelIndex";
 import { CacheManager } from "../Cache/CacheManager";
 import { VoxelLightData } from "./Cursor/VoxelLightData";
 import { VoxelTagIds } from "./Data/VoxelTag.types";
-import { BuildTagAndPaletteData } from "./Functions/BuildTagAndPaletteData";
+import { BuildTagAndPaletteData as BuildTagData } from "./Functions/BuildTagData";
+import { VoxelPalettesRegister } from "./Data/VoxelPalettesRegister";
+import { VoxelLogicRegister } from "./Logic/VoxelLogicRegister";
+import { BuildPaletteData } from "./Functions/BuildPaletteData";
+import { BuildRules } from "./Models/Rules/Functions/BuildRules";
+import { VoxelTagsRegister } from "./Data/VoxelTagsRegister";
+import { farmGeomtry, farmModels } from "./Models/Defaults/FarmVoxelModels";
+function RegisterModels(data) {
+    VoxelModelRuleBuilderRegister.registerGeometry(cube, halfDownCube, halfSouthCube, halfWestCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, eighthCube, thinPanelDown, thinPanelSouth, thinPanelWest, diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, fencePost, fenceEastWest, fenceNorthsouth, chainGeometry, carpetGeometry, candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, liquidGeometry, ...leverGeometry, ...farmGeomtry, ...(data.geometry || []));
+    VoxelModelRuleBuilderRegister.registerModels(simpleCube, simpleTransparentCube, simpleNoCulledCube, orientedCube, simpleHalfCube, pillarCube, simpleThinPannel, stair, simpleCrossedPannel, chainModel, carpetModel, candlesModel, leverModel, fence, liquidModel, ...farmModels, ...(data.models || []));
+}
 function GetModelData(data) {
     if (CacheManager.cacheLoadEnabled && CacheManager.cachedData) {
         const syncData = CacheManager.cachedData.models;
@@ -27,18 +35,8 @@ function GetModelData(data) {
             const voxel = syncData.voxels[i];
             SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
         }
-        VoxelTagStates.load(syncData.tagState);
         return syncData;
     }
-    VoxelModelRuleBuilderRegister.registerGeometry(cube, halfDownCube, halfSouthCube, halfWestCube, quaterCubeSouthNorth, quaterCubeUpDown, quaterCubeWestEast, eighthCube, thinPanelDown, thinPanelSouth, thinPanelWest, diagonalFlatPanelEastWest, diagonalFlatPanelWestEast, fencePost, fenceEastWest, fenceNorthsouth, chainGeometry, carpetGeometry, candlesGeometry1, candlesGeometry2, candlesGeometry3, candlesGeometry4, liquidGeometry, ...leverGeometry, ...(data.geometry || []));
-    VoxelModelRuleBuilderRegister.registerModels(simpleCube, orientedCube, simpleHalfCube, pillarCube, simpleThinPannel, stair, simpleCrossedPannel, chainModel, carpetModel, candlesModel, leverModel, fence, liquidModel, ...(data.models || []));
-    const syncData = {
-        geometryPalette: VoxelModelRuleBuilderRegister.geometryPalette._palette,
-        geometry: [],
-        models: [],
-        voxels: [],
-        tagState: [],
-    };
     for (const voxel of data.voxels) {
         const voxelData = voxel.properties["dve_model_data"];
         if (!voxelData)
@@ -49,20 +47,18 @@ function GetModelData(data) {
             throw new Error(`Voxel model with id ${voxelData.id} does not exist.`);
         model.voxels.set(voxel.id, voxelData);
     }
+    const syncData = {
+        geometryPalette: VoxelModelRuleBuilderRegister.geometryPalette._palette,
+        ...BuildRules(VoxelModelRuleBuilderRegister.geometryPalette),
+        geometry: [],
+        models: [],
+        voxels: [],
+    };
     for (const [mainKey, mainGeo] of VoxelModelRuleBuilderRegister.geometry) {
-        if (mainGeo.data.ogData.doNotBuildRules) {
-            syncData.geometry.push({
-                id: mainKey,
-                nodes: mainGeo.data.nodes,
-                ruleless: true,
-            });
-            continue;
-        }
-        const output = BuildRules(mainGeo, VoxelModelRuleBuilderRegister.geometryPalette);
         syncData.geometry.push({
             id: mainKey,
-            nodes: mainGeo.data.nodes,
-            ...output,
+            nodes: mainGeo.compiled,
+            cullingProcedure: mainGeo.data.cullingProcedure,
         });
     }
     for (const [mainKey, model] of VoxelModelRuleBuilderRegister.models) {
@@ -73,16 +69,16 @@ function GetModelData(data) {
             id: mainKey,
             effects: stateData.effects,
             schema: stateData.schema,
-            geoLinkMap: stateData.geometryLinkStateMap,
-            shapeStateMap: stateData.shapeStatePalette,
-            shapeStateGeometryMap: stateData.shapeStateGeometryPalette,
-            shapeStateTree: stateData.shapeStateTree,
+            //   geoLinkMap: stateData.geometryLinkStateMap,
+            stateMap: stateData.statePalette,
+            stateGeometryMap: stateData.stateGeometryPalette,
+            stateTree: stateData.stateTree,
             condiotnalStateTree: stateData.condiotnalNodeStateTree,
             condiotnalStatements: stateData.condiotnalStatements,
-            condiotnalStateMap: stateData.condiotnalShapeStatePalette,
+            condiotnalStateMap: stateData.condiotnalStatePalette,
             condiotnalShapeStateMap: stateData.condiotanlStatePalette,
-            condiotnalShapeStateGeometryMap: stateData.condiotanlGeometryStatePalette,
-            shapeStateRelativeGeometryMap: stateData.shapeStateRelativeGeometryMap,
+            condiotanlGeometryStatePalette: stateData.condiotanlGeometryStatePalette,
+            stateRelativeGeometryMap: stateData.stateRelativeGeometryMap,
             relativeGeometryByteIndexMap: stateData.relativeGeometryByteIndexMap,
             condiotnalShapeStateRelativeGeometryMap: stateData.condiotnalShapeStateRelativeGeometryMap,
         });
@@ -91,23 +87,21 @@ function GetModelData(data) {
       BuildGeomtryInputs(geometry);
     } */
     for (const [mainKey, model] of VoxelModelRuleBuilderRegister.models) {
-        const { shapeStateVoxelInputs, conditionalShapeStateVoxelInputs, transparentVoxelFaceIndexes, } = BuildFinalInputs(model);
-        for (const v in shapeStateVoxelInputs) {
+        const { stateVoxelInputs, conditionalShapeStateVoxelInputs } = BuildFinalInputs(model);
+        for (const v in stateVoxelInputs) {
             const stateData = model.voxelModData.get(v);
             SchemaRegister.registerVoxel(v, mainKey, stateData.modSchema);
             syncData.voxels.push({
                 id: v,
-                materialId: VoxelIndex.instance.dataMap.get(v)?.properties["dve_rendered_material"] || "dve_solid",
+                materialId: VoxelTagsRegister.VoxelTags[VoxelPalettesRegister.voxelIds.getNumberId(v)]["dve_rendered_material"] || "dve_solid",
                 modelId: mainKey,
-                transparentFaceIndex: transparentVoxelFaceIndexes[v].data,
                 modSchema: stateData.modSchema,
                 modStateTree: stateData.modStateTree,
-                baseGeometryInputMap: shapeStateVoxelInputs[v],
+                baseGeometryInputMap: stateVoxelInputs[v],
                 condiotnalGeometryInputMap: conditionalShapeStateVoxelInputs[v],
             });
         }
     }
-    syncData.tagState = VoxelTagStates.toJSON();
     if (CacheManager.cacheStoreEnabled) {
         CacheManager.cachedModelData = syncData;
     }
@@ -115,10 +109,10 @@ function GetModelData(data) {
 }
 export function InitVoxelData(data) {
     const lightData = new VoxelLightData();
-    new VoxelIndex(data.voxels);
     const materials = [
         { id: "dve_solid", properties: {} },
         { id: "dve_flora", properties: {} },
+        { id: "dve_flora_transparent", properties: {} },
         {
             id: "dve_transparent",
             properties: {
@@ -227,7 +221,8 @@ export function InitVoxelData(data) {
         },
         ...data.voxels,
     ];
-    const voxelData = BuildTagAndPaletteData({
+    RegisterModels(data);
+    const voxelData = BuildTagData({
         voxels,
         voxelsOverrides: {
             [VoxelTagIds.lightValue]: (value) => {
@@ -243,6 +238,13 @@ export function InitVoxelData(data) {
         materials,
     });
     let models = GetModelData(data);
+    BuildPaletteData({ models });
+    voxelData.data.palette = VoxelPalettesRegister.voxels;
+    voxelData.data.record = VoxelPalettesRegister.voxelRecord;
+    for (const id in voxelData.data.logic) {
+        VoxelLogicRegister.register(id, voxelData.data.logic[id]);
+    }
+    new VoxelIndex(data.voxels);
     return {
         models,
         ...voxelData,

package/Voxels/Interaction/Functions/PickVoxel.d.ts

@@ -0,0 +1,9 @@
+import { Vec3Array } from "@amodx/math";
+import { DataCursorInterface } from "../../Cursor/DataCursor.interface";
+import { VoxelPickResult } from "../VoxelPickResult";
+/**
+ * # PickVoxel
+ * Used to a pick a voxel from any data cursor interface.
+ * The function assumes the data that is loaded into the cursor is available
+ */
+export default function PickVoxel(cursor: DataCursorInterface, rayStart: Vec3Array, rayDirection: Vec3Array, rayLength: number): VoxelPickResult | null;

package/Voxels/Interaction/Functions/PickVoxel.js

@@ -0,0 +1,95 @@
+import { Vec3ArrayLike, Vector3Like } from "@amodx/math";
+import { VoxelPickResult } from "../VoxelPickResult";
+import { closestUnitNormal, closestVoxelFace, } from "../../../Math/UtilFunctions";
+const step = (val) => (val > 0 ? 1 : val < 0 ? -1 : 0);
+const calculateNormal = (intersectPoint, voxelMin, voxelMax) => {
+    const epsilon = 1e-4;
+    let normal = [0, 0, 0];
+    if (Math.abs(intersectPoint[0] - voxelMin[0]) < epsilon)
+        normal = [1, 0, 0];
+    else if (Math.abs(intersectPoint[0] - voxelMax[0]) < epsilon)
+        normal = [-1, 0, 0];
+    else if (Math.abs(intersectPoint[1] - voxelMin[1]) < epsilon)
+        normal = [0, 1, 0];
+    else if (Math.abs(intersectPoint[1] - voxelMax[1]) < epsilon)
+        normal = [0, -1, 0];
+    else if (Math.abs(intersectPoint[2] - voxelMin[2]) < epsilon)
+        normal = [0, 0, 1];
+    else if (Math.abs(intersectPoint[2] - voxelMax[2]) < epsilon)
+        normal = [0, 0, -1];
+    return normal;
+};
+/**
+ * # PickVoxel
+ * Used to a pick a voxel from any data cursor interface.
+ * The function assumes the data that is loaded into the cursor is available
+ */
+export default function PickVoxel(cursor, rayStart, rayDirection, rayLength) {
+    const invDir = [
+        1 / rayDirection[0],
+        1 / rayDirection[1],
+        1 / rayDirection[2],
+    ];
+    const voxelSize = 1.0;
+    const tDelta = [
+        Math.abs(invDir[0]) * voxelSize,
+        Math.abs(invDir[1]) * voxelSize,
+        Math.abs(invDir[2]) * voxelSize,
+    ];
+    const tMax = [
+        (Math.floor(rayStart[0]) - rayStart[0] + (rayDirection[0] > 0 ? 1 : 0)) *
+            invDir[0],
+        (Math.floor(rayStart[1]) - rayStart[1] + (rayDirection[1] > 0 ? 1 : 0)) *
+            invDir[1],
+        (Math.floor(rayStart[2]) - rayStart[2] + (rayDirection[2] > 0 ? 1 : 0)) *
+            invDir[2],
+    ];
+    const pos = [
+        Math.floor(rayStart[0]),
+        Math.floor(rayStart[1]),
+        Math.floor(rayStart[2]),
+    ];
+    const stepDir = [
+        step(rayDirection[0]),
+        step(rayDirection[1]),
+        step(rayDirection[2]),
+    ];
+    for (let i = 0; i < rayLength; i++) {
+        const [tx, ty, tz] = tMax;
+        let axis = 0;
+        if (tx < ty) {
+            if (tx < tz)
+                axis = 0;
+            else
+                axis = 2;
+        }
+        else {
+            if (ty < tz)
+                axis = 1;
+            else
+                axis = 2;
+        }
+        pos[axis] += stepDir[axis];
+        tMax[axis] += tDelta[axis];
+        if (!cursor.inBounds(...pos))
+            continue;
+        const voxel = cursor.getVoxel(...pos);
+        if (voxel && voxel.isRenderable()) {
+            const normal = calculateNormal([
+                rayStart[0] + rayDirection[0] * tMax[axis],
+                rayStart[1] + rayDirection[1] * tMax[axis],
+                rayStart[2] + rayDirection[2] * tMax[axis],
+            ], [pos[0] * voxelSize, pos[1] * voxelSize, pos[2] * voxelSize], [
+                pos[0] * voxelSize + voxelSize,
+                pos[1] * voxelSize + voxelSize,
+                pos[2] * voxelSize + voxelSize,
+            ]);
+            const rd = Vector3Like.Create(...rayDirection);
+            const urd = Vector3Like.FromArray(closestUnitNormal(rd));
+            const n = Vector3Like.Create(...normal);
+            const un = Vector3Like.FromArray(closestUnitNormal(n));
+            return new VoxelPickResult(Vector3Like.Create(...rayStart), rd, rayLength, voxel.getRaw(), Vector3Like.Create(...pos), n, tMax[axis], Vector3Like.Create(...Vec3ArrayLike.Add(pos, normal)), Vector3Like.FromArray(closestUnitNormal(rd)), closestVoxelFace(urd), Vector3Like.FromArray(closestUnitNormal(n)), closestVoxelFace(un), 0);
+        }
+    }
+    return null;
+}

package/Voxels/Interaction/Functions/PickVoxelWorld.d.ts

@@ -0,0 +1,8 @@
+import { Vec3Array } from "@amodx/math";
+import { WorldCursor } from "../../../World";
+/**# PickVoxelWorld
+ * Will pick the voxel world and make sure each sector is available before picking it.
+ *
+ * Useful if the engine is not using shared memory.
+ */
+export default function PickVoxelWorld(cursor: WorldCursor, rayStart: Vec3Array, rayDirection: Vec3Array, rayLength: number): Promise<import("../VoxelPickResult").VoxelPickResult | null>;

package/Voxels/Interaction/Functions/PickVoxelWorld.js

@@ -0,0 +1,66 @@
+import { Vector3Like } from "@amodx/math";
+import PickVoxel from "./PickVoxel";
+import { Axes } from "@amodx/math/Vectors/Axes";
+import { WorldSpaces } from "../../../World/WorldSpaces";
+import { WorldRegister } from "../../../World/WorldRegister";
+import { SectorCursor } from "../../../World/Cursor/SectorCursor";
+/**# PickVoxelWorld
+ * Will pick the voxel world and make sure each sector is available before picking it.
+ *
+ * Useful if the engine is not using shared memory.
+ */
+export default async function PickVoxelWorld(cursor, rayStart, rayDirection, rayLength) {
+    let t = 0;
+    const d = 8;
+    const rayPosition = Vector3Like.Create(...rayStart);
+    const rd = Vector3Like.Create(...rayDirection);
+    const rayRight = Vector3Like.Cross(rd, Axes.UpReadOnly());
+    const rayUp = Vector3Like.Cross(rayRight, rd);
+    const cubeSize = 16.0;
+    const halfSize = cubeSize / 2.0;
+    const rayDirectionScaled = Vector3Like.MultiplyScalar(rd, halfSize);
+    const rayRightScaled = Vector3Like.MultiplyScalar(rayRight, halfSize);
+    const rayUpScaled = Vector3Like.MultiplyScalar(rayUp, halfSize);
+    const finalRayCubeDirection = Vector3Like.Subtract(Vector3Like.Subtract(rayDirectionScaled, rayRightScaled), rayUpScaled);
+    const finalMin = Vector3Like.Create();
+    const finalMax = Vector3Like.Create();
+    const { x: sectorSizeX, y: sectorSizeY, z: sectorSizeZ, } = WorldSpaces.sector.bounds;
+    const visited = new Set();
+    const sectorCursor = new SectorCursor();
+    while (t < rayLength) {
+        rayPosition.x = rayStart[0] + t * rayDirection[0];
+        rayPosition.y = rayStart[1] + t * rayDirection[1];
+        rayPosition.z = rayStart[2] + t * rayDirection[2];
+        t += d;
+        const min = WorldSpaces.sector.getPosition(...Vector3Like.ToArray(Vector3Like.Subtract(rayPosition, finalRayCubeDirection)));
+        const max = WorldSpaces.sector.getPosition(...Vector3Like.ToArray(Vector3Like.Add(rayPosition, finalRayCubeDirection)));
+        max.x < min.x ? (finalMin.x = max.x) : (finalMin.x = min.x);
+        max.y < min.y ? (finalMin.y = max.y) : (finalMin.y = min.y);
+        max.z < min.z ? (finalMin.z = max.z) : (finalMin.z = min.z);
+        min.x > max.x ? (finalMax.x = min.x) : (finalMax.x = max.x);
+        min.y > max.y ? (finalMax.y = min.y) : (finalMax.y = max.y);
+        min.z > max.z ? (finalMax.z = min.z) : (finalMax.z = max.z);
+        const { x: sx, y: sy, z: sz } = finalMin;
+        const { x: ex, y: ey, z: ez } = finalMax;
+        for (let x = sx - sectorSizeX; x < ex + sectorSizeX; x += sectorSizeX) {
+            for (let z = sz - sectorSizeZ; z < ez + sectorSizeZ; z += sectorSizeZ) {
+                for (let y = sy - sectorSizeY; y < ey + sectorSizeY; y += sectorSizeY) {
+                    if (!WorldSpaces.world.inBounds(x, y, z))
+                        continue;
+                    const sector = WorldRegister.sectors.get(cursor.dimension, x, y, z);
+                    if (!sector)
+                        continue;
+                    if (visited.has(sector))
+                        continue;
+                    visited.add(sector);
+                    await sector.waitTillCheckedIn();
+                    sectorCursor.loadSector(cursor.dimension, x, y, z);
+                    const result = PickVoxel(sectorCursor, rayStart, rayDirection, rayLength);
+                    if (result !== null)
+                        return result;
+                }
+            }
+        }
+    }
+    return null;
+}

package/Voxels/Interaction/Placing/VoxelPlacingStrategy.d.ts

@@ -0,0 +1,9 @@
+import { VoxelFaceNames } from "../../../Math";
+import { VoxelPlacingStrategyData } from "./VoxelPlacingStrategy.types";
+import { VoxelPickResult } from "../VoxelPickResult";
+export declare class VoxelModelPlacingStrategy {
+    _faceMap: Map<VoxelFaceNames, VoxelPlacingStrategyData[]>;
+    _defaultState: string;
+    constructor(data: VoxelPlacingStrategyData[] | string);
+    getState(picked: VoxelPickResult, alt?: number | null): string | null;
+}

package/Voxels/Interaction/Placing/VoxelPlacingStrategy.js

@@ -0,0 +1,58 @@
+import { VoxelFaceNameArray } from "../../../Math";
+export class VoxelModelPlacingStrategy {
+    _faceMap = new Map();
+    _defaultState;
+    constructor(data) {
+        if (typeof data == "string") {
+            this._defaultState = data;
+        }
+        else {
+            for (const stragety of data) {
+                let faceArray = this._faceMap.get(stragety.face);
+                if (!faceArray) {
+                    faceArray = [];
+                    this._faceMap.set(stragety.face, faceArray);
+                }
+                faceArray.push(stragety);
+            }
+        }
+    }
+    getState(picked, alt = null) {
+        if (this._defaultState)
+            return this._defaultState;
+        const face = picked.unitNormalFace;
+        const delta = picked.delta;
+        const direction = picked.unitRayDirection;
+        const stragetegies = this._faceMap.get(typeof face == "number" ? VoxelFaceNameArray[face] : face);
+        if (!stragetegies)
+            return null;
+        let match = true;
+        for (const strat of stragetegies) {
+            if (alt !== null) {
+                if (strat.alt == undefined) {
+                    match = false;
+                }
+                if (strat.alt !== alt) {
+                    match = false;
+                }
+            }
+            if (strat.delta) {
+                if (!delta) {
+                    match = false;
+                }
+                else if (!(delta >= strat.delta[0] && delta <= strat.delta[1])) {
+                    match = false;
+                }
+            }
+            if (strat.direction[0] !== direction.x)
+                match = false;
+            if (strat.direction[1] !== direction.y)
+                match = false;
+            if (strat.direction[2] !== direction.z)
+                match = false;
+            if (match)
+                return strat.state;
+        }
+        return null;
+    }
+}

package/Voxels/Interaction/Placing/VoxelPlacingStrategy.types.d.ts

@@ -0,0 +1,15 @@
+import { Vec3Array } from "@amodx/math";
+import { VoxelFaceNames } from "../../../Math";
+/** Defines the state the model should be placed in given the parameters. */
+export interface VoxelPlacingStrategyData {
+    /** The closest voxel face of the intersected voxel model. */
+    face: VoxelFaceNames;
+    /** The direction of the ray that intersected the voxel that is being placed upon.  */
+    direction: Vec3Array;
+    /** The delta of the virtual voxel cube face intersected. If it was intersected halfway, it would be 0.5. */
+    delta?: [min: number, max: number];
+    /** Defines an alternative ID to override the same parameters. */
+    alt?: number;
+    /** The resulting state string of the model. */
+    state: string;
+}

package/Voxels/Interaction/Placing/VoxelPlacingStrategy.types.js

@@ -0,0 +1 @@
+export {};

package/Voxels/Interaction/Placing/VoxelPlacingStrategyRegister.d.ts

@@ -0,0 +1,7 @@
+import { VoxelPlacingStrategyData } from "./VoxelPlacingStrategy.types";
+import { VoxelModelPlacingStrategy } from "./VoxelPlacingStrategy";
+export declare class VoxelPlacingStrategyRegister {
+    static _stragies: Map<string, VoxelModelPlacingStrategy>;
+    static register(id: string, data: VoxelPlacingStrategyData[] | string): void;
+    static get(id: string): VoxelModelPlacingStrategy | null;
+}

package/Voxels/Interaction/Placing/VoxelPlacingStrategyRegister.js

@@ -0,0 +1,13 @@
+import { VoxelModelPlacingStrategy } from "./VoxelPlacingStrategy";
+export class VoxelPlacingStrategyRegister {
+    static _stragies = new Map();
+    static register(id, data) {
+        this._stragies.set(id, new VoxelModelPlacingStrategy(data));
+    }
+    static get(id) {
+        const stragety = this._stragies.get(id);
+        if (!stragety)
+            return null;
+        return stragety;
+    }
+}

package/Voxels/Interaction/VoxelPickResult.d.ts

@@ -0,0 +1,50 @@
+import { Vector3Like } from "@amodx/math";
+import { VoxelFaces } from "../../Math";
+import { RawVoxelData } from "../../Voxels/Types/Voxel.types";
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
+export interface VoxelPickResultData {
+    /**The origin of the ray */
+    rayOrigin: Vector3Like;
+    /**The direction of the ray */
+    rayDirection: Vector3Like;
+    /**The length of the ray */
+    rayLength: number;
+    /**The space position of the voxel */
+    position: Vector3Like;
+    /**The normal of the unit voxel that was hit */
+    normal: Vector3Like;
+    /**The distance from the ray start to the intersection point */
+    distance: number;
+    /**Position + the unit  normal */
+    normalPosition: Vector3Like;
+    /**The voxel data */
+    voxelData: RawVoxelData;
+    /**Closest unit normal of the ray direction */
+    unitRayDirection: Vector3Like;
+    /**Closest voxel face of the ray direction */
+    unitRayVoxelFace: VoxelFaces;
+    /**Closest unit normal of the picked normal */
+    unitNormal: Vector3Like;
+    /**Closest voxel face of the picked normal */
+    unitNormalFace: VoxelFaces;
+    delta: number;
+}
+export declare class VoxelPickResult implements VoxelPickResultData {
+    rayOrigin: Vector3Like;
+    rayDirection: Vector3Like;
+    rayLength: number;
+    voxelData: RawVoxelData;
+    position: Vector3Like;
+    normal: Vector3Like;
+    distance: number;
+    normalPosition: Vector3Like;
+    unitRayDirection: Vector3Like;
+    unitRayVoxelFace: VoxelFaces;
+    unitNormal: Vector3Like;
+    unitNormalFace: VoxelFaces;
+    delta: number;
+    voxel: VoxelCursor;
+    static FromJSON(data: VoxelPickResultData): VoxelPickResult;
+    constructor(rayOrigin: Vector3Like, rayDirection: Vector3Like, rayLength: number, voxelData: RawVoxelData, position: Vector3Like, normal: Vector3Like, distance: number, normalPosition: Vector3Like, unitRayDirection: Vector3Like, unitRayVoxelFace: VoxelFaces, unitNormal: Vector3Like, unitNormalFace: VoxelFaces, delta: number);
+    toJSON(): VoxelPickResultData;
+}

package/Voxels/Interaction/VoxelPickResult.js

@@ -0,0 +1,55 @@
+import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
+export class VoxelPickResult {
+    rayOrigin;
+    rayDirection;
+    rayLength;
+    voxelData;
+    position;
+    normal;
+    distance;
+    normalPosition;
+    unitRayDirection;
+    unitRayVoxelFace;
+    unitNormal;
+    unitNormalFace;
+    delta;
+    voxel;
+    static FromJSON(data) {
+        return new VoxelPickResult(data.rayOrigin, data.rayDirection, data.rayLength, data.voxelData, data.position, data.normal, data.distance, data.normalPosition, data.unitRayDirection, data.unitRayVoxelFace, data.unitNormal, data.unitNormalFace, data.delta);
+    }
+    constructor(rayOrigin, rayDirection, rayLength, voxelData, position, normal, distance, normalPosition, unitRayDirection, unitRayVoxelFace, unitNormal, unitNormalFace, delta) {
+        this.rayOrigin = rayOrigin;
+        this.rayDirection = rayDirection;
+        this.rayLength = rayLength;
+        this.voxelData = voxelData;
+        this.position = position;
+        this.normal = normal;
+        this.distance = distance;
+        this.normalPosition = normalPosition;
+        this.unitRayDirection = unitRayDirection;
+        this.unitRayVoxelFace = unitRayVoxelFace;
+        this.unitNormal = unitNormal;
+        this.unitNormalFace = unitNormalFace;
+        this.delta = delta;
+        this.voxel = new VoxelCursor();
+        this.voxel.setRaw(voxelData);
+        this.voxel.loadIn();
+    }
+    toJSON() {
+        return {
+            rayOrigin: { ...this.rayOrigin },
+            rayDirection: { ...this.rayDirection },
+            rayLength: this.rayLength,
+            position: { ...this.position },
+            normal: { ...this.normal },
+            distance: this.distance,
+            normalPosition: { ...this.normalPosition },
+            unitRayDirection: { ...this.unitRayDirection },
+            unitRayVoxelFace: this.unitRayVoxelFace,
+            unitNormal: { ...this.unitNormal },
+            unitNormalFace: this.unitNormalFace,
+            voxelData: [...this.voxelData],
+            delta: this.delta,
+        };
+    }
+}

package/Voxels/Logic/Classes/Types/VoxelLogicPoweredType.d.ts

@@ -0,0 +1,8 @@
+import { VoxelLogicEffects, VoxelLogicPoweredData } from "../../VoxelLogic.types";
+import { VoxelCursorInterface } from "../../../Cursor/VoxelCursor.interface";
+import { VoxelLogicType } from "../VoxelLogicType";
+export declare class VoxelLogicPoweredType extends VoxelLogicType<VoxelLogicPoweredData> {
+    init(): void;
+    run(voxel: VoxelCursorInterface): boolean;
+    getEffects(): Generator<VoxelLogicEffects>;
+}

package/Voxels/Logic/Classes/Types/VoxelLogicPoweredType.js

@@ -0,0 +1,13 @@
+import { VoxelLogicType } from "../VoxelLogicType";
+export class VoxelLogicPoweredType extends VoxelLogicType {
+    init() { }
+    run(voxel) {
+        return voxel.getPower() > 0;
+    }
+    *getEffects() {
+        for (const effect of this.data.on)
+            yield effect;
+        for (const effect of this.data.off)
+            yield effect;
+    }
+}

package/Voxels/Logic/Classes/Types/VoxelLogicStateType.d.ts

@@ -0,0 +1,9 @@
+import { VoxelLogicEffects, VoxelLogicStateData } from "../../VoxelLogic.types";
+import { VoxelCursorInterface } from "../../../Cursor/VoxelCursor.interface";
+import { VoxelLogicType } from "../VoxelLogicType";
+export declare class VoxelLogicStateType extends VoxelLogicType<VoxelLogicStateData> {
+    keys: string[];
+    init(): void;
+    run(voxel: VoxelCursorInterface): boolean;
+    getEffects(): Generator<VoxelLogicEffects>;
+}

package/Voxels/Logic/Classes/Types/VoxelLogicStateType.js

@@ -0,0 +1,23 @@
+import { VoxelLogicType } from "../VoxelLogicType";
+export class VoxelLogicStateType extends VoxelLogicType {
+    keys;
+    init() {
+        this.keys = Object.keys(this.data.value);
+    }
+    run(voxel) {
+        this.voxelLogic.schema.state.startEncoding(voxel.getState());
+        for (let i = 0; i < this.keys.length; i++) {
+            const key = this.keys[i];
+            if (this.data.value[key] !== this.voxelLogic.schema.state.get(key)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    *getEffects() {
+        for (const effect of this.data.true)
+            yield effect;
+        for (const effect of this.data.false)
+            yield effect;
+    }
+}

package/Voxels/Logic/Classes/VoxelLogic.d.ts

@@ -0,0 +1,14 @@
+import { VoxelSchema } from "../../State/Schema/VoxelSchema";
+import { VoxelCursorInterface } from "../../Cursor/VoxelCursor.interface";
+import { VoxelLogicData } from "../VoxelLogic.types";
+import { VoxelLogicType } from "./VoxelLogicType";
+export declare class VoxelLogic {
+    voxelId: string;
+    types: VoxelLogicType<any>[];
+    effectedTags: Map<string, VoxelLogicType<any>[]>;
+    schema: VoxelSchema;
+    constructor(voxelId: string, data: VoxelLogicData[]);
+    getTagValue(tagId: string, cursor: VoxelCursorInterface): any;
+    registerEffectOnTag(tagId: string, effect: VoxelLogicType<any>): void;
+    hasTag(tag: string): boolean;
+}