@divinevoxel/vlox 0.0.72 → 0.0.74

package/{Tasks/IWG → WorldSimulation}/Procedures/InitalLoad.js

@@ -1,6 +1,6 @@
-import { IWG } from "../IWG";
-import { IWGDimensions } from "../Internal/IWGDimensions";
-import { IWGTools } from "../Internal/IWGTools";
+import { WorldSimulation } from "../WorldSimulation";
+import { WorldSimulationDimensions } from "../Internal/WorldSimulationDimensions";
+import { WorldSimulationTools } from "../Internal/WorldSimulationTools";
 import SaveAllSectors from "./SaveAllSectors";
 /**# InitalLoad
  * ---
@@ -8,23 +8,23 @@ import SaveAllSectors from "./SaveAllSectors";
  */
 export async function InitalLoad(props) {
     return new Promise((resolve) => {
-        const generator = IWG.createGenerator({
+        const generator = WorldSimulation.createGenerator({
             ...props.genData,
             building: false,
             culling: false
         });
-        if (!IWGDimensions._dimensions.has(generator._dimension)) {
-            IWGDimensions.addDimension(generator._dimension);
+        if (!WorldSimulationDimensions._dimensions.has(generator._dimension)) {
+            WorldSimulationDimensions.addDimension(generator._dimension);
         }
-        const dimension = IWGDimensions.getDimension(props.dimension || "main");
+        const dimension = WorldSimulationDimensions.getDimension(props.dimension || 0);
         let done = false;
         generator._building = false;
-        IWG.addGenerator(generator);
+        WorldSimulation.addGenerator(generator);
         let timeOut = null;
         const update = () => {
             if (done)
                 return;
-            IWG.update();
+            WorldSimulation.update();
             timeOut = setTimeout(update, 0);
         };
         update();
@@ -41,9 +41,9 @@ export async function InitalLoad(props) {
             done = true;
             clearInterval(inte);
             clearTimeout(timeOut);
-            IWG.removeGenerator(generator);
+            WorldSimulation.removeGenerator(generator);
             (async () => {
-                if (IWGTools.worldStorage) {
+                if (WorldSimulationTools.worldStorage) {
                     await SaveAllSectors();
                 }
                 resolve(true);

package/{Tasks/IWG → WorldSimulation}/Procedures/SaveAllSectors.js

@@ -1,18 +1,20 @@
-import { WorldRegister } from "../../../World/WorldRegister";
-import { IWGDimensions } from "../Internal/IWGDimensions";
-import { IWGTools } from "../Internal/IWGTools";
+import { WorldRegister } from "../../World/WorldRegister";
+import { WorldSimulationDimensions } from "../Internal/WorldSimulationDimensions";
+import { WorldSimulationTools } from "../Internal/WorldSimulationTools";
 /**# Save All Sectors
  * ---
  * Save all sectors that are loaded.
  */
 export default async function SaveAllSectors() {
-    const worldStorage = IWGTools.worldStorage;
+    const worldStorage = WorldSimulationTools.worldStorage;
     if (!worldStorage)
         return;
     const proms = [];
-    for (const [dimensionId] of IWGDimensions._dimensions) {
+    for (const [dimensionId] of WorldSimulationDimensions._dimensions) {
         const dimension = WorldRegister.dimensions.get(dimensionId);
         for (const [key, sector] of dimension.sectors) {
+            if (sector.isStored())
+                continue;
             proms.push(worldStorage.saveSector([dimensionId, ...sector.position]));
         }
     }

package/{Tasks/IWG/IWG.d.ts → WorldSimulation/WorldSimulation.d.ts}

@@ -1,9 +1,9 @@
 import { Thread, ThreadPool } from "@amodx/threads";
-import { WorldStorageInterface } from "../../World/Storage/WorldStorage.interface";
+import { WorldStorageInterface } from "../World/Types/WorldStorage.interface";
 import { Generator, GeneratorData } from "./Internal/Classes/Generator";
 import { InitalLoad } from "./Procedures/InitalLoad";
 import SaveAllSectors from "./Procedures/SaveAllSectors";
-interface IWGInitData {
+interface WorldSimulationInitData {
     parent: Thread;
     threads: Thread | ThreadPool;
     worldStorage?: WorldStorageInterface;
@@ -11,18 +11,19 @@ interface IWGInitData {
 /**# Infinite World Generation IWG
  * Object to handle the loading and generating the world around a created generator.
  */
-export declare class IWG {
+export declare class WorldSimulation {
     private static _cullGenerators;
     static readonly _generators: Generator[];
-    static addDimension(id: string): void;
+    static addDimension(id: number): void;
     static Procedures: {
         InitalLoad: typeof InitalLoad;
         SaveAllSectors: typeof SaveAllSectors;
     };
-    static init(data: IWGInitData): void;
+    static init(data: WorldSimulationInitData): void;
     static createGenerator(data: Partial<GeneratorData>): Generator;
     static addGenerator(generator: Generator): void;
     static removeGenerator(generator: Generator): boolean;
+    static tick(): void;
     static update(): void;
 }
 export {};

package/{Tasks/IWG/IWG.js → WorldSimulation/WorldSimulation.js}

@@ -1,10 +1,10 @@
-import { TaskTool } from "../../Tools/Tasks/TasksTool";
+import { TaskTool } from "../Tools/Tasks/TasksTool";
 import { Generator } from "./Internal/Classes/Generator";
 import { runWorldUpdate } from "./Internal/Functions/runWorldUpdate";
-import { IWGTasks } from "./Internal/IWGTasks";
-import { runBuildUpdate } from "./Internal/Functions/runBuildUpdate";
-import { IWGTools } from "./Internal/IWGTools";
-import { IWGDimensions } from "./Internal/IWGDimensions";
+import { WorldSimulationTasks } from "./Internal/WorldSimulationTasks";
+import { runTickUpdate } from "./Internal/Functions/runTickUpdate";
+import { WorldSimulationTools } from "./Internal/WorldSimulationTools";
+import { WorldSimulationDimensions } from "./Internal/WorldSimulationDimensions";
 import { cullSectors } from "./Internal/Functions/cullSectors";
 import { Vector3Like } from "@amodx/math";
 import { InitalLoad } from "./Procedures/InitalLoad";
@@ -13,11 +13,11 @@ let initalized = false;
 /**# Infinite World Generation IWG
  * Object to handle the loading and generating the world around a created generator.
  */
-export class IWG {
+export class WorldSimulation {
     static _cullGenerators = [];
     static _generators = [];
     static addDimension(id) {
-        IWGDimensions.addDimension(id);
+        WorldSimulationDimensions.addDimension(id);
     }
     static Procedures = {
         InitalLoad,
@@ -25,15 +25,16 @@ export class IWG {
     };
     static init(data) {
         initalized = true;
-        IWGTools.parent = data.parent;
-        IWGTools.taskTool = new TaskTool(data.threads);
+        WorldSimulationTools.parent = data.parent;
+        WorldSimulationTools.taskTool = new TaskTool(data.threads);
         if (data.worldStorage)
-            IWGTools.worldStorage = data.worldStorage;
-        console.warn("load the thing", IWGTools.worldStorage, data.worldStorage);
+            WorldSimulationTools.worldStorage = data.worldStorage;
     }
     static createGenerator(data) {
-        return new Generator({
-            dimension: data.dimension ? data.dimension : "main",
+        if (!initalized)
+            throw new Error(`IWG must be initalized first before creating generator`);
+        return new Generator(WorldSimulationTools.taskTool, {
+            dimension: data.dimension ? data.dimension : 0,
             position: data.position ? data.position : Vector3Like.Create(),
             renderRadius: data.renderRadius ? data.renderRadius : 150,
             generationRadius: data.generationRadius ? data.generationRadius : 250,
@@ -53,6 +54,11 @@ export class IWG {
         }
         return false;
     }
+    static tick() {
+        for (const gen of this._generators) {
+            gen.tick();
+        }
+    }
     static update() {
         if (!initalized) {
             throw new Error(`IWG must be initalized.`);
@@ -76,17 +82,17 @@ export class IWG {
                 }
             }
         }
-        runBuildUpdate(this._generators);
-        IWGTasks.buildTasks.runTask();
+        runTickUpdate(this._generators);
+        //  IWGTasks.buildTasks.runTask();
         runWorldUpdate(this._generators);
-        IWGTasks.worldLoadTasks.runTask();
-        IWGTasks.worldGenTasks.runTask();
-        IWGTasks.worldDecorateTasks.runTask();
-        IWGTasks.worldSunTasks.runTask();
-        IWGTasks.worldPropagationTasks.runTask();
-        IWGTasks.saveTasks.runTask();
-        IWGTasks.saveAndUnloadTasks.runTask();
+        WorldSimulationTasks.worldLoadTasks.runTask();
+        WorldSimulationTasks.worldGenTasks.runTask();
+        WorldSimulationTasks.worldDecorateTasks.runTask();
+        WorldSimulationTasks.worldSunTasks.runTask();
+        WorldSimulationTasks.worldPropagationTasks.runTask();
+        WorldSimulationTasks.saveTasks.runTask();
+        WorldSimulationTasks.saveAndUnloadTasks.runTask();
         cullSectors(this._generators, this._cullGenerators);
     }
 }
-IWG.addDimension("main");
+WorldSimulation.addDimension(0);

package/{Tasks/IWG → WorldSimulation}/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./IWG";
+export * from "./WorldSimulation";
 export * from "./Procedures/InitalLoad";

package/{Tasks/IWG → WorldSimulation}/index.js

@@ -1,2 +1,2 @@
-export * from "./IWG";
+export * from "./WorldSimulation";
 export * from "./Procedures/InitalLoad";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@divinevoxel/vlox",
-  "version": "0.0.72",
+  "version": "0.0.74",
   "description": "Vlox a block style voxel engine.",
   "main": "index.js",
   "types": "index.d.ts",

package/Mesher/Functions/CompactMesh.d.ts

@@ -1,2 +0,0 @@
-import { MesherDataTool } from "../Geomtry/Tools/MesherDataTools";
-export declare function CompactMesh(materialId: string, tool: MesherDataTool): void;

package/Mesher/Functions/CompactMesh.js

@@ -1,42 +0,0 @@
-export function CompactMesh(materialId, tool) {
-    /*   let webGPU = EngineSettings.settings.rendererSettings.mode == "webgpu";
-    
-      const mesh = tool.mesh!;
-      const byteRanges: [
-        byteStart: number,
-        length: number,
-        type: BinaryNumberTypes,
-      ][] = [];
-      const dataMap: CompactSubMesh = [materialId, []];
-      let totalSize = 0;
-      for (let [key, [array, stride, type]] of mesh.attributes) {
-        if (key == MeshDefaultAttributes.Indices) {
-          if (array.length > 60_000) {
-            type = BinaryNumberTypes.Uint32;
-          }
-        }
-        let current = totalSize;
-    
-        totalSize += MappedByteCounts[type] * array.length;
-        byteRanges.push([current, array.length, type]);
-        dataMap[1].push([key, array as any, stride]);
-      }
-    
-      const finalBuffer = new ArrayBuffer(totalSize);
-    
-      for (let i = 0; i < dataMap[1].length; i++) {
-        const startByte = byteRanges[i][0];
-        const length = byteRanges[i][1];
-        const type = byteRanges[i][2];
-        const newArray = new TypedArrayClassMap[type](
-          finalBuffer,
-          //@ts-ignore
-          startByte,
-          length
-        ) as Float32Array;
-        newArray.set(dataMap[1][i][0] as any as number[]);
-        dataMap[1][i][1] = newArray;
-      }
-    
-      return [0, finalBuffer, [dataMap]]; */
-}

package/Mesher/Geomtry/GeometryNormals.d.ts

@@ -1,10 +0,0 @@
-import type { Vec3Array } from "@amodx/math";
-export declare class GeometryNormals {
-    static subtract(v1: Vec3Array, v2: Vec3Array): Vec3Array;
-    static cross(v1: Vec3Array, v2: Vec3Array): Vec3Array;
-    static scale(v: Vec3Array, scaleFactor: number): Vec3Array;
-    static add(v1: Vec3Array, v2: Vec3Array): Vec3Array;
-    static normalize(v: Vec3Array): Vec3Array;
-    static getTriangleNormals(p1: Vec3Array, p2: Vec3Array, p3: Vec3Array): Vec3Array;
-    static getQuadNormal(p1: Vec3Array, p2: Vec3Array, p3: Vec3Array, p4: Vec3Array): [n1: Vec3Array, n2: Vec3Array, n3: Vec3Array, n4: Vec3Array];
-}

package/Mesher/Geomtry/GeometryNormals.js

@@ -1,52 +0,0 @@
-export class GeometryNormals {
-    static subtract(v1, v2) {
-        return [v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2]];
-    }
-    static cross(v1, v2) {
-        return [
-            v1[1] * v2[2] - v1[2] * v2[1],
-            v1[2] * v2[0] - v1[0] * v2[2],
-            v1[0] * v2[1] - v1[1] * v2[0],
-        ];
-    }
-    static scale(v, scaleFactor) {
-        return [v[0] * scaleFactor, v[1] * scaleFactor, v[2] * scaleFactor];
-    }
-    static add(v1, v2) {
-        return [v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2]];
-    }
-    static normalize(v) {
-        const length = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
-        return length > 0
-            ? [v[0] / length, v[1] / length, v[2] / length]
-            : [0, 0, 0];
-    }
-    static getTriangleNormals(p1, p2, p3) {
-        const a = this.subtract(p2, p1);
-        const b = this.subtract(p3, p1);
-        const substract = this.cross(a, b);
-        const normal = this.scale(substract, -1);
-        return this.normalize(normal);
-    }
-    static getQuadNormal(p1, p2, p3, p4) {
-        const vectorA1 = [p2[0] - p1[0], p2[1] - p1[1], p2[2] - p1[2]];
-        const vectorA2 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
-        const normalA = this.normalize(this.cross(vectorA1, vectorA2));
-        const vectorB1 = [p3[0] - p1[0], p3[1] - p1[1], p3[2] - p1[2]];
-        const vectorB2 = [p4[0] - p1[0], p4[1] - p1[1], p4[2] - p1[2]];
-        const normalB = this.normalize(this.cross(vectorB1, vectorB2));
-        const n1 = this.normalize([
-            (normalA[0] + normalB[0]) / 2,
-            (normalA[1] + normalB[1]) / 2,
-            (normalA[2] + normalB[2]) / 2,
-        ]);
-        const n2 = normalA;
-        const n3 = this.normalize([
-            (normalA[0] + normalB[0]) / 2,
-            (normalA[1] + normalB[1]) / 2,
-            (normalA[2] + normalB[2]) / 2,
-        ]);
-        const n4 = normalB;
-        return [n1, n2, n3, n4];
-    }
-}

package/Mesher/Geomtry/MeshData.types.d.ts

@@ -1,13 +0,0 @@
-import type { TypedArrays } from "@amodx/binary";
-export declare enum MeshDefaultAttributes {
-    Position = "position",
-    Normal = "normal",
-    Indices = "indices"
-}
-export type MeshAttributes = [
-    id: string,
-    data: TypedArrays,
-    stride: number,
-    componentTypes?: number,
-    noramlizer?: number
-][];

package/Mesher/Geomtry/MeshData.types.js

@@ -1,6 +0,0 @@
-export var MeshDefaultAttributes;
-(function (MeshDefaultAttributes) {
-    MeshDefaultAttributes["Position"] = "position";
-    MeshDefaultAttributes["Normal"] = "normal";
-    MeshDefaultAttributes["Indices"] = "indices";
-})(MeshDefaultAttributes || (MeshDefaultAttributes = {}));

package/Mesher/Geomtry/Tools/MesherDataTools.d.ts

@@ -1,7 +0,0 @@
-import { VoxelMesh } from "../VoxelMesh.js";
-export declare class MesherDataTool {
-    segments: Map<string, number[]>;
-    mesh: VoxelMesh | null;
-    startNewMesh(mesh?: VoxelMesh): void;
-    clear(): this;
-}

package/Mesher/Geomtry/Tools/MesherDataTools.js

@@ -1,12 +0,0 @@
-import { VoxelMesh } from "../VoxelMesh.js";
-export class MesherDataTool {
-    segments = new Map();
-    mesh = null;
-    startNewMesh(mesh) {
-        this.mesh = mesh ? mesh : new VoxelMesh();
-    }
-    clear() {
-        this.mesh?.clear();
-        return this;
-    }
-}

package/Mesher/Geomtry/Tools/index.d.ts

@@ -1 +0,0 @@
-export * from "./MesherDataTools.js";

package/Mesher/Geomtry/Tools/index.js

@@ -1 +0,0 @@
-export * from "./MesherDataTools.js";

package/Mesher/RenderedMaterials.d.ts

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

package/Mesher/Tools/VoxelMeshBVHBuilder.js

@@ -1,216 +0,0 @@
-import { WorldSpaces } from "../../World/WorldSpaces";
-const MAX_FLOAT32 = new Float32Array([Infinity])[0];
-/**
- * A class to help with indexing a full flat binary tree defined by the number of levels it has.
- */
-class FlatBinaryTreeIndex {
-    levels;
-    constructor(levels) {
-        this.levels = levels;
-    }
-    /** Gets the number of nodes at a level of the tree */
-    getLevelSize(level) {
-        if (level < 0 || level >= this.levels) {
-            throw new Error("Invalid level");
-        }
-        return 1 << level; // Equivalent to 2^level
-    }
-    /**
-     * Gets the flat index of a node indexed by the level it's on and its relative index in that level.
-     */
-    getIndexAtLevel(level, node) {
-        if (level < 0 || level >= this.levels) {
-            throw new Error("Invalid level");
-        }
-        const levelSize = this.getLevelSize(level);
-        if (node < 0 || node >= levelSize) {
-            throw new Error("Invalid node index at the given level");
-        }
-        return (1 << level) - 1 + node;
-    }
-    /**
-     * Gets the level and relative index of a node's flat index.
-     */
-    getLevelAndIndex(index) {
-        const totalNodes = (1 << this.levels) - 1;
-        if (index < 0 || index >= totalNodes) {
-            throw new Error("Invalid node index");
-        }
-        const level = Math.floor(Math.log2(index + 1));
-        const firstIndexAtLevel = (1 << level) - 1;
-        const relativeIndex = index - firstIndexAtLevel;
-        return [level, relativeIndex];
-    }
-    /**
-     * Gets the flat left child of a node, where the node is indexed by its level and its relative index at that level.
-     * @returns -1 if no child exist
-     */
-    getLeftChildAtLevel(level, node) {
-        if (level + 1 >= this.levels) {
-            return -1;
-        }
-        const nodeIndex = this.getIndexAtLevel(level, node);
-        return this.getLeftChild(nodeIndex);
-    }
-    /**
-     * Gets the flat right child of a node, where the node is indexed by its level and its relative index at that level.
-     * @returns -1 if no child exist
-     */
-    getRightChildAtLevel(level, node) {
-        if (level + 1 >= this.levels) {
-            return -1;
-        }
-        const nodeIndex = this.getIndexAtLevel(level, node);
-        return this.getRightChild(nodeIndex);
-    }
-    /**
-     * Gets the flat index of the parent of a node, where the node is indexed by its level and its relative index at that level.
-     * @returns -1 if level has no parent
-     */
-    getParentAtLevel(level, node) {
-        if (level === 0) {
-            return -1;
-        }
-        const nodeIndex = this.getIndexAtLevel(level, node);
-        return this.getParent(nodeIndex);
-    }
-    /** Gets the flat index of the left child of the node.
-     * @returns -1 if no child exist
-     */
-    getLeftChild(node) {
-        const leftChildIndex = 2 * node + 1;
-        const totalNodes = (1 << this.levels) - 1;
-        return leftChildIndex < totalNodes ? leftChildIndex : -1;
-    }
-    /** Gets the flat index of the right child of the node.
-     * @returns -1 if no child exist
-     */
-    getRightChild(node) {
-        const rightChildIndex = 2 * node + 2;
-        const totalNodes = (1 << this.levels) - 1;
-        return rightChildIndex < totalNodes ? rightChildIndex : -1;
-    }
-    /** Gets the flat index of the parent of the node.
-     * @returns -1 if no parent exist
-     */
-    getParent(node) {
-        if (node === 0) {
-            return -1; // Root node has no parent
-        }
-        return Math.floor((node - 1) / 2);
-    }
-    /** Gets the total number of nodes in the tree */
-    getTotalSize() {
-        return (1 << this.levels) - 1; // Equivalent to 2^levels - 1
-    }
-}
-export class StructCursor {
-    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] == -MAX_FLOAT32) {
-            this.data[ix] = x;
-        }
-        if (y < this.data[iy] || this.data[iy] == -MAX_FLOAT32) {
-            this.data[iy] = y;
-        }
-        if (z < this.data[iz] || this.data[iz] == -MAX_FLOAT32) {
-            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] == -MAX_FLOAT32) {
-            this.data[ix] = x;
-        }
-        if (y > this.data[iy] || this.data[iy] == -MAX_FLOAT32) {
-            this.data[iy] = y;
-        }
-        if (z > this.data[iz] || this.data[iz] == -MAX_FLOAT32) {
-            this.data[iz] = z;
-        }
-    }
-}
-export class VoxelMeshBVHBuilder {
-    static AABBStructByteSize = (4 + 4) * 4;
-    treeIndex = new FlatBinaryTreeIndex(13);
-    tree = new Float32Array(new ArrayBuffer(this.treeIndex.getTotalSize() * VoxelMeshBVHBuilder.AABBStructByteSize));
-    structCursor = new StructCursor(this.tree);
-    indices = new Uint32Array(this.treeIndex.getLevelSize(12) * 2);
-    reset() {
-        this.tree.fill(-MAX_FLOAT32);
-        this.indices.fill(0);
-    }
-    updateVoxel(voxelX, voxelY, voxelZ, meshIndex, indicesStart, indicesEnd, minX, minY, minZ, maxX, maxY, maxZ) {
-        const voxelIndex = WorldSpaces.voxel.getIndex(voxelX, voxelY, voxelZ);
-        const leafIndex = this.treeIndex.getIndexAtLevel(12, voxelIndex);
-        this.indices[voxelIndex * 2] = indicesStart;
-        this.indices[voxelIndex * 2 + 1] = indicesEnd;
-        this.structCursor.setIndex(leafIndex);
-        this.structCursor.updateMin(minX, minY, minZ);
-        this.structCursor.updateMax(maxX, maxY, maxZ);
-        this.structCursor.setVoxelIndex(voxelIndex);
-        this.structCursor.setGeomtryNode();
-        let current = leafIndex;
-        for (let level = 1; level < 13; level++) {
-            let parentNode = this.treeIndex.getParent(current);
-            this.structCursor.setIndex(parentNode);
-            this.structCursor.updateMin(minX, minY, minZ);
-            this.structCursor.updateMax(maxX, maxY, maxZ);
-            this.structCursor.setActive();
-            this.structCursor.setInnerNode();
-            current = parentNode;
-        }
-    }
-}