michael/lwjgl
michael
/
lwjgl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

New Window class, and major changes to Display

This commit is contained in:
Caspian Rychlik-Prince 2003-03-27 22:32:48 +00:00
parent bb2d3d472d
commit 796b84c3d1
9 changed files with 389 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

158
src/java/org/lwjgl/Display.java
View File

@ -34,6 +34,7 @@ package org.lwjgl;
import java.util.HashSet;
import java.util.Arrays;
/**
* $Id$
*
@ -49,6 +50,7 @@ public final class Display {
static {
System.loadLibrary(Sys.getLibraryName());
init();
}
/** Has the display been created? */
@ -83,6 +85,12 @@ public final class Display {
private Display() {
super();
}
/**
* Initialize. This determines, natively, the current display mode and stashes
* it back in the mode static member.
*/
private static native void init();
/**
* Returns the entire list of display modes as an array, in no
@ -116,89 +124,29 @@ public final class Display {
/**
* Native method for getting displaymodes
*/
public static native DisplayMode[] nGetAvailableDisplayModes();
private static native DisplayMode[] nGetAvailableDisplayModes();
/**
* Create a display with the specified display mode. If the display is
* already created then no action is taken - the display must first be
* destroyed.
*
* @param displayMode A display mode to choose
* @param alpha Minimun number of alpha bits on the display
* @param depth Minimun number of depth bits on the display
* @param stencil Minimun number of stencil bits on the display
* @param fullscreen Whether to create the display fullscreen
* @param title The title for the application
* Set the current display mode. The underlying OS may not use an exact match for
* the specified display mode. After successfully calling setDisplayMode() you will
* still need to query the display's characteristics using getDisplayMode().
* @param newMode The new display mode to set
* @throws Exception if the display mode could not be set
* @see #destroy()
*/
public static void create(DisplayMode displayMode, int alpha, int depth, int stencil, boolean fullscreen, String title)
throws Exception {
if (created) {
return;
}
if (!nCreate(displayMode.width,
displayMode.height,
displayMode.bpp,
displayMode.freq,
alpha,
depth,
stencil,
fullscreen,
title)) {
throw new Exception("Failed to set display mode to " + displayMode);
}
created = true;
mode = displayMode;
}
public static native void setDisplayMode(DisplayMode mode) throws Exception;
/**
* Native method to create the display. This will set the handle if it is
* successful.
* @return true if the display was successfully created
* @see #create(org.lwjgl.DisplayMode, boolean)
* Reset the display mode to whatever it was when LWJGL was initialized.
* Fails silently.
*/
private static native boolean nCreate(
int width,
int height,
int bpp,
int freq,
int alpha_bits,
int depth_bits,
int stencil_bits,
boolean fullscreen,
String title);
/**
* Destroy the display and return it to normal. If the display has not yet
* been created no action is taken.
*/
public static void destroy() {
if (!created) {
return;
}
nDestroy();
created = false;
mode = null;
}
/**
* Native method to destroy the display. This will reset the handle.
*/
private static native void nDestroy();
public static native void resetDisplayMode() throws Exception;
/**
* Retrieves the width of the created display
*
* @return the current display width.
* @throws AssertionError if the display has not been created yet.
*/
public static int getWidth() {
assert created : "The display has not been created yet.";
return mode.width;
}
@ -206,10 +154,8 @@ public final class Display {
* Retrieves the height of the created display
*
* @return the current display height.
* @throws AssertionError if the display has not been created yet.
*/
public static int getHeight() {
assert created : "The display has not been created yet.";
return mode.height;
}
@ -217,10 +163,8 @@ public final class Display {
* Retrieves the current display depth of the created display
*
* @return the current display depth.
* @throws AssertionError if the display has not been created yet.
*/
public static int getDepth() {
assert created : "The display has not been created yet.";
return mode.bpp;
}
@ -228,27 +172,14 @@ public final class Display {
* Retrieves the current display frequency of the created display
*
* @return the current display frequency.
* @throws AssertionError if the display has not been created yet.
*/
public static int getFrequency() {
assert created : "The display has not been created yet.";
return mode.freq;
}
/**
* Retrieves the <code>DisplayMode</code> that the display has currently been
* set to.
*
* @return the current display mode, or null if the display is not yet created
* @throws AssertionError if the display has not been created yet.
*/
public static DisplayMode getDisplayMode() {
assert created : "The display has not been created yet.";
return mode;
}
/**
* Retrieves the native handle to the created window
* Retrieves the native handle to the created window. The meaning of this value
* is platform specific. Under Win32, it is an HWND.
*
* @return the native handle
* @throws AssertionError if the display has not been created yet.
@ -258,37 +189,6 @@ public final class Display {
return handle;
}
/**
* Tests whether or not the display has been created
*
* @return true if the display has been created
*/
public static boolean isCreated() {
return created;
}
/**
* Determines if the display is minimized. When the display is minimized it is
* effectively invisible, and you need perform no rendering in your game loop.
* On the native side, when the application is switched to some other application,
* the display window will minimize; when focus is regained, it will maximize and
* automatically gain focus and become the foreground window again.
* @return true if the display is minimized
*/
public static native boolean isMinimized();
/**
* Determines if the user has requested that the application should close.
* When a user has requested that the application should shutdown, it is up to
* the application to perform the actual shutdown and cleanup of any allocated
* resources.
*
* @return true if the user has requested that the application should close
*/
public static boolean isCloseRequested() {
return closeRequested;
}
/**
* Returns the operating system windowing platform. This will be one of the
* constants defined above. There is no "unknown" platform; a native library port
@ -299,5 +199,21 @@ public final class Display {
*/
public static native int getPlatform();
/**
* Obtains the display's gamma ramp. The gamma ramp returned is an array of
* integers in the range 0..255. If gamma is not supported by the underlying
* hardware then null is returned.
* @return an array of ints, or null
*/
public static native int[] getGammaRamp();
/**
* Sets the display's gamma ramp. The gamma ramp should be an array of ints
* in the range 0...255. The length of the array should match the length of the
* array returned by getGammaRamp().
*
* If the underlying hardware does not support gamma then this command is a no-op.
*/
public static native void setGammaRamp(int[] gamma);
}

175
src/java/org/lwjgl/Window.java Normal file
View File

@ -0,0 +1,175 @@
/*
* Created on 27-Mar-2003
*
* To change this generated comment go to
* Window>Preferences>Java>Code Generation>Code Template
*/
package org.lwjgl;
/**
* This is the abstract base class for a Window in LWJGL. LWJGL windows have some
* peculiar characteristics:
*
* - width and height are always fixed and cannot be changed
* - the position of the window may or may not be programmable but once specified
* cannot be changed
* - the window may be closeable by the user or operating system, and may be minimized
* by the user or operating system
* - the operating system may or may not allow more than one window to be constructed
* at any one time. There is no guarantee that all windows can be visible at once.
* - the operating system may or may not be able to do fullscreen or windowed windows.
*
* @author foo
*/
public abstract class Window {
static {
System.loadLibrary(Sys.getLibraryName());
}
/** The window's native data structure. On Win32 this is an HWND. */
private int handle;
/** Whether the window is currently minimized */
private boolean minimized;
/** Whether the window has been asked to close by the user or underlying OS */
private boolean closeRequested;
/** Whether the window is dirty, ie. needs painting */
private boolean dirty;
/** X coordinate of the window */
private int x;
/**
* Y coordinate of the window. Y in window coordinates is from the top of the display down,
* unlike GL, where it is typically at the bottom of the display.
*/
private int y;
/** Width of the window */
private final int width;
/** Height of the window */
private final int height;
/** Title of the window */
private String title;
/**
* Construct a Window. Some OSs may not support non-fullscreen windows; in
* which case the window will be fullscreen regardless.
*
* In this abstract base class, no actual window peer is constructed. This should be
* done in specialised derived classes.
*
* @param title The window's title
* @param x, y, width, height The position and dimensions of the client area of
* the window. The dimensions may be ignored if the window cannot be made non-
* fullscreen. The position may be ignored in either case.
*/
protected Window(String title, int x, int y, int width, int height) {
this.title = title;
this.x = x;
this.y = y;
this.width = width;
this.height = height;
}
/**
* @return the width of the window
*/
public final int getWidth() {
return width;
}
/**
* @return the height of the window
*/
public final int getHeight() {
return height;
}
/**
* @return the title of the window
*/
public final String getTitle() {
return title;
}
/**
* Set the title of the window. This may be ignored by the underlying OS.
* @param newTitle The new window title
*/
public final void setTitle(String newTitle) {
title = newTitle;
nSetTitle();
}
/**
* Native implementation of setTitle(). This will read the window's title member
* and stash it in the native title of the window.
*/
private native void nSetTitle();
/**
* @return true if the user or operating system has asked the window to close
*/
public final boolean isCloseRequested() {
return closeRequested;
}
/**
* @return true if the window is minimized or otherwise not visible
*/
public final boolean isMinimized() {
return minimized;
}
/**
* Determine if the window's contents have been damaged by external events.
* If you are writing a straightforward game rendering loop and simply paint
* every frame regardless, you can ignore this flag altogether. If you are
* trying to be kind to other processes you can check this flag and only
* redraw when it returns true. The flag is cleared when you call paint().
*
* @return true if the window has been damaged by external changes
* and needs to repaint itself
*/
public final boolean isDirty() {
return dirty;
}
/**
* Paint the window. This clears the dirty flag and swaps the buffers.
*/
public final void paint() {
dirty = false;
swapBuffers();
}
/**
* Swap the buffers.
*/
private native void swapBuffers();
/**
* Destroy the window.
*/
public final native void destroy();
/**
* @return the native window handle
*/
public final int getHandle() {
return handle;
}
/**
* 'Tick' the window. This must be called at least once per video frame
* to handle window close requests, moves, paints, etc.
*/
public final native void tick();
}

162
src/java/org/lwjgl/opengl/BaseGL.java
View File

@ -190,4 +190,166 @@ abstract class BaseGL {
&& Thread.currentThread() == renderThread;
}
/**
* Create a fullscreen display. If the display has already been created then this
* method is a no-op.
*
* Alpha, depth, and stencil will be 0 bits.
*
* @param title The title for the application
* @throws Exception if the window could not be created for any reason
* @see #destroy()
*/
public static void create(String title) throws Exception {
create(title, 0, 0, 0);
}
/**
* Create a fullscreen display. If the display has already been created then this
* method is a no-op.
*
* @param title The title for the application
* @param alpha Minimun number of alpha bits on the display
* @param depth Minimun number of depth bits on the display
* @param stencil Minimun number of stencil bits on the display
* @throws Exception if the window could not be created for any reason
* @see #destroy()
*/
public static void create(String title, int alpha, int depth, int stencil)
throws Exception {
if (Display.created) {
return;
}
if (!nCreateFullscreen(title, alpha, depth, stencil)) {
throw new Exception("Failed to create fullscreen display.");
}
Display.created = true;
}
/**
* Create a windowed display. If the display has already been created then this
* method is a no-op.
*
* The window is not guaranteed to be positioned at (x, y). Nor is it guaranteed
* to have a drag bar, title bar, close button, or minimized button. It cannot be
* resized once created.
*
* The window will have 0 bits alpha, depth, and stencil.
*
* @param title The title for the application
* @param x, y The position of the window
* @param width, height The dimensions of the drawable area of the window
* @throws Exception if the window could not be created for any reason
* @see #destroy()
*/
public static void create(String title, int x, int y, int width, int height)
throws Exception {
create(title, x, y, width, height, 0, 0, 0);
}
/**
* Create a windowed display. If the display has already been created then this
* method is a no-op.
*
* The window is not guaranteed to be positioned at (x, y). Nor is it guaranteed
* to have a drag bar, title bar, close button, or minimized button. It cannot be
* resized once created.
*
* @param title The title for the application
* @param x, y The position of the window
* @param width, height The dimensions of the drawable area of the window
* @param alpha Minimun number of alpha bits on the display
* @param depth Minimun number of depth bits on the display
* @param stencil Minimun number of stencil bits on the display
* @throws Exception if the window could not be created for any reason
* @see #destroy()
*/
public static void create(String title, int x, int y, int width, int height, int alpha, int depth, int stencil)
throws Exception {
if (Display.created) {
return;
}
if (!nCreateWindowed(title, x, y, width, height, alpha, depth, stencil)) {
throw new Exception("Failed to create windowed display.");
}
Display.created = true;
}
/**
* Native method to create the display. This will set the handle if it is
* successful.
* @return true if the display was successfully created
* @see #create(org.lwjgl.DisplayMode, boolean)
*/
private static native boolean nCreateWindowed(
String title,
int x,
int y,
int width,
int height,
int alpha_bits,
int depth_bits,
int stencil_bits);
/**
* Native method to create the display. This will set the handle if it is
* successful.
* @return true if the display was successfully created
* @see #create(org.lwjgl.DisplayMode, boolean)
*/
private static native boolean nCreateFullscreen(
String title,
int alpha_bits,
int depth_bits,
int stencil_bits);
/**
* Destroy the display and return it to normal. If the display has not yet
* been created no action is taken.
*/
public static void destroy() {
if (!Display.created) {
return;
}
nDestroy();
Display.created = false;
Display.mode = null;
}
/**
* Native method to destroy the display. This will reset the handle.
*/
private static native void nDestroy();
/**
* Determines if the display is minimized. When the display is minimized it is
* effectively invisible, and you need perform no rendering in your game loop.
* On the native side, when the application is switched to some other application,
* the display window will minimize; when focus is regained, it will maximize and
* automatically gain focus and become the foreground window again.
* @return true if the display is minimized
*/
public static native boolean isMinimized();
/**
* Determines if the user has requested that the application should close.
* When a user has requested that the application should shutdown, it is up to
* the application to perform the actual shutdown and cleanup of any allocated
* resources.
*
* @return true if the user has requested that the application should close
*/
public static boolean isCloseRequested() {
return Display.closeRequested;
}
}

3
src/java/org/lwjgl/test/WindowCreationTest.java
View File

@ -7,6 +7,7 @@
package org.lwjgl.test;
import org.lwjgl.*;
import org.lwjgl.opengl.BaseGL;
/**
* @author Brian
@ -43,6 +44,6 @@ public class WindowCreationTest {
System.out.println("Display created");
Display.destroy();
BaseGL.destroy();
}
}

5
src/java/org/lwjgl/test/input/ControllerCreationTest.java
View File

@ -35,6 +35,7 @@ import org.lwjgl.Sys;
import org.lwjgl.Display;
import org.lwjgl.DisplayMode;
import org.lwjgl.input.Controller;
import org.lwjgl.opengl.*;
import org.lwjgl.opengl.GL;
import org.lwjgl.opengl.GLU;
import org.lwjgl.vector.Vector2f;
@ -118,7 +119,7 @@ public class ControllerCreationTest {
// recreate display in fullscreen mode
System.out.print("Destroying display...");
Display.destroy();
BaseGL.destroy();
System.out.println("success");
System.out.print("Entering fullscreen mode...");
@ -140,7 +141,7 @@ public class ControllerCreationTest {
System.out.print("Shutting down...");
Controller.destroy();
gl.destroy();
Display.destroy();
BaseGL.destroy();
System.out.println("shutdown complete");
}

5
src/java/org/lwjgl/test/input/MouseCreationTest.java
View File

@ -35,6 +35,7 @@ import org.lwjgl.Sys;
import org.lwjgl.Display;
import org.lwjgl.DisplayMode;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.*;
import org.lwjgl.opengl.GL;
import org.lwjgl.opengl.GLU;
import org.lwjgl.vector.Vector2f;
@ -118,7 +119,7 @@ public class MouseCreationTest {
// recreate display in fullscreen mode
System.out.print("Destroying display...");
Display.destroy();
BaseGL.destroy();
System.out.println("success");
System.out.print("Entering fullscreen mode...");
@ -140,7 +141,7 @@ public class MouseCreationTest {
System.out.print("Shutting down...");
Mouse.destroy();
gl.destroy();
Display.destroy();
BaseGL.destroy();
System.out.println("shutdown complete");
}

7
src/java/org/lwjgl/test/input/MouseTest.java
View File

@ -35,6 +35,7 @@ import org.lwjgl.Display;
import org.lwjgl.DisplayMode;
import org.lwjgl.input.Mouse;
import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.*;
import org.lwjgl.opengl.GL;
import org.lwjgl.opengl.GLU;
import org.lwjgl.vector.Vector2f;
@ -118,7 +119,7 @@ public class MouseTest {
Mouse.destroy();
Keyboard.destroy();
gl.destroy();
Display.destroy();
BaseGL.destroy();
}
private void createMouse() {
@ -131,8 +132,8 @@ public class MouseTest {
}
private void wiggleMouse() {
while (!Display.isCloseRequested()) {
if(Display.isMinimized()) {
while (!BaseGL.isCloseRequested()) {
if(BaseGL.isMinimized()) {
continue;
}

4
src/java/org/lwjgl/test/opengl/Game.java
View File

@ -45,7 +45,7 @@ import org.lwjgl.*;
import org.lwjgl.opengl.*;
import org.lwjgl.input.*;
import java.nio.*;
import java.nio.*;
public final class Game {
static {
@ -188,6 +188,6 @@ public final class Game {
Keyboard.destroy();
Mouse.destroy();
gl.destroy();
Display.destroy();
BaseGL.destroy();
}
}

2
src/java/org/lwjgl/test/opengl/Grass.java
View File

@ -214,7 +214,7 @@ public class Grass {
Mouse.destroy();
Keyboard.destroy();
gl.destroy();
Display.destroy();
BaseGL.destroy();
}
private static float myrand() {