@divinevoxel/vlox 0.0.4 → 0.0.6

package/Mesher/Processors/ChunkProcessor.js

@@ -1,117 +0,0 @@
-//objects
-import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor/DivineVoxelEngineConstructor.js";
-//data
-import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
-//tools
-import { HeightMapTool } from "../../Tools/Data/WorldData/HeightMapTool.js";
-import { VoxelGeometryLookUp } from "../Models//VoxelGeometryLookUp.js";
-import { CompactVoxelMesh } from "../Functions/CompactVoxelMesh.js";
-import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
-import { WorldCursor } from "../../Data/Cursor/World/WorldCursor.js";
-import { ChunkCursor } from "../../Data/Cursor/World/ChunkCursor.js";
-import { RenderedSubstances } from "../Substances/RenderedSubstances.js";
-import { VoxelModelConstructorRegister } from "../Models/VoxelModelConstructorRegister.js";
-export class ChunkProcessor {
-    heightMapTool = new HeightMapTool();
-    substanceData = new SubstanceDataTool();
-    chunkCursor = new ChunkCursor();
-    worldCursor = new WorldCursor();
-    _process(x, y, z, doSecondCheck = false) {
-        const voxel = this.chunkCursor.getVoxel(x, y, z);
-        if (!voxel)
-            return false;
-        if (!voxel.isRenderable())
-            return false;
-        let hasVoxel = false;
-        voxel.setSecondary(doSecondCheck);
-        if (!doSecondCheck) {
-            if (voxel.hasSecondaryVoxel()) {
-                hasVoxel = this._process(x, y, z, true);
-            }
-        }
-        const constructor = VoxelModelConstructorRegister.getConstructor(voxel.getStringId());
-        if (!constructor) {
-            throw new Error(`Could not find constructor ${voxel.getId()} | ${voxel.getName()} `);
-        }
-        const mesher = RenderedSubstances.meshers.get(voxel.getRenderedMaterialStringId());
-        if (!mesher) {
-            throw new Error(`Could not find material for ${voxel.getId()} | ${voxel.getName()} | ${constructor?.id} | ${voxel.getMaterial()} | ${voxel.getRenderedMaterialStringId()}`);
-        }
-        mesher.origin.x = this.chunkCursor._voxelPosition.x;
-        mesher.origin.y = this.chunkCursor._voxelPosition.y;
-        mesher.origin.z = this.chunkCursor._voxelPosition.z;
-        mesher.position.x = x;
-        mesher.position.y = y;
-        mesher.position.z = z;
-        mesher.voxel = voxel;
-        mesher.nVoxel = this.worldCursor;
-        mesher.startConstruction();
-        constructor.process(mesher);
-        mesher.endConstruction();
-        mesher.resetVars();
-        return true;
-    }
-    build(location, priority = 0) {
-        this.heightMapTool.chunk.loadInAtLocation(location);
-        const [dimension, cx, cy, cz] = location;
-        this.worldCursor.setFocalPoint(...location);
-        this.chunkCursor.setChunk(...location);
-        let [minY, maxY] = this.heightMapTool.chunk.getMinMax();
-        const maxX = WorldSpaces.chunk._bounds.x;
-        const maxZ = WorldSpaces.chunk._bounds.z;
-        if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
-            return;
-        VoxelGeometryLookUp.start(dimension, location[1], location[2], location[3]);
-        for (const [substance, mesher] of RenderedSubstances.meshers) {
-            mesher.bvhTool.reset();
-        }
-        for (let y = minY; y <= maxY; y++) {
-            let foundVoxels = false;
-            for (let x = 0; x < maxX; x++) {
-                for (let z = 0; z < maxZ; z++) {
-                    if (this._process(x + cx, y + cy, z + cz)) {
-                        foundVoxels = true;
-                    }
-                }
-            }
-            this.heightMapTool.chunk.setY(y).setHasVoxels(foundVoxels);
-            this.heightMapTool.chunk.setY(y).setDirty(false);
-        }
-        VoxelGeometryLookUp.stop();
-        const trasnfers = [];
-        const chunkEffects = [];
-        const chunks = [
-            location,
-            [],
-            chunkEffects,
-            priority,
-        ];
-        const meshed = [];
-        for (const [substance, mesher] of RenderedSubstances.meshers) {
-            for (const e in mesher.effects) {
-                const float = Float32Array.from(mesher.effects[e]);
-                trasnfers.push(float.buffer);
-                chunkEffects.push([e, float]);
-            }
-            if (mesher.mesh.positions.length == 0) {
-                mesher.resetAll();
-                continue;
-            }
-            meshed.push(mesher);
-        }
-        const compactMesh = CompactVoxelMesh(...meshed);
-        trasnfers.push(...(compactMesh[0] == 0
-            ? [compactMesh[1]]
-            : [
-                compactMesh[1],
-                compactMesh[2].buffer,
-                compactMesh[3].buffer,
-                compactMesh[4].buffer,
-            ]));
-        chunks[1] = compactMesh;
-        for (const mesher of meshed) {
-            mesher.resetAll();
-        }
-        DivineVoxelEngineConstructor.instance.threads.parent.runTasks("set-chunk", chunks, trasnfers);
-    }
-}

