v0.7.6

Lwjgl 3.2.2-3, updated breaking change with native signatures shifting at the end the function address
Kotlin 1.3.21
Kotlintest 3.2.1
Shadow 4.0.4
Gradle 5.2.1 with Shadow workaround

Author: elect86

build.gradle

@@ -4,8 +4,8 @@ plugins {
     id 'maven'
     id 'java'
     id 'java-library'
-    id "org.jetbrains.kotlin.jvm" version "1.3.11"
-    id "com.github.johnrengelman.shadow" version '4.0.3'
+    id "org.jetbrains.kotlin.jvm" version "1.3.21"
+    id "com.github.johnrengelman.shadow" version '4.0.4'
 }
 
 // jitpack
@@ -14,11 +14,11 @@ group = 'com.github.kotlin-graphics'
 ext{
     moduleName = 'com.github.kotlin_graphics.uno'
     kotlin = 'org.jetbrains.kotlin:kotlin'
-    kotlin_version = '1.3.11'
-    kotlintest_version = '3.1.11'
-    gln_version = '980c4b28f15aabf881b30805e454d9df31b7f20c'
-    vkk_version = 'a0d037b48e'
-    lwjgl_version = "3.2.1"
+    kotlin_version = '1.3.21'
+    kotlintest_version = '3.2.1'
+    gln_version = '59182dd1021f0365e754335f3be13fd69b6b882b'
+    vkk_version = 'a593ed45c49422b19e74b165a97bcd4a1245e2fd'
+    lwjgl_version = "3.2.2-SNAPSHOT"
     lwjgl_natives = current() == WINDOWS ? "windows" : current() == LINUX ? "linux" : "macos"
 }
 
@@ -42,12 +42,6 @@ dependencies {
         if (it != "-vulkan" && it != "-jawt")
             runtime "org.lwjgl:lwjgl$it:$lwjgl_version:natives-$lwjgl_natives"
     }
