Add bindings for SkRuntimeShaderBuilder::child (#526)

For `SkShader` and `SkColorFilter` that can be passed as uniforms into the main SkSL shader

skiko/src/commonMain/kotlin/org/jetbrains/skia/RuntimeShaderBuilder.kt

@@ -3,7 +3,6 @@ package org.jetbrains.skia
 import org.jetbrains.skia.impl.*
 import org.jetbrains.skia.impl.Library.Companion.staticLoad
 import org.jetbrains.skia.impl.Managed
-import org.jetbrains.skia.impl.Native.Companion.NullPointer
 import org.jetbrains.skia.impl.NativePointer
 import org.jetbrains.skia.impl.Stats
 import org.jetbrains.skia.impl.interopScope
@@ -101,6 +100,20 @@ class RuntimeShaderBuilder internal constructor(ptr: NativePointer) : Managed(pt
             _nUniformFloatMatrix44(_ptr, toInterop(name), toInterop(value.mat))
         }
     }
+
+    fun child(name: String, shader: Shader) {
+        Stats.onNativeCall()
+        interopScope {
+            _nChildShader(_ptr, toInterop(name), getPtr(shader))
+        }
+    }
+
+    fun child(name: String, colorFilter: ColorFilter) {
+        Stats.onNativeCall()
+        interopScope {
+            _nChildColorFilter(_ptr, toInterop(name), getPtr(colorFilter))
+        }
+    }
 }
 
 @ExternalSymbolName("org_jetbrains_skia_RuntimeShaderBuilder__1nMakeFromRuntimeEffect")
@@ -141,3 +154,9 @@ private external fun _nUniformFloatMatrix33(builderPtr: NativePointer, uniformNa
 
 @ExternalSymbolName("org_jetbrains_skia_RuntimeShaderBuilder__1nUniformFloatMatrix44")
 private external fun _nUniformFloatMatrix44(builderPtr: NativePointer, uniformName: InteropPointer, uniformMatrix44: InteropPointer)
+
+@ExternalSymbolName("org_jetbrains_skia_RuntimeShaderBuilder__1nChildShader")
+private external fun _nChildShader(builderPtr: NativePointer, uniformName: InteropPointer, shaderPtr: NativePointer)
+
+@ExternalSymbolName("org_jetbrains_skia_RuntimeShaderBuilder__1nChildColorFilter")
+private external fun _nChildColorFilter(builderPtr: NativePointer, uniformName: InteropPointer, colorFilterPtr: NativePointer)

skiko/src/commonTest/kotlin/org/jetbrains/skia/ImageFilterTest.kt

@@ -534,6 +534,79 @@ class ImageFilterTest {
         )
     }
 
