606 lines
18 KiB
Java
606 lines
18 KiB
Java
/*
|
|
* Copyright (c) 2002-2004 LWJGL Project
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* * Neither the name of 'LWJGL' nor the names of
|
|
* its contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
package org.lwjgl.opengl;
|
|
|
|
/**
|
|
* This is the Display implementation interface. Display delegates
|
|
* to implementors of this interface. There is one DisplayImplementation
|
|
* for each supported platform.
|
|
* @author elias_naur
|
|
*/
|
|
|
|
import java.nio.ByteBuffer;
|
|
import java.nio.FloatBuffer;
|
|
import java.nio.IntBuffer;
|
|
|
|
import org.lwjgl.LWJGLException;
|
|
import org.lwjgl.LWJGLUtil;
|
|
import org.lwjgl.input.Cursor;
|
|
|
|
final class WindowsDisplay implements DisplayImplementation {
|
|
private final static int GAMMA_LENGTH = 256;
|
|
private final static int WM_MOUSEMOVE = 0x0200;
|
|
private final static int WM_LBUTTONDOWN = 0x0201;
|
|
private final static int WM_LBUTTONUP = 0x0202;
|
|
private final static int WM_LBUTTONDBLCLK = 0x0203;
|
|
private final static int WM_RBUTTONDOWN = 0x0204;
|
|
private final static int WM_RBUTTONUP = 0x0205;
|
|
private final static int WM_RBUTTONDBLCLK = 0x0206;
|
|
private final static int WM_MBUTTONDOWN = 0x0207;
|
|
private final static int WM_MBUTTONUP = 0x0208;
|
|
private final static int WM_MBUTTONDBLCLK = 0x0209;
|
|
private final static int WM_MOUSEWHEEL = 0x020A;
|
|
|
|
private final static int WM_QUIT = 0x0012;
|
|
private final static int WM_SYSCOMMAND = 0x0112;
|
|
private final static int WM_PAINT = 0x000F;
|
|
|
|
private final static int SC_SIZE = 0xF000;
|
|
private final static int SC_MOVE = 0xF010;
|
|
private final static int SC_MINIMIZE = 0xF020;
|
|
private final static int SC_MAXIMIZE = 0xF030;
|
|
private final static int SC_NEXTWINDOW = 0xF040;
|
|
private final static int SC_PREVWINDOW = 0xF050;
|
|
private final static int SC_CLOSE = 0xF060;
|
|
private final static int SC_VSCROLL = 0xF070;
|
|
private final static int SC_HSCROLL = 0xF080;
|
|
private final static int SC_MOUSEMENU = 0xF090;
|
|
private final static int SC_KEYMENU = 0xF100;
|
|
private final static int SC_ARRANGE = 0xF110;
|
|
private final static int SC_RESTORE = 0xF120;
|
|
private final static int SC_TASKLIST = 0xF130;
|
|
private final static int SC_SCREENSAVE = 0xF140;
|
|
private final static int SC_HOTKEY = 0xF150;
|
|
private final static int SC_DEFAULT = 0xF160;
|
|
private final static int SC_MONITORPOWER = 0xF170;
|
|
private final static int SC_CONTEXTHELP = 0xF180;
|
|
private final static int SC_SEPARATOR = 0xF00F;
|
|
|
|
private final static int SM_CXCURSOR = 13;
|
|
|
|
private final static int SIZE_RESTORED = 0;
|
|
private final static int SIZE_MINIMIZED = 1;
|
|
private final static int SIZE_MAXIMIZED = 2;
|
|
private final static int WM_SIZE = 0x0005;
|
|
private final static int WM_ACTIVATE = 0x0006;
|
|
private final static int WA_INACTIVE = 0;
|
|
private final static int WA_ACTIVE = 1;
|
|
private final static int WA_CLICKACTIVE = 2;
|
|
private final static int SW_SHOWMINNOACTIVE = 7;
|
|
private final static int SW_SHOWDEFAULT = 10;
|
|
private final static int SW_RESTORE = 9;
|
|
|
|
private static WindowsDisplay current_display;
|
|
|
|
private WindowsDisplayPeerInfo peer_info;
|
|
|
|
private WindowsKeyboard keyboard;
|
|
private WindowsMouse mouse;
|
|
|
|
private boolean close_requested;
|
|
private boolean is_dirty;
|
|
|
|
private ByteBuffer current_gamma;
|
|
private ByteBuffer saved_gamma;
|
|
private DisplayMode current_mode;
|
|
|
|
private boolean mode_set;
|
|
private boolean isFullscreen;
|
|
private boolean isMinimized;
|
|
private boolean isFocused;
|
|
private boolean did_maximize;
|
|
private boolean inAppActivate;
|
|
|
|
public WindowsDisplay() {
|
|
current_display = this;
|
|
}
|
|
|
|
public void createWindow(DisplayMode mode, boolean fullscreen, int x, int y) throws LWJGLException {
|
|
close_requested = false;
|
|
is_dirty = false;
|
|
isFullscreen = fullscreen;
|
|
isMinimized = false;
|
|
isFocused = false;
|
|
did_maximize = false;
|
|
nCreateWindow(mode, fullscreen, x, y);
|
|
peer_info.initDC();
|
|
showWindow(getHwnd(), SW_SHOWDEFAULT);
|
|
setForegroundWindow(getHwnd());
|
|
setFocus(getHwnd());
|
|
}
|
|
private native void nCreateWindow(DisplayMode mode, boolean fullscreen, int x, int y) throws LWJGLException;
|
|
|
|
public void destroyWindow() {
|
|
nDestroyWindow();
|
|
if (isFullscreen)
|
|
resetCursorClipping();
|
|
}
|
|
private static native void nDestroyWindow();
|
|
static native void resetCursorClipping();
|
|
static native void setupCursorClipping(long hwnd) throws LWJGLException;
|
|
|
|
public void switchDisplayMode(DisplayMode mode) throws LWJGLException {
|
|
nSwitchDisplayMode(mode);
|
|
current_mode = mode;
|
|
mode_set = true;
|
|
}
|
|
private static native void nSwitchDisplayMode(DisplayMode mode) throws LWJGLException;
|
|
|
|
/*
|
|
* Called when the application is alt-tabbed to or from
|
|
*/
|
|
private void appActivate(boolean active) {
|
|
if (inAppActivate) {
|
|
return;
|
|
}
|
|
inAppActivate = true;
|
|
isFocused = active;
|
|
if (active) {
|
|
if (isFullscreen) {
|
|
restoreDisplayMode();
|
|
}
|
|
showWindow(getHwnd(), SW_RESTORE);
|
|
setForegroundWindow(getHwnd());
|
|
setFocus(getHwnd());
|
|
did_maximize = true;
|
|
} else if (isFullscreen) {
|
|
showWindow(getHwnd(), SW_SHOWMINNOACTIVE);
|
|
resetDisplayMode();
|
|
}
|
|
inAppActivate = false;
|
|
}
|
|
private static native void showWindow(long hwnd, int mode);
|
|
private static native void setForegroundWindow(long hwnd);
|
|
private static native void setFocus(long hwnd);
|
|
|
|
private void restoreDisplayMode() {
|
|
try {
|
|
doSetGammaRamp(current_gamma);
|
|
} catch (LWJGLException e) {
|
|
LWJGLUtil.log("Failed to restore gamma: " + e.getMessage());
|
|
}
|
|
|
|
if (!mode_set) {
|
|
mode_set = true;
|
|
try {
|
|
nSwitchDisplayMode(current_mode);
|
|
} catch (LWJGLException e) {
|
|
LWJGLUtil.log("Failed to restore display mode: " + e.getMessage());
|
|
}
|
|
}
|
|
}
|
|
|
|
public void resetDisplayMode() {
|
|
try {
|
|
doSetGammaRamp(saved_gamma);
|
|
} catch (LWJGLException e) {
|
|
LWJGLUtil.log("Failed to reset gamma ramp: " + e.getMessage());
|
|
}
|
|
current_gamma = saved_gamma;
|
|
if (mode_set) {
|
|
mode_set = false;
|
|
nResetDisplayMode();
|
|
}
|
|
resetCursorClipping();
|
|
}
|
|
private static native void nResetDisplayMode();
|
|
|
|
public int getGammaRampLength() {
|
|
return GAMMA_LENGTH;
|
|
}
|
|
|
|
public void setGammaRamp(FloatBuffer gammaRamp) throws LWJGLException {
|
|
doSetGammaRamp(convertToNativeRamp(gammaRamp));
|
|
}
|
|
private static native ByteBuffer convertToNativeRamp(FloatBuffer gamma_ramp) throws LWJGLException;
|
|
private static native ByteBuffer getCurrentGammaRamp() throws LWJGLException;
|
|
|
|
private void doSetGammaRamp(ByteBuffer native_gamma) throws LWJGLException {
|
|
nSetGammaRamp(native_gamma);
|
|
current_gamma = native_gamma;
|
|
}
|
|
private static native void nSetGammaRamp(ByteBuffer native_ramp) throws LWJGLException;
|
|
|
|
public String getAdapter() {
|
|
try {
|
|
String adapter_string = WindowsRegistry.queryRegistrationKey(
|
|
WindowsRegistry.HKEY_LOCAL_MACHINE,
|
|
"HARDWARE\\DeviceMap\\Video",
|
|
"\\Device\\Video0");
|
|
String root_key = "\\registry\\machine\\";
|
|
if (adapter_string.toLowerCase().startsWith(root_key)) {
|
|
String driver_value = WindowsRegistry.queryRegistrationKey(
|
|
WindowsRegistry.HKEY_LOCAL_MACHINE,
|
|
adapter_string.substring(root_key.length()),
|
|
"InstalledDisplayDrivers");
|
|
return driver_value;
|
|
}
|
|
} catch (LWJGLException e) {
|
|
LWJGLUtil.log("Exception occurred while querying registry: " + e);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public String getVersion() {
|
|
String driver = getAdapter();
|
|
if (driver != null) {
|
|
WindowsFileVersion version = nGetVersion(driver + ".dll");
|
|
if (version != null)
|
|
return version.toString();
|
|
}
|
|
return null;
|
|
}
|
|
private native WindowsFileVersion nGetVersion(String driver);
|
|
|
|
public DisplayMode init() throws LWJGLException {
|
|
current_gamma = saved_gamma = getCurrentGammaRamp();
|
|
return current_mode = getCurrentDisplayMode();
|
|
}
|
|
private static native DisplayMode getCurrentDisplayMode() throws LWJGLException;
|
|
|
|
public native void setTitle(String title);
|
|
|
|
public boolean isCloseRequested() {
|
|
boolean saved = close_requested;
|
|
close_requested = false;
|
|
return saved;
|
|
}
|
|
|
|
public boolean isVisible() {
|
|
return !isMinimized;
|
|
}
|
|
|
|
public boolean isActive() {
|
|
return isFocused;
|
|
}
|
|
|
|
public boolean isDirty() {
|
|
boolean saved = is_dirty;
|
|
is_dirty = false;
|
|
return saved;
|
|
}
|
|
|
|
public PeerInfo createPeerInfo(PixelFormat pixel_format) throws LWJGLException {
|
|
peer_info = new WindowsDisplayPeerInfo(pixel_format);
|
|
return peer_info;
|
|
}
|
|
|
|
public void update() {
|
|
nUpdate();
|
|
if (did_maximize) {
|
|
did_maximize = false;
|
|
/**
|
|
* WORKAROUND:
|
|
* Making the context current (redundantly) when the window
|
|
* is maximized helps some gfx recover from fullscreen
|
|
*/
|
|
try {
|
|
if (Display.getDrawable().getContext() != null && Display.getDrawable().getContext().isCurrent())
|
|
Display.getDrawable().getContext().makeCurrent();
|
|
} catch (LWJGLException e) {
|
|
LWJGLUtil.log("Exception occurred while trying to make context current: " + e);
|
|
}
|
|
}
|
|
}
|
|
private static native void nUpdate();
|
|
|
|
public void reshape(int x, int y, int width, int height) {
|
|
if (!isFullscreen)
|
|
nReshape(getHwnd(), x, y, width, height);
|
|
}
|
|
private static native void nReshape(long hwnd, int x, int y, int width, int height);
|
|
public native DisplayMode[] getAvailableDisplayModes() throws LWJGLException;
|
|
|
|
/* Mouse */
|
|
public boolean hasWheel() {
|
|
return mouse.hasWheel();
|
|
}
|
|
|
|
public int getButtonCount() {
|
|
return mouse.getButtonCount();
|
|
}
|
|
|
|
public void createMouse() throws LWJGLException {
|
|
mouse = new WindowsMouse(createDirectInput(), getHwnd());
|
|
}
|
|
|
|
public void destroyMouse() {
|
|
mouse.destroy();
|
|
mouse = null;
|
|
}
|
|
|
|
public void pollMouse(IntBuffer coord_buffer, ByteBuffer buttons) {
|
|
update();
|
|
mouse.poll(coord_buffer, buttons);
|
|
}
|
|
|
|
public void readMouse(ByteBuffer buffer) {
|
|
update();
|
|
mouse.read(buffer);
|
|
}
|
|
|
|
public void grabMouse(boolean grab) {
|
|
mouse.grab(grab);
|
|
}
|
|
|
|
public int getNativeCursorCapabilities() {
|
|
return Cursor.CURSOR_ONE_BIT_TRANSPARENCY;
|
|
}
|
|
|
|
public void setCursorPosition(int x, int y) {
|
|
nSetCursorPosition(x, y, isFullscreen);
|
|
}
|
|
private static native void nSetCursorPosition(int x, int y, boolean fullscreen);
|
|
|
|
public native void setNativeCursor(Object handle) throws LWJGLException;
|
|
|
|
public int getMinCursorSize() {
|
|
return getSystemMetrics(SM_CXCURSOR);
|
|
}
|
|
|
|
public int getMaxCursorSize() {
|
|
return getSystemMetrics(SM_CXCURSOR);
|
|
}
|
|
|
|
public native int getSystemMetrics(int index);
|
|
|
|
private static native long getDllInstance();
|
|
private static native long getHwnd();
|
|
|
|
/* Keyboard */
|
|
public void createKeyboard() throws LWJGLException {
|
|
keyboard = new WindowsKeyboard(createDirectInput(), getHwnd());
|
|
}
|
|
|
|
public void destroyKeyboard() {
|
|
keyboard.destroy();
|
|
keyboard = null;
|
|
}
|
|
|
|
public void pollKeyboard(ByteBuffer keyDownBuffer) {
|
|
update();
|
|
keyboard.poll(keyDownBuffer);
|
|
}
|
|
|
|
public void readKeyboard(ByteBuffer buffer) {
|
|
update();
|
|
keyboard.read(buffer);
|
|
}
|
|
|
|
// public native int isStateKeySet(int key);
|
|
|
|
public native ByteBuffer nCreateCursor(int width, int height, int xHotspot, int yHotspot, int numImages, IntBuffer images, int images_offset, IntBuffer delays, int delays_offset) throws LWJGLException;
|
|
|
|
public Object createCursor(int width, int height, int xHotspot, int yHotspot, int numImages, IntBuffer images, IntBuffer delays) throws LWJGLException {
|
|
return nCreateCursor(width, height, xHotspot, yHotspot, numImages, images, images.position(), delays, delays != null ? delays.position() : -1);
|
|
}
|
|
|
|
public native void destroyCursor(Object cursorHandle);
|
|
public int getPbufferCapabilities() {
|
|
try {
|
|
// Return the capabilities of a minimum pixel format
|
|
return nGetPbufferCapabilities(new PixelFormat(0, 0, 0, 0, 0, 0, 0, 0, false));
|
|
} catch (LWJGLException e) {
|
|
LWJGLUtil.log("Exception occurred while determining pbuffer capabilities: " + e);
|
|
return 0;
|
|
}
|
|
}
|
|
private native int nGetPbufferCapabilities(PixelFormat format) throws LWJGLException;
|
|
|
|
public boolean isBufferLost(PeerInfo handle) {
|
|
return ((WindowsPbufferPeerInfo)handle).isBufferLost();
|
|
}
|
|
|
|
public PeerInfo createPbuffer(int width, int height, PixelFormat pixel_format,
|
|
IntBuffer pixelFormatCaps,
|
|
IntBuffer pBufferAttribs) throws LWJGLException {
|
|
return new WindowsPbufferPeerInfo(width, height, pixel_format, pixelFormatCaps, pBufferAttribs);
|
|
}
|
|
|
|
public void setPbufferAttrib(PeerInfo handle, int attrib, int value) {
|
|
((WindowsPbufferPeerInfo)handle).setPbufferAttrib(attrib, value);
|
|
}
|
|
|
|
public void bindTexImageToPbuffer(PeerInfo handle, int buffer) {
|
|
((WindowsPbufferPeerInfo)handle).bindTexImageToPbuffer(buffer);
|
|
}
|
|
|
|
public void releaseTexImageFromPbuffer(PeerInfo handle, int buffer) {
|
|
((WindowsPbufferPeerInfo)handle).releaseTexImageFromPbuffer(buffer);
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets one or more icons for the Display.
|
|
* <ul>
|
|
* <li>On Windows you should supply at least one 16x16 icon and one 32x32.</li>
|
|
* <li>Linux (and similar platforms) expect one 32x32 icon.</li>
|
|
* <li>Mac OS X should be supplied one 128x128 icon</li>
|
|
* </ul>
|
|
* The implementation will use the supplied ByteBuffers with image data in RGBA and perform any conversions nescesarry for the specific platform.
|
|
*
|
|
* @param icons Array of icons in RGBA mode
|
|
* @return number of icons used.
|
|
*/
|
|
public int setIcon(ByteBuffer[] icons) {
|
|
boolean done16 = false;
|
|
boolean done32 = false;
|
|
int used = 0;
|
|
|
|
for (int i=0;i<icons.length;i++) {
|
|
int size = icons[i].limit() / 4;
|
|
|
|
if ((((int) Math.sqrt(size)) == 16) && (!done16)) {
|
|
nSetWindowIcon16(icons[i].asIntBuffer());
|
|
used++;
|
|
done16 = true;
|
|
}
|
|
if ((((int) Math.sqrt(size)) == 32) && (!done32)) {
|
|
nSetWindowIcon32(icons[i].asIntBuffer());
|
|
used++;
|
|
done32 = true;
|
|
}
|
|
}
|
|
|
|
return used;
|
|
}
|
|
|
|
private static native int nSetWindowIcon16(IntBuffer icon);
|
|
|
|
private static native int nSetWindowIcon32(IntBuffer icon);
|
|
|
|
private void handleMouseButton(int button, int state, long millis) {
|
|
if (mouse != null)
|
|
mouse.handleMouseButton((byte)button, (byte)state, millis);
|
|
}
|
|
|
|
private void handleMouseMoved(int x, int y, long millis) {
|
|
if (mouse != null)
|
|
mouse.handleMouseMoved(x, y, millis);
|
|
}
|
|
|
|
private void handleMouseScrolled(int amount, long millis) {
|
|
if (mouse != null)
|
|
mouse.handleMouseScrolled(amount, millis);
|
|
}
|
|
|
|
private static native int transformY(long hwnd, int y);
|
|
|
|
private static boolean handleMessage(long hwnd, int msg, long wParam, long lParam, long millis) {
|
|
if (current_display != null)
|
|
return current_display.doHandleMessage(hwnd, msg, wParam, lParam, millis);
|
|
else
|
|
return false;
|
|
}
|
|
|
|
private boolean doHandleMessage(long hwnd, int msg, long wParam, long lParam, long millis) {
|
|
if (isFullscreen && !isMinimized && isFocused) {
|
|
try {
|
|
setupCursorClipping(getHwnd());
|
|
} catch (LWJGLException e) {
|
|
LWJGLUtil.log("setupCursorClipping failed: " + e.getMessage());
|
|
}
|
|
}
|
|
switch (msg) {
|
|
// disable screen saver and monitor power down messages which wreak havoc
|
|
case WM_ACTIVATE:
|
|
switch ((int)wParam) {
|
|
case WA_ACTIVE:
|
|
case WA_CLICKACTIVE:
|
|
appActivate(true);
|
|
break;
|
|
case WA_INACTIVE:
|
|
appActivate(false);
|
|
break;
|
|
}
|
|
return true;
|
|
case WM_SIZE:
|
|
switch ((int)wParam) {
|
|
case SIZE_RESTORED:
|
|
case SIZE_MAXIMIZED:
|
|
isMinimized = false;
|
|
break;
|
|
case SIZE_MINIMIZED:
|
|
isMinimized = true;
|
|
break;
|
|
}
|
|
return false;
|
|
case WM_MOUSEMOVE:
|
|
int xPos = (int)(short)(lParam & 0xFFFF);
|
|
int yPos = transformY(getHwnd(), (int)(short)((lParam >> 16) & 0xFFFF));
|
|
handleMouseMoved(xPos, yPos, millis);
|
|
return true;
|
|
case WM_MOUSEWHEEL:
|
|
int dwheel = (int)(short)((wParam >> 16) & 0xFFFF);
|
|
handleMouseScrolled(dwheel, millis);
|
|
return true;
|
|
case WM_LBUTTONDOWN:
|
|
handleMouseButton(0, 1, millis);
|
|
return true;
|
|
case WM_LBUTTONUP:
|
|
handleMouseButton(0, 0, millis);
|
|
return true;
|
|
case WM_RBUTTONDOWN:
|
|
handleMouseButton(1, 1, millis);
|
|
return true;
|
|
case WM_RBUTTONUP:
|
|
handleMouseButton(1, 0, millis);
|
|
return true;
|
|
case WM_MBUTTONDOWN:
|
|
handleMouseButton(2, 1, millis);
|
|
return true;
|
|
case WM_MBUTTONUP:
|
|
handleMouseButton(2, 0, millis);
|
|
return true;
|
|
case WM_QUIT:
|
|
close_requested = true;
|
|
return true;
|
|
case WM_SYSCOMMAND:
|
|
switch ((int)wParam) {
|
|
case SC_KEYMENU:
|
|
case SC_MOUSEMENU:
|
|
case SC_SCREENSAVE:
|
|
case SC_MONITORPOWER:
|
|
return true;
|
|
case SC_CLOSE:
|
|
close_requested = true;
|
|
return true;
|
|
default:
|
|
break;
|
|
}
|
|
return false;
|
|
case WM_PAINT:
|
|
is_dirty = true;
|
|
return false;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static WindowsDirectInput createDirectInput() throws LWJGLException {
|
|
try {
|
|
return new WindowsDirectInput8(getDllInstance());
|
|
} catch (LWJGLException e) {
|
|
LWJGLUtil.log("Failed to create DirectInput 8 interface, falling back to DirectInput 3");
|
|
return new WindowsDirectInput3(getDllInstance());
|
|
}
|
|
}
|
|
|
|
public int getWidth() {
|
|
return Display.getDisplayMode().getWidth();
|
|
}
|
|
|
|
public int getHeight() {
|
|
return Display.getDisplayMode().getHeight();
|
|
}
|
|
}
|