@divinevoxel/vlox 0.0.80 → 0.0.81

package/Mesher/Voxels/Models/VoxelConstructor.js

@@ -1,78 +0,0 @@
-import { VoxelModelConstructorRegister } from "./VoxelModelConstructorRegister";
-import { VoxelLUT } from "../../../Voxels/Data/VoxelLUT";
-import { GeometryLUT } from "../../../Voxels/Data/GeometryLUT";
-export class VoxelConstructor {
-    id;
-    builder;
-    isModel = true;
-    // effects: VoxelModelEffect;
-    constructor(id, builder) {
-        this.id = id;
-        this.builder = builder;
-        //  this.effects = new VoxelModelEffect(this);
-    }
-    process() {
-        let added = false;
-        const builder = this.builder;
-        const hashed = builder.space.getHash(builder.nVoxel, builder.position.x, builder.position.y, builder.position.z);
-        const trueVoxelId = builder.voxel.getVoxelId();
-        const voxelId = builder.space.voxelCache[hashed];
-        const reltionalVoxelId = builder.space.reltionalVoxelCache[hashed];
-        const geomtriesIndex = VoxelLUT.getGeometryIndex(voxelId, reltionalVoxelId);
-        const geomtries = GeometryLUT.geometryIndex[geomtriesIndex];
-        const inputsIndex = VoxelLUT.getGeometryInputIndex(voxelId, reltionalVoxelId);
-        const inputs = GeometryLUT.geometryInputsIndex[inputsIndex];
-        const geometriesLength = geomtries.length;
-        for (let i = 0; i < geometriesLength; i++) {
-            const nodeId = geomtries[i];
-            const inputsIndex = inputs[i];
-            const geoInputs = GeometryLUT.geometryInputs[inputsIndex];
-            const geometry = VoxelModelConstructorRegister.geometry[nodeId];
-            const nodesLength = geometry.nodes.length;
-            for (let k = 0; k < nodesLength; k++) {
-                const geo = geometry.nodes[k];
-                geo.builder = this.builder;
-                const addedGeo = geo.add(geoInputs[k]);
-                if (addedGeo)
-                    added = true;
-            }
-        }
-        const conditioanlNodes = VoxelLUT.getConditionalGeometryNodes(trueVoxelId);
-        if (conditioanlNodes) {
-            const modelState = VoxelLUT.voxelIdToModelState[voxelId];
-            const reltionalState = builder.space.reltionalStateCache[hashed];
-            const nodesLength = conditioanlNodes.length;
-            for (let i = 0; i < nodesLength; i++) {
-                const [geoId, requiredModelState, requiredModelReltionalState] = conditioanlNodes[i];
-                if (requiredModelState !== modelState ||
-                    !requiredModelReltionalState[reltionalState])
-                    continue;
-                const geomtries = GeometryLUT.geometryIndex[geoId];
-                const inputsIndex = VoxelLUT.getConditionalGeometryInputIndex(geoId, voxelId, reltionalVoxelId);
-                const inputs = GeometryLUT.geometryInputsIndex[inputsIndex];
-                const geometriesLength = geomtries.length;
-                for (let i = 0; i < geometriesLength; i++) {
-                    const nodeId = geomtries[i];
-                    const inputsIndex = inputs[i];
-                    const geoInputs = GeometryLUT.geometryInputs[inputsIndex];
-                    const geometry = VoxelModelConstructorRegister.geometry[nodeId];
-                    const nodesLength = geometry.nodes.length;
-                    for (let k = 0; k < nodesLength; k++) {
-                        const geo = geometry.nodes[k];
-                        geo.builder = this.builder;
-                        const addedGeo = geo.add(geoInputs[k]);
-                        if (addedGeo)
-                            added = true;
-                    }
-                }
-            }
-        }
-        /*     this.effects.addEffects(
-          builder.voxel.getState(),
-          builder.origin,
-          builder.effects
-        ); */
-        builder.clearCalculatedData();
-        return added;
-    }
-}

