#
# A fatal error has been detected by the Java Runtime Environment:
#
#  EXCEPTION_ACCESS_VIOLATION (0xc0000005) at pc=0x00007ff9a3b5cc00, pid=112124, tid=29404
#
# JRE version: OpenJDK Runtime Environment (17.0.7+7) (build 17.0.7+7-LTS)
# Java VM: OpenJDK 64-Bit Server VM (17.0.7+7-LTS, mixed mode, sharing, tiered, compressed oops, compressed class ptrs, g1 gc, windows-amd64)
# Problematic frame:
# V  [jvm.dll+0x1cc00]
#
# No core dump will be written. Minidumps are not enabled by default on client versions of Windows
#
# An error report file with more information is saved as:
# E:\...\hs_err_pid112124.log
#
# If you would like to submit a bug report, please visit:
#   https://bell-sw.com/support
#

Exception in thread "main" java.lang.AssertionError
        at io.github.humbleui.skija.examples.scenes.TextStyleScene.draw(TextStyleScene.java:110)
        at io.github.humbleui.skija.examples.scenes.Scenes.draw(Scenes.java:103)
        at io.github.humbleui.skija.examples.lwjgl.Window.draw(Main.java:143)
        at io.github.humbleui.skija.examples.lwjgl.Window.loop(Main.java:214)
        at io.github.humbleui.skija.examples.lwjgl.Window.run(Main.java:62)
        at io.github.humbleui.skija.examples.lwjgl.Main.main(Main.java:33)

glavo@W510 ~/P/Skija (linux-arm64) [1]> python3 ./examples/kwinit/script/run.py
Using Skia from /home/glavo/Projects/Skija/platform/Skia-m109-664500fa93-linux-Release-arm64
-- Configuring done
-- Generating done
-- Build files have been written to: /home/glavo/Projects/Skija/platform/target/linux-arm64/native
ninja: no work to do.
    Finished release [optimized + debuginfo] target(s) in 0.11s
2023-02-28T15:00:26.590149605Z [DEBUG] Loading /home/glavo/Projects/Skija/platform/target/linux-arm64/classes/io/github/humbleui/skija/linux/arm64/libskija.so
WARNING in native method: JNI call made with exception pending
        at noria.kwinit.impl.ExternalAPI.runEventLoop(Native Method)
        at noria.kwinit.impl.Main.run(Main.java:65)
        at noria.kwinit.impl.Main.main(Main.java:18)
Exception in thread "main" java.lang.RuntimeException: Can't wrap nullptr
        at io.github.humbleui.skija.impl.Native.<init>(Native.java:12)
        at io.github.humbleui.skija.impl.Managed.<init>(Managed.java:14)
        at io.github.humbleui.skija.impl.Managed.<init>(Managed.java:10)
        at io.github.humbleui.skija.impl.RefCnt.<init>(RefCnt.java:7)
        at io.github.humbleui.skija.Typeface.<init>(Typeface.java:393)
        at io.github.humbleui.skija.Typeface.makeFromName(Typeface.java:123)
        at io.github.humbleui.skija.examples.scenes.FontSizeScene.lambda$new$0(FontSizeScene.java:55)
        at java.base/java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:197)
        at java.base/java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators.java:992)
        at java.base/java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:509)
        at java.base/java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:499)
        at java.base/java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:575)
        at java.base/java.util.stream.AbstractPipeline.evaluateToArrayNode(AbstractPipeline.java:260)
        at java.base/java.util.stream.ReferencePipeline.toArray(ReferencePipeline.java:616)
        at io.github.humbleui.skija.examples.scenes.FontSizeScene.<init>(FontSizeScene.java:59)
        at java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
        at java.base/jdk.internal.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:77)
        at java.base/jdk.internal.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
        at java.base/java.lang.reflect.Constructor.newInstanceWithCaller(Constructor.java:499)
        at java.base/java.lang.reflect.ReflectAccess.newInstance(ReflectAccess.java:128)
        at java.base/jdk.internal.reflect.ReflectionFactory.newInstance(ReflectionFactory.java:347)
        at java.base/java.lang.Class.newInstance(Class.java:645)
        at io.github.humbleui.skija.examples.scenes.Scenes.newScene(Scenes.java:73)
        at io.github.humbleui.skija.examples.scenes.Scenes.setScene(Scenes.java:89)
        at io.github.humbleui.skija.examples.scenes.Scenes.prevScene(Scenes.java:81)
        at noria.kwinit.impl.Main.onKeyDown(Main.java:172)
        at noria.kwinit.impl.Main.lambda$run$1(Main.java:84)
        at noria.kwinit.impl.ExternalAPI.runEventLoop(Native Method)
        at noria.kwinit.impl.Main.run(Main.java:65)
        at noria.kwinit.impl.Main.main(Main.java:18)
