@divinevoxel/vlox 0.0.0

package/VoxelModels/State/State.types.js

@@ -0,0 +1,22 @@
+export var StateCompareOperations;
+(function (StateCompareOperations) {
+    StateCompareOperations[StateCompareOperations["Equals"] = 0] = "Equals";
+    StateCompareOperations[StateCompareOperations["NotEquals"] = 1] = "NotEquals";
+    StateCompareOperations[StateCompareOperations["GreaterThan"] = 2] = "GreaterThan";
+    StateCompareOperations[StateCompareOperations["LessThan"] = 3] = "LessThan";
+})(StateCompareOperations || (StateCompareOperations = {}));
+export var StateLogiceOperations;
+(function (StateLogiceOperations) {
+    StateLogiceOperations[StateLogiceOperations["And"] = 0] = "And";
+    StateLogiceOperations[StateLogiceOperations["Or"] = 1] = "Or";
+})(StateLogiceOperations || (StateLogiceOperations = {}));
+export const StateCompareOperationsMap = {
+    "=": StateCompareOperations.Equals,
+    "!=": StateCompareOperations.NotEquals,
+    ">": StateCompareOperations.GreaterThan,
+    "<": StateCompareOperations.LessThan,
+};
+export const StateLogicOperationsMap = {
+    "&&": StateLogiceOperations.And,
+    "||": StateLogiceOperations.Or,
+};

package/VoxelModels/State/StateTreeReader.d.ts

@@ -0,0 +1,9 @@
+import { StateSchema } from "./Schema/StateSchema";
+export declare class StateTreeReader {
+    schema: StateSchema;
+    defaultValue: number;
+    tree: any[];
+    startingIndex: number;
+    constructor(schema: StateSchema, defaultValue: number, tree: any[]);
+    getState(shapeState: number): number;
+}

package/VoxelModels/State/StateTreeReader.js

@@ -0,0 +1,35 @@
+export class StateTreeReader {
+    schema;
+    defaultValue;
+    tree;
+    startingIndex = 0;
+    constructor(schema, defaultValue = 0, tree) {
+        this.schema = schema;
+        this.defaultValue = defaultValue;
+        this.tree = tree;
+    }
+    getState(shapeState) {
+        if (!this.tree.length)
+            return this.defaultValue;
+        let found = -1;
+        let index = this.startingIndex;
+        let curretNode = this.tree;
+        while (found == -1) {
+            curretNode =
+                curretNode[index][this.schema.nodes[index].getValue(shapeState)];
+            if (typeof curretNode == "number") {
+                return curretNode;
+            }
+            for (let i = 0; i < curretNode.length; i++) {
+                if (curretNode[i]) {
+                    index = i;
+                    break;
+                }
+            }
+            if (typeof curretNode == "number") {
+                return curretNode;
+            }
+        }
+        return found;
+    }
+}

package/VoxelModels/Tags/TagsOverrides.d.ts

@@ -0,0 +1,5 @@
+import { StateTreeReader } from "../State/StateTreeReader";
+export declare class TagOverrides {
+    static isLightSource: StateTreeReader[];
+    static lightValue: StateTreeReader[];
+}

package/VoxelModels/Tags/TagsOverrides.js

@@ -0,0 +1,4 @@
+export class TagOverrides {
+    static isLightSource = [];
+    static lightValue = [];
+}

package/VoxelModels/VoxelModel.types.d.ts

