@divinevoxel/vlox 0.0.75 → 0.0.77

package/Mesher/Items/Models/ItemModelBuilder.js

@@ -0,0 +1,64 @@
+import { ProtoMesh } from "../../Geomtry/Proto/ProtoMesh";
+import { Vector3Like } from "@amodx/math";
+import { ItemMeshVertexStructCursor } from "../Geomtry/ItemMeshVertexStructCursor";
+class ItemVars {
+    textureIndex = 0;
+    reset() {
+        this.textureIndex = 0;
+    }
+}
+export class ItemModelBuilder {
+    id;
+    /**The current world position */
+    position = Vector3Like.Create();
+    /**The current local origin  */
+    origin = Vector3Like.Create();
+    mesh = new ProtoMesh(ItemMeshVertexStructCursor.VertexFloatSize);
+    vars = new ItemVars();
+    bounds = {
+        min: [0, 0, 0],
+        max: [0, 0, 0],
+    };
+    _indexStart = 0;
+    constructor(id) {
+        this.id = id;
+    }
+    startConstruction() {
+        this._indexStart = this.mesh.indicieCount;
+        this.bounds.min[0] = Infinity;
+        this.bounds.min[1] = Infinity;
+        this.bounds.min[2] = Infinity;
+        this.bounds.max[0] = -Infinity;
+        this.bounds.max[1] = -Infinity;
+        this.bounds.max[2] = -Infinity;
+        this._boundsUpdate = false;
+    }
+    endConstruction() {
+        this.vars.reset();
+        return true;
+    }
+    _boundsUpdate = false;
+    updateBounds(bounds) {
+        const origin = this.origin;
+        //min
+        if (origin.x + bounds[0][0] < this.bounds.min[0])
+            this.bounds.min[0] = origin.x + bounds[0][0];
+        if (origin.y + bounds[0][1] < this.bounds.min[1])
+            this.bounds.min[1] = origin.y + bounds[0][1];
+        if (origin.z + bounds[0][2] < this.bounds.min[2])
+            this.bounds.min[2] = origin.z + bounds[0][2];
+        //max
+        if (origin.x + bounds[1][0] > this.bounds.max[0])
+            this.bounds.max[0] = origin.x + bounds[1][0];
+        if (origin.y + bounds[1][1] > this.bounds.max[1])
+            this.bounds.max[1] = origin.y + bounds[1][1];
+        if (origin.z + bounds[1][2] > this.bounds.max[2])
+            this.bounds.max[2] = origin.z + bounds[1][2];
+        this._boundsUpdate = true;
+    }
+    clear() {
+        this.vars.reset();
+        this.mesh.clear();
+        return this;
+    }
+}

package/Mesher/Types/ItemMesh.types.d.ts

@@ -0,0 +1,5 @@
+export declare class ItemMeshTypes {
+    static vertexStrideBytes: number;
+    static vertexStrideFloats: number;
+    static VoxelMeshStructWGSL: string;
+}

package/Mesher/Types/ItemMesh.types.js

@@ -0,0 +1,12 @@
+export class ItemMeshTypes {
+    static vertexStrideBytes = 96;
+    static vertexStrideFloats = 24;
+    static VoxelMeshStructWGSL = /* wgsl */ `
+  struct ItemMeshVertex {
+    position: vec3f, 
+    normal: vec3f,     
+    uv: vec2f,    
+    textureIndex: f32,    
+  };
+      `;
+}

package/Mesher/Types/Mesher.types.d.ts

@@ -7,12 +7,18 @@ export type CompactSubMesh = [
     minBounds: Vec3Array,
     maxBounds: Vec3Array
 ];
-export type CompactMeshData = [type: 0, meshes: CompactSubMesh[]] | [
-    type: 1,
-    vertexBuffer: ArrayBuffer,
-    indexBuffer: Uint32Array,
-    bvhTreeBuffer: Float32Array,
-    bvhIndexBuffer: Uint32Array,
-    minBounds: Vec3Array,
-    maxBounds: Vec3Array
-];
+export type CompactMeshData = CompactSubMesh[];
+/**
+ * old web gpu data
+ [
+      type: 1,
+      vertexBuffer: ArrayBuffer,
+      indexBuffer: Uint32Array,
+      bvhTreeBuffer: Float32Array,
+      bvhIndexBuffer: Uint32Array,
+      minBounds: Vec3Array,
+      maxBounds: Vec3Array,
+    ];
+
+ *
+ */

package/Mesher/Types/Mesher.types.js

@@ -1 +1,15 @@
 export {};
+/**
+ * old web gpu data
+ [
+      type: 1,
+      vertexBuffer: ArrayBuffer,
+      indexBuffer: Uint32Array,
+      bvhTreeBuffer: Float32Array,
+      bvhIndexBuffer: Uint32Array,
+      minBounds: Vec3Array,
+      maxBounds: Vec3Array,
+    ];
+
+ *
+ */

package/Mesher/Types/VoxelMesh.types.js

@@ -3,12 +3,13 @@ export class VoxelMeshTypes {
     static vertexStrideFloats = 24;
     static VoxelMeshStructWGSL = /* wgsl */ `
   struct VoxelMeshVertex {
-      position: vec3f,
-      normal: vec3f,
-      voxelData: f32,
-      textureIndex: vec3f,
-      uv: vec2f,
-      colors: vec3f,
+    position: vec3f, 
+    normal: vec3f,     
+    textureIndex: vec3f,    
+    uv: vec2f,    
+    colors: vec3f,
+    voxelData: f32,    
+    _padding: vec4f
   };
       `;
 }

package/Mesher/Voxels/Base/CompactTemplateMesh.d.ts

@@ -0,0 +1,3 @@
+import { CompactMeshData } from "../../Types/Mesher.types";
+import { VoxelModelBuilder } from "../Models/VoxelModelBuilder";
+export declare function CompactTemplateMesh(tools: VoxelModelBuilder[], transfers?: any[]): CompactMeshData;

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,17 +1,19 @@
 //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.voxel = voxel;
     const builder = constructor.builder;
     builder.origin.x = sectionCursor._voxelPosition.x;
     builder.origin.y = sectionCursor._voxelPosition.y;
@@ -68,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,12 +1,12 @@
 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;
-    tree: Float32Array;
+    tree: Float32Array<ArrayBuffer>;
     structCursor: VoxelMeshBVHStructCursor;
-    indices: Uint32Array;
+    indices: Uint32Array<ArrayBuffer>;
     reset(): void;
     getMeshBounds(): {
         min: Vec3Array;

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);
@@ -19,6 +19,8 @@ export function MeshVoxel(rawVoxelData) {
     if (!constructor) {
         throw new Error(`Could not find constructor for voxel [id:${voxel.getStringId()} name:${voxel.getName()}] `);
     }
+    constructor.schema.dataCursor = templateCursor;
+    constructor.schema.voxel = voxel;
     const builder = constructor.builder;
     if (!builder) {
         console.error(builder, constructor.id, constructor);
@@ -38,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,8 +1,8 @@
-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;
+export declare const GradientCheckSetsArray: Int8Array<ArrayBuffer>;
 export declare const GeometryCheckSetIndexes: Record<VoxelFaces, Record<QuadVerticies, [number, number, number]>>;
 export declare const CenterDirectionIndex: number;
 export declare const DirectionIndexes: Record<VoxelFaces, number>;

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)) {