@divinevoxel/vlox 0.0.2 → 0.0.4

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

@@ -1,250 +0,0 @@
-//types
-import { OverrideManager } from "../../../Rules/Overrides/OverridesManager.js";
-import { ShapeTool } from "../../ShapeTool.js";
-import { QuadScalarVertexData } from "@amodx/meshing/Classes/QuadVertexData";
-import { CubeVoxelShape } from "../Cube/Cube.voxel.shape.js";
-import { VoxelFaces } from "../../../../Math/index.js";
-import { VoxelShapeBase } from "../../VoxelShapeBase.js";
-import { Quad } from "@amodx/meshing/Classes/Quad.js";
-import { QuadVerticies } from "@amodx/meshing/Geometry.types.js";
-import { VoxelGeometry } from "../../../Geometry/VoxelGeometry.js";
-import { CompassAngles } from "@amodx/math";
-let flowAnimationState = 0;
-const vertexValue = new QuadScalarVertexData();
-const vertexLevel = new QuadScalarVertexData();
-var FlowStates;
-(function (FlowStates) {
-    FlowStates[FlowStates["None"] = 0] = "None";
-    FlowStates[FlowStates["Down"] = 1] = "Down";
-    FlowStates[FlowStates["Up"] = 2] = "Up";
-})(FlowStates || (FlowStates = {}));
-const waterHeight = 6 / 7;
-const quadRotations = {
-    [CompassAngles.North]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.North),
-    [CompassAngles.South]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.South),
-    [CompassAngles.East]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.East),
-    [CompassAngles.West]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.West),
-    [CompassAngles.NorthWest]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.NorthWest),
-    [CompassAngles.NorthEast]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.NorthEast),
-    [CompassAngles.SouthWest]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.SouthWest),
-    [CompassAngles.SouthEast]: Quad.RotateUvs(Quad.FullUVs, CompassAngles.SouthEast),
-};
-const getFlowAngle = () => {
-    if (vertexLevel.isAllEqualTo(15)) {
-        flowAnimationState = FlowStates.None;
-        return 0;
-    }
-    const upRight = vertexLevel.vertices[QuadVerticies.TopRight];
-    const upLeft = vertexLevel.vertices[QuadVerticies.TopLeft];
-    const downLeft = vertexLevel.vertices[QuadVerticies.BottomLeft];
-    const downRight = vertexLevel.vertices[QuadVerticies.BottomRight];
-    const upEqual = upRight == upLeft;
-    const downEqual = downRight == downLeft;
-    const rightEqual = upRight == downRight;
-    const leftEqual = upLeft == downLeft;
-    if (upEqual && downEqual) {
-        if (upRight < downRight) {
-            flowAnimationState = FlowStates.Up;
-            return CompassAngles.North;
-        }
-        if (upRight > downRight) {
-            flowAnimationState = FlowStates.Up;
-            return CompassAngles.South;
-        }
-    }
-    if (rightEqual && leftEqual) {
-        if (upRight < upLeft) {
-            flowAnimationState = FlowStates.Up;
-            return CompassAngles.East;
-        }
-        if (upRight > upLeft) {
-            flowAnimationState = FlowStates.Up;
-            return CompassAngles.West;
-        }
-    }
-    if ((downRight < upRight && downRight < upLeft && downRight < downLeft) ||
-        (upLeft > upRight && upLeft > downRight && upLeft > downLeft)) {
-        flowAnimationState = FlowStates.Up;
-        return CompassAngles.SouthEast;
-    }
-    if ((upLeft < upRight && upLeft < downRight && upLeft < downLeft) ||
-        (downRight > upRight && downRight > upLeft && downRight > downLeft)) {
-        flowAnimationState = FlowStates.Up;
-        return CompassAngles.NorthWest;
-    }
-    if ((upRight < downRight && upRight < upLeft && upRight < downLeft) ||
-        (downLeft > downRight && downLeft > upLeft && downLeft > upRight)) {
-        flowAnimationState = FlowStates.Up;
-        return CompassAngles.NorthEast;
-    }
-    if ((downLeft < downRight && downLeft < upLeft && downLeft < upRight) ||
-        (upRight > downRight && upRight > upLeft && upRight > downLeft)) {
-        flowAnimationState = FlowStates.Up;
-        return CompassAngles.SouthWest;
-    }
-    return CompassAngles.North;
-};
-let upFaceExposed = false;
-let level = 0;
-const uvs = [
-    [1, 1],
-    [0, 1],
-    [0, 0],
-    [1, 0],
-];
-const Quads = {
-    up: Quad.Create([
-        [0, waterHeight, 0],
-        [1, waterHeight, 1],
-    ], uvs, false, 0),
-    down: Quad.Create([
-        [0, 0, 0],
-        [1, 0, 1],
-    ], uvs, false, 1),
-    north: Quad.Create([
-        [0, 0, 1],
-        [1, waterHeight, 1],
-    ], uvs, false, 1),
-    south: Quad.Create([
-        [0, 0, 0],
-        [1, waterHeight, 0],
-    ], uvs, false, 0),
-    east: Quad.Create([
-        [1, 0, 0],
-        [1, waterHeight, 1],
-    ], uvs, false, 0),
-    west: Quad.Create([
-        [0, 0, 0],
-        [0, waterHeight, 1],
-    ], uvs, false, 1),
-};
-class LiquidVoxelShapeClass extends VoxelShapeBase {
-    id = "#dve_liquid";
-    init() {
-        OverrideManager.FaceExposedShapeCheck.register(this.numberId, OverrideManager.ANY, (data) => {
-            if (data.face == VoxelFaces.Up &&
-                data.currentVoxel.getStringId() != data.neighborVoxel.getStringId()) {
-                return true;
-            }
-            return data.default;
-        });
-    }
-    start() {
-        upFaceExposed = false;
-        flowAnimationState = 0;
-        vertexLevel.setAll(15);
-        vertexValue.setAll(0);
-        level = ShapeTool.data.voxel.getLevel();
-    }
-    add = {
-        up() {
-            upFaceExposed = true;
-            const level = ShapeTool.data.voxel.getLevel();
-            ShapeTool.data.calculateFlow();
-            vertexLevel.setFromQuadData(ShapeTool.data.getWorldLevel());
-            vertexValue.set(vertexLevel.vertices[0] / 7, vertexLevel.vertices[1] / 7, vertexLevel.vertices[2] / 7, vertexLevel.vertices[3] / 7);
-            const uvAngle = getFlowAngle();
-            const uvSet = quadRotations[uvAngle];
-            Quads.up.uvs.vertices[QuadVerticies.TopRight].x = uvSet[0][0];
-            Quads.up.uvs.vertices[QuadVerticies.TopRight].y = uvSet[0][1];
-            Quads.up.uvs.vertices[QuadVerticies.TopLeft].x = uvSet[1][0];
-            Quads.up.uvs.vertices[QuadVerticies.TopLeft].y = uvSet[1][1];
-            Quads.up.uvs.vertices[QuadVerticies.BottomLeft].x = uvSet[2][0];
-            Quads.up.uvs.vertices[QuadVerticies.BottomLeft].y = uvSet[2][1];
-            Quads.up.uvs.vertices[QuadVerticies.BottomRight].x = uvSet[3][0];
-            Quads.up.uvs.vertices[QuadVerticies.BottomRight].y = uvSet[3][1];
-            Quads.up.positions.vertices[0].y = vertexValue.vertices[0] * waterHeight;
-            Quads.up.positions.vertices[1].y = vertexValue.vertices[1] * waterHeight;
-            Quads.up.positions.vertices[2].y = vertexValue.vertices[2] * waterHeight;
-            Quads.up.positions.vertices[3].y = vertexValue.vertices[3] * waterHeight;
-            ShapeTool.data.getAnimationData().setAll(flowAnimationState);
-            Quads.up.flip = ShapeTool.data.isFaceFlipped();
-            VoxelGeometry.addQuad(ShapeTool.data, ShapeTool.origin, Quads.up);
-        },
-        down() {
-            ShapeTool.data.getAnimationData().setAll(0);
-            CubeVoxelShape.add.down();
-        },
-        north() {
-            ShapeTool.data.getAnimationData().setAll(1);
-            Quads.north.flip = ShapeTool.data.isFaceFlipped();
-            if (upFaceExposed) {
-                Quads.north.positions.vertices[QuadVerticies.TopRight].y =
-                    vertexValue.vertices[QuadVerticies.TopRight] * waterHeight;
-                Quads.north.positions.vertices[QuadVerticies.TopLeft].y =
-                    vertexValue.vertices[QuadVerticies.TopLeft] * waterHeight;
-                Quads.north.uvs.vertices[QuadVerticies.TopRight].y =
-                    vertexValue.vertices[QuadVerticies.TopRight];
-                Quads.north.uvs.vertices[QuadVerticies.TopLeft].y =
-                    vertexValue.vertices[QuadVerticies.TopLeft];
-            }
-            else {
-                Quads.north.positions.vertices[QuadVerticies.TopRight].y = 1;
-                Quads.north.positions.vertices[QuadVerticies.TopLeft].y = 1;
-                Quads.north.setUVs(uvs);
-            }
-            VoxelGeometry.addQuad(ShapeTool.data, ShapeTool.origin, Quads.north);
-        },
-        south() {
-            Quads.south.flip = ShapeTool.data.isFaceFlipped();
-            ShapeTool.data.getAnimationData().setAll(1);
-            if (upFaceExposed) {
-                Quads.south.positions.vertices[QuadVerticies.TopRight].y =
-                    vertexValue.vertices[QuadVerticies.BottomRight] * waterHeight;
-                Quads.south.positions.vertices[QuadVerticies.TopLeft].y =
-                    vertexValue.vertices[QuadVerticies.BottomLeft] * waterHeight;
-                Quads.south.uvs.vertices[QuadVerticies.TopRight].y =
-                    vertexValue.vertices[QuadVerticies.BottomRight];
-                Quads.south.uvs.vertices[QuadVerticies.TopLeft].y =
-                    vertexValue.vertices[QuadVerticies.BottomLeft];
-            }
-            else {
-                Quads.south.positions.vertices[QuadVerticies.TopLeft].y = 1;
-                Quads.south.positions.vertices[QuadVerticies.TopRight].y = 1;
-                Quads.south.setUVs(uvs);
-            }
-            VoxelGeometry.addQuad(ShapeTool.data, ShapeTool.origin, Quads.south);
-        },
-        east() {
-            ShapeTool.data.getAnimationData().setAll(1);
-            Quads.east.flip = ShapeTool.data.isFaceFlipped();
-            if (upFaceExposed) {
-                Quads.east.positions.vertices[QuadVerticies.TopRight].y =
-                    vertexValue.vertices[QuadVerticies.TopRight] * waterHeight;
-                Quads.east.positions.vertices[QuadVerticies.TopLeft].y =
-                    vertexValue.vertices[QuadVerticies.BottomRight] * waterHeight;
-                Quads.east.uvs.vertices[QuadVerticies.TopRight].y =
-                    vertexValue.vertices[QuadVerticies.TopRight];
-                Quads.east.uvs.vertices[QuadVerticies.TopLeft].y =
-                    vertexValue.vertices[QuadVerticies.BottomRight];
-            }
-            else {
-                Quads.east.positions.vertices[QuadVerticies.TopLeft].y = 1;
-                Quads.east.positions.vertices[QuadVerticies.TopRight].y = 1;
-                Quads.east.setUVs(uvs);
-            }
-            VoxelGeometry.addQuad(ShapeTool.data, ShapeTool.origin, Quads.east);
-        },
-        west() {
-            ShapeTool.data.getAnimationData().setAll(1);
-            Quads.west.flip = ShapeTool.data.isFaceFlipped();
-            if (upFaceExposed) {
-                Quads.west.positions.vertices[QuadVerticies.TopRight].y =
-                    vertexValue.vertices[QuadVerticies.TopLeft] * waterHeight;
-                Quads.west.positions.vertices[QuadVerticies.TopLeft].y =
-                    vertexValue.vertices[QuadVerticies.BottomLeft] * waterHeight;
-                Quads.west.uvs.vertices[QuadVerticies.TopRight].y =
-                    vertexValue.vertices[QuadVerticies.TopLeft];
-                Quads.west.uvs.vertices[QuadVerticies.TopLeft].y =
-                    vertexValue.vertices[QuadVerticies.BottomLeft];
-            }
-            else {
-                Quads.west.positions.vertices[QuadVerticies.TopLeft].y = 1;
-                Quads.west.positions.vertices[QuadVerticies.TopRight].y = 1;
-                Quads.west.setUVs(uvs);
-            }
-            VoxelGeometry.addQuad(ShapeTool.data, ShapeTool.origin, Quads.west);
-        },
-    };
-}
-export const LiquidVoxelShape = new LiquidVoxelShapeClass();