package/Mesher/Substances/RenderedSubstances.d.ts

@@ -1,5 +0,0 @@
-import { VoxelMesherDataTool } from "../Tools/VoxelMesherDataTool.js";
-export declare class RenderedSubstances {
-    static meshers: Map<string, VoxelMesherDataTool>;
-    static add(id: string): void;
-}

package/Mesher/Substances/RenderedSubstances.js

@@ -1,7 +0,0 @@
-import { VoxelMesherDataTool } from "../Tools/VoxelMesherDataTool.js";
-export class RenderedSubstances {
-    static meshers = new Map();
-    static add(id) {
-        this.meshers.set(id, new VoxelMesherDataTool(id));
-    }
-}

package/Mesher/Tasks/BuidlerTasks.types.d.ts

@@ -1,7 +0,0 @@
-import { LocationData } from "../../Math";
-import { CompactMeshData } from "Mesher/Types/Mesher.types";
-export type BuildNodeMesh = [location: LocationData, type: string, data: any];
-export type SetNodeMesh = [
-    location: LocationData,
-    attributes: CompactMeshData
-];

package/Mesher/Tasks/BuidlerTasks.types.js

@@ -1 +0,0 @@
-export {};

package/Mesher/Tools/VoxelTemplateDataTool.d.ts

@@ -1,15 +0,0 @@
-import type { DirectionNames } from "../../Util/Util.types.js";
-import { QuadScalarVertexData } from "@amodx/meshing/Primitives/QuadVertexData";
-export declare class VoxelTemplateDataTool {
-    _active: boolean;
-    _faces: Record<DirectionNames, number>;
-    _lights: Record<DirectionNames, QuadScalarVertexData>;
-    _aos: Record<DirectionNames, QuadScalarVertexData>;
-    _light: QuadScalarVertexData;
-    _level: QuadScalarVertexData;
-    _ao: QuadScalarVertexData;
-    isAcive(): boolean;
-    setActive(active: boolean): void;
-    load(template: Uint32Array, index: number): void;
-    isFaceExposed(face: DirectionNames): boolean;
-}

package/Mesher/Tools/VoxelTemplateDataTool.js