@@ -0,0 +1,135 @@
+import { Vec2Array, Vec3Array } from "@amodx/math";
+import { QuadUVData } from "@amodx/meshing/Geometry.types";
+import { VoxelFaceNames } from "../Math";
+export interface VoxelModelConstructorData {
+    id: string;
+    modRelationSchema?: VoxelModelRelationsSchemaData[];
+    modSchema?: VoxelBinaryStringSchemaData[];
+    inputs: Record<string, Record<string, any>>;
+    tagOverrides?: {
+        isLightSource?: Record<string, boolean>;
+        lightValue?: Record<string, Vec3Array>;
+    };
+}
+export interface VoxelBoxGeometryNode {
+    type: "box";
+    noShade?: boolean;
+    points: [start: Vec3Array, end: Vec3Array];
+    rotation?: Vec3Array;
+    faces: Record<VoxelFaceNames, VoxelBoxFaceData>;
+}
+export interface VoxelBoxFaceData {
+    enabled?: boolean;
+    flip?: boolean;
+    texture: string;
+    transparent?: boolean | string;
+    uv: [x1: number, y1: number, x2: number, y2: number] | string;
+    rotation?: number | string;
+}
+export interface VoxelQuadGeometryNode {
+    type: "quad";
+    doubleSided?: boolean | string;
+    points: [p1: Vec3Array, p2: Vec3Array, p3: Vec3Array, p4: Vec3Array];
+    transparent?: boolean | string;
+    texture: string;
+    uv: [x1: number, y1: number, x2: number, y2: number] | QuadUVData | string;
+    textureRotation?: number | string;
+}
+export interface VoxelTriangleGeometryNode {
+    type: "triangle";
+    orientation?: 0 | 1;
+    doubleSided?: boolean;
+    points: [p1: Vec3Array, p2: Vec3Array, p3: Vec3Array];
+    transparent?: boolean | string;
+    texture: string;
+    uv: [v1: Vec2Array, v2: Vec2Array, v3: Vec2Array] | string;
+    textureRotation?: number | string;
+}
+export interface VoxelRawGeometryGeometryNode {
+    type: "raw-geometry";
+    positions: number[];
+    normals: number[];
+    indices: number[];
+    uvs: number[];
+    texture: string;
+}
+export interface VoxelGeometryTextureArgument {
+    type: "texture";
+}
+export interface VoxelGeometryBooleanArgument {
+    type: "boolean";
+    default: boolean;
+}
+export interface VoxelGeometryIntArgument {
+    type: "int";
+    default: number;
+}
+export interface VoxelGeometryFloatArgument {
+    type: "float";
+    default: number;
+}
+export interface VoxelGeometryBoxUVArgument {
+    type: "box-uv";
+    default: [x1: number, y1: number, x2: number, y2: number];
+}
+export interface VoxelGeometryVector3Argument {
+    type: "vector3";
+    default?: Vec3Array;
+    min?: Vec3Array;
+    max?: Vec3Array;
+}
+export interface VoxelBinaryStringSchemaData {
+    name: string;
+    type: "string";
+    values: Record<number, string>;
+}
+export interface VoxelBinaryNumberSchemaData {
+    name: string;
+    type: "number";
+    maxValue: number;
+}
+export interface SameVoxelRelationsConditionData {
+    type: "same-voxel";
+    direction: Vec3Array;
+}
+export interface AnyVoxelRelationsConditionData {
+    type: "any-voxel";
+    direction: Vec3Array;
+}
+export type VoxelModelRelationsConditionData = SameVoxelRelationsConditionData | AnyVoxelRelationsConditionData;
+export interface VoxelModelRelationsSchemaData {
+    name: string;
+    conditions: VoxelModelRelationsConditionData[];
+}
+export type VoxelGeometryNodes = VoxelBoxGeometryNode | VoxelTriangleGeometryNode | VoxelQuadGeometryNode | VoxelRawGeometryGeometryNode;
+export interface VoxelGeometryData {
+    id: string;
+    nodes: VoxelGeometryNodes[];
+    /**
+     * If this is set the voxel geometry will not be included in the
+     * geometry rules and will be fall back to custom inputs.
+     * Ideal for advanced or non cubic models.
+     * */
+    doNotBuildRules?: true;
+    arguments: Record<string, VoxelGeometryTextureArgument | VoxelGeometryBoxUVArgument | VoxelGeometryVector3Argument | VoxelGeometryIntArgument | VoxelGeometryBooleanArgument | VoxelGeometryFloatArgument>;
+}
+export interface VoxelGeometryBaseLinkData {
+    inputs: Record<string, any>;
+    scale?: Vec3Array;
+    position?: Vec3Array;
+    rotation?: Vec3Array;
+    rotationPivot?: Vec3Array;
+    flip?: [flipX: 0 | 1, flipY: 0 | 1, flipZ: 0 | 1];
+}
+export interface VoxelGeometryLinkData extends VoxelGeometryBaseLinkData {
+    id: string;
+    geometryId: string;
+}
+export interface VoxelModelData {
+    id: string;
+    arguments: Record<string, VoxelGeometryTextureArgument | VoxelGeometryBoxUVArgument | VoxelGeometryVector3Argument | VoxelGeometryIntArgument | VoxelGeometryBooleanArgument | VoxelGeometryFloatArgument>;
+    shapeStateSchema: (VoxelBinaryStringSchemaData | VoxelBinaryNumberSchemaData)[];
+    relationsSchema: VoxelModelRelationsSchemaData[];
+    shapeStatesNodes: Record<string, VoxelGeometryLinkData[]>;
+    shapeStatesConditonalNodes: Record<string, VoxelGeometryLinkData[]>;
+}

