@zephyr3d/scene 0.7.0 → 0.8.0

package/dist/utility/blueprint/common/math.js

@@ -1,4 +1,5 @@
-import { BaseGraphNode } from '../node.js';
+import { BaseGraphNode, getNodeTypeComponents } from '../node.js';
+import { defineProps } from '../../serialization/types.js';
 
 /**
  * Vector constructor node
@@ -243,7 +244,7 @@ import { BaseGraphNode } from '../node.js';
             ctor: SwizzleNode,
             name: 'SwizzleNode',
             getProps () {
-                return [
+                return defineProps([
                     {
                         name: 'Swizzle',
                         type: 'string',
@@ -254,7 +255,7 @@ import { BaseGraphNode } from '../node.js';
                             this.swizzle = value.str[0];
                         }
                     }
-                ];
+                ]);
             }
         };
     }
@@ -274,9 +275,6 @@ import { BaseGraphNode } from '../node.js';
         if (err) {
             return err;
         }
-        if (!this._inputs[0].inputNode) {
-            return `Missing argument \`${name}\``;
-        }
         const type = this._inputs[0].inputNode.getOutputType(this._inputs[0].inputId);
         if (!type) {
             return `Cannot determine type of argument \`${name}\``;
@@ -309,7 +307,7 @@ import { BaseGraphNode } from '../node.js';
    * @returns 'float', 'vec2', 'vec3', 'vec4', or empty string if invalid
    *
    */ getType() {
-        const err = super.validate();
+        const err = this.validate();
         if (err) {
             return '';
         }
@@ -343,6 +341,366 @@ import { BaseGraphNode } from '../node.js';
         return this._swizzle.length === 1 ? 'float' : `vec${this._swizzle.length}`;
     }
 }