@@ -1,112 +0,0 @@
-//data
-import { QuadScalarVertexData } from "@amodx/meshing/Primitives/QuadVertexData";
-export class VoxelTemplateDataTool {
-    _active = false;
-    _faces = {
-        up: 0,
-        down: 0,
-        west: 0,
-        east: 0,
-        north: 0,
-        south: 0,
-    };
-    _lights = {
-        up: new QuadScalarVertexData(),
-        down: new QuadScalarVertexData(),
-        west: new QuadScalarVertexData(),
-        east: new QuadScalarVertexData(),
-        north: new QuadScalarVertexData(),
-        south: new QuadScalarVertexData(),
-    };
-    _aos = {
-        up: new QuadScalarVertexData(),
-        down: new QuadScalarVertexData(),
-        west: new QuadScalarVertexData(),
-        east: new QuadScalarVertexData(),
-        north: new QuadScalarVertexData(),
-        south: new QuadScalarVertexData(),
-    };
-    _light = new QuadScalarVertexData();
-    _level = new QuadScalarVertexData();
-    _ao = new QuadScalarVertexData();
-    isAcive() {
-        return this._active;
-    }
-    setActive(active) {
-        this._active = active;
-    }
-    load(template, index) {
-        const segment2 = template[index + 1];
-        const faceByte = segment2 & 0xff;
-        this._faces.up = (faceByte & (0b1 << 0)) >> 0;
-        this._faces.down = (faceByte & (0b1 << 1)) >> 1;
-        this._faces.west = (faceByte & (0b1 << 2)) >> 2;
-        this._faces.east = (faceByte & (0b1 << 3)) >> 3;
-        this._faces.north = (faceByte & (0b1 << 4)) >> 4;
-        this._faces.south = (faceByte & (0b1 << 5)) >> 5;
-        //deocde light
-        let lightIndex = index + 2;
-        {
-            const light1 = template[lightIndex];
-            const light2 = template[lightIndex + 1];
-            this._lights.up.set(light1 & 0xffff, ((0xffff << 16) & light1) >>> 16, light2 & 0xffff, ((0xffff << 16) & light2) >>> 16);
-        }
-        {
-            const light1 = template[lightIndex + 2];
-            const light2 = template[lightIndex + 3];
-            this._lights.down.set(light1 & 0xffff, ((0xffff << 16) & light1) >>> 16, light2 & 0xffff, ((0xffff << 16) & light2) >>> 16);
-        }
-        {
-            const light1 = template[lightIndex + 4];
-            const light2 = template[lightIndex + 5];
-            this._lights.west.set(light1 & 0xffff, ((0xffff << 16) & light1) >>> 16, light2 & 0xffff, ((0xffff << 16) & light2) >>> 16);
-        }
-        {
-            const light1 = template[lightIndex + 6];
-            const light2 = template[lightIndex + 7];
-            this._lights.east.set(light1 & 0xffff, ((0xffff << 16) & light1) >>> 16, light2 & 0xffff, ((0xffff << 16) & light2) >>> 16);
-        }
-        {
-            const light1 = template[lightIndex + 8];
-            const light2 = template[lightIndex + 9];
-            this._lights.north.set(light1 & 0xffff, ((0xffff << 16) & light1) >>> 16, light2 & 0xffff, ((0xffff << 16) & light2) >>> 16);
-        }
-        {
-            const light1 = template[lightIndex + 10];
-            const light2 = template[lightIndex + 11];
-            this._lights.south.set(light1 & 0xffff, ((0xffff << 16) & light1) >>> 16, light2 & 0xffff, ((0xffff << 16) & light2) >>> 16);
-        }
-        let aoIndex = lightIndex + 12;
-        //decode ao
-        {
-            const ao = template[aoIndex];
-            this._aos.up.set(ao & 0xf, ((0xf << 4) & ao) >>> 4, ((0xf << 8) & ao) >>> 8, ((0xf << 12) & ao) >>> 12);
-        }
-        {
-            const ao = ((0xffff << 16) & template[aoIndex]) >> 16;
-            this._aos.down.set(ao & 0xf, ((0xf << 4) & ao) >>> 4, ((0xf << 8) & ao) >>> 8, ((0xf << 12) & ao) >>> 12);
-        }
-        {
-            const ao = template[aoIndex + 1];
-            this._aos.west.set(ao & 0xf, ((0xf << 4) & ao) >>> 4, ((0xf << 8) & ao) >>> 8, ((0xf << 12) & ao) >>> 12);
-        }
-        {
-            const ao = ((0xffff << 16) & template[aoIndex + 1]) >> 16;
-            this._aos.east.set(ao & 0xf, ((0xf << 4) & ao) >>> 4, ((0xf << 8) & ao) >>> 8, ((0xf << 12) & ao) >>> 12);
-        }
-        {
-            const ao = template[aoIndex + 2];
-            this._aos.north.set(ao & 0xf, ((0xf << 4) & ao) >>> 4, ((0xf << 8) & ao) >>> 8, ((0xf << 12) & ao) >>> 12);
-        }
-        {
-            const ao = ((0xffff << 16) & template[aoIndex + 2]) >> 16;
-            this._aos.south.set(ao & 0xf, ((0xf << 4) & ao) >>> 4, ((0xf << 8) & ao) >>> 8, ((0xf << 12) & ao) >>> 12);
-        }
-        //   this._light.setAll(LightData.setRGB(0xf0f, 0));
-        //   this._ao.setAll(1);
-        this._level.setAll(0xf);
-    }
-    isFaceExposed(face) {
-        return this._faces[face] == 1;
-    }
-}

