Add SkPerlinNoiseShader APIs to Skiko (#165)

* Add SkPerlinNoiseShader APIs to Skiko

* Fix passing the correct tiles array

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

+package org.jetbrains.skia
+
+import kotlin.jvm.JvmStatic
+
+class ISize internal constructor(val width: Int, val height: Int) {
+    fun isZero(): Boolean {
+        return (width == 0) && (height == 0)
+    }
+
+    fun isEmpty(): Boolean {
+        return (width <= 0) || (height <= 0)
+    }
+
+    fun area(): Int {
+        return width * height
+    }
+
+    override fun equals(o: Any?): Boolean {
+        if (o === this) return true
+        if (o !is ISize) return false
+        val other = o
+        if (!other.canEqual(this as Any)) return false
+        if (width != other.width) return false
+        return if (height != other.height) false else true
+    }
+
+    protected fun canEqual(other: Any?): Boolean {
+        return other is ISize
+    }
+
+    override fun hashCode(): Int {
+        val PRIME = 59
+        var result = 1
+        result = result * PRIME + width
+        result = result * PRIME + height
+        return result
+    }
+
+    override fun toString(): String {
+        return "ISize(_width=" + width + ", _height=" + height + ")"
+    }
+
+    companion object {
+        @JvmStatic
+        fun make(w: Int, h: Int): ISize {
+            return ISize(w, h)
+        }
+
+        @JvmStatic
+        fun makeEmpty(): ISize {
+            return ISize(0, 0)
+        }
+    }
+}
\ No newline at end of file

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

@@ -444,6 +444,46 @@ class Shader internal constructor(ptr: Long) : RefCnt(ptr) {
             }
         }
 
+        fun makeFractalNoise(
+            baseFrequencyX: Float,
+            baseFrequencyY: Float,
+            numOctaves: Int,
+            seed: Float,
+            tiles: Array<ISize>
+        ): Shader {
+            return try {
+                val arr = IntArray(tiles.size * 2)
+                for (i in tiles.indices) {
+                    arr[i * 2] = tiles[i].width
+                    arr[i * 2 + 1] = tiles[i].height
+                }
+                Stats.onNativeCall()
+                Shader(_nMakeFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves, seed, arr))
+            } finally {
+                reachabilityBarrier(this)
+            }
+        }
+
+        fun makeTurbulence(
+            baseFrequencyX: Float,
+            baseFrequencyY: Float,
+            numOctaves: Int,
+            seed: Float,
+            tiles: Array<ISize>
+        ): Shader {
+            return try {
+                val arr = IntArray(tiles.size * 2)
+                for (i in tiles.indices) {
+                    arr[i * 2] = tiles[i].width
+                    arr[i * 2 + 1] = tiles[i].height
+                }
+                Stats.onNativeCall()
+                Shader(_nMakeTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed, arr))
+            } finally {
+                reachabilityBarrier(this)
+            }
+        }
+
         @JvmStatic external fun _nMakeWithColorFilter(ptr: Long, colorFilterPtr: Long): Long
         @JvmStatic external fun _nMakeLinearGradient(
             x0: Float,
@@ -547,6 +587,22 @@ class Shader internal constructor(ptr: Long) : RefCnt(ptr) {
             matrix: FloatArray?
         ): Long
 
+        @JvmStatic external fun _nMakeFractalNoise(
+            baseFrequencyX: Float,
+            baseFrequencyY: Float,
+            numOctaves: Int,
+            seed: Float,
+            tiles: IntArray?
+        ): Long
+
+        @JvmStatic external fun _nMakeTurbulence(
+            baseFrequencyX: Float,
+            baseFrequencyY: Float,
+            numOctaves: Int,
+            seed: Float,
+            tiles: IntArray?
+        ): Long
+
         @JvmStatic external fun _nMakeEmpty(): Long
         @JvmStatic external fun _nMakeColor(color: Int): Long
         @JvmStatic external fun _nMakeColorCS(r: Float, g: Float, b: Float, a: Float, colorSpacePtr: Long): Long

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

 #include <iostream>
 #include <jni.h>
+#include "interop.hh"
 #include "SkColorFilter.h"
 #include "SkShader.h"
 #include "SkGradientShader.h"
+#include "SkPerlinNoiseShader.h"
+#include "SkSize.h"
 #include "interop.hh"
 
 extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_Shader__1nMakeWithColorFilter
@@ -142,3 +145,27 @@ extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_Shader__1nMakeBlend(J
     SkShader* ptr = SkShaders::Blend(blendMode, sk_ref_sp<SkShader>(dst), sk_ref_sp<SkShader>(src)).release();
     return reinterpret_cast<jlong>(ptr);
 }
+
+extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_Shader__1nMakeFractalNoise
+  (JNIEnv* env, jclass jclass, jfloat baseFrequencyX, jfloat baseFrequencyY, jint numOctaves, jfloat seed, jintArray tilesArray) {
+    int len = env->GetArrayLength(tilesArray);
+    std::vector<SkISize> tiles(len / 2);
+    jint* arr = env->GetIntArrayElements(tilesArray, 0);
+    for (int i = 0; i < len; i += 2)
+        tiles[i / 2] = {arr[i], arr[i+1]};
+    env->ReleaseIntArrayElements(tilesArray, arr, 0);
+    SkShader* ptr = SkPerlinNoiseShader::MakeFractalNoise(baseFrequencyX, baseFrequencyY, numOctaves, seed, tiles.data()).release();
+    return reinterpret_cast<jlong>(ptr);
+}
+
+extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skia_Shader__1nMakeTurbulence
+  (JNIEnv* env, jclass jclass, jfloat baseFrequencyX, jfloat baseFrequencyY, jint numOctaves, jfloat seed, jintArray tilesArray) {
+    int len = env->GetArrayLength(tilesArray);
+    std::vector<SkISize> tiles(len / 2);
+    jint* arr = env->GetIntArrayElements(tilesArray, 0);
+    for (int i = 0; i < len; i += 2)
+        tiles[i / 2] = {arr[i], arr[i+1]};
+    env->ReleaseIntArrayElements(tilesArray, arr, 0);
+    SkShader* ptr = SkPerlinNoiseShader::MakeTurbulence(baseFrequencyX, baseFrequencyY, numOctaves, seed, tiles.data()).release();
+    return reinterpret_cast<jlong>(ptr);
+}