+/**
+ * Vector comparison node
+ *
+ * @public
+ */ class CompComparisonNode extends BaseGraphNode {
+    _mode;
+    /**
+   * Creates a new swizzle node
+   */ constructor(){
+        super();
+        this._mode = 'eq';
+        this._inputs = [
+            {
+                id: 1,
+                name: '',
+                type: [
+                    'vec2',
+                    'vec3',
+                    'vec4'
+                ],
+                required: true
+            },
+            {
+                id: 2,
+                name: '',
+                type: [
+                    'vec2',
+                    'vec3',
+                    'vec4'
+                ],
+                required: true
+            }
+        ];
+        this._outputs = [
+            {
+                id: 1,
+                name: ''
+            }
+        ];
+    }
+    /** Swizzle */ get mode() {
+        return this._mode;
+    }
+    set mode(val) {
+        this._mode = val;
+    }
+    /**
+   * Generates a string representation of this node
+   *
+   * @returns 'Swizzle'
+   */ toString() {
+        return 'Comparison';
+    }
+    /**
+   * Gets the serialization descriptor for this node type
+   *
+   * @returns Serialization class descriptor
+   *
+   * @remarks
+   * No properties need to be serialized beyond the base node data.
+   */ static getSerializationCls() {
+        return {
+            ctor: CompComparisonNode,
+            name: 'CompComparisonNode',
+            getProps () {
+                return defineProps([
+                    {
+                        name: 'mode',
+                        type: 'string',
+                        options: {
+                            enum: {
+                                labels: [
+                                    'Equal',
+                                    'NotEqual',
+                                    'LessThan',
+                                    'LessThanEqual',
+                                    'GreaterThan',
+                                    'GreaterThanEqual'
+                                ],
+                                values: [
+                                    'eq',
+                                    'ne',
+                                    'lt',
+                                    'le',
+                                    'gt',
+                                    'ge'
+                                ]
+                            }
+                        },
+                        get (value) {
+                            value.str[0] = this.mode;
+                        },
+                        set (value) {
+                            this.mode = value.str[0];
+                        }
+                    }
+                ]);
+            }
+        };
+    }
+    /**
+   * Validates the node state and input types
+   *
+   * @returns Error message if invalid, empty string if valid
+   */ validate() {
+        const err = super.validate();
+        if (err) {
+            return err;
+        }
+        const type0 = this._inputs[0].inputNode.getOutputType(this._inputs[0].inputId);
+        const type1 = this._inputs[1].inputNode.getOutputType(this._inputs[1].inputId);
+        if (type0 !== type1) {
+            return 'Input arguments must be the same type';
+        }
+        return '';
+    }
+    /**
+   * Gets the output type based on connected inputs
+   *
+   * @returns 'bvec2', 'bvec3', 'bvec4', or empty string if invalid
+   *
+   */ getType() {
+        const err = this.validate();
+        if (err) {
+            return '';
+        }
+        const type = this._inputs[0].inputNode.getOutputType(this._inputs[0].inputId);
+        return `bvec${getNodeTypeComponents(type)}`;
+    }
+}
+/**
+ * Any condition node
+ *
+ * @public
+ */ class AnyConditionNode extends BaseGraphNode {
+    /**
+   * Creates a new any-condition node
+   */ constructor(){
+        super();
+        this._inputs = [
+            {
+                id: 1,
+                name: '',
+                type: [
+                    'bool',
+                    'bvec2',
+                    'bvec3',
+                    'bvec4'
+                ],
+                required: true
+            }
+        ];
+        this._outputs = [
+            {
+                id: 1,
+                name: ''
+            }
+        ];
+    }
+    /**
+   * Generates a string representation of this node
+   *
+   * @returns 'Any'
+   */ toString() {
+        return 'Any';
+    }
+    /**
+   * Gets the serialization descriptor for this node type
+   *
+   * @returns Serialization class descriptor
+   *
+   * @remarks
+   * No properties need to be serialized beyond the base node data.
+   */ static getSerializationCls() {
+        return {
+            ctor: AnyConditionNode,
+            name: 'AnyConditionNode',
+            getProps () {
+                return [];
+            }
+        };
+    }
+    /**
+   * Gets the output type based on connected inputs
+   *
+   * @returns 'bool'
+   *
+   */ getType() {
+        return this.validate() ? '' : 'bool';
+    }
+}
+/**
+ * All condition node
+ *
+ * @public
+ */ class AllConditionNode extends BaseGraphNode {
+    /**
+   * Creates a new all-condition node
+   */ constructor(){
+        super();
+        this._inputs = [
+            {
+                id: 1,
+                name: '',
+                type: [
+                    'bool',
+                    'bvec2',
+                    'bvec3',
+                    'bvec4'
+                ],
+                required: true
+            }
+        ];
+        this._outputs = [
+            {
+                id: 1,
+                name: ''
+            }
+        ];
+    }
+    /**
+   * Generates a string representation of this node
+   *
+   * @returns 'All'
+   */ toString() {
+        return 'All';
+    }
+    /**
+   * Gets the serialization descriptor for this node type
+   *
+   * @returns Serialization class descriptor
+   *
+   * @remarks
+   * No properties need to be serialized beyond the base node data.
+   */ static getSerializationCls() {
+        return {
+            ctor: AllConditionNode,
+            name: 'AllConditionNode',
+            getProps () {
+                return [];
+            }
+        };
+    }
+    /**
+   * Gets the output type based on connected inputs
+   *
+   * @returns 'bool'
+   *
+   */ getType() {
+        return this.validate() ? '' : 'bool';
+    }
+}
+/**
+ * Selection node
+ *
+ * @public
+ */ class SelectionNode extends BaseGraphNode {
+    /**
+   * Creates a new selection node
+   */ constructor(){
+        super();
+        this._inputs = [
+            {
+                id: 1,
+                name: 'a',
+                type: [
+                    'float',
+                    'vec2',
+                    'vec3',
+                    'vec4'
+                ],
+                required: true
+            },
+            {
+                id: 2,
+                name: 'b',
+                type: [
+                    'float',
+                    'vec2',
+                    'vec3',
+                    'vec4'
+                ],
+                required: true
+            },
+            {
+                id: 3,
+                name: 'condition',
+                type: [
+                    'bool',
+                    'bvec2',
+                    'bvec3',
+                    'bvec4'
+                ],
+                required: true
+            }
+        ];
+        this._outputs = [
+            {
+                id: 1,
+                name: ''
+            }
+        ];
+    }
+    /**
+   * Generates a string representation of this node
+   *
+   * @returns 'Selection'
+   */ toString() {
+        return 'Selection';
+    }
+    /**
+   * Gets the serialization descriptor for this node type
+   *
+   * @returns Serialization class descriptor
+   *
+   * @remarks
+   * No properties need to be serialized beyond the base node data.
+   */ static getSerializationCls() {
+        return {
+            ctor: SelectionNode,
+            name: 'SelectionNode',
+            getProps () {
+                return [];
+            }
+        };
+    }
+    /**
+   * Validates the node state and input types
+   *
+   * @returns Error message if invalid, empty string if valid
+   */ validate() {
+        const err = super.validate();
+        if (err) {
+            return err;
+        }
+        const type0 = this._inputs[0].inputNode.getOutputType(this._inputs[0].inputId);
+        const type1 = this._inputs[1].inputNode.getOutputType(this._inputs[1].inputId);
+        if (type0 !== type1) {
+            return 'Input arguments 0-1 must be the same type';
+        }
+        const type2 = this._inputs[2].inputNode.getOutputType(this._inputs[2].inputId);
+        const n = getNodeTypeComponents(type2);
+        if (n > 1 && n !== getNodeTypeComponents(type0)) {
+            return 'Invalid type of argument 2';
+        }
+        return '';
+    }
+    /**
+   * Gets the output type based on connected inputs
+   *
+   * @returns 'bool'
+   *
+   */ getType() {
+        const err = this.validate();
+        if (err) {
+            return '';
+        }
+        return this._inputs[0].inputNode.getOutputType(this._inputs[0].inputId);
+    }
+}
 /**
  * Matrix-vector transformation node
  *
@@ -500,7 +858,7 @@ import { BaseGraphNode } from '../node.js';
    * - mat * vec = vec (same dimension)
    * - mat * mat = mat (same dimension)
    */ getType() {
-        const err = super.validate();
+        const err = this.validate();
         if (err) {
             return '';
         }
@@ -1590,6 +1948,24 @@ import { BaseGraphNode } from '../node.js';
         };
     }
 }