package/Renderer/Classes/ChunkMesh.d.ts

@@ -1,10 +0,0 @@
-import { ChunkMeshInterface } from "../DVEChunkMeshInterface";
-import { VoxelEffect } from "../../Voxels/Effects/VoxelEffect";
-import { Vec3Array } from "@amodx/math";
-export declare class ChunkMesh {
-    location: Vec3Array;
-    meshes: Map<string, ChunkMeshInterface>;
-    effects: Map<string, VoxelEffect>;
-    constructor(location: Vec3Array);
-    dispose(): void;
-}

package/Renderer/Classes/ChunkMesh.js

@@ -1,13 +0,0 @@
-export class ChunkMesh {
-    location;
-    meshes = new Map();
-    effects = new Map();
-    constructor(location) {
-        this.location = location;
-    }
-    dispose() {
-        for (const [key, effect] of this.effects) {
-            effect.dispose();
-        }
-    }
-}

package/Renderer/Classes/MeshRegisterColumn.d.ts

@@ -1,7 +0,0 @@
-import { LocationData } from "Math";
-import { ChunkMesh } from "./ChunkMesh";
-export declare class MeshRegisterColumn {
-    location: LocationData;
-    chunks: Map<number, ChunkMesh>;
-    constructor(location: LocationData);
-}

package/Renderer/Classes/MeshRegisterColumn.js

@@ -1,7 +0,0 @@
-export class MeshRegisterColumn {
-    location;
-    chunks = new Map();
-    constructor(location) {
-        this.location = location;
-    }
-}

package/Renderer/Classes/MushRegisterRegion.d.ts

@@ -1,4 +0,0 @@
-import { MeshRegisterColumn } from "./MeshRegisterColumn";
-export declare class MushRegisterRegion {
-    columns: Map<number, MeshRegisterColumn>;
-}

package/Renderer/Classes/MushRegisterRegion.js

@@ -1,3 +0,0 @@
-export class MushRegisterRegion {
-    columns = new Map();
-}

package/Renderer/DVEChunkMeshInterface.d.ts

@@ -1,3 +0,0 @@
-export interface ChunkMeshInterface {
-    dispose(): void;
-}

package/Renderer/DVEChunkMeshInterface.js

@@ -1 +0,0 @@
-export {};

package/Renderer/DVEChunkMeshes.d.ts

@@ -1,6 +0,0 @@
-import { Vec3Array } from "@amodx/math";
-import { CompactMeshData } from "../Mesher/Types/Mesher.types";
-import { ChunkMesh } from "./Classes/ChunkMesh";
-export declare abstract class DVEChunkMeshes {
-    abstract updateVertexData(chunk: ChunkMesh, position: Vec3Array, data: CompactMeshData): ChunkMesh;
-}

package/Renderer/DVEChunkMeshes.js

@@ -1,2 +0,0 @@
-export class DVEChunkMeshes {
-}

package/Tasks/Analyzer/Analyzer.d.ts

