@divinevoxel/vlox 0.0.2 → 0.0.4

package/Mesher/Constructors/Voxel/VoxelConstructorsRegister.js

@@ -1,75 +0,0 @@
-//utils
-//constructors
-import { SimpleCubeVoxelConstructor } from "./Classes/Cube/SimpleCube.constructor.js";
-import { PillarCubeVoxelConstructor, } from "./Classes/Cube/PillarCube.constructor.js";
-import { SimpleLiquidConstructor } from "./Classes/Liquid/SimpleLiquid.constructor.js";
-import { SimplePanelVoxelConstructor } from "./Classes/Panel/SimplePanel.constructor.js";
-import { SimpleStairVoxelConstructor } from "./Classes/Stair/SimpleStair.constructor.js";
-import { SimpleCrossedPanelVoxelConstructor } from "./Classes/Panel/SimpleCrossedPanel.constructor.js";
-import { ModCubeVoxelConstructor } from "./Classes/Cube/ModCube.constructor";
-import { SimpleHalfCubeVoxelConstructor } from "./Classes/HalfCube/SimpleHalfCube.constructor";
-import { ModHalfCubeVoxelConstructor } from "./Classes/HalfCube/ModHalfCube.constructor";
-import { ModStairVoxelConstructor } from "./Classes/Stair/ModStair.constructor";
-import { VoxelPalette } from "../../../Data/Voxel/VoxelPalette";
-export class VoxelConstructorsRegister {
-    static constructorsPaltte = [];
-    static constructors = new Map();
-    static get(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[VoxelPalette.ids.getNumberId(vox.id)] = vox;
-            }
-            return;
-        }
-        this.constructorsPaltte[VoxelPalette.ids.getNumberId(voxel.id)] = voxel;
-        this.constructors.set(voxel.id, voxel);
-    }
-    static defaults = {
-        cube: {
-            mod(id, textures) {
-                return new ModCubeVoxelConstructor(id, textures);
-            },
-            simple(id, textures) {
-                return new SimpleCubeVoxelConstructor(id, textures);
-            },
-            pillar(id, textures) {
-                return new PillarCubeVoxelConstructor(id, textures);
-            },
-        },
-        halfCube: {
-            mod(id, textures) {
-                return new ModHalfCubeVoxelConstructor(id, textures);
-            },
-            simple(id, textures) {
-                return new SimpleHalfCubeVoxelConstructor(id, textures);
-            },
-        },
-        stair: {
-            mod(id, textures) {
-                return new ModStairVoxelConstructor(id, textures);
-            },
-            simple(id, texture) {
-                return new SimpleStairVoxelConstructor(id, texture);
-            },
-        },
-        panel: {
-            simple(id, texture) {
-                return new SimplePanelVoxelConstructor(id, texture);
-            },
-        },
-        crossedPanel: {
-            simple(id, texture) {
-                return new SimpleCrossedPanelVoxelConstructor(id, texture);
-            },
-        },
-        liquid: {
-            simple(id, textures) {
-                return new SimpleLiquidConstructor(id, textures);
-            },
-        },
-    };
-}

package/Mesher/Meshers/Classes/Mesher.d.ts

@@ -1,6 +0,0 @@
-import { BuildNodeMesh, SetNodeMesh } from "../../Tasks/BuidlerTasks.types";
-export declare abstract class Mesher {
-    id: string;
-    constructor(id: string);
-    abstract build(data: BuildNodeMesh): [SetNodeMesh, ArrayBuffer[]] | false;
-}

package/Mesher/Meshers/Classes/Mesher.js

@@ -1,6 +0,0 @@
-export class Mesher {
-    id;
-    constructor(id) {
-        this.id = id;
-    }
-}

package/Mesher/Meshers/Meshers/VoxelMesher.d.ts