Traceback (most recent call last):
  File "/home/glavo/Projects/Skija/./examples/kwinit/script/run.py", line 59, in <module>
    sys.exit(main())
  File "/home/glavo/Projects/Skija/./examples/kwinit/script/run.py", line 44, in main
    subprocess.check_call([
  File "/usr/lib/python3.10/subprocess.py", line 369, in check_call
    raise CalledProcessError(retcode, cmd)
subprocess.CalledProcessError: Command '['java', '--class-path', 'target/classes:/home/glavo/.m2/repository/org/jetbrains/annotations/20.1.0/annotations-20.1.0.jar:/home/glavo/.m2/repository/org/projectlombok/lombok/1.18.22/lombok-1.18.22.jar:/home/glavo/.m2/repository/io/github/humbleui/types/0.2.0/types-0.2.0.jar:/home/glavo/.m2/repository/com/google/code/gson/gson/2.8.6/gson-2.8.6.jar:../../platform/target/linux-arm64/classes:../../shared/target/classes-java9:../../shared/target/classes', '-Djava.awt.headless=true', '-enableassertions', '-enablesystemassertions', '-Xcheck:jni', '-Dskija.logLevel=DEBUG', 'noria.kwinit.impl.Main']' returned non-zero exit status 1.

Exception in thread "main" java.lang.UnsatisfiedLinkError: Can't load C:\Users\...\AppData\Local\Temp\skija_0.100.0\skija.dll
	at java.base/java.lang.ClassLoader.loadLibrary(ClassLoader.java:1793)
	at java.base/java.lang.System.load(System.java:672)
	at io.github.humbleui.skija.impl.Library.load(Library.java:73)
	at io.github.humbleui.skija.impl.Library.staticLoad(Library.java:47)
	at io.github.humbleui.skija.Surface.<clinit>(Surface.java:10)
	...

import io.github.humbleui.skija.*;

import javax.imageio.*;
import javax.swing.*;
import java.io.*;

public class TextAliasing {
    public static void main(String[] ignored) throws Exception {
        int width = 130;
        int height = 30;
        Surface surface = Surface.makeRasterN32Premul(width, height);
        Canvas canvas = surface.getCanvas();
        canvas.clear(0xFFFFFFFF);

        Typeface typeface = Typeface.makeFromName("Arial", FontStyle.NORMAL);
        Font font = new Font(typeface, 24);
        font.setEdging(FontEdging.SUBPIXEL_ANTI_ALIAS);
        Paint paint = new Paint();
        paint.setColor(0xFF000000);
        canvas.drawString("Hello World", 3, height * 0.8f, font, paint);

        byte[] pngBytes = surface.makeImageSnapshot().encodeToData().getBytes();
        java.awt.Image image = ImageIO.read(new ByteArrayInputStream(pngBytes));
        image = image.getScaledInstance(width * 4, height * 4, java.awt.Image.SCALE_REPLICATE);
        JFrame frame=new JFrame();
        frame.getContentPane().add(new JLabel(new ImageIcon(image)));
        //frame.getContentPane().add(component);
        frame.pack();
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        //java.nio.file.Files.write(java.nio.file.Path.of("output.png"), pngBytes);

    }
}

import java.nio.IntBuffer;
import java.util.*;

import org.lwjgl.glfw.*;
import org.lwjgl.opengl.*;
import org.lwjgl.system.MemoryStack;

import static org.lwjgl.glfw.Callbacks.*;
import static org.lwjgl.glfw.GLFW.*;
import static org.lwjgl.system.MemoryUtil.*;

import io.github.humbleui.skija.*;
import io.github.humbleui.skija.impl.*;

class Window
{
    //GL
    public long window;
    public int width;
    public int height;
    public float dpi = 1f;
    public int xpos = 0;
    public int ypos = 0;
    public boolean vsync = true;
    public boolean stats = true;
    private int[] refreshRates;
    private String os = System.getProperty("os.name").toLowerCase();

    //SKIA
    private DirectContext context;
    private BackendRenderTarget renderTarget;
    private Surface surface;
    private Canvas canvas;

    //-----------------------------------------------------------------------------------------------------//
    //Create Window
    //-----------------------------------------------------------------------------------------------------//
    private void createWindow(int x, int y, int width, int height)
    {
        glfwDefaultWindowHints(); // optional, the current window hints are already the default
        glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); // the window will stay hidden after creation
        glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); // the window will be resizable

        window = glfwCreateWindow(width, height, "Skija LWJGL Demo", 0, 0);
        if (window == 0)
        {
            throw new RuntimeException("Failed to create the GLFW window");
        }

        glfwSetKeyCallback(window, (window, key, scancode, action, mods) ->
        {
            if (key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE)
            {
                glfwSetWindowShouldClose(window, true);
            }
        });

        glfwSetWindowPos(window, x, y);
        updateDimensions();
        xpos = width / 2;
        ypos = height / 2;

        glfwMakeContextCurrent(window);
        glfwSwapInterval(vsync ? 1 : 0); // Enable v-sync
        glfwShowWindow(window);
    }

    //-----------------------------------------------------------------------------------------------------//
    //Get Refresh Rates
    //-----------------------------------------------------------------------------------------------------//
    private int[] getRefreshRates()
    {
        var monitors = glfwGetMonitors();
        int[] res = new int[monitors.capacity()];
        for (int i=0; i < monitors.capacity(); ++i)
        {
            res[i] = glfwGetVideoMode(monitors.get(i)).refreshRate();
        }
        return res;
    }

    //-----------------------------------------------------------------------------------------------------//
    //Run
    //-----------------------------------------------------------------------------------------------------//
    public void run(int x, int y, int width, int height)
    {
        refreshRates = getRefreshRates();

        createWindow(x, y, width, height);
        loop();

        glfwFreeCallbacks(window);
        glfwDestroyWindow(window);
        glfwTerminate();
        glfwSetErrorCallback(null).free();
    }

    //-----------------------------------------------------------------------------------------------------//
    //Update Dimensions
    //-----------------------------------------------------------------------------------------------------//
    private void updateDimensions()
    {
        int[] width = new int[1];
        int[] height = new int[1];
        glfwGetFramebufferSize(window, width, height);

        float[] xscale = new float[1];
        float[] yscale = new float[1];
        glfwGetWindowContentScale(window, xscale, yscale);
        assert xscale[0] == yscale[0] : "Horizontal dpi=" + xscale[0] + ", vertical dpi=" + yscale[0];

        this.width = (int) (width[0] / xscale[0]);
        this.height = (int) (height[0] / yscale[0]);
        this.dpi = xscale[0];
        System.out.println("FramebufferSize " + width[0] + "x" + height[0] + ", scale " + this.dpi + ", window " + this.width + "x" + this.height);
    }

    //-----------------------------------------------------------------------------------------------------//
    //Initialize Skia
    //-----------------------------------------------------------------------------------------------------//
    private void initSkia()
    {
        Stats.enabled = true;

        if (surface != null)
        {
            surface.close();
        }
        if (renderTarget != null)
        {
            renderTarget.close();
        }

        renderTarget = BackendRenderTarget.makeGL(
                (int) (width * dpi),
                (int) (height * dpi),
                /*samples*/16,
                /*stencil*/8,
                /*fbId*/0,
                FramebufferFormat.GR_GL_RGBA8);

        surface = Surface.makeFromBackendRenderTarget(
                context,
                renderTarget,
                SurfaceOrigin.BOTTOM_LEFT,
                SurfaceColorFormat.RGBA_8888,
                ColorSpace.getDisplayP3(),  // TODO load monitor profile
                new SurfaceProps(PixelGeometry.BGR_H));

        canvas = surface.getCanvas();
    }

    //-----------------------------------------------------------------------------------------------------//
    //Draw
    //-----------------------------------------------------------------------------------------------------//
    private void draw()
    {
        //var canvas = surface.getCanvas();
        //canvas.clear(0);
        //Paint paint = new Paint();
        //paint.setColor4f(new Color4f(1f, 1f, 1f, 1f), ColorSpace.getSRGB());
        //paint.setAntiAlias(true);
        //canvas.drawCircle(640f, 360f, 150f, paint);
        context.flush();
        glfwSwapBuffers(window);
    }

    //-----------------------------------------------------------------------------------------------------//
    //Loop
    //-----------------------------------------------------------------------------------------------------//
    private void loop()
    {
        GL.createCapabilities();
        if ("false".equals(System.getProperty("skija.staticLoad")))
        {
            Library.load();
        }
        context = DirectContext.makeGL();

        GLFW.glfwSetWindowSizeCallback(window, (window, width, height) ->
        {
            updateDimensions();
            initSkia();
            draw();
        });

        glfwSetCursorPosCallback(window, (window, xpos, ypos) ->
        {
            if(os.contains("mac") || os.contains("darwin"))
            {
                this.xpos = (int) xpos;
                this.ypos = (int) ypos;
            }
            else
            {
                this.xpos = (int) (xpos / dpi);
                this.ypos = (int) (ypos / dpi);
            }
        });

        glfwSetMouseButtonCallback(window, (window, button, action, mods) ->
        {
            System.out.println("Button " + button + " " + (action == 0 ? "released" : "pressed"));
        });

        glfwSetScrollCallback(window, (window, xoffset, yoffset) ->
        {
            System.out.println("Scroll " + xoffset + "/" + yoffset);
        });

        glfwSetKeyCallback(window, (window, key, scancode, action, mods) ->
        {
            if (action == GLFW_PRESS)
            {
                switch (key)
                {
                    case GLFW_KEY_V:
                        vsync = !vsync;
                        glfwSwapInterval(vsync ? 1 : 0);
                        System.out.println("Vsync " + (vsync ? "ON" : "OFF"));
                        break;
                    case GLFW_KEY_G:
                        System.out.println("Before GC " + Stats.allocated);
                        System.gc();
                        break;
                }
            }
        });

        initSkia();

        while (!glfwWindowShouldClose(window))
        {
            draw();
            glfwPollEvents();
        }
    }
}

