mirror of
https://github.com/GTNewHorizons/lwjgl3ify.git
synced 2026-11-20 12:19:39 +00:00
631 lines
22 KiB
Java
631 lines
22 KiB
Java
package org.lwjglx.opengl;
|
|
|
|
import static org.lwjgl.glfw.Callbacks.*;
|
|
import static org.lwjgl.glfw.GLFW.*;
|
|
import static org.lwjgl.system.MemoryUtil.NULL;
|
|
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.IntBuffer;
|
|
|
|
import me.eigenraven.lwjgl3ify.Lwjgl3ify;
|
|
import me.eigenraven.lwjgl3ify.core.Config;
|
|
|
|
import org.lwjgl.glfw.*;
|
|
import org.lwjgl.glfw.GLFW;
|
|
import org.lwjgl.glfw.GLFWCharCallback;
|
|
import org.lwjgl.glfw.GLFWCursorPosCallback;
|
|
import org.lwjgl.glfw.GLFWKeyCallback;
|
|
import org.lwjgl.glfw.GLFWMouseButtonCallback;
|
|
import org.lwjgl.glfw.GLFWVidMode;
|
|
import org.lwjgl.glfw.GLFWWindowFocusCallback;
|
|
import org.lwjgl.glfw.GLFWWindowIconifyCallback;
|
|
import org.lwjgl.glfw.GLFWWindowPosCallback;
|
|
import org.lwjgl.glfw.GLFWWindowRefreshCallback;
|
|
import org.lwjgl.opengl.GL;
|
|
import org.lwjgl.opengl.GL11;
|
|
import org.lwjglx.BufferUtils;
|
|
import org.lwjglx.Sys;
|
|
import org.lwjglx.input.Keyboard;
|
|
import org.lwjglx.input.Mouse;
|
|
|
|
public class Display {
|
|
|
|
private static String windowTitle = "Game";
|
|
|
|
private static boolean displayCreated = false;
|
|
private static boolean displayFocused = false;
|
|
private static boolean displayVisible = true;
|
|
private static boolean displayDirty = false;
|
|
private static boolean displayResizable = false;
|
|
private static boolean startFullscreen = false;
|
|
|
|
private static DisplayMode mode = new DisplayMode(854, 480);
|
|
private static DisplayMode desktopDisplayMode = new DisplayMode(854, 480);
|
|
|
|
private static int latestEventKey = 0;
|
|
|
|
private static int displayX = 0;
|
|
private static int displayY = 0;
|
|
|
|
private static boolean displayResized = false;
|
|
private static int displayWidth = 0;
|
|
private static int displayHeight = 0;
|
|
private static int displayFramebufferWidth = 0;
|
|
private static int displayFramebufferHeight = 0;
|
|
|
|
private static boolean latestResized = false;
|
|
private static int latestWidth = 0;
|
|
private static int latestHeight = 0;
|
|
private static ByteBuffer[] savedIcons;
|
|
|
|
static {
|
|
Sys.initialize(); // init using dummy sys method
|
|
|
|
long monitor = glfwGetPrimaryMonitor();
|
|
GLFWVidMode vidmode = glfwGetVideoMode(monitor);
|
|
|
|
int monitorWidth = vidmode.width();
|
|
int monitorHeight = vidmode.height();
|
|
int monitorBitPerPixel = vidmode.redBits() + vidmode.greenBits() + vidmode.blueBits();
|
|
int monitorRefreshRate = vidmode.refreshRate();
|
|
|
|
desktopDisplayMode = new DisplayMode(monitorWidth, monitorHeight, monitorBitPerPixel, monitorRefreshRate);
|
|
}
|
|
|
|
/**
|
|
* Create the OpenGL context with the given minimum parameters. If isFullscreen() is true or if windowed context are
|
|
* not supported on the platform, the display mode will be switched to the mode returned by getDisplayMode(), and a
|
|
* fullscreen context will be created. If isFullscreen() is false, a windowed context will be created with the
|
|
* dimensions given in the mode returned by getDisplayMode(). If a context can't be created with the given
|
|
* parameters, a LWJGLException will be thrown.
|
|
* <p/>
|
|
* <p>
|
|
* The window created will be set up in orthographic 2D projection, with 1:1 pixel ratio with GL coordinates.
|
|
*
|
|
* @param pixel_format Describes the minimum specifications the context must fulfill.
|
|
* @param shared_drawable The Drawable to share context with. (optional, may be null)
|
|
*
|
|
* @throws org.lwjglx.LWJGLException
|
|
*/
|
|
public static void create(PixelFormat pixel_format, Drawable shared_drawable) {
|
|
System.out.println("TODO: Implement Display.create(PixelFormat, Drawable)"); // TODO
|
|
create();
|
|
}
|
|
|
|
public static void create(PixelFormat pixel_format, ContextAttribs attribs) {
|
|
System.out.println("TODO: Implement Display.create(PixelFormat, ContextAttribs)"); // TODO
|
|
create();
|
|
}
|
|
|
|
public static void create(PixelFormat pixel_format) {
|
|
System.out.println("TODO: Implement Display.create(PixelFormat)"); // TODO
|
|
create();
|
|
}
|
|
|
|
public static void create() {
|
|
if (displayCreated) {
|
|
return;
|
|
}
|
|
|
|
long monitor = glfwGetPrimaryMonitor();
|
|
GLFWVidMode vidmode = glfwGetVideoMode(monitor);
|
|
|
|
int monitorWidth = vidmode.width();
|
|
int monitorHeight = vidmode.height();
|
|
int monitorBitPerPixel = vidmode.redBits() + vidmode.greenBits() + vidmode.blueBits();
|
|
int monitorRefreshRate = vidmode.refreshRate();
|
|
|
|
desktopDisplayMode = new DisplayMode(monitorWidth, monitorHeight, monitorBitPerPixel, monitorRefreshRate);
|
|
|
|
glfwDefaultWindowHints();
|
|
glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE);
|
|
glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
|
|
|
|
glfwWindowHint(GLFW_MAXIMIZED, Config.WINDOW_START_MAXIMIZED ? GLFW_TRUE : GLFW_FALSE);
|
|
glfwWindowHint(GLFW_FOCUSED, Config.WINDOW_START_FOCUSED ? GLFW_TRUE : GLFW_FALSE);
|
|
displayFocused = Config.WINDOW_START_FOCUSED;
|
|
glfwWindowHint(GLFW_ICONIFIED, Config.WINDOW_START_ICONIFIED ? GLFW_TRUE : GLFW_FALSE);
|
|
displayVisible = !Config.WINDOW_START_ICONIFIED;
|
|
glfwWindowHint(GLFW_DECORATED, Config.WINDOW_DECORATED ? GLFW_TRUE : GLFW_FALSE);
|
|
|
|
glfwWindowHint(GLFW_SRGB_CAPABLE, Config.OPENGL_SRGB_CONTEXT ? GLFW_TRUE : GLFW_FALSE);
|
|
glfwWindowHint(GLFW_DOUBLEBUFFER, Config.OPENGL_DOUBLEBUFFER ? GLFW_TRUE : GLFW_FALSE);
|
|
glfwWindowHint(GLFW_CONTEXT_NO_ERROR, Config.OPENGL_CONTEXT_NO_ERROR ? GLFW_TRUE : GLFW_FALSE);
|
|
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, Config.OPENGL_DEBUG_CONTEXT ? GLFW_TRUE : GLFW_FALSE);
|
|
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, Config.OPENGL_DEBUG_CONTEXT ? GLFW_TRUE : GLFW_FALSE);
|
|
|
|
glfwWindowHintString(GLFW_X11_CLASS_NAME, Config.X11_CLASS_NAME);
|
|
glfwWindowHintString(GLFW_COCOA_FRAME_NAME, Config.COCOA_FRAME_NAME);
|
|
|
|
glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_FALSE); // request a non-hidpi framebuffer on Retina displays
|
|
// on MacOS
|
|
|
|
Window.handle = glfwCreateWindow(mode.getWidth(), mode.getHeight(), windowTitle, NULL, NULL);
|
|
if (Window.handle == 0L) {
|
|
throw new IllegalStateException("Failed to create Display window");
|
|
}
|
|
|
|
Window.keyCallback = new GLFWKeyCallback() {
|
|
|
|
@Override
|
|
public void invoke(long window, int key, int scancode, int action, int mods) {
|
|
if (Config.DEBUG_PRINT_KEY_EVENTS) {
|
|
Lwjgl3ify.LOG.info(
|
|
"[DEBUG-KEY] key window:{} key:{} scancode:{} action:{} mods:{} char:{}",
|
|
window,
|
|
key,
|
|
scancode,
|
|
action,
|
|
mods,
|
|
(key >= 32 && key < 127) ? ((char) key) : '?');
|
|
}
|
|
latestEventKey = key;
|
|
|
|
Keyboard.addGlfwKeyEvent(window, key, scancode, action, mods);
|
|
// Ctrl should generate ASCII modifier keys (0x01-0x1F), glfw does not give use char events for this
|
|
if ((mods & GLFW_MOD_CONTROL) != 0 && key >= GLFW_KEY_A && key <= GLFW_KEY_Z) {
|
|
int codepoint = key & 0x1F;
|
|
Keyboard.addCharEvent(key, (char) codepoint);
|
|
}
|
|
}
|
|
};
|
|
|
|
Window.charCallback = new GLFWCharCallback() {
|
|
|
|
@Override
|
|
public void invoke(long window, int codepoint) {
|
|
if (Config.DEBUG_PRINT_KEY_EVENTS) {
|
|
Lwjgl3ify.LOG.info(
|
|
"[DEBUG-KEY] char window:{} codepoint:{} char:{}",
|
|
window,
|
|
codepoint,
|
|
(char) codepoint);
|
|
}
|
|
Keyboard.addCharEvent(latestEventKey, (char) codepoint);
|
|
}
|
|
};
|
|
|
|
Window.cursorPosCallback = new GLFWCursorPosCallback() {
|
|
|
|
@Override
|
|
public void invoke(long window, double xpos, double ypos) {
|
|
if (Config.DEBUG_PRINT_MOUSE_EVENTS) {
|
|
Lwjgl3ify.LOG.info("[DEBUG-MOUSE] cursorPos window:{} xpos:{} ypos:{}", window, xpos, ypos);
|
|
}
|
|
Mouse.addMoveEvent(xpos, ypos);
|
|
}
|
|
};
|
|
|
|
Window.mouseButtonCallback = new GLFWMouseButtonCallback() {
|
|
|
|
@Override
|
|
public void invoke(long window, int button, int action, int mods) {
|
|
if (Config.DEBUG_PRINT_MOUSE_EVENTS) {
|
|
Lwjgl3ify.LOG.info(
|
|
"[DEBUG-MOUSE] button window:{} button:{} action:{} mods:{}",
|
|
window,
|
|
button,
|
|
action,
|
|
mods);
|
|
}
|
|
Mouse.addButtonEvent(button, action == GLFW.GLFW_PRESS ? true : false);
|
|
}
|
|
};
|
|
|
|
Window.scrollCallback = new GLFWScrollCallback() {
|
|
|
|
@Override
|
|
public void invoke(long window, double xoffset, double yoffset) {
|
|
if (Config.DEBUG_PRINT_MOUSE_EVENTS) {
|
|
Lwjgl3ify.LOG.info("[DEBUG-MOUSE] wheel window:{} xoffset:{} yoffset:{}", window, xoffset, yoffset);
|
|
}
|
|
Mouse.addWheelEvent(yoffset);
|
|
}
|
|
};
|
|
|
|
Window.windowFocusCallback = new GLFWWindowFocusCallback() {
|
|
|
|
@Override
|
|
public void invoke(long window, boolean focused) {
|
|
if (Config.DEBUG_PRINT_MOUSE_EVENTS) {
|
|
Lwjgl3ify.LOG.info("[DEBUG-MOUSE] focus window:{} focus:{}", window, focused);
|
|
}
|
|
displayFocused = focused;
|
|
}
|
|
};
|
|
|
|
Window.windowIconifyCallback = new GLFWWindowIconifyCallback() {
|
|
|
|
@Override
|
|
public void invoke(long window, boolean iconified) {
|
|
if (Config.DEBUG_PRINT_MOUSE_EVENTS) {
|
|
Lwjgl3ify.LOG.info("[DEBUG-MOUSE] focus window:{} iconified:{}", window, iconified);
|
|
}
|
|
displayVisible = !iconified;
|
|
}
|
|
};
|
|
|
|
Window.windowSizeCallback = new GLFWWindowSizeCallback() {
|
|
|
|
@Override
|
|
public void invoke(long window, int width, int height) {
|
|
if (Config.DEBUG_PRINT_MOUSE_EVENTS) {
|
|
Lwjgl3ify.LOG.info("[DEBUG-MOUSE] window-resize window:{} w:{} h:{}", window, width, height);
|
|
}
|
|
latestResized = true;
|
|
latestWidth = width;
|
|
latestHeight = height;
|
|
}
|
|
};
|
|
|
|
Window.windowPosCallback = new GLFWWindowPosCallback() {
|
|
|
|
@Override
|
|
public void invoke(long window, int xpos, int ypos) {
|
|
displayX = xpos;
|
|
displayY = ypos;
|
|
}
|
|
};
|
|
|
|
Window.windowRefreshCallback = new GLFWWindowRefreshCallback() {
|
|
|
|
@Override
|
|
public void invoke(long window) {
|
|
displayDirty = true;
|
|
}
|
|
};
|
|
|
|
Window.framebufferSizeCallback = new GLFWFramebufferSizeCallback() {
|
|
|
|
@Override
|
|
public void invoke(long window, int width, int height) {
|
|
if (Config.DEBUG_PRINT_MOUSE_EVENTS) {
|
|
Lwjgl3ify.LOG.info("[DEBUG-MOUSE] framebuffer-resize window:{} w:{} h:{}", window, width, height);
|
|
}
|
|
displayFramebufferWidth = width;
|
|
displayFramebufferHeight = height;
|
|
}
|
|
};
|
|
|
|
Window.setCallbacks();
|
|
|
|
displayWidth = mode.getWidth();
|
|
displayHeight = mode.getHeight();
|
|
|
|
IntBuffer fbw = BufferUtils.createIntBuffer(1);
|
|
IntBuffer fbh = BufferUtils.createIntBuffer(1);
|
|
GLFW.glfwGetFramebufferSize(Window.handle, fbw, fbh);
|
|
displayFramebufferWidth = fbw.get(0);
|
|
displayFramebufferHeight = fbh.get(0);
|
|
|
|
displayX = (monitorWidth - mode.getWidth()) / 2;
|
|
displayY = (monitorHeight - mode.getHeight()) / 2;
|
|
|
|
glfwMakeContextCurrent(Window.handle);
|
|
drawable = new DrawableGL();
|
|
GL.createCapabilities();
|
|
|
|
if (savedIcons != null) {
|
|
setIcon(savedIcons);
|
|
savedIcons = null;
|
|
}
|
|
|
|
glfwSwapInterval(1);
|
|
|
|
displayCreated = true;
|
|
|
|
if (startFullscreen) {
|
|
setFullscreen(true);
|
|
}
|
|
|
|
int[] x = new int[1], y = new int[1];
|
|
GLFW.glfwGetWindowSize(Window.handle, x, y);
|
|
Window.windowSizeCallback.invoke(Window.handle, x[0], y[0]);
|
|
GLFW.glfwGetFramebufferSize(Window.handle, x, y);
|
|
Window.framebufferSizeCallback.invoke(Window.handle, x[0], y[0]);
|
|
}
|
|
|
|
public static boolean isCreated() {
|
|
return displayCreated;
|
|
}
|
|
|
|
public static boolean isActive() {
|
|
return displayFocused;
|
|
}
|
|
|
|
public static boolean isVisible() {
|
|
return displayVisible;
|
|
}
|
|
|
|
public static void setLocation(int new_x, int new_y) {
|
|
System.out.println("TODO: Implement Display.setLocation(int, int)");
|
|
}
|
|
|
|
public static void setVSyncEnabled(boolean sync) {
|
|
glfwSwapInterval(sync ? 1 : 0);
|
|
}
|
|
|
|
public static long getWindow() {
|
|
return Window.handle;
|
|
}
|
|
|
|
public static void update() {
|
|
update(true);
|
|
}
|
|
|
|
public static void update(boolean processMessages) {
|
|
swapBuffers();
|
|
displayDirty = false;
|
|
|
|
if (processMessages) processMessages();
|
|
}
|
|
|
|
public static void processMessages() {
|
|
glfwPollEvents();
|
|
Keyboard.poll();
|
|
Mouse.poll();
|
|
|
|
if (latestResized) {
|
|
latestResized = false;
|
|
displayResized = true;
|
|
displayWidth = latestWidth;
|
|
displayHeight = latestHeight;
|
|
} else {
|
|
displayResized = false;
|
|
}
|
|
}
|
|
|
|
public static void swapBuffers() {
|
|
glfwSwapBuffers(Window.handle);
|
|
}
|
|
|
|
public static void destroy() {
|
|
Window.releaseCallbacks();
|
|
glfwDestroyWindow(Window.handle);
|
|
|
|
/*
|
|
* try { glfwTerminate(); } catch (Throwable t) { t.printStackTrace(); }
|
|
*/
|
|
displayCreated = false;
|
|
}
|
|
|
|
public static void setDisplayMode(DisplayMode dm) {
|
|
mode = dm;
|
|
}
|
|
|
|
public static DisplayMode getDisplayMode() {
|
|
return mode;
|
|
}
|
|
|
|
public static DisplayMode[] getAvailableDisplayModes() {
|
|
IntBuffer count = BufferUtils.createIntBuffer(1);
|
|
GLFWVidMode.Buffer modes = GLFW.glfwGetVideoModes(glfwGetPrimaryMonitor());
|
|
|
|
DisplayMode[] displayModes = new DisplayMode[count.get(0)];
|
|
|
|
for (int i = 0; i < count.get(0); i++) {
|
|
modes.position(i * GLFWVidMode.SIZEOF);
|
|
|
|
int w = modes.width();
|
|
int h = modes.height();
|
|
int b = modes.redBits() + modes.greenBits() + modes.blueBits();
|
|
int r = modes.refreshRate();
|
|
|
|
displayModes[i] = new DisplayMode(w, h, b, r);
|
|
}
|
|
|
|
return displayModes;
|
|
}
|
|
|
|
public static DisplayMode getDesktopDisplayMode() {
|
|
return desktopDisplayMode;
|
|
}
|
|
|
|
public static boolean wasResized() {
|
|
return displayResized;
|
|
}
|
|
|
|
public static int getX() {
|
|
return displayX;
|
|
}
|
|
|
|
public static int getY() {
|
|
return displayY;
|
|
}
|
|
|
|
public static int getWidth() {
|
|
return displayWidth;
|
|
}
|
|
|
|
public static int getHeight() {
|
|
return displayHeight;
|
|
}
|
|
|
|
public static int getFramebufferWidth() {
|
|
return displayFramebufferWidth;
|
|
}
|
|
|
|
public static int getFramebufferHeight() {
|
|
return displayFramebufferHeight;
|
|
}
|
|
|
|
public static void setTitle(String title) {
|
|
windowTitle = title;
|
|
}
|
|
|
|
public static boolean isCloseRequested() {
|
|
return glfwWindowShouldClose(Window.handle);
|
|
}
|
|
|
|
public static boolean isDirty() {
|
|
return displayDirty;
|
|
}
|
|
|
|
public static void setInitialBackground(float red, float green, float blue) {
|
|
// no-op
|
|
}
|
|
|
|
public static int setIcon(java.nio.ByteBuffer[] icons) {
|
|
if (getWindow() == 0) {
|
|
savedIcons = icons;
|
|
return 0;
|
|
}
|
|
GLFWImage.Buffer glfwImages = GLFWImage.calloc(icons.length);
|
|
ByteBuffer[] nativeBuffers = new ByteBuffer[icons.length];
|
|
for (int icon = 0; icon < icons.length; icon++) {
|
|
nativeBuffers[icon] = org.lwjgl.BufferUtils.createByteBuffer(icons[icon].capacity());
|
|
nativeBuffers[icon].put(icons[icon]);
|
|
nativeBuffers[icon].flip();
|
|
int dimension = (int) Math.sqrt(nativeBuffers[icon].limit() / 4D);
|
|
if (dimension * dimension * 4 != nativeBuffers[icon].limit()) {
|
|
throw new IllegalStateException();
|
|
}
|
|
glfwImages.put(icon, GLFWImage.create().set(dimension, dimension, nativeBuffers[icon]));
|
|
}
|
|
GLFW.glfwSetWindowIcon(getWindow(), glfwImages);
|
|
glfwImages.free();
|
|
return 0;
|
|
}
|
|
|
|
public static void setResizable(boolean resizable) {
|
|
displayResizable = resizable;
|
|
// Ignore the request because why would you make the game window non-resizable
|
|
}
|
|
|
|
public static boolean isResizable() {
|
|
return displayResizable;
|
|
}
|
|
|
|
public static void setDisplayModeAndFullscreen(DisplayMode mode) {
|
|
// TODO
|
|
System.out.println("TODO: Implement Display.setDisplayModeAndFullscreen(DisplayMode)");
|
|
}
|
|
|
|
private static int savedX[] = new int[1], savedY[] = new int[1];
|
|
private static int savedW[] = new int[1], savedH[] = new int[1];
|
|
|
|
public static void setFullscreen(boolean fullscreen) {
|
|
final long window = getWindow();
|
|
if (window == 0) {
|
|
startFullscreen = fullscreen;
|
|
return;
|
|
}
|
|
final boolean currentState = isFullscreen();
|
|
if (currentState == fullscreen) {
|
|
return;
|
|
}
|
|
if (fullscreen) {
|
|
glfwGetWindowPos(window, savedX, savedY);
|
|
glfwGetWindowSize(window, savedW, savedH);
|
|
long monitorId = glfwGetPrimaryMonitor();
|
|
final GLFWVidMode vidMode = glfwGetVideoMode(monitorId);
|
|
glfwSetWindowMonitor(window, monitorId, 0, 0, vidMode.width(), vidMode.height(), vidMode.refreshRate());
|
|
} else {
|
|
glfwSetWindowMonitor(window, NULL, savedX[0], savedY[0], savedW[0], savedH[0], 0);
|
|
}
|
|
}
|
|
|
|
public static boolean isFullscreen() {
|
|
if (getWindow() != 0) {
|
|
return glfwGetWindowMonitor(getWindow()) != NULL;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static void setParent(java.awt.Canvas parent) {
|
|
// Do nothing as set parent not supported
|
|
}
|
|
|
|
public static void releaseContext() {
|
|
glfwMakeContextCurrent(0);
|
|
}
|
|
|
|
public static boolean isCurrent() {
|
|
return true;
|
|
}
|
|
|
|
public static void makeCurrent() {
|
|
glfwMakeContextCurrent(Window.handle);
|
|
}
|
|
|
|
public static java.lang.String getAdapter() {
|
|
if (isCreated()) {
|
|
return GL11.glGetString(GL11.GL_VENDOR);
|
|
}
|
|
return "Unknown";
|
|
}
|
|
|
|
public static java.lang.String getVersion() {
|
|
if (isCreated()) {
|
|
return GL11.glGetString(GL11.GL_VERSION);
|
|
}
|
|
return "Unknown";
|
|
}
|
|
|
|
/**
|
|
* An accurate sync method that will attempt to run at a constant frame rate. It should be called once every frame.
|
|
*
|
|
* @param fps - the desired frame rate, in frames per second
|
|
*/
|
|
public static void sync(int fps) {
|
|
Sync.sync(fps);
|
|
}
|
|
|
|
protected static DrawableGL drawable = null;
|
|
|
|
public static Drawable getDrawable() {
|
|
return drawable;
|
|
}
|
|
|
|
static DisplayImplementation getImplementation() {
|
|
return null;
|
|
}
|
|
|
|
private static class Window {
|
|
|
|
static long handle;
|
|
|
|
static GLFWKeyCallback keyCallback;
|
|
static GLFWCharCallback charCallback;
|
|
static GLFWCursorPosCallback cursorPosCallback;
|
|
static GLFWMouseButtonCallback mouseButtonCallback;
|
|
static GLFWScrollCallback scrollCallback;
|
|
static GLFWWindowFocusCallback windowFocusCallback;
|
|
static GLFWWindowIconifyCallback windowIconifyCallback;
|
|
static GLFWWindowSizeCallback windowSizeCallback;
|
|
static GLFWWindowPosCallback windowPosCallback;
|
|
static GLFWWindowRefreshCallback windowRefreshCallback;
|
|
static GLFWFramebufferSizeCallback framebufferSizeCallback;
|
|
|
|
public static void setCallbacks() {
|
|
GLFW.glfwSetKeyCallback(handle, keyCallback);
|
|
GLFW.glfwSetCharCallback(handle, charCallback);
|
|
GLFW.glfwSetCursorPosCallback(handle, cursorPosCallback);
|
|
GLFW.glfwSetMouseButtonCallback(handle, mouseButtonCallback);
|
|
GLFW.glfwSetScrollCallback(handle, scrollCallback);
|
|
GLFW.glfwSetWindowFocusCallback(handle, windowFocusCallback);
|
|
GLFW.glfwSetWindowIconifyCallback(handle, windowIconifyCallback);
|
|
GLFW.glfwSetWindowSizeCallback(handle, windowSizeCallback);
|
|
GLFW.glfwSetWindowPosCallback(handle, windowPosCallback);
|
|
GLFW.glfwSetWindowRefreshCallback(handle, windowRefreshCallback);
|
|
GLFW.glfwSetFramebufferSizeCallback(handle, framebufferSizeCallback);
|
|
}
|
|
|
|
public static void releaseCallbacks() {
|
|
keyCallback.free();
|
|
charCallback.free();
|
|
cursorPosCallback.free();
|
|
mouseButtonCallback.free();
|
|
scrollCallback.free();
|
|
windowFocusCallback.free();
|
|
windowIconifyCallback.free();
|
|
windowSizeCallback.free();
|
|
windowPosCallback.free();
|
|
windowRefreshCallback.free();
|
|
framebufferSizeCallback.free();
|
|
}
|
|
}
|
|
}
|