package/Mesher/Shapes/default/Panel/CrossedPanels.voxel.shape.d.ts

@@ -1,8 +0,0 @@
-import { VoxelShapeBase } from "../../VoxelShapeBase.js";
-declare class CrossedPanelsClass extends VoxelShapeBase {
-    id: string;
-    init(): void;
-    build(): void;
-}
-export declare const CrossedPanelsVoxelShape: CrossedPanelsClass;
-export {};

package/Mesher/Shapes/default/Panel/CrossedPanels.voxel.shape.js

@@ -1,67 +0,0 @@
-import { ShapeTool } from "../../ShapeTool.js";
-import { VoxelGeometry } from "../../../Geometry/VoxelGeometry.js";
-import { WorldSpaces } from "../../../../Data/World/WorldSpaces.js";
-import { VoxelShapeBase } from "../../VoxelShapeBase.js";
-import { Quad } from "@amodx/meshing/Classes/Quad.js";
-import { VoxelShaderData } from "../../../../Data/VoxelShaderData.js";
-import { QuadVerticies } from "@amodx/meshing/Geometry.types.js";
-const Quads = [
-    //1
-    Quad.Create([
-        [1, 1, 1],
-        [0, 1, 0],
-        [0, 0, 0],
-        [1, 0, 1],
-    ], [
-        [1, 1],
-        [0, 1],
-        [0, 0],
-        [1, 0],
-    ], true),
-    //2
-    Quad.Create([
-        [0, 1, 1],
-        [1, 1, 0],
-        [1, 0, 0],
-        [0, 0, 1],
-    ], [
-        [0, 1],
-        [1, 1],
-        [1, 0],
-        [0, 0],
-    ], true),
-];
-class CrossedPanelsClass extends VoxelShapeBase {
-    id = "#dve_crossed_panels";
-    init() { }
-    build() {
-        let upANIM = 0;
-        let downANIM = 0;
-        let doubleSided = true;
-        if (ShapeTool.data.voxel.getSubstnaceData().isWindAffected()) {
-            ShapeTool.data.nVoxel.loadInAt(ShapeTool.data.voxel.x, ShapeTool.data.voxel.y + 1, ShapeTool.data.voxel.z);
-            if (ShapeTool.data.voxel.isSameVoxel(ShapeTool.data.nVoxel)) {
-                upANIM = VoxelShaderData.AnimationStates.WindAffected.Box;
-                downANIM = VoxelShaderData.AnimationStates.WindAffected.Box;
-            }
-            else {
-                upANIM = VoxelShaderData.AnimationStates.WindAffected.CrossPanel;
-            }
-            const animData = ShapeTool.data.getAnimationData();
-            animData.vertices[QuadVerticies.TopRight] = upANIM;
-            animData.vertices[QuadVerticies.TopLeft] = upANIM;
-            animData.vertices[QuadVerticies.BottomRight] = downANIM;
-            animData.vertices[QuadVerticies.BottomLeft] = downANIM;
-        }
-        if (ShapeTool.data.voxel.getSubstnaceData().isBackFaceCulled()) {
-            doubleSided = false;
-        }
-        const { x, y, z } = ShapeTool.data.voxel;
-        const voxelPOS = WorldSpaces.voxel.getPositionXYZ(x, y, z);
-        for (const data of Quads) {
-            data.doubleSided = doubleSided;
-            VoxelGeometry.addQuad(ShapeTool.data, voxelPOS, data);
-        }
-    }
-}
-export const CrossedPanelsVoxelShape = new CrossedPanelsClass();