public class SkiaMain
{
    public static void main(String [] args) throws Exception
    {
        GLFWErrorCallback.createPrint(System.err).set();
        if (!glfwInit())
        {
            throw new IllegalStateException("Unable to initialize GLFW");
        }

        GLFWVidMode vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());
        int width = 1280;
        int height = 720;
        new Window().run(Math.max(0, (vidmode.width() - width) / 2), Math.max(0, (vidmode.height() - height) / 2), width, height);
    }
}

public class Main
{
    public static void main(String [] args) throws Exception
    {
        GLFWErrorCallback.createPrint(System.out).set();
        if (!GLFW.glfwInit())
        {
            throw new IllegalStateException("Error: Unable to initialize GLFW");
        }
        loop();
    }

    private static void loop()
    {
        //Create window (Setup GLFW and SKIJA)
        GameWindow window = new GameWindow();

        //Create main offscreen target
        OffscreenTarget mainTarget = new OffscreenTarget(window.getContext(), 640, 480, 0);

        //Create debug effect
        RuntimeEffect effect = RuntimeEffect.makeForShader(
                "uniform shader in_texture0;\n" +
                "uniform shader in_mask0;\n" +
                "\n" +
                "float4 main(float2 p)\n" +
                "{\n" +
                "    float4 texel = in_texture0.eval(p);\n" +
                "    float4 texelMask = in_mask0.eval(p);\n" +
                "    float4 result = float4(texel.r * texelMask.r, texel.g * texelMask.r, texel.b * texelMask.r, texel.a * texelMask.r);\n" +
                "\treturn result;\n" +
                "}"
        );

        while (window.isAlive())
        {
            GLFW.glfwMakeContextCurrent(window.getWindowHandle());
            GLFW.glfwPollEvents();

            //Create debug offscreen targets
            OffscreenTarget debugTarget1 = new OffscreenTarget(window.getContext(), 400, 400, 0);
            OffscreenTarget debugTarget2 = new OffscreenTarget(window.getContext(), 400, 400, 0);

            //Draw gradient to debug target 1
            debugTarget1.clear(Color.makeARGB(0, 0, 0, 0));
            Shader gradientShader = Shader.makeLinearGradient(new Point(0, 0), new Point(400, 400), new int[] { 0xFF247ba0, 0xFFf3ffbd });
            Paint pt1 = new Paint();
            pt1.setShader(gradientShader);
            debugTarget1.getSurface().getCanvas().drawRect(new Rect(0, 0, 400, 400), pt1);
            gradientShader.close();

            //Draw black and white mask to debug target 2
            debugTarget2.clear(Color.makeARGB(255, 0, 0, 0));
            Paint pt2 = new Paint();
            pt2.setAntiAlias(true);
            pt2.setColor(Color.makeARGB(255, 255, 255, 255));
            debugTarget2.getSurface().getCanvas().drawOval(new Rect(0, 0, 400, 400), pt2);

            //Create runtime shader from debug offscreen target 1 + 2 images
            Shader[] debugShaderChildShaders = new Shader[2];
            Image debugImage1 = debugTarget1.getSurface().makeImageSnapshot();
            debugShaderChildShaders[0] = debugImage1.makeShader();
            Image debugImage2 = debugTarget2.getSurface().makeImageSnapshot();
            debugShaderChildShaders[1] = debugImage2.makeShader();

            //Create runtime shader of debug effect
            Shader runtimeShader = effect.makeShader(null, debugShaderChildShaders, null);

            //Clear main offscreen target
            mainTarget.clear(Color.makeARGB(255, 32, 32, 32));

            //Draw runtime debug shader to main target
            mainTarget.getSurface().getCanvas().save();
            Paint pt3 = new Paint();
            pt3.setShader(runtimeShader);
            mainTarget.getSurface().getCanvas().translate(120, 40);
            mainTarget.getSurface().getCanvas().drawRect(new Rect(0, 0, 400, 400), pt3);
            mainTarget.getSurface().getCanvas().restore();

            //Try to close all runtime objects -->
            runtimeShader.close();
            debugShaderChildShaders[0].close();
            debugShaderChildShaders[1].close();
            debugImage1.close();
            debugImage2.close();
            debugTarget1.dispose();
            debugTarget2.dispose();
            //...Still loosing about 200mb of ram + vram per second

            //Draw main offscreen target to window
            window.draw(mainTarget);

            window.getContext().flush();
            GLFW.glfwSwapBuffers(window.getWindowHandle());
        }

        effect.close();
        mainTarget.dispose();
        window.closeWindow();
    }
}

(ns shaders.core
  (:require
    [clojure.main :as cl-main]
    [nrepl.server :as nrepl])
  (:import
    (io.github.humbleui.skija BackendRenderTarget Canvas ColorSpace
                              DirectContext FramebufferFormat Surface
                              SurfaceColorFormat SurfaceOrigin Paint Shader)
    (org.lwjgl.glfw Callbacks GLFW GLFWErrorCallback)
    (org.lwjgl.opengl GL GL11)
    (org.lwjgl.system MemoryUtil)))

(set! *warn-on-reflection* true)

(defn color [^long l]
  (.intValue (Long/valueOf l)))

(def *rect-color (atom (color 0xFFCC3333)))

(defn draw [^Canvas canvas]
  (let [paint (doto (Paint.) (.setShader (Shader/makeRadialGradient
                                           320.0
                                           240.0
                                           50.0
                                           [0xffffff 0x923423])))]
    (.drawPaint paint)))

(defn display-scale [window]
  (let [x (make-array Float/TYPE 1)
        y (make-array Float/TYPE 1)]
    (GLFW/glfwGetWindowContentScale window x y)
    [(first x) (first y)]))

(defn -main [& args]
  (.set (GLFWErrorCallback/createPrint System/err))
  (GLFW/glfwInit)
  (GLFW/glfwWindowHint GLFW/GLFW_VISIBLE GLFW/GLFW_FALSE)
  (GLFW/glfwWindowHint GLFW/GLFW_RESIZABLE GLFW/GLFW_TRUE)
  (let [width 640
        height 480
        window (GLFW/glfwCreateWindow width height "Messing with Skija" MemoryUtil/NULL MemoryUtil/NULL)]
    (GLFW/glfwMakeContextCurrent window)
    (GLFW/glfwSwapInterval 1)
    (GLFW/glfwShowWindow window)
    (GL/createCapabilities)

    (doto (Thread. #(cl-main/main))
      (.start))

    (nrepl/start-server :port 7888)
    (println "nREPL server started at locahost:7888")

    (let [context (DirectContext/makeGL)
          fb-id   (GL11/glGetInteger 0x8CA6)
          [scale-x scale-y] (display-scale window)
          target  (BackendRenderTarget/makeGL (* scale-x width) (* scale-y height) 0 8 fb-id FramebufferFormat/GR_GL_RGBA8)
          surface (Surface/makeFromBackendRenderTarget context target SurfaceOrigin/BOTTOM_LEFT SurfaceColorFormat/RGBA_8888 (ColorSpace/getSRGB))
          canvas  (.getCanvas surface)]
      (.scale canvas scale-x scale-y)
      (loop []
        (when (not (GLFW/glfwWindowShouldClose window))
          (.clear canvas (color 0xFFFFFFFF))
          (let [layer (.save canvas)]
            (draw canvas)
            (.restoreToCount canvas layer))
          (.flush context)
          (GLFW/glfwSwapBuffers window)
          (GLFW/glfwPollEvents)
          (recur)))

      (Callbacks/glfwFreeCallbacks window)
      (GLFW/glfwHideWindow window)
      (GLFW/glfwDestroyWindow window)
      (GLFW/glfwPollEvents)

      (.close surface)
      (.close target)
      (.close context)

      (GLFW/glfwTerminate)
      (.free (GLFW/glfwSetErrorCallback nil))
      (nrepl/stop-server 7888)
      (shutdown-agents)
      )))

(comment
  (reset! shaders.core/*rect-color (shaders.core/color 0xFF33CC33)))

lein run           
Reflection warning, shaders/core.clj:21:42 - call to static method makeRadialGradient on io.github.humbleui.skija.Shader can't be resolved (argument types: double, double, double, clojure.lang.APersistentVector).
Reflection warning, shaders/core.clj:26:5 - reference to field drawPaint on io.github.humbleui.skija.Paint can't be resolved.
Reflection warning, shaders/core.clj:31:5 - call to static method glfwGetWindowContentScale on org.lwjgl.glfw.GLFW can't be resolved (argument types: unknown, unknown, unknown).
Clojure 1.11.1
nREPL server started at locahost:7888
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "clojure.lang.IFn.invoke(Object)" because the return value of "clojure.lang.Var.get()" is null
        at clojure.pprint$write_out.invokeStatic(pprint_base.clj:194)
        at clojure.pprint$pprint$fn__10392.invoke(pprint_base.clj:249)
        at clojure.pprint$pprint.invokeStatic(pprint_base.clj:248)
        at clojure.pprint$pprint.invoke(pprint_base.clj:241)
        at clojure.pprint$pprint.invokeStatic(pprint_base.clj:245)
        at clojure.pprint$pprint.invoke(pprint_base.clj:241)
        at clojure.lang.Var.invoke(Var.java:384)
        at clojure.main$report_error$fn__9280$fn__9281.invoke(main.clj:603)
        at clojure.main$report_error$fn__9280.invoke(main.clj:602)
        at clojure.main$report_error.invokeStatic(main.clj:601)
        at clojure.main$main.invokeStatic(main.clj:666)
        at clojure.main$main.doInvoke(main.clj:616)
        at clojure.lang.RestFn.applyTo(RestFn.java:137)
        at clojure.lang.Var.applyTo(Var.java:705)
        at clojure.main.main(main.java:40)
#
# A fatal error has been detected by the Java Runtime Environment:
#
#  SIGSEGV (0xb) at pc=0x00007ffa222a1770, pid=30010, tid=51459
#
# JRE version: OpenJDK Runtime Environment Homebrew (18.0.2) (build 18.0.2+0)
# Java VM: OpenJDK 64-Bit Server VM Homebrew (18.0.2+0, mixed mode, sharing, tiered, compressed oops, compressed class ptrs, g1 gc, bsd-amd64)
# Problematic frame:
# C  [libGL.dylib+0x5770]  glBindFramebuffer+0x11
#

//Set default window hints
GLFW.glfwDefaultWindowHints();

//Set window as hidden
GLFW.glfwWindowHint(GLFW.GLFW_VISIBLE, GLFW.GLFW_FALSE);

//Set window resizable flag
if (resizable)
{
    GLFW.glfwWindowHint(GLFW.GLFW_RESIZABLE, GLFW.GLFW_TRUE);
}
else
{
    GLFW.glfwWindowHint(GLFW.GLFW_RESIZABLE, GLFW.GLFW_FALSE);
}

//Create GL window
boolean primaryWindow = false;
if (AEGameWindowManager.getPrimaryWindow() == null)
{
    //--> Create primary window and GL context
    windowHandle = GLFW.glfwCreateWindow(width, height, title, 0, 0);
    if (windowHandle == 0)
    {
        throw new RuntimeException("Error: Failed to create GL window");
    }
    primaryWindow = true;
}
else
{
    //--> Create secondary window, use shared context of primary window
    windowHandle = GLFW.glfwCreateWindow(width, height, title, 0, AEGameWindowManager.getPrimaryWindow().getWindowHandle());
    if (windowHandle == 0)
    {
        throw new RuntimeException("Error: Failed to create GL window");
    }
}

//Center window on primary screen
GLFWVidMode vidmode = GLFW.glfwGetVideoMode(GLFW.glfwGetPrimaryMonitor());
int xPos = Math.max(0, (vidmode.width() - width) / 2);
int yPos = Math.max(0, (vidmode.height() - height) / 2);
GLFW.glfwSetWindowPos(windowHandle, xPos, yPos);

//Update window dimensions
updateDimensions();

//Make window context current
GLFW.glfwMakeContextCurrent(windowHandle);

//Set v-sync state
setVSyncState(vsync);

//Unhide window
GLFW.glfwShowWindow(windowHandle);

//Initialize GL context
if (primaryWindow)
{
    initializeGLContext();
}

//Initialize GL window event callbacks
initializeGLCallbacks();

//Update SKIA resources
updateSkia();

//-----------------------------------------------------------------------------------------------------//
//Initialize GL (I only have to do this once, after primary window creation?)
//-----------------------------------------------------------------------------------------------------//
private void initializeGLContext()
{
    //I have no idea what this does...
    if ("false".equals(System.getProperty("skija.staticLoad")))
    {
        Library.load();
    }
    boolean loaded = Library._loaded;

    //Create global gl context
    context = DirectContext.makeGL();
}

//-----------------------------------------------------------------------------------------------------//
//Update SKIA resources
//-----------------------------------------------------------------------------------------------------//
private void updateSkia()
{
    if (surface != null)
    {
        surface.close();
    }
    if (renderTarget != null)
    {
        renderTarget.close();
    }

    renderTarget = BackendRenderTarget.makeGL(
            frameBufferResolution.getX(),
            frameBufferResolution.getY(),
            /*msaaSamples*/0,
            /*stencil*/8,
            /*fbId*/0,
            FramebufferFormat.GR_GL_RGBA8);

    surface = Surface.makeFromBackendRenderTarget(
            context,
            renderTarget,
            SurfaceOrigin.BOTTOM_LEFT,
            SurfaceColorFormat.RGBA_8888,
            ColorSpace.getSRGB(),
            new SurfaceProps(PixelGeometry.RGB_H));
}

//-----------------------------------------------------------------------------------------------------//
//Draw this windows' content
//-----------------------------------------------------------------------------------------------------//
public void _draw()
{
    //Assign window to context?
    GLFW.glfwMakeContextCurrent(windowHandle);

    //Clear window surface
    //(The secondary window stays black, even if I use a different clear color...)
    surface.getCanvas().clear(0x00000000);
    
    //...Draw stuff...//

    //Swap front and back buffer
    GLFW.glfwSwapBuffers(windowHandle);
}

//Process window events
GLFW.glfwPollEvents();

AEGameWindow[] windows = AEGameWindowManager.getWindows();
for (AEGameWindow window : windows)
{
    //Draw window content
    window._draw();
}

//(Context is a static field)
AEGameWindow.getContext().flush();

Current thread (0x00007fbc9402d070):  JavaThread "main" [_thread_in_native, id=10025, stack(0x00007fbc9afeb000,0x00007fbc9b0eb000)]

Stack: [0x00007fbc9afeb000,0x00007fbc9b0eb000],  sp=0x00007fbc9b0e72c8,  free space=1008k
Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)
C  [ld-linux-x86-64.so.2+0x2b1fa]