package/VoxelModels/VoxelModel.types.js

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

package/VoxelModels/VoxelModelRules.types.d.ts

@@ -0,0 +1,67 @@
+import { Vec3Array } from "@amodx/math";
+import { VoxelAOResultsIndexData } from "./Indexing/VoxelAOResultsIndex";
+import { VoxelFaceCullResultsIndexData } from "./Indexing/VoxelFaceCullResultsIndex";
+import { VoxelFaceTransparentResultsIndexData } from "./Indexing/VoxelFaceTransparentResultsIndex";
+import { VoxelModelStateSchemaData, StateLogicStatement } from "./State/State.types";
+import { VoxelGeometryData, VoxelGeometryNodes } from "./VoxelModel.types";
+export interface PrcoessedVoxelGeometryNodes {
+    node: VoxelGeometryNodes;
+    tranform: VoxelGeometryTransform;
+}
+export interface VoxelGeometryTransform {
+    position?: Vec3Array;
+    scale?: Vec3Array;
+    rotation?: Vec3Array;
+    rotationPivot?: Vec3Array;
+    lockUVs?: true;
+    flip?: [flipX: 0 | 1, flipY: 0 | 1, flipZ: 0 | 1];
+}
+export interface PrcoessedVoxelGeometryData {
+    id: string;
+    ogData: VoxelGeometryData;
+    nodes: PrcoessedVoxelGeometryNodes[];
+}
+export interface VoxelGeometrySyncData {
+    id: string;
+    nodes: PrcoessedVoxelGeometryNodes[];
+    faceCullMap: number[][];
+    vertexHitMap: number[][];
+    aoIndex: VoxelAOResultsIndexData;
+    cullIndex: VoxelFaceCullResultsIndexData;
+}
+export interface VoxelGeometryRulelessSyncData {
+    id: string;
+    nodes: PrcoessedVoxelGeometryNodes[];
+    ruleless: true;
+}
+export interface VoxelModelSyncData {
+    id: string;
+    schema: VoxelModelStateSchemaData[];
+    geoLinkMap: number[];
+    shapeStateTree: any[];
+    shapeStateMap: number[][];
+    shapeStateGeometryMap: number[][];
+    shapeStateRelativeGeometryMap: number[][];
+    relativeGeometryByteIndexMap: number[];
+    condiotnalStatements: StateLogicStatement[];
+    condiotnalStateMap: number[][];
+    condiotnalShapeStateMap: number[][][];
+    condiotnalShapeStateGeometryMap: number[][][];
+    condiotnalShapeStateRelativeGeometryMap: number[][];
+    condiotnalStateTree: any[];
+}
+export interface VoxelInputsSyncData {
+    id: string;
+    modelId: string;
+    transparentFaceIndex: VoxelFaceTransparentResultsIndexData;
+    modSchema: VoxelModelStateSchemaData[];
+    modStateTree: any[];
+    baseGeometryInputMap: any[][];
+    condiotnalGeometryInputMap: any[][];
+}
+export interface ConstructorVoxelModelSyncData {
+    geometryPalette: string[];
+    geometry: (VoxelGeometrySyncData | VoxelGeometryRulelessSyncData)[];
+    models: VoxelModelSyncData[];
+    voxels: VoxelInputsSyncData[];
+}