@@ -1,11 +0,0 @@
-import { Mesher } from "../Classes/Mesher.js";
-import { BuilderDataTool } from "../../Tools/BuilderDataTool.js";
-import { BuildNodeMesh, SetNodeMesh } from "../../Tasks/BuidlerTasks.types.js";
-declare class VoxelBuilderBase extends Mesher {
-    id: string;
-    dataTool: BuilderDataTool;
-    constructor(id: string);
-    build([location, type, rawVoxelData]: BuildNodeMesh): [SetNodeMesh, ArrayBuffer[]] | false;
-}
-export declare const VoxelBuilder: VoxelBuilderBase;
-export {};

package/Mesher/Meshers/Meshers/VoxelMesher.js

@@ -1,47 +0,0 @@
-import { Mesher } from "../Classes/Mesher.js";
-import { BuilderDataTool } from "../../Tools/BuilderDataTool.js";
-import { RenderedSubstances } from "../../Rules/RenderedSubstances.js";
-import { ShapeTool } from "../../Shapes/ShapeTool.js";
-class VoxelBuilderBase extends Mesher {
-    id;
-    dataTool = new BuilderDataTool();
-    constructor(id) {
-        super(id);
-        this.id = id;
-        this.dataTool.setMode(BuilderDataTool.Modes.VOXEL_DATA);
-    }
-    build([location, type, rawVoxelData]) {
-        if (!this.dataTool.loadInRaw(rawVoxelData).isRenderable())
-            return false;
-        const constructor = this.dataTool.getConstructor();
-        const mesher = RenderedSubstances.meshers.get(this.dataTool.getSubstnaceData().getRendered());
-        if (!mesher || !constructor)
-            return false;
-        ShapeTool.origin.x = 0;
-        ShapeTool.origin.y = 0;
-        ShapeTool.origin.z = 0;
-        mesher.resetAll();
-        mesher.voxel
-            .loadInRaw(rawVoxelData)
-            .setMode(BuilderDataTool.Modes.VOXEL_DATA);
-        mesher.nVoxel
-            .loadInRaw(rawVoxelData)
-            .setMode(BuilderDataTool.Modes.VOXEL_DATA);
-        ShapeTool.setMesher(mesher);
-        constructor.process(mesher);
-        mesher.resetVars();
-        const [attributes, buffers] = mesher.getAllAttributes();
-        for (const [type, data] of attributes) {
-            if (type == "position") {
-                for (let i = 0; i < data.length; i++) {
-                    data[i] -= 0.5;
-                }
-            }
-        }
-        mesher.voxel.setMode(BuilderDataTool.Modes.WORLD);
-        mesher.nVoxel.setMode(BuilderDataTool.Modes.WORLD);
-        mesher.resetAttributes();
-        return [[location, attributes], buffers];
-    }
-}
-export const VoxelBuilder = new VoxelBuilderBase("#dve_node_voxel");

package/Mesher/Processors/TemplateProcessor.d.ts

@@ -1,16 +0,0 @@
-import type { LocationData } from ".../../Math/index.js";
-import { Flat3DIndex } from "@amodx/math/Volumes/Indexing/Flat3DIndex.js";
-import { Vec3Array } from "@amodx/math";
-export declare const TemplateProcessor: {
-    relative: {
-        x: number;
-        y: number;
-        z: number;
-    };
-    nLocation: LocationData;
-    _states: {
-        foundVoxel: boolean;
-    };
-    _process(index: number, template: Uint32Array): void;
-    build(location: LocationData, template: Uint32Array, startIndex: Vec3Array, templateIndex: Flat3DIndex): void;
-};

package/Mesher/Processors/TemplateProcessor.js