package/Mesher/Shapes/default/Panel/FlatPanel.voxel.shape.d.ts

@@ -1,8 +0,0 @@
-import { VoxelShapeBase } from "../../VoxelShapeBase.js";
-declare class FlatPanelVoxelShapeClass extends VoxelShapeBase {
-    id: string;
-    init(): void;
-    build(): void;
-}
-export declare const PanelVoxelShape: FlatPanelVoxelShapeClass;
-export {};

package/Mesher/Shapes/default/Panel/FlatPanel.voxel.shape.js

@@ -1,68 +0,0 @@
-import { OverrideManager } from "../../../Rules/Overrides/OverridesManager.js";
-import { ShapeTool } from "../../ShapeTool.js";
-import { VoxelShapeBase } from "../../VoxelShapeBase.js";
-import { Quad } from "@amodx/meshing/Classes/Quad.js";
-import { VoxelGeometry } from "../../../Geometry/VoxelGeometry.js";
-import { VoxelShaderData } from "../../../../Data/VoxelShaderData.js";
-import { PanelStates } from "./PanelStates.js";
-const uvs = [
-    [1, 1],
-    [0, 1],
-    [0, 0],
-    [1, 0],
-];
-const near = 0.05;
-const far = 0.85;
-const QuadsPanel = {
-    [PanelStates.South]: Quad.Create([
-        [0, 0, near],
-        [1, 1, near],
-    ], uvs, true, 0),
-    [PanelStates.North]: Quad.Create([
-        [0, 0, far],
-        [1, 1, far],
-    ], uvs, true, 1),
-    [PanelStates.East]: Quad.Create([
-        [far, 0, 0],
-        [far, 1, 1],
-    ], uvs, true, 0),
-    [PanelStates.West]: Quad.Create([
-        [near, 0, 0],
-        [near, 1, 1],
-    ], uvs, false, 1),
-    [PanelStates.Down]: Quad.Create([
-        [0, near, 0],
-        [1, near, 1],
-    ], uvs, false, 1),
-    [PanelStates.Up]: Quad.Create([
-        [0, far, 0],
-        [1, far, 1],
-    ], uvs, false, 0),
-};
-class FlatPanelVoxelShapeClass extends VoxelShapeBase {
-    id = "#dve_flat_panel";
-    init() {
-        OverrideManager.FaceExposedShapeCheck.register(this.numberId, OverrideManager.ANY, (data) => {
-            if (data.currentVoxel.getSubstanceStringId() == "#dve_flora") {
-                return false;
-            }
-            return data.default;
-        });
-    }
-    build() {
-        let doubleSided = true;
-        if (ShapeTool.data.voxel.getSubstnaceData().isWindAffected()) {
-            ShapeTool.data
-                .getAnimationData()
-                .setAll(VoxelShaderData.AnimationStates.WindAffected.Panel);
-        }
-        if (ShapeTool.data.voxel.getSubstnaceData().isBackFaceCulled()) {
-            doubleSided = false;
-        }
-        const quad = QuadsPanel[ShapeTool.data.voxel.getShapeState()];
-        quad.flip = ShapeTool.data.isFaceFlipped();
-        quad.doubleSided = doubleSided;
-        VoxelGeometry.addQuad(ShapeTool.data, ShapeTool.origin, quad);
-    }
-}
-export const PanelVoxelShape = new FlatPanelVoxelShapeClass();