package/VoxelModels/VoxelModelRules.types.js

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

package/VoxelModels/World/InitVoxelModelsWorld.d.ts

@@ -0,0 +1,2 @@
+import { DivineVoxelEngineWorld } from "../../Contexts/World";
+export default function (DVEW: DivineVoxelEngineWorld): void;

package/VoxelModels/World/InitVoxelModelsWorld.js

@@ -0,0 +1,11 @@
+import { SchemaRegister } from "../State/SchemaRegister";
+export default function (DVEW) {
+    DVEW.TC.registerTasks("sync-voxel-model-data", (data) => {
+        for (const model of data.models) {
+            SchemaRegister.registerModel(model.id, model.schema);
+        }
+        for (const voxel of data.voxels) {
+            SchemaRegister.registerVoxel(voxel.id, voxel.modelId, voxel.modSchema);
+        }
+    });
+}

package/WorldGeneration/WorldGenBrush.d.ts

@@ -0,0 +1,75 @@
+import type { Vec3Array } from "@amodx/math";
+import { RichDataTool } from "../Tools/Data/RichDataTool.js";
+import { BrushTool } from "../Tools/Brush/Brush.js";
+export declare class WorldGenBrush extends BrushTool {
+    constructor();
+    requestsId: "";
+    tasks: {
+        rebuildQueMap: Map<string, boolean>;
+        comm: import("@amodx/threads").Thread;
+        priority: import("../Types/Tasks.types.js").Priorities;
+        LOD: number;
+        syncQueue: import("../Math/index.js").LocationData[];
+        aSyncQueue: import("../Math/index.js").LocationData[];
+        buildMode: "sync" | "async";
+        buildTasks: import("../Types/Tasks.types.js").PriorityTask<import("../Types/Tasks.types.js").BuildTasks>;
+        trackedChunks: Map<string, Vec3Array>;
+        keepTrackOfChunks: boolean;
+        rebuildTasks: import("../Types/Tasks.types.js").AddToRebuildQueue;
+        tasksType: string;
+        origin: import("../Math/index.js").LocationData;
+        data: null;
+        buildQueue: string;
+        originThread: string;
+        queues: {
+            flow: {
+                update: {
+                    queue: number[][];
+                    map: import("../Util/VisistedMap.js").VisitedMap;
+                };
+                remove: {
+                    queue: number[][];
+                    map: import("../Util/VisistedMap.js").VisitedMap;
+                    noRemoveMap: import("../Util/VisistedMap.js").VisitedMap;
+                };
+            };
+            rgb: {
+                update: number[];
+                remove: number[];
+                map: import("../Util/VisistedMap.js").VisitedMap;
+            };
+            sun: {
+                update: number[];
+                remove: number[];
+                updateMap: import("../Util/VisistedMap.js").VisitedMap;
+                remvoeMap: import("../Util/VisistedMap.js").VisitedMap;
+            };
+        };
+        start(): any;
+        stop(): any;
+        setPriority(priority: import("../Types/Tasks.types.js").Priorities): any;
+        getData(): null;
+        getOriginThread(): import("../Math/index.js").LocationData;
+        getBuildQueue(): string;
+        getOrigin(): import("../Math/index.js").LocationData;
+        needsRebuild(): boolean;
+        needsToUpdateOriginThread(): boolean;
+        clearBuildQueue(): void;
+        setBuldMode(mode: "sync" | "async"): any;
+        addToRebuildQueue(x: number, y: number, z: number): boolean;
+        addNeighborsToRebuildQueue(x: number, y: number, z: number): false | any | undefined;
+        runRebuildQueue(): any;
+        clear(): void;
+    };
+    richData: RichDataTool;
+    setDimension(dimensionId: string): this;
+    get keepTrackOfChunksToBuild(): boolean;
+    set keepTrackOfChunksToBuild(value: boolean);
+    paint(): this;
+    getUpdatedChunks(): Vec3Array[];
+    update(): false | undefined;
+    erase(): this;
+    runUpdates(): void;
+    worldAlloc(start: Vec3Array, end: Vec3Array): Promise<boolean>;
+    worldDealloc(start: Vec3Array, end: Vec3Array): Promise<boolean>;
+}

