Fix fallback (#144)

* Fix fallback on VM

* Added Intel(R) HD Graphics 2000 to adapter blacklist for OpenGL

* Fix fallback from OpenGLon VMs.

* Added llvmpipe to adapter blacklist for OpenGL

* Added Intel(R) HD Graphics 3000 to adapter blacklist for OpenGL.

* Removed Microsoft Basic Render Driver from adpaters blacklist for DirectX 12.

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

@@ -8,6 +8,8 @@
 #include <GL/gl.h>
 #endif
 #include <jni.h>
+#include <string>
+#include <vector>
 
 extern "C" {
 

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

@@ -30,12 +30,11 @@
 
 const int BuffersCount = 2;
 
-// This is a blacklist of graphics cards that have rendering issues (black screen, flickering)
+// This is a list of not supported graphics cards that have rendering issues (black screen, flickering)
 // with the current Swing/Skia integration.
 // If PC has other graphics cards suitable for DirectX12, one of them will be used. Otherwise,
 // rendering will falls back to OpenGL.
-const std::vector<std::wstring> adapterBlacklist{
-    L"Microsoft Basic Render Driver",
+const std::vector<std::wstring> notSupportedAdapters{
     L"Intel(R) HD Graphics 520",
     L"Intel(R) HD Graphics 530",
     L"Intel(R) HD Graphics 4400",
@@ -205,7 +204,7 @@ extern "C"
         return impl(pSrcData, SrcDataSize, pSourceName, pDefines, pInclude, pEntrypoint, pTarget, Flags1, Flags2, ppCode, ppErrorMsgs);
     }
 
-    bool isBlacklisted(IDXGIAdapter1 *hardwareAdapter)
+    bool isNotSupported(IDXGIAdapter1 *hardwareAdapter)
     {
         DXGI_ADAPTER_DESC1 desc;
         hardwareAdapter->GetDesc1(&desc);
@@ -214,11 +213,11 @@ extern "C"
             return true;
         }
         std::wstring currentAdapterName(desc.Description);
-        for (std::wstring name : adapterBlacklist)
+        for (std::wstring name : notSupportedAdapters)
         {
             if (currentAdapterName == name)
             {
-                fwprintf(stderr, L"Graphics card: %s is blacklisted.\n", name.c_str());
+                fwprintf(stderr, L"Graphics card %s is not supported.\n", name.c_str());
                 return true;
             }
         }
@@ -242,7 +241,7 @@ extern "C"
                 }
                 if (SUCCEEDED(D3D12CreateDevice(pAdapter, D3D_FEATURE_LEVEL_11_0, _uuidof(ID3D12Device), nullptr)))
                 {
-                    if (isBlacklisted(pAdapter))
+                    if (isNotSupported(pAdapter))
                     {
                         pAdapter->Release();
                         continue;
@@ -266,7 +265,7 @@ extern "C"
                 }
                 if (SUCCEEDED(D3D12CreateDevice(pAdapter, D3D_FEATURE_LEVEL_11_0, _uuidof(ID3D12Device), nullptr)))
                 {
-                    if (isBlacklisted(pAdapter))
+                    if (isNotSupported(pAdapter))
                     {
                         pAdapter->Release();
                         continue;

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

 #define WIN32_LEAN_AND_MEAN
+#include <vector>
+#include <string>
 #include <windows.h>
+#include <wingdi.h>
 #include <gl/GL.h>
 #include <jawt_md.h>
 #include <dwmapi.h>

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

 package org.jetbrains.skiko
 
+import org.jetbrains.skiko.redrawer.Redrawer
+import org.jetbrains.skiko.redrawer.WindowsOpenGLRedrawer
+import org.jetbrains.skiko.redrawer.LinuxOpenGLRedrawer
+
 enum class GraphicsApi {
     UNKNOWN, SOFTWARE, OPENGL, DIRECT3D, VULKAN, METAL
 }
@@ -11,3 +15,32 @@ enum class GpuPriority(val value: String) {
         fun parse(value: String?): GpuPriority? = GpuPriority.values().find { it.value == value }
     }
 }
+
+private val notSupportedAdapters by lazy {
+    val resource = SkiaLayer::class.java.getResource("/not-supported-adapter.list").readText()
+    resource.split(";").map { it.trim() }
+}
+
+internal fun isVideoCardSupported(renderApi: GraphicsApi): Boolean {
+    return when (renderApi) {
+        GraphicsApi.DIRECT3D -> {
+            true
+        }
+        GraphicsApi.OPENGL -> {
+            val gl = OpenGLApi.instance
+            val adaptersList = notSupportedAdapters.filter { it.startsWith("opengl:") }.map {
+                it.replace("opengl:", "")
+            }
+            var adapter = gl.glGetString(gl.GL_RENDERER)
+            adaptersList.forEach {
+                if (adapter.startsWith(it)) {
+                    return false
+                }
+            }
+            true
+        }
+        else -> true
+    }
+}
+
+private external fun getNextDirectXAdapter(index: Int = 0): String?

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

@@ -129,6 +129,7 @@ open class SkiaLayer(
                 redrawer = platformOperations.createRedrawer(this, renderApi, properties)
                 if (redraw) redrawer!!.redrawImmediately()
             } catch (e: IllegalArgumentException) {
+                println(e.message)
                 thrown = true
             }
         } while (thrown)

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/redrawer/LinuxOpenGLRedrawer.kt

@@ -10,13 +10,19 @@ import org.jetbrains.skiko.OpenGLApi
 import org.jetbrains.skiko.SkiaLayer
 import org.jetbrains.skiko.SkiaLayerProperties
 import org.jetbrains.skiko.getDrawingSurface
+import org.jetbrains.skiko.isVideoCardSupported
 
 internal class LinuxOpenGLRedrawer(
     private val layer: SkiaLayer,
     private val properties: SkiaLayerProperties
 ) : Redrawer {
     private val context = layer.backedLayer.lockDrawingSurface {
-        it.createContext().also { if (it == 0L) throw IllegalArgumentException("Cannot create Linux GL context") }
+        val result = it.createContext()
+        it.makeCurrent(result)
+        if (result == 0L || !isVideoCardSupported(layer.renderApi)) {
+            throw IllegalArgumentException("Cannot create Linux GL context")
+        }
+        result
     }
     private var isDisposed = false
 

skiko/src/jvmMain/kotlin/org/jetbrains/skiko/redrawer/WindowsOpenGLRedrawer.kt

@@ -5,6 +5,7 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.swing.Swing
 import kotlinx.coroutines.withContext
 import org.jetbrains.skiko.FrameDispatcher
+import org.jetbrains.skiko.isVideoCardSupported
 import org.jetbrains.skiko.OpenGLApi
 import org.jetbrains.skiko.SkiaLayer
 import org.jetbrains.skiko.SkiaLayerProperties
@@ -15,7 +16,12 @@ internal class WindowsOpenGLRedrawer(
     private val properties: SkiaLayerProperties
 ) : Redrawer {
     private val device = layer.backedLayer.useDrawingSurfacePlatformInfo(::getDevice)
-    private val context = createContext(device)
+    private val context = createContext(device).also {
+        makeCurrent(device, it)
+        if (it == 0L || !isVideoCardSupported(layer.renderApi)) {
+            throw IllegalArgumentException("Cannot create Windows GL context")
+        }
+    }
     private var isDisposed = false
 
     init {

skiko/src/jvmMain/resources/not-supported-adapter.list

+directx:Intel(R) HD Graphics 520;
+directx:Intel(R) HD Graphics 530;
+directx:Intel(R) HD Graphics 4400;
+directx:NVIDIA GeForce GTX 750 Ti;
+directx:NVIDIA GeForce GTX 960M;
+directx:NVIDIA Quadro M2000M;
+opengl:Intel(R) HD Graphics 2000;
+opengl:Intel(R) HD Graphics 3000;
+opengl:llvmpipe;
\ No newline at end of file