-
-    constraints {
-        testImplementation("$kotlin-stdlib:$kotlin_version")
-        testImplementation("$kotlin-stdlib-jdk7:$kotlin_version")
-        testImplementation("$kotlin-reflect:$kotlin_version")
-    }
 }
 
 repositories {
@@ -58,12 +52,12 @@ repositories {
 }
 
 task sourcesJar(type: Jar, dependsOn: classes) {
-    classifier = 'sources'
+    archiveClassifier = 'sources'
     from sourceSets.main.allSource
 }
 
 task javadocJar(type: Jar, dependsOn: javadoc) {
-    classifier = 'javadoc'
+    archiveClassifier = 'javadoc'
     from javadoc.destinationDir
 }
 
@@ -76,3 +70,5 @@ jar {
     inputs.property("moduleName", moduleName)
     manifest.attributes('Automatic-Module-Name': moduleName)
 }
+
+shadowJar.archiveClassifier = 'all'

gradle/wrapper/gradle-wrapper.properties

@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.0-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-5.2.1-all.zip

src/main/kotlin/uno/awt/LwjglCanvas.kt

@@ -0,0 +1,313 @@
+package uno.awt
+
+import glm_.vec2.Vec2i
+import org.lwjgl.glfw.GLFWErrorCallback
+import org.lwjgl.opengl.GLUtil
+import org.lwjgl.system.Callback
+import org.lwjgl.system.jawt.JAWTDrawingSurface
+import org.lwjgl.system.jawt.JAWTFunctions
+import uno.glfw.GlfwWindow
+import uno.glfw.HWND
+import uno.glfw.VSync
+import uno.glfw.glfw
+import java.awt.Canvas
+import java.awt.Graphics
+import java.awt.event.ComponentAdapter
+import java.awt.event.ComponentEvent
+import javax.swing.SwingUtilities
+
+/**
+ * A Canvas component that uses OpenGL for rendering.
+ *
+ * Spasi:  GLFW saves the AWT window proc somewhere and replaces it with its own on `glfwAttachWin32Window`.
+ * It restores it back when the GLFW window is destroyed.
+ * The difference between key and mouse events is that for key events the GLFW window proc returns `DefWindowProcW(...)`,
+ * but for mouse events it returns 0, so the events do not propagate to AWT
+ *
+ * This implementation supports Windows only.
+ */
+abstract class LwjglCanvas(val glDebug: Boolean = false) : Canvas() {
+
+    val awt = JAWT()
+
+    lateinit var glfwWindow: GlfwWindow
+
+    var swapBuffers = true
+    var fps = true
+
+    var debugProc: Callback? = null
+
+    var awtDebug = false
+
+    lateinit var glfwErrorCallback: GLFWErrorCallback
+
+    private fun initInternal(hwnd: HWND) {
+//        println("LwjglCanvas.initInternal ${Date().toInstant()}")
+
+        initialized = true
+
+        glfwErrorCallback = GLFWErrorCallback.createPrint().set()
+
+        glfw {
+            init()
+            windowHint { debug = glDebug }
+        }
+
+        // glfwWindowHint can be used here to configure the GL context
+        glfwWindow = GlfwWindow.fromWin32Window(hwnd).apply {
+            makeContextCurrent()
+            createCapabilities(forwardCompatible = false)
+        }
+
+        glfwWindow.cursorPosCallback = { it.toString() }
+
+        if (glDebug)
+            debugProc = GLUtil.setupDebugMessageCallback()
+
+        glfw.swapInterval = VSync.OFF
+
+        init()
+
+        glfwWindow.unmakeContextCurrent()
+
+//        println("/LwjglCanvas.initInternal ${Date().toInstant()}")
+    }
+
+    var initialized = false
+    var resized = false
+    var animated = true
+
+//    lateinit var caps: Caps
+
+    //  According to jawt.h > This value may be cached
+    lateinit var surface: JAWTDrawingSurface
+
+    init {
+
+        if (!awt.get())
+            throw IllegalStateException("GetAWT failed")
+
+        // this avoids to calling the super method
+        this.addComponentListener(object : ComponentAdapter() {
+            override fun componentResized(e: ComponentEvent?) {
+//                println("resized")
+                resized = true
+            }
+//          Not working
+//            override fun componentHidden(e: ComponentEvent?) {
+//                println("hidden")
+//            }
+//
+//            override fun componentMoved(e: ComponentEvent?) {
+//                println("moved")
+//            }
+//
+//            override fun componentShown(e: ComponentEvent?) {
+//                println("shown")
+//            }
+        })
+
+        SwingUtilities.invokeAndWait {
+            surface = awt.getDrawingSurface(this)!!
+        }
+    }
+
+    /** critical, call paint without default g.clearRect, because it causes flickering */
+    override fun update(g: Graphics) = paint(g)//.also { println("update") }
+
+    var last = 0L
+    var time = 0L
+    var frames = 0
+
+    override fun paint(g: Graphics) {
+
+        if (awtDebug)
+            println("paint start " + Thread.currentThread().name)
+
+        // Lock the drawing surface
+        if (surface.lock() == JawtLock.ERROR)
+            throw IllegalStateException("ds->Lock() failed")
+
+        wrapped { hwnd ->
+
+            if (!initialized)
+                initInternal(hwnd)
+
+            glfwWindow.inContext {
+
+                if (resized) {
+//                    println("LwjglCanvas.reshape ${Date().toInstant()}")
+                    val newSize = Vec2i(width, height)
+                    glfwWindow.size = newSize
+                    reshape(newSize)
+                    resized = false
+//                    println("/LwjglCanvas.reshape ${Date().toInstant()}")
+                }
+
+//                println("LwjglCanvas.render ${Date().toInstant()}")
+                if (awtDebug)
+                    println("paint before render ")
+
+                render()
+
+//                println("/LwjglCanvas.render ${Date().toInstant()}")
+                if (awtDebug)
+                    println("paint end")
+
+                if (swapBuffers)
+                    glfwWindow.swapBuffers()
+
+                if (fps) {
+                    val now = System.currentTimeMillis()
+                    time += now - last
+                    last = now
+                    frames++
+                    if (time > 1000) {
+                        time %= 1000
+                        println("fps = $frames")
+                        frames = 0
+                    }
+                }
+            }
+        }
+
+        if (animated)
+            repaint()
+    }
+
+    /*override fun paint(g: Graphics) {
+        if (awtDebug) {
+            println("paint start " + Thread.currentThread().name)
+        }
+
+        // Lock the drawing surface
+        val lock = JAWT_DrawingSurface_Lock(surface, surface.Lock())
+        if (lock has JAWT_LOCK_ERROR)
+            throw IllegalStateException("ds->Lock() failed")
+
+        try {
+            // Get the drawing surface info
+            val dsi = JAWT_DrawingSurface_GetDrawingSurfaceInfo(surface, surface.GetDrawingSurfaceInfo())
+                    ?: throw IllegalStateException("ds->GetDrawingSurfaceInfo() failed")
+
+            try {
+                // Get the window platform drawing info
+                val surfaceInfo = JAWTWin32DrawingSurfaceInfo.create(dsi.platformInfo())
+
+                val hdc = surfaceInfo.hdc()
+                assert(hdc != NULL)
+
+                if (!initialized)
+                    initInternal(HWND(surfaceInfo.hwnd()))
+
+                glfwWindow.makeContextCurrent()
+
+                if (resized) {
+//                    println("LwjglCanvas.reshape ${Date().toInstant()}")
+                    val newSize = Vec2i(width, height)
+                    glfwWindow.size = newSize
+                    reshape(newSize)
+                    resized = false
+//                    println("/LwjglCanvas.reshape ${Date().toInstant()}")
+                }
+
+//                println("LwjglCanvas.render ${Date().toInstant()}")
+                if (awtDebug) {
+                    println("paint before render ")
+                }
+                render()
+//                println("/LwjglCanvas.render ${Date().toInstant()}")
+
+                if (swapBuffers)
+                    glfwWindow.swapBuffers()
+
+                if (fps) {
+                    val now = System.currentTimeMillis()
+                    time += now - last
+                    last = now
+                    frames++
+                    if (time > 1000) {
+                        time %= 1000
+                        println("fps = $frames")
+                        frames = 0
+                    }
+                }
+
+                glfwWindow.unmakeContextCurrent()
+
+            } finally {
+                // Free the drawing surface info
+                JAWT_DrawingSurface_FreeDrawingSurfaceInfo(dsi, surface.FreeDrawingSurfaceInfo())
+            }
+        } finally {
+            // Unlock the drawing surface
+            JAWT_DrawingSurface_Unlock(surface, surface.Unlock())
+        }
+
+        if (awtDebug) {
+            println("paint end")
+        }
+
+        if (animated)
+            repaint()
+    }*/
+
+    inline fun wrapped(block: (HWND) -> Unit) {
+
+        try {
+            // Get the drawing surface info
+            val dsi = surface.info ?: throw IllegalStateException("ds->GetDrawingSurfaceInfo() failed")
+
+            try {
+                // Get the window platform drawing info
+                val surfaceInfo = JAWTWin32DrawingSurfaceInfo(dsi)
+
+                val hdc = surfaceInfo.hdc
+                assert(hdc.isValid)
+
+                block(surfaceInfo.hwnd)
+
+            } finally {
+                // Free the drawing surface info
+                surface free dsi
+            }
+        } finally {
+            // Unlock the drawing surface
+            surface.unlock()
+        }
+    }
+
+    fun destroyInternal() {
+        println("destroyInternal")
+
+        glfwWindow.makeContextCurrent()
+
+        destroy()
+
+        debugProc?.free()
+
+        glfwWindow.unmakeContextCurrent()
+
+        JAWTFunctions.JAWT_FreeDrawingSurface(surface, awt.FreeDrawingSurface())
+        awt.free()
+
+        glfwWindow.destroy()
+        glfw.terminate()
+    }
+
+    fun toggleAnimation() {
+        if (animated)
+            animated = false
+        else {
+            animated = true
+            repaint()
+        }
+    }
+
+    // public methods to overwrite in application
+
+    abstract fun init()
+    abstract fun reshape(size: Vec2i)
+    abstract fun render()
+    abstract fun destroy()
+}