package/WorldGeneration/WorldGenBrush.js

@@ -0,0 +1,136 @@
+import { WorldGenRegister } from "./WorldGenRegister.js";
+import { RichDataTool } from "../Tools/Data/RichDataTool.js";
+import { BrushTool } from "../Tools/Brush/Brush.js";
+import { LightData } from "../Data/LightData.js";
+import { TasksRequest } from "../Contexts/Constructor/Tasks/TasksRequest.js";
+import { WorldGeneration } from "./WorldGeneration.js";
+import { SafePromise } from "@amodx/core/Promises/SafePromise.js";
+import { Propagation } from "../Propagation/Propagation.js";
+import { DivineVoxelEngineConstructor } from "../Contexts/Constructor/DivineVoxelEngineConstructor.js";
+export class WorldGenBrush extends BrushTool {
+    constructor() {
+        super();
+        WorldGeneration._brushes.push(this);
+    }
+    requestsId;
+    tasks = TasksRequest.getVoxelUpdateRequests(["main", 0, 0, 0]);
+    richData = new RichDataTool();
+    setDimension(dimensionId) {
+        this.dimension = dimensionId;
+        this.tasks.origin[0] = dimensionId;
+        this._dt.setDimension(dimensionId);
+        return this;
+    }
+    get keepTrackOfChunksToBuild() {
+        return this.tasks.keepTrackOfChunks;
+    }
+    set keepTrackOfChunksToBuild(value) {
+        this.tasks.keepTrackOfChunks = value;
+    }
+    paint() {
+        if (!this._dt.setDimension(this.dimension).loadInAt(this.x, this.y, this.z)) {
+            if (this.requestsId != "") {
+                WorldGenRegister.addToRequest(this.requestsId, [this.dimension, this.x, this.y, this.z], [...this.getRaw()]);
+                return this;
+            }
+            throw new Error(`Tried painting in an unloaded location ${[
+                this.dimension,
+                this.x,
+                this.y,
+                this.z,
+            ].toString()}`);
+        }
+        if (this._dt.isRenderable()) {
+            this.erase();
+            this._dt.setDimension(this.dimension).loadInAt(this.x, this.y, this.z);
+        }
+        const sl = this._dt.getLight();
+        if (LightData.hasRGBLight(sl)) {
+            this.tasks.queues.rgb.remove.push(this.x, this.y, this.z);
+            Propagation.instance.rgbRemove(this.tasks);
+        }
+        if (LightData.hasSunLight(sl)) {
+            this.tasks.queues.sun.remove.push(this.x, this.y, this.z);
+            Propagation.instance.sunRemove(this.tasks);
+        }
+        this._worldPainter.dimenion = this.dimension;
+        this._worldPainter.data = this.data;
+        this._worldPainter.paintVoxel(this.x, this.y, this.z);
+        if (this.keepTrackOfChunksToBuild) {
+            this.tasks.addNeighborsToRebuildQueue(this.x, this.y, this.z);
+        }
+        return this;
+    }
+    getUpdatedChunks() {
+        const queue = [];
+        if (this.keepTrackOfChunksToBuild) {
+            for (const [key, position] of this.tasks.trackedChunks) {
+                queue.push(position);
+            }
+            this.tasks.trackedChunks.clear();
+        }
+        this.tasks.clearBuildQueue();
+        return queue;
+    }
+    update() {
+        if (!this._dt.setDimension(this.dimension).loadInAt(this.x, this.y, this.z) &&
+            this.requestsId != "")
+            return false;
+        const sl = this._dt.getLight();
+        if (LightData.hasRGBLight(sl)) {
+            this.tasks.queues.rgb.update.push(this.x, this.y, this.z);
+            Propagation.instance.rgbUpdate(this.tasks);
+        }
+        if (LightData.hasSunLight(sl)) {
+            this.tasks.queues.sun.update.push(this.x, this.y, this.z);
+            Propagation.instance.sunUpdate(this.tasks);
+        }
+        if (this.keepTrackOfChunksToBuild) {
+            this.tasks.addNeighborsToRebuildQueue(this.x, this.y, this.z);
+        }
+    }
+    erase() {
+        if (!this._dt.setDimension(this.dimension).loadInAt(this.x, this.y, this.z) &&
+            this.requestsId != "")
+            return this;
+        const sl = this._dt.getLight();
+        this._worldPainter.dimenion = this.dimension;
+        this._worldPainter.eraseVoxel(this.x, this.y, this.z);
+        this._dt
+            .setAir()
+            .setLight(sl > 0 ? sl : 0)
+            .commit();
+        if (LightData.hasRGBLight(sl)) {
+            this.tasks.queues.rgb.remove.push(this.x, this.y, this.z);
+            Propagation.instance.rgbRemove(this.tasks);
+        }
+        if (LightData.hasSunLight(sl)) {
+            this.tasks.queues.sun.remove.push(this.x, this.y, this.z);
+            Propagation.instance.sunRemove(this.tasks);
+        }
+        if (this.keepTrackOfChunksToBuild) {
+            this.tasks.addNeighborsToRebuildQueue(this.x, this.y, this.z);
+        }
+        return this;
+    }
+    runUpdates() {
+        Propagation.instance.rgbUpdate(this.tasks);
+        Propagation.instance.sunUpdate(this.tasks);
+        this.tasks.queues.rgb.map.clear();
+        this.tasks.queues.sun.updateMap.clear();
+    }
+    worldAlloc(start, end) {
+        return new SafePromise("worldAlloc", (resolve) => {
+            DivineVoxelEngineConstructor.instance.threads.world.runPromiseTasks("world-alloc", [this.dimension, start, end], [], () => {
+                resolve(true);
+            });
+        }).run();
+    }
+    worldDealloc(start, end) {
+        return new SafePromise("worldDealloc", (resolve) => {
+            DivineVoxelEngineConstructor.instance.threads.world.runPromiseTasks("world-dealloc", [this.dimension, start, end], [], () => {
+                resolve(true);
+            });
+        }).run();
+    }
+}