package/Mesher/Shapes/default/Panel/PanelStates.d.ts

@@ -1,8 +0,0 @@
-export declare enum PanelStates {
-    South = 0,
-    North = 1,
-    East = 2,
-    West = 3,
-    Down = 4,
-    Up = 5
-}

package/Mesher/Shapes/default/Panel/PanelStates.js

@@ -1,9 +0,0 @@
-export var PanelStates;
-(function (PanelStates) {
-    PanelStates[PanelStates["South"] = 0] = "South";
-    PanelStates[PanelStates["North"] = 1] = "North";
-    PanelStates[PanelStates["East"] = 2] = "East";
-    PanelStates[PanelStates["West"] = 3] = "West";
-    PanelStates[PanelStates["Down"] = 4] = "Down";
-    PanelStates[PanelStates["Up"] = 5] = "Up";
-})(PanelStates || (PanelStates = {}));

package/Mesher/Shapes/default/RegisterDefaultShapes.js

@@ -1,10 +0,0 @@
-import { VoxelShapeManager } from "../VoxelShapeManager";
-import { CubeVoxelShape } from "./Cube/Cube.voxel.shape";
-import { HalfCubeVoxelShape } from "./Cube/HalfCube.voxel.shape";
-import { LiquidVoxelShape } from "./Liquid/Liquid.voxel.shape";
-import { CrossedPanelsVoxelShape } from "./Panel/CrossedPanels.voxel.shape";
-import { PanelVoxelShape } from "./Panel/FlatPanel.voxel.shape";
-import { StairVoxelShape } from "./Stairs/Stair.voxel.shape";
-export default function () {
-    VoxelShapeManager.registerShape(CubeVoxelShape, HalfCubeVoxelShape, PanelVoxelShape, CrossedPanelsVoxelShape, LiquidVoxelShape, StairVoxelShape);
-}

