Removed #slope and merged it with #surface

Author: SIsilicon

src/editor/pane/mask.ts

@@ -14,7 +14,6 @@ import {
     OffsetMaskNode,
     PercentMaskNode,
     ShadowMaskNode,
-    SlopeMaskNode,
     StateMaskNode,
     SurfaceMaskNode,
     TagMaskNode,
@@ -36,7 +35,6 @@ const maskTypes = new Map<new (...args: any[]) => MaskNode, [string, () => MaskN
     [ExistingMaskNode, ["Existing Mask", () => new ExistingMaskNode(dummyToken)]],
     [ShadowMaskNode, ["Shadow Mask", () => new ShadowMaskNode(dummyToken)]],
     [PercentMaskNode, ["Random Mask", () => new PercentMaskNode(dummyToken, 0.5)]],
-    [SlopeMaskNode, ["Slope Mask", () => new SlopeMaskNode(dummyToken, 45, 90)]],
     [InputMaskNode, ["Input Mask", () => new InputMaskNode(dummyToken, defaultBLock)]],
 ]);
 
@@ -96,7 +94,7 @@ export class MaskUIBuilder {
             const subPane = pane.getSubPane(1);
             if (type === BlockMaskNode) this.buildBlockMaskUI(subPane, maskNode as BlockMaskNode);
             else if (type === StateMaskNode) this.buildStateMaskUI(subPane, maskNode as StateMaskNode);
-            else if (type === SlopeMaskNode) this.buildSlopeMaskUI(subPane, maskNode as SlopeMaskNode);
+            else if (type === SurfaceMaskNode) this.buildSurfaceMaskUI(subPane, maskNode as SurfaceMaskNode);
             else if (type === TagMaskNode) this.buildTagMaskUI(subPane, maskNode as TagMaskNode);
             else if (type === PercentMaskNode) this.buildPercentMaskUI(subPane, maskNode as PercentMaskNode);
             else if (type === ChainMaskNode) this.buildChainOrIntersectMaskUI(subPane, maskNode as ChainMaskNode);
@@ -328,11 +326,29 @@ export class MaskUIBuilder {
         this.buildMaskUI(pane.getSubPane(1), node.nodes[0], node);
     }
 
-    private buildSlopeMaskUI(pane: UIPane, node: SlopeMaskNode) {
+    private buildSurfaceMaskUI(pane: UIPane, node: SurfaceMaskNode) {
         const range = { min: 0, max: 90 };
         pane.changeItems([
-            { type: "slider", title: "Minimum Angle", ...range, value: node.lowerAngle, onChange: (value) => (node.lowerAngle = value) },
-            { type: "slider", title: "Maximum Angle", ...range, value: node.upperAngle, onChange: (value) => (node.upperAngle = value) },
+            {
+                type: "toggle",
+                title: "Filter Slope",
+                value: node.lowerAngle === undefined || node.upperAngle === undefined,
+                onChange: (value) => {
+                    pane.setVisibility(1, value);
+                    pane.setVisibility(2, value);
+                    if (value) {
+                        node.lowerAngle = 0;
+                        node.upperAngle = 90;
+                        pane.setValue(1, 0);
+                        pane.setValue(2, 90);
+                    } else {
+                        node.lowerAngle = undefined;
+                        node.upperAngle = undefined;
+                    }
+                },
+            },
+            { type: "slider", title: "Minimum Angle", ...range, value: node.lowerAngle ?? 0, onChange: (value) => (node.lowerAngle = value) },
+            { type: "slider", title: "Maximum Angle", ...range, value: node.upperAngle ?? 90, onChange: (value) => (node.upperAngle = value) },
         ]);
     }
 

src/server/modules/mask.ts

@@ -208,25 +208,25 @@ export class Mask implements CustomArgType {
                     }
                 } else if (token.value == "#") {
                     const t = tokens.next();
-                    if (t.value == "slope") {
-                        let t = tokens.next();
-                        if (t.value != "[") throwTokenError(t);
-                        t = tokens.next();
-                        if (t.type != "number") throwTokenError(t);
-                        const lowerAngle = <number>t.value;
-                        t = tokens.next();
-                        if (t.value != ":") throwTokenError(t);
-                        t = tokens.next();
-                        if (t.type != "number") throwTokenError(t);
-                        const upperAngle = <number>t.value;
-                        t = tokens.next();
-                        if (t.value != "]") throwTokenError(t);
-
-                        out.push(new SlopeMaskNode(nodeToken(), lowerAngle, upperAngle));
-                    } else if (t.value == "existing") {
+                    if (t.value == "existing") {
                         out.push(new ExistingMaskNode(nodeToken()));
                     } else if (t.value == "surface" || t.value == "exposed") {
-                        out.push(new SurfaceMaskNode(nodeToken()));
+                        let lowerAngle: number | undefined;
+                        let upperAngle: number | undefined;
+                        if (tokens.peek().value == "[") {
+                            tokens.next();
+                            let t = tokens.next();
+                            if (t.type != "number") throwTokenError(t);
+                            lowerAngle = <number>t.value;
+                            t = tokens.next();
+                            if (t.value != ":") throwTokenError(t);
+                            t = tokens.next();
+                            if (t.type != "number") throwTokenError(t);
+                            upperAngle = <number>t.value;
+                            t = tokens.next();
+                            if (t.value != "]") throwTokenError(t);
+                        }
+                        out.push(new SurfaceMaskNode(nodeToken(), lowerAngle, upperAngle));
                     } else if (t.value == "shadow") {
                         out.push(new ShadowMaskNode(nodeToken()));
                     } else if (t.value == "#") {
@@ -384,22 +384,61 @@ export class SurfaceMaskNode extends MaskNode {
     readonly prec = -1;
     readonly opCount = 0;
 
+    static readonly testDistance = 2;
+    static readonly testOffsets = {
+        "-z": Vector.from(Direction.North).mul(SurfaceMaskNode.testDistance),
+        "+z": Vector.from(Direction.South).mul(SurfaceMaskNode.testDistance),
+        "+x": Vector.from(Direction.East).mul(SurfaceMaskNode.testDistance),
+        "-x": Vector.from(Direction.West).mul(SurfaceMaskNode.testDistance),
+    };
+
+    constructor(
+        token: Token,
+        public lowerAngle?: number,
+        public upperAngle?: number
+    ) {
+        super(token);
+    }
+
     matchesBlock(block: BlockUnit) {
         const loc = Vector.from(block.location);
         const dim = block.dimension;
         const isEmpty = (loc: Vector3) => {
             return dim.getBlock(loc).isAir;
         };
 
-        return (
+        const isSurface =
             !isEmpty(loc) &&
             (isEmpty(loc.offset(0, 1, 0)) ||
                 isEmpty(loc.offset(0, -1, 0)) ||
                 isEmpty(loc.offset(-1, 0, 0)) ||
                 isEmpty(loc.offset(1, 0, 0)) ||
                 isEmpty(loc.offset(0, 0, -1)) ||
-                isEmpty(loc.offset(0, 0, 1)))
-        );
+                isEmpty(loc.offset(0, 0, 1)));
+
+        if (!isSurface) return false;
+        if (this.lowerAngle === undefined || this.upperAngle === undefined) return true;
+
+        const heights: { [dir: string]: number } = {};
+
+        for (const [entry, offset] of Object.entries(SurfaceMaskNode.testOffsets)) {
+            const start = Vector.add(block, offset).add(0.5);
+
+            let testBlock = block.dimension.getBlock(start);
+            while (testBlock?.isSolid) {
+                testBlock = testBlock.above();
+                start.y++;
+            }
+
+            const hit = block.dimension.getBlockFromRay(start, Vector.DOWN, { includePassableBlocks: false, includeLiquidBlocks: false });
+            if (hit) heights[entry] = hit.block.y + hit.faceLocation.y;
+        }
+
+        const distance2 = SurfaceMaskNode.testDistance * 2;
+        const slopeX = Math.abs(heights["+z"] - heights["-z"]) / distance2;
+        const slopeZ = Math.abs(heights["+x"] - heights["-x"]) / distance2;
+        const pitch = 90 - Math.atan(1 / Math.sqrt(slopeX ** 2 + slopeZ ** 2)) * (180 / Math.PI);
+        return pitch >= this.lowerAngle && pitch <= this.upperAngle;
     }
 }
 
@@ -442,50 +481,6 @@ export class ShadowMaskNode extends MaskNode {
     }
 }
 
-export class SlopeMaskNode extends MaskNode {
-    readonly prec = -1;
-    readonly opCount = 0;
-
-    static readonly testDistance = 2;
-    static readonly testOffsets = {
-        "-z": Vector.from(Direction.North).mul(SlopeMaskNode.testDistance),
-        "+z": Vector.from(Direction.South).mul(SlopeMaskNode.testDistance),
-        "+x": Vector.from(Direction.East).mul(SlopeMaskNode.testDistance),
-        "-x": Vector.from(Direction.West).mul(SlopeMaskNode.testDistance),
-    };
-
-    constructor(
-        token: Token,
-        public lowerAngle: number,
-        public upperAngle: number
-    ) {
-        super(token);
-    }
-
-    matchesBlock(block: BlockUnit) {
-        const heights: { [dir: string]: number } = {};
-
-        for (const [entry, offset] of Object.entries(SlopeMaskNode.testOffsets)) {
-            const start = Vector.add(block, offset).add(0.5);
-
-            let testBlock = block.dimension.getBlock(start);
-            while (testBlock?.isSolid) {
-                testBlock = testBlock.above();
-                start.y++;
-            }
-
-            const hit = block.dimension.getBlockFromRay(start, Vector.DOWN, { includePassableBlocks: false, includeLiquidBlocks: false });
-            if (hit) heights[entry] = hit.block.y + hit.faceLocation.y;
-        }
-
-        const distance2 = SlopeMaskNode.testDistance * 2;
-        const slopeX = Math.abs(heights["+z"] - heights["-z"]) / distance2;
-        const slopeZ = Math.abs(heights["+x"] - heights["-x"]) / distance2;
-        const pitch = 90 - Math.atan(1 / Math.sqrt(slopeX ** 2 + slopeZ ** 2)) * (180 / Math.PI);
-        return pitch >= this.lowerAngle && pitch <= this.upperAngle;
-    }
-}
-
 export class TagMaskNode extends MaskNode {
     readonly prec = -1;
     readonly opCount = 0;