@@ -1,71 +0,0 @@
-//objects
-import { RenderedSubstances } from "../Rules/RenderedSubstances.js";
-import { DivineVoxelEngineConstructor } from "../../Contexts/Constructor/DivineVoxelEngineConstructor.js";
-//tools
-import { BuilderDataTool } from "../Tools/BuilderDataTool.js";
-import { ShapeTool } from "../Shapes/ShapeTool.js";
-const mDataTool = new BuilderDataTool();
-export const TemplateProcessor = {
-    relative: { x: 0, y: 0, z: 0 },
-    nLocation: ["main", 0, 0, 0],
-    _states: {
-        foundVoxel: false,
-    },
-    _process(index, template) {
-        const mainId = template[index] & 0xffff;
-        if (!mainId || !mDataTool.loadInAtLocation(this.nLocation))
-            return;
-        const constructor = mDataTool.getConstructor();
-        const mesher = RenderedSubstances.meshers.get(mDataTool.getSubstnaceData().getRendered());
-        if (!mesher || !constructor)
-            return;
-        mesher.template.setActive(true);
-        mesher.template.load(template, index);
-        mesher.voxel.loadInAtLocation(this.nLocation);
-        mesher.nVoxel.loadInAtLocation(this.nLocation);
-        ShapeTool.setMesher(mesher);
-        constructor.process(mesher);
-        mesher.resetVars();
-        mesher.template.setActive(false);
-    },
-    build(location, template, startIndex, templateIndex) {
-        mDataTool.setDimension(location[0]);
-        const [dimension, cx, cy, cz] = location;
-        this.nLocation[0] = dimension;
-        let [six, siy, siz] = startIndex;
-        let ix = six, iy = siy, iz = siz;
-        const curosr = new Int32Array(3);
-        for (let x = cx; x < cx + 16; x++) {
-            iz = siz;
-            for (let z = cz; z < cz + 16; z++) {
-                iy = siy;
-                for (let y = cy; y < cy + 16; y++) {
-                    this.nLocation[1] = x;
-                    this.nLocation[2] = y;
-                    this.nLocation[3] = z;
-                    curosr[0] = ix;
-                    curosr[1] = iy;
-                    curosr[2] = iz;
-                    //   this._process(templateIndex.getIndex(curosr) * 17, template);
-                    iy++;
-                }
-                iz++;
-            }
-            ix++;
-        }
-        const chunks = [location, [], 0];
-        const trasnfers = [];
-        for (const [substance, mesher] of RenderedSubstances.meshers) {
-            if (mesher.getAttribute("position").length == 0) {
-                chunks[1].push([substance, false]);
-                mesher.resetAll();
-                continue;
-            }
-            const [attributes, buffers] = mesher.getAllAttributes();
-            trasnfers.push(...buffers);
-            chunks[1].push([substance, [location, attributes]]);
-            mesher.resetAll();
-        }
-        DivineVoxelEngineConstructor.instance.threads.parent.runTasks("set-chunk", chunks, trasnfers);
-    },
-};

package/Mesher/Rules/Overrides/OverrideBase.d.ts

@@ -1,8 +0,0 @@
-import { FaceDataOverride } from "../../Types";
-type Run = (data: FaceDataOverride) => boolean;
-export declare class OverrideBase {
-    voxels: Run[][];
-    register(voxel: number, override: number, run: Run): void;
-    run(voxel: number, override: number, data: FaceDataOverride): boolean;
-}
-export {};

package/Mesher/Rules/Overrides/OverrideBase.js

@@ -1,20 +0,0 @@
-export class OverrideBase {
-    voxels = [];
-    register(voxel, override, run) {
-        let voxelRules = this.voxels[voxel];
-        if (!voxelRules) {
-            voxelRules = [];
-            this.voxels[voxel] = voxelRules;
-        }
-        voxelRules[override] = run;
-    }
-    run(voxel, override, data) {
-        const voxelRules = this.voxels[voxel];
-        if (!voxelRules)
-            return data.default;
-        const secondRule = voxelRules[override];
-        if (!secondRule)
-            return data.default;
-        return secondRule(data);
-    }
-}

package/Mesher/Rules/Overrides/OverridesManager.d.ts

@@ -1,10 +0,0 @@
-import { OverrideBase } from "./OverrideBase";
-export declare class OverrideManager {
-    static ANY: number;
-    static AO: OverrideBase;
-    static AOFlipFace: OverrideBase;
-    static FaceExposedShapeCheck: OverrideBase;
-    static FaceExposedVoxelCheck: OverrideBase;
-    static FlipFace: OverrideBase;
-    static DarkenFaceUnderneath: OverrideBase;
-}