package/Mesher/Shapes/default/Stairs/Stair.voxel.shape.d.ts

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

package/Mesher/Shapes/default/Stairs/Stair.voxel.shape.js

@@ -1,31 +0,0 @@
-import { VoxelShapeBase } from "../../VoxelShapeBase.js";
-import { VoxelFaces } from "../../../../Math/index.js";
-import { addStairQuads } from "./StairShapes.js";
-import { StairOverrides } from "./StairOverrides.js";
-class StairVoxelShapeClass extends VoxelShapeBase {
-    id = "#dve_stair";
-    init() {
-        StairOverrides.init();
-    }
-    add = {
-        up() {
-            addStairQuads(VoxelFaces.Up);
-        },
-        down() {
-            addStairQuads(VoxelFaces.Down);
-        },
-        north() {
-            addStairQuads(VoxelFaces.North);
-        },
-        south() {
-            addStairQuads(VoxelFaces.South);
-        },
-        east() {
-            addStairQuads(VoxelFaces.East);
-        },
-        west() {
-            addStairQuads(VoxelFaces.West);
-        },
-    };
-}
-export const StairVoxelShape = new StairVoxelShapeClass();

package/Mesher/Shapes/default/Stairs/StairOverrides.d.ts

@@ -1,17 +0,0 @@
-import { VoxelFaces } from "../../../../Math/index.js";
-/**
- * types
- */
-declare enum FaceType {
-    Box = 0,
-    Side = 1,
-    Up = 2,
-    Front = 3
-}
-type StairShapeState = Record<VoxelFaces, FaceType>;
-export declare class StairOverrides {
-    static FaceTypes: typeof FaceType;
-    static getStairState(state: number): StairShapeState;
-    static init(): void;
-}
-export {};