package/Mesher/Voxels/Models/VoxelModelConstructorRegister.js

@@ -1,37 +0,0 @@
-import { VoxelGeometryConstructor } from "./Nodes/VoxelGeometryConstructor";
-import { VoxelLUT } from "../../../Voxels/Data/VoxelLUT";
-import { GeometryLUT } from "../../../Voxels/Data/GeometryLUT";
-export class VoxelModelConstructorRegister {
-    static geometry = [];
-    static customNodes = new Map();
-    static registerCustomNode(id, node) {
-        this.customNodes.set(id, node);
-    }
-    static getCustomNode(id) {
-        const node = this.customNodes.get(id);
-        if (!node)
-            throw new Error(`Custom geometry node [${id}] does not exist.`);
-        return node;
-    }
-    static constructorsPaltte = [];
-    static constructors = new Map();
-    static getConstructor(id) {
-        return this.constructors.get(id);
-    }
-    static registerVoxel(voxel) {
-        if (Array.isArray(voxel)) {
-            for (const vox of voxel) {
-                this.constructors.set(vox.id, vox);
-                this.constructorsPaltte[VoxelLUT.voxelIds.getNumberId(vox.id)] = vox;
-            }
-            return;
-        }
-        this.constructorsPaltte[VoxelLUT.voxelIds.getNumberId(voxel.id)] = voxel;
-        this.constructors.set(voxel.id, voxel);
-    }
-    static init() {
-        for (let i = 0; i < GeometryLUT.compiledGeometry.length; i++) {
-            this.geometry[i] = new VoxelGeometryConstructor(i);
-        }
-    }
-}

package/WorldSimulation/Procedures/BuildOnly.d.ts

@@ -1,10 +0,0 @@
-import { GeneratorData } from "../Dimensions/Generator";
-/**# InitalLoad
- * ---
- * Load the world without building.
- */
-export declare function BuildOnly(props: {
-    dimension?: number;
-    logTasks?: true;
-    genData: Partial<GeneratorData>;
-}): Promise<unknown>;

package/WorldSimulation/Procedures/BuildOnly.js

@@ -1,55 +0,0 @@
-import { WorldSimulation } from "../WorldSimulation";
-import { WorldSimulationDimensions } from "../Internal/WorldSimulationDimensions";
-import { WorldSimulationTools } from "../Internal/WorldSimulationTools";
-import SaveAllSectors from "./SaveAllSectors";
-/**# InitalLoad
- * ---
- * Load the world without building.
- */
-export async function BuildOnly(props) {
-    return new Promise((resolve) => {
-        const generator = WorldSimulation.createGenerator({
-            ...props.genData,
-            building: false,
-            culling: false,
-        });
-        if (!WorldSimulationDimensions._dimensions.has(generator._dimension)) {
-            WorldSimulationDimensions.addDimension(generator._dimension);
-        }
-        const dimension = WorldSimulationDimensions.getDimension(props.dimension || 0);
-        let done = false;
-        generator._building = false;
-        WorldSimulation.addGenerator(generator);
-        let timeOut = null;
-        const update = () => {
-            if (done)
-                return;
-            WorldSimulation.tick(true);
-            timeOut = setTimeout(update, 0);
-        };
-        update();
-        const inte = setInterval(() => {
-            let allDone = true;
-            for (const [key, task] of dimension.tasks) {
-                if (!task.generationTask)
-                    continue;
-                if (task.waitingFor > 0 || task._task.size > 0) {
-                    allDone = false;
-                    break;
-                }
-            }
-            if (!allDone)
-                return;
-            done = true;
-            clearInterval(inte);
-            clearTimeout(timeOut);
-            WorldSimulation.removeGenerator(generator);
-            (async () => {
-                if (WorldSimulationTools.worldStorage) {
-                    await SaveAllSectors();
-                }
-                resolve(true);
-            })();
-        }, 250);
-    });
-}