@divinevoxel/vlox 0.0.72 → 0.0.73

package/Mesher/Models/Nodes/Custom/Liquid/LiquidGeomtryNode.js

@@ -49,12 +49,13 @@ export class LiquidGeometryNode extends GeoemtryNode {
         return false;
     }
     determineShading(face) {
-        const tool = this.builder;
-        const lightData = tool.lightData[face];
+        this.builder.calculateFaceData(face);
+        const lightData = this.builder.lightData[face];
         const worldLight = this.builder.vars.light;
-        for (let v = 0; v < 4; v++) {
-            worldLight.vertices[v] = lightData[v];
-        }
+        worldLight.vertices[0] = lightData[0];
+        worldLight.vertices[1] = lightData[1];
+        worldLight.vertices[2] = lightData[2];
+        worldLight.vertices[3] = lightData[3];
     }
     shouldFlip() {
         const worldLight = this.builder.vars.light;
@@ -72,7 +73,6 @@ export class LiquidGeometryNode extends GeoemtryNode {
             added = true;
             getFlowGradient(tool, vertexLevel);
             const quad = Quads[VoxelFaces.Up];
-            tool.calculateFaceData(VoxelFaces.Up);
             this.determineShading(VoxelFaces.Up);
             quad.flip = this.shouldFlip();
             tool.vars.textureIndex = args.stillTexture;
@@ -99,19 +99,16 @@ export class LiquidGeometryNode extends GeoemtryNode {
             added = true;
             tool.vars.textureIndex = args.stillTexture;
             const quad = Quads[VoxelFaces.Down];
-            tool.calculateFaceData(VoxelFaces.Down);
             this.determineShading(VoxelFaces.Down);
             quad.flip = this.shouldFlip();
-            tool.vars.textureIndex = args.stillTexture;
             VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
             tool.updateBounds(quadBounds[VoxelFaces.Down]);
         }
         if (this.isExposed(VoxelFaces.North)) {
             added = true;
-            tool.vars.textureIndex = args.stillTexture;
+            tool.vars.textureIndex = args.flowTexture;
             const quad = Quads[VoxelFaces.North];
             tool.vars.animation.setAll(1);
-            tool.calculateFaceData(VoxelFaces.North);
             this.determineShading(VoxelFaces.North);
             quad.flip = this.shouldFlip();
             if (upFaceExposed) {
@@ -134,10 +131,9 @@ export class LiquidGeometryNode extends GeoemtryNode {
         }
         if (this.isExposed(VoxelFaces.South)) {
             added = true;
-            tool.vars.textureIndex = args.stillTexture;
+            tool.vars.textureIndex = args.flowTexture;
             const quad = Quads[VoxelFaces.South];
             tool.vars.animation.setAll(1);
-            tool.calculateFaceData(VoxelFaces.South);
             this.determineShading(VoxelFaces.South);
             quad.flip = this.shouldFlip();
             if (upFaceExposed) {
@@ -160,12 +156,11 @@ export class LiquidGeometryNode extends GeoemtryNode {
         }
         if (this.isExposed(VoxelFaces.East)) {
             added = true;
-            tool.vars.textureIndex = args.stillTexture;
+            tool.vars.textureIndex = args.flowTexture;
             const quad = Quads[VoxelFaces.East];
             tool.vars.animation.setAll(1);
-            tool.calculateFaceData(VoxelFaces.East);
             this.determineShading(VoxelFaces.East);
-            //  quad.flip = this.shouldFlip();
+            quad.flip = this.shouldFlip();
             if (upFaceExposed) {
                 quad.positions.vertices[QuadVerticies.TopRight].y =
                     vertexValue.vertices[FlowVerticies.NorthEast] * waterHeight;
@@ -186,10 +181,9 @@ export class LiquidGeometryNode extends GeoemtryNode {
         }
         if (this.isExposed(VoxelFaces.West)) {
             added = true;
-            tool.vars.textureIndex = args.stillTexture;
+            tool.vars.textureIndex = args.flowTexture;
             const quad = Quads[VoxelFaces.West];
             tool.vars.animation.setAll(1);
-            tool.calculateFaceData(VoxelFaces.West);
             this.determineShading(VoxelFaces.West);
             quad.flip = this.shouldFlip();
             if (upFaceExposed) {

package/Mesher/Models/Nodes/GeometryNode.d.ts

@@ -1,4 +1,4 @@
-import { VoxelMesherDataTool } from "../../../Mesher/Tools/VoxelMesherDataTool";
+import { VoxelModelBuilder } from "../VoxelModelBuilder";
 import { VoxelGeometryConstructor } from "./VoxelGeometryConstructor";
 import { VoxelGeometryTransform } from "../../../Voxels/Types/VoxelModelCompiledData.types";
 export interface GeoemtryNodeConstructor<Data = any, Args = any> {
@@ -13,7 +13,7 @@ export declare abstract class GeoemtryNode<Data = any, Args = any> {
     vertexIndex: number;
     faceCount: number;
     vertexCount: number;
-    builder: VoxelMesherDataTool;
+    builder: VoxelModelBuilder;
     constructor(geometryPaletteId: number, geomtry: VoxelGeometryConstructor, data: Data, transform: VoxelGeometryTransform);
     abstract init(): void;
     abstract add(args: Args): boolean;

package/Mesher/Models/Nodes/Ruled/BoxVoxelGeometryNode.d.ts

@@ -14,6 +14,7 @@ export declare class BoxVoxelGometryNode extends GeoemtryNode<VoxelBoxGeometryNo
         Vec4Array,
         Vec4Array
     ]>;
+    _wasAOShaded: boolean;
     lightData: VoxelLightData;
     init(): void;
     isExposed(face: VoxelFaces): boolean;

package/Mesher/Models/Nodes/Ruled/BoxVoxelGeometryNode.js

@@ -11,6 +11,7 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
     quads;
     quadBounds = [];
     vertexWeights;
+    _wasAOShaded = false;
     lightData = new VoxelLightData();
     init() {
         this.faceCount = 6;
@@ -41,8 +42,8 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                         continue;
                     const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
                     if (faceIndex > -1 &&
-                        !this.builder
-                            .space.getConstructor(hashed)
+                        !this.builder.space
+                            .getConstructor(hashed)
                             ?.isShapeStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], geoId, faceIndex)) {
                         return false;
                     }
@@ -58,8 +59,8 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                         continue;
                     const faceIndex = this.geomtry.cullIndex.getValue(geoId, currentIndex, trueFaceIndex);
                     if (faceIndex > -1 &&
-                        !this.builder
-                            .space.getConstructor(hashed)
+                        !this.builder.space
+                            .getConstructor(hashed)
                             ?.isCondtionalStateFaceTransparent(this.builder.space.modCache[hashed], this.builder.space.stateCache[hashed], geoId, faceIndex))
                         return false;
                 }
@@ -99,21 +100,28 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
                     length = baseGeo.length;
                     for (let geoIndex = 0; geoIndex < length; geoIndex++) {
                         if (this.geomtry.aoIndex.getValue(baseGeo[geoIndex], currentIndex, trueVertexIndex)) {
-                            worldAO.vertices[v] = 1;
-                            shaded = true;
-                            break;
+                            this._wasAOShaded = true;
+                            worldAO.vertices[v]++;
+                            if (worldAO.vertices[v] > 4) {
+                                shaded = true;
+                                break;
+                            }
                         }
                     }
                 }
-                if (!conditonalGeo)
+                if (!conditonalGeo || shaded)
                     continue;
                 length = conditonalGeo.length;
                 for (let condtionsIndex = 0; condtionsIndex < length; condtionsIndex++) {
                     const condiotnalength = conditonalGeo[condtionsIndex].length;
                     for (let geoIndex = 0; geoIndex < condiotnalength; geoIndex++) {
                         if (this.geomtry.aoIndex.getValue(conditonalGeo[condtionsIndex][geoIndex], currentIndex, trueVertexIndex)) {
-                            worldAO.vertices[v] = 1;
-                            break;
+                            this._wasAOShaded = true;
+                            worldAO.vertices[v]++;
+                            if (worldAO.vertices[v] > 4) {
+                                shaded = true;
+                                break;
+                            }
                         }
                     }
                 }
@@ -122,9 +130,12 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
     }
     shouldFlip() {
         const worldAO = this.builder.vars.ao;
-        const worldLight = this.builder.vars.light;
-        if (shouldCauseFlip(worldAO.vertices[0], worldAO.vertices[1], worldAO.vertices[2], worldAO.vertices[3]))
+        if (shouldCauseFlip(worldAO.vertices[0], worldAO.vertices[1], worldAO.vertices[2], worldAO.vertices[3]) &&
+            this._wasAOShaded)
             return true;
+        if (this._wasAOShaded)
+            return false;
+        const worldLight = this.builder.vars.light;
         return (shouldCauseFlip(this.lightData.getS(worldLight.vertices[0]), this.lightData.getS(worldLight.vertices[1]), this.lightData.getS(worldLight.vertices[2]), this.lightData.getS(worldLight.vertices[3])) ||
             shouldCauseFlip(this.lightData.sumRGB(worldLight.vertices[0]), this.lightData.sumRGB(worldLight.vertices[1]), this.lightData.sumRGB(worldLight.vertices[2]), this.lightData.sumRGB(worldLight.vertices[3])));
     }
@@ -159,6 +170,7 @@ export class BoxVoxelGometryNode extends GeoemtryNode {
         }
         this.builder.vars.ao.setAll(0);
         this.builder.vars.light.setAll(0);
+        this._wasAOShaded = false;
         return added;
     }
 }

package/Mesher/{Tools → Models/Protocols}/OutlinedVoxelTool.d.ts

@@ -1,4 +1,4 @@
-import type { TextureId } from "../../Textures/Texture.types.js";
+import type { TextureId } from "../../../Textures/Texture.types.js";
 export declare class OutlinedVoxelTool {
     static _currentTexts: number[];
     static setCurrentTextures(textures: number[]): void;

package/Mesher/{Tools → Models/Protocols}/OutlinedVoxelTool.js

@@ -1,4 +1,4 @@
-import { VoxelFaces } from "../../Math/index.js";
+import { VoxelFaces } from "../../../Math/index.js";
 /*
 0 -> normal direction
 1 -> top right

package/Mesher/Models/RenderedMaterials.d.ts

@@ -0,0 +1,6 @@
+import { VoxelModelBuilder } from "./VoxelModelBuilder";
+export declare class RenderedMaterials {
+    static meshersMap: Map<string, VoxelModelBuilder>;
+    static meshers: VoxelModelBuilder[];
+    static register(materials: string[]): void;
+}

package/Mesher/{RenderedMaterials.js → Models/RenderedMaterials.js}

@@ -1,10 +1,10 @@
-import { VoxelMesherDataTool } from "./Tools/VoxelMesherDataTool";
+import { VoxelModelBuilder } from "./VoxelModelBuilder";
 export class RenderedMaterials {
     static meshersMap = new Map();
     static meshers = [];
     static register(materials) {
         for (let i = 0; i < materials.length; i++) {
-            const newTool = new VoxelMesherDataTool(materials[i], i);
+            const newTool = new VoxelModelBuilder(materials[i], i);
             this.meshersMap.set(materials[i], newTool);
             this.meshers[i] = newTool;
         }

package/Mesher/Models/VoxelConstructor.d.ts

@@ -1,4 +1,4 @@
-import { VoxelMesherDataTool } from "../../Mesher/Tools/VoxelMesherDataTool";
+import { VoxelModelBuilder } from "./VoxelModelBuilder";
 import { CompiledVoxelModelInputData, CompiledVoxelModelData } from "../../Voxels/Types/VoxelModelCompiledData.types";
 import { StateSchema } from "../../Voxels/State/Schema/StateSchema";
 import { StateTreeReader } from "../../Voxels/State/StateTreeReader";
@@ -7,7 +7,7 @@ import { VoxelModelEffect } from "./VoxelModelEffect";
 import { CondtionalTreeReader } from "../../Voxels/State/CondiotnalTreeReader";
 export declare class VoxelConstructor {
     id: string;
-    builder: VoxelMesherDataTool;
+    builder: VoxelModelBuilder;
     data: CompiledVoxelModelData;
     isModel: true;
     geometries: number[][];
@@ -20,7 +20,7 @@ export declare class VoxelConstructor {
     effects: VoxelModelEffect;
     shapeStateTree: StateTreeReader;
     condtioanlShapeStateTree: CondtionalTreeReader;
-    constructor(id: string, builder: VoxelMesherDataTool, data: CompiledVoxelModelData, voxleData: CompiledVoxelModelInputData);
+    constructor(id: string, builder: VoxelModelBuilder, data: CompiledVoxelModelData, voxleData: CompiledVoxelModelInputData);
     isShapeStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;
     isCondtionalStateFaceTransparent(modState: number, shapeState: number, geoId: number, faceIndex: number): boolean;
     process(): boolean;

package/Mesher/Models/VoxelGeometryBuilderCacheSpace.d.ts

@@ -1,11 +1,10 @@
-import { DataCursorInterface } from "../../Tools/DataCursor.interface";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface";
 import { Vec3Array, Vector3Like } from "@amodx/math";
 import { VoxelCursor } from "../../Voxels/Cursor/VoxelCursor";
 export declare class VoxelGeometryBuilderCacheSpace {
     bounds: Vector3Like;
     foundHash: Uint8Array;
     voxelCache: Uint16Array;
-    lightCache: Int32Array;
     modCache: Int32Array;
     stateCache: Int32Array;
     conditonalStateCache: Int32Array;
@@ -19,6 +18,5 @@ export declare class VoxelGeometryBuilderCacheSpace {
     getGeomtry(index: number): false | number[];
     getConditionalGeomtry(index: number): false | number[][];
     getHash(dataCursor: DataCursorInterface, x: number, y: number, z: number): number;
-    getLight(dataCursor: DataCursorInterface, x: number, y: number, z: number): number;
     private hashState;
 }

package/Mesher/Models/VoxelGeometryBuilderCacheSpace.js

@@ -5,7 +5,6 @@ export class VoxelGeometryBuilderCacheSpace {
     bounds;
     foundHash;
     voxelCache;
-    lightCache;
     modCache;
     stateCache;
     conditonalStateCache;
@@ -16,7 +15,6 @@ export class VoxelGeometryBuilderCacheSpace {
         this.bounds = bounds;
         const volume = bounds.x * bounds.y * bounds.z;
         this.foundHash = new Uint8Array(volume);
-        this.lightCache = new Int32Array(volume);
         this.voxelCache = new Uint16Array(volume);
         this.modCache = new Int32Array(volume);
         this.stateCache = new Int32Array(volume);
@@ -27,7 +25,6 @@ export class VoxelGeometryBuilderCacheSpace {
         this.offset[0] = x;
         this.offset[1] = y;
         this.offset[2] = z;
-        this.lightCache.fill(-1);
         this.foundHash.fill(0);
         this.voxelCache.fill(0);
         this.modCache.fill(-1);
@@ -60,32 +57,12 @@ export class VoxelGeometryBuilderCacheSpace {
         }
         return hashed;
     }
-    getLight(dataCursor, x, y, z) {
-        const index = this.getIndex(x, y, z);
-        if (this.lightCache[index] == -1) {
-            this.lightCache[index] = 0;
-            const voxel = dataCursor.getVoxel(x, y, z);
-            if (voxel) {
-                const light = voxel.getLight();
-                if (light > 0) {
-                    this.lightCache[index] = light;
-                }
-            }
-        }
-        return this.lightCache[index];
-    }
     hashState(dataCursor, index, x, y, z) {
         if (this.foundHash[index] == 1)
             return -1;
         if (this.foundHash[index] == 2)
             return this.stateCache[index];
         const voxel = dataCursor.getVoxel(x, y, z);
-        if (voxel) {
-            const light = voxel.getLight();
-            if (light > 0) {
-                this.lightCache[index] = light;
-            }
-        }
         if (!voxel || !voxel.isRenderable()) {
             this.foundHash[index] = 1;
             return -1;

package/Mesher/{Tools/VoxelMesherDataTool.d.ts → Models/VoxelModelBuilder.d.ts}

@@ -1,13 +1,12 @@
-import { MesherDataTool } from "../Geomtry/Tools/MesherDataTools";
 import { QuadScalarVertexData } from "../Geomtry/Primitives/QuadVertexData";
 import { VoxelFaces } from "../../Math";
 import { QuadVerticies } from "../Geomtry/Geometry.types";
 import { VoxelMesh } from "../Geomtry/VoxelMesh";
-import { VoxelMeshBVHBuilder } from "./VoxelMeshBVHBuilder";
+import { VoxelMeshBVHBuilder } from "../Geomtry/VoxelMeshBVHBuilder";
 import { Vec3Array, Vector3Like, Vector4Like } from "@amodx/math";
 import { VoxelCursorInterface } from "../../Voxels/Cursor/VoxelCursor.interface.js";
-import { DataCursorInterface } from "../../Tools/DataCursor.interface.js";
-import { VoxelGeometryBuilderCacheSpace } from "../Models/VoxelGeometryBuilderCacheSpace";
+import { DataCursorInterface } from "../../Voxels/Cursor/DataCursor.interface.js";
+import { VoxelGeometryBuilderCacheSpace } from "./VoxelGeometryBuilderCacheSpace";
 declare class VoxelVars {
     faceFlipped: boolean;
     textureIndex: number;
@@ -18,7 +17,7 @@ declare class VoxelVars {
     level: QuadScalarVertexData;
     reset(): void;
 }
-export declare class VoxelMesherDataTool extends MesherDataTool {
+export declare class VoxelModelBuilder {
     id: string;
     materialIndex: number;
     space: VoxelGeometryBuilderCacheSpace;

package/Mesher/{Tools/VoxelMesherDataTool.js → Models/VoxelModelBuilder.js}

@@ -1,10 +1,9 @@
 //tools
-import { MesherDataTool } from "../Geomtry/Tools/MesherDataTools";
 //data
 import { QuadScalarVertexData } from "../Geomtry/Primitives/QuadVertexData";
 import { VoxelFaces, VoxelFacesArray } from "../../Math";
 import { QuadVerticies } from "../Geomtry/Geometry.types";
-import calculateFaceData from "../Models/Common/Calc/FaceDataCalc.js";
+import calculateFaceData from "./Common/Calc/FaceDataCalc.js";
 import { VoxelMesh } from "../Geomtry/VoxelMesh";
 import { Vector3Like, Vector4Like } from "@amodx/math";
 class VoxelVars {
@@ -23,7 +22,7 @@ class VoxelVars {
         this.overlayTextures.z = 0;
     }
 }
-export class VoxelMesherDataTool extends MesherDataTool {
+export class VoxelModelBuilder {
     id;
     materialIndex;
     space;
@@ -41,11 +40,10 @@ export class VoxelMesherDataTool extends MesherDataTool {
     lightData;
     effects;
     constructor(id, materialIndex) {
-        super();
-        this.id = id;
-        this.materialIndex = materialIndex;
         //  this.faceDataOverride.currentVoxel = this.voxel;
         //  this.faceDataOverride.neighborVoxel = this.nVoxel;
+        this.id = id;
+        this.materialIndex = materialIndex;
         this.dataCalculated = [];
         for (const face of VoxelFacesArray) {
             this.dataCalculated[face] = false;
@@ -74,7 +72,6 @@ export class VoxelMesherDataTool extends MesherDataTool {
             this.lightData[face][QuadVerticies.BottomLeft] = 0;
             this.lightData[face][QuadVerticies.BottomRight] = 0;
         }
-        this.startNewMesh(new VoxelMesh());
     }
     bounds = {
         min: [0, 0, 0],
@@ -97,6 +94,13 @@ export class VoxelMesherDataTool extends MesherDataTool {
             if (!this._boundsUpdate)
                 return false;
             this.bvhTool.updateVoxel(this.position.x, this.position.y, this.position.z, this._indexStart, this.materialIndex, this.mesh.indicieCount, this.bounds.min[0], this.bounds.min[1], this.bounds.min[2], this.bounds.max[0], this.bounds.max[1], this.bounds.max[2]);
+            this.bvhTool.structCursor.setIndex(0);
+            this.mesh.minBounds.x = this.bvhTool.structCursor.minX;
+            this.mesh.minBounds.y = this.bvhTool.structCursor.minY;
+            this.mesh.minBounds.z = this.bvhTool.structCursor.minZ;
+            this.mesh.maxBounds.x = this.bvhTool.structCursor.maxX;
+            this.mesh.maxBounds.y = this.bvhTool.structCursor.maxY;
+            this.mesh.maxBounds.z = this.bvhTool.structCursor.maxZ;
         }
         return true;
     }

package/Models/Defaults/CubeVoxelGeometry.js

@@ -42,6 +42,10 @@ export const cube = {
             type: "int",
             default: 0,
         },
+        northTexTransparent: {
+            type: "boolean",
+            default: false,
+        },
         southTex: {
             type: "texture",
         },