@@ -1,19 +0,0 @@
-import type { AnaylzerTask } from "../Tasks.types.js";
-import type { LocationData } from "../../Math";
-import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor/DivineVoxelEngineConstructor.js";
-import { WorldCursor } from "../../Data/Cursor/World/WorldCursor.js";
-import { ChunkCursor } from "../../Data/Cursor/World/ChunkCursor.js";
-import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
-export declare class Analyzer {
-    updater: {
-        _voxels: Map<string, (locaton: LocationData, deltaTime: number, anayzer: Analyzer, DVEC: DivineVoxelEngineConstructor) => void>;
-        registerVoxel(id: string, run: (locaton: LocationData, deltaTime: number, anayzer: Analyzer, DVEC: DivineVoxelEngineConstructor) => void): void;
-        getVoxel(id: string): false | ((locaton: LocationData, deltaTime: number, anayzer: Analyzer, DVEC: DivineVoxelEngineConstructor) => void);
-    };
-    worldCurosr: WorldCursor;
-    chunkCursor: ChunkCursor;
-    substanceData: SubstanceDataTool;
-    _flowChecks: number[][];
-    runPropagation(data: AnaylzerTask): Promise<void>;
-    runUpdate(data: AnaylzerTask): Promise<void>;
-}

package/Tasks/Analyzer/Analyzer.js

