private void init() {
System.out.println("LWJGL VERSION " + Version.getVersion());
if (!glfwInit()) {
throw new IllegalStateException("Init failed");
}
glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE);
winID = glfwCreateWindow(WORLD_X, WORLD_Y, "Cerberus", NULL, NULL);
if (winID == NULL) throw new RuntimeException("FAILED TO CREATE WINDOW");
glfwSetKeyCallback(
winID,
(window, key, scancode, action, mods) -> {
if (key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE) {
glfwSetWindowShouldClose(winID, true);
}
});
long priMon = glfwGetPrimaryMonitor();
GLFWVidMode vidmod = glfwGetVideoMode(priMon);
glfwSetWindowPos(winID, (vidmod.width() - WORLD_X) / 2, (vidmod.height() - WORLD_Y) / 2);
glfwMakeContextCurrent(winID);
glfwShowWindow(winID);
}
public void init() {
// if not true after being executed then it will fail. - THIS MUST RETURN TRUE IN ORDER TO
// CONTINUE
if (glfwInit() != GL_TRUE) {
// Once GLFW is initialised - window can be created
System.err.println("GLFW initialisation has failed");
throw new IllegalStateException("Unable to initialize GLFW");
}
// indicate that the window we wish to create is to be made resizable
glfwWindowHint(GLFW_RESIZABLE, GL_TRUE);
// glfwCreateWindow(width, height, title, monitor, share)
window = glfwCreateWindow(800, 600, "Mikes Tester Window", NULL, NULL);
// if window is not populated with necessary bytes - then it fails
if (window == NULL) {
System.err.println("Failed to create window");
glfwTerminate();
throw new RuntimeException("Failed to create the GLFW window");
}
glfwSetKeyCallback(window, keyCallback = new Input());
// Returns the video resolution of primary monitor
GLFWVidMode vidMode = glfwGetVideoMode(glfwGetPrimaryMonitor());
//
int WIDTH = 300;
int HEIGHT = 300;
// Centre the window
glfwSetWindowPos(window, (vidMode.width() - WIDTH) / 2, (vidMode.height() - HEIGHT) / 2);
// Make the OpenGL context current
glfwMakeContextCurrent(window);
// library can detect the context and make the OpenGL bindings available for use.
GL.createCapabilities();
// Enable v-sync
glfwSwapInterval(1);
// show the window
glfwShowWindow(window);
// glClearColor(056f, 0.258f, 0.425f, 1.0f);
glEnable(GL_DEPTH_TEST);
System.out.println("OPenGL: " + glGetString(GL_VERSION));
}
private void InitWindow() {
GLFWVidMode vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());
// Center window on the screen
glfwSetWindowPos(window, (vidmode.width() - width) / 2, (vidmode.height() - height) / 2);
// Set window events callbacks
glfwSetKeyCallback(window, keyCallback = new Input());
glfwSetWindowSizeCallback(window, sizeCallback = new ResizeHandler());
glfwSetMouseButtonCallback(window, mouseCallback = new MouseHandler());
glfwSetWindowFocusCallback(window, focusCallback = new FocusCallback());
glfwMakeContextCurrent(window);
glfwSwapInterval(0);
glfwShowWindow(window);
}
private void init() {
// Setup an error callback. The default implementation
// will print the error message in System.err.
glfwSetErrorCallback(errorCallback = GLFWErrorCallback.createPrint(System.err));
// Initialize GLFW. Most GLFW functions will not work before doing this.
if (glfwInit() != GLFW_TRUE) throw new IllegalStateException("Unable to initialize GLFW");
// Configure our window
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
int WIDTH = 300;
int HEIGHT = 300;
// Create the window
window = glfwCreateWindow(WIDTH, HEIGHT, "Hello World!", NULL, NULL);
if (window == NULL) throw new RuntimeException("Failed to create the GLFW window");
// Setup a key callback. It will be called every time a key is pressed, repeated or released.
glfwSetKeyCallback(
window,
keyCallback =
new GLFWKeyCallback() {
@Override
public void invoke(long window, int key, int scancode, int action, int mods) {
if (key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE)
glfwSetWindowShouldClose(
window, GLFW_TRUE); // We will detect this in our rendering loop
}
});
// Get the resolution of the primary monitor
GLFWVidMode vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());
// Center our window
glfwSetWindowPos(window, (vidmode.width() - WIDTH) / 2, (vidmode.height() - HEIGHT) / 2);
// Make the OpenGL context current
glfwMakeContextCurrent(window);
// Enable v-sync
glfwSwapInterval(1);
// Make the window visible
glfwShowWindow(window);
}
private static void initWindow(int w, int h) {
HEIGHT = h;
WIDTH = w;
// Configure our window
glfwDefaultWindowHints(); // optional, the current window hints are already the default
glfwWindowHint(GLFW_VISIBLE, GL_FALSE); // the window will stay hidden after creation
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
glfwWindowHint(GLFW_DECORATED, GL_FALSE);
glfwWindowHint(GLFW_DOUBLE_BUFFER, GL_TRUE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 1);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
// glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
// glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
// Create the window
window = glfwCreateWindow(WIDTH, HEIGHT, "GameEngine", glfwGetPrimaryMonitor(), NULL);
if (window == NULL) throw new RuntimeException("Failed to create the GLFW window");
// Get the resolution of the primary monitor
GLFWVidMode vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());
// Center our window
glfwSetWindowPos(window, (vidmode.width() - WIDTH) / 2, (vidmode.height() - HEIGHT) / 2);
// Make the OpenGL context current
glfwMakeContextCurrent(window);
// GLContext.createFromCurrent();
// Enable v-sync
glfwSwapInterval(1);
GL.createCapabilities();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// glEnable(GL_DEPTH_TEST);
// glDepthFunc(GL_LESS);
// glDepthMask(true);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
// glDisable(GL_DEPTH_TEST);
glClearColor(0.20f, 0.10f, 0.20f, 1.0f);
}
public void init() {
// Setup an error callback. The default implementation
// will print the error message in System.err.
glfwSetErrorCallback(errorCallback = GLFWErrorCallback.createPrint(System.err));
// Initialize GLFW. Most GLFW functions will not work before doing this.
if (glfwInit() != GL11.GL_TRUE) {
throw new IllegalStateException("Unable to initialize GLFW");
}
glfwDefaultWindowHints(); // optional, the current window hints are already the default
glfwWindowHint(GLFW_VISIBLE, GL_FALSE); // the window will stay hidden after creation
glfwWindowHint(GLFW_RESIZABLE, GL_TRUE); // the window will be resizable
// Create the window
windowHandle = glfwCreateWindow(width, height, title, NULL, NULL);
if (windowHandle == NULL) {
throw new RuntimeException("Failed to create the GLFW window");
}
// Setup resize callback
glfwSetWindowSizeCallback(
windowHandle,
windowSizeCallback =
new GLFWWindowSizeCallback() {
@Override
public void invoke(long window, int width, int height) {
Window.this.width = width;
Window.this.height = height;
Window.this.setResized(true);
}
});
// Setup a key callback. It will be called every time a key is pressed, repeated or released.
glfwSetKeyCallback(
windowHandle,
keyCallback =
new GLFWKeyCallback() {
@Override
public void invoke(long window, int key, int scancode, int action, int mods) {
if (key == GLFW_KEY_ESCAPE && action == GLFW_RELEASE) {
glfwSetWindowShouldClose(window, GL_TRUE);
}
}
});
// Get the resolution of the primary monitor
GLFWVidMode vidmode = glfwGetVideoMode(glfwGetPrimaryMonitor());
// Center our window
glfwSetWindowPos(windowHandle, (vidmode.width() - width) / 2, (vidmode.height() - height) / 2);
// Make the OpenGL context current
glfwMakeContextCurrent(windowHandle);
// Enable v-sync
glfwSwapInterval(1);
// Make the window visible
glfwShowWindow(windowHandle);
GL.createCapabilities();
// Set the clear color
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glEnable(GL_DEPTH_TEST);
}
static long createGlfwWindow(Lwjgl3ApplicationConfiguration config, long sharedContextWindow) {
GLFW.glfwDefaultWindowHints();
GLFW.glfwWindowHint(GLFW.GLFW_VISIBLE, GLFW.GLFW_FALSE);
GLFW.glfwWindowHint(
GLFW.GLFW_RESIZABLE, config.windowResizable ? GLFW.GLFW_TRUE : GLFW.GLFW_FALSE);
if (sharedContextWindow == 0) {
GLFW.glfwWindowHint(GLFW.GLFW_RED_BITS, config.r);
GLFW.glfwWindowHint(GLFW.GLFW_GREEN_BITS, config.g);
GLFW.glfwWindowHint(GLFW.GLFW_BLUE_BITS, config.b);
GLFW.glfwWindowHint(GLFW.GLFW_ALPHA_BITS, config.a);
GLFW.glfwWindowHint(GLFW.GLFW_STENCIL_BITS, config.stencil);
GLFW.glfwWindowHint(GLFW.GLFW_DEPTH_BITS, config.depth);
GLFW.glfwWindowHint(GLFW.GLFW_SAMPLES, config.samples);
}
if (config.useGL30) {
// GLFW.glfwWindowHint(GLFW.GLFW_CLIENT_API, GLFW.GLFW_OPENGL_API);
GLFW.glfwWindowHint(GLFW.GLFW_CONTEXT_VERSION_MAJOR, config.gles30ContextMajorVersion);
GLFW.glfwWindowHint(GLFW.GLFW_CONTEXT_VERSION_MINOR, config.gles30ContextMinorVersion);
GLFW.glfwWindowHint(GLFW.GLFW_OPENGL_FORWARD_COMPAT, GLFW.GLFW_TRUE);
GLFW.glfwWindowHint(GLFW.GLFW_OPENGL_PROFILE, GLFW.GLFW_OPENGL_CORE_PROFILE);
}
long windowHandle = 0;
if (config.fullscreenMode != null) {
// glfwWindowHint(GLFW.GLFW_REFRESH_RATE, config.fullscreenMode.refreshRate);
windowHandle =
GLFW.glfwCreateWindow(
config.fullscreenMode.width,
config.fullscreenMode.height,
config.title,
config.fullscreenMode.getMonitor(),
sharedContextWindow);
} else {
GLFW.glfwWindowHint(
GLFW.GLFW_DECORATED, config.windowDecorated ? GLFW.GLFW_TRUE : GLFW.GLFW_FALSE);
windowHandle =
GLFW.glfwCreateWindow(
config.windowWidth, config.windowHeight, config.title, 0, sharedContextWindow);
}
if (windowHandle == 0) {
throw new GdxRuntimeException("Couldn't create window");
}
if (config.fullscreenMode == null) {
if (config.windowX == -1 && config.windowY == -1) {
GLFWVidMode vidMode = GLFW.glfwGetVideoMode(GLFW.glfwGetPrimaryMonitor());
GLFW.glfwSetWindowPos(
windowHandle,
vidMode.width() / 2 - config.windowWidth / 2,
vidMode.height() / 2 - config.windowHeight / 2);
} else {
GLFW.glfwSetWindowPos(windowHandle, config.windowX, config.windowY);
}
}
GLFW.glfwMakeContextCurrent(windowHandle);
GLFW.glfwSwapInterval(config.vSyncEnabled ? 1 : 0);
GL.createCapabilities();
extractVersion();
if (!isOpenGLOrHigher(2, 0))
throw new GdxRuntimeException(
"OpenGL 2.0 or higher with the FBO extension is required. OpenGL version: "
+ GL11.glGetString(GL11.GL_VERSION)
+ "\n"
+ glInfo());
if (!supportsFBO()) {
throw new GdxRuntimeException(
"OpenGL 2.0 or higher with the FBO extension is required. OpenGL version: "
+ GL11.glGetString(GL11.GL_VERSION)
+ ", FBO extension: false\n"
+ glInfo());
}
for (int i = 0; i < 2; i++) {
GL11.glClearColor(
config.initialBackgroundColor.r,
config.initialBackgroundColor.g,
config.initialBackgroundColor.b,
config.initialBackgroundColor.a);
GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
GLFW.glfwSwapBuffers(windowHandle);
}
return windowHandle;
}
public void initialize(
float fieldOfView, int w, int h, float zn, float zf, boolean resizable, long share) {
if (init) {
return;
}
FOV = fieldOfView;
zNear = zn;
zFar = zf;
width = w;
height = h;
Platform.setDefaultGLFWWindowConfigurations();
GLFW.glfwWindowHint(GLFW.GLFW_RESIZABLE, resizable ? GLFW.GLFW_TRUE : GLFW.GLFW_FALSE);
window =
GLFW.glfwCreateWindow(
w,
h,
title,
MemoryUtil.NULL,
share == Registry.INVALID ? Nemgine.getOpenGLContext() : share);
if (window == MemoryUtil.NULL) {
new WindowException(Registry.WINDOW_EXCEPTION_FAILED_TO_CREATE).printStackTrace();
return;
}
GLFWVidMode mode = GLFW.glfwGetVideoMode(GLFW.glfwGetPrimaryMonitor());
GLFW.glfwSetWindowPos(window, (mode.width() - w) / 2, (mode.height() - h) / 2);
sizeCallback =
new GLFWWindowSizeCallback() {
@Override
public void invoke(long window, int wi, int he) {
width = wi;
height = he;
resized = true;
}
};
keyCallback =
new GLFWKeyCallback() {
@Override
public void invoke(long window, int key, int scancode, int action, int mods) {
if (input != null) {
input.keyEvent(key, scancode, action, mods);
}
}
};
charCallback =
new GLFWCharCallback() {
@Override
public void invoke(long window, int codepoint) {
if (input != null) {
input.charEvent((char) codepoint);
}
}
};
charModsCallback =
new GLFWCharModsCallback() {
@Override
public void invoke(long window, int codepoint, int mods) {
if (input != null) {
input.charModsEvent((char) codepoint, mods);
}
}
};
GLFW.glfwSetWindowSizeCallback(window, sizeCallback);
GLFW.glfwSetKeyCallback(window, keyCallback);
GLFW.glfwSetCharCallback(window, charCallback);
GLFW.glfwSetCharModsCallback(window, charModsCallback);
GLFW.glfwMakeContextCurrent(window);
GL.createCapabilities(Registry.OPENGL_FORWARD_COMPATIBLE);
GLFW.glfwShowWindow(window);
IntBuffer b1 = BufferUtils.createIntBuffer(1);
IntBuffer b2 = BufferUtils.createIntBuffer(1);
GLFW.glfwGetFramebufferSize(window, b1, b2);
GL11.glViewport(0, 0, b1.get(), b2.get());
GL11.glEnable(GL11.GL_DEPTH_TEST);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
resize();
init = true;
}