package/WorldGeneration/WorldGenRegister.d.ts

@@ -0,0 +1,14 @@
+import type { LocationData } from "../Math";
+import { RawVoxelData } from "../Data/Types/VoxelData.types";
+export declare class WorldGenRegister {
+    static MAX_ATTEMPTS: number;
+    static _requests: Map<string, {
+        attempts: number;
+        dimension: string;
+        chunks: Map<string, [x: number, y: number, z: number]>;
+        voxels: [x: number, y: number, z: number, data: RawVoxelData][];
+    }>;
+    static registerRequest(location: LocationData): string;
+    static addToRequest(registerId: string, location: LocationData, rawData: RawVoxelData): false | undefined;
+    static attemptRequestFullFill(registerId: string): boolean;
+}

package/WorldGeneration/WorldGenRegister.js

@@ -0,0 +1,94 @@
+import { WorldSpaces } from "../Data/World/WorldSpaces.js";
+import { BrushTool } from "../Tools/Brush/Brush";
+import { ChunkDataTool } from "../Tools/Data/WorldData/ChunkDataTool";
+import { WorldBounds } from "../Data/World/WorldBounds";
+import { DivineVoxelEngineConstructor } from "Contexts/Constructor";
+const brush = new BrushTool();
+const dataTool = brush._dt;
+const chunkTool = new ChunkDataTool();
+export class WorldGenRegister {
+    static MAX_ATTEMPTS = 100;
+    static _requests = new Map();
+    static registerRequest(location) {
+        const id = location.toString();
+        this._requests.set(id, {
+            attempts: 0,
+            chunks: new Map(),
+            dimension: location[0],
+            voxels: [],
+        });
+        return id;
+    }
+    static addToRequest(registerId, location, rawData) {
+        if (location[2] < WorldBounds.bounds.MinY ||
+            location[2] >= WorldBounds.bounds.MaxY)
+            return false;
+        const requests = this._requests.get(registerId);
+        if (!requests)
+            return;
+        const chunkPOS = WorldSpaces.chunk.getPositionXYZ(location[1], location[2], location[3]);
+        const chunkKey = WorldSpaces.chunk.getKeyXYZ(location[1], location[2], location[3]);
+        if (!chunkTool.loadInAtLocation(location)) {
+            if (!requests.chunks.has(chunkKey)) {
+                DivineVoxelEngineConstructor.instance.threads.world.runTasks("add-chunk", [
+                    requests.dimension,
+                    chunkPOS.x,
+                    chunkPOS.y,
+                    chunkPOS.z,
+                ]);
+                requests.chunks.set(chunkKey, [chunkPOS.x, chunkPOS.y, chunkPOS.z]);
+            }
+        }
+        const [dim, x, y, z] = location;
+        requests.voxels.push([x, y, z, rawData]);
+    }
+    static attemptRequestFullFill(registerId) {
+        const requests = this._requests.get(registerId);
+        if (!requests || !requests.voxels.length)
+            return true;
+        chunkTool.setDimension(requests.dimension);
+        let done = true;
+        for (const [key, pos] of requests.chunks) {
+            if (pos[0] < WorldBounds.bounds.MinX ||
+                pos[0] > WorldBounds.bounds.MaxX ||
+                pos[1] < WorldBounds.bounds.MinY ||
+                pos[1] > WorldBounds.bounds.MaxY ||
+                pos[2] < WorldBounds.bounds.MinZ ||
+                pos[2] > WorldBounds.bounds.MaxZ) {
+                continue;
+            }
+            if (!chunkTool.loadInAt(pos[0], pos[1], pos[2])) {
+                done = false;
+                DivineVoxelEngineConstructor.instance.threads.world.runTasks("add-chunk", [
+                    requests.dimension,
+                    pos[0],
+                    pos[1],
+                    pos[2],
+                ]);
+            }
+        }
+        if (!done) {
+            requests.attempts++;
+            if (requests.attempts >= this.MAX_ATTEMPTS) {
+                console.error(`World gen requests cancled after max attempts`, requests);
+                this._requests.delete(registerId);
+                return true;
+            }
+            return false;
+        }
+        brush.setDimension(requests.dimension);
+        dataTool.setDimension(requests.dimension);
+        const voxels = requests.voxels;
+        brush.start();
+        while (voxels.length) {
+            const data = voxels.shift();
+            if (!data)
+                break;
+            dataTool.loadInAt(data[0], data[1], data[2]);
+            brush.setXYZ(data[0], data[1], data[2]).setRaw(data[3]).paint();
+        }
+        brush.stop();
+        this._requests.delete(registerId);
+        return true;
+    }
+}

package/WorldGeneration/WorldGeneration.d.ts

@@ -0,0 +1,14 @@
+import { WorldBounds } from "../Data/World/WorldBounds.js";
+import { WorldGenRegister } from "./WorldGenRegister.js";
+import { WorldGenBrush } from "./WorldGenBrush.js";
+import { WorldGenInterface } from "../Interfaces/WorldGen/WorldGen.types.js";
+import { GenerateTasks } from "../Types/Tasks.types.js";
+export declare class WorldGeneration {
+    static worldGen: WorldGenInterface | null;
+    static register: typeof WorldGenRegister;
+    static worldBounds: typeof WorldBounds;
+    static _brushes: any[];
+    static setWorldGen(worldGen: WorldGenInterface): void;
+    static generate(data: GenerateTasks, mode: "generate" | "decorate", onDone: Function): Promise<void>;
+    static getBrush(): WorldGenBrush;
+}