package/Mesher/Rules/Overrides/OverridesManager.js

@@ -1,10 +0,0 @@
-import { OverrideBase } from "./OverrideBase";
-export class OverrideManager {
-    static ANY = -1;
-    static AO = new OverrideBase();
-    static AOFlipFace = new OverrideBase();
-    static FaceExposedShapeCheck = new OverrideBase();
-    static FaceExposedVoxelCheck = new OverrideBase();
-    static FlipFace = new OverrideBase();
-    static DarkenFaceUnderneath = new OverrideBase();
-}

package/Mesher/Rules/RenderedSubstances.js

@@ -1,13 +0,0 @@
-import { VoxelMesherDataTool } from "../Tools/VoxelMesherDataTool.js";
-export class RenderedSubstances {
-    static meshers = new Map();
-    static add(id) {
-        this.meshers.set(id, new VoxelMesherDataTool());
-    }
-    static setDimension(dimension) {
-        for (const [key, mesher] of this.meshers) {
-            mesher.voxel.setDimension(dimension);
-            mesher.nVoxel.setDimension(dimension);
-        }
-    }
-}

package/Mesher/Rules/SubstanceRules.d.ts

@@ -1,7 +0,0 @@
-export declare class SubstanceRules {
-    static mappedRules: Map<number, Map<number, boolean>>;
-    static mappedParents: Map<number, number>;
-    static buildRules(): void;
-    static exposedCheck(subject: number, neightborVoxel: number): boolean;
-    static getSubstanceParent(id: number): number;
-}

package/Mesher/Rules/SubstanceRules.js

@@ -1,60 +0,0 @@
-//types
-import { RenderedSubstances } from "./RenderedSubstances.js";
-import { SubstanceDataTool } from "../../Tools/Data/SubstanceDataTool.js";
-import { SubstancePaletteReader } from "../../Data/Substance/SubstancePalette.js";
-export class SubstanceRules {
-    static mappedRules = new Map();
-    static mappedParents = new Map();
-    static buildRules() {
-        const rules = new Map();
-        const parents = new Map();
-        const substanceTool = new SubstanceDataTool();
-        const allSubstances = SubstancePaletteReader._palette;
-        for (const substnace of allSubstances) {
-            substanceTool.setSubstanceFromString(substnace);
-            const parent = substanceTool.getParent();
-            const rendered = substanceTool.getRendered();
-            const culled = substanceTool.getCulled();
-            if (!RenderedSubstances.meshers.has(rendered)) {
-                RenderedSubstances.add(rendered);
-            }
-            const map = new Map();
-            rules.set(substnace, map);
-            if (culled) {
-                for (const culls of culled) {
-                    map.set(culls, true);
-                }
-            }
-            if (parent) {
-                parents.set(substnace, parent);
-                continue;
-            }
-            parents.set(substnace, substnace);
-        }
-        for (const [substanceId, rule] of rules) {
-            const substanceNumberId = SubstancePaletteReader.id.numberFromString(substanceId);
-            const mappedRules = new Map();
-            this.mappedRules.set(substanceNumberId, mappedRules);
-            for (const [otherSubstanceId, culled] of rule) {
-                const otherNumberSubstanceId = SubstancePaletteReader.id.numberFromString(otherSubstanceId);
-                mappedRules.set(otherNumberSubstanceId, culled);
-            }
-        }
-        for (const [substanceId, parentSubstanceId] of parents) {
-            const substanceNumberId = SubstancePaletteReader.id.numberFromString(substanceId);
-            const parentSubstanceNumberId = SubstancePaletteReader.id.numberFromString(parentSubstanceId);
-            this.mappedParents.set(substanceNumberId, parentSubstanceNumberId);
-        }
-    }
-    static exposedCheck(subject, neightborVoxel) {
-        const rules = this.mappedRules.get(subject);
-        if (!rules)
-            return true;
-        if (rules.has(neightborVoxel))
-            return false;
-        return true;
-    }
-    static getSubstanceParent(id) {
-        return this.mappedParents.get(id);
-    }
-}

