Add brush behavior binary operators kAndThen, kOrElse, and kXorElse

These three operators allow for greater control over how to handle null values (e.g. unavailable source data) in brush behaviors:
* `kOrElse` returns the first non-null input, allowing for fallback branches in a brush behavior. If a subtree based on some source (like stylus tilt) is unavailable, the behavior can fall back to a substitute implementation.
* `kAndThen` returns the second input, but only if the first input is non-null. This can help when two separate behaviors are meant to work together, but one relies on a source that might be unavailable; `kAndThen` can be used in the other behavior to ensure that it also gets disabled when that source is unavailable.
* `kXorElse` is more niche, but can be used to combine two subtrees where only one should normally be defined at a time, and there's no defined way to combine them if both are defined.  It can also be used with a constant node to form a sort of "logical not" for null values.

PiperOrigin-RevId: 875239647

Author: Ink Open Source

ink/brush/brush_behavior.cc

@@ -217,6 +217,9 @@ bool IsValidBehaviorBinaryOp(BrushBehavior::BinaryOp operation) {
     case BrushBehavior::BinaryOp::kSum:
     case BrushBehavior::BinaryOp::kMin:
     case BrushBehavior::BinaryOp::kMax:
+    case BrushBehavior::BinaryOp::kAndThen:
+    case BrushBehavior::BinaryOp::kOrElse:
+    case BrushBehavior::BinaryOp::kXorElse:
       return true;
   }
   return false;
@@ -671,6 +674,12 @@ std::string ToFormattedString(BrushBehavior::BinaryOp operation) {
       return "kMin";
     case BrushBehavior::BinaryOp::kMax:
       return "kMax";
+    case BrushBehavior::BinaryOp::kAndThen:
+      return "kAndThen";
+    case BrushBehavior::BinaryOp::kOrElse:
+      return "kOrElse";
+    case BrushBehavior::BinaryOp::kXorElse:
+      return "kXorElse";
   }
   return absl::StrCat("BinaryOp(", static_cast<int>(operation), ")");
 }

ink/brush/brush_behavior.h

@@ -407,6 +407,9 @@ struct BrushBehavior {
     kSum,      // A + B
     kMin,      // min(A, B)
     kMax,      // max(A, B)
+    kAndThen,  // returns null if A is null, otherwise returns B
+    kOrElse,   // returns A if A isn't null, otherwise returns B
+    kXorElse,  // if exactly one input isn't null, returns it, otherwise null
   };
   // LINT.ThenChange(
   //   fuzz_domains.cc:binary_op,

ink/brush/brush_behavior_test.cc

@@ -231,6 +231,9 @@ TEST(BrushBehaviorTest, StringifyBinaryOp) {
   EXPECT_EQ(absl::StrCat(BrushBehavior::BinaryOp::kSum), "kSum");
   EXPECT_EQ(absl::StrCat(BrushBehavior::BinaryOp::kMin), "kMin");
   EXPECT_EQ(absl::StrCat(BrushBehavior::BinaryOp::kMax), "kMax");
+  EXPECT_EQ(absl::StrCat(BrushBehavior::BinaryOp::kAndThen), "kAndThen");
+  EXPECT_EQ(absl::StrCat(BrushBehavior::BinaryOp::kOrElse), "kOrElse");
+  EXPECT_EQ(absl::StrCat(BrushBehavior::BinaryOp::kXorElse), "kXorElse");
   EXPECT_EQ(absl::StrCat(static_cast<BrushBehavior::BinaryOp>(147)),
             "BinaryOp(147)");
 }

ink/brush/fuzz_domains.cc

@@ -130,6 +130,9 @@ Domain<BrushBehavior::BinaryOp> ArbitraryBrushBehaviorBinaryOp() {
       BrushBehavior::BinaryOp::kSum,
       BrushBehavior::BinaryOp::kMin,
       BrushBehavior::BinaryOp::kMax,
+      BrushBehavior::BinaryOp::kAndThen,
+      BrushBehavior::BinaryOp::kOrElse,
+      BrushBehavior::BinaryOp::kXorElse,
   });
 }
 // LINT.ThenChange(brush_behavior.h:binary_op)

ink/storage/brush.cc

