Skip to content

S
skiko
Unverified Commit 228274af authored by Nikolay Igotti's avatar Nikolay Igotti Committed by GitHub
Browse files
Options

Remove Skija, prepare for truly MPP Skiko (#150)

parent 6a4f0f73
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 32616 additions and 104 deletions
.github/workflows/blank.yml
View file @ 228274af
......@@ -30,7 +30,7 @@ jobs:
- shell: bash
run: |
cd $GITHUB_WORKSPACE/skiko
./gradlew test
./gradlew jvmTest
./gradlew publishToMavenLocal
./gradlew -Pskiko.native.enabled=true publishToMavenLocal
linux:
......@@ -59,7 +59,7 @@ jobs:
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-9 60 --slave /usr/bin/g++ g++ /usr/bin/g++-9
sudo update-alternatives --config gcc
sudo apt-get install ninja-build fontconfig libfontconfig1-dev libglu1-mesa-dev zip -y
./gradlew test
./gradlew jvmTest
./gradlew publishToMavenLocal
windows:
runs-on: windows-2019
......@@ -74,5 +74,5 @@ jobs:
- shell: bash
run: |
cd ./skiko
./gradlew test
./gradlew jvmTest
./gradlew publishToMavenLocal
README.md
View file @ 228274af
......@@ -40,23 +40,19 @@ i.e. something like this
To use latest development snapshot use version `0.0.0-SNAPSHOT`.
## Building JVM bindings
* (Optional) Set SKIA_DIR to location of Skia (binaries can be downloaded
[here](https://bintray.com/beta/#/jetbrains/skija/Skia?tab=files))
* Set JAVA_HOME to location of JDK, at least version 11
* `cd skiko && ./gradlew publishToMavenLocal` will build the artefact and publish it to local Maven repo
To build with debug symbols and debug Skia build use `-Pskiko.debug=true` Gradle argument.
#### Working with Skia or Skija sources
#### Working with Skia sources
Gradle build downloads the necessary version of Skia & Skija by default.
Gradle build downloads the necessary version of Skia by default.
However, if downloaded sources are modified, changes are discarded (Gradle
re-evaluates tasks, when outputs are changed).
To use custom version of the dependencies, specify `SKIA_DIR` or `SKIJA_DIR` environment variable
respectively.
To use custom version of the dependencies, specify `SKIA_DIR` environment variable.
#### Building on Windows
......
samples/SkijaInjectSample/src/main/kotlin/SkijaInjectSample/App.kt → samples/SkiaJvmSample/src/main/kotlin/SkijaInjectSample/App.kt
View file @ 228274af
......@@ -161,7 +161,7 @@ class State {
}
private val fontCollection = FontCollection()
.setDefaultFontManager(FontMgr.getDefault())
.setDefaultFontManager(FontMgr.default)
fun displayScene(renderer: Renderer, width: Int, height: Int, nanoTime: Long, xpos: Int, ypos: Int, state: State) {
val canvas = renderer.canvas!!
......
skiko/build.gradle.kts
View file @ 228274af
......@@ -84,69 +84,6 @@ val skiaDir = run {
}
}
val skijaZip = run {
val zipFile = skiko.dependenciesDir.resolve("skija/${skiko.skijaCommitHash}.zip")
tasks.register("downloadSkija", Download::class) {
onlyIf { skiko.skijaDir == null && !zipFile.exists() }
inputs.property("skija.commit.hash", skiko.skijaCommitHash)
src("https://github.com/JetBrains/skija/archive/${skiko.skijaCommitHash}.zip")
dest(zipFile)
onlyIfModified(true)
}.map { zipFile }
}
val skijaDir = run {
if (skiko.skijaDir != null) {
tasks.register("skijaDir", DefaultTask::class) {
enabled = false
}.map { skiko.skijaDir!! }
} else {
val skijaDest = skiko.dependenciesDir.resolve("skija/skija").apply { mkdirs() }
tasks.register("unzipSkija", Copy::class) {
from(skijaZip.map { zipTree(it) }) {
include("skija-${skiko.skijaCommitHash}/**")
eachFile {
// drop skija-<COMMIT> subdir
relativePath = RelativePath(true, *relativePath.segments.drop(1).toTypedArray())
}
includeEmptyDirs = false
}
into(skijaDest)
}.map { skijaDest }
}
}
val lombok by configurations.creating
val jetbrainsAnnotations by configurations.creating
dependencies {
lombok("org.projectlombok:lombok:1.18.16")
jetbrainsAnnotations("org.jetbrains:annotations:19.0.0")
}
val skijaSrcDir = run {
val delombokSkijaSrcDir = project.file("src/jvmMain/java/org/jetbrains/skija")
tasks.register("delombokSkija", JavaExec::class) {
classpath = lombok + jetbrainsAnnotations
main = "lombok.launch.Main"
args("delombok", skijaDir.get().resolve("shared/java"), "-d", delombokSkijaSrcDir)
inputs.dir(skijaDir)
outputs.dir(delombokSkijaSrcDir)
doFirst {
// We don't need module info.
skijaDir.get().resolve("shared/java/module-info.java").delete()
delombokSkijaSrcDir.deleteRecursively()
delombokSkijaSrcDir.mkdirs()
}
doLast {
// Remove Library.java from Skija.
file(delombokSkijaSrcDir.path + "/impl/Library.java").delete()
// We don't need module info.
file(delombokSkijaSrcDir.path + "/module-info.java").delete()
}
}.map { delombokSkijaSrcDir }
}
val skiaBinSubdir = "out/${buildType.id}-${targetOs.id}-${targetArch.id}"
val Project.supportNative: Boolean
......@@ -157,7 +94,6 @@ kotlin {
compilations.all {
kotlinOptions.jvmTarget = "11"
}
withJava()
}
if (supportNative) {
......@@ -195,12 +131,9 @@ kotlin {
}
}
val jvmMain by getting {
kotlin.srcDirs(skijaSrcDir)
dependencies {
implementation(kotlin("stdlib-jdk8"))
implementation("org.jetbrains.kotlinx:kotlinx-coroutines-swing:$coroutinesVersion")
compileOnly(lombok)
compileOnly(jetbrainsAnnotations)
}
}
......@@ -480,7 +413,6 @@ tasks.withType(LinkSharedLibrary::class.java).configureEach {
extensions.configure<CppLibrary> {
source.from(
skijaDir.map { fileTree(it.resolve("platform/cc")) },
fileTree("$projectDir/src/jvmMain/cpp/common"),
fileTree("$projectDir/src/jvmMain/cpp/${targetOs.id}")
)
......
skiko/buildSrc/src/main/kotlin/properties.kt
View file @ 228274af
......@@ -86,9 +86,6 @@ class SkikoProperties(private val myProject: Project) {
val buildType: SkiaBuildType
get() = if (myProject.findProperty("skiko.debug") == "true") SkiaBuildType.DEBUG else SkiaBuildType.RELEASE
val skijaCommitHash: String
get() = myProject.property("dependencies.skija.git.commit") as String
val skiaReleaseForTargetOS: String
get() {
val tag = myProject.property("dependencies.skia.$target") as String
......@@ -109,9 +106,6 @@ class SkikoProperties(private val myProject: Project) {
val visualStudioBuildToolsDir: File?
get() = System.getenv()["SKIKO_VSBT_PATH"]?.let { File(it) }?.takeIf { it.isDirectory }
val skijaDir: File?
get() = System.getenv()["SKIJA_DIR"]?.let { File(it) }?.takeIf { it.isDirectory }
val skiaDir: File?
get() = (System.getenv()["SKIA_DIR"] ?: System.getProperty("skia.dir"))?.let { File(it) }
?.takeIf { it.isDirectory }
......
skiko/gradle.properties
View file @ 228274af
......@@ -2,7 +2,6 @@ kotlin.code.style=official
deploy.version=0.0.0
kotlin.native.version=1.5.21-dev-329
dependencies.skija.git.commit=5fb057b0d17ab6ec2e5c284e56707f0527daa54a
dependencies.skia.windows-x64=m93-87e8842e8c
dependencies.skia.linux-x64=m93-87e8842e8c
dependencies.skia.macos-x64=m93-87e8842e8c
......
skiko/src/jvmMain/cpp/common/BackendRenderTarget.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "GrBackendSurface.h"
static void deleteBackendRenderTarget(GrBackendRenderTarget* rt) {
// std::cout << "Deleting [GrBackendRenderTarget " << rt << "]" << std::endl;
delete rt;
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_BackendRenderTarget__1nGetFinalizer
(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteBackendRenderTarget));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_BackendRenderTarget__1nMakeGL
(JNIEnv* env, jclass jclass, jint width, jint height, jint sampleCnt, jint stencilBits, jint fbId, jint fbFormat) {
GrGLFramebufferInfo glInfo = { static_cast<unsigned int>(fbId), static_cast<unsigned int>(fbFormat) };
GrBackendRenderTarget* instance = new GrBackendRenderTarget(width, height, sampleCnt, stencilBits, glInfo);
return reinterpret_cast<jlong>(instance);
}
#ifdef SK_METAL
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_BackendRenderTarget__1nMakeMetal
(JNIEnv* env, jclass jclass, jint width, jint height, jlong texturePtr) {
GrMTLHandle texture = reinterpret_cast<GrMTLHandle>(static_cast<uintptr_t>(texturePtr));
GrMtlTextureInfo fbInfo;
fbInfo.fTexture.retain(texture);
GrBackendRenderTarget* instance = new GrBackendRenderTarget(width, height, fbInfo);
return reinterpret_cast<jlong>(instance);
}
#endif
#ifdef SK_DIRECT3D
#include "d3d/GrD3DTypes.h"
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_BackendRenderTarget__1nMakeDirect3D
(JNIEnv* env, jclass jclass, jint width, jint height, jlong texturePtr, jint format, jint sampleCnt, jint levelCnt) {
GrD3DTextureResourceInfo texResInfo = {};
ID3D12Resource* resource = reinterpret_cast<ID3D12Resource*>(static_cast<uintptr_t>(texturePtr));
texResInfo.fResource.retain(resource);
texResInfo.fResourceState = D3D12_RESOURCE_STATE_COMMON;
texResInfo.fFormat = static_cast<DXGI_FORMAT>(format);
texResInfo.fSampleCount = static_cast<uint32_t>(sampleCnt);
texResInfo.fLevelCount = static_cast<uint32_t>(levelCnt);
GrBackendRenderTarget* instance = new GrBackendRenderTarget(width, height, texResInfo);
return reinterpret_cast<jlong>(instance);
}
#endif //SK_DIRECT3D
\ No newline at end of file
skiko/src/jvmMain/cpp/common/Bitmap.cc 0 → 100644
View file @ 228274af
#include <jni.h>
#include "SkBitmap.h"
#include "SkPixelRef.h"
#include "SkSamplingOptions.h"
#include "SkShader.h"
#include "interop.hh"
static void deleteBitmap(SkBitmap* instance) {
// std::cout << "Deleting [SkBitmap " << instance << "]" << std::endl;
delete instance;
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Bitmap__1nGetFinalizer(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteBitmap));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Bitmap__1nMake
(JNIEnv* env, jclass jclass) {
return reinterpret_cast<jlong>(new SkBitmap());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Bitmap__1nMakeClone
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
return reinterpret_cast<jlong>(new SkBitmap(*instance));
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Bitmap__1nSwap
(JNIEnv* env, jclass jclass, jlong ptr, jlong otherPtr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SkBitmap* other = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(otherPtr));
instance->swap(*other);
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Bitmap__1nGetImageInfo
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
return skija::ImageInfo::toJava(env, instance->info());
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Bitmap__1nGetRowBytesAsPixels
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
return instance->rowBytesAsPixels();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Bitmap__1nIsNull
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
return instance->isNull();
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Bitmap__1nGetRowBytes
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
return instance->rowBytes();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Bitmap__1nSetAlphaType
(JNIEnv* env, jclass jclass, jlong ptr, jint alphaType) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
return instance->setAlphaType(static_cast<SkAlphaType>(alphaType));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Bitmap__1nComputeByteSize
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
return instance->computeByteSize();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Bitmap__1nIsImmutable
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
return instance->isImmutable();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Bitmap__1nSetImmutable
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
instance->setImmutable();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Bitmap__1nReset
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
instance->reset();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Bitmap__1nComputeIsOpaque
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
return SkBitmap::ComputeIsOpaque(*instance);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Bitmap__1nSetImageInfo
(JNIEnv* env, jclass jclass, jlong ptr, jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr, jlong rowBytes) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr));
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
static_cast<SkAlphaType>(alphaType),
sk_ref_sp<SkColorSpace>(colorSpace));
return instance->setInfo(imageInfo, rowBytes);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Bitmap__1nAllocPixelsFlags
(JNIEnv* env, jclass jclass, jlong ptr, jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr, jint flags) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr));
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
static_cast<SkAlphaType>(alphaType),
sk_ref_sp<SkColorSpace>(colorSpace));
return instance->tryAllocPixelsFlags(imageInfo, flags);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Bitmap__1nAllocPixelsRowBytes
(JNIEnv* env, jclass jclass, jlong ptr, jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr, jlong rowBytes) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr));
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
static_cast<SkAlphaType>(alphaType),
sk_ref_sp<SkColorSpace>(colorSpace));
return instance->tryAllocPixels(imageInfo, rowBytes);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Bitmap__1nInstallPixels
(JNIEnv* env, jclass jclass, jlong ptr, jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr, jbyteArray pixelsArr, jlong rowBytes) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr));
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
static_cast<SkAlphaType>(alphaType),
sk_ref_sp<SkColorSpace>(colorSpace));
jsize len = env->GetArrayLength(pixelsArr);
jbyte* pixels = new jbyte[len];
env->GetByteArrayRegion(pixelsArr, 0, len, pixels);
return instance->installPixels(imageInfo, pixels, rowBytes, deleteJBytes, nullptr);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Bitmap__1nAllocPixels
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
return instance->tryAllocPixels();
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Bitmap__1nGetPixelRef
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SkPixelRef* pixelRef = instance->pixelRef();
pixelRef->ref();
return reinterpret_cast<jlong>(pixelRef);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Bitmap__1nGetPixelRefOrigin
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SkIPoint origin = instance->pixelRefOrigin();
return packIPoint(origin);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Bitmap__1nSetPixelRef
(JNIEnv* env, jclass jclass, jlong ptr, jlong pixelRefPtr, jint dx, jint dy) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SkPixelRef* pixelRef = reinterpret_cast<SkPixelRef*>(static_cast<uintptr_t>(pixelRefPtr));
instance->setPixelRef(sk_ref_sp<SkPixelRef>(pixelRef), dx, dy);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Bitmap__1nIsReadyToDraw
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
return instance->readyToDraw();
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Bitmap__1nGetGenerationId
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
return instance->getGenerationID();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Bitmap__1nNotifyPixelsChanged
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
instance->notifyPixelsChanged();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Bitmap__1nEraseColor
(JNIEnv* env, jclass jclass, jlong ptr, jint color) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
instance->eraseColor(color);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Bitmap__1nErase
(JNIEnv* env, jclass jclass, jlong ptr, jint color, jint left, jint top, jint right, jint bottom) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
instance->erase(color, {left, top, right, bottom});
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Bitmap__1nGetColor
(JNIEnv* env, jclass jclass, jlong ptr, jint x, jint y) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
return instance->getColor(x, y);
}
extern "C" JNIEXPORT jfloat JNICALL Java_org_jetbrains_skija_Bitmap__1nGetAlphaf
(JNIEnv* env, jclass jclass, jlong ptr, jint x, jint y) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
return instance->getAlphaf(x, y);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Bitmap__1nExtractSubset
(JNIEnv* env, jclass jclass, jlong ptr, jlong dstPtr, jint left, jint top, jint right, jint bottom) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SkBitmap* dst = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(dstPtr));
return instance->extractSubset(dst, {left, top, right, bottom});
}
extern "C" JNIEXPORT jbyteArray JNICALL Java_org_jetbrains_skija_Bitmap__1nReadPixels
(JNIEnv* env, jclass jclass, jlong ptr, jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr, jlong rowBytes, jint srcX, jint srcY) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr));
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
static_cast<SkAlphaType>(alphaType),
sk_ref_sp<SkColorSpace>(colorSpace));
std::vector<jbyte> pixels(std::min(height, instance->height() - srcY) * rowBytes);
if (instance->readPixels(imageInfo, pixels.data(), rowBytes, srcX, srcY))
return javaByteArray(env, pixels);
else
return nullptr;
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Bitmap__1nExtractAlpha
(JNIEnv* env, jclass jclass, jlong ptr, jlong dstPtr, jlong paintPtr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SkBitmap* dst = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(dstPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
SkIPoint offset;
if (instance->extractAlpha(dst, paint, &offset))
return skija::IPoint::fromSkIPoint(env, offset);
else
return nullptr;
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Bitmap__1nPeekPixels
(JNIEnv* env, jclass jclass, jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SkPixmap pixmap;
if (instance->peekPixels(&pixmap))
return env->NewDirectByteBuffer(pixmap.writable_addr(), pixmap.rowBytes() * pixmap.height());
else
return nullptr;
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Bitmap__1nMakeShader
(JNIEnv* env, jclass jclass, jlong ptr, jint tmx, jint tmy, jlong samplingMode, jfloatArray localMatrixArr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
std::unique_ptr<SkMatrix> localMatrix = skMatrix(env, localMatrixArr);
sk_sp<SkShader> shader = instance->makeShader(static_cast<SkTileMode>(tmx), static_cast<SkTileMode>(tmy), skija::SamplingMode::unpack(samplingMode), localMatrix.get());
return reinterpret_cast<jlong>(shader.release());
}
skiko/src/jvmMain/cpp/common/BreakIterator.cc 0 → 100644
View file @ 228274af
#include <jni.h>
#include "interop.hh"
#include "unicode/ubrk.h"
static void deleteBreakIterator(UBreakIterator* instance) {
ubrk_close(instance);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_BreakIterator__1nGetFinalizer(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteBreakIterator));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_BreakIterator__1nMake
(JNIEnv* env, jclass jclass, jint type, jstring localeStr) {
UErrorCode status = U_ZERO_ERROR;
UBreakIterator* instance;
if (localeStr == nullptr)
instance = ubrk_open(static_cast<UBreakIteratorType>(type), uloc_getDefault(), nullptr, 0, &status);
else {
SkString locale = skString(env, localeStr);
instance = ubrk_open(static_cast<UBreakIteratorType>(type), locale.c_str(), nullptr, 0, &status);
}
if (U_FAILURE(status)) {
env->ThrowNew(java::lang::RuntimeException::cls, u_errorName(status));
return 0;
} else
return reinterpret_cast<jlong>(instance);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_BreakIterator__1nClone
(JNIEnv* env, jclass jclass, jlong ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
UErrorCode status = U_ZERO_ERROR;
UBreakIterator* clone = ubrk_safeClone(instance, nullptr, 0, &status);
if (U_FAILURE(status)) {
env->ThrowNew(java::lang::RuntimeException::cls, u_errorName(status));
return 0;
} else
return reinterpret_cast<jlong>(clone);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_BreakIterator__1nCurrent
(JNIEnv* env, jclass jclass, jlong ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
return ubrk_current(instance);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_BreakIterator__1nNext
(JNIEnv* env, jclass jclass, jlong ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
return ubrk_next(instance);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_BreakIterator__1nPrevious
(JNIEnv* env, jclass jclass, jlong ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
return ubrk_previous(instance);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_BreakIterator__1nFirst
(JNIEnv* env, jclass jclass, jlong ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
return ubrk_first(instance);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_BreakIterator__1nLast
(JNIEnv* env, jclass jclass, jlong ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
return ubrk_last(instance);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_BreakIterator__1nPreceding
(JNIEnv* env, jclass jclass, jlong ptr, jint offset) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
return ubrk_preceding(instance, offset);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_BreakIterator__1nFollowing
(JNIEnv* env, jclass jclass, jlong ptr, jint offset) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
return ubrk_following(instance, offset);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_BreakIterator__1nIsBoundary
(JNIEnv* env, jclass jclass, jlong ptr, jint offset) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
return ubrk_isBoundary(instance, offset);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_BreakIterator__1nGetRuleStatus
(JNIEnv* env, jclass jclass, jlong ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
return ubrk_getRuleStatus(instance);
}
extern "C" JNIEXPORT jintArray JNICALL Java_org_jetbrains_skija_BreakIterator__1nGetRuleStatuses
(JNIEnv* env, jclass jclass, jlong ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
UErrorCode status = U_ZERO_ERROR;
int32_t len = ubrk_getRuleStatusVec(instance, nullptr, 0, &status);
if (U_FAILURE(status))
env->ThrowNew(java::lang::RuntimeException::cls, u_errorName(status));
std::vector<jint> vec(len);
ubrk_getRuleStatusVec(instance, reinterpret_cast<int32_t*>(vec.data()), len, &status);
if (U_FAILURE(status))
env->ThrowNew(java::lang::RuntimeException::cls, u_errorName(status));
return javaIntArray(env, vec);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_BreakIterator__1nSetText
(JNIEnv* env, jclass jclass, jlong ptr, jlong textPtr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
std::vector<jchar>* text = reinterpret_cast<std::vector<jchar>*>(static_cast<uintptr_t>(textPtr));
UErrorCode status = U_ZERO_ERROR;
ubrk_setText(instance, reinterpret_cast<UChar *>(text->data()), text->size(), &status);
if (U_FAILURE(status))
env->ThrowNew(java::lang::RuntimeException::cls, u_errorName(status));
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/Canvas.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "SkCanvas.h"
#include "SkRRect.h"
#include "SkTextBlob.h"
#include "SkVertices.h"
#include "hb.h"
#include "interop.hh"
static void deleteCanvas(SkCanvas* canvas) {
// std::cout << "Deleting [SkCanvas " << canvas << "]" << std::endl;
delete canvas;
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Canvas__1nGetFinalizer(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteCanvas));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Canvas__1nMakeFromBitmap
(JNIEnv* env, jclass jclass, jlong bitmapPtr, jint flags, jint pixelGeometry) {
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(bitmapPtr));
SkCanvas* canvas = new SkCanvas(*bitmap, {static_cast<uint32_t>(flags), static_cast<SkPixelGeometry>(pixelGeometry)});
return reinterpret_cast<jlong>(canvas);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawPoint
(JNIEnv* env, jclass jclass, jlong canvasPtr, jfloat x, jfloat y, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
canvas->drawPoint(x, y, *paint);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawPoints
(JNIEnv* env, jclass jclass, jlong canvasPtr, int mode, jfloatArray coords, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
SkCanvas::PointMode skMode = static_cast<SkCanvas::PointMode>(mode);
jsize len = env->GetArrayLength(coords);
jfloat* arr = static_cast<jfloat*>(env->GetPrimitiveArrayCritical(coords, 0));
canvas->drawPoints(skMode, len / 2, reinterpret_cast<SkPoint*>(arr), *paint);
env->ReleasePrimitiveArrayCritical(coords, arr, 0);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawLine
(JNIEnv* env, jclass jclass, jlong canvasPtr, jfloat x0, jfloat y0, jfloat x1, jfloat y1, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
canvas->drawLine(x0, y0, x1, y1, *paint);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawArc
(JNIEnv* env, jclass jclass, jlong canvasPtr, jfloat left, jfloat top, jfloat right, jfloat bottom, jfloat startAngle, jfloat sweepAngle, jboolean includeCenter, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
canvas->drawArc({left, top, right, bottom}, startAngle, sweepAngle, includeCenter, *paint);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawRect
(JNIEnv* env, jclass jclass, jlong canvasPtr, jfloat left, jfloat top, jfloat right, jfloat bottom, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
canvas->drawRect({left, top, right, bottom}, *paint);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawOval
(JNIEnv* env, jclass jclass, jlong canvasPtr, jfloat left, jfloat top, jfloat right, jfloat bottom, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
canvas->drawOval({left, top, right, bottom}, *paint);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawRRect
(JNIEnv* env, jclass jclass, jlong canvasPtr, jfloat left, jfloat top, jfloat right, jfloat bottom, jfloatArray jradii, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
canvas->drawRRect(skija::RRect::toSkRRect(env, left, top, right, bottom, jradii), *paint);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawDRRect
(JNIEnv* env, jclass jclass, jlong canvasPtr,
jfloat ol, jfloat ot, jfloat oright, jfloat ob, jfloatArray ojradii,
jfloat il, jfloat it, jfloat ir, jfloat ib, jfloatArray ijradii,
jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
canvas->drawDRRect(skija::RRect::toSkRRect(env, ol, ot, oright, ob, ojradii),
skija::RRect::toSkRRect(env, il, it, ir, ib, ijradii), *paint);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawPath
(JNIEnv* env, jclass jclass, jlong canvasPtr, jlong pathPtr, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkPath* path = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(pathPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
canvas->drawPath(*path, *paint);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawImageRect
(JNIEnv* env, jclass jclass, jlong canvasPtr, jlong imagePtr, jfloat sl, jfloat st, jfloat sr, jfloat sb, jfloat dl, jfloat dt, jfloat dr, jfloat db, jlong samplingMode, jlong paintPtr, jboolean strict) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkImage* image = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(imagePtr));
SkRect src {sl, st, sr, sb};
SkRect dst {dl, dt, dr, db};
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
SkCanvas::SrcRectConstraint constraint = strict ? SkCanvas::SrcRectConstraint::kStrict_SrcRectConstraint : SkCanvas::SrcRectConstraint::kFast_SrcRectConstraint;
canvas->drawImageRect(image, src, dst, skija::SamplingMode::unpack(samplingMode), paint, constraint);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawImageNine
(JNIEnv* env, jclass jclass, jlong canvasPtr, jlong imagePtr, jint cl, jint ct, jint cr, jint cb, jfloat dl, jfloat dt, jfloat dr, jfloat db, jint filterMode, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkImage* image = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(imagePtr));
SkIRect center {cl, ct, cr, cb};
SkRect dst {dl, dt, dr, db};
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
canvas->drawImageNine(image, center, dst, static_cast<SkFilterMode>(filterMode), paint);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawRegion
(JNIEnv* env, jclass jclass, jlong canvasPtr, jlong regionPtr, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkRegion* region = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(regionPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
canvas->drawRegion(*region, *paint);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawString
(JNIEnv* env, jclass jclass, jlong canvasPtr, jstring stringObj, jfloat x, jfloat y, jlong skFontPtr, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*> (static_cast<uintptr_t>(canvasPtr));
SkString string = skString(env, stringObj);
SkFont* font = reinterpret_cast<SkFont*> (static_cast<uintptr_t>(skFontPtr));
SkPaint* paint = reinterpret_cast<SkPaint*> (static_cast<uintptr_t>(paintPtr));
canvas->drawString(string, x, y, *font, *paint);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawTextBlob
(JNIEnv* env, jclass jclass, jlong canvasPtr, jlong blobPtr, jfloat x, jfloat y, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*> (static_cast<uintptr_t>(canvasPtr));
SkTextBlob* blob = reinterpret_cast<SkTextBlob*>(static_cast<uintptr_t>(blobPtr));
SkPaint* paint = reinterpret_cast<SkPaint*> (static_cast<uintptr_t>(paintPtr));
canvas->drawTextBlob(blob, x, y, *paint);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawPicture
(JNIEnv* env, jclass jclass, jlong ptr, jlong picturePtr, jfloatArray matrixArr, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*> (static_cast<uintptr_t>(ptr));
SkPicture* picture = reinterpret_cast<SkPicture*>(static_cast<uintptr_t>(picturePtr));
std::unique_ptr<SkMatrix> matrix = skMatrix(env, matrixArr);
SkPaint* paint = reinterpret_cast<SkPaint*> (static_cast<uintptr_t>(paintPtr));
canvas->drawPicture(picture, matrix.get(), paint);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawVertices
(JNIEnv* env, jclass jclass, jlong ptr, jint verticesMode, jfloatArray positionsArr, jintArray colorsArr, jfloatArray texCoordsArr, jshortArray indexArr, jint blendMode, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*> (static_cast<uintptr_t>(ptr));
int indexCount = indexArr == nullptr ? 0 : env->GetArrayLength(indexArr);
jfloat* positions = env->GetFloatArrayElements(positionsArr, 0);
jint* colors = colorsArr == nullptr ? nullptr : env->GetIntArrayElements(colorsArr, 0);
jfloat* texCoords = texCoordsArr == nullptr ? nullptr : env->GetFloatArrayElements(texCoordsArr, 0);
const jshort* indices = indexArr == nullptr ? nullptr : env->GetShortArrayElements(indexArr, 0);
sk_sp<SkVertices> vertices = SkVertices::MakeCopy(
static_cast<SkVertices::VertexMode>(verticesMode),
env->GetArrayLength(positionsArr) / 2,
reinterpret_cast<SkPoint*>(positions),
reinterpret_cast<SkPoint*>(texCoords),
reinterpret_cast<SkColor*>(colors),
indexCount,
reinterpret_cast<const uint16_t *>(indices));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
canvas->drawVertices(vertices, static_cast<SkBlendMode>(blendMode), *paint);
if (texCoords != nullptr)
env->ReleaseFloatArrayElements(texCoordsArr, texCoords, 0);
if (colors != nullptr)
env->ReleaseIntArrayElements(colorsArr, colors, 0);
env->ReleaseFloatArrayElements(positionsArr, positions, 0);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawPatch
(JNIEnv* env, jclass jclass, jlong ptr, jfloatArray cubicsArr, jintArray colorsArr, jfloatArray texCoordsArr, jint blendMode, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*> (static_cast<uintptr_t>(ptr));
jfloat* cubics = env->GetFloatArrayElements(cubicsArr, 0);
jint* colors = env->GetIntArrayElements(colorsArr, 0);
jfloat* texCoords = texCoordsArr == nullptr ? nullptr : env->GetFloatArrayElements(texCoordsArr, 0);
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
canvas->drawPatch(reinterpret_cast<SkPoint*>(cubics), reinterpret_cast<SkColor*>(colors), reinterpret_cast<SkPoint*>(texCoords), static_cast<SkBlendMode>(blendMode), *paint);
if (texCoords != nullptr)
env->ReleaseFloatArrayElements(texCoordsArr, texCoords, 0);
env->ReleaseIntArrayElements(colorsArr, colors, 0);
env->ReleaseFloatArrayElements(cubicsArr, cubics, 0);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawDrawable
(JNIEnv* env, jclass jclass, jlong ptr, jlong drawablePtr, jfloatArray matrixArr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr));
SkDrawable* drawable = reinterpret_cast<SkDrawable*>(static_cast<uintptr_t>(drawablePtr));
std::unique_ptr<SkMatrix> matrix = skMatrix(env, matrixArr);
canvas->drawDrawable(drawable, matrix.get());
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nClear(JNIEnv* env, jclass jclass, jlong ptr, jint color) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr));
canvas->clear(color);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nDrawPaint
(JNIEnv* env, jclass jclass, jlong canvasPtr, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
canvas->drawPaint(*paint);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nSetMatrix
(JNIEnv* env, jclass jclass, jlong canvasPtr, jfloatArray matrixArr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
std::unique_ptr<SkMatrix> matrix = skMatrix(env, matrixArr);
canvas->setMatrix(*matrix);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nResetMatrix
(JNIEnv* env, jclass jclass, jlong canvasPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
canvas->resetMatrix();
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Canvas__1nGetLocalToDevice
(JNIEnv* env, jclass jclass, jlong canvasPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkM44 matrix = canvas->getLocalToDevice();
std::vector<float> floats(16);
matrix.getRowMajor(floats.data());
return javaFloatArray(env, floats);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nClipRect
(JNIEnv* env, jclass jclass, jlong canvasPtr, jfloat left, jfloat top, jfloat right, jfloat bottom, jint mode, jboolean antiAlias) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
canvas->clipRect({left, top, right, bottom}, static_cast<SkClipOp>(mode), antiAlias);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nClipRRect
(JNIEnv* env, jclass jclass, jlong canvasPtr, jfloat left, jfloat top, jfloat right, jfloat bottom, jfloatArray jradii, jint mode, jboolean antiAlias) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
canvas->clipRRect(skija::RRect::toSkRRect(env, left, top, right, bottom, jradii), static_cast<SkClipOp>(mode), antiAlias);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nClipPath
(JNIEnv* env, jclass jclass, jlong canvasPtr, jlong pathPtr, jint mode, jboolean antiAlias) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkPath* path = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(pathPtr));
canvas->clipPath(*path, static_cast<SkClipOp>(mode), antiAlias);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nClipRegion
(JNIEnv* env, jclass jclass, jlong canvasPtr, jlong regionPtr, jint mode) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkRegion* region = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(regionPtr));
canvas->clipRegion(*region, static_cast<SkClipOp>(mode));
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nConcat
(JNIEnv* env, jclass jclass, jlong ptr, jfloatArray matrixArr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr));
std::unique_ptr<SkMatrix> m = skMatrix(env, matrixArr);
canvas->concat(*m);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nConcat44
(JNIEnv* env, jclass jclass, jlong ptr, jfloatArray matrixArr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr));
std::unique_ptr<SkM44> m = skM44(env, matrixArr);
canvas->concat(*m);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Canvas__1nReadPixels
(JNIEnv* env, jclass jclass, jlong ptr, jlong bitmapPtr, jint srcX, jint srcY) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr));
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(bitmapPtr));
return canvas->readPixels(*bitmap, srcX, srcY);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Canvas__1nWritePixels
(JNIEnv* env, jclass jclass, jlong ptr, jlong bitmapPtr, jint x, jint y) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr));
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(bitmapPtr));
return canvas->writePixels(*bitmap, x, y);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Canvas__1nSave(JNIEnv* env, jclass jclass, jlong ptr) {
return reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr))->save();
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Canvas__1nSaveLayer
(JNIEnv* env, jclass jclass, jlong ptr, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
return canvas->saveLayer(nullptr, paint);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Canvas__1nSaveLayerRect
(JNIEnv* env, jclass jclass, jlong ptr, jfloat left, jfloat top, jfloat right, jfloat bottom, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr));
SkRect bounds {left, top, right, bottom};
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
return canvas->saveLayer(&bounds, paint);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Canvas__1nGetSaveCount(JNIEnv* env, jclass jclass, jlong ptr) {
return reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr))->getSaveCount();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nRestore(JNIEnv* env, jclass jclass, jlong ptr) {
reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr))->restore();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Canvas__1nRestoreToCount(JNIEnv* env, jclass jclass, jlong ptr, jint saveCount) {
reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr))->restoreToCount(saveCount);
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/Codec.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "SkBitmap.h"
#include "SkCodec.h"
#include "SkData.h"
#include "interop.hh"
static void deleteCodec(SkCodec* instance) {
delete instance;
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Codec__1nGetFinalizer(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteCodec));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Codec__1nMakeFromData
(JNIEnv* env, jclass jclass, jlong dataPtr) {
SkData* data = reinterpret_cast<SkData*>(static_cast<uintptr_t>(dataPtr));
std::unique_ptr<SkCodec> instance = SkCodec::MakeFromData(sk_ref_sp(data));
return reinterpret_cast<jlong>(instance.release());
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Codec__1nGetImageInfo
(JNIEnv* env, jclass jclass, jlong ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
return skija::ImageInfo::toJava(env, instance->getInfo());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Codec__1nGetSize
(JNIEnv* env, jclass jclass, jlong ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
return packISize(instance->dimensions());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Codec__1nGetEncodedOrigin
(JNIEnv* env, jclass jclass, jlong ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
return static_cast<jint>(instance->getOrigin());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Codec__1nGetEncodedImageFormat
(JNIEnv* env, jclass jclass, jlong ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
return static_cast<jint>(instance->getEncodedFormat());
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Codec__1nReadPixels
(JNIEnv* env, jclass jclass, jlong ptr, jlong bitmapPtr, jint frame, jint priorFrame) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(bitmapPtr));
SkCodec::Options opts;
opts.fFrameIndex = frame;
opts.fPriorFrame = priorFrame;
SkCodec::Result result = instance->getPixels(bitmap->info(), bitmap->getPixels(), bitmap->rowBytes(), &opts);
return static_cast<jint>(result);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Codec__1nGetFrameCount
(JNIEnv* env, jclass jclass, jlong ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
return instance->getFrameCount();
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Codec__1nGetFrameInfo
(JNIEnv* env, jclass jclass, jlong ptr, jint frame) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
SkCodec::FrameInfo info;
instance->getFrameInfo(frame, &info);
return skija::AnimationFrameInfo::toJava(env, info);
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Codec__1nGetFramesInfo
(JNIEnv* env, jclass jclass, jlong ptr, jint frame) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
SkCodec::FrameInfo info;
std::vector<SkCodec::FrameInfo> frames = instance->getFrameInfo();
jobjectArray res = env->NewObjectArray(frames.size(), skija::AnimationFrameInfo::cls, nullptr);
if (java::lang::Throwable::exceptionThrown(env))
return nullptr;
for (int i = 0; i < frames.size(); ++i) {
skija::AutoLocal<jobject> infoObj(env, skija::AnimationFrameInfo::toJava(env, frames[i]));
env->SetObjectArrayElement(res, i, infoObj.get());
}
return res;
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Codec__1nGetRepetitionCount
(JNIEnv* env, jclass jclass, jlong ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
return instance->getRepetitionCount();
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/ColorFilter.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "SkColorFilter.h"
#include "SkColorMatrixFilter.h"
#include "SkHighContrastFilter.h"
#include "SkLumaColorFilter.h"
#include "SkOverdrawColorFilter.h"
#include "SkTableColorFilter.h"
#include "interop.hh"
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorFilter__1nMakeComposed
(JNIEnv* env, jclass jclass, jlong outerPtr, jlong innerPtr) {
SkColorFilter* outer = reinterpret_cast<SkColorFilter*>(static_cast<uintptr_t>(outerPtr));
SkColorFilter* inner = reinterpret_cast<SkColorFilter*>(static_cast<uintptr_t>(innerPtr));
SkColorFilter* ptr = SkColorFilters::Compose(sk_ref_sp(outer), sk_ref_sp(inner)).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorFilter__1nMakeBlend
(JNIEnv* env, jclass jclass, jint colorInt, jint modeInt) {
SkColor color = static_cast<SkColor>(colorInt);
SkBlendMode mode = static_cast<SkBlendMode>(modeInt);
SkColorFilter* ptr = SkColorFilters::Blend(color, mode).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorFilter__1nMakeMatrix
(JNIEnv* env, jclass jclass, jfloatArray rowMajorArray) {
jfloat* rowMajor = env->GetFloatArrayElements(rowMajorArray, 0);
SkColorFilter* ptr = SkColorFilters::Matrix(rowMajor).release();
env->ReleaseFloatArrayElements(rowMajorArray, rowMajor, 0);
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorFilter__1nMakeHSLAMatrix
(JNIEnv* env, jclass jclass, jfloatArray rowMajorArray) {
jfloat* rowMajor = env->GetFloatArrayElements(rowMajorArray, 0);
SkColorFilter* ptr = SkColorFilters::HSLAMatrix(rowMajor).release();
env->ReleaseFloatArrayElements(rowMajorArray, rowMajor, 0);
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorFilter__1nGetLinearToSRGBGamma
(JNIEnv* env, jclass jclass) {
SkColorFilter* ptr = SkColorFilters::LinearToSRGBGamma().release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorFilter__1nGetSRGBToLinearGamma
(JNIEnv* env, jclass jclass) {
SkColorFilter* ptr = SkColorFilters::SRGBToLinearGamma().release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorFilter__1nMakeLerp
(JNIEnv* env, jclass jclass, jfloat t, jlong dstPtr, jlong srcPtr) {
SkColorFilter* dst = reinterpret_cast<SkColorFilter*>(static_cast<uintptr_t>(dstPtr));
SkColorFilter* src = reinterpret_cast<SkColorFilter*>(static_cast<uintptr_t>(srcPtr));
SkColorFilter* ptr = SkColorFilters::Lerp(t, sk_ref_sp(dst), sk_ref_sp(src)).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorFilter__1nMakeLighting
(JNIEnv* env, jclass jclass, jint mul, jint add) {
SkColorFilter* ptr = SkColorMatrixFilter::MakeLightingFilter(mul, add).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorFilter__1nMakeHighContrast
(JNIEnv* env, jclass jclass, jboolean grayscale, jint inverionModeInt, jfloat contrast) {
SkHighContrastConfig config(grayscale, static_cast<SkHighContrastConfig::InvertStyle>(inverionModeInt), contrast);
SkColorFilter* ptr = SkHighContrastFilter::Make(config).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorFilter__1nMakeTable
(JNIEnv* env, jclass jclass, jbyteArray tableArray) {
jbyte* table = env->GetByteArrayElements(tableArray, 0);
SkColorFilter* ptr = SkTableColorFilter::Make(reinterpret_cast<uint8_t*>(table)).release();
env->ReleaseByteArrayElements(tableArray, table, 0);
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorFilter__1nMakeTableARGB
(JNIEnv* env, jclass jclass, jbyteArray arrayA, jbyteArray arrayR, jbyteArray arrayG, jbyteArray arrayB) {
jbyte* a = arrayA ? env->GetByteArrayElements(arrayA, 0) : nullptr;
jbyte* r = arrayR ? env->GetByteArrayElements(arrayR, 0) : nullptr;
jbyte* g = arrayG ? env->GetByteArrayElements(arrayG, 0) : nullptr;
jbyte* b = arrayB ? env->GetByteArrayElements(arrayB, 0) : nullptr;
SkColorFilter* ptr = SkTableColorFilter::MakeARGB(reinterpret_cast<uint8_t*>(a), reinterpret_cast<uint8_t*>(r), reinterpret_cast<uint8_t*>(g), reinterpret_cast<uint8_t*>(b)).release();
if (arrayA) env->ReleaseByteArrayElements(arrayA, a, 0);
if (arrayR) env->ReleaseByteArrayElements(arrayR, r, 0);
if (arrayG) env->ReleaseByteArrayElements(arrayG, g, 0);
if (arrayB) env->ReleaseByteArrayElements(arrayB, b, 0);
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorFilter__1nMakeOverdraw
(JNIEnv* env, jclass jclass, jint c0, jint c1, jint c2, jint c3, jint c4, jint c5) {
SkColor colors[6];
colors[0] = c0;
colors[1] = c1;
colors[2] = c2;
colors[3] = c3;
colors[4] = c4;
colors[5] = c5;
SkColorFilter* ptr = SkOverdrawColorFilter::MakeWithSkColors(colors).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorFilter__1nGetLuma
(JNIEnv* env, jclass jclass) {
SkColorFilter* ptr = SkLumaColorFilter::Make().release();
return reinterpret_cast<jlong>(ptr);
}
skiko/src/jvmMain/cpp/common/ColorSpace.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "SkColorSpace.h"
#include "interop.hh"
static void unrefColorSpace(SkColorSpace* ptr) {
// std::cout << "Deleting [SkColorSpace " << ptr << "]" << std::endl;
ptr->unref();
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorSpace__1nGetFinalizer(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&unrefColorSpace));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorSpace__1nMakeSRGB(JNIEnv* env, jclass jclass) {
SkColorSpace* ptr = SkColorSpace::MakeSRGB().release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorSpace__1nMakeSRGBLinear(JNIEnv* env, jclass jclass) {
SkColorSpace* ptr = SkColorSpace::MakeSRGBLinear().release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorSpace__1nMakeDisplayP3(JNIEnv* env, jclass jclass) {
SkColorSpace* ptr = SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kDisplayP3).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jfloatArray JNICALL Java_org_jetbrains_skija_ColorSpace__1nConvert
(JNIEnv* env, jclass jclass, jlong fromPtr, jlong toPtr, float r, float g, float b, float a) {
SkColorSpace* from = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(fromPtr));
SkColorSpace* to = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(toPtr));
skcms_TransferFunction fromFn;
from->transferFn(&fromFn);
skcms_TransferFunction toFn;
to->invTransferFn(&toFn);
float r1 = skcms_TransferFunction_eval(&toFn, skcms_TransferFunction_eval(&fromFn, r));
float g1 = skcms_TransferFunction_eval(&toFn, skcms_TransferFunction_eval(&fromFn, g));
float b1 = skcms_TransferFunction_eval(&toFn, skcms_TransferFunction_eval(&fromFn, b));
float a1 = skcms_TransferFunction_eval(&toFn, skcms_TransferFunction_eval(&fromFn, a));
return javaFloatArray(env, {r1, g1, b1, a1});
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorSpace__1nIsGammaCloseToSRGB
(JNIEnv* env, jclass jclass, jlong ptr) {
SkColorSpace* instance = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(ptr));
return instance->gammaCloseToSRGB();
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorSpace__1nIsGammaLinear
(JNIEnv* env, jclass jclass, jlong ptr) {
SkColorSpace* instance = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(ptr));
return instance->gammaIsLinear();
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorSpace__1nIsSRGB
(JNIEnv* env, jclass jclass, jlong ptr) {
SkColorSpace* instance = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(ptr));
return instance->isSRGB();
}
skiko/src/jvmMain/cpp/common/ColorType.cc 0 → 100644
View file @ 228274af
#include <jni.h>
#include "SkImageInfo.h"
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ColorType__1nIsAlwaysOpaque
(JNIEnv* env, jclass jclass, jint value) {
return SkColorTypeIsAlwaysOpaque(static_cast<SkColorType>(value));
}
skiko/src/jvmMain/cpp/common/Data.cc 0 → 100644
View file @ 228274af
#include <jni.h>
#include "interop.hh"
#include "SkData.h"
static void deleteData(SkData* data) {
// std::cout << "Deleting [SkData " << data << "]" << std::endl;
data->unref();
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Data__1nGetFinalizer(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteData));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Data__1nSize
(JNIEnv* env, jclass jclass, jlong ptr) {
SkData* instance = reinterpret_cast<SkData*>(static_cast<uintptr_t>(ptr));
return instance->size();
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Data__1nToByteBuffer
(JNIEnv* env, jclass jclass, jlong ptr) {
SkData* instance = reinterpret_cast<SkData*>(static_cast<uintptr_t>(ptr));
return env->NewDirectByteBuffer(instance->writable_data(), instance->size());
}
extern "C" JNIEXPORT jbyteArray JNICALL Java_org_jetbrains_skija_Data__1nBytes
(JNIEnv* env, jclass jclass, jlong ptr, jlong offset, jlong length) {
SkData* instance = reinterpret_cast<SkData*>(static_cast<uintptr_t>(ptr));
jbyteArray bytesArray = env->NewByteArray((jsize) length);
const jbyte* bytes = reinterpret_cast<const jbyte*>(instance->bytes() + offset);
env->SetByteArrayRegion(bytesArray, 0, (jsize) length, bytes);
return bytesArray;
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Data__1nEquals
(JNIEnv* env, jclass jclass, jlong ptr, jlong otherPtr) {
SkData* instance = reinterpret_cast<SkData*>(static_cast<uintptr_t>(ptr));
SkData* other = reinterpret_cast<SkData*>(static_cast<uintptr_t>(otherPtr));
return instance->equals(other);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Data__1nMakeFromBytes
(JNIEnv* env, jclass jclass, jbyteArray bytesArray, jlong offset, jlong length) {
jbyte* bytes = reinterpret_cast<jbyte*>(malloc(length));
if (!bytes) return 0;
env->GetByteArrayRegion(bytesArray, (jsize) offset, (jsize) length, bytes);
SkData* instance = SkData::MakeFromMalloc(bytes, length).release();
return reinterpret_cast<jlong>(instance);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Data__1nMakeFromFileName
(JNIEnv* env, jclass jclass, jstring pathStr) {
SkString path = skString(env, pathStr);
SkData* instance = SkData::MakeFromFileName(path.c_str()).release();
return reinterpret_cast<jlong>(instance);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Data__1nMakeSubset
(JNIEnv* env, jclass jclass, jlong ptr, jlong offset, jlong length) {
SkData* instance = reinterpret_cast<SkData*>(static_cast<uintptr_t>(ptr));
SkData* subset = SkData::MakeSubset(instance, offset, length).release();
return reinterpret_cast<jlong>(subset);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Data__1nMakeEmpty
(JNIEnv* env, jclass jclass) {
SkData* instance = SkData::MakeEmpty().release();
return reinterpret_cast<jlong>(instance);
}
skiko/src/jvmMain/cpp/common/DirectContext.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "GrDirectContext.h"
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_DirectContext__1nMakeGL
(JNIEnv* env, jclass jclass) {
return reinterpret_cast<jlong>(GrDirectContext::MakeGL().release());
}
#ifdef SK_METAL
#include "mtl/GrMtlBackendContext.h"
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_DirectContext__1nMakeMetal
(JNIEnv* env, jclass jclass, long devicePtr, long queuePtr) {
GrMtlBackendContext backendContext = {};
GrMTLHandle device = reinterpret_cast<GrMTLHandle>(static_cast<uintptr_t>(devicePtr));
GrMTLHandle queue = reinterpret_cast<GrMTLHandle>(static_cast<uintptr_t>(queuePtr));
backendContext.fDevice.retain(device);
backendContext.fQueue.retain(queue);
sk_sp<GrDirectContext> instance = GrDirectContext::MakeMetal(backendContext);
return reinterpret_cast<jlong>(instance.release());
}
#endif
#ifdef SK_DIRECT3D
#include "d3d/GrD3DBackendContext.h"
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_DirectContext__1nMakeDirect3D
(JNIEnv* env, jclass jclass, jlong adapterPtr, jlong devicePtr, jlong queuePtr) {
GrD3DBackendContext backendContext = {};
IDXGIAdapter1* adapter = reinterpret_cast<IDXGIAdapter1*>(static_cast<uintptr_t>(adapterPtr));
ID3D12Device* device = reinterpret_cast<ID3D12Device*>(static_cast<uintptr_t>(devicePtr));
ID3D12CommandQueue* queue = reinterpret_cast<ID3D12CommandQueue*>(static_cast<uintptr_t>(queuePtr));
backendContext.fAdapter.retain(adapter);
backendContext.fDevice.retain(device);
backendContext.fQueue.retain(queue);
sk_sp<GrDirectContext> instance = GrDirectContext::MakeDirect3D(backendContext);
return reinterpret_cast<jlong>(instance.release());
}
#endif //SK_DIRECT3D
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_DirectContext__1nFlush
(JNIEnv* env, jclass jclass, jlong ptr) {
GrDirectContext* context = reinterpret_cast<GrDirectContext*>(static_cast<uintptr_t>(ptr));
context->flush(GrFlushInfo());
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_DirectContext__1nSubmit
(JNIEnv* env, jclass jclass, jlong ptr, jboolean syncCpu) {
GrDirectContext* context = reinterpret_cast<GrDirectContext*>(static_cast<uintptr_t>(ptr));
context->submit(syncCpu);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_DirectContext__1nReset
(JNIEnv* env, jclass jclass, jlong ptr, jint flags) {
GrDirectContext* context = reinterpret_cast<GrDirectContext*>(static_cast<uintptr_t>(ptr));
context->resetContext((uint32_t) flags);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_DirectContext__1nAbandon
(JNIEnv* env, jclass jclass, jlong ptr, jint flags) {
GrDirectContext* context = reinterpret_cast<GrDirectContext*>(static_cast<uintptr_t>(ptr));
context->abandonContext();
}
skiko/src/jvmMain/cpp/common/Drawable.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "SkDrawable.h"
#include "interop.hh"
class SkijaDrawableImpl: public SkDrawable {
public:
SkijaDrawableImpl() {
}
~SkijaDrawableImpl() {
JNIEnv* env;
if (fJavaVM->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_8) == JNI_OK)
env->DeleteWeakGlobalRef(fObject);
}
void init(JNIEnv* e, jobject o) {
fEnv = e;
fEnv->GetJavaVM(&fJavaVM);
fObject = fEnv->NewWeakGlobalRef(o);
}
protected:
void onDraw(SkCanvas* canvas) override {
fEnv->CallVoidMethod(fObject, skija::Drawable::onDraw, reinterpret_cast<jlong>(canvas));
java::lang::Throwable::exceptionThrown(fEnv);
}
SkRect onGetBounds() override {
skija::AutoLocal<jobject> rect(fEnv, fEnv->CallObjectMethod(fObject, skija::Drawable::onGetBounds));
java::lang::Throwable::exceptionThrown(fEnv);
return *(skija::Rect::toSkRect(fEnv, rect.get()));
}
private:
JNIEnv* fEnv;
JavaVM* fJavaVM;
jobject fObject;
};
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Drawable__1nMake
(JNIEnv* env, jclass jclass) {
SkijaDrawableImpl* instance = new SkijaDrawableImpl();
return reinterpret_cast<jlong>(instance);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Drawable__1nInit
(JNIEnv* env, jobject jthis, jlong ptr) {
SkijaDrawableImpl* instance = reinterpret_cast<SkijaDrawableImpl*>(static_cast<uintptr_t>(ptr));
instance->init(env, jthis);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Drawable__1nDraw
(JNIEnv* env, jclass jclass, jlong ptr, jlong canvasPtr, jfloatArray matrixArr) {
SkijaDrawableImpl* instance = reinterpret_cast<SkijaDrawableImpl*>(static_cast<uintptr_t>(ptr));
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
std::unique_ptr<SkMatrix> matrix = skMatrix(env, matrixArr);
instance->draw(canvas, matrix.get());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Drawable__1nMakePictureSnapshot
(JNIEnv* env, jclass jclass, jlong ptr) {
SkijaDrawableImpl* instance = reinterpret_cast<SkijaDrawableImpl*>(static_cast<uintptr_t>(ptr));
return reinterpret_cast<jlong>(instance->newPictureSnapshot());
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Drawable__1nGetGenerationId
(JNIEnv* env, jclass jclass, jlong ptr) {
SkijaDrawableImpl* instance = reinterpret_cast<SkijaDrawableImpl*>(static_cast<uintptr_t>(ptr));
return instance->getGenerationID();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Drawable__1nNotifyDrawingChanged
(JNIEnv* env, jclass jclass, jlong ptr) {
SkijaDrawableImpl* instance = reinterpret_cast<SkijaDrawableImpl*>(static_cast<uintptr_t>(ptr));
return instance->notifyDrawingChanged();
}
skiko/src/jvmMain/cpp/common/Font.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "SkFont.h"
#include "SkPath.h"
#include "SkShaper.h"
#include "interop.hh"
static void deleteFont(SkFont* font) {
// std::cout << "Deleting [Font " << font << "]" << std::endl;
delete font;
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Font__1nGetFinalizer
(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteFont));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Font__1nMakeDefault
(JNIEnv* env, jclass jclass) {
SkFont* obj = new SkFont();
return reinterpret_cast<jlong>(obj);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Font__1nMakeTypeface
(JNIEnv* env, jclass jclass, jlong typefacePtr) {
SkTypeface* typeface = reinterpret_cast<SkTypeface*>(static_cast<uintptr_t>(typefacePtr));
SkFont* obj = new SkFont(sk_ref_sp<SkTypeface>(typeface));
return reinterpret_cast<jlong>(obj);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Font__1nMakeTypefaceSize
(JNIEnv* env, jclass jclass, jlong typefacePtr, jfloat size) {
SkTypeface* typeface = reinterpret_cast<SkTypeface*>(static_cast<uintptr_t>(typefacePtr));
SkFont* obj = new SkFont(sk_ref_sp<SkTypeface>(typeface), size);
return reinterpret_cast<jlong>(obj);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Font__1nMakeTypefaceSizeScaleSkew
(JNIEnv* env, jclass jclass, jlong typefacePtr, jfloat size, jfloat scaleX, jfloat skewX) {
SkTypeface* typeface = reinterpret_cast<SkTypeface*>(static_cast<uintptr_t>(typefacePtr));
SkFont* obj = new SkFont(sk_ref_sp<SkTypeface>(typeface), size, scaleX, skewX);
return reinterpret_cast<jlong>(obj);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Font__1nMakeClone
(JNIEnv* env, jclass jclass, jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SkFont* clone = new SkFont(*instance);
return reinterpret_cast<jlong>(clone);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Font__1nEquals
(JNIEnv* env, jclass jclass, jlong ptr, jlong otherPtr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SkFont* other = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(otherPtr));
return *instance == *other;
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Font__1nIsAutoHintingForced
(JNIEnv* env, jclass jclass, jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
return instance->isForceAutoHinting();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Font__1nAreBitmapsEmbedded
(JNIEnv* env, jclass jclass, jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
return instance->isEmbeddedBitmaps();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Font__1nIsSubpixel
(JNIEnv* env, jclass jclass, jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
return instance->isSubpixel();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Font__1nAreMetricsLinear
(JNIEnv* env, jclass jclass, jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
return instance->isLinearMetrics();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Font__1nIsEmboldened
(JNIEnv* env, jclass jclass, jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
return instance->isEmbolden();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Font__1nIsBaselineSnapped
(JNIEnv* env, jclass jclass, jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
return instance->isBaselineSnap();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Font__1nSetAutoHintingForced
(JNIEnv* env, jclass jclass, jlong ptr, jboolean value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
instance->setForceAutoHinting(value);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Font__1nSetBitmapsEmbedded
(JNIEnv* env, jclass jclass, jlong ptr, jboolean value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
instance->setEmbeddedBitmaps(value);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Font__1nSetSubpixel
(JNIEnv* env, jclass jclass, jlong ptr, jboolean value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
instance->setSubpixel(value);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Font__1nSetMetricsLinear
(JNIEnv* env, jclass jclass, jlong ptr, jboolean value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
instance->setLinearMetrics(value);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Font__1nSetEmboldened
(JNIEnv* env, jclass jclass, jlong ptr, jboolean value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
instance->setEmbolden(value);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Font__1nSetBaselineSnapped
(JNIEnv* env, jclass jclass, jlong ptr, jboolean value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
instance->setBaselineSnap(value);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Font__1nGetEdging
(JNIEnv* env, jclass jclass, jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
return static_cast<jint>(instance->getEdging());
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Font__1nSetEdging
(JNIEnv* env, jclass jclass, jlong ptr, jint value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
instance->setEdging(static_cast<SkFont::Edging>(value));
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Font__1nGetHinting
(JNIEnv* env, jclass jclass, jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
return static_cast<jint>(instance->getHinting());
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Font__1nSetHinting
(JNIEnv* env, jclass jclass, jlong ptr, jint value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
instance->setHinting(static_cast<SkFontHinting>(value));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Font__1nGetTypeface
(JNIEnv* env, jclass jclass, jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SkTypeface* typeface = instance->refTypeface().release();
return reinterpret_cast<jlong>(typeface);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Font__1nGetTypefaceOrDefault
(JNIEnv* env, jclass jclass, jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SkTypeface* typeface = instance->refTypefaceOrDefault().release();
return reinterpret_cast<jlong>(typeface);
}
extern "C" JNIEXPORT jfloat JNICALL Java_org_jetbrains_skija_Font__1nGetSize
(JNIEnv* env, jclass jclass, jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
return instance->getSize();
}
extern "C" JNIEXPORT jfloat JNICALL Java_org_jetbrains_skija_Font__1nGetScaleX
(JNIEnv* env, jclass jclass, jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
return instance->getScaleX();
}
extern "C" JNIEXPORT jfloat JNICALL Java_org_jetbrains_skija_Font__1nGetSkewX
(JNIEnv* env, jclass jclass, jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
return instance->getSkewX();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Font__1nSetTypeface
(JNIEnv* env, jclass jclass, jlong ptr, jlong typefacePtr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SkTypeface* typeface = reinterpret_cast<SkTypeface*>(static_cast<uintptr_t>(typefacePtr));
instance->setTypeface(sk_ref_sp(typeface));
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Font__1nSetSize
(JNIEnv* env, jclass jclass, jlong ptr, jfloat value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
instance->setSize(value);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Font__1nSetScaleX
(JNIEnv* env, jclass jclass, jlong ptr, jfloat value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
instance->setScaleX(value);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Font__1nSetSkewX
(JNIEnv* env, jclass jclass, jlong ptr, jfloat value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
instance->setSkewX(value);
}
extern "C" JNIEXPORT jshortArray JNICALL Java_org_jetbrains_skija_Font__1nGetStringGlyphs
(JNIEnv* env, jclass jclass, jlong ptr, jstring str) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
jsize len = env->GetStringLength(str);
const jchar* chars = env->GetStringCritical(str, nullptr);
int count = instance->textToGlyphs(chars, len * sizeof(jchar), SkTextEncoding::kUTF16, nullptr, 0);
std::vector<short> glyphs(count);
instance->textToGlyphs(chars, len * sizeof(jchar), SkTextEncoding::kUTF16, reinterpret_cast<SkGlyphID*>(glyphs.data()), count);
env->ReleaseStringCritical(str, chars);
return javaShortArray(env, glyphs);
}
extern "C" JNIEXPORT jshortArray JNICALL Java_org_jetbrains_skija_Font__1nGetUTF32Glyphs
(JNIEnv* env, jclass jclass, jlong ptr, jintArray uniArr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
int count = env->GetArrayLength(uniArr);
std::vector<jshort> glyphs(count);
jint* uni = env->GetIntArrayElements(uniArr, nullptr);
instance->unicharsToGlyphs(reinterpret_cast<SkUnichar*>(uni), count, reinterpret_cast<SkGlyphID*>(glyphs.data()));
env->ReleaseIntArrayElements(uniArr, uni, 0);
return javaShortArray(env, glyphs);
}
extern "C" JNIEXPORT jshort JNICALL Java_org_jetbrains_skija_Font__1nGetUTF32Glyph
(JNIEnv* env, jclass jclass, jlong ptr, jint uni) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
return instance->unicharToGlyph(uni);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Font__1nGetStringGlyphsCount
(JNIEnv* env, jclass jclass, jlong ptr, jstring str) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
jsize len = env->GetStringLength(str);
const jchar* chars = env->GetStringCritical(str, nullptr);
int count = instance->countText(chars, len * sizeof(jchar), SkTextEncoding::kUTF16);
env->ReleaseStringCritical(str, chars);
return count;
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Font__1nMeasureText
(JNIEnv* env, jclass jclass, jlong ptr, jstring str, jlong paintPtr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
jsize len = env->GetStringLength(str);
const jchar* chars = env->GetStringCritical(str, nullptr);
SkRect bounds;
instance->measureText(chars, len * sizeof(jchar), SkTextEncoding::kUTF16, &bounds, paint);
env->ReleaseStringCritical(str, chars);
return skija::Rect::fromSkRect(env, bounds);
}
extern "C" JNIEXPORT jfloat JNICALL Java_org_jetbrains_skija_Font__1nMeasureTextWidth
(JNIEnv* env, jclass jclass, jlong ptr, jstring str, jlong paintPtr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
jsize len = env->GetStringLength(str);
const jchar* chars = env->GetStringCritical(str, nullptr);
float width = instance->measureText(chars, len * sizeof(jchar), SkTextEncoding::kUTF16, nullptr, paint);
env->ReleaseStringCritical(str, chars);
return width;
}
extern "C" JNIEXPORT jfloatArray JNICALL Java_org_jetbrains_skija_Font__1nGetWidths
(JNIEnv* env, jclass jclass, jlong ptr, jshortArray glyphsArr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
int count = env->GetArrayLength(glyphsArr);
std::vector<jfloat> widths(count);
jshort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
instance->getWidths(reinterpret_cast<SkGlyphID*>(glyphs), count, widths.data());
env->ReleaseShortArrayElements(glyphsArr, glyphs, 0);
return javaFloatArray(env, widths);
}
extern "C" JNIEXPORT jobjectArray JNICALL Java_org_jetbrains_skija_Font__1nGetBounds
(JNIEnv* env, jclass jclass, jlong ptr, jshortArray glyphsArr, jlong paintPtr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
int count = env->GetArrayLength(glyphsArr);
std::vector<SkRect> bounds(count);
jshort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
instance->getBounds(reinterpret_cast<SkGlyphID*>(glyphs), count, bounds.data(), paint);
env->ReleaseShortArrayElements(glyphsArr, glyphs, 0);
jobjectArray res = env->NewObjectArray(count, skija::Rect::cls, nullptr);
for (int i = 0; i < count; ++i) {
skija::AutoLocal<jobject> boundsObj(env, skija::Rect::fromSkRect(env, bounds[i]));
env->SetObjectArrayElement(res, i, boundsObj.get());
}
return res;
}
extern "C" JNIEXPORT jobjectArray JNICALL Java_org_jetbrains_skija_Font__1nGetPositions
(JNIEnv* env, jclass jclass, jlong ptr, jshortArray glyphsArr, jfloat dx, jfloat dy) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
int count = env->GetArrayLength(glyphsArr);
std::vector<SkPoint> positions(count);
jshort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
instance->getPos(reinterpret_cast<SkGlyphID*>(glyphs), count, positions.data(), {dx, dy});
env->ReleaseShortArrayElements(glyphsArr, glyphs, 0);
return skija::Point::fromSkPoints(env, positions);
}
extern "C" JNIEXPORT jfloatArray JNICALL Java_org_jetbrains_skija_Font__1nGetXPositions
(JNIEnv* env, jclass jclass, jlong ptr, jshortArray glyphsArr, jfloat dx) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
int count = env->GetArrayLength(glyphsArr);
std::vector<jfloat> positions(count);
jshort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
instance->getXPos(reinterpret_cast<SkGlyphID*>(glyphs), count, positions.data(), dx);
env->ReleaseShortArrayElements(glyphsArr, glyphs, 0);
return javaFloatArray(env, positions);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Font__1nGetPath
(JNIEnv* env, jclass jclass, jlong ptr, jshort glyph) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SkPath* path = new SkPath();
instance->getPath(glyph, path);
return reinterpret_cast<jlong>(path);
}
extern "C" JNIEXPORT jobjectArray JNICALL Java_org_jetbrains_skija_Font__1nGetPaths
(JNIEnv* env, jclass jclass, jlong ptr, jshortArray glyphsArr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
int count = env->GetArrayLength(glyphsArr);
jshort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
struct Ctx {
jobjectArray paths;
jsize idx;
JNIEnv* env;
} ctx = { env->NewObjectArray(count, skija::Path::cls, nullptr), 0, env };
instance->getPaths(reinterpret_cast<SkGlyphID*>(glyphs), count, [](const SkPath* orig, const SkMatrix& mx, void* voidCtx) {
Ctx* ctx = static_cast<Ctx*>(voidCtx);
if (orig) {
SkPath* path = new SkPath();
orig->transform(mx, path);
jobject pathObj = ctx->env->NewObject(skija::Path::cls, skija::Path::ctor, reinterpret_cast<jlong>(path));
ctx->env->SetObjectArrayElement(ctx->paths, ctx->idx, pathObj);
ctx->env->DeleteLocalRef(pathObj);
++ctx->idx;
}
}, &ctx);
env->ReleaseShortArrayElements(glyphsArr, glyphs, 0);
return ctx.paths;
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Font__1nGetMetrics
(JNIEnv* env, jclass jclass, jlong ptr, jshortArray glyphsArr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SkFontMetrics m;
instance->getMetrics(&m);
return skija::FontMetrics::toJava(env, m);
}
extern "C" JNIEXPORT jfloat JNICALL Java_org_jetbrains_skija_Font__1nGetSpacing
(JNIEnv* env, jclass jclass, jlong ptr, jshortArray glyphsArr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
return instance->getSpacing();
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/FontMgr.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "interop.hh"
#include "SkData.h"
#include "SkTypeface.h"
#include "SkFontMgr.h"
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_FontMgr__1nGetFamiliesCount
(JNIEnv* env, jclass jclass, jlong ptr) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>(static_cast<uintptr_t>(ptr));
return instance->countFamilies();
}
extern "C" JNIEXPORT jstring JNICALL Java_org_jetbrains_skija_FontMgr__1nGetFamilyName
(JNIEnv* env, jclass jclass, jlong ptr, jint index) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>(static_cast<uintptr_t>(ptr));
SkString familyName;
instance->getFamilyName(index, &familyName);
return javaString(env, familyName);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_FontMgr__1nMakeStyleSet
(JNIEnv* env, jclass jclass, jlong ptr, jint index) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>(static_cast<uintptr_t>(ptr));
SkFontStyleSet* styleSet = instance->createStyleSet(index);
return reinterpret_cast<jlong>(styleSet);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_FontMgr__1nMatchFamily
(JNIEnv* env, jclass jclass, jlong ptr, jstring familyNameStr) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>(static_cast<uintptr_t>(ptr));
SkString familyName = skString(env, familyNameStr);
SkFontStyleSet* styleSet = instance->matchFamily(familyName.c_str());
return reinterpret_cast<jlong>(styleSet);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_FontMgr__1nMatchFamilyStyle
(JNIEnv* env, jclass jclass, jlong ptr, jstring familyNameStr, jint fontStyle) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>(static_cast<uintptr_t>(ptr));
SkString familyName = skString(env, familyNameStr);
SkTypeface* typeface = instance->matchFamilyStyle(familyName.c_str(), skija::FontStyle::fromJava(fontStyle));
return reinterpret_cast<jlong>(typeface);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_FontMgr__1nMatchFamilyStyleCharacter
(JNIEnv* env, jclass jclass, jlong ptr, jstring familyNameStr, jint fontStyle, jobjectArray bcp47Array, jint character) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>(static_cast<uintptr_t>(ptr));
SkString familyName = skString(env, familyNameStr);
std::vector<SkString> bcp47Strings = skStringVector(env, bcp47Array);
std::vector<const char*> bcp47(bcp47Strings.size());
for (int i = 0; i < bcp47.size(); ++i)
bcp47[i] = bcp47Strings[i].c_str();
SkTypeface* typeface = instance->matchFamilyStyleCharacter(familyName.c_str(), skija::FontStyle::fromJava(fontStyle), bcp47.data(), (int) bcp47.size(), character);
return reinterpret_cast<jlong>(typeface);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_FontMgr__1nMakeFromData
(JNIEnv* env, jclass jclass, jlong ptr, jlong dataPtr, jint ttcIndex) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>(static_cast<uintptr_t>(ptr));
SkData* data = reinterpret_cast<SkData*>(static_cast<uintptr_t>(dataPtr));
SkTypeface* typeface = instance->makeFromData(sk_ref_sp(data), ttcIndex).release();
return reinterpret_cast<jlong>(typeface);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_FontMgr__1nDefault
(JNIEnv* env, jclass jclass) {
SkFontMgr* instance = SkFontMgr::RefDefault().release();
return reinterpret_cast<jlong>(instance);
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/FontRunIterator.hh 0 → 100644
View file @ 228274af
#pragma once
#include "SkShaper.h"
#include "unicode/ubrk.h"
#include "unicode/utext.h"
class FontRunIterator final: public SkShaper::FontRunIterator {
public:
FontRunIterator(const char* utf8,
size_t utf8Bytes,
const SkFont& font,
sk_sp<SkFontMgr> fallbackMgr,
const char* requestName,
SkFontStyle requestStyle,
const SkShaper::LanguageRunIterator* lang,
std::shared_ptr<UBreakIterator> graphemeIter,
bool approximateSpaces,
bool approximatePunctuation)
: fCurrent(utf8)
, fBegin(utf8)
, fEnd(fCurrent + utf8Bytes)
, fFallbackMgr(std::move(fallbackMgr))
, fFont(font)
, fFallbackFont(fFont)
, fCurrentFont(nullptr)
, fRequestName(requestName)
, fRequestStyle(requestStyle)
, fLanguage(lang)
, fGraphemeIter(graphemeIter)
, fApproximateSpaces(approximateSpaces)
, fApproximatePunctuation(approximatePunctuation)
{
fFont.setTypeface(font.refTypefaceOrDefault());
fFallbackFont.setTypeface(nullptr);
}
FontRunIterator(const char* utf8,
size_t utf8Bytes,
const SkFont& font,
sk_sp<SkFontMgr> fallbackMgr,
std::shared_ptr<UBreakIterator> graphemeIter,
bool approximateSpaces,
bool approximatePunctuation)
: FontRunIterator(utf8,
utf8Bytes,
font,
std::move(fallbackMgr),
nullptr,
font.refTypefaceOrDefault()->fontStyle(),
nullptr,
graphemeIter,
approximateSpaces,
approximatePunctuation) {
}
~FontRunIterator() {
}
void consume() override;
size_t endOfCurrentRun() const override {
return fCurrent - fBegin;
}
bool atEnd() const override {
return fCurrent == fEnd;
}
const SkFont& currentFont() const override {
return *fCurrentFont;
}
private:
char const * fCurrent;
char const * const fBegin;
char const * const fEnd;
sk_sp<SkFontMgr> const fFallbackMgr;
SkFont fFont;
SkFont fFallbackFont;
SkFont* fCurrentFont;
char const * const fRequestName;
SkFontStyle const fRequestStyle;
SkShaper::LanguageRunIterator const * const fLanguage;
std::shared_ptr<UBreakIterator> fGraphemeIter;
bool fApproximateSpaces;
bool fApproximatePunctuation;
};
\ No newline at end of file
skiko/src/jvmMain/cpp/common/FontStyleSet.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "interop.hh"
#include "SkTypeface.h"
#include "SkFontMgr.h"
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_FontStyleSet__1nMakeEmpty
(JNIEnv* env, jclass jclass) {
SkFontStyleSet* instance = SkFontStyleSet::CreateEmpty();
return reinterpret_cast<jlong>(instance);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_FontStyleSet__1nCount
(JNIEnv* env, jclass jclass, jlong ptr) {
SkFontStyleSet* instance = reinterpret_cast<SkFontStyleSet*>(static_cast<uintptr_t>(ptr));
return instance->count();
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_FontStyleSet__1nGetStyle
(JNIEnv* env, jclass jclass, jlong ptr, jint index) {
SkFontStyleSet* instance = reinterpret_cast<SkFontStyleSet*>(static_cast<uintptr_t>(ptr));
SkFontStyle fontStyle;
instance->getStyle(index, &fontStyle, nullptr);
return fontStyle.weight() + (fontStyle.width() << 16) + (fontStyle.slant() << 24);
}
extern "C" JNIEXPORT jstring JNICALL Java_org_jetbrains_skija_FontStyleSet__1nGetStyleName
(JNIEnv* env, jclass jclass, jlong ptr, jint index) {
SkFontStyleSet* instance = reinterpret_cast<SkFontStyleSet*>(static_cast<uintptr_t>(ptr));
SkString style;
instance->getStyle(index, nullptr, &style);
return javaString(env, style);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_FontStyleSet__1nGetTypeface
(JNIEnv* env, jclass jclass, jlong ptr, jint index) {
SkFontStyleSet* instance = reinterpret_cast<SkFontStyleSet*>(static_cast<uintptr_t>(ptr));
SkTypeface* typeface = instance->createTypeface(index);
return reinterpret_cast<jlong>(typeface);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_FontStyleSet__1nMatchStyle
(JNIEnv* env, jclass jclass, jlong ptr, jint fontStyle) {
SkFontStyleSet* instance = reinterpret_cast<SkFontStyleSet*>(static_cast<uintptr_t>(ptr));
SkTypeface* typeface = instance->matchStyle(skija::FontStyle::fromJava(fontStyle));
return reinterpret_cast<jlong>(typeface);
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/Image.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "SkData.h"
#include "SkImage.h"
#include "interop.hh"
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Image__1nMakeRaster
(JNIEnv* env, jclass jclass, jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr, jbyteArray bytesArr, jlong rowBytes) {
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr));
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
static_cast<SkAlphaType>(alphaType),
sk_ref_sp<SkColorSpace>(colorSpace));
void* bytes = env->GetPrimitiveArrayCritical(bytesArr, 0);
sk_sp<SkImage> image = SkImage::MakeRasterCopy(SkPixmap(imageInfo, bytes, rowBytes));
env->ReleasePrimitiveArrayCritical(bytesArr, bytes, 0);
return reinterpret_cast<jlong>(image.release());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Image__1nMakeRasterData
(JNIEnv* env, jclass jclass, jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr, jlong dataPtr, jlong rowBytes) {
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr));
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
static_cast<SkAlphaType>(alphaType),
sk_ref_sp<SkColorSpace>(colorSpace));
SkData* data = reinterpret_cast<SkData*>(static_cast<uintptr_t>(dataPtr));
sk_sp<SkImage> image = SkImage::MakeRasterData(imageInfo, sk_ref_sp(data), rowBytes);
return reinterpret_cast<jlong>(image.release());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Image__1nMakeFromBitmap
(JNIEnv* env, jclass jclass, jlong bitmapPtr) {
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(bitmapPtr));
sk_sp<SkImage> image = SkImage::MakeFromBitmap(*bitmap);
return reinterpret_cast<jlong>(image.release());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Image__1nMakeFromPixmap
(JNIEnv* env, jclass jclass, jlong pixmapPtr) {
SkPixmap* pixmap = reinterpret_cast<SkPixmap*>(static_cast<uintptr_t>(pixmapPtr));
sk_sp<SkImage> image = SkImage::MakeFromRaster(*pixmap, nullptr, nullptr);
return reinterpret_cast<jlong>(image.release());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Image__1nMakeFromEncoded
(JNIEnv* env, jclass jclass, jbyteArray encodedArray) {
jsize encodedLen = env->GetArrayLength(encodedArray);
jbyte* encoded = env->GetByteArrayElements(encodedArray, 0);
sk_sp<SkData> encodedData = SkData::MakeWithCopy(encoded, encodedLen);
env->ReleaseByteArrayElements(encodedArray, encoded, 0);
sk_sp<SkImage> image = SkImage::MakeFromEncoded(encodedData);
return reinterpret_cast<jlong>(image.release());
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Image__1nGetImageInfo
(JNIEnv* env, jclass jclass, jlong ptr) {
SkImage* instance = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(ptr));
return skija::ImageInfo::toJava(env, instance->imageInfo());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Image__1nEncodeToData
(JNIEnv* env, jclass jclass, jlong ptr, jint format, jint quality) {
SkImage* instance = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(ptr));
SkData* data = instance->encodeToData(static_cast<SkEncodedImageFormat>(format), quality).release();
return reinterpret_cast<jlong>(data);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Image__1nMakeShader
(JNIEnv* env, jclass jclass, jlong ptr, jint tmx, jint tmy, jlong sampling, jfloatArray localMatrixArr) {
SkImage* instance = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(ptr));
std::unique_ptr<SkMatrix> localMatrix = skMatrix(env, localMatrixArr);
sk_sp<SkShader> shader = instance->makeShader(static_cast<SkTileMode>(tmx), static_cast<SkTileMode>(tmy), skija::SamplingMode::unpack(sampling), localMatrix.get());
return reinterpret_cast<jlong>(shader.release());
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Image__1nPeekPixels
(JNIEnv* env, jclass jclass, jlong ptr) {
SkImage* instance = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(ptr));
SkPixmap pixmap;
if (instance->peekPixels(&pixmap))
return env->NewDirectByteBuffer(pixmap.writable_addr(), pixmap.rowBytes() * pixmap.height());
else
return nullptr;
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Image__1nPeekPixelsToPixmap
(JNIEnv* env, jclass jclass, jlong ptr, jlong pixmapPtr) {
SkImage* instance = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(ptr));
SkPixmap* pixmap = reinterpret_cast<SkPixmap*>(static_cast<uintptr_t>(pixmapPtr));
return instance->peekPixels(pixmap);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Image__1nReadPixelsBitmap
(JNIEnv* env, jclass jclass, jlong ptr, jlong contextPtr, jlong bitmapPtr, jint srcX, jint srcY, jboolean cache) {
SkImage* instance = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(ptr));
GrDirectContext* context = reinterpret_cast<GrDirectContext*>(static_cast<uintptr_t>(contextPtr));
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(bitmapPtr));
auto cachingHint = cache ? SkImage::CachingHint::kAllow_CachingHint : SkImage::CachingHint::kDisallow_CachingHint;
return instance->readPixels(context, bitmap->info(), bitmap->getPixels(), bitmap->pixmap().rowBytes(), srcX, srcY, cachingHint);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Image__1nReadPixelsPixmap
(JNIEnv* env, jclass jclass, jlong ptr, jlong pixmapPtr, jint srcX, jint srcY, jboolean cache) {
SkImage* instance = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(ptr));
SkPixmap* pixmap = reinterpret_cast<SkPixmap*>(static_cast<uintptr_t>(pixmapPtr));
auto cachingHint = cache ? SkImage::CachingHint::kAllow_CachingHint : SkImage::CachingHint::kDisallow_CachingHint;
return instance->readPixels(*pixmap, srcX, srcY, cachingHint);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Image__1nScalePixels
(JNIEnv* env, jclass jclass, jlong ptr, jlong pixmapPtr, jlong samplingOptions, jboolean cache) {
SkImage* instance = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(ptr));
SkPixmap* pixmap = reinterpret_cast<SkPixmap*>(static_cast<uintptr_t>(pixmapPtr));
auto cachingHint = cache ? SkImage::CachingHint::kAllow_CachingHint : SkImage::CachingHint::kDisallow_CachingHint;
return instance->scalePixels(*pixmap, skija::SamplingMode::unpack(samplingOptions), cachingHint);
}
skiko/src/jvmMain/cpp/common/ImageFilter.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "interop.hh"
#include "SkColorFilter.h"
#include "SkImageFilter.h"
#include "SkImageFilters.h"
#include "SkPoint3.h"
#include "SkRect.h"
#include "interop.hh"
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeAlphaThreshold
(JNIEnv* env, jclass jclass, jlong regionPtr, jfloat innerMin, jfloat outerMax, jlong inputPtr, jobject cropObj) {
SkRegion* region = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(regionPtr));
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::AlphaThreshold(*region, innerMin, outerMax, sk_ref_sp(input), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeArithmetic
(JNIEnv* env, jclass jclass, jfloat k1, jfloat k2, jfloat k3, jfloat k4, jboolean enforcePMColor, jlong bgPtr, jlong fgPtr, jobject cropObj) {
SkImageFilter* bg = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(bgPtr));
SkImageFilter* fg = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(fgPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::Arithmetic(k1, k2, k3, k4, enforcePMColor, sk_ref_sp(bg), sk_ref_sp(fg), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeBlend
(JNIEnv* env, jclass jclass, jint blendModeInt, jlong bgPtr, jlong fgPtr, jobject cropObj) {
SkBlendMode blendMode = static_cast<SkBlendMode>(blendModeInt);
SkImageFilter* bg = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(bgPtr));
SkImageFilter* fg = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(fgPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::Blend(blendMode, sk_ref_sp(bg), sk_ref_sp(fg), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeBlur
(JNIEnv* env, jclass jclass, jfloat sigmaX, jfloat sigmaY, jint tileModeInt, jlong inputPtr, jobject cropObj) {
SkTileMode tileMode = static_cast<SkTileMode>(tileModeInt);
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::Blur(sigmaX, sigmaY, tileMode, sk_ref_sp(input), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeColorFilter
(JNIEnv* env, jclass jclass, jlong colorFilterPtr, jlong inputPtr, jobject cropObj) {
SkColorFilter* colorFilter = reinterpret_cast<SkColorFilter*>(static_cast<uintptr_t>(colorFilterPtr));
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::ColorFilter(sk_ref_sp(colorFilter), sk_ref_sp(input), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeCompose
(JNIEnv* env, jclass jclass, jlong outerPtr, jlong innerPtr) {
SkImageFilter* outer = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(outerPtr));
SkImageFilter* inner = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(innerPtr));
SkImageFilter* ptr = SkImageFilters::Compose(sk_ref_sp(outer), sk_ref_sp(inner)).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeDisplacementMap
(JNIEnv* env, jclass jclass, jint xChanInt, jint yChanInt, jfloat scale, jlong displacementPtr, jlong colorPtr, jobject cropObj) {
SkColorChannel xChan = static_cast<SkColorChannel>(xChanInt);
SkColorChannel yChan = static_cast<SkColorChannel>(yChanInt);
SkImageFilter* displacement = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(displacementPtr));
SkImageFilter* color = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(colorPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::DisplacementMap(xChan, yChan, scale, sk_ref_sp(displacement), sk_ref_sp(color), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeDropShadow
(JNIEnv* env, jclass jclass, jfloat dx, jfloat dy, jfloat sigmaX, jfloat sigmaY, jint color, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::DropShadow(dx, dy, sigmaX, sigmaY, color, sk_ref_sp(input), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeDropShadowOnly
(JNIEnv* env, jclass jclass, jfloat dx, jfloat dy, jfloat sigmaX, jfloat sigmaY, jint color, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::DropShadowOnly(dx, dy, sigmaX, sigmaY, color, sk_ref_sp(input), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeImage
(JNIEnv* env, jclass jclass, jlong imagePtr, jfloat l0, jfloat t0, jfloat r0, jfloat b0, jfloat l1, jfloat t1, jfloat r1, jfloat b1, jlong samplingMode) {
SkImage* image = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(imagePtr));
SkImageFilter* ptr = SkImageFilters::Image(sk_ref_sp(image), SkRect{l0, t0, r0, b0}, SkRect{l1, t1, r1, b1}, skija::SamplingMode::unpack(samplingMode)).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeMagnifier
(JNIEnv* env, jclass jclass, jfloat l, jfloat t, jfloat r, jfloat b, jfloat inset, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::Magnifier(SkRect{l, t, r, b}, inset, sk_ref_sp(input), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeMatrixConvolution
(JNIEnv* env, jclass jclass, jint kernelW, jint kernelH, jfloatArray kernelArray, jfloat gain, jfloat bias, jint offsetX, jint offsetY, jint tileModeInt, jboolean convolveAlpha, jlong inputPtr, jobject cropObj) {
jfloat* kernel = env->GetFloatArrayElements(kernelArray, 0);
SkTileMode tileMode = static_cast<SkTileMode>(tileModeInt);
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::MatrixConvolution(SkISize{kernelW, kernelH}, kernel, gain, bias, SkIPoint{offsetX, offsetY}, tileMode, convolveAlpha, sk_ref_sp(input), crop.get()).release();
env->ReleaseFloatArrayElements(kernelArray, kernel, 0);
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeMatrixTransform
(JNIEnv* env, jclass jclass, jfloatArray matrixArray, jlong samplingMode, jlong inputPtr) {
std::unique_ptr<SkMatrix> matrix = skMatrix(env, matrixArray);
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
SkImageFilter* ptr = SkImageFilters::MatrixTransform(*matrix, skija::SamplingMode::unpack(samplingMode), sk_ref_sp(input)).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeMerge
(JNIEnv* env, jclass jclass, jlongArray filtersArray, jobject cropObj) {
jlong* f = env->GetLongArrayElements(filtersArray, 0);
jsize len = env->GetArrayLength(filtersArray);
std::vector<sk_sp<SkImageFilter>> filters(len);
for (int i = 0; i < len; ++i) {
SkImageFilter* fi = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(f[i]));
filters[i] = sk_ref_sp(fi);
}
env->ReleaseLongArrayElements(filtersArray, f, 0);
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::Merge(filters.data(), len, crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeOffset
(JNIEnv* env, jclass jclass, jfloat dx, jfloat dy, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::Offset(dx, dy, sk_ref_sp(input), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakePaint
(JNIEnv* env, jclass jclass, jlong paintPtr, jobject cropObj) {
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::Paint(*paint, crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakePicture
(JNIEnv* env, jclass jclass, jlong picturePtr, jfloat l, jfloat t, jfloat r, jfloat b) {
SkPicture* picture = reinterpret_cast<SkPicture*>(static_cast<uintptr_t>(picturePtr));
SkImageFilter* ptr = SkImageFilters::Picture(sk_ref_sp(picture), SkRect{l, t, r, b}).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeTile
(JNIEnv* env, jclass jclass, jfloat l0, jfloat t0, jfloat r0, jfloat b0, jfloat l1, jfloat t1, jfloat r1, jfloat b1, jlong inputPtr) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
SkImageFilter* ptr = SkImageFilters::Tile(SkRect{l0, t0, r0, b0}, SkRect{l1, t1, r1, b1}, sk_ref_sp(input)).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeDilate
(JNIEnv* env, jclass jclass, float rx, jfloat ry, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::Dilate(rx, ry, sk_ref_sp(input), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeErode
(JNIEnv* env, jclass jclass, float rx, jfloat ry, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::Erode(rx, ry, sk_ref_sp(input), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeDistantLitDiffuse
(JNIEnv* env, jclass jclass, jfloat x, jfloat y, jfloat z, jint lightColor, jfloat surfaceScale, jfloat kd, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::DistantLitDiffuse(SkPoint3{x, y, z}, lightColor, surfaceScale, kd, sk_ref_sp(input), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakePointLitDiffuse
(JNIEnv* env, jclass jclass, jfloat x, jfloat y, jfloat z, jint lightColor, jfloat surfaceScale, jfloat kd, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::PointLitDiffuse(SkPoint3{x, y, z}, lightColor, surfaceScale, kd, sk_ref_sp(input), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeSpotLitDiffuse
(JNIEnv* env, jclass jclass, jfloat x0, jfloat y0, jfloat z0, jfloat x1, jfloat y1, jfloat z1, jfloat falloffExponent, jfloat cutoffAngle, jint lightColor, jfloat surfaceScale, jfloat kd, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::SpotLitDiffuse(SkPoint3{x0, y0, z0}, SkPoint3{x1, y1, z1}, falloffExponent, cutoffAngle, lightColor, surfaceScale, kd, sk_ref_sp(input), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeDistantLitSpecular
(JNIEnv* env, jclass jclass, jfloat x, jfloat y, jfloat z, jint lightColor, jfloat surfaceScale, jfloat ks, jfloat shininess, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::DistantLitSpecular(SkPoint3{x, y, z}, lightColor, surfaceScale, ks, shininess, sk_ref_sp(input), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakePointLitSpecular
(JNIEnv* env, jclass jclass, jfloat x, jfloat y, jfloat z, jint lightColor, jfloat surfaceScale, jfloat ks, jfloat shininess, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::PointLitSpecular(SkPoint3{x, y, z}, lightColor, surfaceScale, ks, shininess, sk_ref_sp(input), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ImageFilter__1nMakeSpotLitSpecular
(JNIEnv* env, jclass jclass, jfloat x0, jfloat y0, jfloat z0, jfloat x1, jfloat y1, jfloat z1, jfloat falloffExponent, jfloat cutoffAngle, jint lightColor, jfloat surfaceScale, jfloat ks, jfloat shininess, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::SpotLitSpecular(SkPoint3{x0, y0, z0}, SkPoint3{x1, y1, z1}, falloffExponent, cutoffAngle, lightColor, surfaceScale, ks, shininess, sk_ref_sp(input), crop.get()).release();
return reinterpret_cast<jlong>(ptr);
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/ManagedString.cc 0 → 100644
View file @ 228274af
#include <jni.h>
#include "interop.hh"
#include "SkString.h"
static void deleteString(SkString* instance) {
// std::cout << "Deleting [SkString " << instance << "]" << std::endl;
delete instance;
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ManagedString__1nGetFinalizer
(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteString));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_ManagedString__1nMake
(JNIEnv* env, jclass jclass, jstring textStr) {
SkString* text = new SkString(skString(env, textStr));
return reinterpret_cast<jlong>(text);
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_ManagedString__1nToString
(JNIEnv* env, jclass jclass, jlong ptr) {
SkString* instance = reinterpret_cast<SkString*>(static_cast<uintptr_t>(ptr));
return javaString(env, *instance);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_ManagedString__1nInsert
(JNIEnv* env, jclass jclass, jlong ptr, jint offset, jstring s) {
SkString* instance = reinterpret_cast<SkString*>(static_cast<uintptr_t>(ptr));
skija::UtfIndicesConverter conv(*instance);
instance->insert(conv.from16To8(offset), skString(env, s));
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_ManagedString__1nAppend
(JNIEnv* env, jclass jclass, jlong ptr, jstring s) {
SkString* instance = reinterpret_cast<SkString*>(static_cast<uintptr_t>(ptr));
instance->append(skString(env, s));
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_ManagedString__1nRemoveSuffix
(JNIEnv* env, jclass jclass, jlong ptr, jint from) {
SkString* instance = reinterpret_cast<SkString*>(static_cast<uintptr_t>(ptr));
skija::UtfIndicesConverter conv(*instance);
size_t from8 = conv.from16To8(from);
instance->remove(from8, instance->size() - from8);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_ManagedString__1nRemove
(JNIEnv* env, jclass jclass, jlong ptr, jint from, jint len) {
SkString* instance = reinterpret_cast<SkString*>(static_cast<uintptr_t>(ptr));
skija::UtfIndicesConverter conv(*instance);
size_t from8 = conv.from16To8(from);
size_t to8 = conv.from16To8(from + len);
instance->remove(from8, to8 - from8);
}
skiko/src/jvmMain/cpp/common/MaskFilter.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "SkMaskFilter.h"
#include "SkShader.h"
#include "SkShaderMaskFilter.h"
#include "SkTableMaskFilter.h"
#include "interop.hh"
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_MaskFilter__1nMakeBlur
(JNIEnv* env, jclass jclass, jint blurStyleInt, jfloat sigma, jboolean respectCTM) {
SkBlurStyle blurStyle = static_cast<SkBlurStyle>(blurStyleInt);
SkMaskFilter* ptr = SkMaskFilter::MakeBlur(blurStyle, sigma, respectCTM).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_MaskFilter__1nMakeShader
(JNIEnv* env, jclass jclass, jlong shaderPtr) {
SkShader* shader = reinterpret_cast<SkShader*>(static_cast<uintptr_t>(shaderPtr));
SkMaskFilter* ptr = SkShaderMaskFilter::Make(sk_ref_sp(shader)).release();
return reinterpret_cast<jlong>(ptr);
}
// extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_MaskFilter__1nMakeEmboss
// (JNIEnv* env, jclass jclass, jfloat sigma, jfloat x, jfloat y, jfloat z, jint pad, jint ambient, jint specular) {
// SkEmbossMaskFilter::Light light{ {x, y, z}, pad, ambient, specular };
// SkMaskFilter* ptr = SkEmbossMaskFilter::Make(sigma, light).release();
// return reinterpret_cast<jlong>(ptr);
// }
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_MaskFilter__1nMakeTable
(JNIEnv* env, jclass jclass, jbyteArray tableArray) {
jbyte* table = env->GetByteArrayElements(tableArray, 0);
SkMaskFilter* ptr = SkTableMaskFilter::Create(reinterpret_cast<uint8_t*>(table));
env->ReleaseByteArrayElements(tableArray, table, 0);
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_MaskFilter__1nMakeGamma
(JNIEnv* env, jclass jclass, jfloat gamma) {
SkMaskFilter* ptr = SkTableMaskFilter::CreateGamma(gamma);
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_MaskFilter__1nMakeClip
(JNIEnv* env, jclass jclass, jbyte min, jbyte max) {
SkMaskFilter* ptr = SkTableMaskFilter::CreateClip(static_cast<uint8_t>(min), static_cast<uint8_t>(max));
return reinterpret_cast<jlong>(ptr);
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/OutputWStream.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "interop.hh"
#include "SkStream.h"
class OutputWStream: public SkWStream {
public:
OutputWStream(JNIEnv* env, jobject out): fEnv(env) {
fOut = env->NewGlobalRef(out);
}
~OutputWStream() override {
fEnv->DeleteGlobalRef(fOut);
}
size_t bytesWritten() const override {
return fBytesWritten;
}
bool write(const void* buffer, size_t size) override {
jbyteArray arr = fEnv->NewByteArray((jsize) size);
fEnv->SetByteArrayRegion(arr, 0, (jsize) size, static_cast<const jbyte *>(buffer));
fEnv->CallVoidMethod(fOut, java::io::OutputStream::write, arr, 0, (jint) size);
fEnv->DeleteLocalRef(arr);
if (java::lang::Throwable::exceptionThrown(fEnv)) {
return false;
} else {
fBytesWritten += size;
return true;
}
}
void flush() override {
fEnv->CallVoidMethod(fOut, java::io::OutputStream::flush);
}
private:
JNIEnv* fEnv;
jobject fOut;
size_t fBytesWritten = 0;
};
static void deleteOutputWStream(OutputWStream* out) {
delete out;
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_OutputWStream__1nGetFinalizer
(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteOutputWStream));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_OutputWStream__1nMake
(JNIEnv* env, jclass jclass, jobject outputStream) {
OutputWStream* instance = new OutputWStream(env, outputStream);
return reinterpret_cast<jlong>(instance);
}
skiko/src/jvmMain/cpp/common/Paint.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "SkColorFilter.h"
#include "SkImageFilter.h"
#include "SkMaskFilter.h"
#include "SkPaint.h"
#include "SkPathEffect.h"
#include "SkShader.h"
#include "SkFilterQuality.h"
#include "interop.hh"
static void deletePaint(SkPaint* paint) {
// std::cout << "Deleting [SkPaint " << paint << "]" << std::endl;
delete paint;
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Paint__1nGetFinalizer
(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deletePaint));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Paint__1nMake
(JNIEnv* env, jclass jclass) {
SkPaint* obj = new SkPaint();
obj->setAntiAlias(true);
return reinterpret_cast<jlong>(obj);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Paint__1nMakeClone
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
SkPaint* obj = new SkPaint(*instance);
return reinterpret_cast<jlong>(obj);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Paint__1nEquals
(JNIEnv* env, jclass jclass, jlong aPtr, jlong bPtr) {
SkPaint* a = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(aPtr));
SkPaint* b = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(bPtr));
return *a == *b;
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Paint__1nReset
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
instance->reset();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Paint__1nIsAntiAlias
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
return instance->isAntiAlias();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Paint__1nSetAntiAlias
(JNIEnv* env, jclass jclass, jlong ptr, jboolean value) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
instance->setAntiAlias(value);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Paint__1nIsDither
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
return instance->isDither();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Paint__1nSetDither
(JNIEnv* env, jclass jclass, jlong ptr, jboolean value) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
instance->setDither(value);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Paint__1nGetColor
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
return instance->getColor();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Paint__1nSetColor
(JNIEnv* env, jclass jclass, jlong ptr, jint color) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
instance->setColor(color);
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Paint__1nGetColor4f
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
SkColor4f color = instance->getColor4f();
return env->NewObject(skija::Color4f::cls, skija::Color4f::ctor, color.fR, color.fG, color.fB, color.fA);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Paint__1nSetColor4f
(JNIEnv* env, jclass jclass, jlong ptr, jfloat r, jfloat g, jfloat b, jfloat a, jlong colorSpacePtr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr));
instance->setColor4f({r, g, b, a}, colorSpace);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Paint__1nGetMode
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
return static_cast<jlong>(instance->getStyle());
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Paint__1nSetMode
(JNIEnv* env, jclass jclass, jlong ptr, jint mode) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
instance->setStyle(static_cast<SkPaint::Style>(mode));
}
extern "C" JNIEXPORT jfloat JNICALL Java_org_jetbrains_skija_Paint__1nGetStrokeWidth
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
return instance->getStrokeWidth();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Paint__1nSetStrokeWidth
(JNIEnv* env, jclass jclass, jlong ptr, jfloat width) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
instance->setStrokeWidth(width);
}
extern "C" JNIEXPORT jfloat JNICALL Java_org_jetbrains_skija_Paint__1nGetStrokeMiter
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
return instance->getStrokeMiter();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Paint__1nSetStrokeMiter
(JNIEnv* env, jclass jclass, jlong ptr, jfloat miter) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
instance->setStrokeMiter(miter);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Paint__1nGetStrokeCap
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
return static_cast<jlong>(instance->getStrokeCap());
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Paint__1nSetStrokeCap
(JNIEnv* env, jclass jclass, jlong ptr, jint cap) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
instance->setStrokeCap(static_cast<SkPaint::Cap>(cap));
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Paint__1nGetStrokeJoin
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
return static_cast<jlong>(instance->getStrokeJoin());
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Paint__1nSetStrokeJoin
(JNIEnv* env, jclass jclass, jlong ptr, jint join) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
instance->setStrokeJoin(static_cast<SkPaint::Join>(join));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Paint__1nGetFillPath
(JNIEnv* env, jclass jclass, jlong ptr, jlong srcPtr, jfloat resScale) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
SkPath* src = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(srcPtr));
SkPath* dst = new SkPath();
instance->getFillPath(*src, dst, nullptr, resScale);
return reinterpret_cast<jlong>(dst);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Paint__1nGetFillPathCull
(JNIEnv* env, jclass jclass, jlong ptr, jlong srcPtr, jfloat left, jfloat top, jfloat right, jfloat bottom, jfloat resScale) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
SkPath* src = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(srcPtr));
SkPath* dst = new SkPath();
SkRect cull {left, top, right, bottom};
instance->getFillPath(*src, dst, &cull, resScale);
return reinterpret_cast<jlong>(dst);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Paint__1nGetMaskFilter
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
return reinterpret_cast<jlong>(instance->refMaskFilter().release());
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Paint__1nSetMaskFilter
(JNIEnv* env, jclass jclass, jlong ptr, jlong filterPtr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
SkMaskFilter* filter = reinterpret_cast<SkMaskFilter*>(static_cast<uintptr_t>(filterPtr));
instance->setMaskFilter(sk_ref_sp<SkMaskFilter>(filter));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Paint__1nGetImageFilter
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
return reinterpret_cast<jlong>(instance->refImageFilter().release());
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Paint__1nSetImageFilter
(JNIEnv* env, jclass jclass, jlong ptr, jlong filterPtr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
SkImageFilter* filter = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(filterPtr));
instance->setImageFilter(sk_ref_sp<SkImageFilter>(filter));
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Paint__1nGetBlendMode
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
return static_cast<jlong>(instance->getBlendMode_or(SkBlendMode::kSrcOver));
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Paint__1nSetBlendMode
(JNIEnv* env, jclass jclass, jlong ptr, jint mode) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
instance->setBlendMode(static_cast<SkBlendMode>(mode));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Paint__1nGetPathEffect
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
return reinterpret_cast<jlong>(instance->refPathEffect().release());
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Paint__1nSetPathEffect
(JNIEnv* env, jclass jclass, jlong ptr, jlong pathEffectPtr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
SkPathEffect* pathEffect = reinterpret_cast<SkPathEffect*>(static_cast<uintptr_t>(pathEffectPtr));
instance->setPathEffect(sk_ref_sp(pathEffect));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Paint__1nGetShader
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
return reinterpret_cast<jlong>(instance->refShader().release());
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Paint__1nSetShader
(JNIEnv* env, jclass jclass, jlong ptr, jlong shaderPtr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
SkShader* shader = reinterpret_cast<SkShader*>(static_cast<uintptr_t>(shaderPtr));
instance->setShader(sk_ref_sp<SkShader>(shader));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Paint__1nGetColorFilter
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
return reinterpret_cast<jlong>(instance->refColorFilter().release());
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Paint__1nSetColorFilter
(JNIEnv* env, jclass jclass, jlong ptr, jlong colorFilterPtr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
SkColorFilter* colorFilter = reinterpret_cast<SkColorFilter*>(static_cast<uintptr_t>(colorFilterPtr));
instance->setColorFilter(sk_ref_sp<SkColorFilter>(colorFilter));
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Paint__1nHasNothingToDraw
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(ptr));
return instance->nothingToDraw();
}
skiko/src/jvmMain/cpp/common/PaintFilterCanvas.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "SkCanvas.h"
#include "SkDrawable.h"
#include "SkPaintFilterCanvas.h"
#include "interop.hh"
class SkijaPaintFilterCanvas : public SkPaintFilterCanvas {
public:
SkijaPaintFilterCanvas(
SkCanvas* canvas,
bool unrollDrawable
) : SkPaintFilterCanvas(canvas), unrollDrawable(unrollDrawable) {}
virtual ~SkijaPaintFilterCanvas() {
skija::PaintFilterCanvas::detach(jobj);
}
jobject jobj;
protected:
bool onFilter(SkPaint& paint) const override {
return skija::PaintFilterCanvas::onFilter(jobj, paint);
}
void onDrawDrawable(SkDrawable* drawable, const SkMatrix* matrix) override {
if (unrollDrawable) {
drawable->draw(this, matrix);
} else {
SkPaintFilterCanvas::onDrawDrawable(drawable, matrix);
}
}
private:
float unrollDrawable;
};
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_PaintFilterCanvas__1nAttachToJava
(JNIEnv* env, jobject jobj, jlong canvasPtr, jboolean unrollDrawable) {
SkijaPaintFilterCanvas* canvas = reinterpret_cast<SkijaPaintFilterCanvas*>(static_cast<uintptr_t>(canvasPtr));
canvas->jobj = skija::PaintFilterCanvas::attach(env, jobj);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PaintFilterCanvas__1nMake
(JNIEnv* env, jclass jclass, jlong canvasPtr, jboolean unrollDrawable) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkijaPaintFilterCanvas* filterCanvas = new SkijaPaintFilterCanvas(canvas, unrollDrawable);
return reinterpret_cast<jlong>(filterCanvas);
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/Path.cc 0 → 100644
View file @ 228274af
#include <algorithm>
#include <cfloat>
#include <iostream>
#include <vector>
#include <jni.h>
#include "SkPath.h"
#include "SkPathOps.h"
#include "interop.hh"
#include "include/utils/SkParsePath.h"
static void deletePath(SkPath* path) {
// std::cout << "Deleting [SkPath " << path << "]" << std::endl;
delete path;
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Path__1nGetFinalizer(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deletePath));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Path__1nMake(JNIEnv* env, jclass jclass) {
SkPath* obj = new SkPath();
return reinterpret_cast<jlong>(obj);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Path__1nMakeFromSVGString
(JNIEnv* env, jclass jclass, jstring d) {
SkPath* obj = new SkPath();
SkString s = skString(env, d);
if (SkParsePath::FromSVGString(s.c_str(), obj))
return reinterpret_cast<jlong>(obj);
else {
delete obj;
return 0;
}
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Path__1nEquals(JNIEnv* env, jclass jclass, jlong aPtr, jlong bPtr) {
SkPath* a = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(aPtr));
SkPath* b = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(bPtr));
return *a == *b;
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Path__1nIsInterpolatable(JNIEnv* env, jclass jclass, jlong ptr, jlong comparePtr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkPath* compare = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(comparePtr));
return instance->isInterpolatable(*compare);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Path__1nMakeLerp(JNIEnv* env, jclass jclass, jlong ptr, jlong endingPtr, jfloat weight) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkPath* ending = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(endingPtr));
SkPath* out = new SkPath();
if (instance->interpolate(*ending, weight, out)) {
return reinterpret_cast<jlong>(out);
} else {
delete out;
return 0;
}
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Path__1nGetFillMode(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
return static_cast<jint>(instance->getFillType());
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nSetFillMode(JNIEnv* env, jclass jclass, jlong ptr, jint fillMode) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->setFillType(static_cast<SkPathFillType>(fillMode));
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Path__1nIsConvex(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
return instance->isConvex();
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Path__1nIsOval(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkRect bounds;
if (instance->isOval(&bounds))
return skija::Rect::fromSkRect(env, bounds);
else
return nullptr;
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Path__1nIsRRect(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkRRect rrect;
if (instance->isRRect(&rrect))
return skija::RRect::fromSkRRect(env, rrect);
else
return nullptr;
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nReset(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->reset();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nRewind(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->rewind();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Path__1nIsEmpty(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
return instance->isEmpty();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Path__1nIsLastContourClosed(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
return instance->isLastContourClosed();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Path__1nIsFinite(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
return instance->isFinite();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Path__1nIsVolatile(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
return instance->isVolatile();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nSetVolatile(JNIEnv* env, jclass jclass, jlong ptr, jboolean isVolatile) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->setIsVolatile(isVolatile);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Path__1nIsLineDegenerate(JNIEnv* env, jclass jclass, jfloat x0, jfloat y0, jfloat x1, jfloat y1, jboolean exact) {
return SkPath::IsLineDegenerate({x0, y0}, {x1, y1}, exact);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Path__1nIsQuadDegenerate(JNIEnv* env, jclass jclass, jfloat x0, jfloat y0, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jboolean exact) {
return SkPath::IsQuadDegenerate({x0, y0}, {x1, y1}, {x2, y2}, exact);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Path__1nIsCubicDegenerate(JNIEnv* env, jclass jclass, jfloat x0, jfloat y0, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3, jboolean exact) {
return SkPath::IsCubicDegenerate({x0, y0}, {x1, y1}, {x2, y2}, {x3, y3}, exact);
}
extern "C" JNIEXPORT jobjectArray JNICALL Java_org_jetbrains_skija_Path__1nMaybeGetAsLine(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkPoint line[2];
if (instance->isLine(line)) {
jobjectArray res = env->NewObjectArray(2, skija::Point::cls, nullptr);
env->SetObjectArrayElement(res, 0, skija::Point::fromSkPoint(env, line[0]));
env->SetObjectArrayElement(res, 1, skija::Point::fromSkPoint(env, line[1]));
return res;
} else
return nullptr;
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Path__1nGetPointsCount(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
return instance->countPoints();
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Path__1nGetPoint(JNIEnv* env, jclass jclass, jlong ptr, jint index) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkPoint p = instance->getPoint(index);
return skija::Point::fromSkPoint(env, p);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Path__1nGetPoints(JNIEnv* env, jclass jclass, jlong ptr, jobjectArray pointsArray, jint max) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
std::vector<SkPoint> p(std::min<jint>(max, instance->countPoints()));
int count = instance->getPoints(p.data(), max);
for (int i = 0; i < max && i < count; ++ i)
env->SetObjectArrayElement(pointsArray, i, skija::Point::fromSkPoint(env, p[i]));
return count;
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Path__1nCountVerbs(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
return instance->countVerbs();
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Path__1nGetVerbs(JNIEnv* env, jclass jclass, jlong ptr, jbyteArray verbsArray, jint max) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
jbyte* verbs = verbsArray == nullptr ? nullptr : env->GetByteArrayElements(verbsArray, 0);
int count = instance->getVerbs(reinterpret_cast<uint8_t *>(verbs), max);
if (verbsArray != nullptr)
env->ReleaseByteArrayElements(verbsArray, verbs, 0);
return count;
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Path__1nApproximateBytesUsed(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
return (jint) instance->approximateBytesUsed();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nSwap(JNIEnv* env, jclass jclass, jlong ptr, jlong otherPtr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkPath* other = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(otherPtr));
instance->swap(*other);
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Path__1nGetBounds(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
return skija::Rect::fromSkRect(env, instance->getBounds());
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nUpdateBoundsCache(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->updateBoundsCache();
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Path__1nComputeTightBounds(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
return skija::Rect::fromSkRect(env, instance->computeTightBounds());
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Path__1nConservativelyContainsRect(JNIEnv* env, jclass jclass, jlong ptr, float l, float t, float r, float b) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkRect rect {l, t, r, b};
return instance->conservativelyContainsRect(rect);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nIncReserve(JNIEnv* env, jclass jclass, jlong ptr, int extraPtCount) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->incReserve(extraPtCount);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nMoveTo(JNIEnv* env, jclass jclass, jlong ptr, jfloat x, jfloat y) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->moveTo(x, y);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nRMoveTo(JNIEnv* env, jclass jclass, jlong ptr, jfloat dx, jfloat dy) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->rMoveTo(dx, dy);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nLineTo(JNIEnv* env, jclass jclass, jlong ptr, jfloat x, jfloat y) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->lineTo(x, y);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nRLineTo(JNIEnv* env, jclass jclass, jlong ptr, jfloat dx, jfloat dy) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->rLineTo(dx, dy);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nQuadTo(JNIEnv* env, jclass jclass, jlong ptr, jfloat x1, jfloat y1, jfloat x2, jfloat y2) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->quadTo(x1, y1, x2, y2);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nRQuadTo(JNIEnv* env, jclass jclass, jlong ptr, jfloat dx1, jfloat dy1, jfloat dx2, jfloat dy2) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->rQuadTo(dx1, dy1, dx2, dy2);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nConicTo(JNIEnv* env, jclass jclass, jlong ptr, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat w) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->conicTo(x1, y1, x2, y2, w);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nRConicTo(JNIEnv* env, jclass jclass, jlong ptr, jfloat dx1, jfloat dy1, jfloat dx2, jfloat dy2, jfloat w) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->rConicTo(dx1, dy1, dx2, dy2, w);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nCubicTo(JNIEnv* env, jclass jclass, jlong ptr, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->cubicTo(x1, y1, x2, y2, x3, y3);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nRCubicTo(JNIEnv* env, jclass jclass, jlong ptr, jfloat dx1, jfloat dy1, jfloat dx2, jfloat dy2, jfloat dx3, jfloat dy3) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->rCubicTo(dx1, dy1, dx2, dy2, dx3, dy3);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nArcTo(JNIEnv* env, jclass jclass, jlong ptr, jfloat left, jfloat top, jfloat right, jfloat bottom, jfloat startAngle, jfloat sweepAngle, jboolean forceMoveTo) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->arcTo({left, top, right, bottom}, startAngle, sweepAngle, forceMoveTo);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nTangentArcTo(JNIEnv* env, jclass jclass, jlong ptr, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat radius) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->arcTo(x1, y1, x2, y2, radius);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nEllipticalArcTo(JNIEnv* env, jclass jclass, jlong ptr, jfloat rx, jfloat ry, jfloat xAxisRotate, jint size, jint direction, jfloat x, float y) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->arcTo(rx, ry, xAxisRotate, static_cast<SkPath::ArcSize>(size), static_cast<SkPathDirection>(direction), x, y);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nREllipticalArcTo(JNIEnv* env, jclass jclass, jlong ptr, jfloat rx, jfloat ry, jfloat xAxisRotate, jint size, jint direction, jfloat dx, float dy) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->rArcTo(rx, ry, xAxisRotate, static_cast<SkPath::ArcSize>(size), static_cast<SkPathDirection>(direction), dx, dy);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nClosePath(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->close();
}
extern "C" JNIEXPORT jobjectArray Java_org_jetbrains_skija_Path__1nConvertConicToQuads
(JNIEnv* env, jclass jclass, jfloat x0, jfloat y0, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat w, jint pow2) {
std::vector<SkPoint> pts(1 + 2 * (1 << pow2));
int count = SkPath::ConvertConicToQuads({x0, y0}, {x1, y1}, {x2, y2}, w, pts.data(), pow2);
jobjectArray res = env->NewObjectArray(count, skija::Point::cls, nullptr);
for (int i = 0; i < count; ++i) {
env->SetObjectArrayElement(res, i, skija::Point::fromSkPoint(env, pts[i]));
}
return res;
}
extern "C" JNIEXPORT jobject Java_org_jetbrains_skija_Path__1nIsRect
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkRect rect;
if (instance->isRect(&rect))
return skija::Rect::fromSkRect(env, rect);
else
return nullptr;
}
extern "C" JNIEXPORT void Java_org_jetbrains_skija_Path__1nAddRect
(JNIEnv* env, jclass jclass, jlong ptr, jfloat l, jfloat t, jfloat r, jfloat b, jint dirInt, jint start) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkPathDirection dir = static_cast<SkPathDirection>(dirInt);
instance->addRect({l, t, r, b}, dir, start);
}
extern "C" JNIEXPORT void Java_org_jetbrains_skija_Path__1nAddOval
(JNIEnv* env, jclass jclass, jlong ptr, jfloat l, jfloat t, jfloat r, jfloat b, jint dirInt, jint start) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkPathDirection dir = static_cast<SkPathDirection>(dirInt);
instance->addOval({l, t, r, b}, dir, start);
}
extern "C" JNIEXPORT void Java_org_jetbrains_skija_Path__1nAddCircle
(JNIEnv* env, jclass jclass, jlong ptr, jfloat x, jfloat y, jfloat r, jint dirInt) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkPathDirection dir = static_cast<SkPathDirection>(dirInt);
instance->addCircle(x, y, r, dir);
}
extern "C" JNIEXPORT void Java_org_jetbrains_skija_Path__1nAddArc
(JNIEnv* env, jclass jclass, jlong ptr, jfloat l, jfloat t, jfloat r, jfloat b, jfloat startAngle, jfloat sweepAngle) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->addArc({l, t, r, b}, startAngle, sweepAngle);
}
extern "C" JNIEXPORT void Java_org_jetbrains_skija_Path__1nAddRRect
(JNIEnv* env, jclass jclass, jlong ptr, jfloat l, jfloat t, jfloat r, jfloat b, jfloatArray radii, jint dirInt, jint start) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkRRect rrect = skija::RRect::toSkRRect(env, l, t, r, b, radii);
SkPathDirection dir = static_cast<SkPathDirection>(dirInt);
instance->addRRect(rrect, dir, start);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nAddPoly
(JNIEnv* env, jclass jclass, jlong ptr, jfloatArray coords, jboolean close) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
jsize len = env->GetArrayLength(coords);
jfloat* arr = env->GetFloatArrayElements(coords, 0);
instance->addPoly(reinterpret_cast<SkPoint*>(arr), len / 2, close);
env->ReleaseFloatArrayElements(coords, arr, 0);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nAddPath
(JNIEnv* env, jclass jclass, jlong ptr, jlong srcPtr, jboolean extend) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkPath* src = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(srcPtr));
SkPath::AddPathMode mode = extend ? SkPath::AddPathMode::kExtend_AddPathMode : SkPath::AddPathMode::kAppend_AddPathMode;
instance->addPath(*src, mode);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nAddPathOffset
(JNIEnv* env, jclass jclass, jlong ptr, jlong srcPtr, jfloat dx, jfloat dy, jboolean extend) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkPath* src = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(srcPtr));
SkPath::AddPathMode mode = extend ? SkPath::AddPathMode::kExtend_AddPathMode : SkPath::AddPathMode::kAppend_AddPathMode;
instance->addPath(*src, dx, dy, mode);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nAddPathTransform
(JNIEnv* env, jclass jclass, jlong ptr, jlong srcPtr, jfloatArray matrixArr, jboolean extend) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkPath* src = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(srcPtr));
std::unique_ptr<SkMatrix> matrix = skMatrix(env, matrixArr);
SkPath::AddPathMode mode = extend ? SkPath::AddPathMode::kExtend_AddPathMode : SkPath::AddPathMode::kAppend_AddPathMode;
instance->addPath(*src, *matrix, mode);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nReverseAddPath
(JNIEnv* env, jclass jclass, jlong ptr, jlong srcPtr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkPath* src = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(srcPtr));
instance->reverseAddPath(*src);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nOffset
(JNIEnv* env, jclass jclass, jlong ptr, jfloat dx, jfloat dy, jlong dstPtr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkPath* dst = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(dstPtr));
instance->offset(dx, dy, dst);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nTransform
(JNIEnv* env, jclass jclass, jlong ptr, jfloatArray matrixArr, jlong dstPtr, jboolean pcBool) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkPath* dst = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(dstPtr));
std::unique_ptr<SkMatrix> matrix = skMatrix(env, matrixArr);
SkApplyPerspectiveClip pc = pcBool ? SkApplyPerspectiveClip::kYes : SkApplyPerspectiveClip::kNo;
instance->transform(*matrix, dst, pc);
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Path__1nGetLastPt
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
SkPoint out;
if (instance->getLastPt(&out))
return skija::Point::fromSkPoint(env, out);
else
return nullptr;
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nSetLastPt
(JNIEnv* env, jclass jclass, jlong ptr, jfloat x, jfloat y) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->setLastPt(x, y);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Path__1nGetSegmentMasks
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
return instance->getSegmentMasks();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Path__1nContains
(JNIEnv* env, jclass jclass, jlong ptr, jfloat x, jfloat y) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
return instance->contains(x, y);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nDump
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->dump();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Path__1nDumpHex
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
instance->dumpHex();
}
extern "C" JNIEXPORT jbyteArray JNICALL Java_org_jetbrains_skija_Path__1nSerializeToBytes
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
size_t count = instance->writeToMemory(nullptr);
jbyteArray bytesArray = env->NewByteArray((jsize) count);
jbyte* bytes = env->GetByteArrayElements(bytesArray, 0);
instance->writeToMemory(bytes);
env->ReleaseByteArrayElements(bytesArray, bytes, 0);
return bytesArray;
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Path__1nMakeCombining
(JNIEnv* env, jclass jclass, jlong aPtr, jlong bPtr, jint jop) {
SkPath* a = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(aPtr));
SkPath* b = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(bPtr));
SkPathOp op = static_cast<SkPathOp>(jop);
auto res = std::make_unique<SkPath>();
if (Op(*a, *b, op, res.get()))
return reinterpret_cast<jlong>(res.release());
else
return 0;
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Path__1nMakeFromBytes
(JNIEnv* env, jclass jclass, jbyteArray bytesArray) {
SkPath* instance = new SkPath();
int count = env->GetArrayLength(bytesArray);
jbyte* bytes = env->GetByteArrayElements(bytesArray, 0);
if (instance->readFromMemory(bytes, count)) {
env->ReleaseByteArrayElements(bytesArray, bytes, 0);
return reinterpret_cast<jlong>(instance);
} else {
env->ReleaseByteArrayElements(bytesArray, bytes, 0);
delete instance;
return 0;
}
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Path__1nGetGenerationId
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
return instance->getGenerationID();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Path__1nIsValid
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath* instance = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(ptr));
return instance->isValid();
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/PathEffect.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "SkPathEffect.h"
#include "Sk1DPathEffect.h"
#include "Sk2DPathEffect.h"
#include "SkCornerPathEffect.h"
#include "SkDashPathEffect.h"
#include "SkDiscretePathEffect.h"
#include "interop.hh"
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PathEffect__1nMakeSum
(JNIEnv* env, jclass jclass, jlong firstPtr, jlong secondPtr) {
SkPathEffect* first = reinterpret_cast<SkPathEffect*>(static_cast<uintptr_t>(firstPtr));
SkPathEffect* second = reinterpret_cast<SkPathEffect*>(static_cast<uintptr_t>(secondPtr));
SkPathEffect* ptr = SkPathEffect::MakeSum(sk_ref_sp(first), sk_ref_sp(second)).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PathEffect__1nMakeCompose
(JNIEnv* env, jclass jclass, jlong outerPtr, jlong innerPtr) {
SkPathEffect* outer = reinterpret_cast<SkPathEffect*>(static_cast<uintptr_t>(outerPtr));
SkPathEffect* inner = reinterpret_cast<SkPathEffect*>(static_cast<uintptr_t>(innerPtr));
SkPathEffect* ptr = SkPathEffect::MakeCompose(sk_ref_sp(outer), sk_ref_sp(inner)).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PathEffect__1nMakePath1D
(JNIEnv* env, jclass jclass, jlong pathPtr, jfloat advance, jfloat phase, jint styleInt) {
SkPath* path = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(pathPtr));
SkPath1DPathEffect::Style style = static_cast<SkPath1DPathEffect::Style>(styleInt);
SkPathEffect* ptr = SkPath1DPathEffect::Make(*path, advance, phase, style).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PathEffect__1nMakePath2D
(JNIEnv* env, jclass jclass, jfloatArray matrixArr, jlong pathPtr) {
std::unique_ptr<SkMatrix> m = skMatrix(env, matrixArr);
SkPath* path = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(pathPtr));
SkPathEffect* ptr = SkPath2DPathEffect::Make(*m, *path).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PathEffect__1nMakeLine2D
(JNIEnv* env, jclass jclass, jfloat width, jfloatArray matrixArr) {
std::unique_ptr<SkMatrix> m = skMatrix(env, matrixArr);
SkPathEffect* ptr = SkLine2DPathEffect::Make(width, *m).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PathEffect__1nMakeCorner
(JNIEnv* env, jclass jclass, jfloat radius) {
SkPathEffect* ptr = SkCornerPathEffect::Make(radius).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PathEffect__1nMakeDash
(JNIEnv* env, jclass jclass, jfloatArray intervalsArray, jfloat phase) {
jsize len = env->GetArrayLength(intervalsArray);
jfloat* intervals = env->GetFloatArrayElements(intervalsArray, 0);
SkPathEffect* ptr = SkDashPathEffect::Make(intervals, len, phase).release();
env->ReleaseFloatArrayElements(intervalsArray, intervals, 0);
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PathEffect__1nMakeDiscrete
(JNIEnv* env, jclass jclass, jfloat segLength, jfloat dev, jint seed) {
SkPathEffect* ptr = SkDiscretePathEffect::Make(segLength, dev, static_cast<uint32_t>(seed)).release();
return reinterpret_cast<jlong>(ptr);
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/PathMeasure.cc 0 → 100644
View file @ 228274af
#include <jni.h>
#include "SkPathMeasure.h"
#include "interop.hh"
static void deletePathMeasure(SkPathMeasure* instance) {
delete instance;
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PathMeasure__1nGetFinalizer(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deletePathMeasure));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PathMeasure__1nMake
(JNIEnv* env, jclass jclass) {
return reinterpret_cast<jlong>(new SkPathMeasure());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PathMeasure__1nMakePath
(JNIEnv* env, jclass jclass, jlong pathPtr, jboolean forceClosed, jfloat resScale) {
SkPath* path = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(pathPtr));
return reinterpret_cast<jlong>(new SkPathMeasure(*path, forceClosed, resScale));
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_PathMeasure__1nSetPath
(JNIEnv* env, jclass jclass, jlong ptr, jlong pathPtr, jboolean forceClosed) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>(static_cast<uintptr_t>(ptr));
SkPath* path = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(pathPtr));
instance->setPath(path, forceClosed);
}
extern "C" JNIEXPORT jfloat JNICALL Java_org_jetbrains_skija_PathMeasure__1nGetLength
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>(static_cast<uintptr_t>(ptr));
return instance->getLength();
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_PathMeasure__1nGetPosition
(JNIEnv* env, jclass jclass, jlong ptr, jfloat distance) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>(static_cast<uintptr_t>(ptr));
SkPoint position;
if (instance->getPosTan(distance, &position, nullptr))
return skija::Point::fromSkPoint(env, position);
else
return nullptr;
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_PathMeasure__1nGetTangent
(JNIEnv* env, jclass jclass, jlong ptr, jfloat distance) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>(static_cast<uintptr_t>(ptr));
SkVector tangent;
if (instance->getPosTan(distance, nullptr, &tangent))
return skija::Point::fromSkPoint(env, tangent);
else
return nullptr;
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_PathMeasure__1nGetRSXform
(JNIEnv* env, jclass jclass, jlong ptr, jfloat distance) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>(static_cast<uintptr_t>(ptr));
SkPoint position;
SkVector tangent;
if (instance->getPosTan(distance, &position, &tangent))
return env->NewObject(skija::RSXform::cls, skija::RSXform::ctor, tangent.fX, tangent.fY, position.fX, position.fY);
else
return nullptr;
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_PathMeasure__1nGetMatrix
(JNIEnv* env, jclass jclass, jlong ptr, jfloat distance, jboolean getPosition, jboolean getTangent) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>(static_cast<uintptr_t>(ptr));
SkMatrix matrix;
int flags = 0;
if (getPosition)
flags |= SkPathMeasure::MatrixFlags::kGetPosition_MatrixFlag;
if (getTangent)
flags |= SkPathMeasure::MatrixFlags::kGetTangent_MatrixFlag;
if (instance->getMatrix(distance, &matrix, static_cast<SkPathMeasure::MatrixFlags>(flags))) {
std::vector<float> floats(9);
matrix.get9(floats.data());
return javaFloatArray(env, floats);
} else
return nullptr;
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_PathMeasure__1nGetSegment
(JNIEnv* env, jclass jclass, jlong ptr, jfloat startD, jfloat endD, jlong dstPtr, jboolean startWithMoveTo) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>(static_cast<uintptr_t>(ptr));
SkPath* dst = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(dstPtr));
return instance->getSegment(startD, endD, dst, startWithMoveTo);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_PathMeasure__1nIsClosed
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>(static_cast<uintptr_t>(ptr));
return instance->isClosed();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_PathMeasure__1nNextContour
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>(static_cast<uintptr_t>(ptr));
return instance->nextContour();
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/PathSegmentIterator.cc 0 → 100644
View file @ 228274af
#include <jni.h>
#include "SkPath.h"
#include "interop.hh"
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PathSegmentIterator__1nMake
(JNIEnv* env, jclass jclass, jlong pathPtr, jboolean forceClose) {
SkPath* path = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(pathPtr));
SkPath::Iter* iter = new SkPath::Iter(*path, forceClose);
return reinterpret_cast<jlong>(iter);
}
static void deletePathSegmentIterator(SkPath::Iter* iter) {
// std::cout << "Deleting [SkPathSegmentIterator " << path << "]" << std::endl;
delete iter;
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PathSegmentIterator__1nGetFinalizer
(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deletePathSegmentIterator));
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_PathSegmentIterator__1nNext
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPath::Iter* instance = reinterpret_cast<SkPath::Iter*>(static_cast<uintptr_t>(ptr));
SkPoint pts[4];
SkPath::Verb verb = instance->next(pts);
jobject segment;
switch (verb) {
case SkPath::Verb::kDone_Verb:
segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorDone);
break;
case SkPath::Verb::kMove_Verb:
case SkPath::Verb::kClose_Verb:
segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorMoveClose, static_cast<jint>(verb), pts[0].fX, pts[0].fY, instance->isClosedContour());
break;
case SkPath::Verb::kLine_Verb:
segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorLine, pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, instance->isCloseLine(), instance->isClosedContour());
break;
case SkPath::Verb::kQuad_Verb:
segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorQuad, pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY, instance->isClosedContour());
break;
case SkPath::Verb::kConic_Verb:
segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorConic, pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY, instance->conicWeight(), instance->isClosedContour());
break;
case SkPath::Verb::kCubic_Verb:
segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorConic, pts[0].fX, pts[0].fY, pts[1].fX, pts[1].fY, pts[2].fX, pts[2].fY, pts[3].fX, pts[3].fY, instance->isClosedContour());
break;
}
return segment;
}
skiko/src/jvmMain/cpp/common/Picture.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "interop.hh"
#include "SkData.h"
#include "SkPicture.h"
#include "SkShader.h"
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Picture__1nMakeFromData
(JNIEnv* env, jclass jclass, jlong dataPtr) {
SkData* data = reinterpret_cast<SkData*>(static_cast<uintptr_t>(dataPtr));
SkPicture* instance = SkPicture::MakeFromData(data).release();
return reinterpret_cast<jlong>(instance);
}
class BooleanSupplierAbort: public SkPicture::AbortCallback {
public:
BooleanSupplierAbort(JNIEnv* env, jobject supplier) {
this->env = env;
this->supplier = supplier;
}
bool abort() override {
bool res = env->CallBooleanMethod(supplier, java::util::function::BooleanSupplier::apply);
if (java::lang::Throwable::exceptionThrown(env))
return false;
return res;
}
private:
JNIEnv* env;
jobject supplier;
};
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Picture__1nPlayback
(JNIEnv* env, jclass jclass, jlong ptr, jlong canvasPtr, jobject abort) {
SkPicture* instance = reinterpret_cast<SkPicture*>(static_cast<uintptr_t>(ptr));
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
if (abort == nullptr) {
instance->playback(canvas, nullptr);
} else {
BooleanSupplierAbort callback(env, abort);
instance->playback(canvas, &callback);
}
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Picture__1nGetCullRect
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPicture* instance = reinterpret_cast<SkPicture*>(static_cast<uintptr_t>(ptr));
return skija::Rect::fromSkRect(env, instance->cullRect());
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Picture__1nGetUniqueId
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPicture* instance = reinterpret_cast<SkPicture*>(static_cast<uintptr_t>(ptr));
return instance->uniqueID();
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Picture__1nSerializeToData
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPicture* instance = reinterpret_cast<SkPicture*>(static_cast<uintptr_t>(ptr));
SkData* data = instance->serialize().release();
return reinterpret_cast<jlong>(data);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Picture__1nMakePlaceholder
(JNIEnv* env, jclass jclass, jfloat left, jfloat top, jfloat right, jfloat bottom) {
SkRect cull = SkRect::MakeLTRB(left, top, right, bottom);
SkPicture* instance = SkPicture::MakePlaceholder(cull).release();
return reinterpret_cast<jlong>(instance);
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Picture__1nGetApproximateOpCount
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPicture* instance = reinterpret_cast<SkPicture*>(static_cast<uintptr_t>(ptr));
return instance->approximateOpCount();
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Picture__1nGetApproximateBytesUsed
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPicture* instance = reinterpret_cast<SkPicture*>(static_cast<uintptr_t>(ptr));
return instance->approximateBytesUsed();
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Picture__1nMakeShader
(JNIEnv* env, jclass jclass, jlong ptr, jint tmxValue, jint tmyValue, jint filterModeValue, jfloatArray localMatrixArr, jobject tileRectObj) {
SkPicture* instance = reinterpret_cast<SkPicture*>(static_cast<uintptr_t>(ptr));
SkTileMode tmx = static_cast<SkTileMode>(tmxValue);
SkTileMode tmy = static_cast<SkTileMode>(tmyValue);
SkFilterMode filterMode = static_cast<SkFilterMode>(filterModeValue);
std::unique_ptr<SkMatrix> localMatrix = skMatrix(env, localMatrixArr);
std::unique_ptr<SkRect> tileRect = skija::Rect::toSkRect(env, tileRectObj);
SkShader* shader = instance->makeShader(tmx, tmy, filterMode, localMatrix.get(), tileRect.get()).release();
return reinterpret_cast<jlong>(shader);
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/PictureRecorder.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "interop.hh"
#include "SkDrawable.h"
#include "SkPictureRecorder.h"
static void deletePictureRecorder(SkPictureRecorder* pr) {
// std::cout << "Deleting [SkPictureRecorder " << PictureRecorder << "]" << std::endl;
delete pr;
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PictureRecorder__1nMake
(JNIEnv* env, jclass jclass) {
SkPictureRecorder* instance = new SkPictureRecorder();
return reinterpret_cast<jlong>(instance);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PictureRecorder__1nGetFinalizer
(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deletePictureRecorder));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PictureRecorder__1nBeginRecording
(JNIEnv* env, jclass jclass, jlong ptr, jfloat left, jfloat top, jfloat right, jfloat bottom) {
SkPictureRecorder* instance = reinterpret_cast<SkPictureRecorder*>(static_cast<uintptr_t>(ptr));
SkCanvas* canvas = instance->beginRecording(SkRect::MakeLTRB(left, top, right, bottom), nullptr);
return reinterpret_cast<jlong>(canvas);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PictureRecorder__1nGetRecordingCanvas
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPictureRecorder* instance = reinterpret_cast<SkPictureRecorder*>(static_cast<uintptr_t>(ptr));
SkCanvas* canvas = instance->getRecordingCanvas();
return reinterpret_cast<jlong>(canvas);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PictureRecorder__1nFinishRecordingAsPicture
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPictureRecorder* instance = reinterpret_cast<SkPictureRecorder*>(static_cast<uintptr_t>(ptr));
SkPicture* picture = instance->finishRecordingAsPicture().release();
return reinterpret_cast<jlong>(picture);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PictureRecorder__1nFinishRecordingAsPictureWithCull
(JNIEnv* env, jclass jclass, jlong ptr, jfloat left, jfloat top, jfloat right, jfloat bottom) {
SkPictureRecorder* instance = reinterpret_cast<SkPictureRecorder*>(static_cast<uintptr_t>(ptr));
SkPicture* picture = instance->finishRecordingAsPictureWithCull(SkRect::MakeLTRB(left, top, right, bottom)).release();
return reinterpret_cast<jlong>(picture);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PictureRecorder__1nFinishRecordingAsDrawable
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPictureRecorder* instance = reinterpret_cast<SkPictureRecorder*>(static_cast<uintptr_t>(ptr));
SkDrawable* drawable = instance->finishRecordingAsDrawable().release();
return reinterpret_cast<jlong>(drawable);
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/PixelRef.cc 0 → 100644
View file @ 228274af
#include <jni.h>
#include "SkPixelRef.h"
#include "interop.hh"
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_PixelRef__1nGetWidth
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPixelRef* instance = reinterpret_cast<SkPixelRef*>(static_cast<uintptr_t>(ptr));
return instance->width();
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_PixelRef__1nGetHeight
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPixelRef* instance = reinterpret_cast<SkPixelRef*>(static_cast<uintptr_t>(ptr));
return instance->height();
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_PixelRef__1nGetRowBytes
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPixelRef* instance = reinterpret_cast<SkPixelRef*>(static_cast<uintptr_t>(ptr));
return instance->rowBytes();
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_PixelRef__1nGetGenerationId
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPixelRef* instance = reinterpret_cast<SkPixelRef*>(static_cast<uintptr_t>(ptr));
return instance->getGenerationID();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_PixelRef__1nNotifyPixelsChanged
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPixelRef* instance = reinterpret_cast<SkPixelRef*>(static_cast<uintptr_t>(ptr));
instance->notifyPixelsChanged();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_PixelRef__1nIsImmutable
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPixelRef* instance = reinterpret_cast<SkPixelRef*>(static_cast<uintptr_t>(ptr));
return instance->isImmutable();
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_PixelRef__1nSetImmutable
(JNIEnv* env, jclass jclass, jlong ptr) {
SkPixelRef* instance = reinterpret_cast<SkPixelRef*>(static_cast<uintptr_t>(ptr));
instance->setImmutable();
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/Pixmap.cc 0 → 100644
View file @ 228274af
#include <jni.h>
#include "interop.hh"
#include "SkPixmap.h"
static void deletePixmap(SkPixmap *pixmap) {
delete pixmap;
}
extern "C" {
JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Pixmap__1nGetFinalizer
(JNIEnv *env, jclass klass) {
return ptrToJlong(&deletePixmap);
}
JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Pixmap__1nMakeNull
(JNIEnv *env, jclass klass) {
return ptrToJlong(new SkPixmap());
}
JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Pixmap__1nMake
(JNIEnv *env, jclass klass,
jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr, jlong pixelsPtr, jint rowBytes) {
SkColorSpace* colorSpace = jlongToPtr<SkColorSpace*>(colorSpacePtr);
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
static_cast<SkAlphaType>(alphaType),
sk_ref_sp<SkColorSpace>(colorSpace));
return ptrToJlong(new SkPixmap(
imageInfo, jlongToPtr<void*>(pixelsPtr), rowBytes));
}
JNIEXPORT void JNICALL Java_org_jetbrains_skija_Pixmap__1nReset
(JNIEnv *env, jclass klass, jlong ptr) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
pixmap->reset();
}
JNIEXPORT void JNICALL Java_org_jetbrains_skija_Pixmap__1nResetWithInfo
(JNIEnv *env, jclass klass, jlong ptr,
jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr, jlong pixelsPtr, jint rowBytes) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
SkColorSpace* colorSpace = jlongToPtr<SkColorSpace*>(colorSpacePtr);
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
static_cast<SkAlphaType>(alphaType),
sk_ref_sp<SkColorSpace>(colorSpace));
pixmap->reset(imageInfo, jlongToPtr<void*>(pixelsPtr), rowBytes);
}
JNIEXPORT void JNICALL Java_org_jetbrains_skija_Pixmap__1nSetColorSpace
(JNIEnv *env, jclass klass, jlong ptr, jlong colorSpacePtr) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
SkColorSpace* colorSpace = jlongToPtr<SkColorSpace*>(colorSpacePtr);
pixmap->setColorSpace(sk_ref_sp<SkColorSpace>(colorSpace));
}
JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Pixmap__1nExtractSubset
(JNIEnv *env, jclass klass, jlong ptr,
jlong subsetPtr, jint l, jint t, jint w, jint h) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
SkPixmap* dst = jlongToPtr<SkPixmap*>(subsetPtr);
return pixmap->extractSubset(dst, { l, t, w, h });
}
JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Pixmap__1nGetInfo
(JNIEnv *env, jclass klass, jlong ptr) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
const SkImageInfo& imageInfo = pixmap->info();
return skija::ImageInfo::toJava(env, imageInfo);
}
JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Pixmap__1nGetRowBytes
(JNIEnv *env, jclass klass, jlong ptr) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
return static_cast<jint>(pixmap->rowBytes());
}
JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Pixmap__1nGetAddr
(JNIEnv *env, jclass klass, jlong ptr) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
return ptrToJlong(pixmap->addr());
}
JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Pixmap__1nGetRowBytesAsPixels
(JNIEnv *env, jclass klass, jlong ptr) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
return static_cast<jint>(pixmap->rowBytesAsPixels());
}
JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Pixmap__1nComputeByteSize
(JNIEnv *env, jclass klass, jlong ptr) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
return static_cast<jint>(pixmap->computeByteSize());
}
JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Pixmap__1nComputeIsOpaque
(JNIEnv *env, jclass klass, jlong ptr) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
return static_cast<jboolean>(pixmap->computeIsOpaque());
}
JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Pixmap__1nGetColor
(JNIEnv *env, jclass klass, jlong ptr, jint x, jint y) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
return static_cast<jint>(pixmap->getColor(x, y));
}
JNIEXPORT jfloat JNICALL Java_org_jetbrains_skija_Pixmap__1nGetAlphaF
(JNIEnv *env, jclass klass, jlong ptr, jint x, jint y) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
return static_cast<jfloat>(pixmap->getAlphaf(x, y));
}
JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Pixmap__1nGetAddrAt
(JNIEnv *env, jclass klass, jlong ptr, jint x, jint y) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
return reinterpret_cast<jlong>(pixmap->addr(x, y));
}
JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Pixmap__1nReadPixels
(JNIEnv *env, jclass klass, jlong ptr,
jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr, jlong pixelsPtr, jint rowBytes) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
SkColorSpace* colorSpace = jlongToPtr<SkColorSpace*>(colorSpacePtr);
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
static_cast<SkAlphaType>(alphaType),
sk_ref_sp<SkColorSpace>(colorSpace));
return static_cast<jboolean>(pixmap->readPixels(imageInfo, jlongToPtr<void*>(pixelsPtr), rowBytes));
}
JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Pixmap__1nReadPixelsFromPoint
(JNIEnv *env, jclass klass, jlong ptr,
jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr, jlong pixelsPtr, jint rowBytes,
jint srcX, jint srcY) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
SkColorSpace* colorSpace = jlongToPtr<SkColorSpace*>(colorSpacePtr);
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
static_cast<SkAlphaType>(alphaType),
sk_ref_sp<SkColorSpace>(colorSpace));
return static_cast<jboolean>(pixmap->readPixels(imageInfo, jlongToPtr<void*>(pixelsPtr), rowBytes, srcX, srcY));
}
JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Pixmap__1nReadPixelsToPixmap
(JNIEnv *env, jclass klass, jlong ptr, jlong dstPixmapPtr) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
SkPixmap* dstPixmap = jlongToPtr<SkPixmap*>(dstPixmapPtr);
return static_cast<jboolean>(pixmap->readPixels(*dstPixmap));
}
JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Pixmap__1nReadPixelsToPixmapFromPoint
(JNIEnv *env, jclass klass, jlong ptr, jlong dstPixmapPtr, jint srcX, jint srcY) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
SkPixmap* dstPixmap = jlongToPtr<SkPixmap*>(dstPixmapPtr);
return static_cast<jboolean>(pixmap->readPixels(*dstPixmap, srcX, srcY));
}
JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Pixmap__1nScalePixels
(JNIEnv *env, jclass klass, jlong ptr, jlong dstPixmapPtr, jlong samplingOptions) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
SkPixmap* dstPixmap = jlongToPtr<SkPixmap*>(dstPixmapPtr);
return static_cast<jboolean>(pixmap->scalePixels(*dstPixmap, skija::SamplingMode::unpack(samplingOptions)));
}
JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Pixmap__1nErase
(JNIEnv *env, jclass klass, jlong ptr, jint color) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
return static_cast<jboolean>(pixmap->erase(color));
}
JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Pixmap__1nEraseSubset
(JNIEnv *env, jclass klass, jlong ptr, jint color, jint l, jint t, jint w, jint h) {
SkPixmap* pixmap = jlongToPtr<SkPixmap*>(ptr);
return static_cast<jboolean>(pixmap->erase(color, { l, t, w, h }));
}
}
skiko/src/jvmMain/cpp/common/Region.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "SkRegion.h"
#include "interop.hh"
static void deleteRegion(SkRegion* region) {
// std::cout << "Deleting [SkRegion " << Region << "]" << std::endl;
delete region;
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Region__1nMake(JNIEnv* env, jclass jclass) {
SkRegion* obj = new SkRegion();
return reinterpret_cast<jlong>(obj);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Region__1nGetFinalizer(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteRegion));
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nSet(JNIEnv* env, jclass jclass, jlong ptr, jlong regionPtr) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
SkRegion* other = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(regionPtr));
return instance->set(*other);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nIsEmpty(JNIEnv* env, jclass jclass, jlong ptr) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
return instance->isEmpty();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nIsRect(JNIEnv* env, jclass jclass, jlong ptr) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
return instance->isRect();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nIsComplex(JNIEnv* env, jclass jclass, jlong ptr) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
return instance->isComplex();
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Region__1nGetBounds(JNIEnv* env, jclass jclass, jlong ptr) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
return skija::IRect::fromSkIRect(env, instance->getBounds());
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Region__1nComputeRegionComplexity(JNIEnv* env, jclass jclass, jlong ptr) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
return instance->computeRegionComplexity();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nGetBoundaryPath(JNIEnv* env, jclass jclass, jlong ptr, jlong pathPtr) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
SkPath* path = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(pathPtr));
return instance->getBoundaryPath(path);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nSetEmpty(JNIEnv* env, jclass jclass, jlong ptr) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
return instance->setEmpty();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nSetRect(JNIEnv* env, jclass jclass, jlong ptr, jint left, jint top, jint right, jint bottom) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
return instance->setRect({left, top, right, bottom});
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nSetRects(JNIEnv* env, jclass jclass, jlong ptr, jintArray coords) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
int len = env->GetArrayLength(coords);
std::vector<SkIRect> rects(len / 4);
jint* arr = env->GetIntArrayElements(coords, 0);
for (int i = 0; i < len; i += 4)
rects[i / 4] = {arr[i], arr[i+1], arr[i+2], arr[i+3]};
env->ReleaseIntArrayElements(coords, arr, 0);
return instance->setRects(rects.data(), len / 4);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nSetRegion(JNIEnv* env, jclass jclass, jlong ptr, jlong regionPtr) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
SkRegion* region = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(regionPtr));
return instance->setRegion(*region);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nSetPath(JNIEnv* env, jclass jclass, jlong ptr, jlong pathPtr, jlong regionPtr) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
SkPath* path = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(pathPtr));
SkRegion* region = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(regionPtr));
return instance->setPath(*path, *region);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nIntersectsIRect(JNIEnv* env, jclass jclass, jlong ptr, jint left, jint top, jint right, jint bottom) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
return instance->intersects({left, top, right, bottom});
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nIntersectsRegion(JNIEnv* env, jclass jclass, jlong ptr, jlong regionPtr) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
SkRegion* region = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(regionPtr));
return instance->intersects(*region);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nContainsIPoint(JNIEnv* env, jclass jclass, jlong ptr, jint x, jint y) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
return instance->contains(x, y);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nContainsIRect(JNIEnv* env, jclass jclass, jlong ptr, jint left, jint top, jint right, jint bottom) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
return instance->contains({left, top, right, bottom});
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nContainsRegion(JNIEnv* env, jclass jclass, jlong ptr, jlong regionPtr) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
SkRegion* region = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(regionPtr));
return instance->contains(*region);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nQuickContains(JNIEnv* env, jclass jclass, jlong ptr, jint left, jint top, jint right, jint bottom) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
return instance->quickContains({left, top, right, bottom});
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nQuickRejectIRect(JNIEnv* env, jclass jclass, jlong ptr, jint left, jint top, jint right, jint bottom) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
return instance->quickReject({left, top, right, bottom});
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nQuickRejectRegion(JNIEnv* env, jclass jclass, jlong ptr, jlong regionPtr) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
SkRegion* region = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(regionPtr));
return instance->contains(*region);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Region__1nTranslate(JNIEnv* env, jclass jclass, jlong ptr, jint dx, jint dy) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
instance->translate(dx, dy);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nOpIRect(JNIEnv* env, jclass jclass, jlong ptr, jint left, jint top, jint right, jint bottom, jint op) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
return instance->op({left, top, right, bottom}, static_cast<SkRegion::Op>(op));
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nOpRegion(JNIEnv* env, jclass jclass, jlong ptr, jlong regionPtr, jint op) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
SkRegion* region = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(regionPtr));
return instance->op(*region, static_cast<SkRegion::Op>(op));
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nOpIRectRegion(JNIEnv* env, jclass jclass, jlong ptr, jint left, jint top, jint right, jint bottom, jlong regionPtr, jint op) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
SkRegion* region = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(regionPtr));
return instance->op({left, top, right, bottom}, *region, static_cast<SkRegion::Op>(op));
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nOpRegionIRect(JNIEnv* env, jclass jclass, jlong ptr, jlong regionPtr, jint left, jint top, jint right, jint bottom, jint op) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
SkRegion* region = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(regionPtr));
return instance->op(*region, {left, top, right, bottom}, static_cast<SkRegion::Op>(op));
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Region__1nOpRegionRegion(JNIEnv* env, jclass jclass, jlong ptr, jlong regionPtrA, jlong regionPtrB, jint op) {
SkRegion* instance = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(ptr));
SkRegion* regionA = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(regionPtrA));
SkRegion* regionB = reinterpret_cast<SkRegion*>(static_cast<uintptr_t>(regionPtrB));
return instance->op(*regionA, *regionB, static_cast<SkRegion::Op>(op));
}
skiko/src/jvmMain/cpp/common/RuntimeEffect.cc 0 → 100644
View file @ 228274af
#include <jni.h>
#include "SkRuntimeEffect.h"
#include "interop.hh"
extern "C" JNIEXPORT jlong JNICALL
Java_org_jetbrains_skija_RuntimeEffect__1nMakeShader(JNIEnv* env,
jclass jclass,
jlong ptr,
jlong uniformPtr,
jlongArray childrenPtrsArr,
jfloatArray localMatrixArr,
jboolean isOpaque) {
SkRuntimeEffect* runtimeEffect = jlongToPtr<SkRuntimeEffect*>(ptr);
SkData* uniform = jlongToPtr<SkData*>(uniformPtr);
std::unique_ptr<SkMatrix> localMatrix = skMatrix(env, localMatrixArr);
jsize childCount = env->GetArrayLength(childrenPtrsArr);
jlong* childrenPtrs = env->GetLongArrayElements(childrenPtrsArr, 0);
std::vector<sk_sp<SkShader>> children(childCount);
for (size_t i = 0; i < childCount; i++) {
SkShader* si = jlongToPtr<SkShader*>(childrenPtrs[i]);
children[i] = sk_ref_sp(si);
}
env->ReleaseLongArrayElements(childrenPtrsArr, childrenPtrs, 0);
sk_sp<SkShader> shader = runtimeEffect->makeShader(sk_ref_sp<SkData>(uniform),
children.data(),
childCount,
localMatrix.get(),
isOpaque);
return ptrToJlong(shader.release());
}
extern "C" JNIEXPORT jlong JNICALL
Java_org_jetbrains_skija_RuntimeEffect__1nMakeForShader(JNIEnv* env, jclass jclass, jstring sksl) {
SkString skslProper = skString(env, sksl);
SkRuntimeEffect::Result result = SkRuntimeEffect::MakeForShader(skslProper);
if (result.errorText.isEmpty()) {
sk_sp<SkRuntimeEffect> effect = result.effect;
return ptrToJlong(effect.release());
} else {
env->ThrowNew(java::lang::RuntimeException::cls, result.errorText.c_str());
return 0;
}
}
extern "C" JNIEXPORT jlong JNICALL
Java_org_jetbrains_skija_RuntimeEffect__1nMakeForColorFilter(JNIEnv* env,
jclass jclass,
jstring sksl) {
SkString skslProper = skString(env, sksl);
SkRuntimeEffect::Result result = SkRuntimeEffect::MakeForColorFilter(skslProper);
if (result.errorText.isEmpty()) {
return ptrToJlong(result.effect.release());
} else {
env->ThrowNew(java::lang::RuntimeException::cls, result.errorText.c_str());
return 0;
}
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/Shader.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "SkColorFilter.h"
#include "SkShader.h"
#include "SkGradientShader.h"
#include "interop.hh"
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Shader__1nMakeWithColorFilter
(JNIEnv* env, jclass jclass, jlong ptr, jlong filterPtr) {
SkShader* instance = reinterpret_cast<SkShader*>(static_cast<uintptr_t>(ptr));
SkColorFilter* filter = reinterpret_cast<SkColorFilter*>(static_cast<uintptr_t>(filterPtr));
SkShader* newPtr = instance->makeWithColorFilter(sk_ref_sp(filter)).release();
return reinterpret_cast<jlong>(newPtr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Shader__1nMakeLinearGradient
(JNIEnv* env, jclass jclass, jfloat x0, jfloat y0, jfloat x1, jfloat y1, jintArray colorsArray, jfloatArray posArray, jint tileModeInt, jint flags, jfloatArray matrixArray) {
SkPoint pts[2] {SkPoint::Make(x0, y0), SkPoint::Make(x1, y1)};
jint* colors = env->GetIntArrayElements(colorsArray, nullptr);
float* pos = posArray == nullptr ? nullptr : env->GetFloatArrayElements(posArray, nullptr);
SkTileMode tileMode = static_cast<SkTileMode>(tileModeInt);
std::unique_ptr<SkMatrix> localMatrix = skMatrix(env, matrixArray);
SkShader* ptr = SkGradientShader::MakeLinear(pts, reinterpret_cast<SkColor*>(colors), pos, env->GetArrayLength(colorsArray), tileMode, static_cast<uint32_t>(flags), localMatrix.get()).release();
env->ReleaseIntArrayElements(colorsArray, colors, 0);
if (posArray != nullptr)
env->ReleaseFloatArrayElements(posArray, pos, 0);
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Shader__1nMakeLinearGradientCS
(JNIEnv* env, jclass jclass, jfloat x0, jfloat y0, jfloat x1, jfloat y1, jfloatArray colorsArray, jlong colorSpacePtr, jfloatArray posArray, jint tileModeInt, jint flags, jfloatArray matrixArray) {
SkPoint pts[2] {SkPoint::Make(x0, y0), SkPoint::Make(x1, y1)};
float* colors = env->GetFloatArrayElements(colorsArray, nullptr);
sk_sp<SkColorSpace> colorSpace = sk_ref_sp<SkColorSpace>(reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr)));
float* pos = env->GetFloatArrayElements(posArray, nullptr);
SkTileMode tileMode = static_cast<SkTileMode>(tileModeInt);
std::unique_ptr<SkMatrix> localMatrix = skMatrix(env, matrixArray);
SkShader* ptr = SkGradientShader::MakeLinear(pts, reinterpret_cast<SkColor4f*>(colors), colorSpace, pos, env->GetArrayLength(posArray), tileMode, static_cast<uint32_t>(flags), localMatrix.get()).release();
env->ReleaseFloatArrayElements(colorsArray, colors, 0);
env->ReleaseFloatArrayElements(posArray, pos, 0);
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Shader__1nMakeRadialGradient
(JNIEnv* env, jclass jclass, jfloat x, jfloat y, jfloat r, jintArray colorsArray, jfloatArray posArray, jint tileModeInt, jint flags, jfloatArray matrixArray) {
jint* colors = env->GetIntArrayElements(colorsArray, nullptr);
float* pos = posArray == nullptr ? nullptr : env->GetFloatArrayElements(posArray, nullptr);
SkTileMode tileMode = static_cast<SkTileMode>(tileModeInt);
std::unique_ptr<SkMatrix> localMatrix = skMatrix(env, matrixArray);
SkShader* ptr = SkGradientShader::MakeRadial(SkPoint::Make(x, y), r, reinterpret_cast<SkColor*>(colors), pos, env->GetArrayLength(colorsArray), tileMode, static_cast<uint32_t>(flags), localMatrix.get()).release();
env->ReleaseIntArrayElements(colorsArray, colors, 0);
if (posArray != nullptr)
env->ReleaseFloatArrayElements(posArray, pos, 0);
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Shader__1nMakeRadialGradientCS
(JNIEnv* env, jclass jclass, jfloat x, jfloat y, jfloat r, jfloatArray colorsArray, jlong colorSpacePtr, jfloatArray posArray, jint tileModeInt, jint flags, jfloatArray matrixArray) {
float* colors = env->GetFloatArrayElements(colorsArray, nullptr);
sk_sp<SkColorSpace> colorSpace = sk_ref_sp<SkColorSpace>(reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr)));
float* pos = env->GetFloatArrayElements(posArray, nullptr);
SkTileMode tileMode = static_cast<SkTileMode>(tileModeInt);
std::unique_ptr<SkMatrix> localMatrix = skMatrix(env, matrixArray);
SkShader* ptr = SkGradientShader::MakeRadial(SkPoint::Make(x, y), r, reinterpret_cast<SkColor4f*>(colors), colorSpace, pos, env->GetArrayLength(posArray), tileMode, static_cast<uint32_t>(flags), localMatrix.get()).release();
env->ReleaseFloatArrayElements(colorsArray, colors, 0);
env->ReleaseFloatArrayElements(posArray, pos, 0);
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Shader__1nMakeTwoPointConicalGradient
(JNIEnv* env, jclass jclass, jfloat x0, jfloat y0, jfloat r0, jfloat x1, jfloat y1, jfloat r1, jintArray colorsArray, jfloatArray posArray, jint tileModeInt, jint flags, jfloatArray matrixArray) {
jint* colors = env->GetIntArrayElements(colorsArray, nullptr);
float* pos = posArray == nullptr ? nullptr : env->GetFloatArrayElements(posArray, nullptr);
SkTileMode tileMode = static_cast<SkTileMode>(tileModeInt);
std::unique_ptr<SkMatrix> localMatrix = skMatrix(env, matrixArray);
SkShader* ptr = SkGradientShader::MakeTwoPointConical(SkPoint::Make(x0, y0), r0, SkPoint::Make(x1, y1), r1, reinterpret_cast<SkColor*>(colors), pos, env->GetArrayLength(colorsArray), tileMode, static_cast<uint32_t>(flags), localMatrix.get()).release();
env->ReleaseIntArrayElements(colorsArray, colors, 0);
if (posArray != nullptr)
env->ReleaseFloatArrayElements(posArray, pos, 0);
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Shader__1nMakeTwoPointConicalGradientCS
(JNIEnv* env, jclass jclass, jfloat x0, jfloat y0, jfloat r0, jfloat x1, jfloat y1, jfloat r1, jfloatArray colorsArray, jlong colorSpacePtr, jfloatArray posArray, jint tileModeInt, jint flags, jfloatArray matrixArray) {
float* colors = env->GetFloatArrayElements(colorsArray, nullptr);
sk_sp<SkColorSpace> colorSpace = sk_ref_sp<SkColorSpace>(reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr)));
float* pos = env->GetFloatArrayElements(posArray, nullptr);
SkTileMode tileMode = static_cast<SkTileMode>(tileModeInt);
std::unique_ptr<SkMatrix> localMatrix = skMatrix(env, matrixArray);
SkShader* ptr = SkGradientShader::MakeTwoPointConical(SkPoint::Make(x0, y0), r0, SkPoint::Make(x1, y1), r1, reinterpret_cast<SkColor4f*>(colors), colorSpace, pos, env->GetArrayLength(posArray), tileMode, static_cast<uint32_t>(flags), localMatrix.get()).release();
env->ReleaseFloatArrayElements(colorsArray, colors, 0);
env->ReleaseFloatArrayElements(posArray, pos, 0);
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Shader__1nMakeSweepGradient
(JNIEnv* env, jclass jclass, jfloat x, jfloat y, jfloat start, jfloat end, jintArray colorsArray, jfloatArray posArray, jint tileModeInt, jint flags, jfloatArray matrixArray) {
jint* colors = env->GetIntArrayElements(colorsArray, nullptr);
float* pos = posArray == nullptr ? nullptr : env->GetFloatArrayElements(posArray, nullptr);
SkTileMode tileMode = static_cast<SkTileMode>(tileModeInt);
std::unique_ptr<SkMatrix> localMatrix = skMatrix(env, matrixArray);
SkShader* ptr = SkGradientShader::MakeSweep(x, y, reinterpret_cast<SkColor*>(colors), pos, env->GetArrayLength(colorsArray), tileMode, start, end, static_cast<uint32_t>(flags), localMatrix.get()).release();
env->ReleaseIntArrayElements(colorsArray, colors, 0);
if (posArray != nullptr)
env->ReleaseFloatArrayElements(posArray, pos, 0);
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Shader__1nMakeSweepGradientCS
(JNIEnv* env, jclass jclass, jfloat x, jfloat y, jfloat start, jfloat end, jfloatArray colorsArray, jlong colorSpacePtr, jfloatArray posArray, jint tileModeInt, jint flags, jfloatArray matrixArray) {
float* colors = env->GetFloatArrayElements(colorsArray, nullptr);
sk_sp<SkColorSpace> colorSpace = sk_ref_sp<SkColorSpace>(reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr)));
float* pos = env->GetFloatArrayElements(posArray, nullptr);
SkTileMode tileMode = static_cast<SkTileMode>(tileModeInt);
std::unique_ptr<SkMatrix> localMatrix = skMatrix(env, matrixArray);
SkShader* ptr = SkGradientShader::MakeSweep(x, y, reinterpret_cast<SkColor4f*>(colors), colorSpace, pos, env->GetArrayLength(colorsArray), tileMode, start, end, static_cast<uint32_t>(flags), localMatrix.get()).release();
env->ReleaseFloatArrayElements(colorsArray, colors, 0);
env->ReleaseFloatArrayElements(posArray, pos, 0);
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Shader__1nMakeEmpty(JNIEnv* env, jclass jclass) {
SkShader* ptr = SkShaders::Empty().release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Shader__1nMakeColor(JNIEnv* env, jclass jclass, jint color) {
SkShader* ptr = SkShaders::Color(color).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Shader__1nMakeColorCS(JNIEnv* env, jclass jclass, jfloat r, jfloat g, jfloat b, jfloat a, jlong colorSpacePtr) {
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr));
SkShader* ptr = SkShaders::Color(SkColor4f{r, g, b, a}, sk_ref_sp<SkColorSpace>(colorSpace)).release();
return reinterpret_cast<jlong>(ptr);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Shader__1nMakeBlend(JNIEnv* env, jclass jclass, jint blendModeInt, jlong dstPtr, jlong srcPtr) {
SkShader* dst = reinterpret_cast<SkShader*>(static_cast<uintptr_t>(dstPtr));
SkShader* src = reinterpret_cast<SkShader*>(static_cast<uintptr_t>(srcPtr));
SkBlendMode blendMode = static_cast<SkBlendMode>(blendModeInt);
SkShader* ptr = SkShaders::Blend(blendMode, sk_ref_sp<SkShader>(dst), sk_ref_sp<SkShader>(src)).release();
return reinterpret_cast<jlong>(ptr);
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/ShadowUtils.cc 0 → 100644
View file @ 228274af
#include <jni.h>
#include "SkShadowUtils.h"
#include "interop.hh"
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_ShadowUtils__1nDrawShadow
(JNIEnv* env, jclass jclass, jlong canvasPtr, jlong pathPtr, jfloat zPlaneX, jfloat zPlaneY, jfloat zPlaneZ,
jfloat lightPosX, jfloat lightPosY, jfloat lightPosZ, jfloat lightRadius, jint ambientColor, jint spotColor, jint flags) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkPath* path = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(pathPtr));
SkShadowUtils::DrawShadow(canvas, *path, {zPlaneX, zPlaneY, zPlaneZ}, {lightPosX, lightPosY, lightPosZ}, lightRadius, ambientColor, spotColor, flags);
}
extern "C" JNIEXPORT int JNICALL Java_org_jetbrains_skija_ShadowUtils__1nComputeTonalAmbientColor
(JNIEnv* env, jclass jclass, jint ambientColor, jint spotColor) {
SkColor outAmbientColor, outSpotColor;
SkShadowUtils::ComputeTonalColors(ambientColor, spotColor, &outAmbientColor, &outSpotColor);
return outAmbientColor;
}
extern "C" JNIEXPORT int JNICALL Java_org_jetbrains_skija_ShadowUtils__1nComputeTonalSpotColor
(JNIEnv* env, jclass jclass, jint ambientColor, jint spotColor) {
SkColor outAmbientColor, outSpotColor;
SkShadowUtils::ComputeTonalColors(ambientColor, spotColor, &outAmbientColor, &outSpotColor);
return outSpotColor;
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/Surface.cc 0 → 100644
View file @ 228274af
#include <iostream>
#include <jni.h>
#include "GrDirectContext.h"
#include "SkSurface.h"
#include "interop.hh"
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Surface__1nMakeRasterDirect
(JNIEnv* env, jclass jclass,
jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr,
jlong pixelsPtr, jlong rowBytes,
jobject surfacePropsObj)
{
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr));
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
static_cast<SkAlphaType>(alphaType),
sk_ref_sp<SkColorSpace>(colorSpace));
std::unique_ptr<SkSurfaceProps> surfaceProps = skija::SurfaceProps::toSkSurfaceProps(env, surfacePropsObj);
sk_sp<SkSurface> instance = SkSurface::MakeRasterDirect(
imageInfo,
reinterpret_cast<void*>(static_cast<uintptr_t>(pixelsPtr)),
rowBytes,
surfaceProps.get());
return reinterpret_cast<jlong>(instance.release());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Surface__1nMakeRasterDirectWithPixmap
(JNIEnv* env, jclass jclass,
jlong pixmapPtr, jobject surfacePropsObj)
{
SkPixmap* pixmap = reinterpret_cast<SkPixmap*>(static_cast<uintptr_t>(pixmapPtr));
std::unique_ptr<SkSurfaceProps> surfaceProps = skija::SurfaceProps::toSkSurfaceProps(env, surfacePropsObj);
sk_sp<SkSurface> instance = SkSurface::MakeRasterDirect(*pixmap, surfaceProps.get());
return reinterpret_cast<jlong>(instance.release());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Surface__1nMakeRaster
(JNIEnv* env, jclass jclass,
jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr,
jlong rowBytes,
jobject surfacePropsObj)
{
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr));
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
static_cast<SkAlphaType>(alphaType),
sk_ref_sp<SkColorSpace>(colorSpace));
std::unique_ptr<SkSurfaceProps> surfaceProps = skija::SurfaceProps::toSkSurfaceProps(env, surfacePropsObj);
sk_sp<SkSurface> instance = SkSurface::MakeRaster(
imageInfo,
rowBytes,
surfaceProps.get());
return reinterpret_cast<jlong>(instance.release());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Surface__1nMakeRasterN32Premul
(JNIEnv* env, jclass jclass, jint width, jint height) {
sk_sp<SkSurface> surface = SkSurface::MakeRasterN32Premul(
width, height,
/* const SkSurfaceProps* */ nullptr
);
return reinterpret_cast<jlong>(surface.release());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Surface__1nMakeFromBackendRenderTarget
(JNIEnv* env, jclass jclass, jlong pContext, jlong pBackendRenderTarget, jint surfaceOrigin, jint colorType, jlong colorSpacePtr, jobject surfacePropsObj) {
GrDirectContext* context = reinterpret_cast<GrDirectContext*>(static_cast<uintptr_t>(pContext));
GrBackendRenderTarget* backendRenderTarget = reinterpret_cast<GrBackendRenderTarget*>(static_cast<uintptr_t>(pBackendRenderTarget));
GrSurfaceOrigin grSurfaceOrigin = static_cast<GrSurfaceOrigin>(surfaceOrigin);
SkColorType skColorType = static_cast<SkColorType>(colorType);
sk_sp<SkColorSpace> colorSpace = sk_ref_sp<SkColorSpace>(reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr)));
std::unique_ptr<SkSurfaceProps> surfaceProps = skija::SurfaceProps::toSkSurfaceProps(env, surfacePropsObj);
sk_sp<SkSurface> surface = SkSurface::MakeFromBackendRenderTarget(
static_cast<GrRecordingContext*>(context),
*backendRenderTarget,
grSurfaceOrigin,
skColorType,
colorSpace,
surfaceProps.get(),
/* RenderTargetReleaseProc */ nullptr,
/* ReleaseContext */ nullptr
);
return reinterpret_cast<jlong>(surface.release());
}
#ifdef SK_METAL
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Surface__1nMakeFromMTKView
(JNIEnv* env, jclass jclass, jlong contextPtr, jlong mtkViewPtr, jint surfaceOrigin, jint sampleCount, jint colorType, jlong colorSpacePtr, jobject surfacePropsObj) {
GrDirectContext* context = reinterpret_cast<GrDirectContext*>(static_cast<uintptr_t>(contextPtr));
GrMTLHandle* mtkView = reinterpret_cast<GrMTLHandle*>(static_cast<uintptr_t>(mtkViewPtr));
GrSurfaceOrigin grSurfaceOrigin = static_cast<GrSurfaceOrigin>(surfaceOrigin);
SkColorType skColorType = static_cast<SkColorType>(colorType);
sk_sp<SkColorSpace> colorSpace = sk_ref_sp<SkColorSpace>(reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr)));
std::unique_ptr<SkSurfaceProps> surfaceProps = skija::SurfaceProps::toSkSurfaceProps(env, surfacePropsObj);
sk_sp<SkSurface> surface = SkSurface::MakeFromMTKView(
static_cast<GrRecordingContext*>(context),
mtkView,
grSurfaceOrigin,
sampleCount,
skColorType,
colorSpace,
surfaceProps.get());
return reinterpret_cast<jlong>(surface.release());
}
#endif
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Surface__1nMakeRenderTarget
(JNIEnv* env, jclass jclass, jlong contextPtr, jboolean budgeted,
jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr,
jint sampleCount, jint surfaceOrigin,
jobject surfacePropsObj,
jboolean shouldCreateWithMips)
{
GrDirectContext* context = reinterpret_cast<GrDirectContext*>(static_cast<uintptr_t>(contextPtr));
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr));
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
static_cast<SkAlphaType>(alphaType),
sk_ref_sp<SkColorSpace>(colorSpace));
std::unique_ptr<SkSurfaceProps> surfaceProps = skija::SurfaceProps::toSkSurfaceProps(env, surfacePropsObj);
sk_sp<SkSurface> instance = SkSurface::MakeRenderTarget(
context, budgeted ? SkBudgeted::kYes : SkBudgeted::kNo,
imageInfo,
sampleCount, static_cast<GrSurfaceOrigin>(surfaceOrigin),
surfaceProps.get(),
shouldCreateWithMips);
return reinterpret_cast<jlong>(instance.release());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Surface__1nMakeNull
(JNIEnv* env, jclass jclass, jint width, jint height) {
sk_sp<SkSurface> instance = SkSurface::MakeNull(width, height);
return reinterpret_cast<jlong>(instance.release());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Surface__1nGetCanvas
(JNIEnv* env, jclass jclass, jlong ptr) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
return reinterpret_cast<jlong>(surface->getCanvas());
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Surface__1nGetWidth
(JNIEnv* env, jclass jclass, jlong ptr) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
return surface->width();
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Surface__1nGetHeight
(JNIEnv* env, jclass jclass, jlong ptr) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
return surface->height();
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Surface__1nMakeImageSnapshot
(JNIEnv* env, jclass jclass, jlong ptr) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
return reinterpret_cast<jlong>(surface->makeImageSnapshot().release());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Surface__1nMakeImageSnapshotR
(JNIEnv* env, jclass jclass, jlong ptr, jint left, jint top, jint right, jint bottom) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
return reinterpret_cast<jlong>(surface->makeImageSnapshot({left, top, right, bottom}).release());
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_Surface__1nGenerationId
(JNIEnv* env, jclass jclass, jlong ptr) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
return surface->generationID();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Surface__1nReadPixelsToPixmap
(JNIEnv* env, jclass jclass, jlong ptr, jlong pixmapPtr, jint srcX, jint srcY) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
SkPixmap* pixmap = reinterpret_cast<SkPixmap*>(static_cast<uintptr_t>(pixmapPtr));
return surface->readPixels(*pixmap, srcX, srcY);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Surface__1nReadPixels
(JNIEnv* env, jclass jclass, jlong ptr, jlong bitmapPtr, jint srcX, jint srcY) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(bitmapPtr));
return surface->readPixels(*bitmap, srcX, srcY);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Surface__1nWritePixelsFromPixmap
(JNIEnv* env, jclass jclass, jlong ptr, jlong pixmapPtr, jint x, jint y) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
SkPixmap* pixmap = reinterpret_cast<SkPixmap*>(static_cast<uintptr_t>(pixmapPtr));
surface->writePixels(*pixmap, x, y);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Surface__1nWritePixels
(JNIEnv* env, jclass jclass, jlong ptr, jlong bitmapPtr, jint x, jint y) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(bitmapPtr));
surface->writePixels(*bitmap, x, y);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Surface__1nFlushAndSubmit
(JNIEnv* env, jclass jclass, jlong ptr, jboolean syncCpu) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
surface->flushAndSubmit(syncCpu);
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Surface__1nFlush
(JNIEnv* env, jclass jclass, jlong ptr) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
surface->flush();
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Surface__1nUnique
(JNIEnv* env, jclass jclass, jlong ptr) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
return surface->unique();
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_Surface__1nGetImageInfo
(JNIEnv* env, jclass jclass, jlong ptr) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
const SkImageInfo& info = surface->imageInfo();
return env->NewObject(skija::ImageInfo::cls, skija::ImageInfo::ctor,
info.width(),
info.height(),
static_cast<jint>(info.colorType()),
static_cast<jint>(info.alphaType()),
reinterpret_cast<jlong>(info.refColorSpace().release()));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Surface__1nMakeSurface
(JNIEnv* env, jclass jclass, jlong ptr, jint width, jint height) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
sk_sp<SkSurface> newSurface = surface->makeSurface(width, height);
return reinterpret_cast<jlong>(newSurface.release());
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Surface__1nMakeSurfaceI
(JNIEnv* env, jclass jclass, jlong ptr, jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr));
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
static_cast<SkAlphaType>(alphaType),
sk_ref_sp<SkColorSpace>(colorSpace));
sk_sp<SkSurface> newSurface = surface->makeSurface(imageInfo);
return reinterpret_cast<jlong>(newSurface.release());
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Surface__1nDraw
(JNIEnv* env, jclass jclass, jlong ptr, jlong canvasPtr, jfloat x, jfloat y, jlong paintPtr) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
surface->draw(canvas, x, y, paint);
}
extern "C" JNIEXPORT jboolean JNICALL Java_org_jetbrains_skija_Surface__1nPeekPixels
(JNIEnv *env, jclass jclass, jlong ptr, jlong dstPixmapPtr) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
SkPixmap* pixmap = reinterpret_cast<SkPixmap*>(static_cast<uintptr_t>(dstPixmapPtr));
return static_cast<jboolean>(surface->peekPixels(pixmap));
}
extern "C" JNIEXPORT void JNICALL Java_org_jetbrains_skija_Surface__1nNotifyContentWillChange
(JNIEnv* env, jclass jclass, jlong ptr, jint mode) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
surface->notifyContentWillChange(static_cast<SkSurface::ContentChangeMode>(mode));
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_Surface__1nGetRecordingContext
(JNIEnv* env, jclass jclass, jlong ptr) {
SkSurface* surface = reinterpret_cast<SkSurface*>(static_cast<uintptr_t>(ptr));
return reinterpret_cast<jlong>(surface->recordingContext());
}
\ No newline at end of file
skiko/src/jvmMain/cpp/common/TextBlob.cc 0 → 100644
View file @ 228274af
#include <cstring>
#include <iostream>
#include <jni.h>
#include "SkData.h"
#include "SkSerialProcs.h"
#include "SkTextBlob.h"
#include "interop.hh"
static void unrefTextBlob(SkTextBlob* ptr) {
ptr->unref();
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_TextBlob__1nGetFinalizer
(JNIEnv* env, jclass jclass) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&unrefTextBlob));
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_TextBlob__1nBounds
(JNIEnv* env, jclass jclass, jlong ptr) {
SkTextBlob* instance = reinterpret_cast<SkTextBlob*>(static_cast<uintptr_t>(ptr));
SkRect bounds = instance->bounds();
return skija::Rect::fromSkRect(env, instance->bounds());
}
extern "C" JNIEXPORT jint JNICALL Java_org_jetbrains_skija_TextBlob__1nGetUniqueId
(JNIEnv* env, jclass jclass, jlong ptr) {
SkTextBlob* instance = reinterpret_cast<SkTextBlob*>(static_cast<uintptr_t>(ptr));
return instance->uniqueID();
}
extern "C" JNIEXPORT jfloatArray JNICALL Java_org_jetbrains_skija_TextBlob__1nGetIntercepts
(JNIEnv* env, jclass jclass, jlong ptr, jfloat lower, jfloat upper, jlong paintPtr) {
SkTextBlob* instance = reinterpret_cast<SkTextBlob*>(static_cast<uintptr_t>(ptr));
std::vector<float> bounds {lower, upper};
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
int len = instance->getIntercepts(bounds.data(), nullptr, paint);
std::vector<float> intervals(len);
instance->getIntercepts(bounds.data(), intervals.data(), paint);
return javaFloatArray(env, intervals);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_TextBlob__1nMakeFromPosH
(JNIEnv* env, jclass jclass, jshortArray glyphsArr, jfloatArray xposArr, jfloat ypos, jlong fontPtr) {
jsize len = env->GetArrayLength(glyphsArr);
jshort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
jfloat* xpos = env->GetFloatArrayElements(xposArr, nullptr);
SkFont* font = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(fontPtr));
SkTextBlob* instance = SkTextBlob::MakeFromPosTextH(glyphs, len * sizeof(jshort), xpos, ypos, *font, SkTextEncoding::kGlyphID).release();
env->ReleaseShortArrayElements(glyphsArr, glyphs, 0);
env->ReleaseFloatArrayElements(xposArr, xpos, 0);
return reinterpret_cast<jlong>(instance);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_TextBlob__1nMakeFromPos
(JNIEnv* env, jclass jclass, jshortArray glyphsArr, jfloatArray posArr, jlong fontPtr ) {
jsize len = env->GetArrayLength(glyphsArr);
jshort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
jfloat* pos = env->GetFloatArrayElements(posArr, nullptr);
SkFont* font = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(fontPtr));
SkTextBlob* instance = SkTextBlob::MakeFromPosText(glyphs, len * sizeof(jshort), reinterpret_cast<SkPoint*>(pos), *font, SkTextEncoding::kGlyphID).release();
env->ReleaseShortArrayElements(glyphsArr, glyphs, 0);
env->ReleaseFloatArrayElements(posArr, pos, 0);
return reinterpret_cast<jlong>(instance);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_TextBlob__1nMakeFromRSXform
(JNIEnv* env, jclass jclass, jshortArray glyphsArr, jfloatArray xformArr, jlong fontPtr ) {
jsize len = env->GetArrayLength(glyphsArr);
jshort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
jfloat* xform = env->GetFloatArrayElements(xformArr, nullptr);
SkFont* font = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(fontPtr));
SkTextBlob* instance = SkTextBlob::MakeFromRSXform(glyphs, len * sizeof(jshort), reinterpret_cast<SkRSXform*>(xform), *font, SkTextEncoding::kGlyphID).release();
env->ReleaseShortArrayElements(glyphsArr, glyphs, 0);
env->ReleaseFloatArrayElements(xformArr, xform, 0);
return reinterpret_cast<jlong>(instance);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_TextBlob__1nSerializeToData
(JNIEnv* env, jclass jclass, jlong ptr) {
SkTextBlob* instance = reinterpret_cast<SkTextBlob*>(static_cast<uintptr_t>(ptr));
SkData* data = instance->serialize({}).release();
return reinterpret_cast<jlong>(data);
}
extern "C" JNIEXPORT jlong JNICALL Java_org_jetbrains_skija_TextBlob__1nMakeFromData
(JNIEnv* env, jclass jclass, jlong dataPtr) {
SkData* data = reinterpret_cast<SkData*>(static_cast<uintptr_t>(dataPtr));
SkTextBlob* instance = SkTextBlob::Deserialize(data->data(), data->size(), {}).release();
return reinterpret_cast<jlong>(instance);
}
// Must match SkTextBlobPriv.h
//
// Extended Textblob runs have more data after the Pos[] array:
//
// -------------------------------------------------------------------------
// ... | RunRecord | Glyphs[] | Pos[] | TextSize | Clusters[] | Text[] | ...
// -------------------------------------------------------------------------
class RunRecordClone {
public:
SkFont fFont;
uint32_t fCount;
SkPoint fOffset;
uint32_t fFlags;
uint16_t* glyphBuffer() const {
// Glyphs are stored immediately following the record.
return reinterpret_cast<uint16_t*>(const_cast<RunRecordClone*>(this) + 1);
}
SkScalar* posBuffer() const {
// Position scalars follow the (aligned) glyph buffer.
return reinterpret_cast<SkScalar*>(reinterpret_cast<uint8_t*>(this->glyphBuffer()) +
SkAlign4(fCount * sizeof(uint16_t)));
}
uint32_t* textSizePtr() const {
// textSize follows the position buffer.
return (uint32_t*)(&this->posBuffer()[fCount * ScalarsPerGlyph(positioning())]);
}
uint32_t textSize() const {
return isExtended() ? *this->textSizePtr() : 0;
}
uint32_t* clusterBuffer() const {
// clusters follow the textSize.
return isExtended() ? 1 + this->textSizePtr() : nullptr;
}
char* textBuffer() const {
return isExtended()
? reinterpret_cast<char*>(this->clusterBuffer() + fCount)
: nullptr;
}
uint8_t positioning() const {
return fFlags & 0x3; // kPositioning_Mask
}
bool isExtended() const {
return fFlags & 0x8; // kExtended_Flag
}
static unsigned ScalarsPerGlyph(uint8_t pos) {
const uint8_t gScalarsPerPositioning[] = {
0, // kDefault_Positioning
1, // kHorizontal_Positioning
2, // kFull_Positioning
4, // kRSXform_Positioning
};
return gScalarsPerPositioning[pos];
}
};
extern "C" JNIEXPORT jshortArray JNICALL Java_org_jetbrains_skija_TextBlob__1nGetGlyphs
(JNIEnv* env, jclass jclass, jlong ptr) {
SkTextBlob* instance = reinterpret_cast<SkTextBlob*>(static_cast<uintptr_t>(ptr));
SkTextBlob::Iter iter(*instance);
SkTextBlob::Iter::Run run;
std::vector<jshort> glyphs;
size_t stored = 0;
while (iter.next(&run)) {
glyphs.resize(stored + run.fGlyphCount);
memcpy(&glyphs[stored], run.fGlyphIndices, run.fGlyphCount * sizeof(uint16_t));
stored += run.fGlyphCount;
}
return javaShortArray(env, glyphs);
}
extern "C" JNIEXPORT jfloatArray JNICALL Java_org_jetbrains_skija_TextBlob__1nGetPositions
(JNIEnv* env, jclass jclass, jlong ptr) {
SkTextBlob* instance = reinterpret_cast<SkTextBlob*>(static_cast<uintptr_t>(ptr));
SkTextBlob::Iter iter(*instance);
SkTextBlob::Iter::Run run;
std::vector<jfloat> positions;
size_t stored = 0;
while (iter.next(&run)) {
// run.fGlyphIndices points directly to runRecord.glyphBuffer(), which comes directly after RunRecord itself
auto runRecord = reinterpret_cast<const RunRecordClone*>(run.fGlyphIndices) - 1;
unsigned scalarsPerGlyph = RunRecordClone::ScalarsPerGlyph(runRecord->positioning());
positions.resize(stored + run.fGlyphCount * scalarsPerGlyph);
memcpy(&positions[stored], runRecord->posBuffer(), run.fGlyphCount * scalarsPerGlyph * sizeof(SkScalar));
stored += run.fGlyphCount * scalarsPerGlyph;
}
return javaFloatArray(env, positions);
}
extern "C" JNIEXPORT jintArray JNICALL Java_org_jetbrains_skija_TextBlob__1nGetClusters
(JNIEnv* env, jclass jclass, jlong ptr) {
SkTextBlob* instance = reinterpret_cast<SkTextBlob*>(static_cast<uintptr_t>(ptr));
SkTextBlob::Iter iter(*instance);
SkTextBlob::Iter::Run run;
std::vector<jint> clusters;
size_t stored = 0;
// uint32_t cluster8 = 0;
uint32_t runStart16 = 0;
while (iter.next(&run)) {
// run.fGlyphIndices points directly to runRecord.glyphBuffer(), which comes directly after RunRecord itself
auto runRecord = reinterpret_cast<const RunRecordClone*>(run.fGlyphIndices) - 1;
if (!runRecord->isExtended())
return nullptr;
skija::UtfIndicesConverter conv(runRecord->textBuffer(), runRecord->textSize());
clusters.resize(stored + run.fGlyphCount);
uint32_t* clusterBuffer = runRecord->clusterBuffer();
for (int i = 0; i < run.fGlyphCount; ++i)
clusters[stored + i] = runStart16 + conv.from8To16(clusterBuffer[i]);
runStart16 += conv.from8To16(runRecord->textSize());
// memcpy(&clusters[stored], runRecord->clusterBuffer(), run.fGlyphCount * sizeof(uint32_t));
stored += run.fGlyphCount;
}
return javaIntArray(env, clusters);
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_TextBlob__1nGetTightBounds
(JNIEnv* env, jclass jclass, jlong ptr) {
SkTextBlob* instance = reinterpret_cast<SkTextBlob*>(static_cast<uintptr_t>(ptr));
SkTextBlob::Iter iter(*instance);
SkTextBlob::Iter::Run run;
auto bounds = SkRect::MakeEmpty();
SkRect tmpBounds;
while (iter.next(&run)) {
// run.fGlyphIndices points directly to runRecord.glyphBuffer(), which comes directly after RunRecord itself
auto runRecord = reinterpret_cast<const RunRecordClone*>(run.fGlyphIndices) - 1;
if (runRecord->positioning() != 2) // kFull_Positioning
return nullptr;
runRecord->fFont.measureText(runRecord->glyphBuffer(), run.fGlyphCount * sizeof(uint16_t), SkTextEncoding::kGlyphID, &tmpBounds, nullptr);
SkScalar* posBuffer = runRecord->posBuffer();
tmpBounds.offset(posBuffer[0], posBuffer[1]);
bounds.join(tmpBounds);
}
return skija::Rect::fromSkRect(env, bounds);
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_TextBlob__1nGetBlockBounds
(JNIEnv* env, jclass jclass, jlong ptr) {
SkTextBlob* instance = reinterpret_cast<SkTextBlob*>(static_cast<uintptr_t>(ptr));
SkTextBlob::Iter iter(*instance);
SkTextBlob::Iter::Run run;
auto bounds = SkRect::MakeEmpty();
SkFontMetrics metrics;
while (iter.next(&run)) {
// run.fGlyphIndices points directly to runRecord.glyphBuffer(), which comes directly after RunRecord itself
auto runRecord = reinterpret_cast<const RunRecordClone*>(run.fGlyphIndices) - 1;
if (runRecord->positioning() != 2) // kFull_Positioning
return nullptr;
SkScalar* posBuffer = runRecord->posBuffer();
const SkFont& font = runRecord->fFont;
font.getMetrics(&metrics);
SkScalar lastLeft = posBuffer[(run.fGlyphCount - 1) * 2];
SkScalar lastWidth;
if (run.fGlyphCount > 1 && SkScalarNearlyEqual(posBuffer[(run.fGlyphCount - 2) * 2], lastLeft))
lastWidth = 0;
else
font.getWidths(&run.fGlyphIndices[run.fGlyphCount - 1], 1, &lastWidth);
auto runBounds = SkRect::MakeLTRB(posBuffer[0], posBuffer[1] + metrics.fAscent, lastLeft + lastWidth, posBuffer[1] + metrics.fDescent);
bounds.join(runBounds);
}
return skija::Rect::fromSkRect(env, bounds);
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_TextBlob__1nGetFirstBaseline
(JNIEnv* env, jclass jclass, jlong ptr) {
SkTextBlob* instance = reinterpret_cast<SkTextBlob*>(static_cast<uintptr_t>(ptr));
SkTextBlob::Iter iter(*instance);
SkTextBlob::Iter::Run run;
while (iter.next(&run)) {
// run.fGlyphIndices points directly to runRecord.glyphBuffer(), which comes directly after RunRecord itself
auto runRecord = reinterpret_cast<const RunRecordClone*>(run.fGlyphIndices) - 1;
if (runRecord->positioning() != 2) // kFull_Positioning
return nullptr;
return javaFloat(env, runRecord->posBuffer()[1]);
}
return nullptr;
}
extern "C" JNIEXPORT jobject JNICALL Java_org_jetbrains_skija_TextBlob__1nGetLastBaseline
(JNIEnv* env, jclass jclass, jlong ptr) {
SkTextBlob* instance = reinterpret_cast<SkTextBlob*>(static_cast<uintptr_t>(ptr));
SkTextBlob::Iter iter(*instance);
SkTextBlob::Iter::Run run;
SkScalar baseline = 0;
while (iter.next(&run)) {
// run.fGlyphIndices points directly to runRecord.glyphBuffer(), which comes directly after RunRecord itself
auto runRecord = reinterpret_cast<const RunRecordClone*>(run.fGlyphIndices) - 1;
if (runRecord->positioning() != 2) // kFull_Positioning
return nullptr;
baseline = std::max(baseline, runRecord->posBuffer()[1]);
}
return javaFloat(env, baseline);
}
skiko/src/jvmMain/cpp/common/TextBlobBuilder.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/TextLine.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/TextLine.hh 0 → 100644
View file @ 228274af
#include "SkCanvas.h"
#include "SkFont.h"
#include "SkPoint.h"
#include "SkRefCnt.h"
#include "SkTextBlob.h"
class TextLine: public SkNVRefCnt<TextLine> {
public:
struct Run {
SkFont fFont;
uint8_t fBidiLevel;
SkScalar fPosition;
SkScalar fWidth;
size_t fGlyphCount;
const uint16_t* fGlyphs;
const SkPoint* fPos;
std::vector<SkScalar> fBreakPositions;
std::vector<SkScalar> fBreakOffsets;
Run(const SkFont& font,
uint8_t bidiLevel,
SkScalar position,
SkScalar width,
size_t glyphCount,
SkPoint* pos):
fFont(font),
fBidiLevel(bidiLevel),
fPosition(position),
fWidth(width),
fGlyphCount(glyphCount),
fGlyphs(nullptr),
fPos(pos)
{
}
};
size_t fGlyphCount = 0;
SkScalar fAscent = 0;
SkScalar fCapHeight = 0;
SkScalar fXHeight = 0;
SkScalar fDescent = 0;
SkScalar fLeading = 0;
SkScalar fWidth = 0;
std::vector<Run> fRuns;
sk_sp<SkTextBlob> fBlob;
TextLine() {
}
TextLine(const SkFont& font) {
SkFontMetrics metrics;
font.getMetrics(&metrics);
fAscent = metrics.fAscent;
fCapHeight = metrics.fCapHeight;
fXHeight = metrics.fXHeight;
fDescent = metrics.fDescent;
fLeading = metrics.fLeading;
}
};
\ No newline at end of file
skiko/src/jvmMain/cpp/common/Typeface.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/U16String.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/impl/BufferUtil.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/impl/Library.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/impl/Managed.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/impl/RefCnt.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/interop.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/interop.hh 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/paragraph/FontCollection.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/paragraph/Paragraph.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/paragraph/ParagraphBuilder.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/paragraph/ParagraphCache.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/paragraph/ParagraphStyle.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/paragraph/StrutStyle.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/paragraph/TextStyle.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/paragraph/TypefaceFontProvider.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/paragraph/interop.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/paragraph/interop.hh 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/shaper/FontMgrRunIterator.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/shaper/FontRunIterator.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/shaper/FontRunIterator.hh 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/shaper/HbIcuScriptRunIterator.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/shaper/IcuBidiRunIterator.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/shaper/ManagedRunIterator.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/shaper/Shaper.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/shaper/TextLineRunHandler.hh 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/shaper/interop.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/shaper/interop.hh 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/skottie/Animation.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/skottie/AnimationBuilder.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/skottie/Logger.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/skottie/interop.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/skottie/interop.hh 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/svg/SVGCanvas.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/svg/SVGDOM.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/svg/SVGNode.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/svg/SVGSVG.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/svg/interop.cc 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/cpp/common/svg/interop.hh 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Bitmap.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/BlendMode.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/BreakIterator.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Canvas.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/ClipMode.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Codec.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Color.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Color4f.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/ColorAlphaType.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/ColorChannel.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/ColorFilter.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/ColorInfo.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/ColorMatrix.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/ColorSpace.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/ColorType.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/CubicResampler.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Data.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/DirectContext.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Drawable.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/EncodedOrigin.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FilterBlurMode.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FilterMipmap.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FilterMode.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FilterQuality.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FilterTileMode.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Font.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FontEdging.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FontExtents.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FontFamilyName.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FontFeature.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FontHinting.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FontMetrics.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FontMgr.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FontSlant.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FontStyle.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FontStyleSet.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FontVariation.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FontWeight.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FontWidth.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/FourByteTag.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/GLBackendState.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/GradientStyle.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/IHasImageInfo.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/IPoint.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/IRange.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/IRect.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Image.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/ImageFilter.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/ImageInfo.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/InversionMode.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/ManagedString.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/MaskFilter.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Matrix33.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Matrix44.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/MipmapMode.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/OutputWStream.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Paint.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/PaintMode.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/PaintStrokeCap.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Path.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/PathDirection.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/PathEffect.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/PathEllipseArc.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/PathFillMode.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/PathMeasure.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/PathOp.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/PathSegment.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/PathVerb.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Picture.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/PixelGeometry.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/PixelRef.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Pixmap.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Point.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Point3.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/RRect.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/RSXform.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Rect.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Region.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/RuntimeEffect.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/SamplingMode.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Shader.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/ShadowUtils.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Surface.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/SurfaceOrigin.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/SurfaceProps.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/TextBlob.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/TextLine.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/Typeface.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/U16String.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/WStream.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/impl/Log.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/impl/Managed.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/impl/Native.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/impl/RefCnt.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/impl/Stats.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/shaper/BidiRun.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/shaper/FontRun.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/shaper/RunInfo.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/shaper/Shaper.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/skottie/Logger.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/svg/SVGCanvas.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/svg/SVGDOM.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/svg/SVGLength.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/svg/SVGNode.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/svg/SVGSVG.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
skiko/src/jvmMain/kotlin/org/jetbrains/skija/svg/SVGTag.kt 0 → 100644
View file @ 228274af
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment