@divinevoxel/vlox 0.0.72 → 0.0.74

package/Mesher/Geomtry/VoxelMeshBVHStructCursor.js

@@ -0,0 +1,78 @@
+export class VoxelMeshBVHStructCursor {
+    data;
+    get minX() {
+        return this.data[this.trueIndex];
+    }
+    get minY() {
+        return this.data[this.trueIndex + 1];
+    }
+    get minZ() {
+        return this.data[this.trueIndex + 2];
+    }
+    get maxX() {
+        return this.data[this.trueIndex + 4];
+    }
+    get maxY() {
+        return this.data[this.trueIndex + 5];
+    }
+    get maxZ() {
+        return this.data[this.trueIndex + 6];
+    }
+    get voxelIndex() {
+        return this.data[this.trueIndex + 3];
+    }
+    get active() {
+        return this.data[this.trueIndex + 3];
+    }
+    get nodeType() {
+        return this.data[this.trueIndex + 7];
+    }
+    trueIndex = 0;
+    index = 0;
+    setIndex(index) {
+        this.trueIndex = index * 8;
+    }
+    constructor(data) {
+        this.data = data;
+    }
+    setActive() {
+        this.data[this.trueIndex + 3] = 1;
+    }
+    setVoxelIndex(value) {
+        this.data[this.trueIndex + 3] = value;
+    }
+    setInnerNode() {
+        this.data[this.trueIndex + 7] = 1;
+    }
+    setGeomtryNode() {
+        this.data[this.trueIndex + 7] = 2;
+    }
+    updateMin(x, y, z) {
+        const ix = this.trueIndex;
+        const iy = this.trueIndex + 1;
+        const iz = this.trueIndex + 2;
+        if (x < this.data[ix] || this.data[ix] == -Infinity) {
+            this.data[ix] = x;
+        }
+        if (y < this.data[iy] || this.data[iy] == -Infinity) {
+            this.data[iy] = y;
+        }
+        if (z < this.data[iz] || this.data[iz] == -Infinity) {
+            this.data[iz] = z;
+        }
+    }
+    updateMax(x, y, z) {
+        const ix = this.trueIndex + 4;
+        const iy = this.trueIndex + 5;
+        const iz = this.trueIndex + 6;
+        if (x > this.data[ix] || this.data[ix] == -Infinity) {
+            this.data[ix] = x;
+        }
+        if (y > this.data[iy] || this.data[iy] == -Infinity) {
+            this.data[iy] = y;
+        }
+        if (z > this.data[iz] || this.data[iz] == -Infinity) {
+            this.data[iz] = z;
+        }
+    }
+}

package/Mesher/Geomtry/{Buffers.js → VoxelMeshBuffers.js}

