google · copybara-service · Mar 3, 2026
diff --git a/ink/brush/BUILD.bazel b/ink/brush/BUILD.bazel
@@ -279,6 +279,7 @@ cc_library(
     deps = [
         ":easing_function",
         ":version",
+        "//ink/strokes/input:stroke_input",
         "@abseil-cpp//absl/status",
         "@abseil-cpp//absl/status:status_macros",
         "@abseil-cpp//absl/strings",

diff --git a/ink/brush/brush_behavior.cc b/ink/brush/brush_behavior.cc
@@ -28,6 +28,7 @@
 #include "absl/strings/str_join.h"
 #include "ink/brush/easing_function.h"
 #include "ink/brush/version.h"
+#include "ink/strokes/input/stroke_input.h"
 
 namespace ink {
 
@@ -448,8 +449,6 @@ absl::Status ValidateBrushBehavior(const BrushBehavior& behavior) {
   return absl::OkStatus();
 }
 
-namespace {
-
 Version CalculateMinimumRequiredVersion(BrushBehavior::Source source) {
   switch (source) {
     case BrushBehavior::Source::kNormalizedPressure:
@@ -550,11 +549,6 @@ Version CalculateMinimumRequiredVersion(
   return Version::kDevelopment();
 }
 
-Version CalculateMinimumRequiredVersion(
-    BrushBehavior::EnabledToolTypes enabled) {
-  return Version::k0Jetpack1_0_0();
-}
-
 Version CalculateMinimumRequiredVersion(BrushBehavior::BinaryOp operation) {
   switch (operation) {
     case BrushBehavior::BinaryOp::kProduct:
@@ -591,6 +585,10 @@ Version CalculateMinimumRequiredVersion(
   return Version::kDevelopment();
 }
 
+namespace {
+
+using ::ink::brush_internal::CalculateMinimumRequiredVersion;
+
 Version CalculateMinimumRequiredVersion(BrushBehavior::SourceNode node) {
   return std::max(
       CalculateMinimumRequiredVersion(node.source_out_of_range_behavior),
@@ -605,6 +603,24 @@ Version CalculateMinimumRequiredVersion(BrushBehavior::NoiseNode node) {
   return CalculateMinimumRequiredVersion(node.vary_over);
 }
 
+Version CalculateMinimumRequiredVersion(
+    BrushBehavior::EnabledToolTypes enabled) {
+  return std::max({
+      enabled.unknown
+          ? CalculateMinimumRequiredVersion(StrokeInput::ToolType::kUnknown)
+          : Version::k0Jetpack1_0_0(),
+      enabled.mouse
+          ? CalculateMinimumRequiredVersion(StrokeInput::ToolType::kMouse)
+          : Version::k0Jetpack1_0_0(),
+      enabled.touch
+          ? CalculateMinimumRequiredVersion(StrokeInput::ToolType::kTouch)
+          : Version::k0Jetpack1_0_0(),
+      enabled.stylus
+          ? CalculateMinimumRequiredVersion(StrokeInput::ToolType::kStylus)
+          : Version::k0Jetpack1_0_0(),
+  });
+}
+
 Version CalculateMinimumRequiredVersion(
     BrushBehavior::ToolTypeFilterNode node) {
   return CalculateMinimumRequiredVersion(node.enabled_tool_types);
@@ -615,7 +631,7 @@ Version CalculateMinimumRequiredVersion(BrushBehavior::DampingNode node) {
 }
 
 Version CalculateMinimumRequiredVersion(BrushBehavior::ResponseNode node) {
-  return brush_internal::CalculateMinimumRequiredVersion(node.response_curve);
+  return CalculateMinimumRequiredVersion(node.response_curve);
 }
 
 Version CalculateMinimumRequiredVersion(BrushBehavior::IntegralNode node) {
@@ -641,14 +657,14 @@ Version CalculateMinimumRequiredVersion(BrushBehavior::PolarTargetNode node) {
   return CalculateMinimumRequiredVersion(node.target);
 }
 
+}  // namespace
+
 Version CalculateMinimumRequiredVersion(const BrushBehavior::Node& node) {
   return std::visit(
       [](const auto& node) { return CalculateMinimumRequiredVersion(node); },
       node);
 }
 
-}  // namespace
-
 Version CalculateMinimumRequiredVersion(const BrushBehavior& behavior) {
   Version max_version = Version::k0Jetpack1_0_0();
   for (const auto& node : behavior.nodes) {

diff --git a/ink/brush/brush_behavior.h b/ink/brush/brush_behavior.h
@@ -759,6 +759,16 @@ absl::Status ValidateBrushBehaviorNode(const BrushBehavior::Node& node);
 
 // Calculates the minimum version of the Ink library that is required to use
 // this brush behavior.
+Version CalculateMinimumRequiredVersion(BrushBehavior::Source source);
+Version CalculateMinimumRequiredVersion(BrushBehavior::Target target);
+Version CalculateMinimumRequiredVersion(BrushBehavior::PolarTarget target);
+Version CalculateMinimumRequiredVersion(BrushBehavior::OutOfRange out_of_range);
+Version CalculateMinimumRequiredVersion(BrushBehavior::BinaryOp operation);
+Version CalculateMinimumRequiredVersion(
+    BrushBehavior::ProgressDomain progress_domain);
+Version CalculateMinimumRequiredVersion(
+    BrushBehavior::Interpolation interpolation);
+Version CalculateMinimumRequiredVersion(const BrushBehavior::Node& node);
 Version CalculateMinimumRequiredVersion(const BrushBehavior& behavior);
 
 std::string ToFormattedString(BrushBehavior::Source source);

diff --git a/ink/brush/brush_family.cc b/ink/brush/brush_family.cc
@@ -142,7 +142,8 @@ std::string BrushFamily::ToFormattedString() const {
 }
 
 Version BrushFamily::CalculateMinimumRequiredVersion() const {
-  Version max_version = Version::k0Jetpack1_0_0();
+  Version max_version =
+      brush_internal::CalculateMinimumRequiredVersion(input_model_);
   for (const auto& coat : coats_) {
     max_version = std::max(
         max_version, brush_internal::CalculateMinimumRequiredVersion(coat));
@@ -192,6 +193,10 @@ absl::Status ValidateInputModel(const BrushFamily::InputModel& model) {
                     model);
 }
 
+Version CalculateMinimumRequiredVersion(const BrushFamily::InputModel& model) {
+  return Version::k0Jetpack1_0_0();
+}
+
 std::string ToFormattedString(const BrushFamily::InputModel& model) {
   return std::visit([](const auto& model) { return ToFormattedString(model); },
                     model);

diff --git a/ink/brush/brush_family.h b/ink/brush/brush_family.h
@@ -224,6 +224,8 @@ namespace brush_internal {
 
 absl::Status ValidateInputModel(const BrushFamily::InputModel& model);
 
+Version CalculateMinimumRequiredVersion(const BrushFamily::InputModel& model);
+
 std::string ToFormattedString(const BrushFamily::InputModel& model);
 
 }  // namespace brush_internal

diff --git a/ink/brush/brush_paint.cc b/ink/brush/brush_paint.cc
@@ -303,8 +303,6 @@ absl::Status ValidateBrushPaint(const BrushPaint& paint) {
   return absl::OkStatus();
 }
 
-namespace {
-
 Version CalculateMinimumRequiredVersion(
     BrushPaint::TextureOrigin texture_origin) {
   switch (texture_origin) {
@@ -365,6 +363,10 @@ Version CalculateMinimumRequiredVersion(BrushPaint::SelfOverlap self_overlap) {
   return Version::kDevelopment();
 }
 
+namespace {
+
+using ::ink::brush_internal::CalculateMinimumRequiredVersion;
+
 Version CalculateMinimumRequiredVersion(
     const BrushPaint::TilingTexture& layer) {
   return std::max({CalculateMinimumRequiredVersion(layer.origin),
@@ -389,14 +391,14 @@ Version CalculateMinimumRequiredVersion(
   return CalculateMinimumRequiredVersion(layer.blend_mode);
 }
 
+}  // namespace
+
 Version CalculateMinimumRequiredVersion(const BrushPaint::TextureLayer& layer) {
   return std::visit(
       [](const auto& layer) { return CalculateMinimumRequiredVersion(layer); },
       layer);
 }
 
-}  // namespace
-
 Version CalculateMinimumRequiredVersion(const BrushPaint& paint) {
   Version max_version = CalculateMinimumRequiredVersion(paint.self_overlap);
   for (const BrushPaint::TextureLayer& layer : paint.texture_layers) {

diff --git a/ink/brush/brush_paint.h b/ink/brush/brush_paint.h
@@ -334,6 +334,14 @@ absl::Status ValidateBrushPaintTextureLayer(
 // Calculates the minimum version of the Ink library that is required to use
 // this brush paint.
 Version CalculateMinimumRequiredVersion(const BrushPaint& paint);
+Version CalculateMinimumRequiredVersion(
+    BrushPaint::TextureOrigin texture_origin);
+Version CalculateMinimumRequiredVersion(
+    BrushPaint::TextureSizeUnit texture_size_unit);
+Version CalculateMinimumRequiredVersion(BrushPaint::TextureWrap texture_wrap);
+Version CalculateMinimumRequiredVersion(BrushPaint::BlendMode blend_mode);
+Version CalculateMinimumRequiredVersion(BrushPaint::SelfOverlap self_overlap);
+Version CalculateMinimumRequiredVersion(const BrushPaint::TextureLayer& layer);
 
 // Adds the mesh attribute IDs that are required to properly render a mesh
 // with this brush paint to the given `attribute_ids` set. Note that other

diff --git a/ink/brush/easing_function.cc b/ink/brush/easing_function.cc
@@ -170,6 +170,19 @@ Version CalculateMinimumRequiredVersion(const EasingFunction::Linear& linear) {
   return Version::k0Jetpack1_0_0();
 }
 
+Version CalculateMinimumRequiredVersion(const EasingFunction::Steps& steps) {
+  return brush_internal::CalculateMinimumRequiredVersion(steps.step_position);
+}
+
+Version CalculateMinimumRequiredVersion(
+    const EasingFunction::Parameters& parameters) {
+  return std::visit(
+      [](auto&& params) { return CalculateMinimumRequiredVersion(params); },
+      parameters);
+}
+
+}  // namespace
+
 Version CalculateMinimumRequiredVersion(
     EasingFunction::StepPosition step_position) {
   switch (step_position) {
@@ -182,18 +195,6 @@ Version CalculateMinimumRequiredVersion(
   return Version::kDevelopment();
 }
 
-Version CalculateMinimumRequiredVersion(const EasingFunction::Steps& steps) {
-  return CalculateMinimumRequiredVersion(steps.step_position);
-}
-
-Version CalculateMinimumRequiredVersion(
-    const EasingFunction::Parameters& parameters) {
-  return std::visit(
-      [](auto&& params) { return CalculateMinimumRequiredVersion(params); },
-      parameters);
-}
-}  // namespace
-
 Version CalculateMinimumRequiredVersion(const EasingFunction& easing_function) {
   return CalculateMinimumRequiredVersion(easing_function.parameters);
 }

diff --git a/ink/brush/easing_function.h b/ink/brush/easing_function.h
@@ -192,6 +192,8 @@ absl::Status ValidateEasingFunction(const EasingFunction& easing_function);
 // Calculates the minimum version of the Ink library that is required to use
 // this easing function.
 Version CalculateMinimumRequiredVersion(const EasingFunction& easing_function);
+Version CalculateMinimumRequiredVersion(
+    EasingFunction::StepPosition step_position);
 
 std::string ToFormattedString(const EasingFunction& easing_function);
 std::string ToFormattedString(EasingFunction::Predefined predefined);

diff --git a/ink/brush/internal/jni/BUILD.bazel b/ink/brush/internal/jni/BUILD.bazel
@@ -30,6 +30,8 @@ cc_library(
         ":brush_paint_jni",
         ":brush_tip_jni",
         ":easing_function_jni",
+        ":input_tool_type_jni",
+        ":self_overlap_jni",
         ":stock_brushes_jni",
     ],
 )
@@ -50,6 +52,8 @@ cc_library(
         ":brush_paint_native",
         ":brush_tip_native",
         ":easing_function_native",
+        ":input_tool_type_native",
+        ":self_overlap_native",
         ":stock_brushes_native",
     ],
 )
@@ -408,3 +412,55 @@ cc_library(
         "@abseil-cpp//absl/status",
     ],
 )
+
+cc_library(
+    name = "input_tool_type_native",
+    srcs = ["input_tool_type_native.cc"],
+    hdrs = ["input_tool_type_native.h"],
+    deps = [
+        "//ink/brush:version",
+        "//ink/strokes/input:stroke_input",
+    ],
+)
+
+cc_library(
+    name = "input_tool_type_jni",
+    srcs = ["input_tool_type_jni.cc"],
+    tags = ["keep_dep"],
+    deps = [
+        ":input_tool_type_native",
+        "//ink/jni/internal:jni_defines",
+    ] + select({
+        "@platforms//os:android": [],
+        "//conditions:default": [
+            "@rules_jni//jni",
+        ],
+    }),
+    alwayslink = 1,
+)
+
+cc_library(
+    name = "self_overlap_native",
+    srcs = ["self_overlap_native.cc"],
+    hdrs = ["self_overlap_native.h"],
+    deps = [
+        "//ink/brush:brush_paint",
+        "//ink/brush:version",
+    ],
+)
+
+cc_library(
+    name = "self_overlap_jni",
+    srcs = ["self_overlap_jni.cc"],
+    tags = ["keep_dep"],
+    deps = [
+        ":self_overlap_native",
+        "//ink/jni/internal:jni_defines",
+    ] + select({
+        "@platforms//os:android": [],
+        "//conditions:default": [
+            "@rules_jni//jni",
+        ],
+    }),
+    alwayslink = 1,
+)
diff --git a/ink/brush/internal/jni/brush_behavior_jni.cc b/ink/brush/internal/jni/brush_behavior_jni.cc
@@ -82,4 +82,9 @@ JNI_METHOD(brush, BrushBehaviorNative, jlong, newCopyOfNode)
   return BrushBehaviorNative_newCopyOfNode(native_pointer, index);
 }
 
+JNI_METHOD(brush, BrushBehaviorNative, jint, calculateMinimumRequiredVersion)
+(JNIEnv* env, jobject thiz, jlong native_pointer) {
+  return BrushBehaviorNative_calculateMinimumRequiredVersion(native_pointer);
+}
+
 }  // extern "C"
diff --git a/ink/brush/internal/jni/brush_behavior_native.cc b/ink/brush/internal/jni/brush_behavior_native.cc
@@ -27,6 +27,7 @@
 
 namespace {
 using ::ink::BrushBehavior;
+using ::ink::brush_internal::CalculateMinimumRequiredVersion;
 using ::ink::brush_internal::ValidateBrushBehaviorTopLevel;
 using ::ink::native::CastToBrushBehavior;
 using ::ink::native::CastToBrushBehaviorNode;
@@ -107,4 +108,9 @@ int64_t BrushBehaviorNative_newCopyOfNode(int64_t native_ptr, int index) {
       CastToBrushBehavior(native_ptr).nodes[index]);
 }
 
+int BrushBehaviorNative_calculateMinimumRequiredVersion(int64_t native_ptr) {
+  return CalculateMinimumRequiredVersion(CastToBrushBehavior(native_ptr))
+      .value();
+}
+
 }  // extern "C"
diff --git a/ink/brush/internal/jni/brush_behavior_native.h b/ink/brush/internal/jni/brush_behavior_native.h
@@ -37,6 +37,8 @@ const char* BrushBehaviorNative_getDeveloperComment(int64_t native_ptr);
 
 int64_t BrushBehaviorNative_newCopyOfNode(int64_t native_ptr, int index);
 
+int BrushBehaviorNative_calculateMinimumRequiredVersion(int64_t native_ptr);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif