Skip to content

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

Common cpp (WIP) (#193)

parent d6008a3a
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 11579 additions and 2369 deletions
samples/SkiaJsSample/src/jsMain/resources/index.html
View file @ 4b6f133a
......@@ -3,8 +3,11 @@
<head>
<meta charset="UTF-8">
<title>skiko for web demo</title>
<script src="skiko.js"> </script>
<script>
// Temporary, to debug loading issues.
initRuntime();
</script>
<script src="SkiaJsSample.js"> </script>
</head>
<body>
......
skiko/build.gradle.kts
View file @ 4b6f133a
......@@ -202,8 +202,7 @@ tasks.withType(JavaCompile::class.java).configureEach {
this.getOptions().compilerArgs.addAll(listOf("-source", "11", "-target", "11"))
}
val skiaPreprocessorFlags: Array<String> get() {
val skiaDir = skiaDir.get().absolutePath
fun skiaPreprocessorFlags(skiaDir: String): Array<String> {
return listOf(
"-I$skiaDir",
"-I$skiaDir/include",
......@@ -251,11 +250,9 @@ tasks.withType(CppCompile::class.java).configureEach {
dependsOn(skiaDir)
val skiaDir = skiaDir.get().absolutePath
compilerArgs.addAll(
listOf("-I$jdkHome/include") + skiaPreprocessorFlags
listOf("-I$jdkHome/include") + skiaPreprocessorFlags(skiaDir)
)
val includeDir = "$projectDir/src/jvmMain/cpp/include"
val commonIncludeDir = "$projectDir/src/commonMain/cpp/headers"
compilerArgs.add("-I$projectDir/src/jvmMain/cpp/include")
when (targetOs) {
OS.MacOS -> {
compilerArgs.addAll(
......@@ -263,8 +260,6 @@ tasks.withType(CppCompile::class.java).configureEach {
"-fvisibility=hidden",
"-fvisibility-inlines-hidden",
"-I$jdkHome/include/darwin",
"-I$includeDir",
"-I$commonIncludeDir",
"-DSK_SHAPER_CORETEXT_AVAILABLE",
"-DSK_BUILD_FOR_MAC",
"-DSK_METAL",
......@@ -281,8 +276,6 @@ tasks.withType(CppCompile::class.java).configureEach {
"-fvisibility=hidden",
"-fvisibility-inlines-hidden",
"-I$jdkHome/include/linux",
"-I$includeDir",
"-I$commonIncludeDir",
"-DSK_BUILD_FOR_LINUX",
"-D_GLIBCXX_USE_CXX11_ABI=0",
*buildType.clangFlags
......@@ -293,8 +286,6 @@ tasks.withType(CppCompile::class.java).configureEach {
compilerArgs.addAll(
listOf(
"-I$jdkHome/include/win32",
"-I$includeDir",
"-I$commonIncludeDir",
"-DSK_BUILD_FOR_WIN",
"-D_CRT_SECURE_NO_WARNINGS",
"-D_HAS_EXCEPTIONS=0",
......@@ -345,13 +336,21 @@ project.tasks.register<Exec>("objcCompile") {
outputs.files(outs)
}
project.tasks.register<Exec>("wasmCompile") {
fun List<String>.findAllFiles(suffix: String): List<String> = this
.map { File(it) }
.flatMap { it.walk().toList() }
.map { it.absolutePath }
.filter { it.endsWith(suffix) }
val wasmCompileTask = project.tasks.register<Exec>("wasmCompile") {
dependsOn(skiaWasmDir)
val skiaDir = skiaWasmDir.get().absolutePath
val inputDir = "$projectDir/src/jsMain/cpp"
val outDir = "$buildDir/wasm"
val names = File(inputDir).listFiles()!!.filter { it.name.endsWith(".cc") }.map { it.name.removeSuffix(".cc") }
val srcs = names.map { "$inputDir/$it.cc" }.toTypedArray()
val srcs = listOf(
"$projectDir/src/jsMain/cpp",
"$projectDir/src/commonMain/cpp"
).findAllFiles(".cc").toTypedArray()
val outJs = "$outDir/skiko.js"
val outWasm = "$outDir/skiko.wasm"
workingDir = File(outDir)
......@@ -359,11 +358,8 @@ project.tasks.register<Exec>("wasmCompile") {
commandLine = listOf(
"emcc",
*Arch.Wasm.clangFlags,
"-I$skiaDir",
"-I$skiaDir/include",
"-I$skiaDir/include/core",
"-I$skiaDir/include/effects",
"-I$skiaDir/include/gpu",
"-I$projectDir/src/commonMain/cpp",
*skiaPreprocessorFlags(skiaDir),
"-o", outJs,
*srcs
)
......@@ -385,21 +381,26 @@ project.tasks.register<Exec>("wasmCompile") {
outputs.files(outJs, outWasm)
}
fun List<String>.findAllFiles(suffix: String): List<String> = this
.map { File(it) }
.flatMap { it.walk().toList() }
.map { it.absolutePath }
.filter { it.endsWith(suffix) }
val wasmJsPatcher = project.tasks.register<Exec>("wasmJsPatcher") {
dependsOn(wasmCompileTask)
val inJs = wasmCompileTask.get().outputs.files.single { it.name.endsWith(".js") }
val outDir = "$buildDir/wasm"
val outJs = "$outDir/skiko_processed.js"
commandLine = listOf(
"bash", "-c",
"sed 's/_org_jetbrains_/org_jetbrains_/g' ${inJs.absolutePath} > ${outJs}"
)
inputs.files(inJs)
outputs.files(outJs)
}
// Very hacky way to compile native bridges and add the
// resulting object files into the final native klib.
project.tasks.register<Exec>("nativeBridgesCompile") {
dependsOn(skiaDir)
val inputDirs = listOf(
"$projectDir/src/nativeMain/cpp/generated",
"$projectDir/src/nativeMain/cpp/common",
"$projectDir/src/commonMain/cpp/common"
"$projectDir/src/commonMain/cpp"
)
val outDir = "$buildDir/nativeBridges/obj/$target"
val srcs = inputDirs
......@@ -422,9 +423,8 @@ project.tasks.register<Exec>("nativeBridgesCompile") {
"-DSK_SHAPER_CORETEXT_AVAILABLE",
"-DSK_BUILD_FOR_MAC",
"-DSK_METAL",
"-I$projectDir/src/nativeMain/cpp/include",
"-I$projectDir/src/commonMain/cpp/headers",
*skiaPreprocessorFlags,
"-I$projectDir/src/commonMain/cpp",
*skiaPreprocessorFlags(skiaDir.get().absolutePath),
*srcs
)
file(outDir).mkdirs()
......@@ -579,7 +579,6 @@ tasks.withType(LinkSharedLibrary::class.java).configureEach {
extensions.configure<CppLibrary> {
source.from(
fileTree("$projectDir/src/commonMain/cpp/common"),
fileTree("$projectDir/src/jvmMain/cpp/common"),
fileTree("$projectDir/src/jvmMain/cpp/${targetOs.id}")
)
......@@ -673,7 +672,9 @@ val skikoJvmRuntimeJar by project.tasks.registering(Jar::class) {
val skikoWasmJar by project.tasks.registering(Jar::class) {
// We produce jar that contains .js of wrapper/bindings and .wasm with Skia + bindings.
from(project.tasks.named("wasmCompile").get().outputs)
from(wasmCompileTask.get().outputs.files.single { it.name.endsWith(".wasm")})
from(wasmJsPatcher.get().outputs)
rename { if (it == "skiko_processed.js") "skiko.js" else it }
archiveBaseName.set("skiko-wasm")
doLast {
println("Wasm and JS at ${outputs.files.files.single()}")
......
skiko/buildSrc/src/main/kotlin/properties.kt
View file @ 4b6f133a
......@@ -15,7 +15,7 @@ enum class OS(val id: String, val clangFlags: Array<String>) {
enum class Arch(val id: String, val clangFlags: Array<String>) {
X64("x64", arrayOf("-arch", "x86_64")),
Arm64("arm64", arrayOf("-arch", "arm64")),
Wasm("wasm", arrayOf("-std=c++17", "--bind"))
Wasm("wasm", arrayOf("-std=c++17", "--bind", "-DSKIKO_WASM"))
}
enum class SkiaBuildType(
......
skiko/src/commonMain/cpp/headers/common.h → skiko/src/commonMain/cpp/common.h
View file @ 4b6f133a
#ifndef SKIKO_COMMON_H
#define SKIKO_COMMON_H
// Note that this file is only common between Wasm and Native targets, JVM uses different headers.
#include <stdexcept>
#include "SkCodec.h"
#include "SkFontMetrics.h"
#include "SkFontStyle.h"
......@@ -15,18 +19,18 @@
#include "SkShaper.h"
#include "SkString.h"
#include "SkSurfaceProps.h"
#include <stdexcept>
#include "types.h"
jlong packTwoInts(int32_t a, int32_t b);
KLong packTwoInts(KInt a, KInt b);
jlong packIPoint(SkIPoint p);
KLong packIPoint(SkIPoint p);
jlong packISize(SkISize p);
KLong packISize(SkISize p);
namespace skija {
namespace SamplingMode {
SkSamplingOptions unpack(jlong val);
SkSamplingOptions unpack(KLong val);
}
class UtfIndicesConverter {
......@@ -42,17 +46,23 @@ namespace skija {
size_t from16To8(uint32_t i16);
uint32_t from8To16(size_t i8);
};
namespace RRect {
SkRRect toSkRRect(KFloat left, KFloat top, KFloat right, KFloat bottom, KFloat* jradii, KInt size);
}
}
std::unique_ptr<SkMatrix> skMatrix(KFloat* matrixArray);
std::unique_ptr<SkM44> skM44(KFloat* matrixArray);
template <typename T>
inline T jlongToPtr(jlong ptr) {
return reinterpret_cast<T>(static_cast<uintptr_t>(ptr));
inline T interopToPtr(KNativePointer ptr) {
return reinterpret_cast<T>(ptr);
}
template <typename T>
jlong ptrToJlong(T* ptr) {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(ptr));
KNativePointer ptrToInterop(T* ptr) {
return ptr;
}
#ifdef __clang__
......@@ -62,5 +72,12 @@ void TODO(const char*);
void TODO(const char*);
#endif
#ifdef SKIKO_WASM
#include <emscripten.h>
#define SKIKO_EXPORT EMSCRIPTEN_KEEPALIVE extern "C"
#else
#define SKIKO_EXPORT extern "C"
#endif
#endif /* SKIKO_COMMON_H */
skiko/src/commonMain/cpp/common/common_interop.cc → skiko/src/commonMain/cpp/common_interop.cc
View file @ 4b6f133a
......@@ -2,22 +2,22 @@
#include "src/utils/SkUTF.h"
#include <stdio.h>
jlong packTwoInts(int32_t a, int32_t b) {
KLong packTwoInts(int32_t a, int32_t b) {
return (uint64_t (a) << 32) | b;
}
jlong packIPoint(SkIPoint p) {
KLong packIPoint(SkIPoint p) {
return packTwoInts(p.fX, p.fY);
}
jlong packISize(SkISize p) {
KLong packISize(SkISize p) {
return packTwoInts(p.fWidth, p.fHeight);
}
namespace skija {
namespace SamplingMode {
SkSamplingOptions unpack(jlong val) {
SkSamplingOptions unpack(KLong val) {
if (0x8000000000000000 & val) {
val = val & 0x7FFFFFFFFFFFFFFF;
float* ptr = reinterpret_cast<float*>(&val);
......@@ -80,3 +80,51 @@ void TODO(const char* message) {
abort();
}
std::unique_ptr<SkMatrix> skMatrix(KFloat* matrixArray) {
if (matrixArray == nullptr)
return std::unique_ptr<SkMatrix>(nullptr);
else {
KFloat* m = matrixArray;
SkMatrix* ptr = new SkMatrix();
ptr->setAll(m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8]);
return std::unique_ptr<SkMatrix>(ptr);
}
}
std::unique_ptr<SkM44> skM44(KFloat* matrixArray) {
if (matrixArray == nullptr)
return std::unique_ptr<SkM44>(nullptr);
else {
KFloat* m = matrixArray;
SkM44* ptr = new SkM44(m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8], m[9], m[10], m[11], m[12], m[13], m[14], m[15]);
return std::unique_ptr<SkM44>(ptr);
}
}
namespace skija {
namespace RRect {
SkRRect toSkRRect(KFloat left, KFloat top, KFloat right, KFloat bottom, KFloat* radii, KInt radiiSize) {
SkRect rect {left, top, right, bottom};
SkRRect rrect = SkRRect::MakeEmpty();
switch (radiiSize) {
case 1:
rrect.setRectXY(rect, radii[0], radii[0]);
break;
case 2:
rrect.setRectXY(rect, radii[0], radii[1]);
break;
case 4: {
SkVector vradii[4] = {{radii[0], radii[0]}, {radii[1], radii[1]}, {radii[2], radii[2]}, {radii[3], radii[3]}};
rrect.setRectRadii(rect, vradii);
break;
}
case 8: {
SkVector vradii[4] = {{radii[0], radii[1]}, {radii[2], radii[3]}, {radii[4], radii[5]}, {radii[6], radii[7]}};
rrect.setRectRadii(rect, vradii);
break;
}
}
return rrect;
}
}
}
skiko/src/nativeMain/cpp/common/BackendRenderTarget.cc → skiko/src/commonMain/cpp/generated/BackendRenderTarget.cc
View file @ 4b6f133a
......@@ -6,26 +6,25 @@
static void deleteBackendRenderTarget(GrBackendRenderTarget* rt) {
delete rt;
}
extern "C" jlong BackendRenderTarget_nGetFinalizer() {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteBackendRenderTarget));
SKIKO_EXPORT KNativePointer BackendRenderTarget_nGetFinalizer() {
return reinterpret_cast<KNativePointer>(&deleteBackendRenderTarget);
}
extern "C" jlong BackendRenderTarget_nMakeGL
(jint width, jint height, jint sampleCnt, jint stencilBits, jint fbId, jint fbFormat) {
SKIKO_EXPORT KNativePointer BackendRenderTarget_nMakeGL
(KInt width, KInt height, KInt sampleCnt, KInt stencilBits, KInt fbId, KInt 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);
return instance;
}
extern "C" jlong BackendRenderTarget_nMakeMetal
(jint width, jint height, jlong texturePtr) {
SKIKO_EXPORT KNativePointer BackendRenderTarget_nMakeMetal
( KInt width, KInt height, KNativePointer texturePtr) {
#ifdef SK_METAL
GrMTLHandle texture = reinterpret_cast<GrMTLHandle>(static_cast<uintptr_t>(texturePtr));
GrMTLHandle texture = reinterpret_cast<GrMTLHandle>((texturePtr));
GrMtlTextureInfo fbInfo;
fbInfo.fTexture.retain(texture);
GrBackendRenderTarget* instance = new GrBackendRenderTarget(width, height, fbInfo);
return reinterpret_cast<jlong>(instance);
return instance;
#else
return 0;
#endif
......@@ -35,18 +34,18 @@ extern "C" jlong BackendRenderTarget_nMakeMetal
#include "d3d/GrD3DTypes.h"
#endif
extern "C" jlong BackendRenderTarget_MakeDirect3D
(jint width, jint height, jlong texturePtr, jint format, jint sampleCnt, jint levelCnt) {
SKIKO_EXPORT KNativePointer BackendRenderTarget_MakeDirect3D
(KInt width, KInt height, KNativePointer texturePtr, KInt format, KInt sampleCnt, KInt levelCnt) {
#ifdef SK_DIRECT3D
GrD3DTextureResourceInfo texResInfo = {};
ID3D12Resource* resource = reinterpret_cast<ID3D12Resource*>(static_cast<uintptr_t>(texturePtr));
ID3D12Resource* resource = reinterpret_cast<ID3D12Resource*>((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);
return instance;
#else
return 0;
#endif
......
skiko/src/nativeMain/cpp/generated/Bitmap.cc → skiko/src/commonMain/cpp/generated/Bitmap.cc
View file @ 4b6f133a
......@@ -12,101 +12,101 @@ static void deleteBitmap(SkBitmap* instance) {
delete instance;
}
extern "C" jlong org_jetbrains_skia_Bitmap__1nGetFinalizer() {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteBitmap));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Bitmap__1nGetFinalizer() {
return reinterpret_cast<KNativePointer>((&deleteBitmap));
}
extern "C" jlong org_jetbrains_skia_Bitmap__1nMake
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Bitmap__1nMake
() {
return reinterpret_cast<jlong>(new SkBitmap());
return reinterpret_cast<KNativePointer>(new SkBitmap());
}
extern "C" jlong org_jetbrains_skia_Bitmap__1nMakeClone
(jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
return reinterpret_cast<jlong>(new SkBitmap(*instance));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Bitmap__1nMakeClone
(KNativePointer ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
return reinterpret_cast<KNativePointer>(new SkBitmap(*instance));
}
extern "C" void org_jetbrains_skia_Bitmap__1nSwap
(jlong ptr, jlong otherPtr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SkBitmap* other = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(otherPtr));
SKIKO_EXPORT void org_jetbrains_skia_Bitmap__1nSwap
(KNativePointer ptr, KNativePointer otherPtr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
SkBitmap* other = reinterpret_cast<SkBitmap*>((otherPtr));
instance->swap(*other);
}
extern "C" jobject org_jetbrains_skia_Bitmap__1nGetImageInfo
(jlong ptr) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Bitmap__1nGetImageInfo
(KNativePointer ptr) {
TODO("implement org_jetbrains_skia_Bitmap__1nGetImageInfo");
}
#if 0
extern "C" jobject org_jetbrains_skia_Bitmap__1nGetImageInfo
(jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Bitmap__1nGetImageInfo
(KNativePointer ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
return skija::ImageInfo::toJava(env, instance->info());
}
#endif
extern "C" jint org_jetbrains_skia_Bitmap__1nGetRowBytesAsPixels
(jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_Bitmap__1nGetRowBytesAsPixels
(KNativePointer ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
return instance->rowBytesAsPixels();
}
extern "C" jboolean org_jetbrains_skia_Bitmap__1nIsNull
(jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Bitmap__1nIsNull
(KNativePointer ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
return instance->isNull();
}
extern "C" jlong org_jetbrains_skia_Bitmap__1nGetRowBytes
(jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_Bitmap__1nGetRowBytes
(KNativePointer ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
return instance->rowBytes();
}
extern "C" jboolean org_jetbrains_skia_Bitmap__1nSetAlphaType
(jlong ptr, jint alphaType) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Bitmap__1nSetAlphaType
(KNativePointer ptr, KInt alphaType) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
return instance->setAlphaType(static_cast<SkAlphaType>(alphaType));
}
extern "C" jlong org_jetbrains_skia_Bitmap__1nComputeByteSize
(jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_Bitmap__1nComputeByteSize
(KNativePointer ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
return instance->computeByteSize();
}
extern "C" jboolean org_jetbrains_skia_Bitmap__1nIsImmutable
(jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Bitmap__1nIsImmutable
(KNativePointer ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
return instance->isImmutable();
}
extern "C" void org_jetbrains_skia_Bitmap__1nSetImmutable
(jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Bitmap__1nSetImmutable
(KNativePointer ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
instance->setImmutable();
}
extern "C" void org_jetbrains_skia_Bitmap__1nReset
(jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Bitmap__1nReset
(KNativePointer ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
instance->reset();
}
extern "C" jboolean org_jetbrains_skia_Bitmap__1nComputeIsOpaque
(jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Bitmap__1nComputeIsOpaque
(KNativePointer ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
return SkBitmap::ComputeIsOpaque(*instance);
}
extern "C" jboolean org_jetbrains_skia_Bitmap__1nSetImageInfo
(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));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Bitmap__1nSetImageInfo
(KNativePointer ptr, KInt width, KInt height, KInt colorType, KInt alphaType, KNativePointer colorSpacePtr, KInt rowBytes) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>((colorSpacePtr));
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
......@@ -115,10 +115,10 @@ extern "C" jboolean org_jetbrains_skia_Bitmap__1nSetImageInfo
return instance->setInfo(imageInfo, rowBytes);
}
extern "C" jboolean org_jetbrains_skia_Bitmap__1nAllocPixelsFlags
(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));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Bitmap__1nAllocPixelsFlags
(KNativePointer ptr, KInt width, KInt height, KInt colorType, KInt alphaType, KNativePointer colorSpacePtr, KInt flags) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>((colorSpacePtr));
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
......@@ -127,10 +127,10 @@ extern "C" jboolean org_jetbrains_skia_Bitmap__1nAllocPixelsFlags
return instance->tryAllocPixelsFlags(imageInfo, flags);
}
extern "C" jboolean org_jetbrains_skia_Bitmap__1nAllocPixelsRowBytes
(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));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Bitmap__1nAllocPixelsRowBytes
(KNativePointer ptr, KInt width, KInt height, KInt colorType, KInt alphaType, KNativePointer colorSpacePtr, KInt rowBytes) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>((colorSpacePtr));
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
......@@ -140,16 +140,16 @@ extern "C" jboolean org_jetbrains_skia_Bitmap__1nAllocPixelsRowBytes
}
extern "C" jboolean org_jetbrains_skia_Bitmap__1nInstallPixels
(jlong ptr, jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr, jbyteArray pixelsArr, jlong rowBytes) {
SKIKO_EXPORT KBoolean org_jetbrains_skia_Bitmap__1nInstallPixels
(KNativePointer ptr, KInt width, KInt height, KInt colorType, KInt alphaType, KNativePointer colorSpacePtr, KByte* pixelsArr, KNativePointer rowBytes) {
TODO("implement org_jetbrains_skia_Bitmap__1nInstallPixels");
}
#if 0
extern "C" jboolean org_jetbrains_skia_Bitmap__1nInstallPixels
(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));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Bitmap__1nInstallPixels
(KNativePointer ptr, KInt width, KInt height, KInt colorType, KInt alphaType, KNativePointer colorSpacePtr, KByte* pixelsArr, KNativePointer rowBytes) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>((colorSpacePtr));
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
......@@ -157,107 +157,107 @@ extern "C" jboolean org_jetbrains_skia_Bitmap__1nInstallPixels
sk_ref_sp<SkColorSpace>(colorSpace));
jsize len = env->GetArrayLength(pixelsArr);
jbyte* pixels = new jbyte[len];
KByte* pixels = new KByte[len];
env->GetByteArrayRegion(pixelsArr, 0, len, pixels);
return instance->installPixels(imageInfo, pixels, rowBytes, deleteJBytes, nullptr);
}
#endif
extern "C" jboolean org_jetbrains_skia_Bitmap__1nAllocPixels
(jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Bitmap__1nAllocPixels
(KNativePointer ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
return instance->tryAllocPixels();
}
extern "C" jlong org_jetbrains_skia_Bitmap__1nGetPixelRef
(jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Bitmap__1nGetPixelRef
(KNativePointer ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
SkPixelRef* pixelRef = instance->pixelRef();
pixelRef->ref();
return reinterpret_cast<jlong>(pixelRef);
return reinterpret_cast<KNativePointer>(pixelRef);
}
extern "C" jlong org_jetbrains_skia_Bitmap__1nGetPixelRefOrigin
(jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KLong org_jetbrains_skia_Bitmap__1nGetPixelRefOrigin
(KNativePointer ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
SkIPoint origin = instance->pixelRefOrigin();
return packIPoint(origin);
}
extern "C" void org_jetbrains_skia_Bitmap__1nSetPixelRef
(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));
SKIKO_EXPORT void org_jetbrains_skia_Bitmap__1nSetPixelRef
(KNativePointer ptr, KNativePointer pixelRefPtr, KInt dx, KInt dy) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
SkPixelRef* pixelRef = reinterpret_cast<SkPixelRef*>((pixelRefPtr));
instance->setPixelRef(sk_ref_sp<SkPixelRef>(pixelRef), dx, dy);
}
extern "C" jboolean org_jetbrains_skia_Bitmap__1nIsReadyToDraw
(jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Bitmap__1nIsReadyToDraw
(KNativePointer ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
return instance->readyToDraw();
}
extern "C" jint org_jetbrains_skia_Bitmap__1nGetGenerationId
(jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_Bitmap__1nGetGenerationId
(KNativePointer ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
return instance->getGenerationID();
}
extern "C" void org_jetbrains_skia_Bitmap__1nNotifyPixelsChanged
(jlong ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Bitmap__1nNotifyPixelsChanged
(KNativePointer ptr) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
instance->notifyPixelsChanged();
}
extern "C" void org_jetbrains_skia_Bitmap__1nEraseColor
(jlong ptr, jint color) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Bitmap__1nEraseColor
(KNativePointer ptr, KInt color) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
instance->eraseColor(color);
}
extern "C" void org_jetbrains_skia_Bitmap__1nErase
(jlong ptr, jint color, jint left, jint top, jint right, jint bottom) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Bitmap__1nErase
(KNativePointer ptr, KInt color, KInt left, KInt top, KInt right, KInt bottom) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
instance->erase(color, {left, top, right, bottom});
}
extern "C" jint org_jetbrains_skia_Bitmap__1nGetColor
(jlong ptr, jint x, jint y) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_Bitmap__1nGetColor
(KNativePointer ptr, KInt x, KInt y) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
return instance->getColor(x, y);
}
extern "C" jfloat org_jetbrains_skia_Bitmap__1nGetAlphaf
(jlong ptr, jint x, jint y) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KFloat org_jetbrains_skia_Bitmap__1nGetAlphaf
(KNativePointer ptr, KInt x, KInt y) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
return instance->getAlphaf(x, y);
}
extern "C" jboolean org_jetbrains_skia_Bitmap__1nExtractSubset
(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));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Bitmap__1nExtractSubset
(KNativePointer ptr, KNativePointer dstPtr, KInt left, KInt top, KInt right, KInt bottom) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
SkBitmap* dst = reinterpret_cast<SkBitmap*>((dstPtr));
return instance->extractSubset(dst, {left, top, right, bottom});
}
extern "C" jbyteArray org_jetbrains_skia_Bitmap__1nReadPixels
(jlong ptr, jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr, jlong rowBytes, jint srcX, jint srcY) {
SKIKO_EXPORT KByte* org_jetbrains_skia_Bitmap__1nReadPixels
(KNativePointer ptr, KInt width, KInt height, KInt colorType, KInt alphaType, KNativePointer colorSpacePtr, KNativePointer rowBytes, KInt srcX, KInt srcY) {
TODO("implement org_jetbrains_skia_Bitmap__1nReadPixels");
}
#if 0
extern "C" jbyteArray org_jetbrains_skia_Bitmap__1nReadPixels
(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));
SKIKO_EXPORT KByte* org_jetbrains_skia_Bitmap__1nReadPixels
(KNativePointer ptr, KInt width, KInt height, KInt colorType, KInt alphaType, KNativePointer colorSpacePtr, KNativePointer rowBytes, KInt srcX, KInt srcY) {
SkBitmap* instance = reinterpret_cast<SkBitmap*>((ptr));
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>((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);
std::vector<KByte> pixels(std::min(height, instance->height() - srcY) * rowBytes);
if (instance->readPixels(imageInfo, pixels.data(), rowBytes, srcX, srcY))
return javaByteArray(env, pixels);
else
......@@ -265,60 +265,18 @@ extern "C" jbyteArray org_jetbrains_skia_Bitmap__1nReadPixels
}
#endif
extern "C" jobject org_jetbrains_skia_Bitmap__1nExtractAlpha
(jlong ptr, jlong dstPtr, jlong paintPtr) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Bitmap__1nExtractAlpha
(KNativePointer ptr, KNativePointer dstPtr, KNativePointer paintPtr) {
TODO("implement org_jetbrains_skia_Bitmap__1nExtractAlpha");
}
#if 0
extern "C" jobject org_jetbrains_skia_Bitmap__1nExtractAlpha
(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;
}
#endif
extern "C" jobject org_jetbrains_skia_Bitmap__1nPeekPixels
(jlong ptr) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Bitmap__1nPeekPixels
(KNativePointer ptr) {
TODO("implement org_jetbrains_skia_Bitmap__1nPeekPixels");
}
#if 0
extern "C" jobject org_jetbrains_skia_Bitmap__1nPeekPixels
(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;
}
#endif
extern "C" jlong org_jetbrains_skia_Bitmap__1nMakeShader
(jlong ptr, jint tmx, jint tmy, jlong samplingMode, jfloatArray localMatrixArr) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Bitmap__1nMakeShader
(KNativePointer ptr, KInt tmx, KInt tmy, KNativePointer samplingMode, KFloat* localMatrixArr) {
TODO("implement org_jetbrains_skia_Bitmap__1nMakeShader");
}
#if 0
extern "C" jlong org_jetbrains_skia_Bitmap__1nMakeShader
(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());
}
#endif
skiko/src/nativeMain/cpp/generated/BreakIterator.cc → skiko/src/commonMain/cpp/generated/BreakIterator.cc
View file @ 4b6f133a
......@@ -8,127 +8,88 @@ static void deleteBreakIterator(UBreakIterator* instance) {
ubrk_close(instance);
}
extern "C" jlong org_jetbrains_skia_BreakIterator__1nGetFinalizer() {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteBreakIterator));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_BreakIterator__1nGetFinalizer() {
return reinterpret_cast<KNativePointer>((&deleteBreakIterator));
}
extern "C" jlong org_jetbrains_skia_BreakIterator__1nMake
(jint type, jstring localeStr) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_BreakIterator__1nMake
(KInt type, KInteropPointer localeStr) {
TODO("implement org_jetbrains_skia_BreakIterator__1nMake");
}
#if 0
extern "C" jlong org_jetbrains_skia_BreakIterator__1nMake
(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);
}
#endif
extern "C" jint org_jetbrains_skia_BreakIterator__1nClone
(jlong ptr) {
SKIKO_EXPORT KInt org_jetbrains_skia_BreakIterator__1nClone
(KNativePointer ptr) {
TODO("implement org_jetbrains_skia_BreakIterator__1nClone");
}
#if 0
extern "C" jint org_jetbrains_skia_BreakIterator__1nClone
(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);
}
#endif
extern "C" jint org_jetbrains_skia_BreakIterator__1nCurrent
(jlong ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_BreakIterator__1nCurrent
(KNativePointer ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>((ptr));
return ubrk_current(instance);
}
extern "C" jint org_jetbrains_skia_BreakIterator__1nNext
(jlong ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_BreakIterator__1nNext
(KNativePointer ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>((ptr));
return ubrk_next(instance);
}
extern "C" jint org_jetbrains_skia_BreakIterator__1nPrevious
(jlong ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_BreakIterator__1nPrevious
(KNativePointer ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>((ptr));
return ubrk_previous(instance);
}
extern "C" jint org_jetbrains_skia_BreakIterator__1nFirst
(jlong ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_BreakIterator__1nFirst
(KNativePointer ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>((ptr));
return ubrk_first(instance);
}
extern "C" jint org_jetbrains_skia_BreakIterator__1nLast
(jlong ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_BreakIterator__1nLast
(KNativePointer ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>((ptr));
return ubrk_last(instance);
}
extern "C" jint org_jetbrains_skia_BreakIterator__1nPreceding
(jlong ptr, jint offset) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_BreakIterator__1nPreceding
(KNativePointer ptr, KInt offset) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>((ptr));
return ubrk_preceding(instance, offset);
}
extern "C" jint org_jetbrains_skia_BreakIterator__1nFollowing
(jlong ptr, jint offset) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_BreakIterator__1nFollowing
(KNativePointer ptr, KInt offset) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>((ptr));
return ubrk_following(instance, offset);
}
extern "C" jboolean org_jetbrains_skia_BreakIterator__1nIsBoundary
(jlong ptr, jint offset) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_BreakIterator__1nIsBoundary
(KNativePointer ptr, KInt offset) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>((ptr));
return ubrk_isBoundary(instance, offset);
}
extern "C" jint org_jetbrains_skia_BreakIterator__1nGetRuleStatus
(jlong ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_BreakIterator__1nGetRuleStatus
(KNativePointer ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>((ptr));
return ubrk_getRuleStatus(instance);
}
extern "C" jintArray org_jetbrains_skia_BreakIterator__1nGetRuleStatuses
(jlong ptr) {
TODO("implement org_jetbrains_skia_BreakIterator__1nGetRuleStatuses");
}
#if 0
extern "C" jintArray org_jetbrains_skia_BreakIterator__1nGetRuleStatuses
(jlong ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt* org_jetbrains_skia_BreakIterator__1nGetRuleStatuses
(KNativePointer ptr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>((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);
std::vector<KInt> 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));
......@@ -138,16 +99,16 @@ extern "C" jintArray org_jetbrains_skia_BreakIterator__1nGetRuleStatuses
extern "C" void org_jetbrains_skia_BreakIterator__1nSetText
(jlong ptr, jlong textPtr) {
SKIKO_EXPORT void org_jetbrains_skia_BreakIterator__1nSetText
(KNativePointer ptr, KNativePointer textPtr) {
TODO("implement org_jetbrains_skia_BreakIterator__1nSetText");
}
#if 0
extern "C" void org_jetbrains_skia_BreakIterator__1nSetText
(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));
SKIKO_EXPORT void org_jetbrains_skia_BreakIterator__1nSetText
(KNativePointer ptr, KNativePointer textPtr) {
UBreakIterator* instance = reinterpret_cast<UBreakIterator*>((ptr));
std::vector<KChar>* text = reinterpret_cast<std::vector<KChar>*>((textPtr));
UErrorCode status = U_ZERO_ERROR;
ubrk_setText(instance, reinterpret_cast<UChar *>(text->data()), text->size(), &status);
if (U_FAILURE(status))
......
skiko/src/nativeMain/cpp/generated/Canvas.cc → skiko/src/commonMain/cpp/generated/Canvas.cc
View file @ 4b6f133a
......@@ -8,187 +8,186 @@
#include "SkVertices.h"
#include "hb.h"
#include "common.h"
#include "native_interop.h"
static void deleteCanvas(SkCanvas* canvas) {
// std::cout << "Deleting [SkCanvas " << canvas << "]" << std::endl;
delete canvas;
}
extern "C" jlong org_jetbrains_skia_Canvas__1nGetFinalizer() {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteCanvas));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Canvas__1nGetFinalizer() {
return reinterpret_cast<KNativePointer>((&deleteCanvas));
}
extern "C" jlong org_jetbrains_skia_Canvas__1nMakeFromBitmap
(jlong bitmapPtr, jint flags, jint pixelGeometry) {
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(bitmapPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Canvas__1nMakeFromBitmap
(KNativePointer bitmapPtr, KInt flags, KInt pixelGeometry) {
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>((bitmapPtr));
SkCanvas* canvas = new SkCanvas(*bitmap, {static_cast<uint32_t>(flags), static_cast<SkPixelGeometry>(pixelGeometry)});
return reinterpret_cast<jlong>(canvas);
return reinterpret_cast<KNativePointer>(canvas);
}
extern "C" void org_jetbrains_skia_Canvas__1nDrawPoint
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawPoint
(KNativePointer canvasPtr, KFloat x, KFloat y, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
canvas->drawPoint(x, y, *paint);
}
extern "C" void org_jetbrains_skia_Canvas__1nDrawPoints
(jlong canvasPtr, int mode, jfloatArray coords, jlong paintPtr) {
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawPoints
(KNativePointer canvasPtr, int mode, KFloat* coords, KNativePointer paintPtr) {
TODO("implement org_jetbrains_skia_Canvas__1nDrawPoints");
}
#if 0
extern "C" void org_jetbrains_skia_Canvas__1nDrawPoints
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawPoints
(KNativePointer canvasPtr, int mode, KFloat* coords, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
SkCanvas::PointMode skMode = static_cast<SkCanvas::PointMode>(mode);
jsize len = env->GetArrayLength(coords);
jfloat* arr = static_cast<jfloat*>(env->GetPrimitiveArrayCritical(coords, 0));
KFloat* arr = static_cast<KFloat*>(env->GetPrimitiveArrayCritical(coords, 0));
canvas->drawPoints(skMode, len / 2, reinterpret_cast<SkPoint*>(arr), *paint);
env->ReleasePrimitiveArrayCritical(coords, arr, 0);
}
#endif
extern "C" void org_jetbrains_skia_Canvas__1nDrawLine
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawLine
(KNativePointer canvasPtr, KFloat x0, KFloat y0, KFloat x1, KFloat y1, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
canvas->drawLine(x0, y0, x1, y1, *paint);
}
extern "C" void org_jetbrains_skia_Canvas__1nDrawArc
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawArc
(KNativePointer canvasPtr, KFloat left, KFloat top, KFloat right, KFloat bottom, KFloat startAngle, KFloat sweepAngle, KBoolean includeCenter, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
canvas->drawArc({left, top, right, bottom}, startAngle, sweepAngle, includeCenter, *paint);
}
extern "C" void org_jetbrains_skia_Canvas__1nDrawRect
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawRect
(KNativePointer canvasPtr, KFloat left, KFloat top, KFloat right, KFloat bottom, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
canvas->drawRect({left, top, right, bottom}, *paint);
}
extern "C" void org_jetbrains_skia_Canvas__1nDrawOval
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawOval
(KNativePointer canvasPtr, KFloat left, KFloat top, KFloat right, KFloat bottom, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
canvas->drawOval({left, top, right, bottom}, *paint);
}
extern "C" void org_jetbrains_skia_Canvas__1nDrawRRect
(jlong canvasPtr, jfloat left, jfloat top, jfloat right, jfloat bottom, jfloatArray jradii, jint jradiiSize, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawRRect
(KNativePointer canvasPtr, KFloat left, KFloat top, KFloat right, KFloat bottom, KFloat* jradii, KInt jradiiSize, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
canvas->drawRRect(skija::RRect::toSkRRect(left, top, right, bottom, jradii, jradiiSize), *paint);
}
extern "C" void org_jetbrains_skia_Canvas__1nDrawDRRect
(jlong canvasPtr,
jfloat ol, jfloat ot, jfloat oright, jfloat ob, jfloatArray ojradii, jint ojradiiSize,
jfloat il, jfloat it, jfloat ir, jfloat ib, jfloatArray ijradii, jint ijradiiSize,
jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawDRRect
(KNativePointer canvasPtr,
KFloat ol, KFloat ot, KFloat oright, KFloat ob, KFloat* ojradii, KInt ojradiiSize,
KFloat il, KFloat it, KFloat ir, KFloat ib, KFloat* ijradii, KInt ijradiiSize,
KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
canvas->drawDRRect(skija::RRect::toSkRRect(ol, ot, oright, ob, ojradii, ojradiiSize),
skija::RRect::toSkRRect(il, it, ir, ib, ijradii, ijradiiSize), *paint);
}
extern "C" void org_jetbrains_skia_Canvas__1nDrawPath
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawPath
(KNativePointer canvasPtr, KNativePointer pathPtr, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkPath* path = reinterpret_cast<SkPath*>((pathPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
canvas->drawPath(*path, *paint);
}
extern "C" void org_jetbrains_skia_Canvas__1nDrawImageRect
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawImageRect
(KNativePointer canvasPtr, KNativePointer imagePtr, KFloat sl, KFloat st, KFloat sr, KFloat sb, KFloat dl, KFloat dt, KFloat dr, KFloat db, KInt samplingMode, KNativePointer paintPtr, KBoolean strict) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkImage* image = reinterpret_cast<SkImage*>((imagePtr));
SkRect src {sl, st, sr, sb};
SkRect dst {dl, dt, dr, db};
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>((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" void org_jetbrains_skia_Canvas__1nDrawImageNine
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawImageNine
(KNativePointer canvasPtr, KNativePointer imagePtr, KInt cl, KInt ct, KInt cr, KInt cb, KFloat dl, KFloat dt, KFloat dr, KFloat db, KInt filterMode, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkImage* image = reinterpret_cast<SkImage*>((imagePtr));
SkIRect center {cl, ct, cr, cb};
SkRect dst {dl, dt, dr, db};
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
canvas->drawImageNine(image, center, dst, static_cast<SkFilterMode>(filterMode), paint);
}
extern "C" void org_jetbrains_skia_Canvas__1nDrawRegion
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawRegion
(KNativePointer canvasPtr, KNativePointer regionPtr, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkRegion* region = reinterpret_cast<SkRegion*>((regionPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
canvas->drawRegion(*region, *paint);
}
extern "C" void org_jetbrains_skia_Canvas__1nDrawString
(jlong canvasPtr, jstring stringObj, jfloat x, jfloat y, jlong skFontPtr, jlong paintPtr) {
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawString
(KNativePointer canvasPtr, KInteropPointer stringObj, KFloat x, KFloat y, KNativePointer skFontPtr, KNativePointer paintPtr) {
TODO("implement org_jetbrains_skia_Canvas__1nDrawString");
}
#if 0
extern "C" void org_jetbrains_skia_Canvas__1nDrawString
(jlong canvasPtr, jstring stringObj, jfloat x, jfloat y, jlong skFontPtr, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*> (static_cast<uintptr_t>(canvasPtr));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawString
(KNativePointer canvasPtr, KInteropPointer stringObj, KFloat x, KFloat y, KNativePointer skFontPtr, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*> ((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));
SkFont* font = reinterpret_cast<SkFont*> ((skFontPtr));
SkPaint* paint = reinterpret_cast<SkPaint*> ((paintPtr));
canvas->drawString(string, x, y, *font, *paint);
}
#endif
extern "C" void org_jetbrains_skia_Canvas__1nDrawTextBlob
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawTextBlob
(KNativePointer canvasPtr, KNativePointer blobPtr, KFloat x, KFloat y, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*> ((canvasPtr));
SkTextBlob* blob = reinterpret_cast<SkTextBlob*>((blobPtr));
SkPaint* paint = reinterpret_cast<SkPaint*> ((paintPtr));
canvas->drawTextBlob(blob, x, y, *paint);
}
extern "C" void org_jetbrains_skia_Canvas__1nDrawPicture
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawPicture
(KNativePointer ptr, KNativePointer picturePtr, KFloat* matrixArr, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*> ((ptr));
SkPicture* picture = reinterpret_cast<SkPicture*>((picturePtr));
std::unique_ptr<SkMatrix> matrix = skMatrix(matrixArr);
SkPaint* paint = reinterpret_cast<SkPaint*> (static_cast<uintptr_t>(paintPtr));
SkPaint* paint = reinterpret_cast<SkPaint*> ((paintPtr));
canvas->drawPicture(picture, matrix.get(), paint);
}
extern "C" void org_jetbrains_skia_Canvas__1nDrawVertices
(jlong ptr, jint verticesMode, jfloatArray positionsArr, jintArray colorsArr, jfloatArray texCoordsArr, jshortArray indexArr, jint blendMode, jlong paintPtr) {
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawVertices
(KNativePointer ptr, KInt verticesMode, KFloat* positionsArr, KInt* colorsArr, KFloat* texCoordsArr, KShort* indexArr, KInt blendMode, KNativePointer paintPtr) {
TODO("implement org_jetbrains_skia_Canvas__1nDrawVertices");
}
#if 0
extern "C" void org_jetbrains_skia_Canvas__1nDrawVertices
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawVertices
(KNativePointer ptr, KInt verticesMode, KFloat* positionsArr, KInt* colorsArr, KFloat* texCoordsArr, KShort* indexArr, KInt blendMode, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*> ((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);
KFloat* positions = env->GetFloatArrayElements(positionsArr, 0);
KInt* colors = colorsArr == nullptr ? nullptr : env->GetIntArrayElements(colorsArr, 0);
KFloat* texCoords = texCoordsArr == nullptr ? nullptr : env->GetFloatArrayElements(texCoordsArr, 0);
const KShort* indices = indexArr == nullptr ? nullptr : env->GetShortArrayElements(indexArr, 0);
sk_sp<SkVertices> vertices = SkVertices::MakeCopy(
static_cast<SkVertices::VertexMode>(verticesMode),
env->GetArrayLength(positionsArr) / 2,
......@@ -197,7 +196,7 @@ extern "C" void org_jetbrains_skia_Canvas__1nDrawVertices
reinterpret_cast<SkColor*>(colors),
indexCount,
reinterpret_cast<const uint16_t *>(indices));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
canvas->drawVertices(vertices, static_cast<SkBlendMode>(blendMode), *paint);
......@@ -211,19 +210,19 @@ extern "C" void org_jetbrains_skia_Canvas__1nDrawVertices
extern "C" void org_jetbrains_skia_Canvas__1nDrawPatch
(jlong ptr, jfloatArray cubicsArr, jintArray colorsArr, jfloatArray texCoordsArr, jint blendMode, jlong paintPtr) {
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawPatch
(KNativePointer ptr, KFloat* cubicsArr, KInt* colorsArr, KFloat* texCoordsArr, KInt blendMode, KNativePointer paintPtr) {
TODO("implement org_jetbrains_skia_Canvas__1nDrawPatch");
}
#if 0
extern "C" void org_jetbrains_skia_Canvas__1nDrawPatch
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawPatch
(KNativePointer ptr, KFloat* cubicsArr, KInt* colorsArr, KFloat* texCoordsArr, KInt blendMode, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*> ((ptr));
KFloat* cubics = env->GetFloatArrayElements(cubicsArr, 0);
KInt* colors = env->GetIntArrayElements(colorsArr, 0);
KFloat* texCoords = texCoordsArr == nullptr ? nullptr : env->GetFloatArrayElements(texCoordsArr, 0);
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
canvas->drawPatch(reinterpret_cast<SkPoint*>(cubics), reinterpret_cast<SkColor*>(colors), reinterpret_cast<SkPoint*>(texCoords), static_cast<SkBlendMode>(blendMode), *paint);
......@@ -236,66 +235,66 @@ extern "C" void org_jetbrains_skia_Canvas__1nDrawPatch
extern "C" void org_jetbrains_skia_Canvas__1nDrawDrawable
(jlong ptr, jlong drawablePtr, jfloatArray matrixArr) {
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawDrawable
(KNativePointer ptr, KNativePointer drawablePtr, KFloat* matrixArr) {
TODO("implement org_jetbrains_skia_Canvas__1nDrawDrawable");
}
#if 0
extern "C" void org_jetbrains_skia_Canvas__1nDrawDrawable
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawDrawable
(KNativePointer ptr, KNativePointer drawablePtr, KFloat* matrixArr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((ptr));
SkDrawable* drawable = reinterpret_cast<SkDrawable*>((drawablePtr));
std::unique_ptr<SkMatrix> matrix = skMatrix(env, matrixArr);
canvas->drawDrawable(drawable, matrix.get());
}
#endif
extern "C" void org_jetbrains_skia_Canvas__1nClear(jlong ptr, jint color) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nClear(KNativePointer ptr, KInt color) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((ptr));
canvas->clear(color);
}
extern "C" void org_jetbrains_skia_Canvas__1nDrawPaint
(jlong canvasPtr, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nDrawPaint
(KNativePointer canvasPtr, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
canvas->drawPaint(*paint);
}
extern "C" void org_jetbrains_skia_Canvas__1nSetMatrix
(jlong canvasPtr, jfloatArray matrixArr) {
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nSetMatrix
(KNativePointer canvasPtr, KFloat* matrixArr) {
TODO("implement org_jetbrains_skia_Canvas__1nSetMatrix");
}
#if 0
extern "C" void org_jetbrains_skia_Canvas__1nSetMatrix
(jlong canvasPtr, jfloatArray matrixArr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nSetMatrix
(KNativePointer canvasPtr, KFloat* matrixArr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
std::unique_ptr<SkMatrix> matrix = skMatrix(env, matrixArr);
canvas->setMatrix(*matrix);
}
#endif
extern "C" void org_jetbrains_skia_Canvas__1nResetMatrix
(jlong canvasPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nResetMatrix
(KNativePointer canvasPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
canvas->resetMatrix();
}
extern "C" jobject org_jetbrains_skia_Canvas__1nGetLocalToDevice
(jlong canvasPtr) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Canvas__1nGetLocalToDevice
(KNativePointer canvasPtr) {
TODO("implement org_jetbrains_skia_Canvas__1nGetLocalToDevice");
}
#if 0
extern "C" jobject org_jetbrains_skia_Canvas__1nGetLocalToDevice
(jlong canvasPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Canvas__1nGetLocalToDevice
(KNativePointer canvasPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkM44 matrix = canvas->getLocalToDevice();
std::vector<float> floats(16);
matrix.getRowMajor(floats.data());
......@@ -304,90 +303,90 @@ extern "C" jobject org_jetbrains_skia_Canvas__1nGetLocalToDevice
#endif
extern "C" void org_jetbrains_skia_Canvas__1nClipRect
(jlong canvasPtr, jfloat left, jfloat top, jfloat right, jfloat bottom, jint mode, jboolean antiAlias) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nClipRect
(KNativePointer canvasPtr, KFloat left, KFloat top, KFloat right, KFloat bottom, KInt mode, KBoolean antiAlias) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
canvas->clipRect({left, top, right, bottom}, static_cast<SkClipOp>(mode), antiAlias);
}
extern "C" void org_jetbrains_skia_Canvas__1nClipRRect
(jlong canvasPtr, jfloat left, jfloat top, jfloat right, jfloat bottom, jfloatArray jradii, jint jradiiSize, jint mode, jboolean antiAlias) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nClipRRect
(KNativePointer canvasPtr, KFloat left, KFloat top, KFloat right, KFloat bottom, KFloat* jradii, KInt jradiiSize, KInt mode, KBoolean antiAlias) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
canvas->clipRRect(skija::RRect::toSkRRect(left, top, right, bottom, jradii, jradiiSize), static_cast<SkClipOp>(mode), antiAlias);
}
extern "C" void org_jetbrains_skia_Canvas__1nClipPath
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nClipPath
(KNativePointer canvasPtr, KNativePointer pathPtr, KInt mode, KBoolean antiAlias) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkPath* path = reinterpret_cast<SkPath*>((pathPtr));
canvas->clipPath(*path, static_cast<SkClipOp>(mode), antiAlias);
}
extern "C" void org_jetbrains_skia_Canvas__1nClipRegion
(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));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nClipRegion
(KNativePointer canvasPtr, KNativePointer regionPtr, KInt mode) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkRegion* region = reinterpret_cast<SkRegion*>((regionPtr));
canvas->clipRegion(*region, static_cast<SkClipOp>(mode));
}
extern "C" void org_jetbrains_skia_Canvas__1nConcat
(jlong ptr, jfloatArray matrixArr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nConcat
(KNativePointer ptr, KFloat* matrixArr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((ptr));
std::unique_ptr<SkMatrix> m = skMatrix(matrixArr);
canvas->concat(*m);
}
extern "C" void org_jetbrains_skia_Canvas__1nConcat44
(jlong ptr, jfloatArray matrixArr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nConcat44
(KNativePointer ptr, KFloat* matrixArr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((ptr));
std::unique_ptr<SkM44> m = skM44(matrixArr);
canvas->concat(*m);
}
extern "C" jint org_jetbrains_skia_Canvas__1nReadPixels
(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));
SKIKO_EXPORT KInt org_jetbrains_skia_Canvas__1nReadPixels
(KNativePointer ptr, KNativePointer bitmapPtr, KInt srcX, KInt srcY) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((ptr));
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>((bitmapPtr));
return canvas->readPixels(*bitmap, srcX, srcY);
}
extern "C" jint org_jetbrains_skia_Canvas__1nWritePixels
(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));
SKIKO_EXPORT KInt org_jetbrains_skia_Canvas__1nWritePixels
(KNativePointer ptr, KNativePointer bitmapPtr, KInt x, KInt y) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((ptr));
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>((bitmapPtr));
return canvas->writePixels(*bitmap, x, y);
}
extern "C" jint org_jetbrains_skia_Canvas__1nSave(jlong ptr) {
return reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr))->save();
SKIKO_EXPORT KInt org_jetbrains_skia_Canvas__1nSave(KNativePointer ptr) {
return reinterpret_cast<SkCanvas*>((ptr))->save();
}
extern "C" jint org_jetbrains_skia_Canvas__1nSaveLayer
(jlong ptr, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr));
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
SKIKO_EXPORT KInt org_jetbrains_skia_Canvas__1nSaveLayer
(KNativePointer ptr, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((ptr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
return canvas->saveLayer(nullptr, paint);
}
extern "C" jint org_jetbrains_skia_Canvas__1nSaveLayerRect
(jlong ptr, jfloat left, jfloat top, jfloat right, jfloat bottom, jlong paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_Canvas__1nSaveLayerRect
(KNativePointer ptr, KFloat left, KFloat top, KFloat right, KFloat bottom, KNativePointer paintPtr) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((ptr));
SkRect bounds {left, top, right, bottom};
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
return canvas->saveLayer(&bounds, paint);
}
extern "C" jint org_jetbrains_skia_Canvas__1nGetSaveCount(jlong ptr) {
return reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr))->getSaveCount();
SKIKO_EXPORT KInt org_jetbrains_skia_Canvas__1nGetSaveCount(KNativePointer ptr) {
return reinterpret_cast<SkCanvas*>((ptr))->getSaveCount();
}
extern "C" void org_jetbrains_skia_Canvas__1nRestore(jlong ptr) {
reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr))->restore();
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nRestore(KNativePointer ptr) {
reinterpret_cast<SkCanvas*>((ptr))->restore();
}
extern "C" void org_jetbrains_skia_Canvas__1nRestoreToCount(jlong ptr, jint saveCount) {
reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(ptr))->restoreToCount(saveCount);
SKIKO_EXPORT void org_jetbrains_skia_Canvas__1nRestoreToCount(KNativePointer ptr, KInt saveCount) {
reinterpret_cast<SkCanvas*>((ptr))->restoreToCount(saveCount);
}
skiko/src/nativeMain/cpp/generated/Codec.cc → skiko/src/commonMain/cpp/generated/Codec.cc
View file @ 4b6f133a
......@@ -11,77 +11,77 @@ static void deleteCodec(SkCodec* instance) {
delete instance;
}
extern "C" jlong org_jetbrains_skia_Codec__1nGetFinalizer() {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteCodec));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Codec__1nGetFinalizer() {
return reinterpret_cast<KNativePointer>(&deleteCodec);
}
extern "C" jlong org_jetbrains_skia_Codec__1nMakeFromData
(jlong dataPtr) {
SkData* data = reinterpret_cast<SkData*>(static_cast<uintptr_t>(dataPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Codec__1nMakeFromData
(KNativePointer dataPtr) {
SkData* data = reinterpret_cast<SkData*>((dataPtr));
std::unique_ptr<SkCodec> instance = SkCodec::MakeFromData(sk_ref_sp(data));
return reinterpret_cast<jlong>(instance.release());
return reinterpret_cast<KNativePointer>(instance.release());
}
extern "C" jobject org_jetbrains_skia_Codec__1nGetImageInfo
(jlong ptr) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Codec__1nGetImageInfo
(KNativePointer ptr) {
TODO("implement org_jetbrains_skia_Codec__1nGetImageInfo");
}
#if 0
extern "C" jobject org_jetbrains_skia_Codec__1nGetImageInfo
(jlong ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Codec__1nGetImageInfo
(KNativePointer ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>((ptr));
return skija::ImageInfo::toJava(env, instance->getInfo());
}
#endif
extern "C" jlong org_jetbrains_skia_Codec__1nGetSize
(jlong ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_Codec__1nGetSize
(KNativePointer ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>((ptr));
return packISize(instance->dimensions());
}
extern "C" jlong org_jetbrains_skia_Codec__1nGetEncodedOrigin
(jlong ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
return static_cast<jint>(instance->getOrigin());
SKIKO_EXPORT KInt org_jetbrains_skia_Codec__1nGetEncodedOrigin
(KNativePointer ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>((ptr));
return static_cast<KInt>(instance->getOrigin());
}
extern "C" jlong org_jetbrains_skia_Codec__1nGetEncodedImageFormat
(jlong ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
return static_cast<jint>(instance->getEncodedFormat());
SKIKO_EXPORT KInt org_jetbrains_skia_Codec__1nGetEncodedImageFormat
(KNativePointer ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>((ptr));
return static_cast<KInt>(instance->getEncodedFormat());
}
extern "C" jint org_jetbrains_skia_Codec__1nReadPixels
(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));
SKIKO_EXPORT KInt org_jetbrains_skia_Codec__1nReadPixels
(KNativePointer ptr, KNativePointer bitmapPtr, KInt frame, KInt priorFrame) {
SkCodec* instance = reinterpret_cast<SkCodec*>((ptr));
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>((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);
return static_cast<KInt>(result);
}
extern "C" jint org_jetbrains_skia_Codec__1nGetFrameCount
(jlong ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_Codec__1nGetFrameCount
(KNativePointer ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>((ptr));
return instance->getFrameCount();
}
extern "C" jobject org_jetbrains_skia_Codec__1nGetFrameInfo
(jlong ptr, jint frame) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Codec__1nGetFrameInfo
(KNativePointer ptr, KInt frame) {
TODO("implement org_jetbrains_skia_Codec__1nGetFrameInfo");
}
#if 0
extern "C" jobject org_jetbrains_skia_Codec__1nGetFrameInfo
(jlong ptr, jint frame) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Codec__1nGetFrameInfo
(KNativePointer ptr, KInt frame) {
SkCodec* instance = reinterpret_cast<SkCodec*>((ptr));
SkCodec::FrameInfo info;
instance->getFrameInfo(frame, &info);
return skija::AnimationFrameInfo::toJava(env, info);
......@@ -90,22 +90,22 @@ extern "C" jobject org_jetbrains_skia_Codec__1nGetFrameInfo
extern "C" jobject org_jetbrains_skia_Codec__1nGetFramesInfo
(jlong ptr, jint frame) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Codec__1nGetFramesInfo
(KNativePointer ptr, KInt frame) {
TODO("implement org_jetbrains_skia_Codec__1nGetFramesInfo");
}
#if 0
extern "C" jobject org_jetbrains_skia_Codec__1nGetFramesInfo
(jlong ptr, jint frame) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Codec__1nGetFramesInfo
(KNativePointer ptr, KInt frame) {
SkCodec* instance = reinterpret_cast<SkCodec*>((ptr));
SkCodec::FrameInfo info;
std::vector<SkCodec::FrameInfo> frames = instance->getFrameInfo();
jobjectArray res = env->NewObjectArray(frames.size(), skija::AnimationFrameInfo::cls, nullptr);
KInteropPointerArray 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]));
skija::AutoLocal<KInteropPointer> infoObj(env, skija::AnimationFrameInfo::toJava(env, frames[i]));
env->SetObjectArrayElement(res, i, infoObj.get());
}
return res;
......@@ -113,8 +113,8 @@ extern "C" jobject org_jetbrains_skia_Codec__1nGetFramesInfo
#endif
extern "C" jint org_jetbrains_skia_Codec__1nGetRepetitionCount
(jlong ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_Codec__1nGetRepetitionCount
(KNativePointer ptr) {
SkCodec* instance = reinterpret_cast<SkCodec*>((ptr));
return instance->getRepetitionCount();
}
skiko/src/nativeMain/cpp/generated/ColorFilter.cc → skiko/src/commonMain/cpp/generated/ColorFilter.cc
View file @ 4b6f133a
......@@ -10,128 +10,128 @@
#include "SkTableColorFilter.h"
#include "common.h"
extern "C" jlong org_jetbrains_skia_ColorFilter__1nMakeComposed
(jlong outerPtr, jlong innerPtr) {
SkColorFilter* outer = reinterpret_cast<SkColorFilter*>(static_cast<uintptr_t>(outerPtr));
SkColorFilter* inner = reinterpret_cast<SkColorFilter*>(static_cast<uintptr_t>(innerPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorFilter__1nMakeComposed
(KNativePointer outerPtr, KNativePointer innerPtr) {
SkColorFilter* outer = reinterpret_cast<SkColorFilter*>((outerPtr));
SkColorFilter* inner = reinterpret_cast<SkColorFilter*>((innerPtr));
SkColorFilter* ptr = SkColorFilters::Compose(sk_ref_sp(outer), sk_ref_sp(inner)).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_ColorFilter__1nMakeBlend
(jint colorInt, jint modeInt) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorFilter__1nMakeBlend
(KInt colorInt, KInt 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);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_ColorFilter__1nMakeMatrix
(jfloatArray rowMajorArray) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorFilter__1nMakeMatrix
(KFloat* rowMajorArray) {
TODO("implement org_jetbrains_skia_ColorFilter__1nMakeMatrix");
}
#if 0
extern "C" jlong org_jetbrains_skia_ColorFilter__1nMakeMatrix
(jfloatArray rowMajorArray) {
jfloat* rowMajor = env->GetFloatArrayElements(rowMajorArray, 0);
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorFilter__1nMakeMatrix
(KFloat* rowMajorArray) {
KFloat* rowMajor = env->GetFloatArrayElements(rowMajorArray, 0);
SkColorFilter* ptr = SkColorFilters::Matrix(rowMajor).release();
env->ReleaseFloatArrayElements(rowMajorArray, rowMajor, 0);
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ColorFilter__1nMakeHSLAMatrix
(jfloatArray rowMajorArray) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorFilter__1nMakeHSLAMatrix
(KFloat* rowMajorArray) {
TODO("implement org_jetbrains_skia_ColorFilter__1nMakeHSLAMatrix");
}
#if 0
extern "C" jlong org_jetbrains_skia_ColorFilter__1nMakeHSLAMatrix
(jfloatArray rowMajorArray) {
jfloat* rowMajor = env->GetFloatArrayElements(rowMajorArray, 0);
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorFilter__1nMakeHSLAMatrix
(KFloat* rowMajorArray) {
KFloat* rowMajor = env->GetFloatArrayElements(rowMajorArray, 0);
SkColorFilter* ptr = SkColorFilters::HSLAMatrix(rowMajor).release();
env->ReleaseFloatArrayElements(rowMajorArray, rowMajor, 0);
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ColorFilter__1nGetLinearToSRGBGamma
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorFilter__1nGetLinearToSRGBGamma
() {
SkColorFilter* ptr = SkColorFilters::LinearToSRGBGamma().release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_ColorFilter__1nGetSRGBToLinearGamma
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorFilter__1nGetSRGBToLinearGamma
() {
SkColorFilter* ptr = SkColorFilters::SRGBToLinearGamma().release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_ColorFilter__1nMakeLerp
(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));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorFilter__1nMakeLerp
(KFloat t, KNativePointer dstPtr, KNativePointer srcPtr) {
SkColorFilter* dst = reinterpret_cast<SkColorFilter*>((dstPtr));
SkColorFilter* src = reinterpret_cast<SkColorFilter*>((srcPtr));
SkColorFilter* ptr = SkColorFilters::Lerp(t, sk_ref_sp(dst), sk_ref_sp(src)).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_ColorFilter__1nMakeLighting
(jint mul, jint add) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorFilter__1nMakeLighting
(KInt mul, KInt add) {
SkColorFilter* ptr = SkColorMatrixFilter::MakeLightingFilter(mul, add).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_ColorFilter__1nMakeHighContrast
(jboolean grayscale, jint inverionModeInt, jfloat contrast) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorFilter__1nMakeHighContrast
(KBoolean grayscale, KInt inverionModeInt, KFloat contrast) {
SkHighContrastConfig config(grayscale, static_cast<SkHighContrastConfig::InvertStyle>(inverionModeInt), contrast);
SkColorFilter* ptr = SkHighContrastFilter::Make(config).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_ColorFilter__1nMakeTable
(jbyteArray tableArray) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorFilter__1nMakeTable
(KByte* tableArray) {
TODO("implement org_jetbrains_skia_ColorFilter__1nMakeTable");
}
#if 0
extern "C" jlong org_jetbrains_skia_ColorFilter__1nMakeTable
(jbyteArray tableArray) {
jbyte* table = env->GetByteArrayElements(tableArray, 0);
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorFilter__1nMakeTable
(KByte* tableArray) {
KByte* 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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
typedef void* KPointer;
typedef void* KInteropPointer;
extern "C" KPointer org_jetbrains_skia_ColorFilter__nMakeTableARGB
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_ColorFilter__nMakeTableARGB
(uint8_t* arrayA,
jint arrayASize,
KInt arrayASize,
uint8_t* arrayR,
jint arrayRSize,
KInt arrayRSize,
uint8_t* arrayG,
jint arrayGSize,
KInt arrayGSize,
uint8_t* arrayB,
jint arrayBSize
KInt arrayBSize
) {
SkColorFilter* ptr = SkTableColorFilter::MakeARGB(arrayA, arrayR, arrayG, arrayB).release();
return ptr;
}
#if 0
extern "C" jlong org_jetbrains_skia_ColorFilter__1nMakeTableARGB
(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;
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorFilter__1nMakeTableARGB
(KByte* arrayA, KByte* arrayR, KByte* arrayG, KByte* arrayB) {
KByte* a = arrayA ? env->GetByteArrayElements(arrayA, 0) : nullptr;
KByte* r = arrayR ? env->GetByteArrayElements(arrayR, 0) : nullptr;
KByte* g = arrayG ? env->GetByteArrayElements(arrayG, 0) : nullptr;
KByte* 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();
......@@ -140,13 +140,13 @@ extern "C" jlong org_jetbrains_skia_ColorFilter__1nMakeTableARGB
if (arrayG) env->ReleaseByteArrayElements(arrayG, g, 0);
if (arrayB) env->ReleaseByteArrayElements(arrayB, b, 0);
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ColorFilter__1nMakeOverdraw
(jint c0, jint c1, jint c2, jint c3, jint c4, jint c5) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorFilter__1nMakeOverdraw
(KInt c0, KInt c1, KInt c2, KInt c3, KInt c4, KInt c5) {
SkColor colors[6];
colors[0] = c0;
colors[1] = c1;
......@@ -155,11 +155,11 @@ extern "C" jlong org_jetbrains_skia_ColorFilter__1nMakeOverdraw
colors[4] = c4;
colors[5] = c5;
SkColorFilter* ptr = SkOverdrawColorFilter::MakeWithSkColors(colors).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_ColorFilter__1nGetLuma
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorFilter__1nGetLuma
() {
SkColorFilter* ptr = SkLumaColorFilter::Make().release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
skiko/src/nativeMain/cpp/generated/ColorSpace.cc → skiko/src/commonMain/cpp/generated/ColorSpace.cc
View file @ 4b6f133a
......@@ -10,30 +10,30 @@ static void unrefColorSpace(SkColorSpace* ptr) {
ptr->unref();
}
extern "C" jlong org_jetbrains_skia_ColorSpace__1nGetFinalizer() {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&unrefColorSpace));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorSpace__1nGetFinalizer() {
return reinterpret_cast<KNativePointer>((&unrefColorSpace));
}
extern "C" jlong org_jetbrains_skia_ColorSpace__1nMakeSRGB() {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorSpace__1nMakeSRGB() {
SkColorSpace* ptr = SkColorSpace::MakeSRGB().release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_ColorSpace__1nMakeSRGBLinear() {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorSpace__1nMakeSRGBLinear() {
SkColorSpace* ptr = SkColorSpace::MakeSRGBLinear().release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_ColorSpace__1nMakeDisplayP3() {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ColorSpace__1nMakeDisplayP3() {
SkColorSpace* ptr = SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB, SkNamedGamut::kDisplayP3).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" void org_jetbrains_skia_ColorSpace__nConvert(
jlong fromPtr, jlong toPtr, float r, float g, float b, float a, float* result) {
SkColorSpace* from = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(fromPtr));
SkColorSpace* to = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(toPtr));
SKIKO_EXPORT void org_jetbrains_skia_ColorSpace__nConvert(
KNativePointer fromPtr, KNativePointer toPtr, float r, float g, float b, float a, float* result) {
SkColorSpace* from = reinterpret_cast<SkColorSpace*>((fromPtr));
SkColorSpace* to = reinterpret_cast<SkColorSpace*>((toPtr));
skcms_TransferFunction fromFn;
from->transferFn(&fromFn);
......@@ -48,20 +48,20 @@ extern "C" void org_jetbrains_skia_ColorSpace__nConvert(
}
extern "C" jlong org_jetbrains_skia_ColorSpace__1nIsGammaCloseToSRGB
(jlong ptr) {
SkColorSpace* instance = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_ColorSpace__1nIsGammaCloseToSRGB
(KNativePointer ptr) {
SkColorSpace* instance = reinterpret_cast<SkColorSpace*>((ptr));
return instance->gammaCloseToSRGB();
}
extern "C" jlong org_jetbrains_skia_ColorSpace__1nIsGammaLinear
(jlong ptr) {
SkColorSpace* instance = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_ColorSpace__1nIsGammaLinear
(KNativePointer ptr) {
SkColorSpace* instance = reinterpret_cast<SkColorSpace*>((ptr));
return instance->gammaIsLinear();
}
extern "C" jlong org_jetbrains_skia_ColorSpace__1nIsSRGB
(jlong ptr) {
SkColorSpace* instance = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_ColorSpace__1nIsSRGB
(KNativePointer ptr) {
SkColorSpace* instance = reinterpret_cast<SkColorSpace*>((ptr));
return instance->isSRGB();
}
skiko/src/nativeMain/cpp/generated/ColorType.cc → skiko/src/commonMain/cpp/generated/ColorType.cc
View file @ 4b6f133a
......@@ -4,7 +4,7 @@
#include "SkImageInfo.h"
#include "common.h"
extern "C" jlong org_jetbrains_skia_ColorType__1nIsAlwaysOpaque
(jint value) {
SKIKO_EXPORT KBoolean org_jetbrains_skia_ColorType__1nIsAlwaysOpaque
(KInt value) {
return SkColorTypeIsAlwaysOpaque(static_cast<SkColorType>(value));
}
skiko/src/commonMain/cpp/generated/Data.cc 0 → 100644
View file @ 4b6f133a
// This file has been auto generated.
#include "SkData.h"
#include "common.h"
static void deleteData(SkData* data) {
// std::cout << "Deleting [SkData " << data << "]" << std::endl;
data->unref();
}
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Data__1nGetFinalizer(){
return reinterpret_cast<KNativePointer>((&deleteData));
}
SKIKO_EXPORT KInt org_jetbrains_skia_Data__1nSize
(KNativePointer ptr) {
SkData* instance = reinterpret_cast<SkData*>((ptr));
return instance->size();
}
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Data__1nToByteBuffer
(KNativePointer ptr) {
TODO("implement org_jetbrains_skia_Data__1nToByteBuffer");
}
#if 0
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Data__1nToByteBuffer
(KNativePointer ptr) {
SkData* instance = reinterpret_cast<SkData*>((ptr));
return env->NewDirectByteBuffer(instance->writable_data(), instance->size());
}
#endif
SKIKO_EXPORT KByte* org_jetbrains_skia_Data__1nBytes
(KNativePointer ptr, KNativePointer offset, KNativePointer length) {
TODO("implement org_jetbrains_skia_Data__1nBytes");
}
SKIKO_EXPORT KBoolean org_jetbrains_skia_Data__1nEquals
(KNativePointer ptr, KNativePointer otherPtr) {
SkData* instance = reinterpret_cast<SkData*>((ptr));
SkData* other = reinterpret_cast<SkData*>((otherPtr));
return instance->equals(other);
}
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Data__1nMakeFromBytes
(KByte* bytesArray, KNativePointer offset, KNativePointer length) {
TODO("implement org_jetbrains_skia_Data__1nMakeFromBytes");
}
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Data__1nMakeFromFileName
(KInteropPointer pathStr) {
TODO("implement org_jetbrains_skia_Data__1nMakeFromFileName");
}
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Data__1nMakeSubset
(KNativePointer ptr, KInt offset, KInt length) {
SkData* instance = reinterpret_cast<SkData*>((ptr));
SkData* subset = SkData::MakeSubset(instance, offset, length).release();
return reinterpret_cast<KNativePointer>(subset);
}
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Data__1nMakeEmpty() {
SkData* instance = SkData::MakeEmpty().release();
return reinterpret_cast<KNativePointer>(instance);
}
\ No newline at end of file
skiko/src/nativeMain/cpp/generated/DirectContext.cc → skiko/src/commonMain/cpp/generated/DirectContext.cc
View file @ 4b6f133a
// This file has been auto generated.
#ifndef SKIKO_WASM
#include <iostream>
#include "GrDirectContext.h"
#include "mtl/GrMtlBackendContext.h"
#include "common.h"
extern "C" jlong org_jetbrains_skia_DirectContext__1nMakeGL
SKIKO_EXPORT KNativePointer org_jetbrains_skia_DirectContext__1nMakeGL
() {
return reinterpret_cast<jlong>(GrDirectContext::MakeGL().release());
return reinterpret_cast<KNativePointer>(GrDirectContext::MakeGL().release());
}
extern "C" jlong org_jetbrains_skia_DirectContext__1nMakeMetal
SKIKO_EXPORT KNativePointer org_jetbrains_skia_DirectContext__1nMakeMetal
(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));
GrMTLHandle device = reinterpret_cast<GrMTLHandle>((devicePtr));
GrMTLHandle queue = reinterpret_cast<GrMTLHandle>((queuePtr));
backendContext.fDevice.retain(device);
backendContext.fQueue.retain(queue);
sk_sp<GrDirectContext> instance = GrDirectContext::MakeMetal(backendContext);
return reinterpret_cast<jlong>(instance.release());
return reinterpret_cast<KNativePointer>(instance.release());
}
extern "C" jlong org_jetbrains_skia_DirectContext__1nMakeDirect3D
(jlong adapterPtr, jlong devicePtr, jlong queuePtr) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_DirectContext__1nMakeDirect3D
(KNativePointer adapterPtr, KNativePointer devicePtr, KNativePointer queuePtr) {
TODO("implement org_jetbrains_skia_DirectContext__1nMakeDirect3D");
}
#if 0
extern "C" jlong org_jetbrains_skia_DirectContext__1nMakeDirect3D
(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
extern "C" void org_jetbrains_skia_DirectContext__1nFlush
(jlong ptr) {
GrDirectContext* context = reinterpret_cast<GrDirectContext*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_DirectContext__1nFlush
(KNativePointer ptr) {
GrDirectContext* context = reinterpret_cast<GrDirectContext*>((ptr));
context->flush(GrFlushInfo());
}
extern "C" void org_jetbrains_skia_DirectContext__1nSubmit
(jlong ptr, jboolean syncCpu) {
GrDirectContext* context = reinterpret_cast<GrDirectContext*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_DirectContext__1nSubmit
(KNativePointer ptr, KBoolean syncCpu) {
GrDirectContext* context = reinterpret_cast<GrDirectContext*>((ptr));
context->submit(syncCpu);
}
extern "C" void org_jetbrains_skia_DirectContext__1nReset
(jlong ptr, jint flags) {
GrDirectContext* context = reinterpret_cast<GrDirectContext*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_DirectContext__1nReset
(KNativePointer ptr, KInt flags) {
GrDirectContext* context = reinterpret_cast<GrDirectContext*>((ptr));
context->resetContext((uint32_t) flags);
}
extern "C" void org_jetbrains_skia_DirectContext__1nAbandon
(jlong ptr, jint flags) {
GrDirectContext* context = reinterpret_cast<GrDirectContext*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_DirectContext__1nAbandon
(KNativePointer ptr, KInt flags) {
GrDirectContext* context = reinterpret_cast<GrDirectContext*>((ptr));
context->abandonContext();
}
#endif
\ No newline at end of file
skiko/src/nativeMain/cpp/generated/Drawable.cc → skiko/src/commonMain/cpp/generated/Drawable.cc
View file @ 4b6f133a
......@@ -6,46 +6,46 @@
#include "common.h"
extern "C" jlong org_jetbrains_skia_Drawable__1nMake
() {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Drawable__1nMake
(){
TODO("implement org_jetbrains_skia_Drawable__1nMake");
}
#if 0
extern "C" jlong org_jetbrains_skia_Drawable__1nMake
() {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Drawable__1nMake
(){
SkijaDrawableImpl* instance = new SkijaDrawableImpl();
return reinterpret_cast<jlong>(instance);
return reinterpret_cast<KNativePointer>(instance);
}
#endif
extern "C" void org_jetbrains_skia_Drawable__1nInit
(jlong ptr) {
SKIKO_EXPORT void org_jetbrains_skia_Drawable__1nInit
(KNativePointer ptr) {
TODO("implement org_jetbrains_skia_Drawable__1nInit");
}
#if 0
extern "C" void org_jetbrains_skia_Drawable__1nInit
(jlong ptr) {
SkijaDrawableImpl* instance = reinterpret_cast<SkijaDrawableImpl*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Drawable__1nInit
(KNativePointer ptr) {
SkijaDrawableImpl* instance = reinterpret_cast<SkijaDrawableImpl*>((ptr));
instance->init(env, jthis);
}
#endif
extern "C" void org_jetbrains_skia_Drawable__1nDraw
(jlong ptr, jlong canvasPtr, jfloatArray matrixArr) {
SKIKO_EXPORT void org_jetbrains_skia_Drawable__1nDraw
(KNativePointer ptr, KNativePointer canvasPtr, KFloat* matrixArr) {
TODO("implement org_jetbrains_skia_Drawable__1nDraw");
}
#if 0
extern "C" void org_jetbrains_skia_Drawable__1nDraw
(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));
SKIKO_EXPORT void org_jetbrains_skia_Drawable__1nDraw
(KNativePointer ptr, KNativePointer canvasPtr, KFloat* matrixArr) {
SkijaDrawableImpl* instance = reinterpret_cast<SkijaDrawableImpl*>((ptr));
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
std::unique_ptr<SkMatrix> matrix = skMatrix(env, matrixArr);
instance->draw(canvas, matrix.get());
}
......@@ -53,45 +53,45 @@ extern "C" void org_jetbrains_skia_Drawable__1nDraw
extern "C" jlong org_jetbrains_skia_Drawable__1nMakePictureSnapshot
(jlong ptr) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Drawable__1nMakePictureSnapshot
(KNativePointer ptr) {
TODO("implement org_jetbrains_skia_Drawable__1nMakePictureSnapshot");
}
#if 0
extern "C" jlong org_jetbrains_skia_Drawable__1nMakePictureSnapshot
(jlong ptr) {
SkijaDrawableImpl* instance = reinterpret_cast<SkijaDrawableImpl*>(static_cast<uintptr_t>(ptr));
return reinterpret_cast<jlong>(instance->newPictureSnapshot());
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Drawable__1nMakePictureSnapshot
(KNativePointer ptr) {
SkijaDrawableImpl* instance = reinterpret_cast<SkijaDrawableImpl*>((ptr));
return reinterpret_cast<KNativePointer>(instance->newPictureSnapshot());
}
#endif
extern "C" jint org_jetbrains_skia_Drawable__1nGetGenerationId
(jlong ptr) {
SKIKO_EXPORT KInt org_jetbrains_skia_Drawable__1nGetGenerationId
(KNativePointer ptr) {
TODO("implement org_jetbrains_skia_Drawable__1nGetGenerationId");
}
#if 0
extern "C" jint org_jetbrains_skia_Drawable__1nGetGenerationId
(jlong ptr) {
SkijaDrawableImpl* instance = reinterpret_cast<SkijaDrawableImpl*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_Drawable__1nGetGenerationId
(KNativePointer ptr) {
SkijaDrawableImpl* instance = reinterpret_cast<SkijaDrawableImpl*>((ptr));
return instance->getGenerationID();
}
#endif
extern "C" void org_jetbrains_skia_Drawable__1nNotifyDrawingChanged
(jlong ptr) {
SKIKO_EXPORT void org_jetbrains_skia_Drawable__1nNotifyDrawingChanged
(KNativePointer ptr) {
TODO("implement org_jetbrains_skia_Drawable__1nNotifyDrawingChanged");
}
#if 0
extern "C" void org_jetbrains_skia_Drawable__1nNotifyDrawingChanged
(jlong ptr) {
SkijaDrawableImpl* instance = reinterpret_cast<SkijaDrawableImpl*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Drawable__1nNotifyDrawingChanged
(KNativePointer ptr) {
SkijaDrawableImpl* instance = reinterpret_cast<SkijaDrawableImpl*>((ptr));
return instance->notifyDrawingChanged();
}
#endif
......
skiko/src/nativeMain/cpp/generated/Font.cc → skiko/src/commonMain/cpp/generated/Font.cc
View file @ 4b6f133a
......@@ -11,220 +11,220 @@ static void deleteFont(SkFont* font) {
delete font;
}
extern "C" jlong org_jetbrains_skia_Font__1nGetFinalizer
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Font__1nGetFinalizer
() {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteFont));
return reinterpret_cast<KNativePointer>((&deleteFont));
}
extern "C" jlong org_jetbrains_skia_Font__1nMakeDefault
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Font__1nMakeDefault
() {
SkFont* obj = new SkFont();
return reinterpret_cast<jlong>(obj);
return reinterpret_cast<KNativePointer>(obj);
}
extern "C" jlong org_jetbrains_skia_Font__1nMakeTypeface
(jlong typefacePtr) {
SkTypeface* typeface = reinterpret_cast<SkTypeface*>(static_cast<uintptr_t>(typefacePtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Font__1nMakeTypeface
(KNativePointer typefacePtr) {
SkTypeface* typeface = reinterpret_cast<SkTypeface*>((typefacePtr));
SkFont* obj = new SkFont(sk_ref_sp<SkTypeface>(typeface));
return reinterpret_cast<jlong>(obj);
return reinterpret_cast<KNativePointer>(obj);
}
extern "C" jlong org_jetbrains_skia_Font__1nMakeTypefaceSize
(jlong typefacePtr, jfloat size) {
SkTypeface* typeface = reinterpret_cast<SkTypeface*>(static_cast<uintptr_t>(typefacePtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Font__1nMakeTypefaceSize
(KNativePointer typefacePtr, KFloat size) {
SkTypeface* typeface = reinterpret_cast<SkTypeface*>((typefacePtr));
SkFont* obj = new SkFont(sk_ref_sp<SkTypeface>(typeface), size);
return reinterpret_cast<jlong>(obj);
return reinterpret_cast<KNativePointer>(obj);
}
extern "C" jlong org_jetbrains_skia_Font__1nMakeTypefaceSizeScaleSkew
(jlong typefacePtr, jfloat size, jfloat scaleX, jfloat skewX) {
SkTypeface* typeface = reinterpret_cast<SkTypeface*>(static_cast<uintptr_t>(typefacePtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Font__1nMakeTypefaceSizeScaleSkew
(KNativePointer typefacePtr, KFloat size, KFloat scaleX, KFloat skewX) {
SkTypeface* typeface = reinterpret_cast<SkTypeface*>((typefacePtr));
SkFont* obj = new SkFont(sk_ref_sp<SkTypeface>(typeface), size, scaleX, skewX);
return reinterpret_cast<jlong>(obj);
return reinterpret_cast<KNativePointer>(obj);
}
extern "C" jlong org_jetbrains_skia_Font__1nMakeClone
(jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Font__1nMakeClone
(KNativePointer ptr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
SkFont* clone = new SkFont(*instance);
return reinterpret_cast<jlong>(clone);
return reinterpret_cast<KNativePointer>(clone);
}
extern "C" jboolean org_jetbrains_skia_Font__1nEquals
(jlong ptr, jlong otherPtr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SkFont* other = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(otherPtr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Font__1nEquals
(KNativePointer ptr, KNativePointer otherPtr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
SkFont* other = reinterpret_cast<SkFont*>((otherPtr));
return *instance == *other;
}
extern "C" jboolean org_jetbrains_skia_Font__1nIsAutoHintingForced
(jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Font__1nIsAutoHintingForced
(KNativePointer ptr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
return instance->isForceAutoHinting();
}
extern "C" jboolean org_jetbrains_skia_Font__1nAreBitmapsEmbedded
(jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Font__1nAreBitmapsEmbedded
(KNativePointer ptr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
return instance->isEmbeddedBitmaps();
}
extern "C" jboolean org_jetbrains_skia_Font__1nIsSubpixel
(jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Font__1nIsSubpixel
(KNativePointer ptr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
return instance->isSubpixel();
}
extern "C" jboolean org_jetbrains_skia_Font__1nAreMetricsLinear
(jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Font__1nAreMetricsLinear
(KNativePointer ptr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
return instance->isLinearMetrics();
}
extern "C" jboolean org_jetbrains_skia_Font__1nIsEmboldened
(jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Font__1nIsEmboldened
(KNativePointer ptr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
return instance->isEmbolden();
}
extern "C" jboolean org_jetbrains_skia_Font__1nIsBaselineSnapped
(jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Font__1nIsBaselineSnapped
(KNativePointer ptr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
return instance->isBaselineSnap();
}
extern "C" void org_jetbrains_skia_Font__1nSetAutoHintingForced
(jlong ptr, jboolean value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Font__1nSetAutoHintingForced
(KNativePointer ptr, KBoolean value) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
instance->setForceAutoHinting(value);
}
extern "C" void org_jetbrains_skia_Font__1nSetBitmapsEmbedded
(jlong ptr, jboolean value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Font__1nSetBitmapsEmbedded
(KNativePointer ptr, KBoolean value) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
instance->setEmbeddedBitmaps(value);
}
extern "C" void org_jetbrains_skia_Font__1nSetSubpixel
(jlong ptr, jboolean value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Font__1nSetSubpixel
(KNativePointer ptr, KBoolean value) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
instance->setSubpixel(value);
}
extern "C" void org_jetbrains_skia_Font__1nSetMetricsLinear
(jlong ptr, jboolean value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Font__1nSetMetricsLinear
(KNativePointer ptr, KBoolean value) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
instance->setLinearMetrics(value);
}
extern "C" void org_jetbrains_skia_Font__1nSetEmboldened
(jlong ptr, jboolean value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Font__1nSetEmboldened
(KNativePointer ptr, KBoolean value) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
instance->setEmbolden(value);
}
extern "C" void org_jetbrains_skia_Font__1nSetBaselineSnapped
(jlong ptr, jboolean value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Font__1nSetBaselineSnapped
(KNativePointer ptr, KBoolean value) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
instance->setBaselineSnap(value);
}
extern "C" jint org_jetbrains_skia_Font__1nGetEdging
(jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
return static_cast<jint>(instance->getEdging());
SKIKO_EXPORT KInt org_jetbrains_skia_Font__1nGetEdging
(KNativePointer ptr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
return static_cast<KInt>(instance->getEdging());
}
extern "C" void org_jetbrains_skia_Font__1nSetEdging
(jlong ptr, jint value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Font__1nSetEdging
(KNativePointer ptr, KInt value) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
instance->setEdging(static_cast<SkFont::Edging>(value));
}
extern "C" jint org_jetbrains_skia_Font__1nGetHinting
(jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
return static_cast<jint>(instance->getHinting());
SKIKO_EXPORT KInt org_jetbrains_skia_Font__1nGetHinting
(KNativePointer ptr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
return static_cast<KInt>(instance->getHinting());
}
extern "C" void org_jetbrains_skia_Font__1nSetHinting
(jlong ptr, jint value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Font__1nSetHinting
(KNativePointer ptr, KInt value) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
instance->setHinting(static_cast<SkFontHinting>(value));
}
extern "C" jlong org_jetbrains_skia_Font__1nGetTypeface
(jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Font__1nGetTypeface
(KNativePointer ptr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
SkTypeface* typeface = instance->refTypeface().release();
return reinterpret_cast<jlong>(typeface);
return reinterpret_cast<KNativePointer>(typeface);
}
extern "C" jlong org_jetbrains_skia_Font__1nGetTypefaceOrDefault
(jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Font__1nGetTypefaceOrDefault
(KNativePointer ptr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
SkTypeface* typeface = instance->refTypefaceOrDefault().release();
return reinterpret_cast<jlong>(typeface);
return reinterpret_cast<KNativePointer>(typeface);
}
extern "C" jfloat org_jetbrains_skia_Font__1nGetSize
(jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KFloat org_jetbrains_skia_Font__1nGetSize
(KNativePointer ptr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
return instance->getSize();
}
extern "C" jfloat org_jetbrains_skia_Font__1nGetScaleX
(jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KFloat org_jetbrains_skia_Font__1nGetScaleX
(KNativePointer ptr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
return instance->getScaleX();
}
extern "C" jfloat org_jetbrains_skia_Font__1nGetSkewX
(jlong ptr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KFloat org_jetbrains_skia_Font__1nGetSkewX
(KNativePointer ptr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
return instance->getSkewX();
}
extern "C" void org_jetbrains_skia_Font__1nSetTypeface
(jlong ptr, jlong typefacePtr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SkTypeface* typeface = reinterpret_cast<SkTypeface*>(static_cast<uintptr_t>(typefacePtr));
SKIKO_EXPORT void org_jetbrains_skia_Font__1nSetTypeface
(KNativePointer ptr, KNativePointer typefacePtr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
SkTypeface* typeface = reinterpret_cast<SkTypeface*>((typefacePtr));
instance->setTypeface(sk_ref_sp(typeface));
}
extern "C" void org_jetbrains_skia_Font__1nSetSize
(jlong ptr, jfloat value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Font__1nSetSize
(KNativePointer ptr, KFloat value) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
instance->setSize(value);
}
extern "C" void org_jetbrains_skia_Font__1nSetScaleX
(jlong ptr, jfloat value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Font__1nSetScaleX
(KNativePointer ptr, KFloat value) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
instance->setScaleX(value);
}
extern "C" void org_jetbrains_skia_Font__1nSetSkewX
(jlong ptr, jfloat value) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_Font__1nSetSkewX
(KNativePointer ptr, KFloat value) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
instance->setSkewX(value);
}
extern "C" jshortArray org_jetbrains_skia_Font__1nGetStringGlyphs
(jlong ptr, jstring str) {
SKIKO_EXPORT KShort* org_jetbrains_skia_Font__1nGetStringGlyphs
(KNativePointer ptr, KInteropPointer str) {
TODO("implement org_jetbrains_skia_Font__1nGetStringGlyphs");
}
#if 0
extern "C" jshortArray org_jetbrains_skia_Font__1nGetStringGlyphs
(jlong ptr, jstring str) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KShort* org_jetbrains_skia_Font__1nGetStringGlyphs
(KNativePointer ptr, KInteropPointer str) {
SkFont* instance = reinterpret_cast<SkFont*>((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);
const KChar* chars = env->GetStringCritical(str, nullptr);
int count = instance->textToGlyphs(chars, len * sizeof(KChar), SkTextEncoding::kUTF16, nullptr, 0);
std::vector<short> glyphs(count);
instance->textToGlyphs(chars, len * sizeof(jchar), SkTextEncoding::kUTF16, reinterpret_cast<SkGlyphID*>(glyphs.data()), count);
instance->textToGlyphs(chars, len * sizeof(KChar), SkTextEncoding::kUTF16, reinterpret_cast<SkGlyphID*>(glyphs.data()), count);
env->ReleaseStringCritical(str, chars);
return javaShortArray(env, glyphs);
}
......@@ -232,18 +232,18 @@ extern "C" jshortArray org_jetbrains_skia_Font__1nGetStringGlyphs
extern "C" jshortArray org_jetbrains_skia_Font__1nGetUTF32Glyphs
(jlong ptr, jintArray uniArr) {
SKIKO_EXPORT KShort* org_jetbrains_skia_Font__1nGetUTF32Glyphs
(KNativePointer ptr, KInt* uniArr) {
TODO("implement org_jetbrains_skia_Font__1nGetUTF32Glyphs");
}
#if 0
extern "C" jshortArray org_jetbrains_skia_Font__1nGetUTF32Glyphs
(jlong ptr, jintArray uniArr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KShort* org_jetbrains_skia_Font__1nGetUTF32Glyphs
(KNativePointer ptr, KInt* uniArr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
int count = env->GetArrayLength(uniArr);
std::vector<jshort> glyphs(count);
jint* uni = env->GetIntArrayElements(uniArr, nullptr);
std::vector<KShort> glyphs(count);
KInt* 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);
......@@ -251,25 +251,25 @@ extern "C" jshortArray org_jetbrains_skia_Font__1nGetUTF32Glyphs
#endif
extern "C" jshort org_jetbrains_skia_Font__1nGetUTF32Glyph
(jlong ptr, jint uni) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KShort org_jetbrains_skia_Font__1nGetUTF32Glyph
(KNativePointer ptr, KInt uni) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
return instance->unicharToGlyph(uni);
}
extern "C" jint org_jetbrains_skia_Font__1nGetStringGlyphsCount
(jlong ptr, jstring str) {
SKIKO_EXPORT KInt org_jetbrains_skia_Font__1nGetStringGlyphsCount
(KNativePointer ptr, KInteropPointer str) {
TODO("implement org_jetbrains_skia_Font__1nGetStringGlyphsCount");
}
#if 0
extern "C" jint org_jetbrains_skia_Font__1nGetStringGlyphsCount
(jlong ptr, jstring str) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_Font__1nGetStringGlyphsCount
(KNativePointer ptr, KInteropPointer str) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
jsize len = env->GetStringLength(str);
const jchar* chars = env->GetStringCritical(str, nullptr);
int count = instance->countText(chars, len * sizeof(jchar), SkTextEncoding::kUTF16);
const KChar* chars = env->GetStringCritical(str, nullptr);
int count = instance->countText(chars, len * sizeof(KChar), SkTextEncoding::kUTF16);
env->ReleaseStringCritical(str, chars);
return count;
}
......@@ -277,20 +277,20 @@ extern "C" jint org_jetbrains_skia_Font__1nGetStringGlyphsCount
extern "C" jobject org_jetbrains_skia_Font__1nMeasureText
(jlong ptr, jstring str, jlong paintPtr) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Font__1nMeasureText
(KNativePointer ptr, KInteropPointer str, KNativePointer paintPtr) {
TODO("implement org_jetbrains_skia_Font__1nMeasureText");
}
#if 0
extern "C" jobject org_jetbrains_skia_Font__1nMeasureText
(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));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Font__1nMeasureText
(KNativePointer ptr, KInteropPointer str, KNativePointer paintPtr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
jsize len = env->GetStringLength(str);
const jchar* chars = env->GetStringCritical(str, nullptr);
const KChar* chars = env->GetStringCritical(str, nullptr);
SkRect bounds;
instance->measureText(chars, len * sizeof(jchar), SkTextEncoding::kUTF16, &bounds, paint);
instance->measureText(chars, len * sizeof(KChar), SkTextEncoding::kUTF16, &bounds, paint);
env->ReleaseStringCritical(str, chars);
return skija::Rect::fromSkRect(env, bounds);
}
......@@ -298,19 +298,19 @@ extern "C" jobject org_jetbrains_skia_Font__1nMeasureText
extern "C" jfloat org_jetbrains_skia_Font__1nMeasureTextWidth
(jlong ptr, jstring str, jlong paintPtr) {
SKIKO_EXPORT KFloat org_jetbrains_skia_Font__1nMeasureTextWidth
(KNativePointer ptr, KInteropPointer str, KNativePointer paintPtr) {
TODO("implement org_jetbrains_skia_Font__1nMeasureTextWidth");
}
#if 0
extern "C" jfloat org_jetbrains_skia_Font__1nMeasureTextWidth
(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));
SKIKO_EXPORT KFloat org_jetbrains_skia_Font__1nMeasureTextWidth
(KNativePointer ptr, KInteropPointer str, KNativePointer paintPtr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
SkPaint* paint = reinterpret_cast<SkPaint*>((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);
const KChar* chars = env->GetStringCritical(str, nullptr);
float width = instance->measureText(chars, len * sizeof(KChar), SkTextEncoding::kUTF16, nullptr, paint);
env->ReleaseStringCritical(str, chars);
return width;
}
......@@ -318,18 +318,18 @@ extern "C" jfloat org_jetbrains_skia_Font__1nMeasureTextWidth
extern "C" jfloatArray org_jetbrains_skia_Font__1nGetWidths
(jlong ptr, jshortArray glyphsArr) {
SKIKO_EXPORT KFloat* org_jetbrains_skia_Font__1nGetWidths
(KNativePointer ptr, KShort* glyphsArr) {
TODO("implement org_jetbrains_skia_Font__1nGetWidths");
}
#if 0
extern "C" jfloatArray org_jetbrains_skia_Font__1nGetWidths
(jlong ptr, jshortArray glyphsArr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KFloat* org_jetbrains_skia_Font__1nGetWidths
(KNativePointer ptr, KShort* glyphsArr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
int count = env->GetArrayLength(glyphsArr);
std::vector<jfloat> widths(count);
jshort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
std::vector<KFloat> widths(count);
KShort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
instance->getWidths(reinterpret_cast<SkGlyphID*>(glyphs), count, widths.data());
env->ReleaseShortArrayElements(glyphsArr, glyphs, 0);
return javaFloatArray(env, widths);
......@@ -338,25 +338,25 @@ extern "C" jfloatArray org_jetbrains_skia_Font__1nGetWidths
extern "C" jobjectArray org_jetbrains_skia_Font__1nGetBounds
(jlong ptr, jshortArray glyphsArr, jlong paintPtr) {
SKIKO_EXPORT KInteropPointerArray org_jetbrains_skia_Font__1nGetBounds
(KNativePointer ptr, KShort* glyphsArr, KNativePointer paintPtr) {
TODO("implement org_jetbrains_skia_Font__1nGetBounds");
}
#if 0
extern "C" jobjectArray org_jetbrains_skia_Font__1nGetBounds
(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));
SKIKO_EXPORT KInteropPointerArray org_jetbrains_skia_Font__1nGetBounds
(KNativePointer ptr, KShort* glyphsArr, KNativePointer paintPtr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
int count = env->GetArrayLength(glyphsArr);
std::vector<SkRect> bounds(count);
jshort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
KShort* 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);
KInteropPointerArray 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]));
skija::AutoLocal<KInteropPointer> boundsObj(env, skija::Rect::fromSkRect(env, bounds[i]));
env->SetObjectArrayElement(res, i, boundsObj.get());
}
......@@ -366,19 +366,19 @@ extern "C" jobjectArray org_jetbrains_skia_Font__1nGetBounds
extern "C" jobjectArray org_jetbrains_skia_Font__1nGetPositions
(jlong ptr, jshortArray glyphsArr, jfloat dx, jfloat dy) {
SKIKO_EXPORT KInteropPointerArray org_jetbrains_skia_Font__1nGetPositions
(KNativePointer ptr, KShort* glyphsArr, KFloat dx, KFloat dy) {
TODO("implement org_jetbrains_skia_Font__1nGetPositions");
}
#if 0
extern "C" jobjectArray org_jetbrains_skia_Font__1nGetPositions
(jlong ptr, jshortArray glyphsArr, jfloat dx, jfloat dy) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointerArray org_jetbrains_skia_Font__1nGetPositions
(KNativePointer ptr, KShort* glyphsArr, KFloat dx, KFloat dy) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
int count = env->GetArrayLength(glyphsArr);
std::vector<SkPoint> positions(count);
jshort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
KShort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
instance->getPos(reinterpret_cast<SkGlyphID*>(glyphs), count, positions.data(), {dx, dy});
env->ReleaseShortArrayElements(glyphsArr, glyphs, 0);
......@@ -388,18 +388,18 @@ extern "C" jobjectArray org_jetbrains_skia_Font__1nGetPositions
extern "C" jfloatArray org_jetbrains_skia_Font__1nGetXPositions
(jlong ptr, jshortArray glyphsArr, jfloat dx) {
SKIKO_EXPORT KFloat* org_jetbrains_skia_Font__1nGetXPositions
(KNativePointer ptr, KShort* glyphsArr, KFloat dx) {
TODO("implement org_jetbrains_skia_Font__1nGetXPositions");
}
#if 0
extern "C" jfloatArray org_jetbrains_skia_Font__1nGetXPositions
(jlong ptr, jshortArray glyphsArr, jfloat dx) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KFloat* org_jetbrains_skia_Font__1nGetXPositions
(KNativePointer ptr, KShort* glyphsArr, KFloat dx) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
int count = env->GetArrayLength(glyphsArr);
std::vector<jfloat> positions(count);
jshort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
std::vector<KFloat> positions(count);
KShort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
instance->getXPos(reinterpret_cast<SkGlyphID*>(glyphs), count, positions.data(), dx);
env->ReleaseShortArrayElements(glyphsArr, glyphs, 0);
return javaFloatArray(env, positions);
......@@ -407,30 +407,30 @@ extern "C" jfloatArray org_jetbrains_skia_Font__1nGetXPositions
#endif
extern "C" jlong org_jetbrains_skia_Font__1nGetPath
(jlong ptr, jshort glyph) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Font__1nGetPath
(KNativePointer ptr, KShort glyph) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
SkPath* path = new SkPath();
instance->getPath(glyph, path);
return reinterpret_cast<jlong>(path);
return reinterpret_cast<KNativePointer>(path);
}
extern "C" jobjectArray org_jetbrains_skia_Font__1nGetPaths
(jlong ptr, jshortArray glyphsArr) {
SKIKO_EXPORT KInteropPointerArray org_jetbrains_skia_Font__1nGetPaths
(KNativePointer ptr, KShort* glyphsArr) {
TODO("implement org_jetbrains_skia_Font__1nGetPaths");
}
#if 0
extern "C" jobjectArray org_jetbrains_skia_Font__1nGetPaths
(jlong ptr, jshortArray glyphsArr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointerArray org_jetbrains_skia_Font__1nGetPaths
(KNativePointer ptr, KShort* glyphsArr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
int count = env->GetArrayLength(glyphsArr);
jshort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
KShort* glyphs = env->GetShortArrayElements(glyphsArr, nullptr);
struct Ctx {
jobjectArray paths;
KInteropPointerArray paths;
jsize idx;
JNIEnv* env;
} ctx = { env->NewObjectArray(count, skija::Path::cls, nullptr), 0, env };
......@@ -440,7 +440,7 @@ extern "C" jobjectArray org_jetbrains_skia_Font__1nGetPaths
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));
KInteropPointer pathObj = ctx->env->NewObject(skija::Path::cls, skija::Path::ctor, reinterpret_cast<KNativePointer>(path));
ctx->env->SetObjectArrayElement(ctx->paths, ctx->idx, pathObj);
ctx->env->DeleteLocalRef(pathObj);
++ctx->idx;
......@@ -454,15 +454,15 @@ extern "C" jobjectArray org_jetbrains_skia_Font__1nGetPaths
extern "C" jobject org_jetbrains_skia_Font__1nGetMetrics
(jlong ptr, jshortArray glyphsArr) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Font__1nGetMetrics
(KNativePointer ptr, KShort* glyphsArr) {
TODO("implement org_jetbrains_skia_Font__1nGetMetrics");
}
#if 0
extern "C" jobject org_jetbrains_skia_Font__1nGetMetrics
(jlong ptr, jshortArray glyphsArr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Font__1nGetMetrics
(KNativePointer ptr, KShort* glyphsArr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
SkFontMetrics m;
instance->getMetrics(&m);
return skija::FontMetrics::toJava(env, m);
......@@ -471,15 +471,15 @@ extern "C" jobject org_jetbrains_skia_Font__1nGetMetrics
extern "C" jfloat org_jetbrains_skia_Font__1nGetSpacing
(jlong ptr, jshortArray glyphsArr) {
SKIKO_EXPORT KFloat org_jetbrains_skia_Font__1nGetSpacing
(KNativePointer ptr, KShort* glyphsArr) {
TODO("implement org_jetbrains_skia_Font__1nGetSpacing");
}
#if 0
extern "C" jfloat org_jetbrains_skia_Font__1nGetSpacing
(jlong ptr, jshortArray glyphsArr) {
SkFont* instance = reinterpret_cast<SkFont*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KFloat org_jetbrains_skia_Font__1nGetSpacing
(KNativePointer ptr, KShort* glyphsArr) {
SkFont* instance = reinterpret_cast<SkFont*>((ptr));
return instance->getSpacing();
}
#endif
......
skiko/src/nativeMain/cpp/generated/FontMgr.cc → skiko/src/commonMain/cpp/generated/FontMgr.cc
View file @ 4b6f133a
......@@ -7,22 +7,22 @@
#include "SkFontMgr.h"
#include "common.h"
extern "C" jint org_jetbrains_skia_FontMgr__1nGetFamiliesCount
(jlong ptr) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_FontMgr__1nGetFamiliesCount
(KNativePointer ptr) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>((ptr));
return instance->countFamilies();
}
extern "C" jstring org_jetbrains_skia_FontMgr__1nGetFamilyName
(jlong ptr, jint index) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_FontMgr__1nGetFamilyName
(KNativePointer ptr, KInt index) {
TODO("implement org_jetbrains_skia_FontMgr__1nGetFamilyName");
}
#if 0
extern "C" jstring org_jetbrains_skia_FontMgr__1nGetFamilyName
(jlong ptr, jint index) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_FontMgr__1nGetFamilyName
(KNativePointer ptr, KInt index) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>((ptr));
SkString familyName;
instance->getFamilyName(index, &familyName);
return javaString(env, familyName);
......@@ -30,57 +30,57 @@ extern "C" jstring org_jetbrains_skia_FontMgr__1nGetFamilyName
#endif
extern "C" jlong org_jetbrains_skia_FontMgr__1nMakeStyleSet
(jlong ptr, jint index) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_FontMgr__1nMakeStyleSet
(KNativePointer ptr, KInt index) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>((ptr));
SkFontStyleSet* styleSet = instance->createStyleSet(index);
return reinterpret_cast<jlong>(styleSet);
return reinterpret_cast<KNativePointer>(styleSet);
}
extern "C" jlong org_jetbrains_skia_FontMgr__1nMatchFamily
(jlong ptr, jstring familyNameStr) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_FontMgr__1nMatchFamily
(KNativePointer ptr, KInteropPointer familyNameStr) {
TODO("implement org_jetbrains_skia_FontMgr__1nMatchFamily");
}
#if 0
extern "C" jlong org_jetbrains_skia_FontMgr__1nMatchFamily
(jlong ptr, jstring familyNameStr) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_FontMgr__1nMatchFamily
(KNativePointer ptr, KInteropPointer familyNameStr) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>((ptr));
SkString familyName = skString(env, familyNameStr);
SkFontStyleSet* styleSet = instance->matchFamily(familyName.c_str());
return reinterpret_cast<jlong>(styleSet);
return reinterpret_cast<KNativePointer>(styleSet);
}
#endif
extern "C" jlong org_jetbrains_skia_FontMgr__1nMatchFamilyStyle
(jlong ptr, jstring familyNameStr, jint fontStyle) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_FontMgr__1nMatchFamilyStyle
(KNativePointer ptr, KInteropPointer familyNameStr, KInt fontStyle) {
TODO("implement org_jetbrains_skia_FontMgr__1nMatchFamilyStyle");
}
#if 0
extern "C" jlong org_jetbrains_skia_FontMgr__1nMatchFamilyStyle
(jlong ptr, jstring familyNameStr, jint fontStyle) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_FontMgr__1nMatchFamilyStyle
(KNativePointer ptr, KInteropPointer familyNameStr, KInt fontStyle) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>((ptr));
SkString familyName = skString(env, familyNameStr);
SkTypeface* typeface = instance->matchFamilyStyle(familyName.c_str(), skija::FontStyle::fromJava(fontStyle));
return reinterpret_cast<jlong>(typeface);
return reinterpret_cast<KNativePointer>(typeface);
}
#endif
extern "C" jlong org_jetbrains_skia_FontMgr__1nMatchFamilyStyleCharacter
(jlong ptr, jstring familyNameStr, jint fontStyle, jobjectArray bcp47Array, jint character) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_FontMgr__1nMatchFamilyStyleCharacter
(KNativePointer ptr, KInteropPointer familyNameStr, KInt fontStyle, KInteropPointerArray bcp47Array, KInt character) {
TODO("implement org_jetbrains_skia_FontMgr__1nMatchFamilyStyleCharacter");
}
#if 0
extern "C" jlong org_jetbrains_skia_FontMgr__1nMatchFamilyStyleCharacter
(jlong ptr, jstring familyNameStr, jint fontStyle, jobjectArray bcp47Array, jint character) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_FontMgr__1nMatchFamilyStyleCharacter
(KNativePointer ptr, KInteropPointer familyNameStr, KInt fontStyle, KInteropPointerArray bcp47Array, KInt character) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>((ptr));
SkString familyName = skString(env, familyNameStr);
......@@ -91,21 +91,21 @@ extern "C" jlong org_jetbrains_skia_FontMgr__1nMatchFamilyStyleCharacter
SkTypeface* typeface = instance->matchFamilyStyleCharacter(familyName.c_str(), skija::FontStyle::fromJava(fontStyle), bcp47.data(), (int) bcp47.size(), character);
return reinterpret_cast<jlong>(typeface);
return reinterpret_cast<KNativePointer>(typeface);
}
#endif
extern "C" jlong org_jetbrains_skia_FontMgr__1nMakeFromData
(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));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_FontMgr__1nMakeFromData
(KNativePointer ptr, KNativePointer dataPtr, KInt ttcIndex) {
SkFontMgr* instance = reinterpret_cast<SkFontMgr*>((ptr));
SkData* data = reinterpret_cast<SkData*>((dataPtr));
SkTypeface* typeface = instance->makeFromData(sk_ref_sp(data), ttcIndex).release();
return reinterpret_cast<jlong>(typeface);
return reinterpret_cast<KNativePointer>(typeface);
}
extern "C" jlong org_jetbrains_skia_FontMgr__1nDefault
SKIKO_EXPORT KNativePointer org_jetbrains_skia_FontMgr__1nDefault
() {
SkFontMgr* instance = SkFontMgr::RefDefault().release();
return reinterpret_cast<jlong>(instance);
return reinterpret_cast<KNativePointer>(instance);
}
skiko/src/nativeMain/cpp/generated/FontStyleSet.cc → skiko/src/commonMain/cpp/generated/FontStyleSet.cc
View file @ 4b6f133a
......@@ -6,36 +6,36 @@
#include "SkFontMgr.h"
#include "common.h"
extern "C" jlong org_jetbrains_skia_FontStyleSet__1nMakeEmpty
SKIKO_EXPORT KNativePointer org_jetbrains_skia_FontStyleSet__1nMakeEmpty
() {
SkFontStyleSet* instance = SkFontStyleSet::CreateEmpty();
return reinterpret_cast<jlong>(instance);
return reinterpret_cast<KNativePointer>(instance);
}
extern "C" jint org_jetbrains_skia_FontStyleSet__1nCount
(jlong ptr) {
SkFontStyleSet* instance = reinterpret_cast<SkFontStyleSet*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_FontStyleSet__1nCount
(KNativePointer ptr) {
SkFontStyleSet* instance = reinterpret_cast<SkFontStyleSet*>((ptr));
return instance->count();
}
extern "C" jint org_jetbrains_skia_FontStyleSet__1nGetStyle
(jlong ptr, jint index) {
SkFontStyleSet* instance = reinterpret_cast<SkFontStyleSet*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_FontStyleSet__1nGetStyle
(KNativePointer ptr, KInt index) {
SkFontStyleSet* instance = reinterpret_cast<SkFontStyleSet*>((ptr));
SkFontStyle fontStyle;
instance->getStyle(index, &fontStyle, nullptr);
return fontStyle.weight() + (fontStyle.width() << 16) + (fontStyle.slant() << 24);
}
extern "C" jstring org_jetbrains_skia_FontStyleSet__1nGetStyleName
(jlong ptr, jint index) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_FontStyleSet__1nGetStyleName
(KNativePointer ptr, KInt index) {
TODO("implement org_jetbrains_skia_FontStyleSet__1nGetStyleName");
}
#if 0
extern "C" jstring org_jetbrains_skia_FontStyleSet__1nGetStyleName
(jlong ptr, jint index) {
SkFontStyleSet* instance = reinterpret_cast<SkFontStyleSet*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_FontStyleSet__1nGetStyleName
(KNativePointer ptr, KInt index) {
SkFontStyleSet* instance = reinterpret_cast<SkFontStyleSet*>((ptr));
SkString style;
instance->getStyle(index, nullptr, &style);
return javaString(env, style);
......@@ -43,25 +43,25 @@ extern "C" jstring org_jetbrains_skia_FontStyleSet__1nGetStyleName
#endif
extern "C" jlong org_jetbrains_skia_FontStyleSet__1nGetTypeface
(jlong ptr, jint index) {
SkFontStyleSet* instance = reinterpret_cast<SkFontStyleSet*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_FontStyleSet__1nGetTypeface
(KNativePointer ptr, KInt index) {
SkFontStyleSet* instance = reinterpret_cast<SkFontStyleSet*>((ptr));
SkTypeface* typeface = instance->createTypeface(index);
return reinterpret_cast<jlong>(typeface);
return reinterpret_cast<KNativePointer>(typeface);
}
extern "C" jlong org_jetbrains_skia_FontStyleSet__1nMatchStyle
(jlong ptr, jint fontStyle) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_FontStyleSet__1nMatchStyle
(KNativePointer ptr, KInt fontStyle) {
TODO("implement org_jetbrains_skia_FontStyleSet__1nMatchStyle");
}
#if 0
extern "C" jlong org_jetbrains_skia_FontStyleSet__1nMatchStyle
(jlong ptr, jint fontStyle) {
SkFontStyleSet* instance = reinterpret_cast<SkFontStyleSet*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_FontStyleSet__1nMatchStyle
(KNativePointer ptr, KInt fontStyle) {
SkFontStyleSet* instance = reinterpret_cast<SkFontStyleSet*>((ptr));
SkTypeface* typeface = instance->matchStyle(skija::FontStyle::fromJava(fontStyle));
return reinterpret_cast<jlong>(typeface);
return reinterpret_cast<KNativePointer>(typeface);
}
#endif
skiko/src/nativeMain/cpp/generated/Image.cc → skiko/src/commonMain/cpp/generated/Image.cc
View file @ 4b6f133a
......@@ -7,15 +7,15 @@
#include "common.h"
extern "C" jlong org_jetbrains_skia_Image__1nMakeRaster
(jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr, jbyteArray bytesArr, jlong rowBytes) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Image__1nMakeRaster
(KInt width, KInt height, KInt colorType, KInt alphaType, KNativePointer colorSpacePtr, KByte* bytesArr, KNativePointer rowBytes) {
TODO("implement org_jetbrains_skia_Image__1nMakeRaster");
}
#if 0
extern "C" jlong org_jetbrains_skia_Image__1nMakeRaster
(jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr, jbyteArray bytesArr, jlong rowBytes) {
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Image__1nMakeRaster
(KInt width, KInt height, KInt colorType, KInt alphaType, KNativePointer colorSpacePtr, KByte* bytesArr, KNativePointer rowBytes) {
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>((colorSpacePtr));
SkImageInfo imageInfo = SkImageInfo::Make(width,
height,
static_cast<SkColorType>(colorType),
......@@ -24,108 +24,108 @@ extern "C" jlong org_jetbrains_skia_Image__1nMakeRaster
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());
return reinterpret_cast<KNativePointer>(image.release());
}
#endif
extern "C" jlong org_jetbrains_skia_Image__1nMakeRasterData
(jint width, jint height, jint colorType, jint alphaType, jlong colorSpacePtr, jlong dataPtr, jlong rowBytes) {
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>(static_cast<uintptr_t>(colorSpacePtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Image__1nMakeRasterData
(KInt width, KInt height, KInt colorType, KInt alphaType, KNativePointer colorSpacePtr, KNativePointer dataPtr, KInt rowBytes) {
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>((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));
SkData* data = reinterpret_cast<SkData*>((dataPtr));
sk_sp<SkImage> image = SkImage::MakeRasterData(imageInfo, sk_ref_sp(data), rowBytes);
return reinterpret_cast<jlong>(image.release());
return reinterpret_cast<KNativePointer>(image.release());
}
extern "C" jlong org_jetbrains_skia_Image__1nMakeFromBitmap
(jlong bitmapPtr) {
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(static_cast<uintptr_t>(bitmapPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Image__1nMakeFromBitmap
(KNativePointer bitmapPtr) {
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>((bitmapPtr));
sk_sp<SkImage> image = SkImage::MakeFromBitmap(*bitmap);
return reinterpret_cast<jlong>(image.release());
return reinterpret_cast<KNativePointer>(image.release());
}
extern "C" jlong org_jetbrains_skia_Image__1nMakeFromPixmap
(jlong pixmapPtr) {
SkPixmap* pixmap = reinterpret_cast<SkPixmap*>(static_cast<uintptr_t>(pixmapPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Image__1nMakeFromPixmap
(KNativePointer pixmapPtr) {
SkPixmap* pixmap = reinterpret_cast<SkPixmap*>((pixmapPtr));
sk_sp<SkImage> image = SkImage::MakeFromRaster(*pixmap, nullptr, nullptr);
return reinterpret_cast<jlong>(image.release());
return reinterpret_cast<KNativePointer>(image.release());
}
extern "C" jlong org_jetbrains_skia_Image__1nMakeFromEncoded
(jbyteArray encodedArray) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Image__1nMakeFromEncoded
(KByte* encodedArray) {
TODO("implement org_jetbrains_skia_Image__1nMakeFromEncoded");
}
#if 0
extern "C" jlong org_jetbrains_skia_Image__1nMakeFromEncoded
(jbyteArray encodedArray) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Image__1nMakeFromEncoded
(KByte* encodedArray) {
jsize encodedLen = env->GetArrayLength(encodedArray);
jbyte* encoded = env->GetByteArrayElements(encodedArray, 0);
KByte* 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());
return reinterpret_cast<KNativePointer>(image.release());
}
#endif
extern "C" jobject org_jetbrains_skia_Image__1nGetImageInfo
(jlong ptr) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Image__1nGetImageInfo
(KNativePointer ptr) {
TODO("implement org_jetbrains_skia_Image__1nGetImageInfo");
}
#if 0
extern "C" jobject org_jetbrains_skia_Image__1nGetImageInfo
(jlong ptr) {
SkImage* instance = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Image__1nGetImageInfo
(KNativePointer ptr) {
SkImage* instance = reinterpret_cast<SkImage*>((ptr));
return skija::ImageInfo::toJava(env, instance->imageInfo());
}
#endif
extern "C" jlong org_jetbrains_skia_Image__1nEncodeToData
(jlong ptr, jint format, jint quality) {
SkImage* instance = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Image__1nEncodeToData
(KNativePointer ptr, KInt format, KInt quality) {
SkImage* instance = reinterpret_cast<SkImage*>((ptr));
SkData* data = instance->encodeToData(static_cast<SkEncodedImageFormat>(format), quality).release();
return reinterpret_cast<jlong>(data);
return reinterpret_cast<KNativePointer>(data);
}
extern "C" jlong org_jetbrains_skia_Image__1nMakeShader
(jlong ptr, jint tmx, jint tmy, jlong sampling, jfloatArray localMatrixArr) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Image__1nMakeShader
(KNativePointer ptr, KInt tmx, KInt tmy, KNativePointer sampling, KFloat* localMatrixArr) {
TODO("implement org_jetbrains_skia_Image__1nMakeShader");
}
#if 0
extern "C" jlong org_jetbrains_skia_Image__1nMakeShader
(jlong ptr, jint tmx, jint tmy, jlong sampling, jfloatArray localMatrixArr) {
SkImage* instance = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Image__1nMakeShader
(KNativePointer ptr, KInt tmx, KInt tmy, KNativePointer sampling, KFloat* localMatrixArr) {
SkImage* instance = reinterpret_cast<SkImage*>((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());
return reinterpret_cast<KNativePointer>(shader.release());
}
#endif
extern "C" jobject org_jetbrains_skia_Image__1nPeekPixels
(jlong ptr) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Image__1nPeekPixels
(KNativePointer ptr) {
TODO("implement org_jetbrains_skia_Image__1nPeekPixels");
}
#if 0
extern "C" jobject org_jetbrains_skia_Image__1nPeekPixels
(jlong ptr) {
SkImage* instance = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Image__1nPeekPixels
(KNativePointer ptr) {
SkImage* instance = reinterpret_cast<SkImage*>((ptr));
SkPixmap pixmap;
if (instance->peekPixels(&pixmap))
return env->NewDirectByteBuffer(pixmap.writable_addr(), pixmap.rowBytes() * pixmap.height());
......@@ -135,34 +135,34 @@ extern "C" jobject org_jetbrains_skia_Image__1nPeekPixels
#endif
extern "C" jboolean org_jetbrains_skia_Image__1nPeekPixelsToPixmap
(jlong ptr, jlong pixmapPtr) {
SkImage* instance = reinterpret_cast<SkImage*>(static_cast<uintptr_t>(ptr));
SkPixmap* pixmap = reinterpret_cast<SkPixmap*>(static_cast<uintptr_t>(pixmapPtr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Image__1nPeekPixelsToPixmap
(KNativePointer ptr, KNativePointer pixmapPtr) {
SkImage* instance = reinterpret_cast<SkImage*>((ptr));
SkPixmap* pixmap = reinterpret_cast<SkPixmap*>((pixmapPtr));
return instance->peekPixels(pixmap);
}
extern "C" jboolean org_jetbrains_skia_Image__1nReadPixelsBitmap
(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));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Image__1nReadPixelsBitmap
(KNativePointer ptr, KNativePointer contextPtr, KNativePointer bitmapPtr, KInt srcX, KInt srcY, KBoolean cache) {
SkImage* instance = reinterpret_cast<SkImage*>((ptr));
GrDirectContext* context = reinterpret_cast<GrDirectContext*>((contextPtr));
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>((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" jboolean org_jetbrains_skia_Image__1nReadPixelsPixmap
(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));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Image__1nReadPixelsPixmap
(KNativePointer ptr, KNativePointer pixmapPtr, KInt srcX, KInt srcY, KBoolean cache) {
SkImage* instance = reinterpret_cast<SkImage*>((ptr));
SkPixmap* pixmap = reinterpret_cast<SkPixmap*>((pixmapPtr));
auto cachingHint = cache ? SkImage::CachingHint::kAllow_CachingHint : SkImage::CachingHint::kDisallow_CachingHint;
return instance->readPixels(*pixmap, srcX, srcY, cachingHint);
}
extern "C" jboolean org_jetbrains_skia_Image__1nScalePixels
(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));
SKIKO_EXPORT KBoolean org_jetbrains_skia_Image__1nScalePixels
(KNativePointer ptr, KNativePointer pixmapPtr, KLong samplingOptions, KBoolean cache) {
SkImage* instance = reinterpret_cast<SkImage*>((ptr));
SkPixmap* pixmap = reinterpret_cast<SkPixmap*>((pixmapPtr));
auto cachingHint = cache ? SkImage::CachingHint::kAllow_CachingHint : SkImage::CachingHint::kDisallow_CachingHint;
return instance->scalePixels(*pixmap, skija::SamplingMode::unpack(samplingOptions), cachingHint);
}
skiko/src/nativeMain/cpp/generated/ImageFilter.cc → skiko/src/commonMain/cpp/generated/ImageFilter.cc
View file @ 4b6f133a
......@@ -10,423 +10,423 @@
#include "common.h"
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeAlphaThreshold
(jlong regionPtr, jfloat innerMin, jfloat outerMax, jlong inputPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeAlphaThreshold
(KNativePointer regionPtr, KFloat innerMin, KFloat outerMax, KNativePointer inputPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeAlphaThreshold");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeAlphaThreshold
(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));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeAlphaThreshold
(KNativePointer regionPtr, KFloat innerMin, KFloat outerMax, KNativePointer inputPtr, KInteropPointer cropObj) {
SkRegion* region = reinterpret_cast<SkRegion*>((regionPtr));
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeArithmetic
(jfloat k1, jfloat k2, jfloat k3, jfloat k4, jboolean enforcePMColor, jlong bgPtr, jlong fgPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeArithmetic
(KFloat k1, KFloat k2, KFloat k3, KFloat k4, KBoolean enforcePMColor, KNativePointer bgPtr, KNativePointer fgPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeArithmetic");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeArithmetic
(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));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeArithmetic
(KFloat k1, KFloat k2, KFloat k3, KFloat k4, KBoolean enforcePMColor, KNativePointer bgPtr, KNativePointer fgPtr, KInteropPointer cropObj) {
SkImageFilter* bg = reinterpret_cast<SkImageFilter*>((bgPtr));
SkImageFilter* fg = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeBlend
(jint blendModeInt, jlong bgPtr, jlong fgPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeBlend
(KInt blendModeInt, KNativePointer bgPtr, KNativePointer fgPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeBlend");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeBlend
(jint blendModeInt, jlong bgPtr, jlong fgPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeBlend
(KInt blendModeInt, KNativePointer bgPtr, KNativePointer fgPtr, KInteropPointer 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));
SkImageFilter* bg = reinterpret_cast<SkImageFilter*>((bgPtr));
SkImageFilter* fg = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeBlur
(jfloat sigmaX, jfloat sigmaY, jint tileModeInt, jlong inputPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeBlur
(KFloat sigmaX, KFloat sigmaY, KInt tileModeInt, KNativePointer inputPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeBlur");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeBlur
(jfloat sigmaX, jfloat sigmaY, jint tileModeInt, jlong inputPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeBlur
(KFloat sigmaX, KFloat sigmaY, KInt tileModeInt, KNativePointer inputPtr, KInteropPointer cropObj) {
SkTileMode tileMode = static_cast<SkTileMode>(tileModeInt);
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeColorFilter
(jlong colorFilterPtr, jlong inputPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeColorFilter
(KNativePointer colorFilterPtr, KNativePointer inputPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeColorFilter");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeColorFilter
(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));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeColorFilter
(KNativePointer colorFilterPtr, KNativePointer inputPtr, KInteropPointer cropObj) {
SkColorFilter* colorFilter = reinterpret_cast<SkColorFilter*>((colorFilterPtr));
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeCompose
(jlong outerPtr, jlong innerPtr) {
SkImageFilter* outer = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(outerPtr));
SkImageFilter* inner = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(innerPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeCompose
(KNativePointer outerPtr, KNativePointer innerPtr) {
SkImageFilter* outer = reinterpret_cast<SkImageFilter*>((outerPtr));
SkImageFilter* inner = reinterpret_cast<SkImageFilter*>((innerPtr));
SkImageFilter* ptr = SkImageFilters::Compose(sk_ref_sp(outer), sk_ref_sp(inner)).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeDisplacementMap
(jint xChanInt, jint yChanInt, jfloat scale, jlong displacementPtr, jlong colorPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDisplacementMap
(KInt xChanInt, KInt yChanInt, KFloat scale, KNativePointer displacementPtr, KNativePointer colorPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeDisplacementMap");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeDisplacementMap
(jint xChanInt, jint yChanInt, jfloat scale, jlong displacementPtr, jlong colorPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDisplacementMap
(KInt xChanInt, KInt yChanInt, KFloat scale, KNativePointer displacementPtr, KNativePointer colorPtr, KInteropPointer 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));
SkImageFilter* displacement = reinterpret_cast<SkImageFilter*>((displacementPtr));
SkImageFilter* color = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeDropShadow
(jfloat dx, jfloat dy, jfloat sigmaX, jfloat sigmaY, jint color, jlong inputPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDropShadow
(KFloat dx, KFloat dy, KFloat sigmaX, KFloat sigmaY, KInt color, KNativePointer inputPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeDropShadow");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeDropShadow
(jfloat dx, jfloat dy, jfloat sigmaX, jfloat sigmaY, jint color, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDropShadow
(KFloat dx, KFloat dy, KFloat sigmaX, KFloat sigmaY, KInt color, KNativePointer inputPtr, KInteropPointer cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeDropShadowOnly
(jfloat dx, jfloat dy, jfloat sigmaX, jfloat sigmaY, jint color, jlong inputPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDropShadowOnly
(KFloat dx, KFloat dy, KFloat sigmaX, KFloat sigmaY, KInt color, KNativePointer inputPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeDropShadowOnly");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeDropShadowOnly
(jfloat dx, jfloat dy, jfloat sigmaX, jfloat sigmaY, jint color, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDropShadowOnly
(KFloat dx, KFloat dy, KFloat sigmaX, KFloat sigmaY, KInt color, KNativePointer inputPtr, KInteropPointer cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeImage
(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));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeImage
(KNativePointer imagePtr, KFloat l0, KFloat t0, KFloat r0, KFloat b0, KFloat l1, KFloat t1, KFloat r1, KFloat b1, KLong samplingMode) {
SkImage* image = reinterpret_cast<SkImage*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeMagnifier
(jfloat l, jfloat t, jfloat r, jfloat b, jfloat inset, jlong inputPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMagnifier
(KFloat l, KFloat t, KFloat r, KFloat b, KFloat inset, KNativePointer inputPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeMagnifier");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeMagnifier
(jfloat l, jfloat t, jfloat r, jfloat b, jfloat inset, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMagnifier
(KFloat l, KFloat t, KFloat r, KFloat b, KFloat inset, KNativePointer inputPtr, KInteropPointer cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeMatrixConvolution
(jint kernelW, jint kernelH, jfloatArray kernelArray, jfloat gain, jfloat bias, jint offsetX, jint offsetY, jint tileModeInt, jboolean convolveAlpha, jlong inputPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMatrixConvolution
(KInt kernelW, KInt kernelH, KFloat* kernelArray, KFloat gain, KFloat bias, KInt offsetX, KInt offsetY, KInt tileModeInt, KBoolean convolveAlpha, KNativePointer inputPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeMatrixConvolution");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeMatrixConvolution
(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);
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMatrixConvolution
(KInt kernelW, KInt kernelH, KFloat* kernelArray, KFloat gain, KFloat bias, KInt offsetX, KInt offsetY, KInt tileModeInt, KBoolean convolveAlpha, KNativePointer inputPtr, KInteropPointer cropObj) {
KFloat* kernel = env->GetFloatArrayElements(kernelArray, 0);
SkTileMode tileMode = static_cast<SkTileMode>(tileModeInt);
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeMatrixTransform
(jfloatArray matrixArray, jlong samplingMode, jlong inputPtr) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMatrixTransform
(KFloat* matrixArray, KNativePointer samplingMode, KNativePointer inputPtr) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeMatrixTransform");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeMatrixTransform
(jfloatArray matrixArray, jlong samplingMode, jlong inputPtr) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMatrixTransform
(KFloat* matrixArray, KNativePointer samplingMode, KNativePointer inputPtr) {
std::unique_ptr<SkMatrix> matrix = skMatrix(env, matrixArray);
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((inputPtr));
SkImageFilter* ptr = SkImageFilters::MatrixTransform(*matrix, skija::SamplingMode::unpack(samplingMode), sk_ref_sp(input)).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeMerge
(jlongArray filtersArray, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMerge
(KNativePointerArray filtersArray, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeMerge");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeMerge
(jlongArray filtersArray, jobject cropObj) {
jlong* f = env->GetLongArrayElements(filtersArray, 0);
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeMerge
(KNativePointerArray filtersArray, KInteropPointer cropObj) {
KNativePointer* 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]));
SkImageFilter* fi = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeOffset
(jfloat dx, jfloat dy, jlong inputPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeOffset
(KFloat dx, KFloat dy, KNativePointer inputPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeOffset");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeOffset
(jfloat dx, jfloat dy, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeOffset
(KFloat dx, KFloat dy, KNativePointer inputPtr, KInteropPointer cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakePaint
(jlong paintPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakePaint
(KNativePointer paintPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakePaint");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakePaint
(jlong paintPtr, jobject cropObj) {
SkPaint* paint = reinterpret_cast<SkPaint*>(static_cast<uintptr_t>(paintPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakePaint
(KNativePointer paintPtr, KInteropPointer cropObj) {
SkPaint* paint = reinterpret_cast<SkPaint*>((paintPtr));
std::unique_ptr<SkIRect> crop = skija::IRect::toSkIRect(env, cropObj);
SkImageFilter* ptr = SkImageFilters::Paint(*paint, crop.get()).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakePicture
(jlong picturePtr, jfloat l, jfloat t, jfloat r, jfloat b) {
SkPicture* picture = reinterpret_cast<SkPicture*>(static_cast<uintptr_t>(picturePtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakePicture
(KNativePointer picturePtr, KFloat l, KFloat t, KFloat r, KFloat b) {
SkPicture* picture = reinterpret_cast<SkPicture*>((picturePtr));
SkImageFilter* ptr = SkImageFilters::Picture(sk_ref_sp(picture), SkRect{l, t, r, b}).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeTile
(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));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeTile
(KFloat l0, KFloat t0, KFloat r0, KFloat b0, KFloat l1, KFloat t1, KFloat r1, KFloat b1, KNativePointer inputPtr) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeDilate
(float rx, jfloat ry, jlong inputPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDilate
(float rx, KFloat ry, KNativePointer inputPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeDilate");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeDilate
(float rx, jfloat ry, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDilate
(float rx, KFloat ry, KNativePointer inputPtr, KInteropPointer cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeErode
(float rx, jfloat ry, jlong inputPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeErode
(float rx, KFloat ry, KNativePointer inputPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeErode");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeErode
(float rx, jfloat ry, jlong inputPtr, jobject cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>(static_cast<uintptr_t>(inputPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeErode
(float rx, KFloat ry, KNativePointer inputPtr, KInteropPointer cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeDistantLitDiffuse
(jfloat x, jfloat y, jfloat z, jint lightColor, jfloat surfaceScale, jfloat kd, jlong inputPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDistantLitDiffuse
(KFloat x, KFloat y, KFloat z, KInt lightColor, KFloat surfaceScale, KFloat kd, KNativePointer inputPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeDistantLitDiffuse");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeDistantLitDiffuse
(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));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDistantLitDiffuse
(KFloat x, KFloat y, KFloat z, KInt lightColor, KFloat surfaceScale, KFloat kd, KNativePointer inputPtr, KInteropPointer cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakePointLitDiffuse
(jfloat x, jfloat y, jfloat z, jint lightColor, jfloat surfaceScale, jfloat kd, jlong inputPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakePointLitDiffuse
(KFloat x, KFloat y, KFloat z, KInt lightColor, KFloat surfaceScale, KFloat kd, KNativePointer inputPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakePointLitDiffuse");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakePointLitDiffuse
(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));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakePointLitDiffuse
(KFloat x, KFloat y, KFloat z, KInt lightColor, KFloat surfaceScale, KFloat kd, KNativePointer inputPtr, KInteropPointer cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeSpotLitDiffuse
(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) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeSpotLitDiffuse
(KFloat x0, KFloat y0, KFloat z0, KFloat x1, KFloat y1, KFloat z1, KFloat falloffExponent, KFloat cutoffAngle, KInt lightColor, KFloat surfaceScale, KFloat kd, KNativePointer inputPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeSpotLitDiffuse");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeSpotLitDiffuse
(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));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeSpotLitDiffuse
(KFloat x0, KFloat y0, KFloat z0, KFloat x1, KFloat y1, KFloat z1, KFloat falloffExponent, KFloat cutoffAngle, KInt lightColor, KFloat surfaceScale, KFloat kd, KNativePointer inputPtr, KInteropPointer cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeDistantLitSpecular
(jfloat x, jfloat y, jfloat z, jint lightColor, jfloat surfaceScale, jfloat ks, jfloat shininess, jlong inputPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDistantLitSpecular
(KFloat x, KFloat y, KFloat z, KInt lightColor, KFloat surfaceScale, KFloat ks, KFloat shininess, KNativePointer inputPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeDistantLitSpecular");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeDistantLitSpecular
(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));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeDistantLitSpecular
(KFloat x, KFloat y, KFloat z, KInt lightColor, KFloat surfaceScale, KFloat ks, KFloat shininess, KNativePointer inputPtr, KInteropPointer cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakePointLitSpecular
(jfloat x, jfloat y, jfloat z, jint lightColor, jfloat surfaceScale, jfloat ks, jfloat shininess, jlong inputPtr, jobject cropObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakePointLitSpecular
(KFloat x, KFloat y, KFloat z, KInt lightColor, KFloat surfaceScale, KFloat ks, KFloat shininess, KNativePointer inputPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakePointLitSpecular");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakePointLitSpecular
(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));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakePointLitSpecular
(KFloat x, KFloat y, KFloat z, KInt lightColor, KFloat surfaceScale, KFloat ks, KFloat shininess, KNativePointer inputPtr, KInteropPointer cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeSpotLitSpecular
(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) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeSpotLitSpecular
(KFloat x0, KFloat y0, KFloat z0, KFloat x1, KFloat y1, KFloat z1, KFloat falloffExponent, KFloat cutoffAngle, KInt lightColor, KFloat surfaceScale, KFloat ks, KFloat shininess, KNativePointer inputPtr, KInteropPointer cropObj) {
TODO("implement org_jetbrains_skia_ImageFilter__1nMakeSpotLitSpecular");
}
#if 0
extern "C" jlong org_jetbrains_skia_ImageFilter__1nMakeSpotLitSpecular
(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));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ImageFilter__1nMakeSpotLitSpecular
(KFloat x0, KFloat y0, KFloat z0, KFloat x1, KFloat y1, KFloat z1, KFloat falloffExponent, KFloat cutoffAngle, KInt lightColor, KFloat surfaceScale, KFloat ks, KFloat shininess, KNativePointer inputPtr, KInteropPointer cropObj) {
SkImageFilter* input = reinterpret_cast<SkImageFilter*>((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);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
skiko/src/nativeMain/cpp/generated/ManagedString.cc → skiko/src/commonMain/cpp/generated/ManagedString.cc
View file @ 4b6f133a
......@@ -8,51 +8,51 @@ static void deleteString(SkString* instance) {
delete instance;
}
extern "C" jlong org_jetbrains_skia_ManagedString__1nGetFinalizer
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ManagedString__1nGetFinalizer
() {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteString));
return reinterpret_cast<KNativePointer>((&deleteString));
}
extern "C" jlong org_jetbrains_skia_ManagedString__1nMake
(jstring textStr) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ManagedString__1nMake
(KInteropPointer textStr) {
TODO("implement org_jetbrains_skia_ManagedString__1nMake");
}
#if 0
extern "C" jlong org_jetbrains_skia_ManagedString__1nMake
(jstring textStr) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_ManagedString__1nMake
(KInteropPointer textStr) {
SkString* text = new SkString(skString(env, textStr));
return reinterpret_cast<jlong>(text);
return reinterpret_cast<KNativePointer>(text);
}
#endif
extern "C" jobject org_jetbrains_skia_ManagedString__1nToString
(jlong ptr) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_ManagedString__1nToString
(KNativePointer ptr) {
TODO("implement org_jetbrains_skia_ManagedString__1nToString");
}
#if 0
extern "C" jobject org_jetbrains_skia_ManagedString__1nToString
(jlong ptr) {
SkString* instance = reinterpret_cast<SkString*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_ManagedString__1nToString
(KNativePointer ptr) {
SkString* instance = reinterpret_cast<SkString*>((ptr));
return javaString(env, *instance);
}
#endif
extern "C" void org_jetbrains_skia_ManagedString__1nInsert
(jlong ptr, jint offset, jstring s) {
SKIKO_EXPORT void org_jetbrains_skia_ManagedString__1nInsert
(KNativePointer ptr, KInt offset, KInteropPointer s) {
TODO("implement org_jetbrains_skia_ManagedString__1nInsert");
}
#if 0
extern "C" void org_jetbrains_skia_ManagedString__1nInsert
(jlong ptr, jint offset, jstring s) {
SkString* instance = reinterpret_cast<SkString*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_ManagedString__1nInsert
(KNativePointer ptr, KInt offset, KInteropPointer s) {
SkString* instance = reinterpret_cast<SkString*>((ptr));
skija::UtfIndicesConverter conv(*instance);
instance->insert(conv.from16To8(offset), skString(env, s));
}
......@@ -60,31 +60,31 @@ extern "C" void org_jetbrains_skia_ManagedString__1nInsert
extern "C" void org_jetbrains_skia_ManagedString__1nAppend
(jlong ptr, jstring s) {
SKIKO_EXPORT void org_jetbrains_skia_ManagedString__1nAppend
(KNativePointer ptr, KInteropPointer s) {
TODO("implement org_jetbrains_skia_ManagedString__1nAppend");
}
#if 0
extern "C" void org_jetbrains_skia_ManagedString__1nAppend
(jlong ptr, jstring s) {
SkString* instance = reinterpret_cast<SkString*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_ManagedString__1nAppend
(KNativePointer ptr, KInteropPointer s) {
SkString* instance = reinterpret_cast<SkString*>((ptr));
instance->append(skString(env, s));
}
#endif
extern "C" void org_jetbrains_skia_ManagedString__1nRemoveSuffix
(jlong ptr, jint from) {
SkString* instance = reinterpret_cast<SkString*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_ManagedString__1nRemoveSuffix
(KNativePointer ptr, KInt from) {
SkString* instance = reinterpret_cast<SkString*>((ptr));
skija::UtfIndicesConverter conv(*instance);
size_t from8 = conv.from16To8(from);
instance->remove(from8, instance->size() - from8);
}
extern "C" void org_jetbrains_skia_ManagedString__1nRemove
(jlong ptr, jint from, jint len) {
SkString* instance = reinterpret_cast<SkString*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT void org_jetbrains_skia_ManagedString__1nRemove
(KNativePointer ptr, KInt from, KInt len) {
SkString* instance = reinterpret_cast<SkString*>((ptr));
skija::UtfIndicesConverter conv(*instance);
size_t from8 = conv.from16To8(from);
size_t to8 = conv.from16To8(from + len);
......
skiko/src/nativeMain/cpp/generated/MaskFilter.cc → skiko/src/commonMain/cpp/generated/MaskFilter.cc
View file @ 4b6f133a
......@@ -8,45 +8,45 @@
#include "SkTableMaskFilter.h"
#include "common.h"
extern "C" jlong org_jetbrains_skia_MaskFilter__1nMakeBlur
(jint blurStyleInt, jfloat sigma, jboolean respectCTM) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_MaskFilter__1nMakeBlur
(KInt blurStyleInt, KFloat sigma, KBoolean respectCTM) {
SkBlurStyle blurStyle = static_cast<SkBlurStyle>(blurStyleInt);
SkMaskFilter* ptr = SkMaskFilter::MakeBlur(blurStyle, sigma, respectCTM).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KInteropPointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_MaskFilter__1nMakeShader
(jlong shaderPtr) {
SkShader* shader = reinterpret_cast<SkShader*>(static_cast<uintptr_t>(shaderPtr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_MaskFilter__1nMakeShader
(KInteropPointer shaderPtr) {
SkShader* shader = reinterpret_cast<SkShader*>((shaderPtr));
SkMaskFilter* ptr = SkShaderMaskFilter::Make(sk_ref_sp(shader)).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KInteropPointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_MaskFilter__1nMakeTable
(jbyteArray tableArray) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_MaskFilter__1nMakeTable
(KByte* tableArray) {
TODO("implement org_jetbrains_skia_MaskFilter__1nMakeTable");
}
#if 0
extern "C" jlong org_jetbrains_skia_MaskFilter__1nMakeTable
(jbyteArray tableArray) {
jbyte* table = env->GetByteArrayElements(tableArray, 0);
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_MaskFilter__1nMakeTable
(KByte* tableArray) {
KByte* table = env->GetByteArrayElements(tableArray, 0);
SkMaskFilter* ptr = SkTableMaskFilter::Create(reinterpret_cast<uint8_t*>(table));
env->ReleaseByteArrayElements(tableArray, table, 0);
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KInteropPointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_MaskFilter__1nMakeGamma
(jfloat gamma) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_MaskFilter__1nMakeGamma
(KFloat gamma) {
SkMaskFilter* ptr = SkTableMaskFilter::CreateGamma(gamma);
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KInteropPointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_MaskFilter__1nMakeClip
(jbyte min, jbyte max) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_MaskFilter__1nMakeClip
(KByte min, KByte max) {
SkMaskFilter* ptr = SkTableMaskFilter::CreateClip(static_cast<uint8_t>(min), static_cast<uint8_t>(max));
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KInteropPointer>(ptr);
}
skiko/src/nativeMain/cpp/generated/OutputWStream.cc → skiko/src/commonMain/cpp/generated/OutputWStream.cc
View file @ 4b6f133a
......@@ -6,30 +6,30 @@
#include "common.h"
extern "C" jlong org_jetbrains_skia_OutputWStream__1nGetFinalizer
SKIKO_EXPORT KNativePointer org_jetbrains_skia_OutputWStream__1nGetFinalizer
() {
TODO("implement org_jetbrains_skia_OutputWStream__1nGetFinalizer");
}
#if 0
extern "C" jlong org_jetbrains_skia_OutputWStream__1nGetFinalizer
SKIKO_EXPORT KNativePointer org_jetbrains_skia_OutputWStream__1nGetFinalizer
() {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deleteOutputWStream));
return reinterpret_cast<KNativePointer>((&deleteOutputWStream));
}
#endif
extern "C" jlong org_jetbrains_skia_OutputWStream__1nMake
(jobject outputStream) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_OutputWStream__1nMake
(KInteropPointer outputStream) {
TODO("implement org_jetbrains_skia_OutputWStream__1nMake");
}
#if 0
extern "C" jlong org_jetbrains_skia_OutputWStream__1nMake
(jobject outputStream) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_OutputWStream__1nMake
(KInteropPointer outputStream) {
OutputWStream* instance = new OutputWStream(env, outputStream);
return reinterpret_cast<jlong>(instance);
return reinterpret_cast<KNativePointer>(instance);
}
#endif
skiko/src/commonMain/cpp/generated/Paint.cc 0 → 100644
View file @ 4b6f133a
// This file has been auto generated.
#include <iostream>
#include "SkColorFilter.h"
#include "SkImageFilter.h"
#include "SkMaskFilter.h"
#include "SkPaint.h"
#include "SkPathEffect.h"
#include "SkShader.h"
#include "SkFilterQuality.h"
#include "common.h"
static void deletePaint(SkPaint* paint) {
delete paint;
}
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Paint__1nGetFinalizer
(){
return reinterpret_cast<KNativePointer>((&deletePaint));
}
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Paint__1nMake
(){
SkPaint* obj = new SkPaint();
obj->setAntiAlias(true);
return reinterpret_cast<KNativePointer>(obj);
}
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Paint__1nMakeClone
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
SkPaint* obj = new SkPaint(*instance);
return reinterpret_cast<KNativePointer>(obj);
}
SKIKO_EXPORT KBoolean org_jetbrains_skia_Paint__1nEquals
(KNativePointer aPtr, KNativePointer bPtr) {
SkPaint* a = reinterpret_cast<SkPaint*>((aPtr));
SkPaint* b = reinterpret_cast<SkPaint*>((bPtr));
return *a == *b;
}
SKIKO_EXPORT void org_jetbrains_skia_Paint__1nReset
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
instance->reset();
}
SKIKO_EXPORT KBoolean org_jetbrains_skia_Paint__1nIsAntiAlias
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
return instance->isAntiAlias();
}
SKIKO_EXPORT void org_jetbrains_skia_Paint__1nSetAntiAlias
(KNativePointer ptr, KBoolean value) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
instance->setAntiAlias(value);
}
SKIKO_EXPORT KBoolean org_jetbrains_skia_Paint__1nIsDither
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
return instance->isDither();
}
SKIKO_EXPORT void org_jetbrains_skia_Paint__1nSetDither
(KNativePointer ptr, KBoolean value) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
instance->setDither(value);
}
SKIKO_EXPORT KInt org_jetbrains_skia_Paint__1nGetColor
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
return instance->getColor();
}
SKIKO_EXPORT void org_jetbrains_skia_Paint__1nSetColor
(KNativePointer ptr, KInt color) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
instance->setColor(color);
}
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Paint__1nGetColor4f
(KNativePointer ptr) {
TODO("implement org_jetbrains_skia_Paint__1nGetColor4f");
}
#if 0
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Paint__1nGetColor4f
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
SkColor4f color = instance->getColor4f();
return env->NewObject(skija::Color4f::cls, skija::Color4f::ctor, color.fR, color.fG, color.fB, color.fA);
}
#endif
SKIKO_EXPORT void org_jetbrains_skia_Paint__1nSetColor4f
(KNativePointer ptr, KFloat r, KFloat g, KFloat b, KFloat a, KNativePointer colorSpacePtr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
SkColorSpace* colorSpace = reinterpret_cast<SkColorSpace*>((colorSpacePtr));
instance->setColor4f({r, g, b, a}, colorSpace);
}
SKIKO_EXPORT KInt org_jetbrains_skia_Paint__1nGetMode
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
return instance->getStyle();
}
SKIKO_EXPORT void org_jetbrains_skia_Paint__1nSetMode
(KNativePointer ptr, KInt mode) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
instance->setStyle(static_cast<SkPaint::Style>(mode));
}
SKIKO_EXPORT KFloat org_jetbrains_skia_Paint__1nGetStrokeWidth
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
return instance->getStrokeWidth();
}
SKIKO_EXPORT void org_jetbrains_skia_Paint__1nSetStrokeWidth
(KNativePointer ptr, KFloat width) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
instance->setStrokeWidth(width);
}
SKIKO_EXPORT KFloat org_jetbrains_skia_Paint__1nGetStrokeMiter
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
return instance->getStrokeMiter();
}
SKIKO_EXPORT void org_jetbrains_skia_Paint__1nSetStrokeMiter
(KNativePointer ptr, KFloat miter) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
instance->setStrokeMiter(miter);
}
SKIKO_EXPORT KInt org_jetbrains_skia_Paint__1nGetStrokeCap
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
return instance->getStrokeCap();
}
SKIKO_EXPORT void org_jetbrains_skia_Paint__1nSetStrokeCap
(KNativePointer ptr, KInt cap) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
instance->setStrokeCap(static_cast<SkPaint::Cap>(cap));
}
SKIKO_EXPORT KInt org_jetbrains_skia_Paint__1nGetStrokeJoin
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
return instance->getStrokeJoin();
}
SKIKO_EXPORT void org_jetbrains_skia_Paint__1nSetStrokeJoin
(KNativePointer ptr, KInt join) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
instance->setStrokeJoin(static_cast<SkPaint::Join>(join));
}
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Paint__1nGetFillPath
(KNativePointer ptr, KNativePointer srcPtr, KFloat resScale) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
SkPath* src = reinterpret_cast<SkPath*>((srcPtr));
SkPath* dst = new SkPath();
instance->getFillPath(*src, dst, nullptr, resScale);
return reinterpret_cast<KNativePointer>(dst);
}
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Paint__1nGetFillPathCull
(KNativePointer ptr, KNativePointer srcPtr, KFloat left, KFloat top, KFloat right, KFloat bottom, KFloat resScale) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
SkPath* src = reinterpret_cast<SkPath*>((srcPtr));
SkPath* dst = new SkPath();
SkRect cull {left, top, right, bottom};
instance->getFillPath(*src, dst, &cull, resScale);
return reinterpret_cast<KNativePointer>(dst);
}
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Paint__1nGetMaskFilter
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
return reinterpret_cast<KNativePointer>(instance->refMaskFilter().release());
}
SKIKO_EXPORT void org_jetbrains_skia_Paint__1nSetMaskFilter
(KNativePointer ptr, KNativePointer filterPtr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
SkMaskFilter* filter = reinterpret_cast<SkMaskFilter*>((filterPtr));
instance->setMaskFilter(sk_ref_sp<SkMaskFilter>(filter));
}
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Paint__1nGetImageFilter
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
return reinterpret_cast<KNativePointer>(instance->refImageFilter().release());
}
SKIKO_EXPORT void org_jetbrains_skia_Paint__1nSetImageFilter
(KNativePointer ptr, KNativePointer filterPtr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
SkImageFilter* filter = reinterpret_cast<SkImageFilter*>((filterPtr));
instance->setImageFilter(sk_ref_sp<SkImageFilter>(filter));
}
SKIKO_EXPORT KInt org_jetbrains_skia_Paint__1nGetBlendMode
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
return static_cast<KInt>(instance->getBlendMode_or(SkBlendMode::kSrcOver));
}
SKIKO_EXPORT void org_jetbrains_skia_Paint__1nSetBlendMode
(KNativePointer ptr, KInt mode) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
instance->setBlendMode(static_cast<SkBlendMode>(mode));
}
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Paint__1nGetPathEffect
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
return reinterpret_cast<KNativePointer>(instance->refPathEffect().release());
}
SKIKO_EXPORT void org_jetbrains_skia_Paint__1nSetPathEffect
(KNativePointer ptr, KNativePointer pathEffectPtr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
SkPathEffect* pathEffect = reinterpret_cast<SkPathEffect*>((pathEffectPtr));
instance->setPathEffect(sk_ref_sp(pathEffect));
}
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Paint__1nGetShader
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
return reinterpret_cast<KNativePointer>(instance->refShader().release());
}
SKIKO_EXPORT void org_jetbrains_skia_Paint__1nSetShader
(KNativePointer ptr, KNativePointer shaderPtr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
SkShader* shader = reinterpret_cast<SkShader*>((shaderPtr));
instance->setShader(sk_ref_sp<SkShader>(shader));
}
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Paint__1nGetColorFilter
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
return reinterpret_cast<KNativePointer>(instance->refColorFilter().release());
}
SKIKO_EXPORT void org_jetbrains_skia_Paint__1nSetColorFilter
(KNativePointer ptr, KNativePointer colorFilterPtr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
SkColorFilter* colorFilter = reinterpret_cast<SkColorFilter*>((colorFilterPtr));
instance->setColorFilter(sk_ref_sp<SkColorFilter>(colorFilter));
}
SKIKO_EXPORT KBoolean org_jetbrains_skia_Paint__1nHasNothingToDraw
(KNativePointer ptr) {
SkPaint* instance = reinterpret_cast<SkPaint*>((ptr));
return instance->nothingToDraw();
}
skiko/src/nativeMain/cpp/generated/PaintFilterCanvas.cc → skiko/src/commonMain/cpp/generated/PaintFilterCanvas.cc
View file @ 4b6f133a
......@@ -8,32 +8,32 @@
#include "common.h"
extern "C" void org_jetbrains_skia_PaintFilterCanvas__1nAttachToJava
(jlong canvasPtr, jboolean unrollDrawable) {
SKIKO_EXPORT void org_jetbrains_skia_PaintFilterCanvas__1nAttachToJava
(KNativePointer canvasPtr, KBoolean unrollDrawable) {
TODO("implement org_jetbrains_skia_PaintFilterCanvas__1nAttachToJava");
}
#if 0
extern "C" void org_jetbrains_skia_PaintFilterCanvas__1nAttachToJava
(jlong canvasPtr, jboolean unrollDrawable) {
SkijaPaintFilterCanvas* canvas = reinterpret_cast<SkijaPaintFilterCanvas*>(static_cast<uintptr_t>(canvasPtr));
SKIKO_EXPORT void org_jetbrains_skia_PaintFilterCanvas__1nAttachToJava
(KNativePointer canvasPtr, KBoolean unrollDrawable) {
SkijaPaintFilterCanvas* canvas = reinterpret_cast<SkijaPaintFilterCanvas*>((canvasPtr));
canvas->jobj = skija::PaintFilterCanvas::attach(env, jobj);
}
#endif
extern "C" jlong org_jetbrains_skia_PaintFilterCanvas__1nMake
(jlong canvasPtr, jboolean unrollDrawable) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PaintFilterCanvas__1nMake
(KNativePointer canvasPtr, KBoolean unrollDrawable) {
TODO("implement org_jetbrains_skia_PaintFilterCanvas__1nMake");
}
#if 0
extern "C" jlong org_jetbrains_skia_PaintFilterCanvas__1nMake
(jlong canvasPtr, jboolean unrollDrawable) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>(static_cast<uintptr_t>(canvasPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PaintFilterCanvas__1nMake
(KNativePointer canvasPtr, KBoolean unrollDrawable) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkijaPaintFilterCanvas* filterCanvas = new SkijaPaintFilterCanvas(canvas, unrollDrawable);
return reinterpret_cast<jlong>(filterCanvas);
return reinterpret_cast<KNativePointer>(filterCanvas);
}
#endif
skiko/src/nativeMain/cpp/generated/PathEffect.cc → skiko/src/commonMain/cpp/generated/PathEffect.cc
View file @ 4b6f133a
......@@ -10,89 +10,77 @@
#include "SkDiscretePathEffect.h"
#include "common.h"
extern "C" jlong org_jetbrains_skia_PathEffect__1nMakeSum
(jlong firstPtr, jlong secondPtr) {
SkPathEffect* first = reinterpret_cast<SkPathEffect*>(static_cast<uintptr_t>(firstPtr));
SkPathEffect* second = reinterpret_cast<SkPathEffect*>(static_cast<uintptr_t>(secondPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathEffect__1nMakeSum
(KNativePointer firstPtr, KNativePointer secondPtr) {
SkPathEffect* first = reinterpret_cast<SkPathEffect*>((firstPtr));
SkPathEffect* second = reinterpret_cast<SkPathEffect*>((secondPtr));
SkPathEffect* ptr = SkPathEffect::MakeSum(sk_ref_sp(first), sk_ref_sp(second)).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_PathEffect__1nMakeCompose
(jlong outerPtr, jlong innerPtr) {
SkPathEffect* outer = reinterpret_cast<SkPathEffect*>(static_cast<uintptr_t>(outerPtr));
SkPathEffect* inner = reinterpret_cast<SkPathEffect*>(static_cast<uintptr_t>(innerPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathEffect__1nMakeCompose
(KNativePointer outerPtr, KNativePointer innerPtr) {
SkPathEffect* outer = reinterpret_cast<SkPathEffect*>((outerPtr));
SkPathEffect* inner = reinterpret_cast<SkPathEffect*>((innerPtr));
SkPathEffect* ptr = SkPathEffect::MakeCompose(sk_ref_sp(outer), sk_ref_sp(inner)).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_PathEffect__1nMakePath1D
(jlong pathPtr, jfloat advance, jfloat phase, jint styleInt) {
SkPath* path = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(pathPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathEffect__1nMakePath1D
(KNativePointer pathPtr, KFloat advance, KFloat phase, KInt styleInt) {
SkPath* path = reinterpret_cast<SkPath*>((pathPtr));
SkPath1DPathEffect::Style style = static_cast<SkPath1DPathEffect::Style>(styleInt);
SkPathEffect* ptr = SkPath1DPathEffect::Make(*path, advance, phase, style).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_PathEffect__1nMakePath2D
(jfloatArray matrixArr, jlong pathPtr) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathEffect__1nMakePath2D
(KFloat* matrixArr, KNativePointer pathPtr) {
TODO("implement org_jetbrains_skia_PathEffect__1nMakePath2D");
}
#if 0
extern "C" jlong org_jetbrains_skia_PathEffect__1nMakePath2D
(jfloatArray matrixArr, jlong pathPtr) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathEffect__1nMakePath2D
(KFloat* matrixArr, KNativePointer pathPtr) {
std::unique_ptr<SkMatrix> m = skMatrix(env, matrixArr);
SkPath* path = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(pathPtr));
SkPath* path = reinterpret_cast<SkPath*>((pathPtr));
SkPathEffect* ptr = SkPath2DPathEffect::Make(*m, *path).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_PathEffect__1nMakeLine2D
(jfloat width, jfloatArray matrixArr) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathEffect__1nMakeLine2D
(KFloat width, KFloat* matrixArr) {
TODO("implement org_jetbrains_skia_PathEffect__1nMakeLine2D");
}
#if 0
extern "C" jlong org_jetbrains_skia_PathEffect__1nMakeLine2D
(jfloat width, jfloatArray matrixArr) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathEffect__1nMakeLine2D
(KFloat width, KFloat* matrixArr) {
std::unique_ptr<SkMatrix> m = skMatrix(env, matrixArr);
SkPathEffect* ptr = SkLine2DPathEffect::Make(width, *m).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
#endif
extern "C" jlong org_jetbrains_skia_PathEffect__1nMakeCorner
(jfloat radius) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathEffect__1nMakeCorner
(KFloat radius) {
SkPathEffect* ptr = SkCornerPathEffect::Make(radius).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
extern "C" jlong org_jetbrains_skia_PathEffect__1nMakeDash
(jfloatArray intervalsArray, jfloat phase) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathEffect__1nMakeDash
(KFloat* intervalsArray, KFloat phase) {
TODO("implement org_jetbrains_skia_PathEffect__1nMakeDash");
}
#if 0
extern "C" jlong org_jetbrains_skia_PathEffect__1nMakeDash
(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);
}
#endif
extern "C" jlong org_jetbrains_skia_PathEffect__1nMakeDiscrete
(jfloat segLength, jfloat dev, jint seed) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathEffect__1nMakeDiscrete
(KFloat segLength, KFloat dev, KInt seed) {
SkPathEffect* ptr = SkDiscretePathEffect::Make(segLength, dev, static_cast<uint32_t>(seed)).release();
return reinterpret_cast<jlong>(ptr);
return reinterpret_cast<KNativePointer>(ptr);
}
skiko/src/nativeMain/cpp/generated/PathMeasure.cc → skiko/src/commonMain/cpp/generated/PathMeasure.cc
View file @ 4b6f133a
......@@ -8,44 +8,44 @@ static void deletePathMeasure(SkPathMeasure* instance) {
delete instance;
}
extern "C" jlong org_jetbrains_skia_PathMeasure__1nGetFinalizer() {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deletePathMeasure));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathMeasure__1nGetFinalizer() {
return reinterpret_cast<KNativePointer>((&deletePathMeasure));
}
extern "C" jlong org_jetbrains_skia_PathMeasure__1nMake
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathMeasure__1nMake
() {
return reinterpret_cast<jlong>(new SkPathMeasure());
return reinterpret_cast<KNativePointer>(new SkPathMeasure());
}
extern "C" jlong org_jetbrains_skia_PathMeasure__1nMakePath
(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));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathMeasure__1nMakePath
(KNativePointer pathPtr, KBoolean forceClosed, KFloat resScale) {
SkPath* path = reinterpret_cast<SkPath*>((pathPtr));
return reinterpret_cast<KNativePointer>(new SkPathMeasure(*path, forceClosed, resScale));
}
extern "C" void org_jetbrains_skia_PathMeasure__1nSetPath
(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));
SKIKO_EXPORT void org_jetbrains_skia_PathMeasure__1nSetPath
(KNativePointer ptr, KNativePointer pathPtr, KBoolean forceClosed) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>((ptr));
SkPath* path = reinterpret_cast<SkPath*>((pathPtr));
instance->setPath(path, forceClosed);
}
extern "C" jfloat org_jetbrains_skia_PathMeasure__1nGetLength
(jlong ptr) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KFloat org_jetbrains_skia_PathMeasure__1nGetLength
(KNativePointer ptr) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>((ptr));
return instance->getLength();
}
extern "C" jobject org_jetbrains_skia_PathMeasure__1nGetPosition
(jlong ptr, jfloat distance) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_PathMeasure__1nGetPosition
(KNativePointer ptr, KFloat distance) {
TODO("implement org_jetbrains_skia_PathMeasure__1nGetPosition");
}
#if 0
extern "C" jobject org_jetbrains_skia_PathMeasure__1nGetPosition
(jlong ptr, jfloat distance) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_PathMeasure__1nGetPosition
(KNativePointer ptr, KFloat distance) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>((ptr));
SkPoint position;
if (instance->getPosTan(distance, &position, nullptr))
return skija::Point::fromSkPoint(env, position);
......@@ -56,15 +56,15 @@ extern "C" jobject org_jetbrains_skia_PathMeasure__1nGetPosition
extern "C" jobject org_jetbrains_skia_PathMeasure__1nGetTangent
(jlong ptr, jfloat distance) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_PathMeasure__1nGetTangent
(KNativePointer ptr, KFloat distance) {
TODO("implement org_jetbrains_skia_PathMeasure__1nGetTangent");
}
#if 0
extern "C" jobject org_jetbrains_skia_PathMeasure__1nGetTangent
(jlong ptr, jfloat distance) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_PathMeasure__1nGetTangent
(KNativePointer ptr, KFloat distance) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>((ptr));
SkVector tangent;
if (instance->getPosTan(distance, nullptr, &tangent))
return skija::Point::fromSkPoint(env, tangent);
......@@ -75,15 +75,15 @@ extern "C" jobject org_jetbrains_skia_PathMeasure__1nGetTangent
extern "C" jobject org_jetbrains_skia_PathMeasure__1nGetRSXform
(jlong ptr, jfloat distance) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_PathMeasure__1nGetRSXform
(KNativePointer ptr, KFloat distance) {
TODO("implement org_jetbrains_skia_PathMeasure__1nGetRSXform");
}
#if 0
extern "C" jobject org_jetbrains_skia_PathMeasure__1nGetRSXform
(jlong ptr, jfloat distance) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_PathMeasure__1nGetRSXform
(KNativePointer ptr, KFloat distance) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>((ptr));
SkPoint position;
SkVector tangent;
if (instance->getPosTan(distance, &position, &tangent))
......@@ -95,15 +95,15 @@ extern "C" jobject org_jetbrains_skia_PathMeasure__1nGetRSXform
extern "C" jobject org_jetbrains_skia_PathMeasure__1nGetMatrix
(jlong ptr, jfloat distance, jboolean getPosition, jboolean getTangent) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_PathMeasure__1nGetMatrix
(KNativePointer ptr, KFloat distance, KBoolean getPosition, KBoolean getTangent) {
TODO("implement org_jetbrains_skia_PathMeasure__1nGetMatrix");
}
#if 0
extern "C" jobject org_jetbrains_skia_PathMeasure__1nGetMatrix
(jlong ptr, jfloat distance, jboolean getPosition, jboolean getTangent) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_PathMeasure__1nGetMatrix
(KNativePointer ptr, KFloat distance, KBoolean getPosition, KBoolean getTangent) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>((ptr));
SkMatrix matrix;
int flags = 0;
......@@ -122,21 +122,21 @@ extern "C" jobject org_jetbrains_skia_PathMeasure__1nGetMatrix
#endif
extern "C" jboolean org_jetbrains_skia_PathMeasure__1nGetSegment
(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));
SKIKO_EXPORT KBoolean org_jetbrains_skia_PathMeasure__1nGetSegment
(KNativePointer ptr, KFloat startD, KFloat endD, KNativePointer dstPtr, KBoolean startWithMoveTo) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>((ptr));
SkPath* dst = reinterpret_cast<SkPath*>((dstPtr));
return instance->getSegment(startD, endD, dst, startWithMoveTo);
}
extern "C" jboolean org_jetbrains_skia_PathMeasure__1nIsClosed
(jlong ptr) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_PathMeasure__1nIsClosed
(KNativePointer ptr) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>((ptr));
return instance->isClosed();
}
extern "C" jboolean org_jetbrains_skia_PathMeasure__1nNextContour
(jlong ptr) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KBoolean org_jetbrains_skia_PathMeasure__1nNextContour
(KNativePointer ptr) {
SkPathMeasure* instance = reinterpret_cast<SkPathMeasure*>((ptr));
return instance->nextContour();
}
skiko/src/nativeMain/cpp/generated/PathSegmentIterator.cc → skiko/src/commonMain/cpp/generated/PathSegmentIterator.cc
View file @ 4b6f133a
......@@ -4,11 +4,11 @@
#include "SkPath.h"
#include "common.h"
extern "C" jlong org_jetbrains_skia_PathSegmentIterator__1nMake
(jlong pathPtr, jboolean forceClose) {
SkPath* path = reinterpret_cast<SkPath*>(static_cast<uintptr_t>(pathPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathSegmentIterator__1nMake
(KNativePointer pathPtr, KBoolean forceClose) {
SkPath* path = reinterpret_cast<SkPath*>((pathPtr));
SkPath::Iter* iter = new SkPath::Iter(*path, forceClose);
return reinterpret_cast<jlong>(iter);
return reinterpret_cast<KNativePointer>(iter);
}
static void deletePathSegmentIterator(SkPath::Iter* iter) {
......@@ -16,31 +16,31 @@ static void deletePathSegmentIterator(SkPath::Iter* iter) {
delete iter;
}
extern "C" jlong org_jetbrains_skia_PathSegmentIterator__1nGetFinalizer
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PathSegmentIterator__1nGetFinalizer
() {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deletePathSegmentIterator));
return reinterpret_cast<KNativePointer>((&deletePathSegmentIterator));
}
extern "C" jobject org_jetbrains_skia_PathSegmentIterator__1nNext
(jlong ptr) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_PathSegmentIterator__1nNext
(KNativePointer ptr) {
TODO("implement org_jetbrains_skia_PathSegmentIterator__1nNext");
}
#if 0
extern "C" jobject org_jetbrains_skia_PathSegmentIterator__1nNext
(jlong ptr) {
SkPath::Iter* instance = reinterpret_cast<SkPath::Iter*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_PathSegmentIterator__1nNext
(KNativePointer ptr) {
SkPath::Iter* instance = reinterpret_cast<SkPath::Iter*>((ptr));
SkPoint pts[4];
SkPath::Verb verb = instance->next(pts);
jobject segment;
KInteropPointer 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());
segment = env->NewObject(skija::PathSegment::cls, skija::PathSegment::ctorMoveClose, static_cast<KInt>(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());
......
skiko/src/nativeMain/cpp/generated/Picture.cc → skiko/src/commonMain/cpp/generated/Picture.cc
View file @ 4b6f133a
......@@ -7,24 +7,24 @@
#include "SkShader.h"
#include "common.h"
extern "C" jlong org_jetbrains_skia_Picture__1nMakeFromData
(jlong dataPtr) {
SkData* data = reinterpret_cast<SkData*>(static_cast<uintptr_t>(dataPtr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Picture__1nMakeFromData
(KNativePointer dataPtr) {
SkData* data = reinterpret_cast<SkData*>((dataPtr));
SkPicture* instance = SkPicture::MakeFromData(data).release();
return reinterpret_cast<jlong>(instance);
return reinterpret_cast<KNativePointer>(instance);
}
extern "C" void org_jetbrains_skia_Picture__1nPlayback
(jlong ptr, jlong canvasPtr, jobject abort) {
SKIKO_EXPORT void org_jetbrains_skia_Picture__1nPlayback
(KNativePointer ptr, KNativePointer canvasPtr, KInteropPointer abort) {
TODO("implement org_jetbrains_skia_Picture__1nPlayback");
}
#if 0
extern "C" void org_jetbrains_skia_Picture__1nPlayback
(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));
SKIKO_EXPORT void org_jetbrains_skia_Picture__1nPlayback
(KNativePointer ptr, KNativePointer canvasPtr, KInteropPointer abort) {
SkPicture* instance = reinterpret_cast<SkPicture*>((ptr));
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
if (abort == nullptr) {
instance->playback(canvas, nullptr);
} else {
......@@ -36,69 +36,69 @@ extern "C" void org_jetbrains_skia_Picture__1nPlayback
extern "C" jobject org_jetbrains_skia_Picture__1nGetCullRect
(jlong ptr) {
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Picture__1nGetCullRect
(KNativePointer ptr) {
TODO("implement org_jetbrains_skia_Picture__1nGetCullRect");
}
#if 0
extern "C" jobject org_jetbrains_skia_Picture__1nGetCullRect
(jlong ptr) {
SkPicture* instance = reinterpret_cast<SkPicture*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInteropPointer org_jetbrains_skia_Picture__1nGetCullRect
(KNativePointer ptr) {
SkPicture* instance = reinterpret_cast<SkPicture*>((ptr));
return skija::Rect::fromSkRect(env, instance->cullRect());
}
#endif
extern "C" jint org_jetbrains_skia_Picture__1nGetUniqueId
(jlong ptr) {
SkPicture* instance = reinterpret_cast<SkPicture*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_Picture__1nGetUniqueId
(KNativePointer ptr) {
SkPicture* instance = reinterpret_cast<SkPicture*>((ptr));
return instance->uniqueID();
}
extern "C" jlong org_jetbrains_skia_Picture__1nSerializeToData
(jlong ptr) {
SkPicture* instance = reinterpret_cast<SkPicture*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Picture__1nSerializeToData
(KNativePointer ptr) {
SkPicture* instance = reinterpret_cast<SkPicture*>((ptr));
SkData* data = instance->serialize().release();
return reinterpret_cast<jlong>(data);
return reinterpret_cast<KNativePointer>(data);
}
extern "C" jlong org_jetbrains_skia_Picture__1nMakePlaceholder
(jfloat left, jfloat top, jfloat right, jfloat bottom) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Picture__1nMakePlaceholder
(KFloat left, KFloat top, KFloat right, KFloat bottom) {
SkRect cull = SkRect::MakeLTRB(left, top, right, bottom);
SkPicture* instance = SkPicture::MakePlaceholder(cull).release();
return reinterpret_cast<jlong>(instance);
return reinterpret_cast<KNativePointer>(instance);
}
extern "C" jint org_jetbrains_skia_Picture__1nGetApproximateOpCount
(jlong ptr) {
SkPicture* instance = reinterpret_cast<SkPicture*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KInt org_jetbrains_skia_Picture__1nGetApproximateOpCount
(KNativePointer ptr) {
SkPicture* instance = reinterpret_cast<SkPicture*>((ptr));
return instance->approximateOpCount();
}
extern "C" jlong org_jetbrains_skia_Picture__1nGetApproximateBytesUsed
(jlong ptr) {
SkPicture* instance = reinterpret_cast<SkPicture*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KLong org_jetbrains_skia_Picture__1nGetApproximateBytesUsed
(KNativePointer ptr) {
SkPicture* instance = reinterpret_cast<SkPicture*>((ptr));
return instance->approximateBytesUsed();
}
extern "C" jlong org_jetbrains_skia_Picture__1nMakeShader
(jlong ptr, jint tmxValue, jint tmyValue, jint filterModeValue, jfloatArray localMatrixArr, jobject tileRectObj) {
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Picture__1nMakeShader
(KNativePointer ptr, KInt tmxValue, KInt tmyValue, KInt filterModeValue, KFloat* localMatrixArr, KInteropPointer tileRectObj) {
TODO("implement org_jetbrains_skia_Picture__1nMakeShader");
}
#if 0
extern "C" jlong org_jetbrains_skia_Picture__1nMakeShader
(jlong ptr, jint tmxValue, jint tmyValue, jint filterModeValue, jfloatArray localMatrixArr, jobject tileRectObj) {
SkPicture* instance = reinterpret_cast<SkPicture*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_Picture__1nMakeShader
(KNativePointer ptr, KInt tmxValue, KInt tmyValue, KInt filterModeValue, KFloat* localMatrixArr, KInteropPointer tileRectObj) {
SkPicture* instance = reinterpret_cast<SkPicture*>((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);
return reinterpret_cast<KNativePointer>(shader);
}
#endif
skiko/src/nativeMain/cpp/generated/PictureRecorder.cc → skiko/src/commonMain/cpp/generated/PictureRecorder.cc
View file @ 4b6f133a
......@@ -11,48 +11,48 @@ static void deletePictureRecorder(SkPictureRecorder* pr) {
delete pr;
}
extern "C" jlong org_jetbrains_skia_PictureRecorder__1nMake
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PictureRecorder__1nMake
() {
SkPictureRecorder* instance = new SkPictureRecorder();
return reinterpret_cast<jlong>(instance);
return reinterpret_cast<KNativePointer>(instance);
}
extern "C" jlong org_jetbrains_skia_PictureRecorder__1nGetFinalizer
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PictureRecorder__1nGetFinalizer
() {
return static_cast<jlong>(reinterpret_cast<uintptr_t>(&deletePictureRecorder));
return reinterpret_cast<KNativePointer>((&deletePictureRecorder));
}
extern "C" jlong org_jetbrains_skia_PictureRecorder__1nBeginRecording
(jlong ptr, jfloat left, jfloat top, jfloat right, jfloat bottom) {
SkPictureRecorder* instance = reinterpret_cast<SkPictureRecorder*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PictureRecorder__1nBeginRecording
(KNativePointer ptr, KFloat left, KFloat top, KFloat right, KFloat bottom) {
SkPictureRecorder* instance = reinterpret_cast<SkPictureRecorder*>((ptr));
SkCanvas* canvas = instance->beginRecording(SkRect::MakeLTRB(left, top, right, bottom), nullptr);
return reinterpret_cast<jlong>(canvas);
return reinterpret_cast<KNativePointer>(canvas);
}
extern "C" jlong org_jetbrains_skia_PictureRecorder__1nGetRecordingCanvas
(jlong ptr) {
SkPictureRecorder* instance = reinterpret_cast<SkPictureRecorder*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PictureRecorder__1nGetRecordingCanvas
(KNativePointer ptr) {
SkPictureRecorder* instance = reinterpret_cast<SkPictureRecorder*>((ptr));
SkCanvas* canvas = instance->getRecordingCanvas();
return reinterpret_cast<jlong>(canvas);
return reinterpret_cast<KNativePointer>(canvas);
}
extern "C" jlong org_jetbrains_skia_PictureRecorder__1nFinishRecordingAsPicture
(jlong ptr) {
SkPictureRecorder* instance = reinterpret_cast<SkPictureRecorder*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PictureRecorder__1nFinishRecordingAsPicture
(KNativePointer ptr) {
SkPictureRecorder* instance = reinterpret_cast<SkPictureRecorder*>((ptr));
SkPicture* picture = instance->finishRecordingAsPicture().release();
return reinterpret_cast<jlong>(picture);
return reinterpret_cast<KNativePointer>(picture);
}
extern "C" jlong org_jetbrains_skia_PictureRecorder__1nFinishRecordingAsPictureWithCull
(jlong ptr, jfloat left, jfloat top, jfloat right, jfloat bottom) {
SkPictureRecorder* instance = reinterpret_cast<SkPictureRecorder*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PictureRecorder__1nFinishRecordingAsPictureWithCull
(KNativePointer ptr, KFloat left, KFloat top, KFloat right, KFloat bottom) {
SkPictureRecorder* instance = reinterpret_cast<SkPictureRecorder*>((ptr));
SkPicture* picture = instance->finishRecordingAsPictureWithCull(SkRect::MakeLTRB(left, top, right, bottom)).release();
return reinterpret_cast<jlong>(picture);
return reinterpret_cast<KNativePointer>(picture);
}
extern "C" jlong org_jetbrains_skia_PictureRecorder__1nFinishRecordingAsDrawable
(jlong ptr) {
SkPictureRecorder* instance = reinterpret_cast<SkPictureRecorder*>(static_cast<uintptr_t>(ptr));
SKIKO_EXPORT KNativePointer org_jetbrains_skia_PictureRecorder__1nFinishRecordingAsDrawable
(KNativePointer ptr) {
SkPictureRecorder* instance = reinterpret_cast<SkPictureRecorder*>((ptr));
SkDrawable* drawable = instance->finishRecordingAsDrawable().release();
return reinterpret_cast<jlong>(drawable);
return reinterpret_cast<KNativePointer>(drawable);
}
skiko/src/commonMain/cpp/generated/PixelRef.cc 0 → 100644
View file @ 4b6f133a
This diff is collapsed.
skiko/src/commonMain/cpp/generated/Pixmap.cc 0 → 100644
View file @ 4b6f133a
This diff is collapsed.
skiko/src/commonMain/cpp/generated/Region.cc 0 → 100644
View file @ 4b6f133a
This diff is collapsed.
skiko/src/nativeMain/cpp/generated/ShadowUtils.cc → skiko/src/commonMain/cpp/generated/ShadowUtils.cc
View file @ 4b6f133a
......@@ -4,23 +4,23 @@
#include "SkShadowUtils.h"
#include "common.h"
extern "C" void org_jetbrains_skia_ShadowUtils__1nDrawShadow
(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));
SKIKO_EXPORT void org_jetbrains_skia_ShadowUtils__1nDrawShadow
(KNativePointer canvasPtr, KNativePointer pathPtr, KFloat zPlaneX, KFloat zPlaneY, KFloat zPlaneZ,
KFloat lightPosX, KFloat lightPosY, KFloat lightPosZ, KFloat lightRadius, KInt ambientColor, KInt spotColor, KInt flags) {
SkCanvas* canvas = reinterpret_cast<SkCanvas*>((canvasPtr));
SkPath* path = reinterpret_cast<SkPath*>((pathPtr));
SkShadowUtils::DrawShadow(canvas, *path, {zPlaneX, zPlaneY, zPlaneZ}, {lightPosX, lightPosY, lightPosZ}, lightRadius, ambientColor, spotColor, flags);
}
extern "C" int org_jetbrains_skia_ShadowUtils__1nComputeTonalAmbientColor
(jint ambientColor, jint spotColor) {
SKIKO_EXPORT int org_jetbrains_skia_ShadowUtils__1nComputeTonalAmbientColor
(KInt ambientColor, KInt spotColor) {
SkColor outAmbientColor, outSpotColor;
SkShadowUtils::ComputeTonalColors(ambientColor, spotColor, &outAmbientColor, &outSpotColor);
return outAmbientColor;
}
extern "C" int org_jetbrains_skia_ShadowUtils__1nComputeTonalSpotColor
(jint ambientColor, jint spotColor) {
SKIKO_EXPORT int org_jetbrains_skia_ShadowUtils__1nComputeTonalSpotColor
(KInt ambientColor, KInt spotColor) {
SkColor outAmbientColor, outSpotColor;
SkShadowUtils::ComputeTonalColors(ambientColor, spotColor, &outAmbientColor, &outSpotColor);
return outSpotColor;
......
skiko/src/commonMain/cpp/generated/TextBlob.cc 0 → 100644
View file @ 4b6f133a
This diff is collapsed.
skiko/src/commonMain/cpp/generated/U16String.cc 0 → 100644
View file @ 4b6f133a
This diff is collapsed.
skiko/src/commonMain/cpp/generated/paragraph/FontCollection.cc 0 → 100644
View file @ 4b6f133a
This diff is collapsed.
skiko/src/commonMain/cpp/generated/paragraph/Paragraph.cc 0 → 100644
View file @ 4b6f133a
This diff is collapsed.
skiko/src/commonMain/cpp/generated/paragraph/StrutStyle.cc 0 → 100644
View file @ 4b6f133a
This diff is collapsed.
skiko/src/commonMain/cpp/generated/shaper/Shaper.cc 0 → 100644
View file @ 4b6f133a
This diff is collapsed.
skiko/src/commonMain/cpp/generated/svg/SVGNode.cc 0 → 100644
View file @ 4b6f133a
This diff is collapsed.
skiko/src/commonMain/cpp/headers/types.h deleted 100644 → 0
View file @ d6008a3a
This diff is collapsed.
skiko/src/commonMain/cpp/types.h 0 → 100644
View file @ 4b6f133a
This diff is collapsed.
skiko/src/jsMain/cpp/BackendRenderTarget.cc deleted 100644 → 0
View file @ d6008a3a
This diff is collapsed.
skiko/src/jsMain/cpp/ColorFilter.cc deleted 100644 → 0
View file @ d6008a3a
This diff is collapsed.
skiko/src/jsMain/cpp/ColorSpace.cc deleted 100644 → 0
View file @ d6008a3a
This diff is collapsed.
skiko/src/jsMain/cpp/NotoMono-Regular.ttf.cc 0 → 100644
View file @ 4b6f133a
This diff is collapsed.
skiko/src/jvmMain/cpp/common/interop.cc
View file @ 4b6f133a
This diff is collapsed.
skiko/src/jvmMain/cpp/common/interop.hh
View file @ 4b6f133a
This diff is collapsed.
skiko/src/nativeMain/cpp/common/native_interop.cc deleted 100644 → 0
View file @ d6008a3a
This diff is collapsed.
skiko/src/nativeMain/cpp/generated/Data.cc deleted 100644 → 0
View file @ d6008a3a
This diff is collapsed.
skiko/src/nativeMain/cpp/generated/Paint.cc deleted 100644 → 0
View file @ d6008a3a
This diff is collapsed.
skiko/src/nativeMain/cpp/generated/PixelRef.cc deleted 100644 → 0
View file @ d6008a3a
This diff is collapsed.
skiko/src/nativeMain/cpp/generated/Pixmap.cc deleted 100644 → 0
View file @ d6008a3a
This diff is collapsed.
skiko/src/nativeMain/cpp/generated/Region.cc deleted 100644 → 0
View file @ d6008a3a
This diff is collapsed.
skiko/src/nativeMain/cpp/generated/TextBlob.cc deleted 100644 → 0
View file @ d6008a3a
This diff is collapsed.
skiko/src/nativeMain/cpp/generated/U16String.cc deleted 100644 → 0
View file @ d6008a3a
This diff is collapsed.
skiko/src/nativeMain/cpp/generated/shaper/Shaper.cc deleted 100644 → 0
View file @ d6008a3a
This diff is collapsed.
skiko/src/nativeMain/cpp/generated/svg/SVGNode.cc deleted 100644 → 0
View file @ d6008a3a
This diff is collapsed.
skiko/src/nativeMain/cpp/include/native_interop.h deleted 100644 → 0
View file @ d6008a3a
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