Those examples are not going anywhere
This commit is contained in:
parent
1e69c2ec92
commit
f872c3b2da
|
@ -0,0 +1,43 @@
|
|||
/*
|
||||
* Created on 18-03-2003
|
||||
*
|
||||
* To change this generated comment go to
|
||||
* Window>Preferences>Java>Code Generation>Code Template
|
||||
*/
|
||||
package org.lwjgl.test;
|
||||
|
||||
import org.lwjgl.*;
|
||||
|
||||
/**
|
||||
* @author Elias Naur
|
||||
*/
|
||||
public class DisplayConfigurationTest {
|
||||
private static void changeConfig(float gamma, float brightness, float contrast) {
|
||||
Display.setDisplayConfiguration(gamma, brightness, contrast);
|
||||
System.out.println("Configuration changed, gamma = " + gamma + " brightness = " + brightness + " contrast = " + contrast);
|
||||
try {
|
||||
Thread.sleep(3000);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
System.out.println("Testing normal setting");
|
||||
changeConfig(1.0f, 0f, 1f);
|
||||
System.out.println("Testing gamma settings");
|
||||
changeConfig(5.0f, 0f, 1f);
|
||||
changeConfig(0.5f, 0f, 1f);
|
||||
System.out.println("Testing brightness settings");
|
||||
changeConfig(1.0f, -1.0f, 1f);
|
||||
changeConfig(1.0f, -0.5f, 1f);
|
||||
changeConfig(1.0f, 0.5f, 1f);
|
||||
changeConfig(1.0f, 1.0f, 1f);
|
||||
System.out.println("Testing contrast settings");
|
||||
changeConfig(1.0f, 0f, 0f);
|
||||
changeConfig(1.0f, 0f, 0.5f);
|
||||
changeConfig(1.0f, 0f, 10000.0f);
|
||||
System.out.println("Test done - Resetting configuration");
|
||||
Display.resetDisplayMode();
|
||||
}
|
||||
}
|
|
@ -0,0 +1,44 @@
|
|||
/*
|
||||
* Created on 18-03-2003
|
||||
*
|
||||
* To change this generated comment go to
|
||||
* Window>Preferences>Java>Code Generation>Code Template
|
||||
*/
|
||||
package org.lwjgl.test;
|
||||
|
||||
import org.lwjgl.*;
|
||||
import org.lwjgl.opengl.Window;
|
||||
|
||||
/**
|
||||
* @author Brian
|
||||
*/
|
||||
public class WindowCreationTest {
|
||||
|
||||
public static void main(String[] args) {
|
||||
DisplayMode[] modes = Display.getAvailableDisplayModes();
|
||||
System.out.println("Found " + modes.length + " display modes");
|
||||
|
||||
|
||||
try {
|
||||
Window.create("WindowCreationTest", 50, 50, 320, 240, 16, 0, 0, 0);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
System.out.println(Window.getHeight() + ", " + Window.getWidth() + ", " + Window.getTitle());
|
||||
|
||||
|
||||
System.out.println("Display created");
|
||||
|
||||
while(!Window.isCloseRequested()) {
|
||||
Window.update();
|
||||
try {
|
||||
Thread.sleep(100);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
Window.destroy();
|
||||
}
|
||||
}
|
|
@ -0,0 +1,225 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Lightweight Java Game Library' 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.test.input;
|
||||
|
||||
import org.lwjgl.Sys;
|
||||
import org.lwjgl.Display;
|
||||
import org.lwjgl.DisplayMode;
|
||||
import org.lwjgl.input.Controller;
|
||||
import org.lwjgl.opengl.GL;
|
||||
import org.lwjgl.opengl.Window;
|
||||
import org.lwjgl.opengl.GLU;
|
||||
import org.lwjgl.vector.Vector2f;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
* <br>
|
||||
* Controller creation test
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class ControllerCreationTest {
|
||||
/** position of quad to draw */
|
||||
private Vector2f position = new Vector2f(320.0f, 240.0f);
|
||||
|
||||
/** Display mode selected */
|
||||
private DisplayMode displayMode;
|
||||
|
||||
/** Creates a new instance of MouseTest */
|
||||
public ControllerCreationTest() {
|
||||
}
|
||||
|
||||
private void initialize(boolean fullscreen) {
|
||||
// find first display mode that allows us 640*480*16
|
||||
DisplayMode[] modes = Display.getAvailableDisplayModes();
|
||||
for (int i = 0; i < modes.length; i++) {
|
||||
if (modes[i].width == 640
|
||||
&& modes[i].height == 480
|
||||
&& modes[i].bpp >= 16) {
|
||||
displayMode = modes[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
if(fullscreen) {
|
||||
Display.setDisplayMode(displayMode);
|
||||
Window.create("ControllerCreationTest", 16, 0, 0, 0);
|
||||
} else {
|
||||
Window.create("ControllerCreationTest", 50, 50, 640, 480, 16, 0, 0, 0);
|
||||
}
|
||||
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
System.exit(-1);
|
||||
}
|
||||
|
||||
initializeOpenGL();
|
||||
}
|
||||
|
||||
private void initializeOpenGL() {
|
||||
GL.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
GLU.gluOrtho2D(0.0, 640, 0, 480);
|
||||
}
|
||||
|
||||
public void executeTest() {
|
||||
initialize(false);
|
||||
|
||||
System.out.println("Test ready:\n");
|
||||
|
||||
// windowed mode
|
||||
System.out.println("=========== WINDOWED MODE ==============");
|
||||
for(int i=0; i<2; i++) {
|
||||
System.out.println("Test " + (i+1) + ":");
|
||||
createController();
|
||||
wiggleController();
|
||||
destroyController();
|
||||
System.out.println("");
|
||||
}
|
||||
|
||||
// recreate display in fullscreen mode
|
||||
System.out.print("Destroying display...");
|
||||
Window.destroy();
|
||||
System.out.println("success");
|
||||
|
||||
System.out.print("Entering fullscreen mode...");
|
||||
try {
|
||||
Window.destroy();
|
||||
initialize(true);
|
||||
Display.setDisplayMode(displayMode);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
System.out.println("success");
|
||||
|
||||
|
||||
// fullscreen mode
|
||||
System.out.println("=========== FULLSCREEN MODE ==============");
|
||||
for(int i=0; i<2; i++) {
|
||||
System.out.println("Test " + (i+3) + ":");
|
||||
createController();
|
||||
wiggleController();
|
||||
destroyController();
|
||||
System.out.println("");
|
||||
}
|
||||
|
||||
System.out.println("Test completed successfully!");
|
||||
System.out.print("Shutting down...");
|
||||
Display.resetDisplayMode();
|
||||
Controller.destroy();
|
||||
Window.destroy();
|
||||
System.out.println("shutdown complete");
|
||||
}
|
||||
|
||||
private void createController() {
|
||||
System.out.print("Creating controller...");
|
||||
try {
|
||||
Controller.create();
|
||||
} catch (Exception e) {
|
||||
System.out.println("failed");
|
||||
System.exit(-1);
|
||||
}
|
||||
System.out.println("success");
|
||||
}
|
||||
|
||||
private void wiggleController() {
|
||||
System.out.print("Please move the controller around");
|
||||
|
||||
long statustime = Sys.getTime();
|
||||
long endtime = Sys.getTime() + Sys.getTimerResolution() * 5;
|
||||
|
||||
while (Sys.getTime() < endtime) {
|
||||
|
||||
Window.update();
|
||||
|
||||
Controller.poll();
|
||||
|
||||
//controller is a bit fuzzy
|
||||
if(Controller.x > 100) {
|
||||
position.x += 1;
|
||||
} else if (Controller.x < -100) {
|
||||
position.x -= 1;
|
||||
}
|
||||
if(Controller.y > 100) {
|
||||
position.y -= 1;
|
||||
} else if (Controller.y < -100) {
|
||||
position.y += 1;
|
||||
}
|
||||
|
||||
render();
|
||||
|
||||
Window.paint();
|
||||
|
||||
if (Sys.getTime() - statustime > Sys.getTimerResolution()) {
|
||||
System.out.print(".");
|
||||
statustime = Sys.getTime();
|
||||
}
|
||||
}
|
||||
System.out.println("thank you");
|
||||
}
|
||||
|
||||
private void destroyController() {
|
||||
System.out.print("Destroying controller...");
|
||||
Controller.destroy();
|
||||
System.out.print("success");
|
||||
}
|
||||
|
||||
private void render() {
|
||||
GL.glClear(GL.GL_COLOR_BUFFER_BIT);
|
||||
|
||||
GL.glPushMatrix();
|
||||
GL.glBegin(GL.GL_POLYGON);
|
||||
{
|
||||
GL.glColor3f(0.0f, 1.0f, 1.0f);
|
||||
GL.glVertex2f(position.x + 0.0f, position.y + 0.0f);
|
||||
|
||||
GL.glColor3f(1.0f, 0.0f, 1.0f);
|
||||
GL.glVertex2f(position.x + 0.0f, position.y + 30.0f);
|
||||
GL.glVertex2f(position.x + 40.0f, position.y + 30.0f);
|
||||
|
||||
GL.glColor3f(1.0f, 1.0f, 0.0f);
|
||||
GL.glVertex2f(position.x + 60.0f, position.y + 15.f);
|
||||
GL.glVertex2f(position.x + 40.0f, position.y + 0.0f);
|
||||
}
|
||||
GL.glEnd();
|
||||
GL.glPopMatrix();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param args the command line arguments
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
ControllerCreationTest cct = new ControllerCreationTest();
|
||||
cct.executeTest();
|
||||
}
|
||||
}
|
|
@ -0,0 +1,201 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Lightweight Java Game Library' 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.test.input;
|
||||
|
||||
import org.lwjgl.DisplayMode;
|
||||
import org.lwjgl.input.Controller;
|
||||
import org.lwjgl.input.Keyboard;
|
||||
import org.lwjgl.opengl.GL;
|
||||
import org.lwjgl.opengl.Window;
|
||||
import org.lwjgl.opengl.GLU;
|
||||
import org.lwjgl.vector.Vector2f;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
* <br>
|
||||
* Controller test
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class ControllerTest {
|
||||
|
||||
/** GLU instance */
|
||||
private GLU glu;
|
||||
|
||||
/** position of quad to draw */
|
||||
private Vector2f position = new Vector2f(320.0f, 240.0f);
|
||||
|
||||
/** Display mode selected */
|
||||
private DisplayMode displayMode;
|
||||
|
||||
/** Creates a new instance of ControllerTest */
|
||||
public ControllerTest() {
|
||||
}
|
||||
|
||||
private void initialize() {
|
||||
// create display and opengl
|
||||
setupDisplay(false);
|
||||
|
||||
try {
|
||||
Keyboard.create();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
System.exit(-1);
|
||||
}
|
||||
}
|
||||
|
||||
private void setupDisplay(boolean fullscreen) {
|
||||
try {
|
||||
Window.create("ControllerTest", 50, 50, 640, 480, 16, 0, 0, 0);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
System.exit(-1);
|
||||
}
|
||||
|
||||
initializeOpenGL();
|
||||
}
|
||||
|
||||
private void initializeOpenGL() {
|
||||
GL.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
GLU.gluOrtho2D(0.0, 640, 0, 480);
|
||||
}
|
||||
|
||||
public void executeTest() {
|
||||
initialize();
|
||||
|
||||
createController();
|
||||
|
||||
wiggleController();
|
||||
|
||||
Controller.destroy();
|
||||
Keyboard.destroy();
|
||||
Window.destroy();
|
||||
}
|
||||
|
||||
private void createController() {
|
||||
try {
|
||||
Controller.create();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
System.exit(-1);
|
||||
}
|
||||
}
|
||||
|
||||
private void wiggleController() {
|
||||
while (!Window.isCloseRequested()) {
|
||||
Window.update();
|
||||
|
||||
if(Window.isMinimized()) {
|
||||
try {
|
||||
Thread.sleep(100);
|
||||
} catch (InterruptedException inte) {
|
||||
inte.printStackTrace();
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
Controller.poll();
|
||||
Keyboard.poll();
|
||||
|
||||
if(Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (Controller.x > 200) {
|
||||
position.x += 1;
|
||||
}
|
||||
|
||||
if (Controller.x < -200) {
|
||||
position.x -= 1;
|
||||
}
|
||||
|
||||
if (Controller.y < -200) {
|
||||
position.y += 1;
|
||||
}
|
||||
|
||||
if (Controller.y > 200) {
|
||||
position.y -= 1;
|
||||
}
|
||||
|
||||
if(position.x<0) {
|
||||
position.x = 0;
|
||||
} else if (position.x>640-60) {
|
||||
position.x = 640-60;
|
||||
}
|
||||
|
||||
if(position.y < 0) {
|
||||
position.y = 0;
|
||||
} else if (position.y>480-30) {
|
||||
position.y = 480-30;
|
||||
}
|
||||
|
||||
|
||||
render();
|
||||
|
||||
Window.paint();
|
||||
}
|
||||
}
|
||||
|
||||
private void render() {
|
||||
GL.glClear(GL.GL_COLOR_BUFFER_BIT);
|
||||
|
||||
GL.glBegin(GL.GL_POLYGON);
|
||||
{
|
||||
float color = 1.0f;
|
||||
int buttonDown = 0;
|
||||
|
||||
for(int i=0;i<Controller.buttonCount; i++) {
|
||||
if(Controller.isButtonDown(i)) {
|
||||
color = (1.0f / Controller.buttonCount) * (i+1);
|
||||
System.out.println("Button " + i + " down");
|
||||
}
|
||||
}
|
||||
GL.glColor3f(color, color, color);
|
||||
|
||||
GL.glVertex2f(position.x + 0.0f, position.y + 0.0f);
|
||||
GL.glVertex2f(position.x + 0.0f, position.y + 30.0f);
|
||||
GL.glVertex2f(position.x + 40.0f, position.y + 30.0f);
|
||||
GL.glVertex2f(position.x + 60.0f, position.y + 15.f);
|
||||
GL.glVertex2f(position.x + 40.0f, position.y + 0.0f);
|
||||
}
|
||||
GL.glEnd();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param args the command line arguments
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
ControllerTest ct = new ControllerTest();
|
||||
ct.executeTest();
|
||||
}
|
||||
}
|
|
@ -0,0 +1,357 @@
|
|||
/*
|
||||
* Copyright (c) 2003 Lightweight Java Game Library 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 'Lightweight Java Game Library' 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.test.input;
|
||||
|
||||
import org.lwjgl.*;
|
||||
import org.lwjgl.input.*;
|
||||
import org.lwjgl.opengl.*;
|
||||
|
||||
import java.nio.*;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
*
|
||||
* Tests switching between windowed and fullscreen - including hardware cursor test
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class HWCursorTest {
|
||||
|
||||
/** Intended deiplay mode */
|
||||
private DisplayMode mode;
|
||||
|
||||
/** GLU instance */
|
||||
private GLU glu;
|
||||
|
||||
/** The native cursor */
|
||||
private static Cursor cursor = null;
|
||||
|
||||
/** The mouse cursor position */
|
||||
private static int mouse_x;
|
||||
private static int mouse_y;
|
||||
|
||||
/**
|
||||
* Executes the test
|
||||
*/
|
||||
public void execute() {
|
||||
initialize();
|
||||
|
||||
mainLoop();
|
||||
|
||||
cleanup();
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes the test
|
||||
*/
|
||||
private void initialize() {
|
||||
try {
|
||||
//find displaymode
|
||||
mode = findDisplayMode(800, 600, 16);
|
||||
|
||||
// start of in windowed mode
|
||||
Window.create("Test", 50, 50, mode.width, mode.height, mode.bpp, 0, 0, 0);
|
||||
|
||||
glInit();
|
||||
|
||||
Keyboard.create();
|
||||
initNativeCursor();
|
||||
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
private static void initNativeCursor() {
|
||||
try {
|
||||
Mouse.create();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
if ((Mouse.getNativeCursorCaps() & Mouse.CURSOR_ONE_BIT_TRANSPARANCY) == 0) {
|
||||
System.out.println("No HW cursor support!");
|
||||
System.exit(0);
|
||||
}
|
||||
System.out.println("Maximum native cursor size: " + Mouse.getMaxCursorSize() + ", min size: " + Mouse.getMinCursorSize());
|
||||
mouse_x = mouse_y = 0;
|
||||
int num_images = 3;
|
||||
int image_size = Mouse.getMaxCursorSize()*Mouse.getMaxCursorSize();
|
||||
IntBuffer cursor_images = ByteBuffer.allocateDirect(num_images*image_size*4).order(ByteOrder.nativeOrder()).asIntBuffer();
|
||||
IntBuffer delays = ByteBuffer.allocateDirect(num_images*4).order(ByteOrder.nativeOrder()).asIntBuffer();
|
||||
delays.put(0, 500);
|
||||
delays.put(1, 500);
|
||||
delays.put(2, 500);
|
||||
int color_scale = 255/Mouse.getMaxCursorSize();
|
||||
int bit_mask = 0x81000000;
|
||||
for (int j = 0; j < image_size; j++) {
|
||||
if (j % 4 == 0)
|
||||
bit_mask = (~bit_mask) & 0x81000000;
|
||||
int color = (j*color_scale/Mouse.getMaxCursorSize()) << 16;
|
||||
cursor_images.put(0*image_size + j, 0x00000020 | color | bit_mask);
|
||||
}
|
||||
for (int j = 0; j < image_size; j++) {
|
||||
if (j % 4 == 0)
|
||||
bit_mask = (~bit_mask) & 0x81000000;
|
||||
int color = (j*color_scale/Mouse.getMaxCursorSize()) << 8;
|
||||
cursor_images.put(1*image_size + j, 0x00000020 | color | bit_mask);
|
||||
}
|
||||
for (int j = 0; j < image_size; j++) {
|
||||
if (j % 4 == 0)
|
||||
bit_mask = (~bit_mask) & 0x81000000;
|
||||
int color = (j*color_scale/Mouse.getMaxCursorSize());
|
||||
cursor_images.put(2*image_size + j, 0x00000020 | color | bit_mask);
|
||||
}
|
||||
try {
|
||||
if ((Mouse.getNativeCursorCaps() | Mouse.CURSOR_ANIMATION) == 0)
|
||||
num_images = 1;
|
||||
cursor = new Cursor(Mouse.getMaxCursorSize(), Mouse.getMaxCursorSize(), Mouse.getMaxCursorSize()/2, Mouse.getMaxCursorSize()/2, num_images, cursor_images, delays);
|
||||
Mouse.setNativeCursor(cursor);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
System.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs the main loop of the "test"
|
||||
*/
|
||||
private void mainLoop() {
|
||||
while (!Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)
|
||||
&& !Window.isCloseRequested()) {
|
||||
// allow subsystem to get a chance to run too
|
||||
Window.update();
|
||||
|
||||
if (!Window.isMinimized()) {
|
||||
// check keyboard input
|
||||
processKeyboard();
|
||||
|
||||
render();
|
||||
|
||||
// paint window
|
||||
Window.paint();
|
||||
} else {
|
||||
|
||||
// no need to render/paint if nothing has changed (ie. window dragged over)
|
||||
if (Window.isDirty()) {
|
||||
render();
|
||||
Window.paint();
|
||||
}
|
||||
|
||||
// don't waste cpu time, sleep more
|
||||
try {
|
||||
Thread.sleep(100);
|
||||
} catch (InterruptedException inte) {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs the logic
|
||||
*/
|
||||
private void render() {
|
||||
//clear background
|
||||
GL.glClear(GL.GL_COLOR_BUFFER_BIT);
|
||||
|
||||
// draw white quad
|
||||
GL.glPushMatrix();
|
||||
{
|
||||
GL.glTranslatef(mouse_x, 600 - mouse_y, 0);
|
||||
GL.glColor3f(1.0f, 1.0f, 1.0f);
|
||||
GL.glBegin(GL.GL_QUADS);
|
||||
{
|
||||
GL.glVertex2i(-50, -50);
|
||||
GL.glVertex2i(50, -50);
|
||||
GL.glVertex2i(50, 50);
|
||||
GL.glVertex2i(-50, 50);
|
||||
}
|
||||
GL.glEnd();
|
||||
}
|
||||
GL.glPopMatrix();
|
||||
}
|
||||
|
||||
/**
|
||||
* Processes keyboard input
|
||||
*/
|
||||
private void processKeyboard() {
|
||||
Keyboard.poll();
|
||||
Mouse.poll();
|
||||
|
||||
if (Mouse.dx != 0 || Mouse.dy != 0) {
|
||||
mouse_x += Mouse.dx;
|
||||
mouse_y += Mouse.dy;
|
||||
System.out.println("mouse_x " + mouse_x + " mouse_y " + mouse_y);
|
||||
}
|
||||
|
||||
//check for fullscreen key
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_F)) {
|
||||
|
||||
try {
|
||||
Keyboard.destroy();
|
||||
try {
|
||||
Mouse.setNativeCursor(null);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
System.exit(1);
|
||||
}
|
||||
cursor.destroy();
|
||||
Mouse.destroy();
|
||||
Window.destroy();
|
||||
|
||||
Display.setDisplayMode(mode);
|
||||
Window.create("Test", mode.bpp, 0, 0, 0);
|
||||
|
||||
glInit();
|
||||
|
||||
Keyboard.create();
|
||||
initNativeCursor();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
//check for window key
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_W)) {
|
||||
try {
|
||||
Keyboard.destroy();
|
||||
try {
|
||||
Mouse.setNativeCursor(null);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
System.exit(1);
|
||||
}
|
||||
cursor.destroy();
|
||||
Mouse.destroy();
|
||||
Window.destroy();
|
||||
|
||||
Display.resetDisplayMode();
|
||||
Window.create("Test", 50, 50, mode.width, mode.height, mode.bpp, 0, 0, 0);
|
||||
|
||||
glInit();
|
||||
|
||||
Keyboard.create();
|
||||
initNativeCursor();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_M)) {
|
||||
try {
|
||||
Mouse.setNativeCursor(null);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_N)) {
|
||||
try {
|
||||
Mouse.setNativeCursor(cursor);
|
||||
mouse_x = mouse_y = 0;
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleans up the test
|
||||
*/
|
||||
private void cleanup() {
|
||||
Keyboard.destroy();
|
||||
try {
|
||||
Mouse.setNativeCursor(null);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
System.exit(1);
|
||||
}
|
||||
cursor.destroy();
|
||||
Mouse.destroy();
|
||||
Display.resetDisplayMode();
|
||||
Window.destroy();
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves a displaymode, if one such is available
|
||||
*
|
||||
* @param width Required width
|
||||
* @param height Required height
|
||||
* @param bpp Minimum required bits per pixel
|
||||
* @return
|
||||
*/
|
||||
private DisplayMode findDisplayMode(int width, int height, int bpp) {
|
||||
DisplayMode[] modes = Display.getAvailableDisplayModes();
|
||||
for (int i = 0; i < modes.length; i++) {
|
||||
if (modes[i].width == width
|
||||
&& modes[i].height == height
|
||||
&& modes[i].bpp >= bpp) {
|
||||
return modes[i];
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes OGL
|
||||
*/
|
||||
private void glInit() {
|
||||
// Go into orthographic projection mode.
|
||||
GL.glMatrixMode(GL.GL_PROJECTION);
|
||||
GL.glLoadIdentity();
|
||||
GLU.gluOrtho2D(0, mode.width, 0, mode.height);
|
||||
GL.glMatrixMode(GL.GL_MODELVIEW);
|
||||
GL.glLoadIdentity();
|
||||
GL.glViewport(0, 0, mode.width, mode.height);
|
||||
|
||||
//set clear color to black
|
||||
GL.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
|
||||
//sync frame (only works on windows)
|
||||
GLCaps.determineAvailableExtensions();
|
||||
if (GLCaps.WGL_EXT_swap_control) {
|
||||
GL.wglSwapIntervalEXT(1);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test entry point
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
System.out.println(
|
||||
"Change between fullscreen and windowed mode, by pressing F and W respectively. Enable hw cursor with N and disable it with M.");
|
||||
System.out.println(
|
||||
"Move quad using arrowkeys, and change rotation using +/-");
|
||||
HWCursorTest cursorTest = new HWCursorTest();
|
||||
cursorTest.execute();
|
||||
}
|
||||
}
|
|
@ -0,0 +1,217 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Lightweight Java Game Library' 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.test.input;
|
||||
|
||||
import org.lwjgl.DisplayMode;
|
||||
import org.lwjgl.input.Keyboard;
|
||||
import org.lwjgl.opengl.GL;
|
||||
import org.lwjgl.opengl.Window;
|
||||
import org.lwjgl.opengl.GLU;
|
||||
import org.lwjgl.vector.Vector2f;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
* <br>
|
||||
* Keyboard test
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class KeyboardTest {
|
||||
|
||||
/** GLU instance */
|
||||
private GLU glu;
|
||||
|
||||
/** position of quad to draw */
|
||||
private Vector2f position = new Vector2f(320.0f, 240.0f);
|
||||
|
||||
/** Display mode selected */
|
||||
private DisplayMode displayMode;
|
||||
|
||||
private boolean bufferedKeyboard;
|
||||
private boolean translatedKeyboard;
|
||||
private int bufferSize;
|
||||
|
||||
/** Creates a new instance of MouseTest */
|
||||
public KeyboardTest() {
|
||||
}
|
||||
|
||||
private void initialize() {
|
||||
// create display and opengl
|
||||
setupDisplay(false);
|
||||
|
||||
try {
|
||||
Keyboard.create();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
System.exit(-1);
|
||||
}
|
||||
}
|
||||
|
||||
private void setupDisplay(boolean fullscreen) {
|
||||
try {
|
||||
Window.create("KeyboardTest", 50, 50, 640, 480, 16, 0, 0, 0);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
System.exit(-1);
|
||||
}
|
||||
|
||||
initializeOpenGL();
|
||||
}
|
||||
|
||||
private void initializeOpenGL() {
|
||||
GL.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
GLU.gluOrtho2D(0.0, 640, 0, 480);
|
||||
}
|
||||
|
||||
public void executeTest() {
|
||||
initialize();
|
||||
|
||||
createKeyboard();
|
||||
|
||||
wiggleKeyboard();
|
||||
|
||||
Keyboard.destroy();
|
||||
Window.destroy();
|
||||
}
|
||||
|
||||
private void createKeyboard() {
|
||||
try {
|
||||
Keyboard.create();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
System.exit(-1);
|
||||
}
|
||||
}
|
||||
|
||||
private void wiggleKeyboard() {
|
||||
Keyboard.enableBuffer();
|
||||
Keyboard.enableTranslation();
|
||||
|
||||
while (!Window.isCloseRequested()) {
|
||||
Window.update();
|
||||
|
||||
if(Window.isMinimized()) {
|
||||
try {
|
||||
Thread.sleep(100);
|
||||
} catch (InterruptedException inte) {
|
||||
inte.printStackTrace();
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
//check keys, buffered
|
||||
Keyboard.read();
|
||||
|
||||
int count = Keyboard.getNumKeyboardEvents();
|
||||
System.out.println("Read " + count + " events");
|
||||
while(Keyboard.next()) {
|
||||
System.out.println("Checking key:" + Keyboard.getKeyName(Keyboard.key));
|
||||
if(Keyboard.key == Keyboard.KEY_ESCAPE) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_RIGHT)) {
|
||||
position.x += 1;
|
||||
}
|
||||
|
||||
if (Keyboard.key == Keyboard.KEY_RIGHT) {
|
||||
position.x += 1;
|
||||
}
|
||||
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_LEFT)) {
|
||||
position.x -= 1;
|
||||
}
|
||||
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_UP)) {
|
||||
position.y += 1;
|
||||
}
|
||||
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_DOWN)) {
|
||||
position.y -= 1;
|
||||
}
|
||||
|
||||
}
|
||||
if (count > 0) {
|
||||
System.out.println();
|
||||
}
|
||||
|
||||
if(position.x<0) {
|
||||
position.x = 0;
|
||||
} else if (position.x>640-60) {
|
||||
position.x = 640-60;
|
||||
}
|
||||
|
||||
if(position.y < 0) {
|
||||
position.y = 0;
|
||||
} else if (position.y>480-30) {
|
||||
position.y = 480-30;
|
||||
}
|
||||
|
||||
|
||||
render();
|
||||
|
||||
Window.paint();
|
||||
|
||||
try {
|
||||
Thread.sleep(0);
|
||||
} catch (Exception e) {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void render() {
|
||||
GL.glClear(GL.GL_COLOR_BUFFER_BIT);
|
||||
|
||||
GL.glBegin(GL.GL_POLYGON);
|
||||
{
|
||||
float color = 1.0f;
|
||||
int buttonDown = 0;
|
||||
GL.glColor3f(color, color, color);
|
||||
|
||||
GL.glVertex2f(position.x + 0.0f, position.y + 0.0f);
|
||||
GL.glVertex2f(position.x + 0.0f, position.y + 30.0f);
|
||||
GL.glVertex2f(position.x + 40.0f, position.y + 30.0f);
|
||||
GL.glVertex2f(position.x + 60.0f, position.y + 15.f);
|
||||
GL.glVertex2f(position.x + 40.0f, position.y + 0.0f);
|
||||
}
|
||||
GL.glEnd();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param args the command line arguments
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
KeyboardTest kt = new KeyboardTest();
|
||||
kt.executeTest();
|
||||
}
|
||||
}
|
|
@ -0,0 +1,234 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Lightweight Java Game Library' 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.test.input;
|
||||
|
||||
import org.lwjgl.Sys;
|
||||
import org.lwjgl.Display;
|
||||
import org.lwjgl.DisplayMode;
|
||||
import org.lwjgl.input.Mouse;
|
||||
import org.lwjgl.opengl.GL;
|
||||
import org.lwjgl.opengl.Window;
|
||||
import org.lwjgl.opengl.GLU;
|
||||
import org.lwjgl.vector.Vector2f;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
* <br>
|
||||
* Mouse test
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class MouseCreationTest {
|
||||
/** GLU instance */
|
||||
private GLU glu;
|
||||
|
||||
/** position of quad to draw */
|
||||
private Vector2f position = new Vector2f(320.0f, 240.0f);
|
||||
|
||||
/** Display mode selected */
|
||||
private DisplayMode displayMode;
|
||||
|
||||
/** Creates a new instance of MouseTest */
|
||||
public MouseCreationTest() {
|
||||
}
|
||||
|
||||
private void initialize(boolean fullscreen) {
|
||||
// find first display mode that allows us 640*480*16
|
||||
DisplayMode[] modes = Display.getAvailableDisplayModes();
|
||||
for (int i = 0; i < modes.length; i++) {
|
||||
if (modes[i].width == 640
|
||||
&& modes[i].height == 480
|
||||
&& modes[i].bpp >= 16) {
|
||||
displayMode = modes[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
if(fullscreen) {
|
||||
Display.setDisplayMode(displayMode);
|
||||
Window.create("MouseCreationTest", 16, 0, 0, 0);
|
||||
} else {
|
||||
Window.create("MouseCreationTest", 50, 50, 640, 480, 16, 0, 0, 0);
|
||||
}
|
||||
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
System.exit(-1);
|
||||
}
|
||||
|
||||
initializeOpenGL();
|
||||
}
|
||||
|
||||
private void initializeOpenGL() {
|
||||
GL.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
GLU.gluOrtho2D(0.0, 640, 0, 480);
|
||||
}
|
||||
|
||||
public void executeTest() {
|
||||
initialize(false);
|
||||
|
||||
System.out.println("Test ready:\n");
|
||||
|
||||
// windowed mode
|
||||
System.out.println("=========== WINDOWED MODE ==============");
|
||||
for(int i=0; i<2; i++) {
|
||||
System.out.println("Test " + (i+1) + ":");
|
||||
createMouse();
|
||||
wiggleMouse();
|
||||
destroyMouse();
|
||||
System.out.println("");
|
||||
}
|
||||
|
||||
// recreate display in fullscreen mode
|
||||
System.out.print("Destroying display...");
|
||||
|
||||
System.out.println("success");
|
||||
|
||||
System.out.print("Entering fullscreen mode...");
|
||||
try {
|
||||
Window.destroy();
|
||||
initialize(true);
|
||||
Display.setDisplayMode(displayMode);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
System.out.println("success");
|
||||
|
||||
|
||||
// fullscreen mode
|
||||
System.out.println("=========== FULLSCREEN MODE ==============");
|
||||
for(int i=0; i<2; i++) {
|
||||
System.out.println("Test " + (i+3) + ":");
|
||||
createMouse();
|
||||
wiggleMouse();
|
||||
destroyMouse();
|
||||
System.out.println("");
|
||||
}
|
||||
|
||||
System.out.println("Test completed successfully!");
|
||||
System.out.print("Shutting down...");
|
||||
Display.resetDisplayMode();
|
||||
Mouse.destroy();
|
||||
Window.destroy();
|
||||
System.out.println("shutdown complete");
|
||||
}
|
||||
|
||||
private void createMouse() {
|
||||
System.out.print("Creating mouse...");
|
||||
try {
|
||||
Mouse.create();
|
||||
} catch (Exception e) {
|
||||
System.out.println("failed");
|
||||
System.exit(-1);
|
||||
}
|
||||
System.out.println("success");
|
||||
}
|
||||
|
||||
private void wiggleMouse() {
|
||||
System.out.print("Please move the mouse around");
|
||||
|
||||
long statustime = Sys.getTime();
|
||||
long endtime = Sys.getTime() + Sys.getTimerResolution() * 5;
|
||||
|
||||
while (Sys.getTime() < endtime) {
|
||||
Window.update();
|
||||
|
||||
Mouse.poll();
|
||||
|
||||
position.x += Mouse.dx;
|
||||
position.y -= Mouse.dy;
|
||||
|
||||
if(position.x<0) {
|
||||
position.x = 0;
|
||||
} else if (position.x>640-60) {
|
||||
position.x = 640-60;
|
||||
}
|
||||
|
||||
if(position.y < 0) {
|
||||
position.y = 0;
|
||||
} else if (position.y>480-30) {
|
||||
position.y = 480-30;
|
||||
}
|
||||
|
||||
render();
|
||||
|
||||
Window.paint();
|
||||
|
||||
if (Sys.getTime() - statustime > Sys.getTimerResolution()) {
|
||||
System.out.print(".");
|
||||
statustime = Sys.getTime();
|
||||
}
|
||||
}
|
||||
System.out.println("thank you");
|
||||
}
|
||||
|
||||
private void destroyMouse() {
|
||||
System.out.print("Destroying mouse...");
|
||||
Mouse.destroy();
|
||||
System.out.print("success");
|
||||
}
|
||||
|
||||
private void render() {
|
||||
GL.glClear(GL.GL_COLOR_BUFFER_BIT);
|
||||
|
||||
GL.glBegin(GL.GL_POLYGON);
|
||||
{
|
||||
float color = 1.0f;
|
||||
int buttonDown = 0;
|
||||
|
||||
for(int i=0;i<Mouse.buttonCount; i++) {
|
||||
if(Mouse.isButtonDown(i)) {
|
||||
color = (1.0f / Mouse.buttonCount) * (i+1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
GL.glColor3f(color, color, color);
|
||||
|
||||
GL.glVertex2f(position.x + 0.0f, position.y + 0.0f);
|
||||
GL.glVertex2f(position.x + 0.0f, position.y + 30.0f);
|
||||
GL.glVertex2f(position.x + 40.0f, position.y + 30.0f);
|
||||
GL.glVertex2f(position.x + 60.0f, position.y + 15.f);
|
||||
GL.glVertex2f(position.x + 40.0f, position.y + 0.0f);
|
||||
}
|
||||
GL.glEnd();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param args the command line arguments
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
MouseCreationTest mt = new MouseCreationTest();
|
||||
mt.executeTest();
|
||||
}
|
||||
}
|
|
@ -0,0 +1,188 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Lightweight Java Game Library' 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.test.input;
|
||||
|
||||
import org.lwjgl.DisplayMode;
|
||||
import org.lwjgl.input.Mouse;
|
||||
import org.lwjgl.input.Keyboard;
|
||||
import org.lwjgl.opengl.GL;
|
||||
import org.lwjgl.opengl.Window;
|
||||
import org.lwjgl.opengl.GLU;
|
||||
import org.lwjgl.vector.Vector2f;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
* <br>
|
||||
* Mouse test
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class MouseTest {
|
||||
|
||||
/** GLU instance */
|
||||
private GLU glu;
|
||||
|
||||
/** position of quad to draw */
|
||||
private Vector2f position = new Vector2f(320.0f, 240.0f);
|
||||
|
||||
/** Display mode selected */
|
||||
private DisplayMode displayMode;
|
||||
|
||||
/** Creates a new instance of MouseTest */
|
||||
public MouseTest() {
|
||||
}
|
||||
|
||||
private void initialize() {
|
||||
// create display and opengl
|
||||
setupDisplay(false);
|
||||
|
||||
try {
|
||||
Keyboard.create();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
System.exit(-1);
|
||||
}
|
||||
}
|
||||
|
||||
private void setupDisplay(boolean fullscreen) {
|
||||
try {
|
||||
Window.create("MouseTest", 50, 50, 640, 480, 16, 0, 0, 0);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
System.exit(-1);
|
||||
}
|
||||
|
||||
initializeOpenGL();
|
||||
}
|
||||
|
||||
private void initializeOpenGL() {
|
||||
GL.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
GLU.gluOrtho2D(0.0, 640, 0, 480);
|
||||
}
|
||||
|
||||
public void executeTest() {
|
||||
initialize();
|
||||
|
||||
createMouse();
|
||||
|
||||
wiggleMouse();
|
||||
|
||||
Mouse.destroy();
|
||||
Keyboard.destroy();
|
||||
Window.destroy();
|
||||
}
|
||||
|
||||
private void createMouse() {
|
||||
try {
|
||||
Mouse.create();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
System.exit(-1);
|
||||
}
|
||||
}
|
||||
|
||||
private void wiggleMouse() {
|
||||
while (!Window.isCloseRequested()) {
|
||||
Window.update();
|
||||
|
||||
if(Window.isMinimized()) {
|
||||
try {
|
||||
Thread.sleep(100);
|
||||
} catch (InterruptedException inte) {
|
||||
inte.printStackTrace();
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
Mouse.poll();
|
||||
Keyboard.poll();
|
||||
|
||||
if(Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)) {
|
||||
return;
|
||||
}
|
||||
|
||||
position.x += Mouse.dx;
|
||||
position.y -= Mouse.dy;
|
||||
|
||||
if(position.x<0) {
|
||||
position.x = 0;
|
||||
} else if (position.x>640-60) {
|
||||
position.x = 640-60;
|
||||
}
|
||||
|
||||
if(position.y < 0) {
|
||||
position.y = 0;
|
||||
} else if (position.y>480-30) {
|
||||
position.y = 480-30;
|
||||
}
|
||||
|
||||
|
||||
render();
|
||||
|
||||
Window.paint();
|
||||
}
|
||||
}
|
||||
|
||||
private void render() {
|
||||
GL.glClear(GL.GL_COLOR_BUFFER_BIT);
|
||||
|
||||
GL.glBegin(GL.GL_POLYGON);
|
||||
{
|
||||
float color = 1.0f;
|
||||
int buttonDown = 0;
|
||||
|
||||
for(int i=0;i<Mouse.buttonCount; i++) {
|
||||
if(Mouse.isButtonDown(i)) {
|
||||
color = (1.0f / Mouse.buttonCount) * (i+1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
GL.glColor3f(color, color, color);
|
||||
|
||||
GL.glVertex2f(position.x + 0.0f, position.y + 0.0f);
|
||||
GL.glVertex2f(position.x + 0.0f, position.y + 30.0f);
|
||||
GL.glVertex2f(position.x + 40.0f, position.y + 30.0f);
|
||||
GL.glVertex2f(position.x + 60.0f, position.y + 15.f);
|
||||
GL.glVertex2f(position.x + 40.0f, position.y + 0.0f);
|
||||
}
|
||||
GL.glEnd();
|
||||
}
|
||||
|
||||
/**
|
||||
* @param args the command line arguments
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
MouseTest mt = new MouseTest();
|
||||
mt.executeTest();
|
||||
}
|
||||
}
|
|
@ -0,0 +1,107 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Light Weight Java Game Library' 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.test.openal;
|
||||
|
||||
import org.lwjgl.openal.ALC;
|
||||
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
*
|
||||
* This is a test for the ALC part of OpenAL
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class ALCTest extends BasicTest {
|
||||
|
||||
/**
|
||||
* Creates an instance of ALCTest
|
||||
*/
|
||||
public ALCTest() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs the actual test, using supplied arguments
|
||||
*/
|
||||
protected void execute(String[] args) {
|
||||
//error stuff
|
||||
int lastError = ALC.ALC_NO_ERROR;
|
||||
|
||||
//create attribute list for context creation
|
||||
IntBuffer buffer = createIntBuffer(7);
|
||||
|
||||
if ((lastError = ALC.alcGetError()) != ALC.ALC_NO_ERROR) {
|
||||
System.out.println("ALC Error: " + ALC.alcGetString(lastError));
|
||||
System.exit(-1);
|
||||
}
|
||||
|
||||
//query
|
||||
System.out.println(
|
||||
"DEFAULT_DEVICE_SPECIFIER: "
|
||||
+ ALC.alcGetString(ALC.ALC_DEFAULT_DEVICE_SPECIFIER));
|
||||
System.out.println(
|
||||
"DEVICE_SPECIFIER: " + ALC.alcGetString(ALC.ALC_DEVICE_SPECIFIER));
|
||||
System.out.println("EXTENSIONS: " + ALC.alcGetString(ALC.ALC_EXTENSIONS));
|
||||
|
||||
//mo query
|
||||
buffer.rewind();
|
||||
buffer.limit(1);
|
||||
ALC.alcGetInteger(ALC.ALC_MAJOR_VERSION, buffer);
|
||||
ALC.alcGetInteger(ALC.ALC_MINOR_VERSION, (IntBuffer) buffer.position(1).limit(2));
|
||||
|
||||
System.out.println("ALC_MAJOR_VERSION: " + buffer.get(0));
|
||||
System.out.println("ALC_MINOR_VERSION: " + buffer.get(1));
|
||||
|
||||
//no check for ALC_ALL_ATTRIBUTES / ALC_ATTRIBUTES_SIZE since it
|
||||
//is buggy on win32 - my dev platform
|
||||
|
||||
//get an enumerstion value
|
||||
System.out.println(
|
||||
"Value of ALC_MAJOR_VERSION: "
|
||||
+ ALC.alcGetEnumValue("ALC_MAJOR_VERSION"));
|
||||
|
||||
alExit();
|
||||
}
|
||||
|
||||
/**
|
||||
* main entry point
|
||||
*
|
||||
* @param args String array containing arguments
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
ALCTest alcTest = new ALCTest();
|
||||
alcTest.execute(args);
|
||||
}
|
||||
}
|
|
@ -0,0 +1,108 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Light Weight Java Game Library' 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.test.openal;
|
||||
|
||||
import org.lwjgl.openal.AL;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.ByteOrder;
|
||||
import java.nio.IntBuffer;
|
||||
import java.nio.FloatBuffer;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
*
|
||||
* This is a basic test, which contains the most used stuff
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public abstract class BasicTest {
|
||||
|
||||
/**
|
||||
* Creates an instance of PlayTest
|
||||
*/
|
||||
public BasicTest() {
|
||||
try {
|
||||
AL.create();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Shutdowns OpenAL
|
||||
*/
|
||||
protected void alExit() {
|
||||
AL.destroy();
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an integer buffer to hold specified ints
|
||||
* - strictly a utility method
|
||||
*
|
||||
* @param size how many int to contain
|
||||
* @return created IntBuffer
|
||||
*/
|
||||
protected IntBuffer createIntBuffer(int size) {
|
||||
ByteBuffer temp = ByteBuffer.allocateDirect(4 * size);
|
||||
temp.order(ByteOrder.nativeOrder());
|
||||
|
||||
return temp.asIntBuffer();
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a float buffer to hold specified floats
|
||||
* - strictly a utility method
|
||||
*
|
||||
* @param size how many floats to contain
|
||||
* @return created FloatBuffer
|
||||
*/
|
||||
protected FloatBuffer createFloatBuffer(int size) {
|
||||
ByteBuffer temp = ByteBuffer.allocateDirect(4 * size);
|
||||
temp.order(ByteOrder.nativeOrder());
|
||||
|
||||
return temp.asFloatBuffer();
|
||||
}
|
||||
|
||||
/**
|
||||
* Exits the test NOW, printing errorcode to stdout
|
||||
*
|
||||
* @param error Error code causing exit
|
||||
*/
|
||||
protected void exit(int error) {
|
||||
System.out.println("OpenAL Error: " + AL.alGetString(error));
|
||||
alExit();
|
||||
System.exit(-1);
|
||||
}
|
||||
}
|
|
@ -0,0 +1,80 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Light Weight Java Game Library' 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.test.openal;
|
||||
|
||||
import org.lwjgl.openal.eax.EAX;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
*
|
||||
* This test initializes EAX and tries to get and set some EAX values
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class EAXTest extends BasicTest {
|
||||
|
||||
/**
|
||||
* Creates an instance of EAXTest
|
||||
*/
|
||||
public EAXTest() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs the actual test, using supplied arguments
|
||||
*/
|
||||
protected void execute(String[] args) {
|
||||
try {
|
||||
System.out.print("Testing EAX support...");
|
||||
EAX.create();
|
||||
System.out.println("supported!");
|
||||
} catch (Exception e) {
|
||||
System.out.println("no supported!");
|
||||
}
|
||||
|
||||
//shutdown
|
||||
alExit();
|
||||
|
||||
System.out.println("test done.");
|
||||
}
|
||||
|
||||
/**
|
||||
* main entry point
|
||||
*
|
||||
* @param args String array containing arguments
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
EAXTest eaxTest = new EAXTest();
|
||||
eaxTest.execute(args);
|
||||
}
|
||||
}
|
|
@ -0,0 +1,238 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Light Weight Java Game Library' 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.test.openal;
|
||||
|
||||
import org.lwjgl.openal.AL;
|
||||
import org.lwjgl.openal.eax.*;
|
||||
import org.lwjgl.input.Keyboard;
|
||||
import org.lwjgl.opengl.Window;
|
||||
import org.lwjgl.vector.Vector3f;
|
||||
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
*
|
||||
* This test simulates a listener positioned in the center, and
|
||||
* a source moving around the listener using the keyboard
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class MovingSoundTest extends BasicTest {
|
||||
|
||||
public static float MOVEMENT = 50.00f;
|
||||
|
||||
/**
|
||||
* Creates an instance of MovingSoundTest
|
||||
*/
|
||||
public MovingSoundTest() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs the actual test, using supplied arguments
|
||||
*/
|
||||
protected void execute(String[] args) {
|
||||
if (args.length < 1) {
|
||||
System.out.println("no argument supplied, assuming Footsteps.wav");
|
||||
args = new String[] {"Footsteps.wav"};
|
||||
}
|
||||
|
||||
try {
|
||||
Window.create("Moving Sound Test", 100, 100, 320, 240, 32, 0 ,0 ,0);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
|
||||
int lastError;
|
||||
Vector3f sourcePosition = new Vector3f();
|
||||
Vector3f listenerPosition = new Vector3f();
|
||||
boolean eaxApplied = false;
|
||||
EAXListenerProperties eaxListenerProp = null;
|
||||
|
||||
//initialize keyboard
|
||||
try {
|
||||
Keyboard.create();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
//create 1 buffer and 1 source
|
||||
IntBuffer buffers = createIntBuffer(1);
|
||||
IntBuffer sources = createIntBuffer(1);
|
||||
|
||||
// al generate buffers and sources
|
||||
buffers.position(0).limit(1);
|
||||
AL.alGenBuffers(buffers);
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
sources.position(0).limit(1);
|
||||
AL.alGenSources(sources);
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//load wave data
|
||||
WaveData wavefile = WaveData.create(args[0]);
|
||||
|
||||
//copy to buffers
|
||||
AL.alBufferData(
|
||||
buffers.get(0),
|
||||
wavefile.format,
|
||||
wavefile.data,
|
||||
wavefile.data.capacity(),
|
||||
wavefile.samplerate);
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//unload file again
|
||||
wavefile.dispose();
|
||||
|
||||
//set up source input
|
||||
AL.alSourcei(sources.get(0), AL.AL_BUFFER, buffers.get(0));
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
AL.alSourcef(sources.get(0), AL.AL_REFERENCE_DISTANCE, 1024.0f);
|
||||
AL.alSourcef(sources.get(0), AL.AL_ROLLOFF_FACTOR, 0.5f);
|
||||
|
||||
//lets loop the sound
|
||||
AL.alSourcei(sources.get(0), AL.AL_LOOPING, AL.AL_TRUE);
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//play source 0
|
||||
AL.alSourcePlay(sources.get(0));
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//setup EAX if possible
|
||||
if (AL.alIsExtensionPresent("EAX")) {
|
||||
try {
|
||||
EAX.create();
|
||||
eaxListenerProp = new EAXListenerProperties();
|
||||
} catch (Exception e) {
|
||||
}
|
||||
}
|
||||
|
||||
System.out.println("Move source with arrow keys\nMove listener with right shift and arrowkeys\nEnable EAX effect by pressing e (if available)\nExit with ESC");
|
||||
|
||||
while(!Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)) {
|
||||
Window.update();
|
||||
|
||||
Keyboard.poll();
|
||||
if(Keyboard.isKeyDown(Keyboard.KEY_LEFT)) {
|
||||
if(Keyboard.isKeyDown(Keyboard.KEY_RSHIFT)) {
|
||||
listenerPosition.x -= MOVEMENT;
|
||||
AL.alListener3f(AL.AL_POSITION, listenerPosition.x, listenerPosition.y, listenerPosition.z);
|
||||
System.out.println("listenerx: " + listenerPosition.x);
|
||||
} else {
|
||||
sourcePosition.x -= MOVEMENT;
|
||||
AL.alSource3f(sources.get(0), AL.AL_POSITION, sourcePosition.x, sourcePosition.y, sourcePosition.z);
|
||||
System.out.println("sourcex: " + sourcePosition.x);
|
||||
}
|
||||
}
|
||||
if(Keyboard.isKeyDown(Keyboard.KEY_RIGHT)) {
|
||||
if(Keyboard.isKeyDown(Keyboard.KEY_RSHIFT)) {
|
||||
listenerPosition.x += MOVEMENT;
|
||||
AL.alListener3f(AL.AL_POSITION, listenerPosition.x, listenerPosition.y, listenerPosition.z);
|
||||
System.out.println("listenerx: " + listenerPosition.x);
|
||||
} else {
|
||||
sourcePosition.x += MOVEMENT;
|
||||
AL.alSource3f(sources.get(0), AL.AL_POSITION, sourcePosition.x, sourcePosition.y, sourcePosition.z);
|
||||
System.out.println("sourcex: " + sourcePosition.x);
|
||||
}
|
||||
}
|
||||
|
||||
if(Keyboard.isKeyDown(Keyboard.KEY_E)) {
|
||||
if(eaxApplied) {
|
||||
eaxListenerProp.setEnvironment(EAX.EAX_ENVIRONMENT_GENERIC);
|
||||
eaxListenerProp.eaxSet(EAXListenerProperties.EAXLISTENER_ENVIRONMENT, 0);
|
||||
} else {
|
||||
eaxListenerProp.setEnvironment(EAX.EAX_ENVIRONMENT_HANGAR);
|
||||
eaxListenerProp.eaxSet(EAXListenerProperties.EAXLISTENER_ENVIRONMENT, 0);
|
||||
}
|
||||
eaxApplied = !eaxApplied;
|
||||
}
|
||||
|
||||
if(Window.isCloseRequested()) {
|
||||
break;
|
||||
}
|
||||
|
||||
try {
|
||||
Thread.sleep(100);
|
||||
} catch (InterruptedException inte) {
|
||||
}
|
||||
}
|
||||
|
||||
//stop source 0
|
||||
AL.alSourceStop(sources.get(0));
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//delete buffers and sources
|
||||
sources.position(0).limit(1);
|
||||
AL.alDeleteSources(sources);
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
buffers.position(0).limit(1);
|
||||
AL.alDeleteBuffers(buffers);
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//shutdown
|
||||
alExit();
|
||||
}
|
||||
|
||||
/**
|
||||
* main entry point
|
||||
*
|
||||
* @param args String array containing arguments
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
MovingSoundTest movingSoundTest = new MovingSoundTest();
|
||||
movingSoundTest.execute(args);
|
||||
}
|
||||
}
|
|
@ -0,0 +1,223 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Lightweight Java Game Library' 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.test.openal;
|
||||
|
||||
import org.lwjgl.openal.AL;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.ByteOrder;
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
* <br>
|
||||
* Performs a creation test, by creating and destroying OpenAL twice.
|
||||
* We cannot inherit from BasicTest since it follows another structure.
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class OpenALCreationTest {
|
||||
|
||||
/**
|
||||
* Creates an instance of OpenALCreationTest
|
||||
*/
|
||||
public OpenALCreationTest() {
|
||||
}
|
||||
|
||||
public void alInitialize() {
|
||||
try {
|
||||
AL.create();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
public void alExit() {
|
||||
AL.destroy();
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an integer buffer to hold specified ints
|
||||
* - strictly a utility method
|
||||
*
|
||||
* @param size how many int to contain
|
||||
* @return created IntBuffer
|
||||
*/
|
||||
protected IntBuffer createIntBuffer(int size) {
|
||||
ByteBuffer temp = ByteBuffer.allocateDirect(4 * size);
|
||||
temp.order(ByteOrder.nativeOrder());
|
||||
|
||||
return temp.asIntBuffer();
|
||||
}
|
||||
|
||||
/**
|
||||
* Exits the test NOW, printing errorcode to stdout
|
||||
*
|
||||
* @param error Error code causing exit
|
||||
*/
|
||||
protected void exit(int error) {
|
||||
System.out.println("OpenAL Error: " + AL.alGetString(error));
|
||||
alExit();
|
||||
System.exit(-1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs the actual test, using supplied arguments
|
||||
*/
|
||||
protected void execute(String[] args) {
|
||||
int lastError;
|
||||
|
||||
//initialize AL, using ALC
|
||||
System.out.print("initialize...");
|
||||
alInitialize();
|
||||
System.out.println("success");
|
||||
|
||||
//do some audio
|
||||
executeAudioTest();
|
||||
|
||||
//shutdown
|
||||
System.out.print("shutdown...");
|
||||
alExit();
|
||||
System.out.println("success");
|
||||
|
||||
//initialize AL, using ALC
|
||||
System.out.print("initialize...");
|
||||
alInitialize();
|
||||
System.out.println("success");
|
||||
|
||||
//do some audio
|
||||
executeAudioTest();
|
||||
|
||||
//shutdown
|
||||
System.out.print("shutdown...");
|
||||
alExit();
|
||||
System.out.println("success");
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes the audio test, which just plays some sound
|
||||
*/
|
||||
private void executeAudioTest() {
|
||||
int lastError;
|
||||
|
||||
//create 1 buffer and 1 source
|
||||
IntBuffer buffers = createIntBuffer(1);
|
||||
IntBuffer sources = createIntBuffer(1);
|
||||
|
||||
// al generate buffers and sources
|
||||
buffers.position(0).limit(1);
|
||||
AL.alGenBuffers(buffers);
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
sources.position(0).limit(1);
|
||||
AL.alGenSources(sources);
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//load wave data
|
||||
WaveData wavefile = WaveData.create("Footsteps.wav");
|
||||
|
||||
//copy to buffers
|
||||
AL.alBufferData(
|
||||
buffers.get(0),
|
||||
wavefile.format,
|
||||
wavefile.data,
|
||||
wavefile.data.capacity(),
|
||||
wavefile.samplerate);
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//unload file again
|
||||
wavefile.dispose();
|
||||
|
||||
//set up source input
|
||||
AL.alSourcei(sources.get(0), AL.AL_BUFFER, buffers.get(0));
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//lets loop the sound
|
||||
AL.alSourcei(sources.get(0), AL.AL_LOOPING, AL.AL_TRUE);
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//play source 0
|
||||
AL.alSourcePlay(sources.get(0));
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//wait 5 secs
|
||||
try {
|
||||
System.out.print("Playing 'Footsteps.wav' for 2 seconds...");
|
||||
Thread.sleep(2000);
|
||||
} catch (InterruptedException inte) {
|
||||
}
|
||||
System.out.println("done");
|
||||
|
||||
//stop source 0
|
||||
AL.alSourceStop(sources.get(0));
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//delete buffers and sources
|
||||
sources.position(0).limit(1);
|
||||
AL.alDeleteSources(sources);
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
buffers.position(0).limit(1);
|
||||
AL.alDeleteBuffers(buffers);
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* main entry point
|
||||
*
|
||||
* @param args String array containing arguments
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
OpenALCreationTest oalCreationTest = new OpenALCreationTest();
|
||||
oalCreationTest.execute(args);
|
||||
}
|
||||
}
|
|
@ -0,0 +1,154 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Light Weight Java Game Library' 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.test.openal;
|
||||
|
||||
import org.lwjgl.openal.AL;
|
||||
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
*
|
||||
* This is a basic play test
|
||||
* Yes, over zealous use of getError ;)
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class PlayTest extends BasicTest {
|
||||
|
||||
/**
|
||||
* Creates an instance of PlayTest
|
||||
*/
|
||||
public PlayTest() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs the actual test, using supplied arguments
|
||||
*/
|
||||
protected void execute(String[] args) {
|
||||
if(args.length < 1) {
|
||||
System.out.println("no argument supplied, assuming Footsteps.wav");
|
||||
args = new String[] {"Footsteps.wav"};
|
||||
}
|
||||
|
||||
int lastError;
|
||||
|
||||
//create 1 buffer and 1 source
|
||||
IntBuffer buffers = createIntBuffer(1);
|
||||
IntBuffer sources = createIntBuffer(1);
|
||||
|
||||
// al generate buffers and sources
|
||||
buffers.position(0).limit(1);
|
||||
AL.alGenBuffers(buffers);
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
sources.position(0).limit(1);
|
||||
AL.alGenSources(sources);
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//load wave data
|
||||
WaveData wavefile = WaveData.create(args[0]);
|
||||
|
||||
//copy to buffers
|
||||
AL.alBufferData(buffers.get(0), wavefile.format, wavefile.data, wavefile.data.capacity(), wavefile.samplerate);
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//unload file again
|
||||
wavefile.dispose();
|
||||
|
||||
//set up source input
|
||||
AL.alSourcei(sources.get(0), AL.AL_BUFFER, buffers.get(0));
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//lets loop the sound
|
||||
AL.alSourcei(sources.get(0), AL.AL_LOOPING, AL.AL_TRUE);
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//play source 0
|
||||
AL.alSourcePlay(sources.get(0));
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//wait 5 secs
|
||||
try {
|
||||
System.out.println("Waiting 5 seconds for sound to complete");
|
||||
Thread.sleep(5000);
|
||||
} catch (InterruptedException inte) {
|
||||
}
|
||||
|
||||
//stop source 0
|
||||
AL.alSourceStop(sources.get(0));
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//delete buffers and sources
|
||||
sources.position(0).limit(1);
|
||||
AL.alDeleteSources(sources);
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
buffers.position(0).limit(1);
|
||||
AL.alDeleteBuffers(buffers);
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//no errorchecking from now on, since our context is gone.
|
||||
//shutdown
|
||||
alExit();
|
||||
}
|
||||
|
||||
/**
|
||||
* main entry point
|
||||
*
|
||||
* @param args String array containing arguments
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
PlayTest playTest = new PlayTest();
|
||||
playTest.execute(args);
|
||||
}
|
||||
}
|
|
@ -0,0 +1,200 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Light Weight Java Game Library' 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.test.openal;
|
||||
|
||||
import org.lwjgl.openal.AL;
|
||||
|
||||
import java.io.BufferedInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.ByteOrder;
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
*
|
||||
* This is a basic play test
|
||||
* Yes, over zealous use of getError ;)
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class PlayTestMemory extends BasicTest {
|
||||
|
||||
/**
|
||||
* Creates an instance of PlayTestMemory
|
||||
*/
|
||||
public PlayTestMemory() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs the actual test, using supplied arguments
|
||||
*/
|
||||
protected void execute(String[] args) {
|
||||
if(args.length < 1) {
|
||||
System.out.println("no argument supplied, assuming Footsteps.wav");
|
||||
args = new String[] {"Footsteps.wav"};
|
||||
}
|
||||
|
||||
int lastError;
|
||||
|
||||
//create 1 buffer and 1 source
|
||||
IntBuffer buffers = createIntBuffer(1);
|
||||
IntBuffer sources = createIntBuffer(1);
|
||||
|
||||
// al generate buffers and sources
|
||||
buffers.position(0).limit(1);
|
||||
AL.alGenBuffers(buffers);
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
sources.position(0).limit(1);
|
||||
AL.alGenSources(sources);
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//load wave data
|
||||
ByteBuffer filebuffer = getData(args[0]);
|
||||
if(filebuffer == null) {
|
||||
System.out.println("Error loading file: " + args[0]);
|
||||
System.exit(-1);
|
||||
}
|
||||
|
||||
//ALUTLoadWAVData file = alut.loadWAVMemory(Sys.getDirectBufferAddress(filebuffer));
|
||||
WaveData wavefile = WaveData.create(filebuffer.array());
|
||||
|
||||
|
||||
//copy to buffers
|
||||
AL.alBufferData(buffers.get(0), wavefile.format, wavefile.data, wavefile.data.capacity(), wavefile.samplerate);
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//unload file again
|
||||
wavefile.dispose();
|
||||
|
||||
//set up source input
|
||||
AL.alSourcei(sources.get(0), AL.AL_BUFFER, buffers.get(0));
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//lets loop the sound
|
||||
AL.alSourcei(sources.get(0), AL.AL_LOOPING, AL.AL_TRUE);
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//play source 0
|
||||
AL.alSourcePlay(sources.get(0));
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//wait 5 secs
|
||||
try {
|
||||
System.out.println("Waiting 5 seconds for sound to complete");
|
||||
Thread.sleep(5000);
|
||||
} catch (InterruptedException inte) {
|
||||
}
|
||||
|
||||
//stop source 0
|
||||
AL.alSourceStop(sources.get(0));
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//delete buffers and sources
|
||||
sources.position(0).limit(1);
|
||||
AL.alDeleteSources(sources);
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
buffers.position(0).limit(1);
|
||||
AL.alDeleteBuffers(buffers);
|
||||
if((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
exit(lastError);
|
||||
}
|
||||
|
||||
//no errorchecking from now on, since our context is gone.
|
||||
alExit();
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads the file into a ByteBuffer
|
||||
*
|
||||
* @param filename Name of file to load
|
||||
* @return ByteBuffer containing file data
|
||||
*/
|
||||
protected ByteBuffer getData(String filename) {
|
||||
ByteBuffer buffer = null;
|
||||
|
||||
System.out.println("Attempting to load: " + filename);
|
||||
|
||||
try {
|
||||
BufferedInputStream bis = new BufferedInputStream(WaveData.class.getClassLoader().getResourceAsStream(filename));
|
||||
ByteArrayOutputStream baos = new ByteArrayOutputStream();
|
||||
|
||||
int bufferLength = 4096;
|
||||
byte[] readBuffer = new byte[bufferLength];
|
||||
int read = -1;
|
||||
|
||||
while((read = bis.read(readBuffer, 0, bufferLength)) != -1) {
|
||||
baos.write(readBuffer, 0, read);
|
||||
}
|
||||
|
||||
//done reading, close
|
||||
bis.close();
|
||||
|
||||
buffer = ByteBuffer.allocate(baos.size());
|
||||
buffer.order(ByteOrder.nativeOrder());
|
||||
buffer.put(baos.toByteArray());
|
||||
} catch (Exception ioe) {
|
||||
ioe.printStackTrace();
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
|
||||
/**
|
||||
* main entry point
|
||||
*
|
||||
* @param args String array containing arguments
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
PlayTestMemory playTestMemory = new PlayTestMemory();
|
||||
playTestMemory.execute(args);
|
||||
}
|
||||
}
|
|
@ -0,0 +1,162 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Light Weight Java Game Library' 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.test.openal;
|
||||
|
||||
import org.lwjgl.openal.AL;
|
||||
import org.lwjgl.openal.OpenALException;
|
||||
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
*
|
||||
* Simple test for testing the number of available sources
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class SourceLimitTest extends BasicTest {
|
||||
|
||||
/** Sources to create */
|
||||
protected int sourcesToCreate = 64;
|
||||
|
||||
/**
|
||||
* Creates an instance of SourceLimitTest
|
||||
*/
|
||||
public SourceLimitTest() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs the actual test, using supplied arguments
|
||||
*/
|
||||
protected void execute(String[] args) {
|
||||
//parse 1st arg to sourcecount
|
||||
if (args.length > 0) {
|
||||
try {
|
||||
sourcesToCreate = Integer.parseInt(args[0]);
|
||||
} catch (NumberFormatException nfe) {
|
||||
System.out.println(
|
||||
"Unable to parse parameter to integer. Defaulting to 64 sources.");
|
||||
}
|
||||
}
|
||||
|
||||
System.out.print("Creating " + sourcesToCreate + " in one go...");
|
||||
try {
|
||||
CreateAllSources();
|
||||
} catch(OpenALException oale) {
|
||||
}
|
||||
|
||||
|
||||
System.out.print("Creating " + sourcesToCreate + " one at a time...");
|
||||
try {
|
||||
CreateSourcesStep();
|
||||
} catch(Exception e) {
|
||||
}
|
||||
//shutdown
|
||||
alExit();
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the creation of n sources in on go
|
||||
*/
|
||||
protected void CreateAllSources() {
|
||||
int lastError;
|
||||
|
||||
//make bytbuffer that can hold sourcesToCreate sources
|
||||
IntBuffer sources = createIntBuffer(sourcesToCreate);
|
||||
|
||||
//Create sourcesToCreate sources in one fell swoop
|
||||
sources.position(0).limit(sourcesToCreate);
|
||||
AL.alGenSources(sources);
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
System.out.println("failed to create " + sourcesToCreate + " sources (" + AL.alGetString(lastError) + ")");
|
||||
return;
|
||||
}
|
||||
|
||||
//delete sources
|
||||
sources.position(0).limit(sourcesToCreate);
|
||||
AL.alDeleteSources(sources);
|
||||
|
||||
System.out.println("created " + sourcesToCreate + " sources successfully!");
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests if n sources can be created one at a time
|
||||
*/
|
||||
protected void CreateSourcesStep() {
|
||||
int lastError;
|
||||
int sourcesCreated = 0;
|
||||
|
||||
//make bytbuffer that can hold sourcesToCreate sources
|
||||
IntBuffer[] sources = new IntBuffer[sourcesToCreate];
|
||||
|
||||
//create the sources
|
||||
for (int i = 0; i <= sourcesToCreate; i++) {
|
||||
sources[i] = createIntBuffer(1);
|
||||
sources[i].position(0).limit(1);
|
||||
AL.alGenSources(sources[i]);
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
System.out.println("failed to create source: " + (i + 1));
|
||||
break;
|
||||
}
|
||||
sourcesCreated++;
|
||||
}
|
||||
|
||||
//delete allocated sources
|
||||
for (int i = 0; i < sourcesCreated; i++) {
|
||||
//delete buffers and sources
|
||||
sources[i].position(0).limit(1);
|
||||
AL.alDeleteSources(sources[i]);
|
||||
if ((lastError = AL.alGetError()) != AL.AL_NO_ERROR) {
|
||||
System.out.println("failed to delete source: " + i + "(" + AL.alGetString(lastError) + ")");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if(sourcesCreated != sourcesToCreate) {
|
||||
System.out.println("created " + sourcesCreated + " sources before failing");
|
||||
} else {
|
||||
System.out.println("created " + sourcesCreated + " sources successfully!");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* main entry point
|
||||
*
|
||||
* @param args String array containing arguments
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
SourceLimitTest sourceLimitTest = new SourceLimitTest();
|
||||
sourceLimitTest.execute(args);
|
||||
}
|
||||
}
|
|
@ -0,0 +1,219 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Light Weight Java Game Library' 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.test.openal;
|
||||
|
||||
import org.lwjgl.openal.AL;
|
||||
import java.nio.IntBuffer;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
*
|
||||
* Simple test for stresstesting OpenAL playing random samples ad nausea
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class StressTest extends BasicTest {
|
||||
|
||||
/** Buffer containing sources */
|
||||
private IntBuffer sources;
|
||||
|
||||
/** Buffer containing buffers */
|
||||
private IntBuffer buffers;
|
||||
|
||||
/**
|
||||
* Creates an instance of StressTest
|
||||
*/
|
||||
public StressTest() {
|
||||
super();
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs the actual test, using supplied arguments
|
||||
*/
|
||||
protected void execute(String[] args) {
|
||||
|
||||
createSources();
|
||||
|
||||
createBuffers();
|
||||
|
||||
try {
|
||||
loadSamples();
|
||||
runTest();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
|
||||
|
||||
alExit();
|
||||
}
|
||||
|
||||
private void createSources() {
|
||||
sources = createIntBuffer(4);
|
||||
sources.position(0).limit(4);
|
||||
AL.alGenSources(sources);
|
||||
if (AL.alGetError() != AL.AL_NO_ERROR) {
|
||||
System.out.println("Unable to create 4 sources");
|
||||
alExit();
|
||||
}
|
||||
}
|
||||
|
||||
private void createBuffers() {
|
||||
buffers = createIntBuffer(10);
|
||||
buffers.position(0).limit(10);
|
||||
AL.alGenBuffers(buffers);
|
||||
if (AL.alGetError() != AL.AL_NO_ERROR) {
|
||||
System.out.println("Unable to create 10 buffers");
|
||||
sources.position(0).limit(4);
|
||||
AL.alDeleteSources(sources);
|
||||
alExit();
|
||||
}
|
||||
}
|
||||
|
||||
private void loadSamples() throws Exception {
|
||||
AL.alGetError();
|
||||
WaveData data = WaveData.create("ding.wav");
|
||||
for (int i = 1; i <= 10; i++) {
|
||||
AL.alBufferData(
|
||||
buffers.get(i - 1),
|
||||
data.format,
|
||||
data.data,
|
||||
data.data.capacity(),
|
||||
data.samplerate);
|
||||
|
||||
if (AL.alGetError() != AL.AL_NO_ERROR) {
|
||||
System.out.println("Failed to load " + i + ".wav into buffer");
|
||||
sources.position(0).limit(4);
|
||||
AL.alDeleteSources(sources);
|
||||
buffers.position(0).limit(10);
|
||||
AL.alDeleteBuffers(buffers);
|
||||
|
||||
alExit();
|
||||
}
|
||||
}
|
||||
data.dispose();
|
||||
}
|
||||
|
||||
public void runTest() {
|
||||
int iterations = 0;
|
||||
int randomBuffer;
|
||||
int startSlot = 1;
|
||||
int nextSlot = startSlot;
|
||||
long startTime = System.currentTimeMillis();
|
||||
|
||||
//mark background source as looping
|
||||
AL.alSourcei(sources.get(0), AL.AL_LOOPING, AL.AL_TRUE);
|
||||
|
||||
//play background
|
||||
AL.alSourcei(sources.get(0), AL.AL_BUFFER, buffers.get(0));
|
||||
AL.alSourcePlay(sources.get(0));
|
||||
|
||||
while (System.currentTimeMillis() - startTime < (2000)) {
|
||||
|
||||
randomBuffer = getRandomBuffer();
|
||||
System.out.println("random:" + randomBuffer);
|
||||
|
||||
//stop source at slot
|
||||
AL.alSourceStop(sources.get(nextSlot));
|
||||
if (AL.alGetError() != AL.AL_NO_ERROR) {
|
||||
System.out.println("Error stopping source.");
|
||||
}
|
||||
System.out.println("Stopped source: " + nextSlot);
|
||||
|
||||
//link source<->buffer
|
||||
AL.alSourcei(sources.get(nextSlot), AL.AL_BUFFER, buffers.get(randomBuffer));
|
||||
if (AL.alGetError() != AL.AL_NO_ERROR) {
|
||||
System.out.println("Error linking buffer and source.");
|
||||
}
|
||||
System.out.println("linked source " + nextSlot + " with buffer " + randomBuffer);
|
||||
|
||||
//start playing
|
||||
System.out.println("playing source " + nextSlot);
|
||||
AL.alSourcePlay(sources.get(nextSlot++));
|
||||
if (nextSlot == 4) {
|
||||
nextSlot = startSlot;
|
||||
}
|
||||
|
||||
//pause
|
||||
try {
|
||||
Thread.sleep(500);
|
||||
} catch (InterruptedException inte) {
|
||||
}
|
||||
|
||||
//debug info
|
||||
if ((++iterations % 10) == 0) {
|
||||
System.out.println("========================");
|
||||
System.out.println("MaxMemory: " + Runtime.getRuntime().maxMemory() / 1024);
|
||||
System.out.println("FreeMemory: " + Runtime.getRuntime().freeMemory() / 1024);
|
||||
System.out.println("TotalMemory: " + Runtime.getRuntime().totalMemory() / 1024);
|
||||
System.out.println("========================");
|
||||
}
|
||||
}
|
||||
|
||||
//stop all sources
|
||||
for (int i = 0; i < 4; i++) {
|
||||
AL.alSourceStop(sources.get(i));
|
||||
System.out.println("Stopping source " + (i+1));
|
||||
}
|
||||
|
||||
//test done - ask for user input
|
||||
try {
|
||||
System.out.println("Test completed");
|
||||
System.out.println("========================");
|
||||
System.out.println("MaxMemory: " + Runtime.getRuntime().maxMemory() / 1024);
|
||||
System.out.println("FreeMemory: " + Runtime.getRuntime().freeMemory() / 1024);
|
||||
System.out.println("TotalMemory: " + Runtime.getRuntime().totalMemory() / 1024);
|
||||
System.out.println("========================");
|
||||
System.in.read();
|
||||
} catch (Exception e) {
|
||||
}
|
||||
|
||||
sources.position(0).limit(4);
|
||||
AL.alDeleteSources(sources);
|
||||
buffers.position(0).limit(10);
|
||||
AL.alDeleteBuffers(buffers);
|
||||
}
|
||||
|
||||
private int getRandomBuffer() {
|
||||
return (int) (Math.random() * 10.0);
|
||||
}
|
||||
|
||||
/**
|
||||
* main entry point
|
||||
*
|
||||
* @param args String array containing arguments
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
StressTest stressTest = new StressTest();
|
||||
stressTest.execute(args);
|
||||
}
|
||||
}
|
|
@ -0,0 +1,183 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Light Weight Java Game Library' 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.test.openal;
|
||||
|
||||
import org.lwjgl.openal.AL;
|
||||
|
||||
import java.nio.ByteBuffer;
|
||||
|
||||
import javax.sound.sampled.AudioInputStream;
|
||||
import javax.sound.sampled.AudioSystem;
|
||||
import javax.sound.sampled.*;
|
||||
|
||||
import java.io.BufferedInputStream;
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.IOException;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
*
|
||||
* Utitlity class for loading wavefiles.
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class WaveData {
|
||||
/** actual wave data */
|
||||
public final ByteBuffer data;
|
||||
|
||||
/** format type of data */
|
||||
public final int format;
|
||||
|
||||
/** sample rate of data */
|
||||
public final int samplerate;
|
||||
|
||||
/**
|
||||
* Creates a new WaveData
|
||||
*
|
||||
* @param data actual wavedata
|
||||
* @param format format of wave data
|
||||
* @param samplerate sample rate of data
|
||||
*/
|
||||
private WaveData(ByteBuffer data, int format, int samplerate) {
|
||||
this.data = data;
|
||||
this.format = format;
|
||||
this.samplerate = samplerate;
|
||||
}
|
||||
|
||||
/**
|
||||
* Disposes the wavedata
|
||||
*/
|
||||
public void dispose() {
|
||||
data.clear();
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a WaveData container from the specified filename
|
||||
*
|
||||
* @param filepath path to file (relative, and in classpath)
|
||||
* @return WaveData containing data, or null if a failure occured
|
||||
*/
|
||||
public static WaveData create(String filepath) {
|
||||
try {
|
||||
return create(
|
||||
AudioSystem.getAudioInputStream(
|
||||
new BufferedInputStream(WaveData.class.getClassLoader().getResourceAsStream(filepath))));
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a WaveData container from the specified bytes
|
||||
*
|
||||
* @param buffer array of bytes containing the complete wave file
|
||||
* @return WaveData containing data, or null if a failure occured
|
||||
*/
|
||||
public static WaveData create(byte[] buffer) {
|
||||
try {
|
||||
return create(
|
||||
AudioSystem.getAudioInputStream(
|
||||
new BufferedInputStream(new ByteArrayInputStream(buffer))));
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a WaveData container from the specified stream
|
||||
*
|
||||
* @param ais AudioInputStream to read from
|
||||
* @return WaveData containing data, or null if a failure occured
|
||||
*/
|
||||
public static WaveData create(AudioInputStream ais) {
|
||||
//get format of data
|
||||
AudioFormat audioformat = ais.getFormat();
|
||||
|
||||
// get channels
|
||||
int channels = 0;
|
||||
if (audioformat.getChannels() == 1) {
|
||||
if (audioformat.getSampleSizeInBits() == 8) {
|
||||
channels = AL.AL_FORMAT_MONO8;
|
||||
} else if (audioformat.getSampleSizeInBits() == 16) {
|
||||
channels = AL.AL_FORMAT_MONO16;
|
||||
} else {
|
||||
assert false : "Illegal sample size";
|
||||
}
|
||||
} else if (audioformat.getChannels() == 2) {
|
||||
if (audioformat.getSampleSizeInBits() == 8) {
|
||||
channels = AL.AL_FORMAT_STEREO8;
|
||||
} else if (audioformat.getSampleSizeInBits() == 16) {
|
||||
channels = AL.AL_FORMAT_STEREO16;
|
||||
} else {
|
||||
assert false : "Illegal sample size";
|
||||
}
|
||||
} else {
|
||||
assert false : "Only mono or stereo is supported";
|
||||
}
|
||||
|
||||
//read data into buffer
|
||||
byte[] buf =
|
||||
new byte[audioformat.getChannels()
|
||||
* (int) ais.getFrameLength()
|
||||
* audioformat.getSampleSizeInBits()
|
||||
/ 8];
|
||||
int read = 0, total = 0;
|
||||
try {
|
||||
while ((read = ais.read(buf, total, buf.length - total)) != -1
|
||||
&& total < buf.length) {
|
||||
total += read;
|
||||
}
|
||||
} catch (IOException ioe) {
|
||||
return null;
|
||||
}
|
||||
|
||||
//insert data into bytebuffer
|
||||
ByteBuffer buffer = ByteBuffer.allocateDirect(buf.length);
|
||||
buffer.put(buf);
|
||||
buffer.rewind();
|
||||
|
||||
//create our result
|
||||
WaveData wavedata =
|
||||
new WaveData(buffer, channels, (int) audioformat.getSampleRate());
|
||||
|
||||
//close stream
|
||||
try {
|
||||
ais.close();
|
||||
} catch (IOException ioe) {
|
||||
}
|
||||
|
||||
return wavedata;
|
||||
}
|
||||
}
|
|
@ -0,0 +1,335 @@
|
|||
/*
|
||||
* Copyright (c) 2003 Lightweight Java Game Library 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 'Lightweight Java Game Library' 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.test.opengl;
|
||||
|
||||
import org.lwjgl.*;
|
||||
import org.lwjgl.input.*;
|
||||
import org.lwjgl.opengl.*;
|
||||
import org.lwjgl.vector.Vector2f;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
*
|
||||
* Tests switching between windowed and fullscreen
|
||||
*
|
||||
* @author Brian Matzon <brian@matzon.dk>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class FullScreenWindowedTest {
|
||||
|
||||
/** Intended deiplay mode */
|
||||
private DisplayMode mode;
|
||||
|
||||
/** GLU instance */
|
||||
private GLU glu;
|
||||
|
||||
/** our quad moving around */
|
||||
private Vector2f quadPosition;
|
||||
|
||||
/** our quadVelocity */
|
||||
private Vector2f quadVelocity;
|
||||
|
||||
/** angle of quad */
|
||||
private float angle;
|
||||
|
||||
/** degrees to rotate per frame */
|
||||
private float angleRotation = 1.0f;
|
||||
|
||||
/** Max speed of all changable attributes */
|
||||
private static final float MAX_SPEED = 20.0f;
|
||||
|
||||
/**
|
||||
* Creates a FullScreenWindowedTest
|
||||
*/
|
||||
public FullScreenWindowedTest() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes the test
|
||||
*/
|
||||
public void execute() {
|
||||
initialize();
|
||||
|
||||
mainLoop();
|
||||
|
||||
cleanup();
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes the test
|
||||
*/
|
||||
private void initialize() {
|
||||
try {
|
||||
//find displaymode
|
||||
mode = findDisplayMode(800, 600, 16);
|
||||
|
||||
// start of in windowed mode
|
||||
Window.create("Test", 50, 50, mode.width, mode.height, mode.bpp, 0, 0, 0);
|
||||
|
||||
glInit();
|
||||
|
||||
Keyboard.create();
|
||||
|
||||
quadPosition = new Vector2f(100f, 100f);
|
||||
quadVelocity = new Vector2f(1.0f, 1.0f);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs the main loop of the "test"
|
||||
*/
|
||||
private void mainLoop() {
|
||||
while (!Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)
|
||||
&& !Window.isCloseRequested()) {
|
||||
// allow subsystem to get a chance to run too
|
||||
Window.update();
|
||||
|
||||
if (!Window.isMinimized()) {
|
||||
// check keyboard input
|
||||
processKeyboard();
|
||||
|
||||
// do "game" logic, and render it
|
||||
logic();
|
||||
render();
|
||||
|
||||
// paint window
|
||||
Window.paint();
|
||||
} else {
|
||||
|
||||
// no need to render/paint if nothing has changed (ie. window dragged over)
|
||||
if (Window.isDirty()) {
|
||||
render();
|
||||
Window.paint();
|
||||
}
|
||||
|
||||
// don't waste cpu time, sleep more
|
||||
try {
|
||||
Thread.sleep(100);
|
||||
} catch (InterruptedException inte) {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs the logic
|
||||
*/
|
||||
private void logic() {
|
||||
angle += angleRotation;
|
||||
if (angle > 90.0f) {
|
||||
angle = 0.0f;
|
||||
}
|
||||
|
||||
quadPosition.x += quadVelocity.x;
|
||||
quadPosition.y += quadVelocity.y;
|
||||
|
||||
//check colision with vertical border border
|
||||
if (quadPosition.x + 50 >= mode.width || quadPosition.x - 50 <= 0) {
|
||||
quadVelocity.x *= -1;
|
||||
}
|
||||
|
||||
//check collision with horizontal border
|
||||
if (quadPosition.y + 50 >= mode.height || quadPosition.y - 50 <= 0) {
|
||||
quadVelocity.y *= -1;
|
||||
}
|
||||
}
|
||||
|
||||
private void render() {
|
||||
//clear background
|
||||
GL.glClear(GL.GL_COLOR_BUFFER_BIT);
|
||||
|
||||
// draw white quad
|
||||
GL.glPushMatrix();
|
||||
{
|
||||
GL.glTranslatef(quadPosition.x, quadPosition.y, 0);
|
||||
GL.glRotatef(angle, 0.0f, 0.0f, 1.0f);
|
||||
GL.glColor3f(1.0f, 1.0f, 1.0f);
|
||||
GL.glBegin(GL.GL_QUADS);
|
||||
{
|
||||
GL.glVertex2i(-50, -50);
|
||||
GL.glVertex2i(50, -50);
|
||||
GL.glVertex2i(50, 50);
|
||||
GL.glVertex2i(-50, 50);
|
||||
}
|
||||
GL.glEnd();
|
||||
}
|
||||
GL.glPopMatrix();
|
||||
}
|
||||
|
||||
/**
|
||||
* Processes keyboard input
|
||||
*/
|
||||
private void processKeyboard() {
|
||||
Keyboard.poll();
|
||||
|
||||
//check for fullscreen key
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_F)) {
|
||||
|
||||
try {
|
||||
Keyboard.destroy();
|
||||
Window.destroy();
|
||||
|
||||
Display.setDisplayMode(mode);
|
||||
Window.create("Test", mode.bpp, 0, 0, 0);
|
||||
|
||||
glInit();
|
||||
|
||||
Keyboard.create();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
//check for window key
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_W)) {
|
||||
try {
|
||||
Keyboard.destroy();
|
||||
Window.destroy();
|
||||
|
||||
Display.resetDisplayMode();
|
||||
Window.create("Test", 50, 50, mode.width, mode.height, mode.bpp, 0, 0, 0);
|
||||
|
||||
glInit();
|
||||
|
||||
Keyboard.create();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
//check for speed changes
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_UP)) {
|
||||
quadVelocity.y += 0.1f;
|
||||
}
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_DOWN)) {
|
||||
quadVelocity.y -= 0.1f;
|
||||
}
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_RIGHT)) {
|
||||
quadVelocity.x += 0.1f;
|
||||
}
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_LEFT)) {
|
||||
quadVelocity.x -= 0.1f;
|
||||
}
|
||||
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_ADD)) {
|
||||
angleRotation += 0.1f;
|
||||
}
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_SUBTRACT)) {
|
||||
angleRotation -= 0.1f;
|
||||
}
|
||||
|
||||
//throttle
|
||||
if (quadVelocity.x < -MAX_SPEED) {
|
||||
quadVelocity.x = -MAX_SPEED;
|
||||
}
|
||||
if (quadVelocity.x > MAX_SPEED) {
|
||||
quadVelocity.x = MAX_SPEED;
|
||||
}
|
||||
if (quadVelocity.y < -MAX_SPEED) {
|
||||
quadVelocity.y = -MAX_SPEED;
|
||||
}
|
||||
if (quadVelocity.y > MAX_SPEED) {
|
||||
quadVelocity.y = MAX_SPEED;
|
||||
}
|
||||
|
||||
if (angleRotation < 0.0f) {
|
||||
angleRotation = 0.0f;
|
||||
}
|
||||
if (angleRotation > MAX_SPEED) {
|
||||
angleRotation = MAX_SPEED;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleans up the test
|
||||
*/
|
||||
private void cleanup() {
|
||||
Keyboard.destroy();
|
||||
Window.destroy();
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves a displaymode, if one such is available
|
||||
*
|
||||
* @param width Required width
|
||||
* @param height Required height
|
||||
* @param bpp Minimum required bits per pixel
|
||||
* @return
|
||||
*/
|
||||
private DisplayMode findDisplayMode(int width, int height, int bpp) {
|
||||
DisplayMode[] modes = Display.getAvailableDisplayModes();
|
||||
for (int i = 0; i < modes.length; i++) {
|
||||
if (modes[i].width == width
|
||||
&& modes[i].height == height
|
||||
&& modes[i].bpp >= bpp) {
|
||||
return modes[i];
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes OGL
|
||||
*/
|
||||
private void glInit() {
|
||||
// Go into orthographic projection mode.
|
||||
GL.glMatrixMode(GL.GL_PROJECTION);
|
||||
GL.glLoadIdentity();
|
||||
GLU.gluOrtho2D(0, mode.width, 0, mode.height);
|
||||
GL.glMatrixMode(GL.GL_MODELVIEW);
|
||||
GL.glLoadIdentity();
|
||||
GL.glViewport(0, 0, mode.width, mode.height);
|
||||
|
||||
//set clear color to black
|
||||
GL.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
||||
|
||||
//sync frame (only works on windows)
|
||||
GLCaps.determineAvailableExtensions();
|
||||
if (GLCaps.WGL_EXT_swap_control) {
|
||||
GL.wglSwapIntervalEXT(1);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Test entry point
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
System.out.println(
|
||||
"Change between fullscreen and windowed mode, by pressing F and W respectively");
|
||||
System.out.println(
|
||||
"Move quad using arrowkeys, and change rotation using +/-");
|
||||
FullScreenWindowedTest fswTest = new FullScreenWindowedTest();
|
||||
fswTest.execute();
|
||||
}
|
||||
}
|
|
@ -0,0 +1,202 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Light Weight Java Game Library' 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
*
|
||||
* Simple java test program.
|
||||
*
|
||||
* @author elias_naur <elias_naur@users.sourceforge.net>
|
||||
* @version $Revision$
|
||||
*/
|
||||
|
||||
package org.lwjgl.test.opengl;
|
||||
|
||||
import org.lwjgl.*;
|
||||
import org.lwjgl.opengl.*;
|
||||
import org.lwjgl.input.*;
|
||||
|
||||
import java.nio.*;
|
||||
|
||||
public final class Game {
|
||||
static {
|
||||
try {
|
||||
//find first display mode that allows us 640*480*16
|
||||
int mode = -1;
|
||||
DisplayMode[] modes = Display.getAvailableDisplayModes();
|
||||
for (int i = 0; i < modes.length; i++) {
|
||||
if (modes[i].width == 640
|
||||
&& modes[i].height == 480
|
||||
&& modes[i].bpp >= 16) {
|
||||
mode = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (mode != -1) {
|
||||
//select above found displaymode
|
||||
System.out.println("Setting display mode to "+modes[mode]);
|
||||
Display.setDisplayMode(modes[mode]);
|
||||
System.out.println("Created display.");
|
||||
}
|
||||
} catch (Exception e) {
|
||||
System.err.println("Failed to create display due to " + e);
|
||||
}
|
||||
}
|
||||
|
||||
static {
|
||||
try {
|
||||
Window.create("LWJGL Game Example", 16, 0, 0,0);
|
||||
System.out.println("Created OpenGL.");
|
||||
} catch (Exception e) {
|
||||
System.err.println("Failed to create OpenGL due to "+e);
|
||||
System.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
/** Is the game finished? */
|
||||
private static boolean finished;
|
||||
|
||||
/** A rotating square! */
|
||||
private static float angle;
|
||||
|
||||
/**
|
||||
* No construction allowed
|
||||
*/
|
||||
private Game() {
|
||||
}
|
||||
|
||||
public static void main(String[] arguments) {
|
||||
try {
|
||||
init();
|
||||
while (!finished) {
|
||||
Window.update();
|
||||
|
||||
if (Window.isMinimized())
|
||||
Thread.sleep(200);
|
||||
else if (Window.isCloseRequested())
|
||||
System.exit(0);
|
||||
|
||||
Keyboard.poll();
|
||||
mainLoop();
|
||||
render();
|
||||
Window.paint();
|
||||
}
|
||||
} catch (Throwable t) {
|
||||
t.printStackTrace();
|
||||
} finally {
|
||||
cleanup();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* All calculations are done in here
|
||||
*/
|
||||
private static void mainLoop() {
|
||||
angle += 1f;
|
||||
if (angle > 360.0f)
|
||||
angle = 0.0f;
|
||||
|
||||
Mouse.poll();
|
||||
if (Mouse.dx != 0 || Mouse.dy != 0 || Mouse.dwheel != 0)
|
||||
System.out.println("Mouse moved " + Mouse.dx + " " + Mouse.dy + " " + Mouse.dwheel);
|
||||
for (int i = 0; i < Mouse.buttonCount; i++)
|
||||
if (Mouse.isButtonDown(i))
|
||||
System.out.println("Button " + i + " down");
|
||||
/* Keyboard.poll();
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_ESCAPE))
|
||||
finished = true;*/
|
||||
Keyboard.read();
|
||||
for (int i = 0; i < Keyboard.getNumKeyboardEvents(); i++) {
|
||||
Keyboard.next();
|
||||
if (Keyboard.key == Keyboard.KEY_ESCAPE && Keyboard.state)
|
||||
finished = true;
|
||||
if (Keyboard.key == Keyboard.KEY_T && Keyboard.state)
|
||||
System.out.println("Current time: " + Sys.getTime());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* All rendering is done in here
|
||||
*/
|
||||
private static void render() {
|
||||
GL.glClear(GL.GL_COLOR_BUFFER_BIT);
|
||||
GL.glPushMatrix();
|
||||
GL.glTranslatef(Display.getWidth() / 2, Display.getHeight() / 2, 0.0f);
|
||||
GL.glRotatef(angle, 0, 0, 1.0f);
|
||||
GL.glBegin(GL.GL_QUADS);
|
||||
GL.glVertex2i(-50, -50);
|
||||
GL.glVertex2i(50, -50);
|
||||
GL.glVertex2i(50, 50);
|
||||
GL.glVertex2i(-50, 50);
|
||||
GL.glEnd();
|
||||
GL.glPopMatrix();
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize
|
||||
*/
|
||||
private static void init() throws Exception {
|
||||
Keyboard.create();
|
||||
Keyboard.enableBuffer();
|
||||
Mouse.create();
|
||||
Sys.setTime(0);
|
||||
Sys.setProcessPriority(Sys.HIGH_PRIORITY);
|
||||
System.out.println("Timer resolution: " + Sys.getTimerResolution());
|
||||
// Go into orthographic projection mode.
|
||||
GL.glMatrixMode(GL.GL_PROJECTION);
|
||||
GL.glLoadIdentity();
|
||||
GLU.gluOrtho2D(0, Display.getWidth(), 0, Display.getHeight());
|
||||
GL.glMatrixMode(GL.GL_MODELVIEW);
|
||||
GL.glLoadIdentity();
|
||||
GL.glViewport(0, 0, Display.getWidth(), Display.getHeight());
|
||||
ByteBuffer num_tex_units_buf = ByteBuffer.allocateDirect(4);
|
||||
num_tex_units_buf.order(ByteOrder.nativeOrder());
|
||||
GL.glGetInteger(GL.GL_MAX_TEXTURE_UNITS_ARB, num_tex_units_buf.asIntBuffer());
|
||||
System.out.println("Number of texture units: " + num_tex_units_buf.getInt());
|
||||
// Fix the refresh rate to the display frequency.
|
||||
// GL.wglSwapIntervalEXT(1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleanup
|
||||
*/
|
||||
private static void cleanup() {
|
||||
Keyboard.destroy();
|
||||
Mouse.destroy();
|
||||
Window.destroy();
|
||||
try {
|
||||
Display.resetDisplayMode();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
|
@ -0,0 +1,466 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Light Weight Java Game Library' 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
*
|
||||
* Simple java test program.
|
||||
*
|
||||
* @author elias_naur <elias_naur@users.sourceforge.net>
|
||||
* @version $Revision$
|
||||
*/
|
||||
|
||||
package org.lwjgl.test.opengl;
|
||||
|
||||
import org.lwjgl.input.*;
|
||||
import org.lwjgl.opengl.*;
|
||||
import org.lwjgl.*;
|
||||
|
||||
import java.io.*;
|
||||
import java.nio.*;
|
||||
import java.util.*;
|
||||
|
||||
public class Grass {
|
||||
|
||||
static class Aslod {
|
||||
float angle;
|
||||
float value;
|
||||
float ripple;
|
||||
float count;
|
||||
}
|
||||
private static boolean finished = false;
|
||||
private static Random rand = new Random();
|
||||
|
||||
static {
|
||||
try {
|
||||
int mode = -1;
|
||||
DisplayMode[] modes = Display.getAvailableDisplayModes();
|
||||
for (int i = 0; i < modes.length; i++) {
|
||||
if (modes[i].width == 640
|
||||
&& modes[i].height == 480
|
||||
&& modes[i].bpp >= 16) {
|
||||
mode = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (mode == -1) {
|
||||
System.out.println("did not find suitable mode");
|
||||
} else {
|
||||
System.out.println("Display mode: " + modes[mode]);
|
||||
}
|
||||
// For now let's just pick a mode we're certain to have
|
||||
|
||||
Display.setDisplayMode(modes[mode]);
|
||||
System.out.println("Created display.");
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
System.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
static {
|
||||
try {
|
||||
Window.create("LWJGL Grass", 50, 50, 640, 480, 16, 0, 0,0);
|
||||
Keyboard.create();
|
||||
Keyboard.enableBuffer();
|
||||
Mouse.create();
|
||||
System.out.println("Created OpenGL.");
|
||||
} catch (Exception e) {
|
||||
System.err.println("Failed to create OpenGL due to " + e);
|
||||
System.exit(1);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
private static Aslod aslod = new Aslod();
|
||||
|
||||
private static int mesh;
|
||||
private static int program_handle;
|
||||
|
||||
private static byte[] loadFile(String file) {
|
||||
int next;
|
||||
java.util.Vector bytes = new java.util.Vector();
|
||||
try {
|
||||
ClassLoader loader = Grass.class.getClassLoader();
|
||||
InputStream stream = new BufferedInputStream(loader.getResourceAsStream(file));
|
||||
while ((next = (stream.read())) != -1)
|
||||
bytes.add(new Byte((byte) next));
|
||||
stream.close();
|
||||
byte[] result = new byte[bytes.size()];
|
||||
for (int i = 0; i < result.length; i++)
|
||||
result[i] = ((Byte) bytes.get(i)).byteValue();
|
||||
return result;
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public static void main(String[] args) {
|
||||
ByteBuffer byte_buf = ByteBuffer.allocateDirect(4);
|
||||
byte_buf.order(ByteOrder.nativeOrder());
|
||||
GLCaps.determineAvailableExtensions();
|
||||
System.out.println("Vertex program supported: " + GLCaps.GL_NV_vertex_program);
|
||||
GL.glGenProgramsNV(byte_buf.asIntBuffer());
|
||||
IntBuffer int_buf = byte_buf.asIntBuffer();
|
||||
if (int_buf.get(0) == 0)
|
||||
throw new RuntimeException("Could not allocate new vertex program id!");
|
||||
|
||||
program_handle = int_buf.get(0);
|
||||
byte[] program = loadFile("cg_grass2.vp");
|
||||
ByteBuffer program_buf = ByteBuffer.allocateDirect(program.length);
|
||||
program_buf.order(ByteOrder.nativeOrder());
|
||||
program_buf.rewind();
|
||||
program_buf.put(program);
|
||||
program_buf.rewind();
|
||||
GL.glLoadProgramNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
program_handle,
|
||||
program_buf);
|
||||
/*GL.glGetInteger(GL.PROGRAM_ERROR_POSITION_NV, int_buf);
|
||||
System.out.println("error position: " + int_buf.get(0));*/
|
||||
|
||||
genMesh();
|
||||
|
||||
float[] LightDiffuse = { 1.0f, 0.0f, 0.0f, 1.0f };
|
||||
float[] LightPosition = { 1.0f, 1.0f, 1.0f, 0.0f };
|
||||
ByteBuffer light_buf = ByteBuffer.allocateDirect(4 * 4);
|
||||
light_buf.order(ByteOrder.nativeOrder());
|
||||
FloatBuffer light_buf_f = light_buf.asFloatBuffer();
|
||||
light_buf_f.rewind();
|
||||
light_buf_f.put(LightDiffuse);
|
||||
|
||||
GL.glLightfv(
|
||||
GL.GL_LIGHT0,
|
||||
GL.GL_DIFFUSE,
|
||||
light_buf_f);
|
||||
light_buf_f.rewind();
|
||||
light_buf_f.put(LightPosition);
|
||||
GL.glLightfv(
|
||||
GL.GL_LIGHT0,
|
||||
GL.GL_POSITION,
|
||||
light_buf_f);
|
||||
GL.glEnable(GL.GL_LIGHT0);
|
||||
GL.glEnable(GL.GL_LIGHTING);
|
||||
GL.glEnable(GL.GL_DEPTH_TEST);
|
||||
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
|
||||
GL.glEnable(GL.GL_BLEND);
|
||||
GL.glMatrixMode(GL.GL_PROJECTION);
|
||||
GLU.gluPerspective(40.0, 1.0, 1.0, 50.0);
|
||||
GL.glMatrixMode(GL.GL_MODELVIEW);
|
||||
|
||||
GLU.gluLookAt(14.0, 10.0, -16.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
|
||||
|
||||
aslod.angle = 2.6179935f;
|
||||
aslod.value = 0.2f;
|
||||
aslod.ripple = 0.0f;
|
||||
aslod.count = 0.0f;
|
||||
|
||||
while (!finished) {
|
||||
keyPoll();
|
||||
float degree = (1.0f + (aslod.value * 20.0f)) * 0.01745329f;
|
||||
|
||||
degree *= (0.5 + myrand());
|
||||
|
||||
ptrAnimate(degree);
|
||||
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
|
||||
|
||||
//ptrDraw();
|
||||
|
||||
grsDraw();
|
||||
|
||||
Window.paint();
|
||||
}
|
||||
Mouse.destroy();
|
||||
Keyboard.destroy();
|
||||
Window.destroy();
|
||||
}
|
||||
|
||||
private static float myrand() {
|
||||
// returns a value between 0 and 1
|
||||
return rand.nextFloat();
|
||||
}
|
||||
|
||||
private static void genGrass(
|
||||
float fFaceHeight,
|
||||
float fFaceWidth,
|
||||
float fX,
|
||||
float fZ) {
|
||||
int cFaces;
|
||||
int numFaces;
|
||||
float cWidth;
|
||||
float fDecWidth, frndWidth, frndHeight;
|
||||
float fRotate;
|
||||
float fRigid;
|
||||
|
||||
numFaces = 5;
|
||||
frndHeight =
|
||||
fFaceHeight
|
||||
+ ((fFaceHeight / 1.5f)
|
||||
* (float) java.lang.Math.cos(
|
||||
java.lang.Math.abs(rand.nextInt())));
|
||||
frndWidth =
|
||||
fFaceWidth
|
||||
+ ((fFaceWidth / 4.0f)
|
||||
* (float) java.lang.Math.cos(
|
||||
java.lang.Math.abs(rand.nextInt())));
|
||||
fDecWidth = frndWidth / 5.0f;
|
||||
fRotate = myrand() * 3.1415f;
|
||||
fRigid = ((fRigid = myrand()) < 0.2f) ? 0.2f : fRigid;
|
||||
|
||||
if (myrand() < 0.3)
|
||||
GL.glBegin(GL.GL_LINE_STRIP);
|
||||
else
|
||||
GL.glBegin(GL.GL_QUAD_STRIP);
|
||||
|
||||
for (cFaces = 0; cFaces < numFaces; cFaces++) {
|
||||
for (cWidth = frndWidth;
|
||||
cWidth >= -frndWidth;
|
||||
cWidth -= (frndWidth * 2.0f)) {
|
||||
GL.glColor4f(fX, fRigid, fZ, (float) cFaces / (float) numFaces);
|
||||
GL.glVertex3f(
|
||||
(float) (((cFaces - 2) * 0.1f)
|
||||
* java.lang.Math.cos(fRotate)
|
||||
+ (cWidth) * java.lang.Math.sin(fRotate)),
|
||||
cFaces * frndHeight,
|
||||
- (float)
|
||||
(((cFaces - 2) * 0.1f) * java.lang.Math.sin(fRotate)
|
||||
+ (cWidth) * java.lang.Math.cos(fRotate)));
|
||||
}
|
||||
frndWidth -= fDecWidth;
|
||||
}
|
||||
GL.glEnd();
|
||||
|
||||
}
|
||||
|
||||
private static void genMesh() {
|
||||
float cI, cJ, fArea;
|
||||
|
||||
fArea = 20.0f;
|
||||
mesh = GL.glGenLists(1);
|
||||
GL.glNewList(mesh, GL.GL_COMPILE);
|
||||
for (cI = -fArea / 2; cI < fArea / 2; cI += 0.25f) {
|
||||
for (cJ = -fArea / 2; cJ < fArea / 2; cJ += 0.25f) {
|
||||
genGrass(0.5f, 0.1f, cI, cJ);
|
||||
}
|
||||
}
|
||||
GL.glEndList();
|
||||
}
|
||||
|
||||
private static void grsDraw() {
|
||||
GL.glEnable(GL.GL_VERTEX_PROGRAM_NV);
|
||||
GL.glBindProgramNV(GL.GL_VERTEX_PROGRAM_NV, program_handle);
|
||||
GL.glTrackMatrixNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
0,
|
||||
GL.GL_MODELVIEW_PROJECTION_NV,
|
||||
GL.GL_IDENTITY_NV);
|
||||
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
4,
|
||||
0.0f,
|
||||
0.0f,
|
||||
0.0f,
|
||||
0.0f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
5,
|
||||
0.0f,
|
||||
0.0f,
|
||||
0.0f,
|
||||
0.0f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
6,
|
||||
1.763609f,
|
||||
0.496495f,
|
||||
0.0f,
|
||||
0.0f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
7,
|
||||
-0.943599f,
|
||||
3.203737f,
|
||||
0.0f,
|
||||
0.0f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
8,
|
||||
4.101107f,
|
||||
0.943413f,
|
||||
0.0f,
|
||||
0.0f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
9,
|
||||
-1.218603f,
|
||||
6.259399f,
|
||||
0.0f,
|
||||
0.0f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
10,
|
||||
7.214299f,
|
||||
1.352961f,
|
||||
0.0f,
|
||||
0.0f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
11,
|
||||
-1.540748f,
|
||||
10.080958f,
|
||||
0.0f,
|
||||
0.0f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
12,
|
||||
10.880035f,
|
||||
1.759046f,
|
||||
0.0f,
|
||||
0.0f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
13,
|
||||
-1.852705f,
|
||||
14.468674f,
|
||||
0.0f,
|
||||
0.0f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
14,
|
||||
14.292879f,
|
||||
1.973329f,
|
||||
0.0f,
|
||||
0.0f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
15,
|
||||
-1.973387f,
|
||||
18.506531f,
|
||||
0.0f,
|
||||
0.0f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
16,
|
||||
(float) (java.lang.Math.sin(aslod.angle)
|
||||
* (aslod.value + aslod.ripple)),
|
||||
0.0f,
|
||||
(float) (java.lang.Math.cos(aslod.angle)
|
||||
* (aslod.value + aslod.ripple)),
|
||||
0.0f);
|
||||
|
||||
GL.glProgramParameter4fNV(GL.GL_VERTEX_PROGRAM_NV, 17, 1.7f, 5f, 2f, 0f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
18,
|
||||
-0.0187293f,
|
||||
0.074261f,
|
||||
0.2121144f,
|
||||
1.570729f);
|
||||
GL.glProgramParameter4fNV(GL.GL_VERTEX_PROGRAM_NV, 20, 0f, 0.5f, 1f, 0f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
21,
|
||||
0.25f,
|
||||
-9f,
|
||||
0.75f,
|
||||
0.1591549f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
22,
|
||||
24.9808f,
|
||||
-24.9808f,
|
||||
-60.14581f,
|
||||
60.14581f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
23,
|
||||
85.45379f,
|
||||
-85.45379f,
|
||||
-64.93935f,
|
||||
64.93935f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
24,
|
||||
19.73921f,
|
||||
-19.73921f,
|
||||
-1f,
|
||||
1f);
|
||||
GL.glProgramParameter4fNV(GL.GL_VERTEX_PROGRAM_NV, 25, 0f, 4f, 0f, 0f);
|
||||
GL.glProgramParameter4fNV(
|
||||
GL.GL_VERTEX_PROGRAM_NV,
|
||||
19,
|
||||
1f,
|
||||
3.141593f,
|
||||
0.5f,
|
||||
1f);
|
||||
GL.glProgramParameter4fNV(GL.GL_VERTEX_PROGRAM_NV, 26, 0.7f, 0.4f, 0f, 0f);
|
||||
GL.glCallList(mesh);
|
||||
GL.glDisable(GL.GL_VERTEX_PROGRAM_NV);
|
||||
|
||||
}
|
||||
|
||||
private static void ptrAnimate(float degree) {
|
||||
aslod.count += degree;
|
||||
aslod.ripple = (float) (java.lang.Math.cos(aslod.count) / 80.0);
|
||||
|
||||
}
|
||||
|
||||
private static void keyPoll() {
|
||||
Keyboard.read();
|
||||
for (int i = 0; i < Keyboard.getNumKeyboardEvents(); i++) {
|
||||
Keyboard.next();
|
||||
if (!Keyboard.state)
|
||||
continue;
|
||||
switch (Keyboard.key) {
|
||||
case Keyboard.KEY_A :
|
||||
aslod.angle += 0.1;
|
||||
break;
|
||||
case Keyboard.KEY_D :
|
||||
aslod.angle -= 0.1;
|
||||
break;
|
||||
case Keyboard.KEY_W :
|
||||
aslod.value += (aslod.value >= 0.15) ? 0.0 : 0.0025;
|
||||
break;
|
||||
case Keyboard.KEY_S :
|
||||
aslod.value -= (aslod.value <= 0.005) ? 0.0 : 0.0025;
|
||||
break;
|
||||
case Keyboard.KEY_ESCAPE :
|
||||
finished = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
|
@ -0,0 +1,417 @@
|
|||
/*
|
||||
* Copyright (c) 2003 Lightweight Java Game Library 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 'Lightweight Java Game Library' 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.test.opengl;
|
||||
|
||||
import org.lwjgl.*;
|
||||
import org.lwjgl.input.*;
|
||||
import org.lwjgl.opengl.*;
|
||||
import org.lwjgl.vector.Vector2f;
|
||||
|
||||
import java.nio.*;
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
*
|
||||
* Tests Pbuffers
|
||||
*
|
||||
* @author elias_naur <elias_naur@users.sourceforge.net>
|
||||
* @version $Revision$
|
||||
*/
|
||||
public class PbufferTest {
|
||||
|
||||
/** Intended deiplay mode */
|
||||
private DisplayMode mode;
|
||||
|
||||
/** GLU instance */
|
||||
private GLU glu;
|
||||
|
||||
/** our quad moving around */
|
||||
private Vector2f quadPosition;
|
||||
|
||||
/** our quadVelocity */
|
||||
private Vector2f quadVelocity;
|
||||
|
||||
/** angle of quad */
|
||||
private float angle;
|
||||
|
||||
/** degrees to rotate per frame */
|
||||
private float angleRotation = 1.0f;
|
||||
|
||||
/** Max speed of all changable attributes */
|
||||
private static final float MAX_SPEED = 20.0f;
|
||||
|
||||
/** Pbuffer instance */
|
||||
private static Pbuffer pbuffer;
|
||||
|
||||
/** The shared texture */
|
||||
private static int tex_handle;
|
||||
|
||||
/**
|
||||
* Executes the test
|
||||
*/
|
||||
public void execute() {
|
||||
initialize();
|
||||
|
||||
mainLoop();
|
||||
|
||||
cleanup();
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes the test
|
||||
*/
|
||||
private void initialize() {
|
||||
try {
|
||||
//find displaymode
|
||||
mode = findDisplayMode(800, 600, 16);
|
||||
|
||||
// start of in windowed mode
|
||||
Window.create("Test", 50, 50, mode.width, mode.height, mode.bpp, 0, 0, 0);
|
||||
// gl = new GLWindow("Test", 50, 50, mode.width, mode.height, mode.bpp, 0, 0, 0);
|
||||
if ((Pbuffer.getPbufferCaps() & Pbuffer.PBUFFER_SUPPORTED) == 0) {
|
||||
System.out.println("No Pbuffer support!");
|
||||
System.exit(1);
|
||||
}
|
||||
System.out.println("Pbuffer support detected");
|
||||
|
||||
glInit();
|
||||
initPbuffer();
|
||||
|
||||
Keyboard.create();
|
||||
|
||||
quadPosition = new Vector2f(100f, 100f);
|
||||
quadVelocity = new Vector2f(1.0f, 1.0f);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Runs the main loop of the "test"
|
||||
*/
|
||||
private void mainLoop() {
|
||||
while (!Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)
|
||||
&& !Window.isCloseRequested()) {
|
||||
// allow subsystem to get a chance to run too
|
||||
Window.update();
|
||||
|
||||
if (!Window.isMinimized()) {
|
||||
// check keyboard input
|
||||
processKeyboard();
|
||||
|
||||
// do "game" logic, and render it
|
||||
logic();
|
||||
render();
|
||||
|
||||
// paint window
|
||||
Window.paint();
|
||||
} else {
|
||||
|
||||
// no need to render/paint if nothing has changed (ie. window dragged over)
|
||||
if (Window.isDirty()) {
|
||||
render();
|
||||
Window.paint();
|
||||
}
|
||||
|
||||
// don't waste cpu time, sleep more
|
||||
try {
|
||||
Thread.sleep(100);
|
||||
} catch (InterruptedException inte) {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs the logic
|
||||
*/
|
||||
private void logic() {
|
||||
angle += angleRotation;
|
||||
if (angle > 90.0f) {
|
||||
angle = 0.0f;
|
||||
}
|
||||
|
||||
quadPosition.x += quadVelocity.x;
|
||||
quadPosition.y += quadVelocity.y;
|
||||
|
||||
//check colision with vertical border border
|
||||
if (quadPosition.x + 50 >= mode.width || quadPosition.x - 50 <= 0) {
|
||||
quadVelocity.x *= -1;
|
||||
}
|
||||
|
||||
//check collision with horizontal border
|
||||
if (quadPosition.y + 50 >= mode.height || quadPosition.y - 50 <= 0) {
|
||||
quadVelocity.y *= -1;
|
||||
}
|
||||
}
|
||||
|
||||
private void render() {
|
||||
if (pbuffer.isBufferLost()) {
|
||||
System.out.println("Buffer contents lost - will recreate the buffer");
|
||||
Pbuffer.releaseContext();
|
||||
pbuffer.destroy();
|
||||
initPbuffer();
|
||||
}
|
||||
pbuffer.makeCurrent();
|
||||
// Pbuffer rendering
|
||||
//clear background
|
||||
GL.glClear(GL.GL_COLOR_BUFFER_BIT);
|
||||
|
||||
// draw white quad
|
||||
GL.glPushMatrix();
|
||||
{
|
||||
GL.glTranslatef(quadPosition.x, quadPosition.y, 0);
|
||||
GL.glRotatef(angle, 0.0f, 0.0f, 1.0f);
|
||||
GL.glColor3f(1.0f, 1.0f, 1.0f);
|
||||
GL.glBegin(GL.GL_QUADS);
|
||||
{
|
||||
GL.glVertex2i(-50, -50);
|
||||
GL.glVertex2i(50, -50);
|
||||
GL.glVertex2i(50, 50);
|
||||
GL.glVertex2i(-50, 50);
|
||||
}
|
||||
GL.glEnd();
|
||||
}
|
||||
GL.glPopMatrix();
|
||||
GL.glCopyTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGB, 0, 0, 256, 256, 0);
|
||||
Pbuffer.releaseContext();
|
||||
|
||||
// OpenGL window rendering
|
||||
GL.glClear(GL.GL_COLOR_BUFFER_BIT);
|
||||
// draw white quad
|
||||
GL.glPushMatrix();
|
||||
{
|
||||
GL.glTranslatef(quadPosition.x, quadPosition.y, 0);
|
||||
GL.glRotatef(angle, 0.0f, 0.0f, 1.0f);
|
||||
GL.glColor3f(1.0f, 1.0f, 0.0f);
|
||||
GL.glBegin(GL.GL_QUADS);
|
||||
{
|
||||
GL.glTexCoord2f(0f, 0f);
|
||||
GL.glVertex2i(-50, -50);
|
||||
GL.glTexCoord2f(1f, 0f);
|
||||
GL.glVertex2i(50, -50);
|
||||
GL.glTexCoord2f(1f, 1f);
|
||||
GL.glVertex2i(50, 50);
|
||||
GL.glTexCoord2f(0f, 1f);
|
||||
GL.glVertex2i(-50, 50);
|
||||
}
|
||||
GL.glEnd();
|
||||
}
|
||||
GL.glPopMatrix();
|
||||
}
|
||||
|
||||
private void initPbuffer() {
|
||||
try {
|
||||
pbuffer = new Pbuffer(256, 256, mode.bpp, 0, 0, 0);
|
||||
pbuffer.makeCurrent();
|
||||
initGLState(256, 256, 0.5f);
|
||||
GL.glBindTexture(GL.GL_TEXTURE_2D, tex_handle);
|
||||
Pbuffer.releaseContext();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Processes keyboard input
|
||||
*/
|
||||
private void processKeyboard() {
|
||||
Keyboard.poll();
|
||||
|
||||
//check for fullscreen key
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_F)) {
|
||||
|
||||
try {
|
||||
destroyTexture();
|
||||
Keyboard.destroy();
|
||||
Pbuffer.releaseContext();
|
||||
pbuffer.destroy();
|
||||
Window.destroy();
|
||||
|
||||
Display.setDisplayMode(mode);
|
||||
Window.create("Test", mode.bpp, 0, 0, 0);
|
||||
glInit();
|
||||
initPbuffer();
|
||||
|
||||
Keyboard.create();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
//check for window key
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_W)) {
|
||||
try {
|
||||
destroyTexture();
|
||||
Keyboard.destroy();
|
||||
Pbuffer.releaseContext();
|
||||
pbuffer.destroy();
|
||||
Window.destroy();
|
||||
|
||||
Display.resetDisplayMode();
|
||||
Window.create("Test", 50, 50, mode.width, mode.height, mode.bpp, 0, 0, 0);
|
||||
glInit();
|
||||
initPbuffer();
|
||||
|
||||
|
||||
Keyboard.create();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
//check for speed changes
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_UP)) {
|
||||
quadVelocity.y += 0.1f;
|
||||
}
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_DOWN)) {
|
||||
quadVelocity.y -= 0.1f;
|
||||
}
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_RIGHT)) {
|
||||
quadVelocity.x += 0.1f;
|
||||
}
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_LEFT)) {
|
||||
quadVelocity.x -= 0.1f;
|
||||
}
|
||||
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_ADD)) {
|
||||
angleRotation += 0.1f;
|
||||
}
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_SUBTRACT)) {
|
||||
angleRotation -= 0.1f;
|
||||
}
|
||||
|
||||
//throttle
|
||||
if (quadVelocity.x < -MAX_SPEED) {
|
||||
quadVelocity.x = -MAX_SPEED;
|
||||
}
|
||||
if (quadVelocity.x > MAX_SPEED) {
|
||||
quadVelocity.x = MAX_SPEED;
|
||||
}
|
||||
if (quadVelocity.y < -MAX_SPEED) {
|
||||
quadVelocity.y = -MAX_SPEED;
|
||||
}
|
||||
if (quadVelocity.y > MAX_SPEED) {
|
||||
quadVelocity.y = MAX_SPEED;
|
||||
}
|
||||
|
||||
if (angleRotation < 0.0f) {
|
||||
angleRotation = 0.0f;
|
||||
}
|
||||
if (angleRotation > MAX_SPEED) {
|
||||
angleRotation = MAX_SPEED;
|
||||
}
|
||||
}
|
||||
|
||||
private void destroyTexture() {
|
||||
IntBuffer buffer = ByteBuffer.allocateDirect(4).order(ByteOrder.nativeOrder()).asIntBuffer();
|
||||
buffer.put(0, tex_handle);
|
||||
GL.glDeleteTextures(buffer);
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleans up the test
|
||||
*/
|
||||
private void cleanup() {
|
||||
destroyTexture();
|
||||
Keyboard.destroy();
|
||||
Pbuffer.releaseContext();
|
||||
pbuffer.destroy();
|
||||
Window.destroy();
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieves a displaymode, if one such is available
|
||||
*
|
||||
* @param width Required width
|
||||
* @param height Required height
|
||||
* @param bpp Minimum required bits per pixel
|
||||
* @return
|
||||
*/
|
||||
private DisplayMode findDisplayMode(int width, int height, int bpp) {
|
||||
DisplayMode[] modes = Display.getAvailableDisplayModes();
|
||||
for (int i = 0; i < modes.length; i++) {
|
||||
if (modes[i].width == width
|
||||
&& modes[i].height == height
|
||||
&& modes[i].bpp >= bpp) {
|
||||
return modes[i];
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private void initGLState(int width, int height, float color) {
|
||||
GL.glMatrixMode(GL.GL_PROJECTION);
|
||||
GL.glLoadIdentity();
|
||||
GLU.gluOrtho2D(0, mode.width, 0, mode.height);
|
||||
GL.glMatrixMode(GL.GL_MODELVIEW);
|
||||
GL.glLoadIdentity();
|
||||
GL.glViewport(0, 0, width, height);
|
||||
|
||||
//set clear color to black
|
||||
GL.glClearColor(color, color, color, 0.0f);
|
||||
}
|
||||
|
||||
/**
|
||||
* Initializes OGL
|
||||
*/
|
||||
private void glInit() {
|
||||
//sync frame (only works on windows)
|
||||
GLCaps.determineAvailableExtensions();
|
||||
if (GLCaps.WGL_EXT_swap_control) {
|
||||
GL.wglSwapIntervalEXT(1);
|
||||
}
|
||||
GL.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_REPLACE);
|
||||
GL.glEnable(GL.GL_TEXTURE_2D);
|
||||
// Create shared texture
|
||||
IntBuffer buffer = ByteBuffer.allocateDirect(4).order(ByteOrder.nativeOrder()).asIntBuffer();
|
||||
GL.glGenTextures(buffer);
|
||||
tex_handle = buffer.get(0);
|
||||
GL.glBindTexture(GL.GL_TEXTURE_2D, tex_handle);
|
||||
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP);
|
||||
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP);
|
||||
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
|
||||
GL.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
|
||||
initGLState(mode.width, mode.height, 0f);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test entry point
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
System.out.println(
|
||||
"Change between fullscreen and windowed mode, by pressing F and W respectively");
|
||||
System.out.println("Move quad using arrowkeys, and change rotation using +/-");
|
||||
PbufferTest fswTest = new PbufferTest();
|
||||
fswTest.execute();
|
||||
}
|
||||
}
|
|
@ -0,0 +1,242 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Light Weight Java Game Library' 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
*
|
||||
* Simple java test program.
|
||||
*
|
||||
* @author elias_naur <elias_naur@users.sourceforge.net>
|
||||
* @version $Revision$
|
||||
*/
|
||||
|
||||
package org.lwjgl.test.opengl;
|
||||
|
||||
import org.lwjgl.*;
|
||||
import org.lwjgl.opengl.*;
|
||||
import org.lwjgl.input.*;
|
||||
|
||||
import java.nio.*;
|
||||
|
||||
public final class VBOIndexTest {
|
||||
static {
|
||||
try {
|
||||
//find first display mode that allows us 640*480*16
|
||||
int mode = -1;
|
||||
DisplayMode[] modes = Display.getAvailableDisplayModes();
|
||||
for (int i = 0; i < modes.length; i++) {
|
||||
if (modes[i].width == 640
|
||||
&& modes[i].height == 480
|
||||
&& modes[i].bpp >= 16) {
|
||||
mode = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (mode != -1) {
|
||||
//select above found displaymode
|
||||
System.out.println("Setting display mode to "+modes[mode]);
|
||||
Display.setDisplayMode(modes[mode]);
|
||||
System.out.println("Created display.");
|
||||
}
|
||||
} catch (Exception e) {
|
||||
System.err.println("Failed to create display due to " + e);
|
||||
}
|
||||
}
|
||||
|
||||
static {
|
||||
try {
|
||||
Window.create("LWJGL Game Example", 16, 0, 0,0);
|
||||
System.out.println("Created OpenGL.");
|
||||
} catch (Exception e) {
|
||||
System.err.println("Failed to create OpenGL due to "+e);
|
||||
System.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
/** Is the game finished? */
|
||||
private static boolean finished;
|
||||
|
||||
/** A rotating square! */
|
||||
private static float angle;
|
||||
private static int buffer_id;
|
||||
private static int indices_buffer_id;
|
||||
private static FloatBuffer vertices;
|
||||
private static ByteBuffer mapped_buffer = null;
|
||||
private static FloatBuffer mapped_float_buffer = null;
|
||||
private static IntBuffer indices;
|
||||
private static ByteBuffer mapped_indices_buffer = null;
|
||||
private static IntBuffer mapped_indices_int_buffer = null;
|
||||
|
||||
public static void main(String[] arguments) {
|
||||
try {
|
||||
init();
|
||||
while (!finished) {
|
||||
Window.update();
|
||||
|
||||
if (Window.isMinimized())
|
||||
Thread.sleep(200);
|
||||
else if (Window.isCloseRequested())
|
||||
System.exit(0);
|
||||
|
||||
Keyboard.poll();
|
||||
mainLoop();
|
||||
render();
|
||||
Window.paint();
|
||||
}
|
||||
} catch (Throwable t) {
|
||||
t.printStackTrace();
|
||||
} finally {
|
||||
cleanup();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* All calculations are done in here
|
||||
*/
|
||||
private static void mainLoop() {
|
||||
angle += 1f;
|
||||
if (angle > 360.0f)
|
||||
angle = 0.0f;
|
||||
|
||||
Mouse.poll();
|
||||
if (Mouse.dx != 0 || Mouse.dy != 0 || Mouse.dwheel != 0)
|
||||
System.out.println("Mouse moved " + Mouse.dx + " " + Mouse.dy + " " + Mouse.dwheel);
|
||||
for (int i = 0; i < Mouse.buttonCount; i++)
|
||||
if (Mouse.isButtonDown(i))
|
||||
System.out.println("Button " + i + " down");
|
||||
/* Keyboard.poll();
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_ESCAPE))
|
||||
finished = true;*/
|
||||
Keyboard.read();
|
||||
for (int i = 0; i < Keyboard.getNumKeyboardEvents(); i++) {
|
||||
Keyboard.next();
|
||||
if (Keyboard.key == Keyboard.KEY_ESCAPE && Keyboard.state)
|
||||
finished = true;
|
||||
if (Keyboard.key == Keyboard.KEY_T && Keyboard.state)
|
||||
System.out.println("Current time: " + Sys.getTime());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* All rendering is done in here
|
||||
*/
|
||||
private static void render() {
|
||||
GL.glClear(GL.GL_COLOR_BUFFER_BIT);
|
||||
GL.glPushMatrix();
|
||||
GL.glTranslatef(Display.getWidth() / 2, Display.getHeight() / 2, 0.0f);
|
||||
GL.glRotatef(angle, 0, 0, 1.0f);
|
||||
|
||||
|
||||
ByteBuffer new_mapped_buffer = GL.glMapBufferARB(GL.GL_ARRAY_BUFFER_ARB, GL.GL_WRITE_ONLY_ARB, 2*4*4, mapped_buffer);
|
||||
if (new_mapped_buffer != mapped_buffer)
|
||||
mapped_float_buffer = new_mapped_buffer.order(ByteOrder.nativeOrder()).asFloatBuffer();
|
||||
mapped_buffer = new_mapped_buffer;
|
||||
|
||||
new_mapped_buffer = GL.glMapBufferARB(GL.GL_ELEMENT_ARRAY_BUFFER_ARB, GL.GL_WRITE_ONLY_ARB, 4*4, mapped_indices_buffer);
|
||||
if (new_mapped_buffer != mapped_indices_buffer)
|
||||
mapped_indices_int_buffer = new_mapped_buffer.order(ByteOrder.nativeOrder()).asIntBuffer();
|
||||
|
||||
mapped_float_buffer.rewind();
|
||||
vertices.rewind();
|
||||
mapped_float_buffer.put(vertices);
|
||||
|
||||
mapped_indices_int_buffer.rewind();
|
||||
indices.rewind();
|
||||
mapped_indices_int_buffer.put(indices);
|
||||
if (GL.glUnmapBufferARB(GL.GL_ARRAY_BUFFER_ARB) && GL.glUnmapBufferARB(GL.GL_ELEMENT_ARRAY_BUFFER_ARB)) {
|
||||
GL.glDrawElements(GL.GL_QUADS, 4, GL.GL_UNSIGNED_INT, 0);
|
||||
}
|
||||
GL.glPopMatrix();
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize
|
||||
*/
|
||||
private static void init() throws Exception {
|
||||
Keyboard.create();
|
||||
Keyboard.enableBuffer();
|
||||
Mouse.create();
|
||||
Sys.setTime(0);
|
||||
Sys.setProcessPriority(Sys.HIGH_PRIORITY);
|
||||
System.out.println("Timer resolution: " + Sys.getTimerResolution());
|
||||
// Go into orthographic projection mode.
|
||||
GLCaps.determineAvailableExtensions();
|
||||
GL.glMatrixMode(GL.GL_PROJECTION);
|
||||
GL.glLoadIdentity();
|
||||
GLU.gluOrtho2D(0, Display.getWidth(), 0, Display.getHeight());
|
||||
GL.glMatrixMode(GL.GL_MODELVIEW);
|
||||
GL.glLoadIdentity();
|
||||
GL.glViewport(0, 0, Display.getWidth(), Display.getHeight());
|
||||
if (!GLCaps.GL_ARB_vertex_buffer_object) {
|
||||
System.out.println("ARB VBO not supported!");
|
||||
System.exit(1);
|
||||
}
|
||||
IntBuffer int_buffer = ByteBuffer.allocateDirect(8).order(ByteOrder.nativeOrder()).asIntBuffer();
|
||||
GL.glGenBuffersARB(int_buffer);
|
||||
buffer_id = int_buffer.get(0);
|
||||
indices_buffer_id = int_buffer.get(1);
|
||||
GL.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, buffer_id);
|
||||
GL.glBindBufferARB(GL.GL_ELEMENT_ARRAY_BUFFER_ARB, indices_buffer_id);
|
||||
vertices = ByteBuffer.allocateDirect(2*4*4).order(ByteOrder.nativeOrder()).asFloatBuffer();
|
||||
vertices.put(-50).put(-50).put(50).put(-50).put(50).put(50).put(-50).put(50);
|
||||
vertices.rewind();
|
||||
indices = ByteBuffer.allocateDirect(4*4).order(ByteOrder.nativeOrder()).asIntBuffer();
|
||||
indices.put(0).put(1).put(2).put(3);
|
||||
indices.rewind();
|
||||
GL.glBufferDataARB(GL.GL_ARRAY_BUFFER_ARB, 2*4*4, (ByteBuffer)null, GL.GL_STREAM_DRAW_ARB);
|
||||
GL.glBufferDataARB(GL.GL_ELEMENT_ARRAY_BUFFER_ARB, 4*4, (ByteBuffer)null, GL.GL_STREAM_DRAW_ARB);
|
||||
GL.glEnableClientState(GL.GL_VERTEX_ARRAY);
|
||||
GL.glVertexPointer(2, GL.GL_FLOAT, 0, 0);
|
||||
GL.glGetInteger(GL.GL_MAX_TEXTURE_UNITS_ARB, int_buffer);
|
||||
System.out.println("Number of texture units: " + int_buffer.get(0));
|
||||
// Fix the refresh rate to the display frequency.
|
||||
// gl.wglSwapIntervalEXT(1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleanup
|
||||
*/
|
||||
private static void cleanup() {
|
||||
IntBuffer int_buffer = ByteBuffer.allocateDirect(8).order(ByteOrder.nativeOrder()).asIntBuffer();
|
||||
int_buffer.put(0, buffer_id);
|
||||
int_buffer.put(1, indices_buffer_id);
|
||||
GL.glDeleteBuffersARB(int_buffer);
|
||||
Keyboard.destroy();
|
||||
Mouse.destroy();
|
||||
Window.destroy();
|
||||
try {
|
||||
Display.resetDisplayMode();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
|
@ -0,0 +1,218 @@
|
|||
/*
|
||||
* Copyright (c) 2002 Lightweight Java Game Library 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 'Light Weight Java Game Library' 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.
|
||||
*/
|
||||
|
||||
/**
|
||||
* $Id$
|
||||
*
|
||||
* Simple java test program.
|
||||
*
|
||||
* @author elias_naur <elias_naur@users.sourceforge.net>
|
||||
* @version $Revision$
|
||||
*/
|
||||
|
||||
package org.lwjgl.test.opengl;
|
||||
|
||||
import org.lwjgl.*;
|
||||
import org.lwjgl.opengl.*;
|
||||
import org.lwjgl.input.*;
|
||||
|
||||
import java.nio.*;
|
||||
|
||||
public final class VBOTest {
|
||||
static {
|
||||
try {
|
||||
//find first display mode that allows us 640*480*16
|
||||
int mode = -1;
|
||||
DisplayMode[] modes = Display.getAvailableDisplayModes();
|
||||
for (int i = 0; i < modes.length; i++) {
|
||||
if (modes[i].width == 640
|
||||
&& modes[i].height == 480
|
||||
&& modes[i].bpp >= 16) {
|
||||
mode = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (mode != -1) {
|
||||
//select above found displaymode
|
||||
System.out.println("Setting display mode to "+modes[mode]);
|
||||
Display.setDisplayMode(modes[mode]);
|
||||
System.out.println("Created display.");
|
||||
}
|
||||
} catch (Exception e) {
|
||||
System.err.println("Failed to create display due to " + e);
|
||||
}
|
||||
}
|
||||
|
||||
static {
|
||||
try {
|
||||
Window.create("LWJGL Game Example", 16, 0, 0,0);
|
||||
System.out.println("Created OpenGL.");
|
||||
} catch (Exception e) {
|
||||
System.err.println("Failed to create OpenGL due to "+e);
|
||||
System.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
/** Is the game finished? */
|
||||
private static boolean finished;
|
||||
|
||||
/** A rotating square! */
|
||||
private static float angle;
|
||||
private static int buffer_id;
|
||||
private static FloatBuffer vertices;
|
||||
private static ByteBuffer mapped_buffer = null;
|
||||
private static FloatBuffer mapped_float_buffer = null;
|
||||
|
||||
public static void main(String[] arguments) {
|
||||
try {
|
||||
init();
|
||||
while (!finished) {
|
||||
Window.update();
|
||||
|
||||
if (Window.isMinimized())
|
||||
Thread.sleep(200);
|
||||
else if (Window.isCloseRequested())
|
||||
System.exit(0);
|
||||
|
||||
Keyboard.poll();
|
||||
mainLoop();
|
||||
render();
|
||||
Window.paint();
|
||||
}
|
||||
} catch (Throwable t) {
|
||||
t.printStackTrace();
|
||||
} finally {
|
||||
cleanup();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* All calculations are done in here
|
||||
*/
|
||||
private static void mainLoop() {
|
||||
angle += 1f;
|
||||
if (angle > 360.0f)
|
||||
angle = 0.0f;
|
||||
|
||||
Mouse.poll();
|
||||
if (Mouse.dx != 0 || Mouse.dy != 0 || Mouse.dwheel != 0)
|
||||
System.out.println("Mouse moved " + Mouse.dx + " " + Mouse.dy + " " + Mouse.dwheel);
|
||||
for (int i = 0; i < Mouse.buttonCount; i++)
|
||||
if (Mouse.isButtonDown(i))
|
||||
System.out.println("Button " + i + " down");
|
||||
/* Keyboard.poll();
|
||||
if (Keyboard.isKeyDown(Keyboard.KEY_ESCAPE))
|
||||
finished = true;*/
|
||||
Keyboard.read();
|
||||
for (int i = 0; i < Keyboard.getNumKeyboardEvents(); i++) {
|
||||
Keyboard.next();
|
||||
if (Keyboard.key == Keyboard.KEY_ESCAPE && Keyboard.state)
|
||||
finished = true;
|
||||
if (Keyboard.key == Keyboard.KEY_T && Keyboard.state)
|
||||
System.out.println("Current time: " + Sys.getTime());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* All rendering is done in here
|
||||
*/
|
||||
private static void render() {
|
||||
GL.glClear(GL.GL_COLOR_BUFFER_BIT);
|
||||
GL.glPushMatrix();
|
||||
GL.glTranslatef(Display.getWidth() / 2, Display.getHeight() / 2, 0.0f);
|
||||
GL.glRotatef(angle, 0, 0, 1.0f);
|
||||
ByteBuffer new_mapped_buffer = GL.glMapBufferARB(GL.GL_ARRAY_BUFFER_ARB, GL.GL_WRITE_ONLY_ARB, 2*4*4, mapped_buffer);
|
||||
if (new_mapped_buffer != mapped_buffer)
|
||||
mapped_float_buffer = new_mapped_buffer.order(ByteOrder.nativeOrder()).asFloatBuffer();
|
||||
mapped_buffer = new_mapped_buffer;
|
||||
mapped_float_buffer.rewind();
|
||||
vertices.rewind();
|
||||
mapped_float_buffer.put(vertices);
|
||||
if (GL.glUnmapBufferARB(GL.GL_ARRAY_BUFFER_ARB))
|
||||
GL.glDrawArrays(GL.GL_QUADS, 0, 4);
|
||||
GL.glPopMatrix();
|
||||
}
|
||||
|
||||
/**
|
||||
* Initialize
|
||||
*/
|
||||
private static void init() throws Exception {
|
||||
Keyboard.create();
|
||||
Keyboard.enableBuffer();
|
||||
Mouse.create();
|
||||
Sys.setTime(0);
|
||||
Sys.setProcessPriority(Sys.HIGH_PRIORITY);
|
||||
System.out.println("Timer resolution: " + Sys.getTimerResolution());
|
||||
// Go into orthographic projection mode.
|
||||
GLCaps.determineAvailableExtensions();
|
||||
GL.glMatrixMode(GL.GL_PROJECTION);
|
||||
GL.glLoadIdentity();
|
||||
GLU.gluOrtho2D(0, Display.getWidth(), 0, Display.getHeight());
|
||||
GL.glMatrixMode(GL.GL_MODELVIEW);
|
||||
GL.glLoadIdentity();
|
||||
GL.glViewport(0, 0, Display.getWidth(), Display.getHeight());
|
||||
if (!GLCaps.GL_ARB_vertex_buffer_object) {
|
||||
System.out.println("ARB VBO not supported!");
|
||||
System.exit(1);
|
||||
}
|
||||
IntBuffer int_buffer = ByteBuffer.allocateDirect(4).order(ByteOrder.nativeOrder()).asIntBuffer();
|
||||
GL.glGenBuffersARB(int_buffer);
|
||||
buffer_id = int_buffer.get(0);
|
||||
GL.glBindBufferARB(GL.GL_ARRAY_BUFFER_ARB, buffer_id);
|
||||
vertices = ByteBuffer.allocateDirect(2*4*4).order(ByteOrder.nativeOrder()).asFloatBuffer();
|
||||
vertices.put(-50).put(-50).put(50).put(-50).put(50).put(50).put(-50).put(50);
|
||||
GL.glBufferDataARB(GL.GL_ARRAY_BUFFER_ARB, 2*4*4, (ByteBuffer)null, GL.GL_STREAM_DRAW_ARB);
|
||||
GL.glEnableClientState(GL.GL_VERTEX_ARRAY);
|
||||
GL.glVertexPointer(2, GL.GL_FLOAT, 0, 0);
|
||||
GL.glGetInteger(GL.GL_MAX_TEXTURE_UNITS_ARB, int_buffer);
|
||||
System.out.println("Number of texture units: " + int_buffer.get(0));
|
||||
// Fix the refresh rate to the display frequency.
|
||||
// gl.wglSwapIntervalEXT(1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Cleanup
|
||||
*/
|
||||
private static void cleanup() {
|
||||
IntBuffer int_buffer = ByteBuffer.allocateDirect(4).order(ByteOrder.nativeOrder()).asIntBuffer();
|
||||
int_buffer.put(0, buffer_id);
|
||||
GL.glDeleteBuffersARB(int_buffer);
|
||||
Keyboard.destroy();
|
||||
Mouse.destroy();
|
||||
Window.destroy();
|
||||
try {
|
||||
Display.resetDisplayMode();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
|
@ -0,0 +1,72 @@
|
|||
#pragma bind app2vert.position = ATTR0
|
||||
#pragma bind app2vert.normal = ATTR2
|
||||
#pragma bind app2vert.color = ATTR3
|
||||
|
||||
|
||||
struct app2vert : application2vertex
|
||||
{
|
||||
float4 position; //in object space
|
||||
float3 normal; //in object space
|
||||
float4 color;
|
||||
};
|
||||
|
||||
#pragma bind vert2frag.HPOS = HPOS
|
||||
#pragma bind vert2frag.COL0 = COL0
|
||||
|
||||
struct vert2frag : vertex2fragment
|
||||
{
|
||||
float4 HPOS;
|
||||
float4 COL0;
|
||||
};
|
||||
|
||||
vert2frag main(app2vert IN,
|
||||
uniform float4x4 ModelViewProj,
|
||||
uniform float4 Stiff[12],
|
||||
uniform float4 Load)
|
||||
{
|
||||
vert2frag OUT;
|
||||
float4 position;
|
||||
float3 normal;
|
||||
float3 disloc;
|
||||
float4 dif;
|
||||
float index;
|
||||
float teta;
|
||||
float alpha;
|
||||
|
||||
alpha = IN.position.y / 1.7;
|
||||
|
||||
// matrix line index
|
||||
index = IN.color.a * 5 * 2;
|
||||
|
||||
// straw stiffness (randomic)
|
||||
Load = Load * IN.color.y;
|
||||
|
||||
disloc.x = IN.position.x + dot(Stiff[index].xy, Load.xz);
|
||||
disloc.y = IN.position.y;
|
||||
disloc.z = IN.position.z + dot(Stiff[index + 1].xy, Load.xz);
|
||||
|
||||
// find the normal
|
||||
teta = acos(IN.position.y / length(disloc));
|
||||
|
||||
normal = IN.position.xyz - disloc.xyz;
|
||||
normal.y = sin(teta) * length(disloc);
|
||||
normal = normalize(normal);
|
||||
|
||||
position.x = disloc.x + IN.color.x;
|
||||
position.y = disloc.y;
|
||||
position.z = disloc.z + IN.color.z;
|
||||
position.w = 1;
|
||||
|
||||
OUT.HPOS = mul(ModelViewProj, position);
|
||||
|
||||
// calculate diffuse lighting off the normal that was just calculated
|
||||
float4 lightPos = float4(0,4,0,0);
|
||||
float4 lightVec = normalize(lightPos - position);
|
||||
float diffuseInten = dot(lightVec.xyz, normal);
|
||||
|
||||
diffuseInten = (diffuseInten < 0.5) ? 0.5 : diffuseInten;
|
||||
|
||||
OUT.COL0 = float4(IN.color.y * 0.7, 0.7, 0.4, alpha) * diffuseInten;
|
||||
|
||||
return OUT;
|
||||
}
|
|
@ -0,0 +1,116 @@
|
|||
!!VP1.0
|
||||
# NV_vertex_program generated by NVIDIA Cg compiler
|
||||
# cgc version 1.5.0001, build date Sep 12 2002 15:49:58
|
||||
# command line args: -profile vp20 cg_grass2.cg
|
||||
# nv30vp backend compiling 'main' program
|
||||
#vendor NVIDIA Corporation
|
||||
#version 1.0.1
|
||||
#profile vp20
|
||||
#program main
|
||||
#semantic main.ModelViewProj
|
||||
#semantic main.Stiff
|
||||
#semantic main.Load
|
||||
#var float4 IN.position : $vin.ATTR0 : ATTR0 : 0 : 1
|
||||
#var float3 IN.normal : $vin.ATTR2 : ATTR2 : 0 : 1
|
||||
#var float4 IN.color : $vin.ATTR3 : ATTR3 : 0 : 1
|
||||
#var float4x4 ModelViewProj : : c[0], 4 : 1 : 1
|
||||
#var float4 Stiff[0] : : c[4] : 2 : 1
|
||||
#var float4 Stiff[1] : : c[5] : 2 : 1
|
||||
#var float4 Stiff[2] : : c[6] : 2 : 1
|
||||
#var float4 Stiff[3] : : c[7] : 2 : 1
|
||||
#var float4 Stiff[4] : : c[8] : 2 : 1
|
||||
#var float4 Stiff[5] : : c[9] : 2 : 1
|
||||
#var float4 Stiff[6] : : c[10] : 2 : 1
|
||||
#var float4 Stiff[7] : : c[11] : 2 : 1
|
||||
#var float4 Stiff[8] : : c[12] : 2 : 1
|
||||
#var float4 Stiff[9] : : c[13] : 2 : 1
|
||||
#var float4 Stiff[10] : : c[14] : 2 : 1
|
||||
#var float4 Stiff[11] : : c[15] : 2 : 1
|
||||
#var float4 Load : : c[16] : 3 : 1
|
||||
#var float4 HPOS : $vout.HPOS : HPOS : -1 : 1
|
||||
#var float4 COL0 : $vout.COL0 : COL0 : -1 : 1
|
||||
#const c[17] = 1.7 5 2 0
|
||||
#const c[18] = -0.0187293 0.074261 0.2121144 1.570729
|
||||
#const c[20] = 0 0.5 1 0
|
||||
#const c[21] = 0.25 -9 0.75 0.1591549
|
||||
#const c[22] = 24.9808 -24.9808 -60.14581 60.14581
|
||||
#const c[23] = 85.45379 -85.45379 -64.93935 64.93935
|
||||
#const c[24] = 19.73921 -19.73921 -1 1
|
||||
#const c[25] = 0 4 0 0
|
||||
#const c[19] = 1 3.141593 0.5 1
|
||||
#const c[26] = 0.7 0.4 0 0
|
||||
MUL R2, c[16], v[3].y;
|
||||
MUL R0, v[3].w, c[17].y;
|
||||
MUL R1, R0.x, c[17].z;
|
||||
ARL A0.x, R1.x;
|
||||
MUL R0, c[A0.x + 4].xyxx, R2.xzxx;
|
||||
ADD R0, R0.x, R0.y;
|
||||
ADD R3.x, v[0].x, R0.x;
|
||||
MOV R3.y, v[0].y;
|
||||
MUL R0, c[A0.x + 5].xyxx, R2.xzxx;
|
||||
ADD R0, R0.x, R0.y;
|
||||
ADD R3.z, v[0].z, R0.x;
|
||||
ADD R2.x, R3.x, v[3].x;
|
||||
MOV R2.y, R3.y;
|
||||
ADD R2.z, R3.z, v[3].z;
|
||||
MOV R2.w, c[19].x;
|
||||
DP4 R0.x, c[0], R2;
|
||||
DP4 R0.y, c[1], R2;
|
||||
DP4 R0.z, c[2], R2;
|
||||
DP4 R0.w, c[3], R2;
|
||||
MOV o[HPOS], R0;
|
||||
ADD R1.xz, v[0].xyzx, -R3.xyzx;
|
||||
DP3 R0, R3.xyzx, R3.xyzx;
|
||||
RSQ R0, R0.x;
|
||||
RCP R0, R0.x;
|
||||
RCP R3, R0.x;
|
||||
MUL R6, v[0].y, R3.x;
|
||||
MAX R5, R6.x, -R6.x;
|
||||
MAD R3, c[18].x, R5.x, c[18].y;
|
||||
MAD R3, R3.x, R5.x, -c[18].z;
|
||||
MAD R4, R3.x, R5.x, c[18].w;
|
||||
ADD R3, c[19].x, -R5.x;
|
||||
RSQ R3, R3.x;
|
||||
RCP R3, R3.x;
|
||||
MUL R5, R4.x, R3.x;
|
||||
SLT R4, R6.x, c[17].w;
|
||||
MUL R3, c[17].z, R4.x;
|
||||
MUL R3, R3.x, R5.x;
|
||||
ADD R3, R5.x, -R3.x;
|
||||
MAD R3, R4.x, c[19].y, R3.x;
|
||||
MAD R6, c[21].w, R3.x, -c[21].x;
|
||||
EXP R6.y, R6.x;
|
||||
ADD R3, c[20].xyzx, -R6.yyyy;
|
||||
MUL R5, R3.xyzx, R3.xyzx;
|
||||
SLT R4.x, R6.y, c[21].x;
|
||||
SGE R3, R6.yyyy, c[21].yzyy;
|
||||
MOV R4.yz, R3.xxyw;
|
||||
DP3 R4.y, R4.xyzx, c[24].zwzz;
|
||||
MAD R3, c[22].xyxx, R5.xyzx, c[22].zwzz;
|
||||
MAD R3, R3.xyzx, R5.xyzx, c[23].xyxx;
|
||||
MAD R3, R3.xyzx, R5.xyzx, c[23].zwzz;
|
||||
MAD R3, R3.xyzx, R5.xyzx, c[24].xyxx;
|
||||
MAD R3, R3.xyzx, R5.xyzx, c[24].zwzz;
|
||||
DP3 R5.x, R3.xyzx, -R4.xyzx;
|
||||
MUL R1.y, R5.x, R0.x;
|
||||
DP3 R0, R1.xyzx, R1.xyzx;
|
||||
RSQ R0, R0.x;
|
||||
MUL R3, R0.x, R1.xyzx;
|
||||
ADD R1, c[25], -R2;
|
||||
DP4 R0, R1, R1;
|
||||
RSQ R0, R0.x;
|
||||
MUL R0, R0.x, R1;
|
||||
DP3 R2, R0.xyzx, R3.xyzx;
|
||||
SLT R1, R2.x, c[19].z;
|
||||
ADD R0, c[19].w, -R1.x;
|
||||
MUL R0, R0.x, R2.x;
|
||||
MAD R2, R1.x, c[19].z, R0.x;
|
||||
MUL R1.x, v[3].y, c[26].x;
|
||||
MOV R1.y, c[26].x;
|
||||
MOV R1.z, c[26].y;
|
||||
RCP R0, c[17].x;
|
||||
MUL R1.w, v[0].y, R0.x;
|
||||
MUL o[COL0], R1, R2.x;
|
||||
END
|
||||
# 72 instructions
|
||||
# End of program
|
Loading…
Reference in New Issue