@divinevoxel/vlox 0.0.76 → 0.0.78

package/Mesher/{Functions/CompactVoxelMesh.js → Voxels/Base/CompactTemplateMesh.js}

@@ -60,52 +60,16 @@ function MakeWebGPUMesh(tool: VoxelMesherDataTool): CompactMeshData {
     Vector3Like.ToArray(mesh.maxBounds),
   ];
 } */
-export function CompactVoxelMesh(tools, transfers = []) {
-    const data = [0, []];
+export function CompactTemplateMesh(tools, transfers = []) {
+    const data = [];
     for (let i = 0; i < tools.length; i++) {
         const tool = tools[i];
         if (!tool.mesh.vertexCount)
             continue;
-        const totalVerticies = tool.mesh.vertexCount * VoxelMeshVertexStructCursor.VertexFloatSize;
-        const vertexArray = new Float32Array(totalVerticies);
-        const vertexBuffers = tool.mesh.buffer._buffers;
-        let start = 0;
-        let done = false;
-        for (let i = 0; i < vertexBuffers.length; i++) {
-            const buffer = vertexBuffers[i];
-            for (let j = 0; j < buffer.length; j++) {
-                vertexArray[start] = buffer[j];
-                start++;
-                if (start > totalVerticies) {
-                    done = true;
-                    break;
-                }
-            }
-            if (done)
-                break;
-        }
-        const indiciesArray = tool.mesh.indicieCount > 65535
-            ? new Uint32Array(tool.mesh.indicieCount)
-            : new Uint16Array(tool.mesh.indicieCount);
-        const indiceBuffers = tool.mesh.indices._buffers;
-        start = 0;
-        done = false;
-        for (let i = 0; i < indiceBuffers.length; i++) {
-            const buffer = indiceBuffers[i];
-            for (let j = 0; j < buffer.length; j++) {
-                indiciesArray[start] = buffer[j];
-                start++;
-                if (start > tool.mesh.indicieCount) {
-                    done = true;
-                    break;
-                }
-            }
-            if (done)
-                break;
-        }
+        const { vertexArray, indiciesArray } = tool.mesh.create();
         const minBounds = tool.mesh.minBounds;
         const maxBounds = tool.mesh.maxBounds;
-        data[1].push([
+        data.push([
             tool.id,
             vertexArray,
             indiciesArray,

package/Mesher/{Functions → Voxels/Base}/CompactVoxelSectionMesh.d.ts

@@ -1,4 +1,4 @@
-import { SetSectionMeshTask } from "../Types/Mesher.types";
+import { SetSectionMeshTask } from "../../Types/Mesher.types";
 import { VoxelModelBuilder } from "../Models/VoxelModelBuilder";
-import { LocationData } from "../../Math";
+import { LocationData } from "../../../Math";
 export declare function CompactVoxelSectionMesh(location: LocationData, tools: VoxelModelBuilder[], transfers?: any[]): SetSectionMeshTask;

package/Mesher/{Functions → Voxels}/Base/MeshSectionBase.d.ts

@@ -1,5 +1,5 @@
 import { LocationData } from "../../../Math";
 import type { SetSectionMeshTask } from "../../Types/Mesher.types";
 import { SectionCursor } from "../../../World/Cursor/SectionCursor.js";
-import { DataCursorInterface } from "Voxels/Cursor/DataCursor.interface";
+import { DataCursorInterface } from "../../../Voxels/Cursor/DataCursor.interface";
 export declare function MeshSectionBase(worldCursor: DataCursorInterface, sectionCursor: SectionCursor, location: LocationData, transfers?: any[]): SetSectionMeshTask | null;

package/Mesher/{Functions → Voxels}/Base/MeshSectionBase.js

@@ -1,19 +1,18 @@
 //data
 import { WorldSpaces } from "../../../World/WorldSpaces.js";
 //tools
-import { VoxelGeometryBuilderCacheSpace } from "../../Models/VoxelGeometryBuilderCacheSpace.js";
-import { VoxelModelConstructorRegister } from "../../Models/VoxelModelConstructorRegister.js";
-import { VoxelMeshBVHBuilder } from "../../Geomtry/VoxelMeshBVHBuilder";
+import { VoxelGeometryBuilderCacheSpace } from "../Models/VoxelGeometryBuilderCacheSpace.js";
+import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
+import { VoxelMeshBVHBuilder } from "../Geomtry/VoxelMeshBVHBuilder";
 import { Vector3Like } from "@amodx/math";
-import { RenderedMaterials } from "../../Models/RenderedMaterials";
-import { CompactVoxelSectionMesh } from "../CompactVoxelSectionMesh";
+import { RenderedMaterials } from "../Models/RenderedMaterials";
+import { CompactVoxelSectionMesh } from "./CompactVoxelSectionMesh";
 let space;
 const bvhTool = new VoxelMeshBVHBuilder();
 function meshVoxel(x, y, z, voxel, worldCursor, sectionCursor) {
     let added = false;
     const constructor = VoxelModelConstructorRegister.constructorsPaltte[voxel.getVoxelId()];
     constructor.schema.dataCursor = worldCursor;
-    constructor.schema.dataCursor = worldCursor;
     constructor.schema.voxel = voxel;
     const builder = constructor.builder;
     builder.origin.x = sectionCursor._voxelPosition.x;
@@ -71,12 +70,14 @@ export function MeshSectionBase(worldCursor, sectionCursor, location, transfers
         const y = cy + sectionCursor._voxelPosition.y;
         const z = cz + sectionCursor._voxelPosition.z;
         let addedVoxel = false;
-        if (meshVoxel(x, y, z, voxel, worldCursor, sectionCursor))
+        if (meshVoxel(x, y, z, voxel, worldCursor, sectionCursor)) {
             addedVoxel = true;
+        }
         if (voxel.hasSecondaryVoxel()) {
             voxel.setSecondary(true);
-            if (meshVoxel(x, y, z, voxel, worldCursor, sectionCursor))
+            if (meshVoxel(x, y, z, voxel, worldCursor, sectionCursor)) {
                 addedVoxel = true;
+            }
             voxel.setSecondary(false);
         }
         section.setBuried(i, !addedVoxel);

package/Mesher/{Geomtry → Voxels/Geomtry}/CompactedSectionVoxelMesh.d.ts

@@ -1,5 +1,5 @@
 import { Vec3Array } from "@amodx/math";
-import { LocationData } from "../../Math";
+import { LocationData } from "../../../Math";
 export declare class CompactedMeshData {
     material: number;
     materialId: string;

package/Mesher/{Geomtry → Voxels/Geomtry}/CompactedSectionVoxelMesh.js

@@ -1,4 +1,4 @@
-import { VoxelPalettesRegister } from "../../Voxels/Data/VoxelPalettesRegister";
+import { VoxelPalettesRegister } from "../../../Voxels/Data/VoxelPalettesRegister";
 import { VoxelMeshVertexStructCursor } from "./VoxelMeshVertexStructCursor";
 export class CompactedMeshData {
     material;

package/Mesher/{Geomtry → Voxels/Geomtry}/VoxelGeometryBuilder.d.ts

@@ -1,5 +1,5 @@
 import { VoxelModelBuilder } from "../Models/VoxelModelBuilder";
-import { Quad } from "./Primitives/Quad";
-import { Triangle } from "./Primitives";
+import { Quad } from "../../Geomtry/Primitives/Quad";
+import { Triangle } from "../../Geomtry/Primitives";
 export declare function addVoxelTriangle(builder: VoxelModelBuilder, tri: Triangle): void;
 export declare function addVoxelQuad(builder: VoxelModelBuilder, quad: Quad): void;

package/Mesher/{Geomtry → Voxels/Geomtry}/VoxelGeometryBuilder.js

@@ -1,6 +1,6 @@
 import { Vector4Like } from "@amodx/math";
 import { VoxelShaderData } from "./VoxelShaderData";
-import { QuadVerticies } from "./Geometry.types";
+import { QuadVerticies } from "../../Geomtry/Geometry.types";
 import { VoxelMeshVertexConstants } from "./VoxelMeshVertexStructCursor";
 const vector1ShaderData = Vector4Like.Create();
 const vector2ShaderData = Vector4Like.Create();

package/Mesher/{Geomtry → Voxels/Geomtry}/VoxelMeshBVHBuilder.d.ts

@@ -1,6 +1,6 @@
 import { Vec3Array } from "@amodx/math";
 import { VoxelMeshBVHStructCursor } from "./VoxelMeshBVHStructCursor";
-import { FlatBinaryTreeIndex } from "../../Util/FlatBinaryTreeIndex";
+import { FlatBinaryTreeIndex } from "../../../Util/FlatBinaryTreeIndex";
 export declare class VoxelMeshBVHBuilder {
     static AABBStructByteSize: number;
     treeIndex: FlatBinaryTreeIndex;

package/Mesher/{Geomtry → Voxels/Geomtry}/VoxelMeshBVHBuilder.js

@@ -1,6 +1,6 @@
-import { WorldSpaces } from "../../World/WorldSpaces";
+import { WorldSpaces } from "../../../World/WorldSpaces";
 import { VoxelMeshBVHStructCursor } from "./VoxelMeshBVHStructCursor";
-import { FlatBinaryTreeIndex } from "../../Util/FlatBinaryTreeIndex";
+import { FlatBinaryTreeIndex } from "../../../Util/FlatBinaryTreeIndex";
 const MAX_FLOAT32 = new Float32Array([Infinity])[0];
 export class VoxelMeshBVHBuilder {
     static AABBStructByteSize = (4 + 4) * 4;

package/Mesher/Voxels/MeshTemplate.d.ts

@@ -0,0 +1,3 @@
+import { CompactMeshData } from "../Types/index.js";
+import { FullVoxelTemplateData } from "../../Templates/Full/FullVoxelTemplate.types.js";
+export declare function MeshTemplate(fullVoxelData: FullVoxelTemplateData, baseLightValue?: number): [mesh: CompactMeshData, tranfers: any[]] | false;

package/Mesher/Voxels/MeshTemplate.js

@@ -0,0 +1,81 @@
+import { VoxelGeometryBuilderCacheSpace } from "./Models/VoxelGeometryBuilderCacheSpace.js";
+import { TemplateCursor } from "../../Templates/Cursor/TemplateCursor.js";
+import { FullVoxelTemplate } from "../../Templates/Full/FullVoxelTemplate.js";
+import { CompactTemplateMesh } from "./Base/CompactTemplateMesh.js";
+import { VoxelModelConstructorRegister } from "./Models/VoxelModelConstructorRegister.js";
+import { Vector3Like } from "@amodx/math";
+import { RenderedMaterials } from "./Models/RenderedMaterials.js";
+import { VoxelLightData } from "../../Voxels/Cursor/VoxelLightData.js";
+const templateCursor = new TemplateCursor();
+const padding = Vector3Like.Create(5, 5, 5);
+const lightData = new VoxelLightData();
+function meshVoxel(x, y, z, voxel, templateCursor) {
+    if (voxel.isAir() || !voxel.isRenderable())
+        return false;
+    let added = false;
+    const constructor = VoxelModelConstructorRegister.constructorsPaltte[voxel.getVoxelId()];
+    constructor.schema.dataCursor = templateCursor;
+    constructor.schema.dataCursor = templateCursor;
+    constructor.schema.voxel = voxel;
+    const builder = constructor.builder;
+    builder.origin.x = x;
+    builder.origin.y = y;
+    builder.origin.z = z;
+    builder.position.x = x;
+    builder.position.y = y;
+    builder.position.z = z;
+    builder.voxel = voxel;
+    builder.nVoxel = templateCursor;
+    builder.startConstruction();
+    added = constructor.process();
+    builder.endConstruction();
+    return added;
+}
+export function MeshTemplate(fullVoxelData, baseLightValue = lightData.setS(0xf, 0)) {
+    const template = new FullVoxelTemplate(fullVoxelData);
+    templateCursor.setTemplate(template);
+    const space = new VoxelGeometryBuilderCacheSpace({
+        x: template.bounds.size.x + padding.x,
+        y: template.bounds.size.y + padding.y,
+        z: template.bounds.size.z + padding.z,
+    });
+    space.start(-2, -2, -2);
+    const effects = {};
+    for (let i = 0; i < RenderedMaterials.meshers.length; i++) {
+        const mesher = RenderedMaterials.meshers[i];
+        mesher.space = space;
+        mesher.effects = effects;
+    }
+    const oldLight = template.light.slice();
+    template.light.fill(baseLightValue);
+    const size = template.bounds.size;
+    for (let x = 0; x < size.x; x++) {
+        for (let y = 0; y < size.y; y++) {
+            for (let z = 0; z < size.z; z++) {
+                const voxel = templateCursor.getVoxel(x, y, z);
+                meshVoxel(x, y, z, voxel, templateCursor);
+                if (voxel.hasSecondaryVoxel()) {
+                    voxel.setSecondary(true);
+                    meshVoxel(x, y, z, voxel, templateCursor);
+                    voxel.setSecondary(false);
+                }
+            }
+        }
+    }
+    const meshed = [];
+    for (let i = 0; i < RenderedMaterials.meshers.length; i++) {
+        const mesher = RenderedMaterials.meshers[i];
+        if (!mesher.mesh.vertexCount) {
+            mesher.clear();
+            continue;
+        }
+        meshed.push(mesher);
+    }
+    const transfers = [];
+    const compacted = CompactTemplateMesh(meshed, transfers);
+    for (let i = 0; i < meshed.length; i++) {
+        meshed[i].clear();
+    }
+    template.light.set(oldLight);
+    return [compacted, transfers];
+}

package/Mesher/{Functions → Voxels}/MeshVoxel.d.ts

@@ -1,3 +1,3 @@
 import { RawVoxelData } from "../../Voxels/Types/Voxel.types.js";
-import { CompactMeshData } from "Mesher/Types";
+import { CompactMeshData } from "../Types/index.js";
 export declare function MeshVoxel(rawVoxelData: RawVoxelData): [mesh: CompactMeshData, tranfers: any[]] | false;

package/Mesher/{Functions → Voxels}/MeshVoxel.js

@@ -1,8 +1,8 @@
-import { VoxelGeometryBuilderCacheSpace } from "../Models/VoxelGeometryBuilderCacheSpace.js";
+import { VoxelGeometryBuilderCacheSpace } from "./Models/VoxelGeometryBuilderCacheSpace.js";
 import { TemplateCursor } from "../../Templates/Cursor/TemplateCursor.js";
 import { FullVoxelTemplate } from "../../Templates/Full/FullVoxelTemplate.js";
-import { CompactVoxelMesh } from "../Functions/CompactVoxelMesh.js";
-import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
+import { CompactTemplateMesh } from "./Base/CompactTemplateMesh.js";
+import { VoxelModelConstructorRegister } from "./Models/VoxelModelConstructorRegister.js";
 const template = new FullVoxelTemplate(FullVoxelTemplate.CreateNew([3, 3, 3], 0xf));
 const templateCursor = new TemplateCursor();
 templateCursor.setTemplate(template);
@@ -40,7 +40,7 @@ export function MeshVoxel(rawVoxelData) {
     builder.nVoxel = templateCursor;
     constructor.process();
     const transfers = [];
-    const compacted = CompactVoxelMesh([builder], transfers);
+    const compacted = CompactTemplateMesh([builder], transfers);
     builder.clear();
     return [compacted, transfers];
 }

package/Mesher/{Models → Voxels/Models}/Common/Calc/CalcConstants.d.ts

@@ -1,5 +1,5 @@
-import { QuadVerticies } from "../../../Geomtry/Geometry.types";
-import { VoxelFaces } from "../../../../Math";
+import { QuadVerticies } from "../../../../Geomtry/Geometry.types";
+import { VoxelFaces } from "../../../../../Math";
 import { Vec4Array } from "@amodx/math";
 export declare const GradientCheckSets: Record<VoxelFaces, Record<QuadVerticies, number[]>>;
 export declare const GradientCheckSetsArray: Int8Array<ArrayBuffer>;

package/Mesher/{Models → Voxels/Models}/Common/Calc/CalcConstants.js

@@ -1,7 +1,7 @@
-import { QuadVerticies, } from "../../../Geomtry/Geometry.types";
-import { VoxelFaces, VoxelFacesArray } from "../../../../Math";
-import { VoxelRelativeCubeIndex } from "../../../../Voxels/Models/Indexing/VoxelRelativeCubeIndex";
-import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData";
+import { QuadVerticies } from "../../../../Geomtry/Geometry.types";
+import { VoxelFaces, VoxelFacesArray } from "../../../../../Math";
+import { VoxelRelativeCubeIndex } from "../../../../../Voxels/Models/Indexing/VoxelRelativeCubeIndex";
+import { VoxelLightData } from "../../../../../Voxels/Cursor/VoxelLightData";
 export const GradientCheckSets = [];
 GradientCheckSets[VoxelFaces.Up] = [];
 GradientCheckSets[VoxelFaces.Up][QuadVerticies.TopRight] = [

package/Mesher/{Models → Voxels/Models}/Common/Calc/FaceDataCalc.d.ts

@@ -1,3 +1,3 @@
 import type { VoxelModelBuilder } from "../../VoxelModelBuilder.js";
-import { VoxelFaces } from "../../../../Math/index.js";
+import { VoxelFaces } from "../../../../../Math/index.js";
 export default function calculateFaceData(face: VoxelFaces, builder: VoxelModelBuilder): void;

package/Mesher/{Models → Voxels/Models}/Common/Calc/FaceDataCalc.js

@@ -1,6 +1,6 @@
-import { VoxelFaceDirections } from "../../../../Math/index.js";
+import { VoxelFaceDirections } from "../../../../../Math/index.js";
 import { GradientCheckSets } from "./CalcConstants.js";
-import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData.js";
+import { VoxelLightData } from "../../../../../Voxels/Cursor/VoxelLightData.js";
 const lightData = new VoxelLightData();
 export default function calculateFaceData(face, builder) {
     const x = builder.position.x;

package/Mesher/{Models → Voxels/Models}/Common/Faces/CullRulledFace.js

@@ -1,4 +1,4 @@
-import { VoxelRelativeCubeIndexPositionMap } from "../../../../Voxels/Models/Indexing/VoxelRelativeCubeIndex";
+import { VoxelRelativeCubeIndexPositionMap } from "../../../../../Voxels/Models/Indexing/VoxelRelativeCubeIndex";
 import { VoxelModelConstructorRegister } from "../../VoxelModelConstructorRegister";
 export function CullRulledFace(builder, trueFaceIndex) {
     const faceIndexes = VoxelModelConstructorRegister.faceCullMap[trueFaceIndex];

package/Mesher/{Models → Voxels/Models}/Common/Faces/ShadeRulelessFace.d.ts

@@ -1,4 +1,4 @@
-import { QuadVerticies } from "../../../Geomtry/Geometry.types";
+import { QuadVerticies } from "../../../../Geomtry/Geometry.types";
 import { VoxelModelBuilder } from "../../../Models/VoxelModelBuilder";
 import { Vec4Array } from "@amodx/math";
 export declare function ShadeRulelessFace(builder: VoxelModelBuilder, lightData: Record<QuadVerticies, number>, vertexWeights: Vec4Array[], verticesStride: number): void;

package/Mesher/{Models → Voxels/Models}/Common/Faces/ShadeRulledFace.d.ts

@@ -1,4 +1,4 @@
 import { VoxelModelBuilder } from "../../VoxelModelBuilder";
 import { Vec4Array } from "@amodx/math";
-import { QuadVerticies } from "../../../Geomtry/Geometry.types";
+import { QuadVerticies } from "../../../../Geomtry/Geometry.types";
 export declare function ShadeRulledFace(builder: VoxelModelBuilder, trueFaceIndex: number, lightData: Record<QuadVerticies, number>, vertexWeights: Vec4Array[], vertexStride: number): void;

package/Mesher/{Models → Voxels/Models}/Common/Faces/ShadeRulledFace.js

@@ -1,4 +1,4 @@
-import { VoxelRelativeCubeIndexPositionMap } from "../../../../Voxels/Models/Indexing/VoxelRelativeCubeIndex";
+import { VoxelRelativeCubeIndexPositionMap } from "../../../../../Voxels/Models/Indexing/VoxelRelativeCubeIndex";
 import { VoxelModelConstructorRegister } from "../../VoxelModelConstructorRegister";
 import { getInterpolationValue } from "../Calc/CalcConstants";
 export function ShadeRulledFace(builder, trueFaceIndex, lightData, vertexWeights, vertexStride) {

package/Mesher/{Models → Voxels/Models}/Common/GetTexture.d.ts

@@ -1,6 +1,6 @@
 import { BaseVoxelGeomtryTextureProcedureData } from "../Procedures/TextureProcedure";
 import { VoxelModelBuilder } from "../VoxelModelBuilder";
-import { Quad } from "../../Geomtry";
-import { VoxelFaces } from "../../../Math";
-import { Triangle } from "../../Geomtry";
+import { Quad } from "../../../Geomtry";
+import { VoxelFaces } from "../../../../Math";
+import { Triangle } from "../../../Geomtry";
 export declare function GetTexture(builder: VoxelModelBuilder, data: number | BaseVoxelGeomtryTextureProcedureData, closestFace: VoxelFaces, primitive: Quad | Triangle): void;

package/Mesher/{Models → Voxels/Models}/Nodes/Custom/Liquid/FlowGradient.d.ts

@@ -1,5 +1,5 @@
 import type { VoxelModelBuilder } from "../../../VoxelModelBuilder";
-import { QuadScalarVertexData } from "../../../../Geomtry/Primitives/QuadVertexData";
+import { QuadScalarVertexData } from "../../../../../Geomtry/Primitives/QuadVertexData";
 import { CompassAngles } from "@amodx/math";
 export declare enum FlowVerticies {
     NorthEast = 0,

package/Mesher/{Models → Voxels/Models}/Nodes/Custom/Liquid/FlowGradient.js

@@ -1,4 +1,4 @@
-import { QuadVerticies } from "../../../../Geomtry/Geometry.types";
+import { QuadVerticies } from "../../../../../Geomtry/Geometry.types";
 import { CompassAngles } from "@amodx/math";
 var FlowStates;
 (function (FlowStates) {

package/Mesher/{Models → Voxels/Models}/Nodes/Custom/Liquid/LiquidGeomtryNode.d.ts

@@ -1,7 +1,7 @@
 import { GeoemtryNode } from "../../GeometryNode";
-import { VoxelCustomGeomtryNode } from "../../../../../Voxels/Models/VoxelModel.types";
-import { VoxelFaces } from "../../../../../Math";
-import type { LiquidVoxelModelArgs } from "../../../../../Voxels/Models/Defaults/LiquidVoxelModel";
+import { VoxelCustomGeomtryNode } from "../../../../../../Voxels/Models/VoxelModel.types";
+import { VoxelFaces } from "../../../../../../Math";
+import type { LiquidVoxelModelArgs } from "../../../../../../Voxels/Models/Defaults/LiquidVoxelModel";
 export declare class LiquidGeometryNode extends GeoemtryNode<VoxelCustomGeomtryNode, LiquidVoxelModelArgs> {
     init(): void;
     isExposed(face: VoxelFaces): boolean;

package/Mesher/{Models → Voxels/Models}/Nodes/Custom/Liquid/LiquidGeomtryNode.js

@@ -1,14 +1,14 @@
 import { GeoemtryNode } from "../../GeometryNode";
 import { CompassAngles } from "@amodx/math";
-import { Quad } from "../../../../Geomtry/Primitives/Quad";
-import { QuadVerticies } from "../../../../Geomtry/Geometry.types";
-import { QuadScalarVertexData } from "../../../../Geomtry/Primitives/QuadVertexData";
-import { VoxelFaceDirections, VoxelFaces } from "../../../../../Math";
+import { Quad } from "../../../../../Geomtry/Primitives/Quad";
+import { QuadVerticies, } from "../../../../../Geomtry/Geometry.types";
+import { QuadScalarVertexData } from "../../../../../Geomtry/Primitives/QuadVertexData";
+import { VoxelFaceDirections, VoxelFaces } from "../../../../../../Math";
 import { getFlowAngle, getFlowGradient, FlowVerticies } from "./FlowGradient";
-import { VoxelLightData } from "../../../../../Voxels/Cursor/VoxelLightData";
+import { VoxelLightData } from "../../../../../../Voxels/Cursor/VoxelLightData";
 import { addVoxelQuad } from "../../../../Geomtry/VoxelGeometryBuilder";
 import { GetTexture } from "../../../Common/GetTexture";
-import { Box } from "../../../../Geomtry/Shapes/Box";
+import { Box } from "../../../../../Geomtry/Shapes/Box";
 const vertexValue = new QuadScalarVertexData();
 const vertexLevel = new QuadScalarVertexData();
 const lightData = new VoxelLightData();
@@ -33,25 +33,23 @@ const { quads: Quads } = Box.Create([
     [0, 0, 0],
     [1, waterHeight, 1],
 ]);
-const { quads: Quads2 } = Box.Create([
-    [0, 0, 0],
-    [1, waterHeight, 1],
-]);
 Quads[VoxelFaces.Up].setUVs(uvs);
 Quads[VoxelFaces.Down].setUVs(uvs);
 export class LiquidGeometryNode extends GeoemtryNode {
     init() { }
     isExposed(face) {
         /*     if (this.builder.voxel.getLevel() <= 0 || this.builder.voxel.getLevelState() && face !== VoxelFaces.Up) {
-              return true;
-            } */
+          return true;
+        } */
         const nv = this.builder.nVoxel.getVoxel(VoxelFaceDirections[face][0] + this.builder.position.x, VoxelFaceDirections[face][1] + this.builder.position.y, VoxelFaceDirections[face][2] + this.builder.position.z);
-        if (!nv || (face == VoxelFaces.Up && nv.isAir()))
+        if (!nv)
             return true;
         if (this.builder.voxel.isSameVoxel(nv))
             return false;
         if (nv.isAir() || nv.tags["dve_is_transparent"])
             return true;
+        if (face == VoxelFaces.Up)
+            return true;
         return false;
     }
     determineShading(face) {
@@ -76,9 +74,9 @@ export class LiquidGeometryNode extends GeoemtryNode {
             currentHeight = 1 - builder.voxel.getLevel() / 7;
         }
         /*     if (builder.voxel.getLevelState() == 1 || builder.voxel.getLevel() == 0) {
-              flowTexture = 0;
-              stillTexture = 0;
-            } */
+          flowTexture = 0;
+          stillTexture = 0;
+        } */
         let added = false;
         let upFaceExposed = false;
         if (this.isExposed(VoxelFaces.Up)) {

package/Mesher/{Models → Voxels/Models}/Nodes/Default/QuadVoxelGeometryNode.d.ts

@@ -1,6 +1,6 @@
 import { Vec4Array } from "@amodx/math";
-import { VoxelFaces } from "../../../../Math";
-import { Quad } from "../../../Geomtry/Primitives/Quad";
+import { VoxelFaces } from "../../../../../Math";
+import { Quad } from "../../../../Geomtry/Primitives/Quad";
 import { GeoemtryNode } from "../GeometryNode";
 import { CompiledQuadVoxelGeomtryNode, QuadVoxelGometryArgs } from "../Types/QuadVoxelGometryNodeTypes";
 export declare class QuadVoxelGometryNode extends GeoemtryNode<CompiledQuadVoxelGeomtryNode, QuadVoxelGometryArgs> {

package/Mesher/{Models → Voxels/Models}/Nodes/Default/QuadVoxelGeometryNode.js

@@ -1,4 +1,4 @@
-import { Quad } from "../../../Geomtry/Primitives/Quad";
+import { Quad } from "../../../../Geomtry/Primitives/Quad";
 import { addVoxelQuad } from "../../../Geomtry/VoxelGeometryBuilder";
 import { GeoemtryNode } from "../GeometryNode";
 import { QuadVoxelGometryInputs, } from "../Types/QuadVoxelGometryNodeTypes";

package/Mesher/{Models → Voxels/Models}/Nodes/Default/TriangleVoxelGeometryNode.d.ts

@@ -1,8 +1,8 @@
 import { Vec4Array } from "@amodx/math";
-import { VoxelFaces } from "../../../../Math";
+import { VoxelFaces } from "../../../../../Math";
 import { GeoemtryNode } from "../GeometryNode";
 import { CompiledTriangleVoxelGeomtryNode, TriangleVoxelGometryArgs } from "../Types/TriangleVoxelGometryNodeTypes";
-import { Triangle } from "../../../Geomtry/Primitives/Triangle";
+import { Triangle } from "../../../../Geomtry/Primitives/Triangle";
 export declare class TriangleVoxelGeometryNode extends GeoemtryNode<CompiledTriangleVoxelGeomtryNode, TriangleVoxelGometryArgs> {
     triangle: Triangle;
     vertexWeights: Vec4Array[];

package/Mesher/{Models → Voxels/Models}/Nodes/Default/TriangleVoxelGeometryNode.js

@@ -2,7 +2,7 @@ import { addVoxelTriangle } from "../../../Geomtry/VoxelGeometryBuilder";
 import { GeoemtryNode } from "../GeometryNode";
 import { GetTexture } from "../../Common/GetTexture";
 import { TriangleVoxelGometryInputs, } from "../Types/TriangleVoxelGometryNodeTypes";
-import { Triangle } from "../../../Geomtry/Primitives/Triangle";
+import { Triangle } from "../../../../Geomtry/Primitives/Triangle";
 import { CullRulledFace } from "../../Common/Faces/CullRulledFace";
 import { ShadeRulledFace } from "../../Common/Faces/ShadeRulledFace";
 import { ShadeRulelessFace } from "../../Common/Faces/ShadeRulelessFace";

package/Mesher/{Models → Voxels/Models}/Nodes/Types/QuadVoxelGometryNodeTypes.d.ts

@@ -1,6 +1,6 @@
 import { Vec3Array, Vec4Array } from "@amodx/math";
-import { QuadUVData } from "../../../Geomtry/Geometry.types";
-import { VoxelFaces } from "../../../../Math";
+import { QuadUVData } from "../../../../Geomtry/Geometry.types";
+import { VoxelFaces } from "../../../../../Math";
 export type QuadVoxelGometryArgs = [
     enabled: boolean,
     texture: number,

package/Mesher/{Models → Voxels/Models}/Nodes/Types/TriangleVoxelGometryNodeTypes.d.ts

@@ -1,5 +1,5 @@
 import { Vec2Array, Vec3Array, Vec4Array } from "@amodx/math";
-import { VoxelFaces } from "../../../../Math";
+import { VoxelFaces } from "../../../../../Math";
 export type TriangleVoxelGometryArgs = [
     enabled: boolean,
     texture: number,

package/Mesher/{Models → Voxels/Models}/Nodes/VoxelGeometryConstructor.d.ts

@@ -1,6 +1,6 @@
-import { CompiledVoxelGeometrySyncData } from "../../../Voxels/Models/CompiledVoxelModel.types";
+import { CompiledVoxelGeometrySyncData } from "../../../../Voxels/Models/CompiledVoxelModel.types";
 import { GeoemtryNode } from "./GeometryNode";
-import { CullingProcedureData } from "../../../Voxels/Models/VoxelModel.types";
+import { CullingProcedureData } from "../../../../Voxels/Models/VoxelModel.types";
 export declare class VoxelGeometryConstructor {
     geometryPaletteId: number;
     nodes: GeoemtryNode<any, any>[];

package/Mesher/Voxels/Models/Procedures/Default/ConsistentRotationTextureProcedure.d.ts

@@ -0,0 +1,24 @@
+import { Vec3Array, Vector4Like } from "@amodx/math";
+import type { Quad } from "../../../../Geomtry";
+import { VoxelModelBuilder } from "Mesher/Voxels/Models/VoxelModelBuilder";
+import { TextureProcedure, BaseVoxelGeomtryTextureProcedureData } from "../TextureProcedure";
+import { TextureId } from "Textures";
+import { VoxelFaces } from "Math";
+/**
+ * Extend your data type so we can add a seed if we want, and define
+ * the rotations we can choose from.
+ */
+export interface ConsistentRotationTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
+    type: "consistent-rotation";
+    texture: TextureId | number;
+    /**
+     * You can allow (0 | 90 | 180 | 270), or remove 0 if you don’t want an unrotated option
+     */
+    rotations: (0 | 90 | 180 | 270)[];
+    rotationBounds?: Vec3Array;
+}
+export declare class ConsistentRotationTextureProcedure extends TextureProcedure<ConsistentRotationTextureProcedureData> {
+    getTexture(builder: VoxelModelBuilder, data: ConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): number;
+    getOverlayTexture(builder: VoxelModelBuilder, data: ConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad, ref: Vector4Like): Vector4Like;
+    transformUVs(builder: VoxelModelBuilder, data: ConsistentRotationTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): void;
+}

package/Mesher/{Models → Voxels/Models}/Procedures/Default/ConsistentRotationTextureProcedure.js

@@ -1,7 +1,7 @@
 import { Vector3Like } from "@amodx/math";
 import { TextureProcedure, } from "../TextureProcedure";
-import { WorldSpaces } from "../../../../World/WorldSpaces";
-import { GetYXZOrderArrayIndex } from "../../../../Math/Indexing";
+import { WorldSpaces } from "../../../../../World/WorldSpaces";
+import { GetYXZOrderArrayIndex } from "../../../../../Math/Indexing";
 const voxelPos = Vector3Like.Create();
 const defaultBounds = [4, 4, 4];
 export class ConsistentRotationTextureProcedure extends TextureProcedure {

package/Mesher/{Models → Voxels/Models}/Procedures/Default/OutlinedTextureProcedure.d.ts

@@ -1,10 +1,10 @@
 import { Vector4Like } from "@amodx/math";
-import type { Quad } from "../../../Geomtry";
-import { VoxelModelBuilder } from "Mesher/Models/VoxelModelBuilder";
+import type { Quad } from "../../../../Geomtry";
+import { VoxelModelBuilder } from "Mesher/Voxels/Models/VoxelModelBuilder";
 import { TextureProcedure, BaseVoxelGeomtryTextureProcedureData } from "../TextureProcedure";
 import { TextureId } from "Textures";
-import { VoxelFaces } from "../../../../Math/index.js";
-interface OutlinedTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
+import { VoxelFaces } from "../../../../../Math/index.js";
+export interface OutlinedTextureProcedureData extends BaseVoxelGeomtryTextureProcedureData {
     type: "outlined";
     texture: TextureId | number;
     textureRecrod: {
@@ -25,4 +25,3 @@ export declare class OutlinedTextureProcedure extends TextureProcedure<OutlinedT
     getOverlayTexture(builder: VoxelModelBuilder, data: OutlinedTextureProcedureData, closestFace: VoxelFaces, primitive: Quad, ref: Vector4Like): Vector4Like;
     transformUVs(builder: VoxelModelBuilder, data: OutlinedTextureProcedureData, closestFace: VoxelFaces, primitive: Quad): void;
 }
-export {};