@@ -1,156 +0,0 @@
-//objects
-import { EngineSettings } from "../../Settings/EngineSettings.js";
-import { AnalyzerUpdater } from "./AnalyzerUpdater.js";
-import { Propagation } from "../Propagation/Propagation.js";
-import { WorldRegister } from "../../Data/World/WorldRegister.js";
-//tools
-import { WorldSpaces } from "../../Data/World/WorldSpaces.js";
-import { ColumnDataTool } from "../../Tools/Data/WorldData/ColumnDataTool.js";
-import { HeightMapTool } from "../../Tools/Data/WorldData/HeightMapTool.js";
-import { WorldCursor } from "../../Data/Cursor/World/WorldCursor.js";
-import { ChunkCursor } from "../../Data/Cursor/World/ChunkCursor.js";
-import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
-import { UpdateTask } from "../Update/UpdateTask.js";
-const columnTool = new ColumnDataTool();
-const heightMapTool = new HeightMapTool();
-//const mainDT = new DataTool();
-//const secondaryDT = new DataTool();
-export class Analyzer {
-    updater = AnalyzerUpdater;
-    worldCurosr = new WorldCursor();
-    chunkCursor = new ChunkCursor();
-    substanceData = new SubstanceDataTool();
-    _flowChecks = [
-        [0, -1, 0],
-        [1, 0, 0],
-        [-1, 0, 0],
-        [0, 0, 1],
-        [0, 0, -1],
-    ];
-    async runPropagation(data) {
-        let t = {};
-        this.worldCurosr.setFocalPoint(...data[0]);
-        const options = {
-            light: EngineSettings.doLight(),
-            flow: EngineSettings.doFlow(),
-        };
-        //  mainDT.setDimension(data[0][0]);
-        const location = data[0];
-        // secondaryDT.setDimension(data[0][0]);
-        const tasks = new UpdateTask();
-        tasks.setOrigin(location);
-        if (!columnTool.loadInAtLocation(location))
-            return;
-        WorldRegister.instance.cache.enable();
-        const column = columnTool.getColumn();
-        let maxX = WorldSpaces.chunk._bounds.x + location[1];
-        let maxZ = WorldSpaces.chunk._bounds.z + location[3];
-        for (let i = 0; i < column.chunks.length; i++) {
-            const chunk = column.chunks[i];
-            if (!chunk)
-                continue;
-            heightMapTool.chunk.setChunk(chunk);
-            this.chunkCursor.setChunk(chunk);
-            const [cx, cy, cz] = [
-                location[1],
-                location[2] + i * WorldSpaces.chunk.getHeight(),
-                location[3],
-            ];
-            let [minY, maxY] = heightMapTool.chunk.getMinMax();
-            if (Math.abs(minY) == Infinity && Math.abs(maxY) == Infinity)
-                continue;
-            for (let y = cy + minY; y <= cy + maxY; y++) {
-                for (let z = cz; z < maxZ; z++) {
-                    for (let x = cx; x < maxX; x++) {
-                        const voxel = this.chunkCursor.getVoxel(x, y, z);
-                        if (!voxel || voxel.isAir())
-                            continue;
-                        if (options.light) {
-                            if (voxel.isLightSource()) {
-                                tasks.rgb.update.push(x, y, z);
-                            }
-                        }
-                        if (options.flow) {
-                            t = {
-                                id: voxel.getStringId(),
-                                sustance: voxel.getSubstance(),
-                                substanceStringId: voxel.getSubstanceStringId(),
-                            };
-                            if (this.substanceData.setSubstance(voxel.getSubstance()).isLiquid()) {
-                                let add = false;
-                                for (const check of this._flowChecks) {
-                                    const nVoxel = this.worldCurosr.getVoxel(x + check[0], y + check[1], z + check[2]);
-                                    if (nVoxel) {
-                                        if (nVoxel.isAir()) {
-                                            add = true;
-                                            break;
-                                        }
-                                    }
-                                }
-                                if (add) {
-                                    //  tasks.flow.update.queue.push([x, y, z]);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        WorldRegister.instance.cache.disable();
-        Propagation.instance.rgbUpdate(tasks);
-        const dimension = data[0][0];
-        for (const flowUpdate of tasks.flow.update.queue) {
-            const [x, y, z] = flowUpdate;
-            if (!this.worldCurosr.getVoxel(x, y, z))
-                continue;
-            const tasks = new UpdateTask();
-            tasks.setOrigin([dimension, x, y, z]);
-            await Propagation.instance.flowUpdate(tasks, false);
-        }
-    }
-    async runUpdate(data) {
-        /*     if (!columnTool.setLocation(data[0]).loadIn()) return;
-        const deltaTime = Date.now() - columnTool.getLastAnalyzerUpdateTimestamp();
-    
-        const location = [...data[0]] as LocationData;
-    
-        WorldRegister.instance.cache.enable();
-        const column = columnTool.getColumn();
-        let maxX = WorldSpaces.chunk._bounds.x + location[1];
-        let maxZ = WorldSpaces.chunk._bounds.z + location[3];
-        for (let i = 0; i < column.chunks.length; i++) {
-          const chunk = column.chunks[i];
-          if (!chunk) continue;
-          heightMapTool.chunk.setChunk(chunk);
-          const [cx, cy, cz] = [
-            location[1],
-            location[2] + i * WorldSpaces.chunk.getHeight(),
-            location[3],
-          ];
-          let [minY, maxY] = heightMapTool.chunk.getMinMax();
-          minY += cy;
-          maxY += cy + 1;
-          for (let y = minY; y < maxY; y += 1) {
-            for (let z = cz; z < maxZ; z += 1) {
-              for (let x = cx; x < maxX; x += 1) {
-                if (!mainDT.loadInAt(x, y, z)) continue;
-                location[1] = x;
-                location[2] = y;
-                location[3] = z;
-                const run = this.updater.getVoxel(mainDT.getStringId());
-                if (!run) continue;
-                run(
-                  location,
-                  deltaTime,
-                  this,
-                  DivineVoxelEngineConstructor.instance
-                );
-              }
-            }
-          }
-        }
-    
-        WorldRegister.instance.cache.disable();
-        columnTool.setLastAnalyzerUpdateTimestamp(); */
-    }
-}

package/Tasks/Analyzer/AnalyzerUpdater.d.ts

@@ -1,10 +0,0 @@
-import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor/DivineVoxelEngineConstructor.js";
-import type { LocationData } from "../../Math";
-import type { Analyzer } from "./Analyzer";
-type RunFunction = (locaton: LocationData, deltaTime: number, anayzer: Analyzer, DVEC: DivineVoxelEngineConstructor) => void;
-export declare const AnalyzerUpdater: {
-    _voxels: Map<string, RunFunction>;
-    registerVoxel(id: string, run: RunFunction): void;
-    getVoxel(id: string): false | RunFunction;
-};
-export {};

package/Tasks/Analyzer/AnalyzerUpdater.js

@@ -1,13 +0,0 @@
-;
-export const AnalyzerUpdater = {
-    _voxels: new Map(),
-    registerVoxel(id, run) {
-        this._voxels.set(id, run);
-    },
-    getVoxel(id) {
-        const run = this._voxels.get(id);
-        if (!run)
-            return false;
-        return run;
-    },
-};

package/Tasks/Analyzer/InitTasks.d.ts

@@ -1 +0,0 @@
-export default function (): void;

package/Tasks/Analyzer/InitTasks.js

@@ -1,16 +0,0 @@
-import { Threads } from "@amodx/threads";
-import { Analyzer } from "./Analyzer";
-import { TasksIds } from "../TasksIds";
-export default function () {
-    const analyzer = new Analyzer();
-    Threads.registerTasks(TasksIds.AnalyzerPropagation, async (data, onDone) => {
-        await analyzer.runPropagation(data);
-        if (onDone)
-            onDone();
-    }, "deferred");
-    Threads.registerTasks(TasksIds.AnalyzerUpdate, async (data, onDone) => {
-        await analyzer.runUpdate(data);
-        if (onDone)
-            onDone();
-    }, "deferred");
-}

package/Tasks/DataLoader/Broswer/DataHandler.d.ts

@@ -1,20 +0,0 @@
-import { WorldDataTool } from "./WorldDataTool";
-import { LocationData } from "../../../Math";
-import { DVEDataHandler } from "../Types/DVEDataHandler";
-import { WorldDataBase } from "./WorldDataBase";
-export declare class DefaultDataHandler extends DVEDataHandler {
-    static instance: DefaultDataHandler;
-    worldDataTool: WorldDataTool;
-    worldData: WorldDataBase;
-    constructor();
-    init(): Promise<void>;
-    openWorldDataBae(id: string, dimension?: string): Promise<void>;
-    getRegionHeader(location: LocationData): Promise<ArrayBuffer>;
-    getColumn(location: LocationData): Promise<ArrayBufferLike>;
-    saveColumn(location: LocationData, buffer: ArrayBuffer): Promise<boolean>;
-    setPath(id: string): Promise<boolean>;
-    columnExists(location: LocationData): Promise<boolean>;
-    columnExistsBatch(location: LocationData[]): Promise<Record<string, boolean>>;
-    columnTimestamp(location: LocationData): Promise<number>;
-    columnHasSegment(location: LocationData, segment: "rich-data" | "dbo" | "entities"): Promise<boolean>;
-}

package/Tasks/DataLoader/Broswer/DataHandler.js

@@ -1,54 +0,0 @@
-import { DVEDataHandler } from "../Types/DVEDataHandler";
-import { WorldDataBaseManager } from "./WorldDataBaseManager";
-export class DefaultDataHandler extends DVEDataHandler {
-    static instance;
-    worldDataTool;
-    worldData;
-    constructor() {
-        super();
-        if (DefaultDataHandler.instance)
-            return DefaultDataHandler.instance;
-        DefaultDataHandler.instance = this;
-    }
-    async init() {
-        await WorldDataBaseManager.init();
-    }
-    async openWorldDataBae(id, dimension = "main") {
-        const worldDataBase = await WorldDataBaseManager.getWorldDataBase(id);
-        await worldDataBase.setDimension(dimension);
-        this.worldData = worldDataBase;
-        this.worldDataTool = worldDataBase.worldDataTool;
-    }
-    async getRegionHeader(location) {
-        this.worldDataTool.setType(this.dataType);
-        return await this.worldDataTool.loadRegionHeader(location);
-    }
-    async getColumn(location) {
-        this.worldDataTool.setType(this.dataType);
-        return await this.worldDataTool.loadColumn(location);
-    }
-    async saveColumn(location, buffer) {
-        this.worldDataTool.setType(this.dataType);
-        return await this.worldDataTool.saveColumn(location, buffer);
-    }
-    async setPath(id) {
-        this.worldDataTool.setType(this.dataType);
-        return this.worldDataTool.setPath(id);
-    }
-    async columnExists(location) {
-        this.worldDataTool.setType(this.dataType);
-        return await this.worldDataTool.columnExists(location);
-    }
-    async columnExistsBatch(location) {
-        this.worldDataTool.setType(this.dataType);
-        return await this.worldDataTool.columnExistsBatch(location);
-    }
-    async columnTimestamp(location) {
-        this.worldDataTool.setType(this.dataType);
-        return await this.worldDataTool.columnTimestamp(location);
-    }
-    async columnHasSegment(location, segment) {
-        this.worldDataTool.setType(segment);
-        return await this.worldDataTool.columnExists(location);
-    }
-}