+    @Test
+    fun makeRuntimeShaderChildShader() = imageFilterTest {
+        // A simple Skia shader that applies a child shader on part of the input
+        val compositeSksl = """
+            uniform shader content;
+            uniform shader gradient;
+            uniform float cutoff;
+            
+            vec4 main(vec2 coord) {
+                vec4 c = content.eval(coord);
+                vec4 b = gradient.eval(coord);
+                if (coord.x > cutoff) {
+                    return vec4(1.0 * c.a, c.g * c.a, c.b * c.a, c.a);
+                } else {
+                    return vec4(b.r * c.a, b.g * c.a, b.b * c.a, c.a);
+                }
+            }
+            """
+
+        val compositeRuntimeEffect = RuntimeEffect.makeForShader(compositeSksl)
+        val compositeShaderBuilder = RuntimeShaderBuilder(compositeRuntimeEffect)
+        compositeShaderBuilder.uniform("cutoff", 100.0f)
+        compositeShaderBuilder.child(
+            "gradient",
+            Shader.Companion.makeLinearGradient(
+                x0 = 0.0f, y0 = 0.0f,
+                x1 = 200.0f, y1 = 0.0f,
+                colors = intArrayOf(Color.RED, Color.BLUE),
+                style = GradientStyle.DEFAULT
+            )
+        )
+
+        ImageFilter.makeRuntimeShader(
+            runtimeShaderBuilder = compositeShaderBuilder,
+            shaderName = "content",
+            input = null
+        )
+    }
+
+    @Test
+    fun makeRuntimeShaderChildColorFilter() = imageFilterTest {
+        // A simple Skia shader that applies a child color filter on part of the input
+        val compositeSksl = """
+            uniform shader content;
+            uniform colorFilter filter;
+            uniform float cutoff;
+            
+            vec4 main(vec2 coord) {
+                vec4 c = content.eval(coord);
+                vec4 b = filter.eval(c);
+                if (coord.x > cutoff) {
+                    return vec4(1.0 * c.a, c.g * c.a, c.b * c.a, c.a);
+                } else {
+                    return vec4(b.r * c.a, b.g * c.a, b.b * c.a, c.a);
+                }
+            }
+            """
+
+        val compositeRuntimeEffect = RuntimeEffect.makeForShader(compositeSksl)
+        val compositeShaderBuilder = RuntimeShaderBuilder(compositeRuntimeEffect)
+        compositeShaderBuilder.uniform("cutoff", 100.0f)
+        compositeShaderBuilder.child(
+            "filter",
+            ColorFilter.makeHighContrast(grayscale = false, mode = InversionMode.BRIGHTNESS, contrast = 0.7f)
+        )
+
+        ImageFilter.makeRuntimeShader(
+            runtimeShaderBuilder = compositeShaderBuilder,
+            shaderName = "content",
+            input = null
+        )
+    }
+
     @Test
     fun makeTile() = imageFilterTest {
         ImageFilter.makeTile(

skiko/src/jvmMain/cpp/common/RuntimeShaderBuilder.cc

@@ -107,3 +107,19 @@ Java_org_jetbrains_skia_RuntimeShaderBuilderKt__1nUniformFloatMatrix44
     std::unique_ptr<SkM44> matrix44 = skM44(env, uniformMatrix44);
     runtimeShaderBuilder->uniform(skString(env, uniformName).c_str()) = matrix44.get();
 }
+
+extern "C" JNIEXPORT void JNICALL
+Java_org_jetbrains_skia_RuntimeShaderBuilderKt__1nChildShader
+  (JNIEnv* env, jclass jclass, jlong builderPtr, jstring childName, jlong childShaderPtr) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = jlongToPtr<SkRuntimeShaderBuilder*>(builderPtr);
+    sk_sp<SkShader> shader = sk_ref_sp<SkShader>(reinterpret_cast<SkShader*>(static_cast<uintptr_t>(childShaderPtr)));
+    runtimeShaderBuilder->child(skString(env, childName).c_str()) = shader;
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_org_jetbrains_skia_RuntimeShaderBuilderKt__1nChildColorFilter
+  (JNIEnv* env, jclass jclass, jlong builderPtr, jstring childName, jlong childColorFilterPtr) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = jlongToPtr<SkRuntimeShaderBuilder*>(builderPtr);
+    sk_sp<SkColorFilter> colorFilter = sk_ref_sp<SkColorFilter>(reinterpret_cast<SkColorFilter*>(static_cast<uintptr_t>(childColorFilterPtr)));
+    runtimeShaderBuilder->child(skString(env, childName).c_str()) = colorFilter;
+}

skiko/src/nativeJsMain/cpp/RuntimeShaderBuilder.cc

@@ -89,3 +89,17 @@ SKIKO_EXPORT void org_jetbrains_skia_RuntimeShaderBuilder__1nUniformFloatMatrix4
     SkRuntimeShaderBuilder* runtimeShaderBuilder = reinterpret_cast<SkRuntimeShaderBuilder*>(builderPtr);
     runtimeShaderBuilder->uniform(skString(uniformName).c_str()) = uniformMatrix44;
 }
+
+SKIKO_EXPORT void org_jetbrains_skia_RuntimeShaderBuilder__1nChildShader
+  (KNativePointer builderPtr, KInteropPointer childName, KNativePointer childShaderPtr) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = reinterpret_cast<SkRuntimeShaderBuilder*>(builderPtr);
+    sk_sp<SkShader> shader = sk_ref_sp<SkShader>(reinterpret_cast<SkShader*>(childShaderPtr));
+    runtimeShaderBuilder->child(skString(childName).c_str()) = shader;
+}
+
+SKIKO_EXPORT void org_jetbrains_skia_RuntimeShaderBuilder__1nChildColorFilter
+  (KNativePointer builderPtr, KInteropPointer childName, KNativePointer childColorFilterPtr) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = reinterpret_cast<SkRuntimeShaderBuilder*>(builderPtr);
+    sk_sp<SkColorFilter> colorFilter = sk_ref_sp<SkColorFilter>(reinterpret_cast<SkColorFilter*>(childColorFilterPtr));
+    runtimeShaderBuilder->child(skString(childName).c_str()) = colorFilter;
+}