@divinevoxel/vlox 0.0.0

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

@@ -0,0 +1,231 @@
+import { VoxelFaces } from "../../../../Math/index.js";
+import { OverrideManager } from "../../../Rules/Overrides/OverridesManager.js";
+import { ShapeTool } from "../../ShapeTool.js";
+import { QuadScalarVertexData } from "@amodx/meshing/Classes/QuadVertexData";
+import { VoxelShapeBase } from "../../VoxelShapeBase.js";
+import { VoxelShapeManager } from "../../VoxelShapeManager.js";
+import { Quad } from "@amodx/meshing/Classes/Quad.js";
+import { VoxelShaderData } from "../../../../Data/VoxelShaderData.js";
+import { VoxelGeometry } from "../../../Geometry/VoxelGeometry.js";
+const animationState = new QuadScalarVertexData();
+export var HalfCubeStates;
+(function (HalfCubeStates) {
+    HalfCubeStates[HalfCubeStates["Down"] = 0] = "Down";
+    HalfCubeStates[HalfCubeStates["Up"] = 1] = "Up";
+    HalfCubeStates[HalfCubeStates["North"] = 2] = "North";
+    HalfCubeStates[HalfCubeStates["Sourth"] = 3] = "Sourth";
+    HalfCubeStates[HalfCubeStates["East"] = 4] = "East";
+    HalfCubeStates[HalfCubeStates["West"] = 5] = "West";
+})(HalfCubeStates || (HalfCubeStates = {}));
+const fullUvs = [
+    [1, 1],
+    [0, 1],
+    [0, 0],
+    [1, 0],
+];
+const halfUvs = [
+    [1, 0.5],
+    [0, 0.5],
+    [0, 0],
+    [1, 0],
+];
+const Quads = {
+    up: Quad.Create([
+        [0, 0.5, 0],
+        [1, 0.5, 1],
+    ], fullUvs, false, 0),
+    down: Quad.Create([
+        [0, 0, 0],
+        [1, 0, 1],
+    ], fullUvs, false, 1),
+    north: Quad.Create([
+        [0, 0, 1],
+        [1, 0.5, 1],
+    ], halfUvs, false, 1),
+    south: Quad.Create([
+        [0, 0, 0],
+        [1, 0.5, 0],
+    ], halfUvs, false, 0),
+    east: Quad.Create([
+        [1, 0, 0],
+        [1, 0.5, 1],
+    ], halfUvs, false, 0),
+    west: Quad.Create([
+        [0, 0, 0],
+        [0, 0.5, 1],
+    ], halfUvs, false, 1),
+};
+class HalfCubeVoxelShapeClass extends VoxelShapeBase {
+    id = "#dve_half_cube";
+    init() {
+        //cullface
+        OverrideManager.FaceExposedShapeCheck.register(this.numberId, VoxelShapeManager.getMappedId("#dve_flat_panel"), (data) => {
+            return false;
+        });
+        OverrideManager.FaceExposedShapeCheck.register(this.numberId, VoxelShapeManager.getMappedId("#dve_cube"), (data) => {
+            if (data.currentVoxel.getShapeState() == HalfCubeStates.Up) {
+                if (data.face == VoxelFaces.Up) {
+                    return false;
+                }
+                if (data.face == VoxelFaces.Down) {
+                    return true;
+                }
+                return true;
+            }
+            if (data.currentVoxel.getShapeState() == HalfCubeStates.Down) {
+                if (data.face == VoxelFaces.Up) {
+                    return true;
+                }
+                if (data.face == VoxelFaces.Down) {
+                    return false;
+                }
+                return true;
+            }
+            return true;
+        });
+        OverrideManager.FaceExposedShapeCheck.register(this.numberId, this.numberId, (data) => {
+            if (data.currentVoxel.getShapeState() == HalfCubeStates.Up &&
+                data.neighborVoxel.getShapeState() == HalfCubeStates.Up) {
+                if (data.face == VoxelFaces.Up) {
+                    return true;
+                }
+                if (data.face == VoxelFaces.Down) {
+                    return true;
+                }
+                return false;
+            }
+            if (data.currentVoxel.getShapeState() == HalfCubeStates.Down &&
+                data.neighborVoxel.getShapeState() == HalfCubeStates.Down) {
+                if (data.face == VoxelFaces.Up) {
+                    return true;
+                }
+                if (data.face == VoxelFaces.Down) {
+                    return true;
+                }
+                return false;
+            }
+            if (data.currentVoxel.getShapeState() == HalfCubeStates.Up &&
+                data.neighborVoxel.getShapeState() == HalfCubeStates.Down) {
+                if (data.face == VoxelFaces.Up) {
+                    return false;
+                }
+                if (data.face == VoxelFaces.Down) {
+                    return true;
+                }
+                return true;
+            }
+            if (data.currentVoxel.getShapeState() == HalfCubeStates.Down &&
+                data.neighborVoxel.getShapeState() == HalfCubeStates.Up) {
+                if (data.face == VoxelFaces.Up) {
+                    return true;
+                }
+                if (data.face == VoxelFaces.Down) {
+                    return false;
+                }
+                return true;
+            }
+            return true;
+        });
+        OverrideManager.FaceExposedShapeCheck.register(this.numberId, VoxelShapeManager.getMappedId("#dve_stair"), (data) => {
+            return true;
+        });
+        //AO
+        OverrideManager.AO.register(this.numberId, VoxelShapeManager.getMappedId("#dve_flat_panel"), (data) => {
+            return false;
+        });
+        OverrideManager.AO.register(this.numberId, this.numberId, (data) => {
+            if (data.currentVoxel.getShapeState() == HalfCubeStates.Up &&
+                data.neighborVoxel.getShapeState() == HalfCubeStates.Up) {
+                return false;
+            }
+            if (data.currentVoxel.getShapeState() == HalfCubeStates.Down &&
+                data.neighborVoxel.getShapeState() == HalfCubeStates.Down) {
+                return false;
+            }
+            if (data.currentVoxel.getShapeState() == HalfCubeStates.Up &&
+                data.neighborVoxel.getShapeState() == HalfCubeStates.Down) {
+                return true;
+            }
+            if (data.currentVoxel.getShapeState() == HalfCubeStates.Down &&
+                data.neighborVoxel.getShapeState() == HalfCubeStates.Up) {
+                return true;
+            }
+            return false;
+        });
+        OverrideManager.AO.register(this.numberId, VoxelShapeManager.getMappedId("#dve_cube"), (data) => {
+            if (data.currentVoxel.getShapeState() == HalfCubeStates.Up) {
+                if (data.neighborVoxel.y == data.currentVoxel.y - 1)
+                    return false;
+                return data.default;
+            }
+            if (data.currentVoxel.getShapeState() == HalfCubeStates.Down &&
+                data.currentVoxel.y < data.neighborVoxel.y) {
+                return false;
+            }
+            return data.default;
+        });
+    }
+    start() {
+        const state = ShapeTool.data.voxel.getShapeState();
+        if (state == HalfCubeStates.Up) {
+            ShapeTool.origin.y += 0.5;
+        }
+    }
+    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 HalfCubeVoxelShape = new HalfCubeVoxelShapeClass();

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+export default function (): void;