@divinevoxel/vlox 0.0.0

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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,10 @@
+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.d.ts

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

package/Mesher/Rules/RenderedSubstances.js

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,60 @@
+//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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,9 @@
+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

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

package/Mesher/Shapes/VoxelShapeBase.js

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

package/Mesher/Shapes/VoxelShapeManager.d.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,15 @@
+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 {};

package/Mesher/Shapes/default/Cube/Cube.voxel.shape.js

@@ -0,0 +1,234 @@
+import { OverrideManager } from "../../../Rules/Overrides/OverridesManager.js";
+import { ShapeTool } from "../../ShapeTool.js";
+import { QuadScalarVertexData } from "@amodx/meshing/Classes/QuadVertexData";
+import { VoxelFaceOpositeDirectionMap, VoxelFaces, } from "../../../../Math/index.js";
+import { VoxelShapeBase } from "../../VoxelShapeBase.js";
+import { VoxelShapeManager } from "../../VoxelShapeManager.js";
+import { Quad } from "@amodx/meshing/Classes/Quad.js";
+import { StairOverrides } from "../Stairs/StairOverrides.js";
+import { VoxelShaderData } from "../../../../Data/VoxelShaderData.js";
+import { VoxelGeometry } from "../../../Geometry/VoxelGeometry.js";
+import { HalfCubeStates } from "./HalfCube.voxel.shape.js";
+const animationState = new QuadScalarVertexData();
+const uvs = [
+    [1, 1],
+    [0, 1],
+    [0, 0],
+    [1, 0],
+];
+const Quads = {
+    up: Quad.Create([
+        [0, 1, 0],
+        [1, 1, 1],
+    ], uvs, false, 0),
+    down: Quad.Create([
+        [0, 0, 0],
+        [1, 0, 1],
+    ], uvs, false, 1),
+    north: Quad.Create([
+        [0, 0, 1],
+        [1, 1, 1],
+    ], uvs, false, 1),
+    south: Quad.Create([
+        [0, 0, 0],
+        [1, 1, 0],
+    ], uvs, false, 0),
+    east: Quad.Create([
+        [1, 0, 0],
+        [1, 1, 1],
+    ], uvs, false, 0),
+    west: Quad.Create([
+        [0, 0, 0],
+        [0, 1, 1],
+    ], uvs, false, 1),
+};
+class CubeVoxelShapeClass extends VoxelShapeBase {
+    id = "#dve_cube";
+    init() {
+        //cullface
+        OverrideManager.FaceExposedShapeCheck.register(this.numberId, this.numberId, (data) => {
+            return CubeCullFunctions[data.face](data);
+        });
+        OverrideManager.FaceExposedShapeCheck.register(this.numberId, VoxelShapeManager.getMappedId("#dve_flat_panel"), (data) => {
+            return true;
+        });
+        OverrideManager.DarkenFaceUnderneath.register(this.numberId, OverrideManager.ANY, (data) => {
+            return true;
+        });
+        OverrideManager.FaceExposedShapeCheck.register(this.numberId, VoxelShapeManager.getMappedId("#dve_half_cube"), (data) => {
+            if (data.neighborVoxel.getShapeState() == HalfCubeStates.Up) {
+                if (data.face == VoxelFaces.Up) {
+                    return true;
+                }
+                if (data.face == VoxelFaces.Down) {
+                    return false;
+                }
+                return true;
+            }
+            if (data.neighborVoxel.getShapeState() == HalfCubeStates.Down) {
+                if (data.face == VoxelFaces.Up) {
+                    return false;
+                }
+                if (data.face == VoxelFaces.Down) {
+                    return true;
+                }
+                return true;
+            }
+            return true;
+        });
+        OverrideManager.AO.register(this.numberId, VoxelShapeManager.getMappedId("#dve_half_cube"), (data) => {
+            if (data.neighborVoxel.getShapeState() == HalfCubeStates.Up) {
+                if (data.face == VoxelFaces.Up) {
+                    return false;
+                }
+                if (data.face == VoxelFaces.Down) {
+                    return true;
+                }
+                return true;
+            }
+            if (data.neighborVoxel.getShapeState() == HalfCubeStates.Down) {
+                if (data.face == VoxelFaces.Up) {
+                    return true;
+                }
+                if (data.face == VoxelFaces.Down) {
+                    return false;
+                }
+                if (data.currentVoxel.y == data.neighborVoxel.y) {
+                    return true;
+                }
+                return false;
+            }
+            return true;
+        });
+        OverrideManager.FaceExposedShapeCheck.register(this.numberId, VoxelShapeManager.getMappedId("#dve_stair"), (data) => {
+            const faceType = StairOverrides.getStairState(data.neighborVoxel.getShapeState())[VoxelFaceOpositeDirectionMap[data.face]];
+            if (faceType == StairOverrides.FaceTypes.Box)
+                return false;
+            return true;
+        });
+        //ao
+        OverrideManager.AO.register(this.numberId, VoxelShapeManager.getMappedId("#dve_flat_panel"), (data) => {
+            return false;
+        });
+    }
+    add = {
+        up() {
+            Quads.up.flip = ShapeTool.data.isFaceFlipped();
+            if (ShapeTool.data.voxel.getSubstnaceData().isWindAffected()) {
+                ShapeTool.data
+                    .getAnimationData()
+                    .setAll(VoxelShaderData.AnimationStates.WindAffected.Box);
+            }
+            VoxelGeometry.addQuad(ShapeTool.data, ShapeTool.origin, Quads.up);
+        },
+        down() {
+            Quads.down.flip = ShapeTool.data.isFaceFlipped();
+            if (ShapeTool.data.voxel.getSubstnaceData().isWindAffected()) {
+                ShapeTool.data
+                    .getAnimationData()
+                    .setAll(VoxelShaderData.AnimationStates.WindAffected.Box);
+            }
+            VoxelGeometry.addQuad(ShapeTool.data, ShapeTool.origin, Quads.down);
+        },
+        north() {
+            Quads.north.flip = ShapeTool.data.isFaceFlipped();
+            if (ShapeTool.data.voxel.getSubstnaceData().isWindAffected()) {
+                ShapeTool.data
+                    .getAnimationData()
+                    .setAll(VoxelShaderData.AnimationStates.WindAffected.Box);
+            }
+            VoxelGeometry.addQuad(ShapeTool.data, ShapeTool.origin, Quads.north);
+        },
+        south() {
+            Quads.south.flip = ShapeTool.data.isFaceFlipped();
+            if (ShapeTool.data.voxel.getSubstnaceData().isWindAffected()) {
+                ShapeTool.data
+                    .getAnimationData()
+                    .setAll(VoxelShaderData.AnimationStates.WindAffected.Box);
+            }
+            VoxelGeometry.addQuad(ShapeTool.data, ShapeTool.origin, Quads.south);
+        },
+        east() {
+            Quads.east.flip = ShapeTool.data.isFaceFlipped();
+            if (ShapeTool.data.voxel.getSubstnaceData().isWindAffected()) {
+                ShapeTool.data
+                    .getAnimationData()
+                    .setAll(VoxelShaderData.AnimationStates.WindAffected.Box);
+            }
+            VoxelGeometry.addQuad(ShapeTool.data, ShapeTool.origin, Quads.east);
+        },
+        west() {
+            Quads.west.flip = ShapeTool.data.isFaceFlipped();
+            if (ShapeTool.data.voxel.getSubstnaceData().isWindAffected()) {
+                ShapeTool.data
+                    .getAnimationData()
+                    .setAll(VoxelShaderData.AnimationStates.WindAffected.Box);
+            }
+            VoxelGeometry.addQuad(ShapeTool.data, ShapeTool.origin, Quads.west);
+        },
+    };
+}
+export const CubeVoxelShape = new CubeVoxelShapeClass();
+//cull leaf faces
+const CubeCullFunctions = {
+    [VoxelFaces.Up]: (data) => {
+        if (data.currentVoxel.getSubstnaceData().cullDense() &&
+            data.neighborVoxel.loadInAt(data.currentVoxel.x, data.currentVoxel.y + 1, data.currentVoxel.z) &&
+            data.currentVoxel.isSameVoxel(data.neighborVoxel) &&
+            data.neighborVoxel.loadInAt(data.currentVoxel.x, data.currentVoxel.y + 2, data.currentVoxel.z) &&
+            data.currentVoxel.isSameVoxel(data.neighborVoxel)) {
+            return false;
+        }
+        return data.default;
+    },
+    [VoxelFaces.Down]: (data) => {
+        if (data.currentVoxel.getSubstnaceData().cullDense() &&
+            data.neighborVoxel.loadInAt(data.currentVoxel.x, data.currentVoxel.y - 1, data.currentVoxel.z) &&
+            data.currentVoxel.isSameVoxel(data.neighborVoxel) &&
+            data.neighborVoxel.loadInAt(data.currentVoxel.x, data.currentVoxel.y - 2, data.currentVoxel.z) &&
+            data.currentVoxel.isSameVoxel(data.neighborVoxel)) {
+            return false;
+        }
+        return data.default;
+    },
+    [VoxelFaces.East]: (data) => {
+        if (data.currentVoxel.getSubstnaceData().cullDense() &&
+            data.neighborVoxel.loadInAt(data.currentVoxel.x + 1, data.currentVoxel.y, data.currentVoxel.z) &&
+            data.currentVoxel.isSameVoxel(data.neighborVoxel) &&
+            data.neighborVoxel.loadInAt(data.currentVoxel.x + 2, data.currentVoxel.y, data.currentVoxel.z) &&
+            data.currentVoxel.isSameVoxel(data.neighborVoxel)) {
+            return false;
+        }
+        return data.default;
+    },
+    [VoxelFaces.West]: (data) => {
+        if (data.currentVoxel.getSubstnaceData().cullDense() &&
+            data.neighborVoxel.loadInAt(data.currentVoxel.x - 1, data.currentVoxel.y, data.currentVoxel.z) &&
+            data.currentVoxel.isSameVoxel(data.neighborVoxel) &&
+            data.neighborVoxel.loadInAt(data.currentVoxel.x - 2, data.currentVoxel.y, data.currentVoxel.z) &&
+            data.currentVoxel.isSameVoxel(data.neighborVoxel)) {
+            return false;
+        }
+        return data.default;
+    },
+    [VoxelFaces.North]: (data) => {
+        if (data.currentVoxel.getSubstnaceData().cullDense() &&
+            data.neighborVoxel.loadInAt(data.currentVoxel.x, data.currentVoxel.y, data.currentVoxel.z + 1) &&
+            data.currentVoxel.isSameVoxel(data.neighborVoxel) &&
+            data.neighborVoxel.loadInAt(data.currentVoxel.x, data.currentVoxel.y, data.currentVoxel.z + 2) &&
+            data.currentVoxel.isSameVoxel(data.neighborVoxel)) {
+            return false;
+        }
+        return data.default;
+    },
+    [VoxelFaces.South]: (data) => {
+        if (data.currentVoxel.getSubstnaceData().cullDense() &&
+            data.neighborVoxel.loadInAt(data.currentVoxel.x, data.currentVoxel.y, data.currentVoxel.z - 1) &&
+            data.currentVoxel.isSameVoxel(data.neighborVoxel) &&
+            data.neighborVoxel.loadInAt(data.currentVoxel.x, data.currentVoxel.y, data.currentVoxel.z - 2) &&
+            data.currentVoxel.isSameVoxel(data.neighborVoxel)) {
+            return false;
+        }
+        return data.default;
+    },
+};

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

@@ -0,0 +1,24 @@
+import { VoxelShapeBase } from "../../VoxelShapeBase.js";
+export declare enum HalfCubeStates {
+    Down = 0,
+    Up = 1,
+    North = 2,
+    Sourth = 3,
+    East = 4,
+    West = 5
+}
+declare class HalfCubeVoxelShapeClass extends VoxelShapeBase {
+    id: string;
+    init(): void;
+    start(): void;
+    add: {
+        up(): void;
+        down(): void;
+        north(): void;
+        south(): void;
+        east(): void;
+        west(): void;
+    };
+}
+export declare const HalfCubeVoxelShape: HalfCubeVoxelShapeClass;
+export {};