@@ -61,6 +61,12 @@ proto::BrushBehavior::BinaryOp EncodeBrushBehaviorBinaryOp(
       return proto::BrushBehavior::BINARY_OP_MIN;
     case BrushBehavior::BinaryOp::kMax:
       return proto::BrushBehavior::BINARY_OP_MAX;
+    case BrushBehavior::BinaryOp::kAndThen:
+      return proto::BrushBehavior::BINARY_OP_AND_THEN;
+    case BrushBehavior::BinaryOp::kOrElse:
+      return proto::BrushBehavior::BINARY_OP_OR_ELSE;
+    case BrushBehavior::BinaryOp::kXorElse:
+      return proto::BrushBehavior::BINARY_OP_XOR_ELSE;
   }
   return proto::BrushBehavior::BINARY_OP_UNSPECIFIED;
 }
@@ -76,6 +82,12 @@ absl::StatusOr<BrushBehavior::BinaryOp> DecodeBrushBehaviorBinaryOp(
       return BrushBehavior::BinaryOp::kMin;
     case proto::BrushBehavior::BINARY_OP_MAX:
       return BrushBehavior::BinaryOp::kMax;
+    case proto::BrushBehavior::BINARY_OP_AND_THEN:
+      return BrushBehavior::BinaryOp::kAndThen;
+    case proto::BrushBehavior::BINARY_OP_OR_ELSE:
+      return BrushBehavior::BinaryOp::kOrElse;
+    case proto::BrushBehavior::BINARY_OP_XOR_ELSE:
+      return BrushBehavior::BinaryOp::kXorElse;
     default:
       return absl::InvalidArgumentError(absl::StrCat(
           "invalid ink.proto.BrushBehavior.BinaryOp value: ", binary_op_proto));

ink/storage/proto/brush_family.proto

@@ -945,6 +945,15 @@ message BrushBehavior {
 
     // max(A, B), or null if either is null
     BINARY_OP_MAX = 4;
+
+    // null if A is null, or B otherwise
+    BINARY_OP_AND_THEN = 5;
+
+    // A if A isn't null, or B otherwise
+    BINARY_OP_OR_ELSE = 6;
+
+    // A if B is null, or B if A is null, or null if neither is null
+    BINARY_OP_XOR_ELSE = 7;
   }
   // LINT.ThenChange(../../brush/brush_behavior.h:binary_op)
 

ink/strokes/internal/brush_tip_modeler_helpers.cc

@@ -480,11 +480,25 @@ void ProcessBehaviorNodeImpl(const BrushBehavior::BinaryOpNode& node,
   context.stack.pop_back();
   float first_input = context.stack.back();
   float* result = &context.stack.back();
-  if (IsNullBehaviorNodeValue(first_input) ||
-      IsNullBehaviorNodeValue(second_input)) {
-    *result = kNullBehaviorNodeValue;
-    return;
+
+  // Some operations always return null if either input is null.
+  switch (node.operation) {
+    case BrushBehavior::BinaryOp::kProduct:
+    case BrushBehavior::BinaryOp::kSum:
+    case BrushBehavior::BinaryOp::kMin:
+    case BrushBehavior::BinaryOp::kMax:
+    case BrushBehavior::BinaryOp::kAndThen:
+      if (IsNullBehaviorNodeValue(first_input) ||
+          IsNullBehaviorNodeValue(second_input)) {
+        *result = kNullBehaviorNodeValue;
+        return;
+      }
+      break;
+    case BrushBehavior::BinaryOp::kOrElse:
+    case BrushBehavior::BinaryOp::kXorElse:
+      break;
   }
+
   switch (node.operation) {
     case BrushBehavior::BinaryOp::kProduct:
       *result = first_input * second_input;
@@ -498,7 +512,21 @@ void ProcessBehaviorNodeImpl(const BrushBehavior::BinaryOpNode& node,
     case BrushBehavior::BinaryOp::kMax:
       *result = std::max(first_input, second_input);
       break;
+    case BrushBehavior::BinaryOp::kAndThen:
+      *result = second_input;
+      break;
+    case BrushBehavior::BinaryOp::kOrElse:
+      *result =
+          IsNullBehaviorNodeValue(first_input) ? second_input : first_input;
+      break;
+    case BrushBehavior::BinaryOp::kXorElse:
+      *result = IsNullBehaviorNodeValue(first_input) ? second_input
+                : IsNullBehaviorNodeValue(second_input)
+                    ? first_input
+                    : kNullBehaviorNodeValue;
+      break;
   }
+
   // If any of the above operations resulted in a non-finite value
   // (e.g. overflow to infinity), treat the result as null.
   if (!std::isfinite(*result)) {

ink/strokes/internal/brush_tip_modeler_helpers_test.cc

@@ -1346,6 +1346,98 @@ TEST_F(ProcessBehaviorNodeTest, BinaryOpNodeMax) {
   EXPECT_THAT(stack_, ElementsAre(NullNodeValueMatcher()));
 }
 
+TEST_F(ProcessBehaviorNodeTest, BinaryOpNodeAndThen) {
+  BrushBehavior::BinaryOpNode binary_op_node = {
+      .operation = BrushBehavior::BinaryOp::kAndThen};
+
+  // `kAndThen` returns the second input as long as the first input isn't null.
+  stack_.push_back(2.0f);
+  stack_.push_back(7.0f);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(7.0f));
+
+  stack_.clear();
+  stack_.push_back(2.0f);
+  stack_.push_back(kNullBehaviorNodeValue);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(NullNodeValueMatcher()));
+
+  // If the first input is null, `kAndThen` always returns null.
+  stack_.clear();
+  stack_.push_back(kNullBehaviorNodeValue);
+  stack_.push_back(7.0f);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(NullNodeValueMatcher()));
+
+  stack_.clear();
+  stack_.push_back(kNullBehaviorNodeValue);
+  stack_.push_back(kNullBehaviorNodeValue);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(NullNodeValueMatcher()));
+}
+
+TEST_F(ProcessBehaviorNodeTest, BinaryOpNodeOrElse) {
+  BrushBehavior::BinaryOpNode binary_op_node = {
+      .operation = BrushBehavior::BinaryOp::kOrElse};
+
+  // `kOrElse` returns the first input as long as it isn't null.
+  stack_.push_back(2.0f);
+  stack_.push_back(7.0f);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(2.0f));
+
+  stack_.clear();
+  stack_.push_back(2.0f);
+  stack_.push_back(kNullBehaviorNodeValue);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(2.0f));
+
+  // If the first input is null, `kOrElse` returns the second input.
+  stack_.clear();
+  stack_.push_back(kNullBehaviorNodeValue);
+  stack_.push_back(7.0f);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(7.0f));
+
+  stack_.clear();
+  stack_.push_back(kNullBehaviorNodeValue);
+  stack_.push_back(kNullBehaviorNodeValue);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(NullNodeValueMatcher()));
+}
+
+TEST_F(ProcessBehaviorNodeTest, BinaryOpNodeXorElse) {
+  BrushBehavior::BinaryOpNode binary_op_node = {
+      .operation = BrushBehavior::BinaryOp::kXorElse};
+
+  // If neither input is null, `kXorElse` returns null.
+  stack_.push_back(2.0f);
+  stack_.push_back(7.0f);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(NullNodeValueMatcher()));
+
+  // If only the first input is null, `kXorElse` returns the second input.
+  stack_.clear();
+  stack_.push_back(kNullBehaviorNodeValue);
+  stack_.push_back(7.0f);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(7.0f));
+
+  // If only the second input is null, `kXorElse` returns the first input.
+  stack_.clear();
+  stack_.push_back(2.0f);
+  stack_.push_back(kNullBehaviorNodeValue);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(2.0f));
+
+  // If both inputs are null, `kXorElse` returns null.
+  stack_.clear();
+  stack_.push_back(kNullBehaviorNodeValue);
+  stack_.push_back(kNullBehaviorNodeValue);
+  ProcessBehaviorNode(binary_op_node, context_);
+  EXPECT_THAT(stack_, ElementsAre(NullNodeValueMatcher()));
+}
+
 TEST_F(ProcessBehaviorNodeTest, InterpolationNodeLerp) {
   BrushBehavior::InterpolationNode interpolation_node = {
       .interpolation = BrushBehavior::Interpolation::kLerp,