Complete bindings for SkRuntimeShaderBuilder::uniform (#524)

* Add bindings for SkImageFilters::RuntimeShader

For https://github.com/JetBrains/skiko/issues/519

* More work for SkImageFilters::RuntimeShader

* Add a check that input array sizes match
* Add tests for the new image filters
* Add JS bindings for the added common bindings

* Add test coverage for the new image filters

* Fix name mismatch in the JS bindings

* Fix SkString conversions in JS bindings

* Fix input shader cast

* Fix runtime shader builder finalizer name

* A slightly different way to wrap the input image filter

* A different way to get char* in the binding

* Pass shader name as interop pointer

* Pass shader names as interop pointer

* Complete bindings for SkRuntimeShaderBuilder::uniform

Add bindings for kInt2, kInt3, kInt4, kFloat2, kFloat3, kFloat4, kFloat2x2, kFloat3x3, kFloat4x4

* Small tweaks to Matrix classes

* Add `Matrix22.IDENTITY`
* Align visibility of float array `mat` field to be public across all three matrix classes (2x2, 3x3, 4x4)

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

+package org.jetbrains.skia
+
+import org.jetbrains.skia.impl.InteropPointer
+import org.jetbrains.skia.impl.InteropScope
+import org.jetbrains.skia.impl.withResult
+
+/**
+ * 2x2 matrix.
+ */
+class Matrix22(vararg mat: Float) {
+    /**
+     * Matrix elements are in row-major order.
+     */
+    val mat: FloatArray
+
+    override fun equals(other: Any?): Boolean {
+        if (other === this) return true
+        if (other !is Matrix22) return false
+        return mat.contentEquals(other.mat)
+    }
+
+    override fun hashCode(): Int {
+        val PRIME = 59
+        var result = 1
+        result = result * PRIME + mat.contentHashCode()
+        return result
+    }
+
+    override fun toString(): String {
+        return "Matrix22(_mat=$mat)"
+    }
+
+    companion object {
+        val IDENTITY = Matrix22(1f, 0f, 0f, 1f)
+
+        internal fun fromInteropPointer(block: InteropScope.(InteropPointer) -> Unit): Matrix22 {
+            val result = withResult(FloatArray(4), block)
+            return Matrix22(*result)
+        }
+    }
+
+    /**
+     * The constructor parameters are in row-major order.
+     */
+    init {
+        require(mat.size == 4) { "Expected 4 elements, got ${mat.size}" }
+        this.mat = mat
+    }
+}

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

@@ -20,16 +20,6 @@ internal fun Float.toRadians(): Double = this.toDouble() / 180 * PI
  * @see [https://fiddle.skia.org/c/@Matrix_063](https://fiddle.skia.org/c/@Matrix_063)
  */
 class Matrix33(vararg mat: Float) {
-    /**
-     *
-     * Matrix33 elements are in row-major order.
-     *
-     * <pre>`
-     * | scaleX   skewX  transX |
-     * |  skewY  scaleY  transY |
-     * | persp0  persp1  persp2 |
-    `</pre> *
-     */
     /**
      *
      * Matrix33 elements are in row-major order.

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

@@ -17,10 +17,7 @@ class Matrix44(vararg mat: Float) {
     /**
      * Matrix elements are in row-major order.
      */
-    /**
-     * Matrix elements are in row-major order.
-     */
-    internal val mat: FloatArray
+    val mat: FloatArray
 
     /**
      *

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

@@ -32,12 +32,75 @@ class RuntimeShaderBuilder internal constructor(ptr: NativePointer) : Managed(pt
         }
     }
 
+    fun uniform(name: String, value1: Int, value2: Int) {
+        Stats.onNativeCall()
+        interopScope {
+            _nUniformInt2(_ptr, toInterop(name), value1, value2)
+        }
+    }
+
+    fun uniform(name: String, value1: Int, value2: Int, value3: Int) {
+        Stats.onNativeCall()
+        interopScope {
+            _nUniformInt3(_ptr, toInterop(name), value1, value2, value3)
+        }
+    }
+
+    fun uniform(name: String, value1: Int, value2: Int, value3: Int, value4: Int) {
+        Stats.onNativeCall()
+        interopScope {
+            _nUniformInt4(_ptr, toInterop(name), value1, value2, value3, value4)
+        }
+    }
+
     fun uniform(name: String, value: Float) {
         Stats.onNativeCall()
         interopScope {
             _nUniformFloat(_ptr, toInterop(name), value)
         }
     }
+
+    fun uniform(name: String, value1: Float, value2: Float) {
+        Stats.onNativeCall()
+        interopScope {
+            _nUniformFloat2(_ptr, toInterop(name), value1, value2)
+        }
+    }
+
+    fun uniform(name: String, value1: Float, value2: Float, value3: Float) {
+        Stats.onNativeCall()
+        interopScope {
+            _nUniformFloat3(_ptr, toInterop(name), value1, value2, value3)
+        }
+    }
+
+    fun uniform(name: String, value1: Float, value2: Float, value3: Float, value4: Float) {
+        Stats.onNativeCall()
+        interopScope {
+            _nUniformFloat4(_ptr, toInterop(name), value1, value2, value3, value4)
+        }
+    }
+
+    fun uniform(name: String, value: Matrix22) {
+        Stats.onNativeCall()
+        interopScope {
+            _nUniformFloatMatrix22(_ptr, toInterop(name), toInterop(value.mat))
+        }
+    }
+
+    fun uniform(name: String, value: Matrix33) {
+        Stats.onNativeCall()
+        interopScope {
+            _nUniformFloatMatrix33(_ptr, toInterop(name), toInterop(value.mat))
+        }
+    }
+
+    fun uniform(name: String, value: Matrix44) {
+        Stats.onNativeCall()
+        interopScope {
+            _nUniformFloatMatrix44(_ptr, toInterop(name), toInterop(value.mat))
+        }
+    }
 }
 
 @ExternalSymbolName("org_jetbrains_skia_RuntimeShaderBuilder__1nMakeFromRuntimeEffect")
@@ -49,5 +112,32 @@ private external fun RuntimeShaderBuilder_nGetFinalizer(): NativePointer
 @ExternalSymbolName("org_jetbrains_skia_RuntimeShaderBuilder__1nUniformInt")
 private external fun _nUniformInt(builderPtr: NativePointer, uniformName: InteropPointer, uniformValue: Int)
 
+@ExternalSymbolName("org_jetbrains_skia_RuntimeShaderBuilder__1nUniformInt2")
+private external fun _nUniformInt2(builderPtr: NativePointer, uniformName: InteropPointer, uniformValue1: Int, uniformValue2: Int)
+
+@ExternalSymbolName("org_jetbrains_skia_RuntimeShaderBuilder__1nUniformInt3")
+private external fun _nUniformInt3(builderPtr: NativePointer, uniformName: InteropPointer, uniformValue1: Int, uniformValue2: Int, uniformValue3: Int)
+
+@ExternalSymbolName("org_jetbrains_skia_RuntimeShaderBuilder__1nUniformInt4")
+private external fun _nUniformInt4(builderPtr: NativePointer, uniformName: InteropPointer, uniformValue1: Int, uniformValue2: Int, uniformValue3: Int, uniformValue4: Int)
+
 @ExternalSymbolName("org_jetbrains_skia_RuntimeShaderBuilder__1nUniformFloat")
 private external fun _nUniformFloat(builderPtr: NativePointer, uniformName: InteropPointer, uniformValue: Float)
+
+@ExternalSymbolName("org_jetbrains_skia_RuntimeShaderBuilder__1nUniformFloat2")
+private external fun _nUniformFloat2(builderPtr: NativePointer, uniformName: InteropPointer, uniformValue1: Float, uniformValue2: Float)
+
+@ExternalSymbolName("org_jetbrains_skia_RuntimeShaderBuilder__1nUniformFloat3")
+private external fun _nUniformFloat3(builderPtr: NativePointer, uniformName: InteropPointer, uniformValue1: Float, uniformValue2: Float, uniformValue3: Float)
+
+@ExternalSymbolName("org_jetbrains_skia_RuntimeShaderBuilder__1nUniformFloat4")
+private external fun _nUniformFloat4(builderPtr: NativePointer, uniformName: InteropPointer, uniformValue1: Float, uniformValue2: Float, uniformValue3: Float, uniformValue4: Float)
+
+@ExternalSymbolName("org_jetbrains_skia_RuntimeShaderBuilder__1nUniformFloatMatrix22")
+private external fun _nUniformFloatMatrix22(builderPtr: NativePointer, uniformName: InteropPointer, uniformMatrix22: InteropPointer)
+
+@ExternalSymbolName("org_jetbrains_skia_RuntimeShaderBuilder__1nUniformFloatMatrix33")
+private external fun _nUniformFloatMatrix33(builderPtr: NativePointer, uniformName: InteropPointer, uniformMatrix33: InteropPointer)
+
+@ExternalSymbolName("org_jetbrains_skia_RuntimeShaderBuilder__1nUniformFloatMatrix44")
+private external fun _nUniformFloatMatrix44(builderPtr: NativePointer, uniformName: InteropPointer, uniformMatrix44: InteropPointer)

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

@@ -227,7 +227,7 @@ class ImageFilterTest {
     fun makeRuntimeShader() = imageFilterTest {
         // A simple Skia shader that bumps up the red channel of every non-transparent
         // pixel to full intensity, and leaves green and blue channels unchanged.
-        val redSksl = """
+        val sksl = """
             uniform shader content;
             vec4 main(vec2 coord) {
                 vec4 c = content.eval(coord);
@@ -235,16 +235,266 @@ class ImageFilterTest {
             }
         """
 
-        val redRuntimeEffect = RuntimeEffect.makeForShader(redSksl)
-        val redShaderBuilder = RuntimeShaderBuilder(redRuntimeEffect)
+        val runtimeEffect = RuntimeEffect.makeForShader(sksl)
+        val shaderBuilder = RuntimeShaderBuilder(runtimeEffect)
 
         ImageFilter.makeRuntimeShader(
-            runtimeShaderBuilder = redShaderBuilder,
+            runtimeShaderBuilder = shaderBuilder,
             shaderName = "content",
             input = null
         )
     }
 
+    @Test
+    fun makeRuntimeShaderUniformFloat2() = imageFilterTest {
+        // A simple Skia shader that bumps up the red channel and bumps down the green channel
+        // of every pixel. This tests the binding to SkRuntimeShaderBuilder::uniform(kFloat2)
+        val sksl = """
+            uniform shader content;
+            uniform vec2 channels;
+            
+            vec4 main(vec2 coord) {
+                vec4 c = content.eval(coord);
+                return vec4(c.a * (c.r + (1.0 - c.r) * channels.x),
+                   c.a * (c.g * channels.y), c.a * c.b, c.a);
+            }
+        """
+
+        val runtimeEffect = RuntimeEffect.makeForShader(sksl)
+        val shaderBuilder = RuntimeShaderBuilder(runtimeEffect)
+        shaderBuilder.uniform("channels", 0.9f, 0.5f)
+
+        ImageFilter.makeRuntimeShader(
+            runtimeShaderBuilder = shaderBuilder,
+            shaderName = "content",
+            input = null
+        )
+    }
+
+    @Test
+    fun makeRuntimeShaderUniformFloat3() = imageFilterTest {
+        // A simple Skia shader that replaces every pixel with the specified uniform color.
+        // This tests the binding to SkRuntimeShaderBuilder::uniform(kFloat3)
+        val sksl = """
+            uniform shader content;
+            uniform vec3 color;
+            
+            vec4 main(vec2 coord) {
+                return vec4(color, 1.0);
+            }
+        """
+
+        val runtimeEffect = RuntimeEffect.makeForShader(sksl)
+        val shaderBuilder = RuntimeShaderBuilder(runtimeEffect)
+        shaderBuilder.uniform("color", 1.0f, 0.0f, 1.0f)
+
+        ImageFilter.makeRuntimeShader(
+            runtimeShaderBuilder = shaderBuilder,
+            shaderName = "content",
+            input = null
+        )
+    }
+
+    @Test
+    fun makeRuntimeShaderUniformFloat4() = imageFilterTest {
+        // A simple Skia shader that replaces every pixel with the specified uniform color.
+        // This tests the binding to SkRuntimeShaderBuilder::uniform(kFloat4)
+        val sksl = """
+            uniform shader content;
+            uniform vec4 color;
+            
+            vec4 main(vec2 coord) {
+                return color;
+            }
+        """
+
+        val runtimeEffect = RuntimeEffect.makeForShader(sksl)
+        val shaderBuilder = RuntimeShaderBuilder(runtimeEffect)
+        shaderBuilder.uniform("color", 1.0f, 0.0f, 1.0f, 1.0f)
+
+        ImageFilter.makeRuntimeShader(
+            runtimeShaderBuilder = shaderBuilder,
+            shaderName = "content",
+            input = null
+        )
+    }
+
+    @Test
+    fun makeRuntimeShaderUniformInt() = imageFilterTest {
+        // A simple Skia shader that replaces the red channel of every pixel.
+        // This tests the binding to SkRuntimeShaderBuilder::uniform(kInt)
+        val sksl = """
+            uniform shader content;
+            uniform int replace;
+            vec4 main(vec2 coord) {
+                vec4 c = content.eval(coord);
+                return vec4(c.a * float(replace) / 255.0, c.g * c.a, c.b * c.a, c.a);
+            }
+        """
+
+        val runtimeEffect = RuntimeEffect.makeForShader(sksl)
+        val shaderBuilder = RuntimeShaderBuilder(runtimeEffect)
+        shaderBuilder.uniform("replace", 128)
+
+        ImageFilter.makeRuntimeShader(
+            runtimeShaderBuilder = shaderBuilder,
+            shaderName = "content",
+            input = null
+        )
+    }
+
+    @Test
+    fun makeRuntimeShaderUniformInt2() = imageFilterTest {
+        // A simple Skia shader that replaces the red and green channels of every pixel.
+        // This tests the binding to SkRuntimeShaderBuilder::uniform(kInt2)
+        val sksl = """
+            uniform shader content;
+            uniform ivec2 replace;
+            vec4 main(vec2 coord) {
+                vec4 c = content.eval(coord);
+                return vec4(c.a * float(replace.x) / 255.0, c.a * float(replace.y) / 255.0, c.b * c.a, c.a);
+            }
+        """
+
+        val runtimeEffect = RuntimeEffect.makeForShader(sksl)
+        val shaderBuilder = RuntimeShaderBuilder(runtimeEffect)
+        shaderBuilder.uniform("replace", 128, 160)
+
+        ImageFilter.makeRuntimeShader(
+            runtimeShaderBuilder = shaderBuilder,
+            shaderName = "content",
+            input = null
+        )
+    }
+
+    @Test
+    fun makeRuntimeShaderUniformInt3() = imageFilterTest {
+        // A simple Skia shader that replaces the red, green and blue channels of every pixel.
+        // This tests the binding to SkRuntimeShaderBuilder::uniform(kInt3)
+        val sksl = """
+            uniform shader content;
+            uniform ivec3 replace;
+            vec4 main(vec2 coord) {
+                vec4 c = content.eval(coord);
+                return vec4(c.a * float(replace.x) / 255.0, c.a * float(replace.y) / 255.0, 
+                    c.a * float(replace.z) / 255.0, c.a);
+            }
+        """
+
+        val runtimeEffect = RuntimeEffect.makeForShader(sksl)
+        val shaderBuilder = RuntimeShaderBuilder(runtimeEffect)
+        shaderBuilder.uniform("replace", 128, 160, 192)
+
+        ImageFilter.makeRuntimeShader(
+            runtimeShaderBuilder = shaderBuilder,
+            shaderName = "content",
+            input = null
+        )
+    }
+
+    @Test
+    fun makeRuntimeShaderUniformInt4() = imageFilterTest {
+        // A simple Skia shader that all channels of every pixel.
+        // This tests the binding to SkRuntimeShaderBuilder::uniform(kInt4)
+        val sksl = """
+            uniform shader content;
+            uniform ivec4 replace;
+            vec4 main(vec2 coord) {
+                vec4 c = content.eval(coord);
+                float alpha = c.a * float(replace.w) / 255.0;
+                return vec4(alpha * float(replace.x) / 255.0, alpha * float(replace.y) / 255.0, 
+                    alpha * float(replace.z) / 255.0, alpha);
+            }
+        """
+
+        val runtimeEffect = RuntimeEffect.makeForShader(sksl)
+        val shaderBuilder = RuntimeShaderBuilder(runtimeEffect)
+        shaderBuilder.uniform("replace", 128, 160, 192, 100)
+
+        ImageFilter.makeRuntimeShader(
+            runtimeShaderBuilder = shaderBuilder,
+            shaderName = "content",
+            input = null
+        )
+    }
+
+    @Test
+    fun makeRuntimeShaderUniformFloatMatrix2x2() = imageFilterTest {
+        // A simple Skia shader that applies a 2x2 matrix on the red and green channels.
+        // This tests the binding to SkRuntimeShaderBuilder::uniform(kFloat2x2)
+        val sksl = """
+            uniform shader content;
+            uniform mat2 matrix2x2;
+            
+            vec4 main(vec2 coord) {
+                vec4 c = content.eval(coord);
+                vec2 intermediate = c.rg * matrix2x2 + vec2(0.1, 0.1);
+                return vec4(c.a * intermediate[0], c.a * intermediate[1], c.a * c.g, c.a);
+            }
+        """
+
+        val runtimeEffect = RuntimeEffect.makeForShader(sksl)
+        val shaderBuilder = RuntimeShaderBuilder(runtimeEffect)
+        shaderBuilder.uniform("matrix2x2", Matrix22(0.4f, 0.3f, 0.2f, 0.6f))
+
+        ImageFilter.makeRuntimeShader(
+            runtimeShaderBuilder = shaderBuilder,
+            shaderName = "content",
+            input = null
+        )
+    }
+
+    @Test
+    fun makeRuntimeShaderUniformFloatMatrix3x3() = imageFilterTest {
+        // A simple Skia shader that applies a 3x3 matrix on the red, green and blue channels.
+        // This tests the binding to SkRuntimeShaderBuilder::uniform(kFloat3x3)
+        val sksl = """
+            uniform shader content;
+            uniform mat3 matrix3x3;
+            
+            vec4 main(vec2 coord) {
+                vec4 c = content.eval(coord);
+                vec3 intermediate = c.rgb * matrix3x3 + vec3(0.1, 0.1, 0.1);
+                return vec4(c.a * intermediate[0], c.a * intermediate[1], c.a * c.g, c.a);
+            }
+        """
+
+        val runtimeEffect = RuntimeEffect.makeForShader(sksl)
+        val shaderBuilder = RuntimeShaderBuilder(runtimeEffect)
+        shaderBuilder.uniform("matrix3x3", Matrix33(0.4f, 0.3f, 0.2f, 0.6f, 0.1f, 0.2f, 0.3f, 0.2f, 0.1f))
+
+        ImageFilter.makeRuntimeShader(
+            runtimeShaderBuilder = shaderBuilder,
+            shaderName = "content",
+            input = null
+        )
+    }
+
+    @Test
+    fun makeRuntimeShaderUniformFloatMatrix4x4() = imageFilterTest {
+        // A simple Skia shader that applies a 4x4 matrix on all channels.
+        // This tests the binding to SkRuntimeShaderBuilder::uniform(kFloat4x4)
+        val sksl = """
+            uniform shader content;
+            uniform mat4 matrix4x4;
+            
+            vec4 main(vec2 coord) {
+                vec4 c = content.eval(coord);
+                vec4 intermediate = c.rgba * matrix4x4 + vec4(0.1, 0.1, 0.1, 0.1);
+                return intermediate;
+            }
+        """
+
+        val runtimeEffect = RuntimeEffect.makeForShader(sksl)
+        val shaderBuilder = RuntimeShaderBuilder(runtimeEffect)
+        shaderBuilder.uniform("matrix4x4", Matrix44(0.2f, 0.3f, 0.2f, 0.1f, 0.4f, 0.1f, 0.2f, 0.1f, 0.1f, 0.3f, 0.2f, 0.1f, 0.2f, 0.2f, 0.2f, 0.3f))
+
+        ImageFilter.makeRuntimeShader(
+            runtimeShaderBuilder = shaderBuilder,
+            shaderName = "content",
+            input = null
+        )
+    }
 
     @Test
     fun makeRuntimeShaderFromArrays() = imageFilterTest {

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

@@ -27,9 +27,83 @@ Java_org_jetbrains_skia_RuntimeShaderBuilderKt__1nUniformInt
     runtimeShaderBuilder->uniform(skString(env, uniformName).c_str()) = uniformValue;
 }
 
+extern "C" JNIEXPORT void JNICALL
+Java_org_jetbrains_skia_RuntimeShaderBuilderKt__1nUniformInt2
+  (JNIEnv* env, jclass jclass, jlong builderPtr, jstring uniformName, jint uniformValue1, jint uniformValue2) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = jlongToPtr<SkRuntimeShaderBuilder*>(builderPtr);
+    using int2 = std::array<int, 2>;
+    runtimeShaderBuilder->uniform(skString(env, uniformName).c_str()) = int2 {uniformValue1, uniformValue2};
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_org_jetbrains_skia_RuntimeShaderBuilderKt__1nUniformInt3
+  (JNIEnv* env, jclass jclass, jlong builderPtr, jstring uniformName, jint uniformValue1, jint uniformValue2, jint uniformValue3) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = jlongToPtr<SkRuntimeShaderBuilder*>(builderPtr);
+    using int3 = std::array<int, 3>;
+    runtimeShaderBuilder->uniform(skString(env, uniformName).c_str()) = int3 {uniformValue1, uniformValue2, uniformValue3};
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_org_jetbrains_skia_RuntimeShaderBuilderKt__1nUniformInt4
+  (JNIEnv* env, jclass jclass, jlong builderPtr, jstring uniformName, jint uniformValue1, jint uniformValue2, jint uniformValue3, jint uniformValue4) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = jlongToPtr<SkRuntimeShaderBuilder*>(builderPtr);
+    using int4 = std::array<int, 4>;
+    runtimeShaderBuilder->uniform(skString(env, uniformName).c_str()) = int4 {uniformValue1, uniformValue2, uniformValue3, uniformValue4};
+}
+
 extern "C" JNIEXPORT void JNICALL
 Java_org_jetbrains_skia_RuntimeShaderBuilderKt__1nUniformFloat
   (JNIEnv* env, jclass jclass, jlong builderPtr, jstring uniformName, jfloat uniformValue) {
     SkRuntimeShaderBuilder* runtimeShaderBuilder = jlongToPtr<SkRuntimeShaderBuilder*>(builderPtr);
     runtimeShaderBuilder->uniform(skString(env, uniformName).c_str()) = uniformValue;
 }
+
+extern "C" JNIEXPORT void JNICALL
+Java_org_jetbrains_skia_RuntimeShaderBuilderKt__1nUniformFloat2
+  (JNIEnv* env, jclass jclass, jlong builderPtr, jstring uniformName, jfloat uniformValue1, jfloat uniformValue2) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = jlongToPtr<SkRuntimeShaderBuilder*>(builderPtr);
+    using float2 = std::array<float, 2>;
+    runtimeShaderBuilder->uniform(skString(env, uniformName).c_str()) = float2 {uniformValue1, uniformValue2};
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_org_jetbrains_skia_RuntimeShaderBuilderKt__1nUniformFloat3
+  (JNIEnv* env, jclass jclass, jlong builderPtr, jstring uniformName, jfloat uniformValue1, jfloat uniformValue2, jfloat uniformValue3) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = jlongToPtr<SkRuntimeShaderBuilder*>(builderPtr);
+    using float3 = std::array<float, 3>;
+    runtimeShaderBuilder->uniform(skString(env, uniformName).c_str()) = float3 {uniformValue1, uniformValue2, uniformValue3};
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_org_jetbrains_skia_RuntimeShaderBuilderKt__1nUniformFloat4
+  (JNIEnv* env, jclass jclass, jlong builderPtr, jstring uniformName, jfloat uniformValue1, jfloat uniformValue2, jfloat uniformValue3, jfloat uniformValue4) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = jlongToPtr<SkRuntimeShaderBuilder*>(builderPtr);
+    using float4 = std::array<float, 4>;
+    runtimeShaderBuilder->uniform(skString(env, uniformName).c_str()) = float4 {uniformValue1, uniformValue2, uniformValue3, uniformValue4};
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_org_jetbrains_skia_RuntimeShaderBuilderKt__1nUniformFloatMatrix22
+  (JNIEnv* env, jclass jclass, jlong builderPtr, jstring uniformName, jfloatArray uniformMatrix22) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = jlongToPtr<SkRuntimeShaderBuilder*>(builderPtr);
+    jfloat* matrix22 = static_cast<jfloat*>(env->GetPrimitiveArrayCritical(uniformMatrix22, 0));
+    runtimeShaderBuilder->uniform(skString(env, uniformName).c_str()) =
+        std::array<float, 4> {matrix22[0], matrix22[1], matrix22[2], matrix22[3]};
+    env->ReleasePrimitiveArrayCritical(uniformMatrix22, matrix22, 0);
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_org_jetbrains_skia_RuntimeShaderBuilderKt__1nUniformFloatMatrix33
+  (JNIEnv* env, jclass jclass, jlong builderPtr, jstring uniformName, jfloatArray uniformMatrix33) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = jlongToPtr<SkRuntimeShaderBuilder*>(builderPtr);
+    std::unique_ptr<SkMatrix> matrix33 = skMatrix(env, uniformMatrix33);
+    runtimeShaderBuilder->uniform(skString(env, uniformName).c_str()) = matrix33.get();
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_org_jetbrains_skia_RuntimeShaderBuilderKt__1nUniformFloatMatrix44
+  (JNIEnv* env, jclass jclass, jlong builderPtr, jstring uniformName, jfloatArray uniformMatrix44) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = jlongToPtr<SkRuntimeShaderBuilder*>(builderPtr);
+    std::unique_ptr<SkM44> matrix44 = skM44(env, uniformMatrix44);
+    runtimeShaderBuilder->uniform(skString(env, uniformName).c_str()) = matrix44.get();
+}

skiko/src/nativeJsMain/cpp/RuntimeShaderBuilder.cc

@@ -23,8 +23,69 @@ SKIKO_EXPORT void org_jetbrains_skia_RuntimeShaderBuilder__1nUniformInt
     runtimeShaderBuilder->uniform(skString(uniformName).c_str()) = uniformValue;
 }
 
+SKIKO_EXPORT void org_jetbrains_skia_RuntimeShaderBuilder__1nUniformInt2
+  (KNativePointer builderPtr, KInteropPointer uniformName, KInt uniformValue1, KInt uniformValue2) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = reinterpret_cast<SkRuntimeShaderBuilder*>(builderPtr);
+    using int2 = std::array<int, 2>;
+    runtimeShaderBuilder->uniform(skString(uniformName).c_str()) = int2 {uniformValue1, uniformValue2};
+}
+
+SKIKO_EXPORT void org_jetbrains_skia_RuntimeShaderBuilder__1nUniformInt3
+  (KNativePointer builderPtr, KInteropPointer uniformName, KInt uniformValue1, KInt uniformValue2, KInt uniformValue3) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = reinterpret_cast<SkRuntimeShaderBuilder*>(builderPtr);
+    using int3 = std::array<int, 3>;
+    runtimeShaderBuilder->uniform(skString(uniformName).c_str()) = int3 {uniformValue1, uniformValue2, uniformValue3};
+}
+
+SKIKO_EXPORT void org_jetbrains_skia_RuntimeShaderBuilder__1nUniformInt4
+  (KNativePointer builderPtr, KInteropPointer uniformName, KInt uniformValue1, KInt uniformValue2, KInt uniformValue3, KInt uniformValue4) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = reinterpret_cast<SkRuntimeShaderBuilder*>(builderPtr);
+    using int4 = std::array<int, 4>;
+    runtimeShaderBuilder->uniform(skString(uniformName).c_str()) = int4 {uniformValue1, uniformValue2, uniformValue3, uniformValue4};
+}
+
 SKIKO_EXPORT void org_jetbrains_skia_RuntimeShaderBuilder__1nUniformFloat
   (KNativePointer builderPtr, KInteropPointer uniformName, KFloat uniformValue) {
     SkRuntimeShaderBuilder* runtimeShaderBuilder = reinterpret_cast<SkRuntimeShaderBuilder*>(builderPtr);
     runtimeShaderBuilder->uniform(skString(uniformName).c_str()) = uniformValue;
 }
+
+SKIKO_EXPORT void org_jetbrains_skia_RuntimeShaderBuilder__1nUniformFloat2
+  (KNativePointer builderPtr, KInteropPointer uniformName, KFloat uniformValue1, KFloat uniformValue2) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = reinterpret_cast<SkRuntimeShaderBuilder*>(builderPtr);
+    using float2 = std::array<float, 2>;
+    runtimeShaderBuilder->uniform(skString(uniformName).c_str()) = float2 {uniformValue1, uniformValue2};
+}
+
+SKIKO_EXPORT void org_jetbrains_skia_RuntimeShaderBuilder__1nUniformFloat3
+  (KNativePointer builderPtr, KInteropPointer uniformName, KFloat uniformValue1, KFloat uniformValue2, KFloat uniformValue3) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = reinterpret_cast<SkRuntimeShaderBuilder*>(builderPtr);
+    using float3 = std::array<float, 3>;
+    runtimeShaderBuilder->uniform(skString(uniformName).c_str()) = float3 {uniformValue1, uniformValue2, uniformValue3};
+}
+
+SKIKO_EXPORT void org_jetbrains_skia_RuntimeShaderBuilder__1nUniformFloat4
+  (KNativePointer builderPtr, KInteropPointer uniformName, KFloat uniformValue1, KFloat uniformValue2, KFloat uniformValue3, KFloat uniformValue4) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = reinterpret_cast<SkRuntimeShaderBuilder*>(builderPtr);
+    using float4 = std::array<float, 4>;
+    runtimeShaderBuilder->uniform(skString(uniformName).c_str()) = float4 {uniformValue1, uniformValue2, uniformValue3, uniformValue4};
+}
+
+SKIKO_EXPORT void org_jetbrains_skia_RuntimeShaderBuilder__1nUniformFloatMatrix22
+  (KNativePointer builderPtr, KInteropPointer uniformName, KFloat* uniformMatrix22) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = reinterpret_cast<SkRuntimeShaderBuilder*>(builderPtr);
+    runtimeShaderBuilder->uniform(skString(uniformName).c_str()) =
+        std::array<float, 4> {uniformMatrix22[0], uniformMatrix22[1], uniformMatrix22[2], uniformMatrix22[3]};
+}
+
+SKIKO_EXPORT void org_jetbrains_skia_RuntimeShaderBuilder__1nUniformFloatMatrix33
+  (KNativePointer builderPtr, KInteropPointer uniformName, KFloat* uniformMatrix33) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = reinterpret_cast<SkRuntimeShaderBuilder*>(builderPtr);
+    runtimeShaderBuilder->uniform(skString(uniformName).c_str()) = uniformMatrix33;
+}
+
+SKIKO_EXPORT void org_jetbrains_skia_RuntimeShaderBuilder__1nUniformFloatMatrix44
+  (KNativePointer builderPtr, KInteropPointer uniformName, KFloat* uniformMatrix44) {
+    SkRuntimeShaderBuilder* runtimeShaderBuilder = reinterpret_cast<SkRuntimeShaderBuilder*>(builderPtr);
+    runtimeShaderBuilder->uniform(skString(uniformName).c_str()) = uniformMatrix44;
+}