+/**
+ * SmoothStep function
+ *
+ * @public
+ */ class SmoothStepNode extends GenericMathNode {
+    constructor(){
+        super('smoothStep', 3);
+    }
+    static getSerializationCls() {
+        return {
+            ctor: SmoothStepNode,
+            name: 'SmoothStepNode',
+            getProps () {
+                return [];
+            }
+        };
+    }
+}
 /**
  * Fused multiply-add operation
  *
@@ -1847,6 +2223,92 @@ import { BaseGraphNode } from '../node.js';
         };
     }
 }
+/**
+ * Logically and
+ *
+ * @public
+ */ class LogicallyAndNode extends GenericMathNode {
+    constructor(){
+        super('and', 2, 'bool', [
+            'bool'
+        ]);
+    }
+    static getSerializationCls() {
+        return {
+            ctor: LogicallyAndNode,
+            name: 'LogicallyAndNode',
+            getProps () {
+                return [];
+            }
+        };
+    }
+}
+/**
+ * Logically or
+ *
+ * @public
+ */ class LogicallyOrNode extends GenericMathNode {
+    constructor(){
+        super('or', 2, 'bool', [
+            'bool'
+        ]);
+    }
+    static getSerializationCls() {
+        return {
+            ctor: LogicallyOrNode,
+            name: 'LogicallyOrNode',
+            getProps () {
+                return [];
+            }
+        };
+    }
+}
+/**
+ * Equal test across two scalar or vectors
+ *
+ * @public
+ */ class EqualNode extends GenericMathNode {
+    constructor(){
+        super('equal', 2, 'bool', [
+            'float',
+            'vec2',
+            'vec3',
+            'vec4'
+        ]);
+    }
+    static getSerializationCls() {
+        return {
+            ctor: EqualNode,
+            name: 'EqualNode',
+            getProps () {
+                return [];
+            }
+        };
+    }
+}
+/**
+ * Not-Equal test across two scalar or vectors
+ *
+ * @public
+ */ class NotEqualNode extends GenericMathNode {
+    constructor(){
+        super('notEqual', 2, 'bool', [
+            'float',
+            'vec2',
+            'vec3',
+            'vec4'
+        ]);
+    }
+    static getSerializationCls() {
+        return {
+            ctor: NotEqualNode,
+            name: 'NotEqualNode',
+            getProps () {
+                return [];
+            }
+        };
+    }
+}
 /**
  * Calculates the dot product of two vectors
  *
@@ -2041,5 +2503,5 @@ import { BaseGraphNode } from '../node.js';
     }
 }
 
-export { AbsNode, ArcCosNode, ArcSinNode, ArcTan2Node, ArcTanNode, ArccosineHNode, ArcsineHNode, ArctangentHNode, CeilNode, ClampNode, CompAddNode, CompDivNode, CompMulNode, CompSubNode, CosHNode, CosNode, CrossProductNode, DDXNode, DDYNode, Degrees2RadiansNode, DistanceNode, DotProductNode, Exp2Node, ExpNode, FWidthNode, FaceForwardNode, FloorNode, FmaNode, FractNode, GenericMathNode, Hash1Node, Hash2Node, Hash3Node, InvSqrtNode, LengthNode, Log2Node, LogNode, MakeVectorNode, MaxNode, MinNode, MixNode, ModNode, NormalizeNode, PerlinNoise2DNode, PowNode, Radians2DegreesNode, ReflectNode, RefractNode, SaturateNode, SignNode, SimplexNoise2DNode, SinHNode, SinNode, SqrtNode, StepNode, SwizzleNode, TanHNode, TanNode, TransformNode };
+export { AbsNode, AllConditionNode, AnyConditionNode, ArcCosNode, ArcSinNode, ArcTan2Node, ArcTanNode, ArccosineHNode, ArcsineHNode, ArctangentHNode, CeilNode, ClampNode, CompAddNode, CompComparisonNode, CompDivNode, CompMulNode, CompSubNode, CosHNode, CosNode, CrossProductNode, DDXNode, DDYNode, Degrees2RadiansNode, DistanceNode, DotProductNode, EqualNode, Exp2Node, ExpNode, FWidthNode, FaceForwardNode, FloorNode, FmaNode, FractNode, GenericMathNode, Hash1Node, Hash2Node, Hash3Node, InvSqrtNode, LengthNode, Log2Node, LogNode, LogicallyAndNode, LogicallyOrNode, MakeVectorNode, MaxNode, MinNode, MixNode, ModNode, NormalizeNode, NotEqualNode, PerlinNoise2DNode, PowNode, Radians2DegreesNode, ReflectNode, RefractNode, SaturateNode, SelectionNode, SignNode, SimplexNoise2DNode, SinHNode, SinNode, SmoothStepNode, SqrtNode, StepNode, SwizzleNode, TanHNode, TanNode, TransformNode };
 //# sourceMappingURL=math.js.map