Refactoring: BuffersCount, toJavaPointer, fromJavaPointer, directXRedrawer.

skiko/src/jvmMain/cpp/windows/directXRedrawer.cc

 #ifdef SK_DIRECT3D
 #include <windows.h>
 #include <jawt_md.h>
+#include "jni_helpers.h"
+
 #include "GrBackendSurface.h"
 #include "GrDirectContext.h"
 #include "SkSurface.h"
@@ -11,6 +13,7 @@
 #include <d3d12.h>
 #include <dxgi1_4.h>
 
+
 #define GR_D3D_CALL_ERRCHECK(X)                                        \
     do                                                                 \
     {                                                                  \
@@ -22,7 +25,7 @@
         }                                                              \
     } while (false)
 
-extern "C" jboolean Skiko_GetAWT(JNIEnv *env, JAWT *awt);
+const int BuffersCount = 2;
 
 class DirectXDevice
 {
@@ -49,15 +52,15 @@ extern "C"
     JNIEXPORT jlong JNICALL Java_org_jetbrains_skiko_redrawer_Direct3DRedrawer_makeDirectXContext(
         JNIEnv* env, jobject redrawer, jlong devicePtr)
     {
-        DirectXDevice *d3dDevice = reinterpret_cast<DirectXDevice *>(static_cast<uintptr_t>(devicePtr));
+        DirectXDevice *d3dDevice = fromJavaPointer<DirectXDevice*>(devicePtr);
         GrD3DBackendContext backendContext = d3dDevice->backendContext;
-        return reinterpret_cast<jlong>(GrDirectContext::MakeDirect3D(backendContext).release());
+        return toJavaPointer(GrDirectContext::MakeDirect3D(backendContext).release());
     }
 
     JNIEXPORT jlong JNICALL Java_org_jetbrains_skiko_redrawer_Direct3DRedrawer_makeDirectXRenderTarget(
         JNIEnv * env, jobject redrawer, jlong devicePtr, jint width, jint height)
     {
-        DirectXDevice *d3dDevice = reinterpret_cast<DirectXDevice *>(static_cast<uintptr_t>(devicePtr));
+        DirectXDevice *d3dDevice = fromJavaPointer<DirectXDevice*>(devicePtr);
         d3dDevice->bufferIndex = d3dDevice->swapChain->GetCurrentBackBufferIndex();
         ID3D12Resource* buffer;
         GR_D3D_CALL_ERRCHECK(d3dDevice->swapChain->GetBuffer(d3dDevice->bufferIndex, IID_PPV_ARGS(&buffer)));
@@ -69,7 +72,7 @@ extern "C"
                                       1,
                                       0);
         GrBackendRenderTarget* renderTarget = new GrBackendRenderTarget(width, height, info);
-        return reinterpret_cast<jlong>(renderTarget);
+        return toJavaPointer(renderTarget);
     }
 
     void defineHardwareAdapter(IDXGIFactory4 *pFactory, IDXGIAdapter1 **ppAdapter)
@@ -127,13 +130,13 @@ extern "C"
         d3dDevice->device = device;
         d3dDevice->queue = queue;
 