Java frames: (J=compiled Java code, j=interpreted, Vv=VM code)
j  jdk.internal.loader.NativeLibraries.load(Ljdk/internal/loader/NativeLibraries$NativeLibraryImpl;Ljava/lang/String;ZZ)Z+0 [email protected]
j  jdk.internal.loader.NativeLibraries$NativeLibraryImpl.open()Z+56 [email protected]
j  jdk.internal.loader.NativeLibraries.loadLibrary(Ljava/lang/Class;Ljava/lang/String;Z)Ljdk/internal/loader/NativeLibrary;+254 [email protected]
j  jdk.internal.loader.NativeLibraries.loadLibrary(Ljava/lang/Class;Ljava/io/File;)Ljdk/internal/loader/NativeLibrary;+51 [email protected]
j  java.lang.ClassLoader.loadLibrary(Ljava/lang/Class;Ljava/io/File;)Ljdk/internal/loader/NativeLibrary;+31 [email protected]
j  java.lang.Runtime.load0(Ljava/lang/Class;Ljava/lang/String;)V+61 [email protected]
j  java.lang.System.load(Ljava/lang/String;)V+7 [email protected]
j  io.github.humbleui.skija.impl.Library.load()V+176
j  io.github.humbleui.skija.impl.Library.staticLoad()V+19
j  io.github.humbleui.skija.Font.<clinit>()V+0
v  ~StubRoutines::call_stub 0x00007fbc8452ccc6
j  io.github.humbleui.jwm.examples.Example.<clinit>()V+34
v  ~StubRoutines::call_stub 0x00007fbc8452ccc6

$ cd examples/clojure && ./scripts/run.py
Syntax error (ClassNotFoundException) compiling at (lwjgl/main.clj:1:1).
io.github.humbleui.types.Rect

Full report at:
/tmp/clojure-1209162283782155536.edn

Traceback (most recent call last):
  File "/home/w1n5t0n/dev/lib/skija/examples/clojure/./script/run.py", line 11, in <module>
    sys.exit(main())
  File "/home/w1n5t0n/dev/lib/skija/examples/clojure/./script/run.py", line 7, in main
    subprocess.check_call(["clj", "-M:" + system, "-m", "lwjgl.main"])
  File "/usr/lib/python3.10/subprocess.py", line 369, in check_call
    raise CalledProcessError(retcode, cmd)
subprocess.CalledProcessError: Command '['clj', '-M:linux', '-m', 'lwjgl.main']' returned non-zero exit status 1.

a    U+0061  LATIN SMALL LETTER A
 ̆     U+0306  COMBINING BREVE