Add ColorFunction class

PiperOrigin-RevId: 796435459

Author: Ink Open Source

ink/brush/BUILD.bazel

@@ -31,6 +31,7 @@ cc_library(
         ":brush_family",
         ":brush_paint",
         ":brush_tip",
+        ":color_function",
         ":easing_function",
         "//:gtest_for_library_testonly",
         "//ink/geometry:type_matchers",
@@ -175,6 +176,32 @@ cc_test(
     ],
 )
 
+cc_library(
+    name = "color_function",
+    srcs = ["color_function.cc"],
+    hdrs = ["color_function.h"],
+    deps = [
+        "//ink/color",
+        "@com_google_absl//absl/status",
+        "@com_google_absl//absl/strings",
+    ],
+)
+
+cc_test(
+    name = "color_function_test",
+    srcs = ["color_function_test.cc"],
+    deps = [
+        ":color_function",
+        ":fuzz_domains",
+        "//ink/color",
+        "@com_google_absl//absl/status",
+        "@com_google_absl//absl/status:status_matchers",
+        "@com_google_absl//absl/strings",
+        "@com_google_fuzztest//fuzztest",
+        "@com_google_fuzztest//fuzztest:fuzztest_gtest_main",
+    ],
+)
+
 cc_library(
     name = "easing_function",
     srcs = ["easing_function.cc"],
@@ -233,6 +260,7 @@ cc_library(
     srcs = ["brush_paint.cc"],
     hdrs = ["brush_paint.h"],
     deps = [
+        ":color_function",
         "//ink/geometry:angle",
         "//ink/geometry:vec",
         "@com_google_absl//absl/status",
@@ -247,7 +275,9 @@ cc_test(
     srcs = ["brush_paint_test.cc"],
     deps = [
         ":brush_paint",
+        ":color_function",
         ":fuzz_domains",
+        "//ink/color",
         "//ink/geometry:angle",
         "//ink/geometry:vec",
         "@com_google_absl//absl/hash:hash_testing",
@@ -272,6 +302,7 @@ cc_library(
         ":brush_family",
         ":brush_paint",
         ":brush_tip",
+        ":color_function",
         ":easing_function",
         "//ink/color",
         "//ink/color:fuzz_domains",

ink/brush/brush_coat_test.cc

@@ -41,7 +41,7 @@ constexpr absl::string_view kTestTextureId = "test-paint";
 TEST(BrushCoatTest, Stringify) {
   EXPECT_EQ(absl::StrCat(BrushCoat{.tip = BrushTip{}}),
             "BrushCoat{tip=BrushTip{scale=<1, 1>, corner_rounding=1}, "
-            "paint=BrushPaint{texture_layers={}}}");
+            "paint=BrushPaint{}}");
 }
 
 TEST(BrushCoatTest, CoatWithDefaultTipAndPaintIsValid) {

ink/brush/brush_paint.cc

@@ -22,6 +22,7 @@
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/time/time.h"
+#include "ink/brush/color_function.h"
 
 namespace ink {
 namespace brush_internal {
@@ -309,6 +310,12 @@ absl::Status ValidateBrushPaint(const BrushPaint& paint) {
       return status;
     }
   }
+  for (const ColorFunction& color_function : paint.color_functions) {
+    if (absl::Status status = ValidateColorFunction(color_function);
+        !status.ok()) {
+      return status;
+    }
+  }
   if (absl::Status status = ValidateBrushPaintTopLevel(paint); !status.ok()) {
     return status;
   }
@@ -436,10 +443,19 @@ std::string ToFormattedString(const BrushPaint::TextureLayer& texture_layer) {
 }
 
 std::string ToFormattedString(const BrushPaint& paint) {
-  std::string formatted =
-      absl::StrCat("BrushPaint{texture_layers={",
-                   absl::StrJoin(paint.texture_layers, ", "), "}}");
-
+  std::string formatted = "BrushPaint{";
+  if (!paint.texture_layers.empty()) {
+    absl::StrAppend(&formatted, "texture_layers={",
+                    absl::StrJoin(paint.texture_layers, ", "), "}");
+  }
+  if (!paint.color_functions.empty()) {
+    if (!paint.texture_layers.empty()) {
+      absl::StrAppend(&formatted, ", ");
+    }
+    absl::StrAppend(&formatted, "color_functions={",
+                    absl::StrJoin(paint.color_functions, ", "), "}");
+  }
+  absl::StrAppend(&formatted, "}");
   return formatted;
 }
 

ink/brush/brush_paint.h

@@ -21,6 +21,7 @@
 
 #include "absl/status/status.h"
 #include "absl/time/time.h"
+#include "ink/brush/color_function.h"
 #include "ink/geometry/angle.h"
 #include "ink/geometry/vec.h"
 
@@ -299,6 +300,10 @@ struct BrushPaint {
   };
 
   std::vector<TextureLayer> texture_layers;
+  // Transformations to apply to the base brush color (in order) before drawing
+  // this coat of paint. When this list is empty, the base brush color will be
+  // used unchanged.
+  std::vector<ColorFunction> color_functions;
 };
 
 bool operator==(const BrushPaint::TextureKeyframe& lhs,
@@ -395,7 +400,7 @@ H AbslHashValue(H h, const BrushPaint::TextureLayer& layer) {
 
 template <typename H>
 H AbslHashValue(H h, const BrushPaint& paint) {
-  return H::combine(std::move(h), paint.texture_layers);
+  return H::combine(std::move(h), paint.texture_layers, paint.color_functions);
 }
 
 inline bool operator!=(const BrushPaint::TextureKeyframe& lhs,
@@ -409,7 +414,8 @@ inline bool operator!=(const BrushPaint::TextureLayer& lhs,
 }
 
 inline bool operator==(const BrushPaint& lhs, const BrushPaint& rhs) {
-  return lhs.texture_layers == rhs.texture_layers;
+  return lhs.texture_layers == rhs.texture_layers &&
+         lhs.color_functions == rhs.color_functions;
 }
 
 inline bool operator!=(const BrushPaint& lhs, const BrushPaint& rhs) {

ink/brush/brush_paint_test.cc

@@ -27,7 +27,9 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/time.h"
+#include "ink/brush/color_function.h"
 #include "ink/brush/fuzz_domains.h"
+#include "ink/color/color.h"
 #include "ink/geometry/angle.h"
 #include "ink/geometry/vec.h"
 
@@ -94,8 +96,16 @@ TEST(BrushPaintTest, BrushPaintSupportsAbslHash) {
   std::string id2 = "bar";
   EXPECT_TRUE(absl::VerifyTypeImplementsAbslHashCorrectly({
       BrushPaint{},
-      BrushPaint{{{.client_texture_id = id1}}},
-      BrushPaint{{{.client_texture_id = id1}, {.client_texture_id = id2}}},
+      BrushPaint{.texture_layers = {{.client_texture_id = id1}}},
+      BrushPaint{.texture_layers = {{.client_texture_id = id2}}},
+      BrushPaint{.texture_layers = {{.client_texture_id = id1},
+                                    {.client_texture_id = id2}}},
+      BrushPaint{.color_functions = {{ColorFunction::OpacityMultiplier{0.5}}}},
+      BrushPaint{
+          .color_functions = {{ColorFunction::ReplaceColor{Color::Red()}}}},
+      BrushPaint{
+          .texture_layers = {{.client_texture_id = id1}},
+          .color_functions = {{ColorFunction::ReplaceColor{Color::Red()}}}},
   }));
 }
 
@@ -417,7 +427,7 @@ TEST(BrushPaintTest, StringifyTextureLayer) {
 }
 
 TEST(BrushPaintTest, StringifyBrushPaint) {
-  EXPECT_EQ(absl::StrCat(BrushPaint{}), "BrushPaint{texture_layers={}}");
+  EXPECT_EQ(absl::StrCat(BrushPaint{}), "BrushPaint{}");
   EXPECT_EQ(
       absl::StrCat(BrushPaint{.texture_layers = {{}}}),
       "BrushPaint{texture_layers={TextureLayer{client_texture_id=, "
@@ -628,6 +638,21 @@ TEST(BrushPaintTest, StringifyBrushPaint) {
       "keyframes={TextureKeyframe{progress=0.2, size=<2, 5>, rotation=0.125π}, "
       "TextureKeyframe{progress=0.4, offset=<2, 0.2>, opacity=0.4}}, "
       "blend_mode=kDstIn}}}");
+  EXPECT_EQ(absl::StrCat(BrushPaint{
+                .color_functions = {{ColorFunction::OpacityMultiplier{0.5}}}}),
+            "BrushPaint{color_functions={OpacityMultiplier{0.5}}}");
+  EXPECT_EQ(absl::StrCat(BrushPaint{
+                .texture_layers = {{.client_texture_id =
+                                        std::string(kTestTextureId)}},
+                .color_functions = {{ColorFunction::OpacityMultiplier{0.5}}}}),
+            "BrushPaint{texture_layers={TextureLayer{client_texture_id=test-"
+            "texture, mapping=kTiling, origin=kStrokeSpaceOrigin, "
+            "size_unit=kStrokeCoordinates, wrap_x=kRepeat, wrap_y=kRepeat, "
+            "size=<1, 1>, offset=<0, 0>, rotation=0π, size_jitter=<0, 0>, "
+            "offset_jitter=<0, 0>, rotation_jitter=0π, opacity=1, "
+            "animation_frames=1, animation_rows=1, animation_columns=1, "
+            "animation_duration=1s, keyframes={}, blend_mode=kModulate}}, "
+            "color_functions={OpacityMultiplier{0.5}}}");
 }
 
 TEST(BrushPaintTest, InvalidTextureLayerRotation) {

ink/brush/color_function.cc

@@ -0,0 +1,100 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "ink/brush/color_function.h"
+
+#include <cmath>
+#include <string>
+#include <variant>
+
+#include "absl/status/status.h"
+#include "absl/strings/str_cat.h"
+
+namespace ink {
+
+bool ColorFunction::operator==(const ColorFunction& other) const {
+  return parameters == other.parameters;
+}
+
+bool ColorFunction::operator!=(const ColorFunction& other) const {
+  return !(*this == other);
+}
+
+bool ColorFunction::OpacityMultiplier::operator==(
+    const OpacityMultiplier& other) const {
+  return multiplier == other.multiplier;
+}
+
+bool ColorFunction::OpacityMultiplier::operator!=(
+    const ColorFunction::OpacityMultiplier& other) const {
+  return !(*this == other);
+}
+
+bool ColorFunction::ReplaceColor::operator==(const ReplaceColor& other) const {
+  return color == other.color;
+}
+
+bool ColorFunction::ReplaceColor::operator!=(
+    const ColorFunction::ReplaceColor& other) const {
+  return !(*this == other);
+}
+
+namespace brush_internal {
+namespace {
+
+absl::Status ValidateColorFunctionParameters(
+    const ColorFunction::OpacityMultiplier& opacity) {
+  if (!std::isfinite(opacity.multiplier) || opacity.multiplier < 0) {
+    return absl::InvalidArgumentError(
+        absl::StrCat("`ColorFunction::OpacityMultiplier::multiplier` must be "
+                     "finite and non-negative, got: ",
+                     opacity.multiplier));
+  }
+  return absl::OkStatus();
+}
+
+absl::Status ValidateColorFunctionParameters(
+    const ColorFunction::ReplaceColor& replace) {
+  return absl::OkStatus();
+}
+
+}  // namespace
+
+absl::Status ValidateColorFunction(const ColorFunction& color_function) {
+  return std::visit(
+      [](const auto& params) {
+        return ValidateColorFunctionParameters(params);
+      },
+      color_function.parameters);
+}
+
+std::string ToFormattedString(const ColorFunction& color_function) {
+  return ToFormattedString(color_function.parameters);
+}
+
+std::string ToFormattedString(const ColorFunction::Parameters& parameters) {
+  return std::visit(
+      [](const auto& params) { return ToFormattedString(params); }, parameters);
+}
+
+std::string ToFormattedString(const ColorFunction::OpacityMultiplier& opacity) {
+  return absl::StrCat("OpacityMultiplier{", opacity.multiplier, "}");
+}
+
+std::string ToFormattedString(const ColorFunction::ReplaceColor& replace) {
+  return absl::StrCat("ReplaceColor{", replace.color, "}");
+}
+
+}  // namespace brush_internal
+}  // namespace ink