-        return reinterpret_cast<jlong>(d3dDevice);
+        return toJavaPointer(d3dDevice);
     }
 
     JNIEXPORT void JNICALL Java_org_jetbrains_skiko_redrawer_Direct3DRedrawer_createSwapChain(
         JNIEnv *env, jobject redrawer, jlong windowHandle, jlong devicePtr)
     {
-        DirectXDevice *d3dDevice = reinterpret_cast<DirectXDevice *>(static_cast<uintptr_t>(devicePtr));
+        DirectXDevice *d3dDevice = fromJavaPointer<DirectXDevice*>(devicePtr);
 
         // Make the swapchain
         HWND fWindow = (HWND)windowHandle;
@@ -142,7 +145,7 @@ extern "C"
         GR_D3D_CALL_ERRCHECK(CreateDXGIFactory2(0, IID_PPV_ARGS(&factory)));
 
         DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {};
-        swapChainDesc.BufferCount = 2;
+        swapChainDesc.BufferCount = BuffersCount;
         swapChainDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
         swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
         swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
@@ -161,10 +164,10 @@ extern "C"
     JNIEXPORT void JNICALL Java_org_jetbrains_skiko_redrawer_Direct3DRedrawer_resizeBuffers(
         JNIEnv *env, jobject redrawer, jlong devicePtr, jint width, jint height)
     {
-        DirectXDevice *d3dDevice = reinterpret_cast<DirectXDevice *>(static_cast<uintptr_t>(devicePtr));
+        DirectXDevice *d3dDevice = fromJavaPointer<DirectXDevice*>(devicePtr);
         if (!d3dDevice->isSizeEqualTo(width, height))
         {
-            GR_D3D_CALL_ERRCHECK(d3dDevice->swapChain->ResizeBuffers(2, width, height, DXGI_FORMAT_R8G8B8A8_UNORM, 0));
+            GR_D3D_CALL_ERRCHECK(d3dDevice->swapChain->ResizeBuffers(BuffersCount, width, height, DXGI_FORMAT_R8G8B8A8_UNORM, 0));
             d3dDevice->bufferWidth = width;
             d3dDevice->bufferHeight = height;
         }
@@ -173,11 +176,11 @@ extern "C"
     JNIEXPORT void JNICALL Java_org_jetbrains_skiko_redrawer_Direct3DRedrawer_finishFrame(
         JNIEnv *env, jobject redrawer, jlong devicePtr, jlong contextPtr, jlong surfacePtr)
     {
-        DirectXDevice *d3dDevice = reinterpret_cast<DirectXDevice *>(static_cast<uintptr_t>(devicePtr));
+        DirectXDevice *d3dDevice = fromJavaPointer<DirectXDevice*>(devicePtr);
 
-        SkSurface *surface = reinterpret_cast<SkSurface *>(static_cast<uintptr_t>(surfacePtr));
+        SkSurface *surface = fromJavaPointer<SkSurface*>(surfacePtr);
         surface->flushAndSubmit();
-        GrDirectContext *fContext = reinterpret_cast<GrDirectContext *>(static_cast<uintptr_t>(contextPtr));
+        GrDirectContext *fContext = fromJavaPointer<GrDirectContext*>(contextPtr);
         surface->flush(SkSurface::BackendSurfaceAccess::kPresent, GrFlushInfo());
         fContext->flush({});
         fContext->submit(true);

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/SkiaLayer.kt

@@ -26,7 +26,7 @@ open class SkiaLayer : HardwareLayer() {
 
     @Volatile
     private var isDisposed = false
-    private var redrawer: Redrawer? = null
+    internal var redrawer: Redrawer? = null
 
     @Volatile
     private var picture: PictureHolder? = null
@@ -103,7 +103,7 @@ open class SkiaLayer : HardwareLayer() {
     override fun draw() {
         check(!isDisposed)
         contextHandler.apply {
-            if (!initContext(redrawer!!)) {
+            if (!initContext()) {
                 fallbackToRaster()
                 return
             }

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/SkikoProperties.kt

@@ -30,10 +30,12 @@ internal object SkikoProperties {
             "SOFTWARE" -> return GraphicsApi.SOFTWARE
             "OPENGL" -> return GraphicsApi.OPENGL
             "DIRECT3D" -> {
-                return if (hostOs == OS.Windows) GraphicsApi.DIRECT3D else bestRenderApiForCurrentOS()
+                return if (hostOs == OS.Windows) GraphicsApi.DIRECT3D
+                    else throw Exception("$hostOs does not support DirectX rendering API.")
             }
             "METAL" -> {
-                return if (hostOs == OS.MacOS) GraphicsApi.METAL else bestRenderApiForCurrentOS()
+                return if (hostOs == OS.MacOS) GraphicsApi.METAL
+                    else throw Exception("$hostOs does not support Metal rendering API.")
             }
             else -> return bestRenderApiForCurrentOS()
         }

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/context/ContextHandler.kt

@@ -6,13 +6,13 @@ import org.jetbrains.skija.DirectContext
 import org.jetbrains.skija.Picture
 import org.jetbrains.skija.Surface
 import org.jetbrains.skiko.GraphicsApi
-import org.jetbrains.skiko.HardwareLayer
+import org.jetbrains.skiko.SkiaLayer
 import org.jetbrains.skiko.OS
 import org.jetbrains.skiko.SkikoProperties
 import org.jetbrains.skiko.hostOs
 import org.jetbrains.skiko.redrawer.Redrawer
 
-internal fun createContextHandler(layer: HardwareLayer): ContextHandler {
+internal fun createContextHandler(layer: SkiaLayer): ContextHandler {
     return when (SkikoProperties.renderApi) {
         GraphicsApi.SOFTWARE -> SoftwareContextHandler(layer)
         GraphicsApi.OPENGL -> OpenGLContextHandler(layer)
@@ -21,14 +21,14 @@ internal fun createContextHandler(layer: HardwareLayer): ContextHandler {
     }
 }
 
-internal abstract class ContextHandler(val layer: HardwareLayer) {
+internal abstract class ContextHandler(val layer: SkiaLayer) {
     open val bleachConstant = if (hostOs == OS.MacOS) 0 else -1
     var context: DirectContext? = null
     var renderTarget: BackendRenderTarget? = null
     var surface: Surface? = null
     var canvas: Canvas? = null
 
-    abstract fun initContext(redrawer: Redrawer): Boolean
+    abstract fun initContext(): Boolean
 
     abstract fun initCanvas()
 

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/context/Direct3DContextHandler.kt

@@ -7,19 +7,17 @@ import org.jetbrains.skija.Surface
 import org.jetbrains.skija.SurfaceColorFormat
 import org.jetbrains.skija.SurfaceOrigin
 import org.jetbrains.skija.impl.Native
-import org.jetbrains.skiko.HardwareLayer
 import org.jetbrains.skiko.SkiaLayer
 import org.jetbrains.skiko.redrawer.Direct3DRedrawer
 import org.jetbrains.skiko.redrawer.Redrawer
 
-internal class Direct3DContextHandler(layer: HardwareLayer) : ContextHandler(layer) {
-    lateinit var directXRedrawer: Direct3DRedrawer
+internal class Direct3DContextHandler(layer: SkiaLayer) : ContextHandler(layer) {
+    val directXRedrawer: Direct3DRedrawer
+        get() = layer.redrawer!! as Direct3DRedrawer
+
     var device: Long = 0
-    override fun initContext(redrawer: Redrawer): Boolean {
+    override fun initContext(): Boolean {
         try {
-            if (!this::directXRedrawer.isInitialized) {
-                directXRedrawer = redrawer as Direct3DRedrawer
-            }
             if (context == null) {
                 device = directXRedrawer.createDevice()
                 directXRedrawer.createSwapChain(layer.windowHandle, device)

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/context/MetalContextHandler.kt

@@ -5,13 +5,13 @@ import org.jetbrains.skija.Surface
 import org.jetbrains.skija.SurfaceColorFormat
 import org.jetbrains.skija.SurfaceOrigin
 import org.jetbrains.skiko.GraphicsApi
-import org.jetbrains.skiko.HardwareLayer
+import org.jetbrains.skiko.SkiaLayer
 import org.jetbrains.skiko.makeMetalContext
 import org.jetbrains.skiko.makeMetalRenderTarget
 import org.jetbrains.skiko.redrawer.Redrawer
 
-internal class MetalContextHandler(layer: HardwareLayer) : ContextHandler(layer) {
-    override fun initContext(redrawer: Redrawer): Boolean {
+internal class MetalContextHandler(layer: SkiaLayer) : ContextHandler(layer) {
+    override fun initContext(): Boolean {
         try {
             if (context == null) {
                 context = makeMetalContext()

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/context/OpenGLContextHandler.kt

@@ -6,14 +6,14 @@ import org.jetbrains.skija.Picture
 import org.jetbrains.skija.Surface
 import org.jetbrains.skija.SurfaceColorFormat
 import org.jetbrains.skija.SurfaceOrigin
-import org.jetbrains.skiko.HardwareLayer
+import org.jetbrains.skiko.SkiaLayer
 import org.jetbrains.skiko.makeGLContext
 import org.jetbrains.skiko.makeGLRenderTarget
 import org.jetbrains.skiko.OpenGLApi
 import org.jetbrains.skiko.redrawer.Redrawer
 
-internal class OpenGLContextHandler(layer: HardwareLayer) : ContextHandler(layer) {
-    override fun initContext(redrawer: Redrawer): Boolean {
+internal class OpenGLContextHandler(layer: SkiaLayer) : ContextHandler(layer) {
+    override fun initContext(): Boolean {
         try {
             if (context == null) {
                 context = makeGLContext()

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/context/SoftwareContextHandler.kt

@@ -14,12 +14,12 @@ import java.awt.image.Raster
 import org.jetbrains.skija.Bitmap
 import org.jetbrains.skija.ColorAlphaType
 import org.jetbrains.skija.Canvas
-import org.jetbrains.skiko.HardwareLayer
+import org.jetbrains.skiko.SkiaLayer
 import org.jetbrains.skija.ImageInfo
 import org.jetbrains.skija.Picture
 import org.jetbrains.skiko.redrawer.Redrawer
 
-internal class SoftwareContextHandler(layer: HardwareLayer) : ContextHandler(layer) {
+internal class SoftwareContextHandler(layer: SkiaLayer) : ContextHandler(layer) {
     override val bleachConstant = -1 // it looks like java.awt.Canvas doesn't support transparency
 
     val colorModel = ComponentColorModel(
@@ -34,7 +34,7 @@ internal class SoftwareContextHandler(layer: HardwareLayer) : ContextHandler(lay
     var imageData: ByteArray? = null
     var raster: WritableRaster? = null
 
-    override fun initContext(redrawer: Redrawer): Boolean {
+    override fun initContext(): Boolean {
         // Raster does not need context
         return true
     }