package/Mesher/Shapes/default/Stairs/StairOverrides.js

@@ -1,151 +0,0 @@
-import { CompassDirectionVoxelFaceMap, VoxelFaceCompassDirectionMap, VoxelFaceOpositeDirectionMap, VoxelFaces, } from "../../../../Math/index.js";
-import { AMath, Directions } from "@amodx/math";
-import { StairStates } from "./StairStates.js";
-import { OverrideManager } from "../../../Rules/Overrides/OverridesManager.js";
-import { StairVoxelShape } from "./Stair.voxel.shape.js";
-import { CubeVoxelShape } from "../Cube/Cube.voxel.shape.js";
-import { HalfCubeStates, HalfCubeVoxelShape, } from "../Cube/HalfCube.voxel.shape.js";
-/**
- * types
- */
-var FaceType;
-(function (FaceType) {
-    FaceType[FaceType["Box"] = 0] = "Box";
-    FaceType[FaceType["Side"] = 1] = "Side";
-    FaceType[FaceType["Up"] = 2] = "Up";
-    FaceType[FaceType["Front"] = 3] = "Front";
-})(FaceType || (FaceType = {}));
-/**
- * constants
- */
-const deg90 = AMath.DegreesToRadians(90);
-const deg180 = AMath.DegreesToRadians(180);
-const deg270 = AMath.DegreesToRadians(270);
-const sideFaces = [
-    VoxelFaces.North,
-    VoxelFaces.South,
-    VoxelFaces.West,
-    VoxelFaces.East,
-];
-const DefaultStair = {
-    [VoxelFaces.Up]: FaceType.Up,
-    [VoxelFaces.Down]: FaceType.Box,
-    [VoxelFaces.North]: FaceType.Box,
-    [VoxelFaces.South]: FaceType.Front,
-    [VoxelFaces.West]: FaceType.Side,
-    [VoxelFaces.East]: FaceType.Side,
-};
-const DefaultConnectedStair = {
-    [VoxelFaces.Up]: FaceType.Up,
-    [VoxelFaces.Down]: FaceType.Box,
-    [VoxelFaces.North]: FaceType.Box,
-    [VoxelFaces.South]: FaceType.Front,
-    [VoxelFaces.West]: FaceType.Front,
-    [VoxelFaces.East]: FaceType.Side,
-};
-/**
- * functions
- */
-const createRototation = (rotation, data, upsideDown = false) => {
-    const newData = structuredClone(data);
-    if (upsideDown) {
-        newData[VoxelFaces.Up] = data[VoxelFaces.Down];
-        newData[VoxelFaces.Down] = data[VoxelFaces.Up];
-    }
-    for (const face of sideFaces) {
-        const newDirection = CompassDirectionVoxelFaceMap[Directions.Rotate(VoxelFaceCompassDirectionMap[face], rotation)];
-        newData[newDirection] = data[face];
-    }
-    return newData;
-};
-/**
- * final
- */
-const StairShapeStates = {
-    [StairStates.DownNorth]: createRototation(0, DefaultStair),
-    [StairStates.DownSouth]: createRototation(deg180, DefaultStair),
-    [StairStates.DownEast]: createRototation(deg90, DefaultStair),
-    [StairStates.DownWest]: createRototation(deg270, DefaultStair),
-    [StairStates.UpNorth]: createRototation(0, DefaultStair, true),
-    [StairStates.UpSouth]: createRototation(deg180, DefaultStair, true),
-    [StairStates.UpEast]: createRototation(deg90, DefaultStair, true),
-    [StairStates.UpWest]: createRototation(deg270, DefaultStair, true),
-    [StairStates.DownNorthEast]: createRototation(0, DefaultConnectedStair),
-    [StairStates.DownSouthWest]: createRototation(deg180, DefaultConnectedStair),
-    [StairStates.DownSouthEast]: createRototation(deg90, DefaultConnectedStair),
-    [StairStates.DownNorthWest]: createRototation(deg270, DefaultConnectedStair),
-    [StairStates.UpNorthEast]: createRototation(0, DefaultConnectedStair, true),
-    [StairStates.UpSouthWest]: createRototation(deg180, DefaultConnectedStair, true),
-    [StairStates.UpSouthEast]: createRototation(deg90, DefaultConnectedStair, true),
-    [StairStates.UpNorthWest]: createRototation(deg270, DefaultConnectedStair, true),
-};
-export class StairOverrides {
-    static FaceTypes = FaceType;
-    static getStairState(state) {
-        return StairShapeStates[state];
-    }
-    static init() {
-        OverrideManager.FaceExposedShapeCheck.register(StairVoxelShape.numberId, StairVoxelShape.numberId, (data) => {
-            const faceType = StairOverrides.getStairState(data.currentVoxel.getShapeState())[data.face];
-            const opositeFaceType = StairOverrides.getStairState(data.neighborVoxel.getShapeState())[VoxelFaceOpositeDirectionMap[data.face]];
-            if (faceType == FaceType.Up)
-                return true;
-            if (faceType == FaceType.Box && opositeFaceType == FaceType.Box)
-                return false;
-            if (faceType == FaceType.Side && opositeFaceType == FaceType.Side)
-                return false;
-            return true;
-        });
-        OverrideManager.FaceExposedShapeCheck.register(StairVoxelShape.numberId, CubeVoxelShape.numberId, (data) => {
-            const faceType = StairOverrides.getStairState(data.currentVoxel.getShapeState())[data.face];
-            if (faceType == FaceType.Up)
-                return true;
-            if (faceType == FaceType.Box)
-                return false;
-            return true;
-        });
-        OverrideManager.FaceExposedShapeCheck.register(StairVoxelShape.numberId, HalfCubeVoxelShape.numberId, (data) => {
-            const state = data.neighborVoxel.getShapeState();
-            const faceType = StairOverrides.getStairState(data.currentVoxel.getShapeState())[data.face];
-            if (state == HalfCubeStates.Down) {
-                return true;
-            }
-            if (state == HalfCubeStates.Up) {
-                if (faceType == FaceType.Up)
-                    return false;
-            }
-            return true;
-        });
-        OverrideManager.AO.register(StairVoxelShape.numberId, HalfCubeVoxelShape.numberId, (data) => {
-            const state = data.neighborVoxel.getShapeState();
-            const faceType = StairOverrides.getStairState(data.currentVoxel.getShapeState())[data.face];
-            if (state == HalfCubeStates.Down) {
-                if (data.neighborVoxel.y < data.currentVoxel.y)
-                    return false;
-                if (faceType == FaceType.Front)
-                    return false;
-                return true;
-            }
-            return data.default;
-        });
-        OverrideManager.AO.register(HalfCubeVoxelShape.numberId, StairVoxelShape.numberId, (data) => {
-            const state = data.currentVoxel.getShapeState();
-            if (state == HalfCubeStates.Down) {
-                if (data.currentVoxel.y == data.neighborVoxel.y)
-                    return false;
-                return data.default;
-            }
-            return data.default;
-        });
-        OverrideManager.DarkenFaceUnderneath.register(StairVoxelShape.numberId, CubeVoxelShape.numberId, (data) => {
-            return true;
-        });
-        OverrideManager.DarkenFaceUnderneath.register(StairVoxelShape.numberId, HalfCubeVoxelShape.numberId, (data) => {
-            const state = data.currentVoxel.getShapeState();
-            if (state == HalfCubeStates.Up) {
-                return true;
-            }
-            return false;
-        });
-    }
-}

package/Mesher/Shapes/default/Stairs/StairShapes.d.ts

@@ -1,2 +0,0 @@
-import { VoxelFaces } from "../../../../Math/index.js";
-export declare const addStairQuads: (face: VoxelFaces) => void;