package/Mesher/Shapes/ShapeTool.d.ts

@@ -1,8 +0,0 @@
-import { Vector3Like } from "@amodx/math/Vectors/Vector3.js";
-import { VoxelMesherDataTool } from "../Tools/VoxelMesherDataTool.js";
-export declare class ShapeToolclass {
-    data: VoxelMesherDataTool;
-    origin: Vector3Like;
-    setMesher(dataTool: VoxelMesherDataTool): void;
-}
-export declare const ShapeTool: ShapeToolclass;

package/Mesher/Shapes/ShapeTool.js

@@ -1,9 +0,0 @@
-import { Vector3Like } from "@amodx/math/Vectors/Vector3.js";
-export class ShapeToolclass {
-    data;
-    origin = Vector3Like.Create();
-    setMesher(dataTool) {
-        this.data = dataTool;
-    }
-}
-export const ShapeTool = new ShapeToolclass();

package/Mesher/Shapes/VoxelShapeBase.d.ts

@@ -1,5 +0,0 @@
-export declare abstract class VoxelShapeBase {
-    abstract id: string;
-    numberId: number;
-    abstract init(): void;
-}

package/Mesher/Shapes/VoxelShapeBase.js

@@ -1,3 +0,0 @@
-export class VoxelShapeBase {
-    numberId = -Infinity;
-}

package/Mesher/Shapes/VoxelShapeManager.d.ts

@@ -1,10 +0,0 @@
-import { VoxelShapeBase } from "./VoxelShapeBase";
-export declare class VoxelShapeManager {
-    static shapes: Map<string, VoxelShapeBase>;
-    static mappedShapes: Map<number, VoxelShapeBase>;
-    static init(): void;
-    static registerShape(...shapes: VoxelShapeBase[]): void;
-    static getMappedShape(id: number): VoxelShapeBase;
-    static getMappedId(id: string): number;
-    static getShape(id: string): VoxelShapeBase;
-}

package/Mesher/Shapes/VoxelShapeManager.js

@@ -1,37 +0,0 @@
-import { MappedDataRegister } from "../../Data/Register/MappedDataRegister";
-import RegisterDefaultShapes from "./default/RegisterDefaultShapes";
-export class VoxelShapeManager {
-    static shapes = new Map();
-    static mappedShapes = new Map();
-    static init() {
-        RegisterDefaultShapes();
-    }
-    static registerShape(...shapes) {
-        shapes.forEach((_) => this.shapes.set(_.id, _));
-    }
-    static getMappedShape(id) {
-        return this.mappedShapes.get(id);
-    }
-    static getMappedId(id) {
-        return this.getShape(id).numberId;
-    }
-    static getShape(id) {
-        const shape = this.shapes.get(id);
-        if (!shape)
-            throw new Error(`Shape with id ${id} does not exist`);
-        return shape;
-    }
-}
-const shapeIdSegment = "#dve_shape_id";
-const segment = MappedDataRegister.stringMaps.addSegment("voxel");
-segment.onEntryAdded(shapeIdSegment, (entry) => {
-    VoxelShapeManager.init();
-    for (let i = 0; i < entry.length; i++) {
-        const shape = VoxelShapeManager.getShape(entry[i]);
-        shape.numberId = i;
-        VoxelShapeManager.mappedShapes.set(i, shape);
-    }
-    for (const [k, shape] of VoxelShapeManager.shapes) {
-        shape.init();
-    }
-});

package/Mesher/Shapes/default/Cube/Cube.voxel.shape.d.ts

@@ -1,15 +0,0 @@
-import { VoxelShapeBase } from "../../VoxelShapeBase.js";
-declare class CubeVoxelShapeClass extends VoxelShapeBase {
-    id: string;
-    init(): void;
-    add: {
-        up(): void;
-        down(): void;
-        north(): void;
-        south(): void;
-        east(): void;
-        west(): void;
-    };
-}
-export declare const CubeVoxelShape: CubeVoxelShapeClass;
-export {};