@@ -3,7 +3,7 @@ export class VoxelVertexBuffer {
     sectorVertexSize;
     _buffers = [];
     sectorSize = 0;
-    constructor(vertexFloatSize, sectorVertexSize, startingSectorSize = 4) {
+    constructor(vertexFloatSize, sectorVertexSize, startingSectorSize = 8) {
         this.vertexFloatSize = vertexFloatSize;
         this.sectorVertexSize = sectorVertexSize;
         this.sectorSize = vertexFloatSize * sectorVertexSize;
@@ -28,7 +28,7 @@ export class VoxelVertexBuffer {
 export class VoxelIndiceBuffer {
     sectorSize;
     _buffers = [];
-    constructor(sectorSize, startingSectorSize = 4) {
+    constructor(sectorSize, startingSectorSize = 8) {
         this.sectorSize = sectorSize;
         for (let i = 0; i < startingSectorSize; i++) {
             this._buffers.push(new Uint32Array(sectorSize));

package/Mesher/Geomtry/index.d.ts

@@ -1,2 +1 @@
 export * from "./Primitives/index";
-export * from "./Tools/index.js";

package/Mesher/Geomtry/index.js

@@ -1,2 +1 @@
 export * from "./Primitives/index";
-export * from "./Tools/index.js";

package/Mesher/InitMesher.js

@@ -1,4 +1,4 @@
-import { RenderedMaterials } from "./RenderedMaterials";
+import { RenderedMaterials } from "./Models/RenderedMaterials";
 import { VoxelModelConstructorRegister } from "./Models/VoxelModelConstructorRegister.js";
 import { LiquidGeometryNode } from "./Models/Nodes/Custom/Liquid/LiquidGeomtryNode.js";
 import { VoxelConstructor } from "./Models/VoxelConstructor.js";

package/Mesher/InitTask.js

@@ -1,6 +1,5 @@
 import { Threads } from "@amodx/threads";
 import { WorldRegister } from "../World/WorldRegister";
-import { WorldSpaces } from "../World/WorldSpaces";
 import { MeshSection } from "./Functions/MeshSection";
 import { TasksIds } from "../Tasks/TasksIds";
 export default function (rendererThread) {
@@ -11,39 +10,26 @@ export default function (rendererThread) {
             return;
         rendererThread.runTask("set-section", section, transfers);
     });
-    Threads.registerTask(TasksIds.BuildSector, (location) => {
-        const sectorPosition = WorldSpaces.sector.getPosition(location[1], location[2], location[3]);
-        const sector = WorldRegister.sectors.get(location[0], sectorPosition.x, sectorPosition.y, sectorPosition.z);
+    Threads.registerTask(TasksIds.BuildSector, (location, origin) => {
+        const sector = WorldRegister.sectors.getAt(location);
         if (!sector) {
-            console.warn("Tried building a sector that does not exists.", [
-                sectorPosition.x,
-                sectorPosition.y,
-                sectorPosition.z,
-            ]);
+            console.warn("Tried building a sector that does not exists.", location);
             return;
         }
-        if (sector.sections.length == 0) {
-            console.warn("Tried building a sector with no sections.", sector.position);
-            return;
-        }
-        const transfers = [];
         for (let i = 0; i < sector.sections.length; i++) {
             const section = sector.sections[i];
-            if (!section)
-                continue;
             let [minY, maxY] = section.getMinMax();
             if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
                 continue;
-            transfers.length = 0;
-            const sectionMesh = MeshSection([
-                location[0],
-                sector.position[0],
-                sector.position[1] + i * WorldSpaces.section.bounds.y,
-                sector.position[2],
-            ], transfers);
+            const t = performance.now();
+            const transfers = [];
+            const sectionMesh = MeshSection([location[0], ...section.getPosition()], transfers);
             if (!sectionMesh)
                 continue;
             rendererThread.runTask("set-section", sectionMesh, transfers);
+            const buildTime = performance.now() - t;
+            origin.runTask("add-build-time", buildTime);
+            console.log("BUILD TIME", buildTime);
         }
     });
 }

package/Mesher/Models/Common/BoxGeometryNode.js

@@ -1,7 +1,7 @@
 import { Vector3Like } from "@amodx/math";
 import { VoxelFaces } from "../../../Math";
 import { Quad } from "../../Geomtry/Primitives/Quad";
-import { addQuadWeights } from "./Calc/CalcConstants";
+import { getQuadWeights } from "./Calc/CalcConstants";
 import { TransformBox } from "../../../Models/Shared/Transform";
 import { GetBounds } from "./BoundsFunctions";
 export function GetBoxGeometryNodeData(points, transform) {
@@ -66,12 +66,12 @@ export function GetBoxGeometryNodeData(points, transform) {
         }
         quadBounds[i] = GetBounds(positions);
     }
-    vertexWeights[VoxelFaces.Up] = addQuadWeights(quads[VoxelFaces.Up], VoxelFaces.Up);
-    vertexWeights[VoxelFaces.Down] = addQuadWeights(quads[VoxelFaces.Down], VoxelFaces.Down);
-    vertexWeights[VoxelFaces.North] = addQuadWeights(quads[VoxelFaces.North], VoxelFaces.North);
-    vertexWeights[VoxelFaces.South] = addQuadWeights(quads[VoxelFaces.South], VoxelFaces.South);
-    vertexWeights[VoxelFaces.East] = addQuadWeights(quads[VoxelFaces.East], VoxelFaces.East);
-    vertexWeights[VoxelFaces.West] = addQuadWeights(quads[VoxelFaces.West], VoxelFaces.West);
+    vertexWeights[VoxelFaces.Up] = getQuadWeights(quads[VoxelFaces.Up], VoxelFaces.Up);
+    vertexWeights[VoxelFaces.Down] = getQuadWeights(quads[VoxelFaces.Down], VoxelFaces.Down);
+    vertexWeights[VoxelFaces.North] = getQuadWeights(quads[VoxelFaces.North], VoxelFaces.North);
+    vertexWeights[VoxelFaces.South] = getQuadWeights(quads[VoxelFaces.South], VoxelFaces.South);
+    vertexWeights[VoxelFaces.East] = getQuadWeights(quads[VoxelFaces.East], VoxelFaces.East);
+    vertexWeights[VoxelFaces.West] = getQuadWeights(quads[VoxelFaces.West], VoxelFaces.West);
     return {
         quads,
         vertexWeights,

package/Mesher/Models/Common/Calc/CalcConstants.d.ts

@@ -11,5 +11,5 @@ export declare function shouldCauseFlip(topRight: number, topLeft: number, botto
 export declare function getVertexWeights(face: VoxelFaces, x: number, y: number, z: number): Vec4Array;
 export declare function getInterpolationValue(value: Vec4Array, weights: Vec4Array): number;
 export type QuadVertexWeights = [Vec4Array, Vec4Array, Vec4Array, Vec4Array];
-export declare const addQuadWeights: (quad: Quad, direction: VoxelFaces) => QuadVertexWeights;
+export declare const getQuadWeights: (quad: Quad, direction: VoxelFaces) => QuadVertexWeights;
 export declare function closestUnitNormal(v: Vec3Array): Vec3Array;

package/Mesher/Models/Common/Calc/CalcConstants.js

@@ -326,7 +326,7 @@ export function getInterpolationValue(value, weights) {
         lightData.getB(value[2]) * weights[2] +
         lightData.getB(value[3]) * weights[3]);
 }
-export const addQuadWeights = (quad, direction) => {
+export const getQuadWeights = (quad, direction) => {
     const returnArray = [];
     for (const vertex of QuadVerticiesArray) {
         const { x, y, z } = quad.positions.vertices[vertex];

package/Mesher/Models/Common/Calc/FaceDataCalc.d.ts

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

package/Mesher/Models/Common/Calc/FaceDataCalc.js

@@ -2,47 +2,54 @@ import { VoxelFaceDirections } from "../../../../Math/index.js";
 import { GradientCheckSets } from "./CalcConstants.js";
 import { VoxelLightData } from "../../../../Voxels/Cursor/VoxelLightData.js";
 const lightData = new VoxelLightData();
-const currentLightValues = new Uint16Array([0, 0, 0, 0]);
-const loadedLightValues = new Uint16Array([0, 0, 0, 0]);
 export default function calculateFaceData(face, builder) {
-    let light = builder.voxel.getLight();
-    const faceNormal = VoxelFaceDirections[face];
     const x = builder.position.x;
     const y = builder.position.y;
     const z = builder.position.z;
     const vertexData = builder.lightData[face];
     const nVoxel = builder.nVoxel;
     const checkSet = GradientCheckSets[face];
-    const otherLight = builder.space.getLight(builder.nVoxel, x + faceNormal[0], y + faceNormal[1], z + faceNormal[2]) || 0;
-    light = otherLight >= 0 ? otherLight : light >= 0 ? light : 0;
+    let startLight = 0;
+    if (builder.voxel.isLightSource()) {
+        startLight = builder.voxel.getLightSourceValue();
+    }
+    else {
+        startLight =
+            nVoxel
+                .getVoxel(x + VoxelFaceDirections[face][0], y + VoxelFaceDirections[face][1], z + VoxelFaceDirections[face][2])
+                ?.getLight() || 0;
+    }
+    if (startLight < 0)
+        startLight = 0;
+    const startS = lightData.getS(startLight);
+    const startR = lightData.getR(startLight);
+    const startG = lightData.getG(startLight);
+    const startB = lightData.getB(startLight);
     for (let vertex = 0; vertex < 4; vertex++) {
-        vertexData[vertex] = light;
-        lightData.getLightValuesArrayToRef(light, currentLightValues);
+        vertexData[vertex] = startLight;
+        let s = startS;
+        let r = startR;
+        let g = startG;
+        let b = startB;
         for (let i = 0; i < 9; i += 3) {
-            const nl = builder.space.getLight(nVoxel, checkSet[vertex][i] + x, checkSet[vertex][i + 1] + y, checkSet[vertex][i + 2] + z);
+            const nl = nVoxel
+                .getVoxel(checkSet[vertex][i] + x, checkSet[vertex][i + 1] + y, checkSet[vertex][i + 2] + z)
+                ?.getLight() || -1;
             if (nl <= 0)
                 continue;
-            /*
-            Do Light
-            */
-            lightData.getLightValuesArrayToRef(nl, loadedLightValues);
-            currentLightValues[0] =
-                currentLightValues[0] < loadedLightValues[0]
-                    ? loadedLightValues[0]
-                    : currentLightValues[0];
-            currentLightValues[1] =
-                currentLightValues[1] < loadedLightValues[1]
-                    ? loadedLightValues[1]
-                    : currentLightValues[1];
-            currentLightValues[2] =
-                currentLightValues[2] < loadedLightValues[2]
-                    ? loadedLightValues[2]
-                    : currentLightValues[2];
-            currentLightValues[3] =
-                currentLightValues[3] < loadedLightValues[3]
-                    ? loadedLightValues[3]
-                    : currentLightValues[3];
+            let ns = lightData.getS(nl);
+            let nr = lightData.getR(nl);
+            let ng = lightData.getG(nl);
+            let nb = lightData.getB(nl);
+            if (s < ns)
+                s = ns;
+            if (r < nr)
+                r = nr;
+            if (g < ng)
+                g = ng;
+            if (b < nb)
+                b = nb;
         }
-        vertexData[vertex] = lightData.setLightValues(currentLightValues);
+        vertexData[vertex] = lightData.createLightValue(s, r, g, b);
     }
 }

package/Mesher/Models/Common/QuadGeometryNode.js

@@ -1,7 +1,7 @@
 import { Vector3Like } from "@amodx/math";
 import { VoxelFaces } from "../../../Math";
 import { Quad } from "../../Geomtry/Primitives/Quad";
-import { addQuadWeights, closestUnitNormal, } from "./Calc/CalcConstants";
+import { getQuadWeights, closestUnitNormal, } from "./Calc/CalcConstants";
 import { TransformQuad } from "../../../Models/Shared/Transform";
 import { GetBounds } from "./BoundsFunctions";
 export function GetQuadGeometryData(data, transform) {
@@ -40,7 +40,7 @@ export function GetQuadGeometryData(data, transform) {
         closestFace = VoxelFaces.North;
     if (unitNormal[2] == -1)
         closestFace = VoxelFaces.South;
-    const vertexWeights = addQuadWeights(quad, closestFace);
+    const vertexWeights = getQuadWeights(quad, closestFace);
     closestFace = closestFace;
     return {
         quad,

package/Mesher/Models/Nodes/Custom/Liquid/FlowGradient.d.ts

@@ -1,4 +1,4 @@
-import type { VoxelMesherDataTool } from "../../../../../Mesher/Tools/VoxelMesherDataTool";
+import type { VoxelModelBuilder } from "../../../VoxelModelBuilder";
 import { QuadScalarVertexData } from "../../../../Geomtry/Primitives/QuadVertexData";
 import { CompassAngles } from "@amodx/math";
 export declare enum FlowVerticies {
@@ -8,4 +8,4 @@ export declare enum FlowVerticies {
     SouthEsat = 3
 }
 export declare function getFlowAngle(vertexLevel: QuadScalarVertexData): [angle: CompassAngles, flow: number];
-export declare function getFlowGradient(tool: VoxelMesherDataTool, flowStates: QuadScalarVertexData): QuadScalarVertexData;
+export declare function getFlowGradient(tool: VoxelModelBuilder, flowStates: QuadScalarVertexData): QuadScalarVertexData;

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

@@ -66,7 +66,7 @@ const returnData = [
 export function getFlowAngle(vertexLevel) {
     if (vertexLevel.isAllEqualTo(7)) {
         returnData[0] = 0;
-        returnData[1] = FlowStates.None;
+        returnData[1] = FlowStates.Up;
         return returnData;
     }
     const upRight = vertexLevel.vertices[QuadVerticies.TopRight];

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

@@ -8,7 +8,7 @@ import { shouldCauseFlip } from "../../../Common/Calc/CalcConstants";
 import { getFlowAngle, getFlowGradient, FlowVerticies } from "./FlowGradient";
 import { GetBoxGeometryNodeData } from "../../../Common/BoxGeometryNode";
 import { VoxelLightData } from "../../../../../Voxels/Cursor/VoxelLightData";
-import { VoxelGeometryBuilder } from "../../../../Geomtry/VoxelGeometryBuilder";
+import { addVoxelQuad } from "../../../../Geomtry/VoxelGeometryBuilder";
 const vertexValue = new QuadScalarVertexData();
 const vertexLevel = new QuadScalarVertexData();
 const lightData = new VoxelLightData();
@@ -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;
@@ -92,26 +92,23 @@ export class LiquidGeometryNode extends GeoemtryNode {
             quad.positions.vertices[1].y = vertexValue.vertices[1] * waterHeight;
             quad.positions.vertices[2].y = vertexValue.vertices[2] * waterHeight;
             quad.positions.vertices[3].y = vertexValue.vertices[3] * waterHeight;
-            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            addVoxelQuad(tool, tool.origin, quad);
             tool.updateBounds(quadBounds[VoxelFaces.Up]);
         }
         if (this.isExposed(VoxelFaces.Down)) {
             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);
+            addVoxelQuad(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) {
@@ -129,15 +126,14 @@ export class LiquidGeometryNode extends GeoemtryNode {
                 quad.positions.vertices[QuadVerticies.TopLeft].y = 1;
                 quad.setUVs(uvs);
             }
-            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            addVoxelQuad(tool, tool.origin, quad);
             tool.updateBounds(quadBounds[VoxelFaces.North]);
         }
         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) {
@@ -155,17 +151,16 @@ export class LiquidGeometryNode extends GeoemtryNode {
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
                 quad.setUVs(uvs);
             }
-            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            addVoxelQuad(tool, tool.origin, quad);
             tool.updateBounds(quadBounds[VoxelFaces.South]);
         }
         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;
@@ -181,15 +176,14 @@ export class LiquidGeometryNode extends GeoemtryNode {
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
                 quad.setUVs(uvs);
             }
-            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            addVoxelQuad(tool, tool.origin, quad);
             tool.updateBounds(quadBounds[VoxelFaces.East]);
         }
         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) {
@@ -207,7 +201,7 @@ export class LiquidGeometryNode extends GeoemtryNode {
                 quad.positions.vertices[QuadVerticies.TopRight].y = 1;
                 quad.setUVs(uvs);
             }
-            VoxelGeometryBuilder.addQuad(tool, tool.origin, quad);
+            addVoxelQuad(tool, tool.origin, quad);
             tool.updateBounds(quadBounds[VoxelFaces.West]);
         }
         this.builder.vars.light.setAll(0);

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;