From e1ac89e4b974f85a53b5ca47cfd1f4038300d47e Mon Sep 17 00:00:00 2001 From: kbr Date: Wed, 28 Dec 2005 20:22:40 +0000 Subject: Added versions of joal-demos ported to gluegen-branch-1-0 branch of JOAL tree. All of these demos should now be able to be Java Web Started easily. git-svn-id: file:///home/mbien/NetBeansProjects/JOGAMP/joal-sync/svn-server-sync-demos/joal-demos/branches/gluegen-branch-1-0@45 235fdd13-0e8c-4fed-b5ee-0a390d04b286 --- src/java/demos/data/Battle.wav | Bin 0 -> 289962 bytes src/java/demos/data/FancyPants.wav | Bin 0 -> 58986 bytes src/java/demos/data/Footsteps.wav | Bin 0 -> 282748 bytes src/java/demos/data/Gun1.wav | Bin 0 -> 41576 bytes src/java/demos/data/Gun2.wav | Bin 0 -> 15461 bytes src/java/demos/data/chimes.wav | Bin 0 -> 321418 bytes src/java/demos/data/ocean.wav | Bin 0 -> 77194 bytes src/java/demos/data/rain.wav | Bin 0 -> 70938 bytes src/java/demos/data/stream.wav | Bin 0 -> 42632 bytes src/java/demos/data/thunder.wav | Bin 0 -> 170558 bytes src/java/demos/data/waterdrop.wav | Bin 0 -> 239582 bytes .../devmaster/lesson1/SingleStaticSource.java | 185 ++++++++++++++ .../devmaster/lesson2/LoopingAndFadeaway.java | 148 ++++++++++++ .../demos/devmaster/lesson3/MultipleSources.java | 211 ++++++++++++++++ .../devmaster/lesson5/SourcesSharingBuffers.java | 268 +++++++++++++++++++++ 15 files changed, 812 insertions(+) create mode 100755 src/java/demos/data/Battle.wav create mode 100755 src/java/demos/data/FancyPants.wav create mode 100755 src/java/demos/data/Footsteps.wav create mode 100755 src/java/demos/data/Gun1.wav create mode 100755 src/java/demos/data/Gun2.wav create mode 100755 src/java/demos/data/chimes.wav create mode 100755 src/java/demos/data/ocean.wav create mode 100755 src/java/demos/data/rain.wav create mode 100755 src/java/demos/data/stream.wav create mode 100755 src/java/demos/data/thunder.wav create mode 100755 src/java/demos/data/waterdrop.wav create mode 100755 src/java/demos/devmaster/lesson1/SingleStaticSource.java create mode 100755 src/java/demos/devmaster/lesson2/LoopingAndFadeaway.java create mode 100755 src/java/demos/devmaster/lesson3/MultipleSources.java create mode 100755 src/java/demos/devmaster/lesson5/SourcesSharingBuffers.java (limited to 'src/java') diff --git a/src/java/demos/data/Battle.wav b/src/java/demos/data/Battle.wav new file mode 100755 index 0000000..c15521b Binary files /dev/null and b/src/java/demos/data/Battle.wav differ diff --git a/src/java/demos/data/FancyPants.wav b/src/java/demos/data/FancyPants.wav new file mode 100755 index 0000000..712a3c6 Binary files /dev/null and b/src/java/demos/data/FancyPants.wav differ diff --git a/src/java/demos/data/Footsteps.wav b/src/java/demos/data/Footsteps.wav new file mode 100755 index 0000000..7bf7a0c Binary files /dev/null and b/src/java/demos/data/Footsteps.wav differ diff --git a/src/java/demos/data/Gun1.wav b/src/java/demos/data/Gun1.wav new file mode 100755 index 0000000..eecc4d1 Binary files /dev/null and b/src/java/demos/data/Gun1.wav differ diff --git a/src/java/demos/data/Gun2.wav b/src/java/demos/data/Gun2.wav new file mode 100755 index 0000000..bf3b4bb Binary files /dev/null and b/src/java/demos/data/Gun2.wav differ diff --git a/src/java/demos/data/chimes.wav b/src/java/demos/data/chimes.wav new file mode 100755 index 0000000..57899f2 Binary files /dev/null and b/src/java/demos/data/chimes.wav differ diff --git a/src/java/demos/data/ocean.wav b/src/java/demos/data/ocean.wav new file mode 100755 index 0000000..4fbbfcd Binary files /dev/null and b/src/java/demos/data/ocean.wav differ diff --git a/src/java/demos/data/rain.wav b/src/java/demos/data/rain.wav new file mode 100755 index 0000000..a6e36b6 Binary files /dev/null and b/src/java/demos/data/rain.wav differ diff --git a/src/java/demos/data/stream.wav b/src/java/demos/data/stream.wav new file mode 100755 index 0000000..9c793c4 Binary files /dev/null and b/src/java/demos/data/stream.wav differ diff --git a/src/java/demos/data/thunder.wav b/src/java/demos/data/thunder.wav new file mode 100755 index 0000000..a1c38f9 Binary files /dev/null and b/src/java/demos/data/thunder.wav differ diff --git a/src/java/demos/data/waterdrop.wav b/src/java/demos/data/waterdrop.wav new file mode 100755 index 0000000..4e4c6da Binary files /dev/null and b/src/java/demos/data/waterdrop.wav differ diff --git a/src/java/demos/devmaster/lesson1/SingleStaticSource.java b/src/java/demos/devmaster/lesson1/SingleStaticSource.java new file mode 100755 index 0000000..4c4c945 --- /dev/null +++ b/src/java/demos/devmaster/lesson1/SingleStaticSource.java @@ -0,0 +1,185 @@ +/** + * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * -Redistribution of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * -Redistribution 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 Sun Microsystems, Inc. or the names of contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * This software is provided "AS IS," without a warranty of any kind. + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING + * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR + * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND ITS + * LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A + * RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. + * IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT + * OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR + * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, + * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS + * BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + * + * You acknowledge that this software is not designed or intended for use in the + * design, construction, operation or maintenance of any nuclear facility. + * + */ + +package demos.devmaster.lesson1; + +import java.io.*; +import java.nio.ByteBuffer; + +import net.java.games.joal.*; +import net.java.games.joal.util.*; + +/** + * Adapted from DevMaster + * SingleStaticSource Tutorial + * by Jesse Maurais. + * + * @author Athomas Goldberg + * @author Kenneth Russell + */ + +public class SingleStaticSource { + + static AL al; + + // Buffers hold sound data. + static int[] buffer = new int[1]; + + // Sources are points emitting sound. + static int[] source = new int[1]; + + // Position of the source sound. + static float[] sourcePos = { 0.0f, 0.0f, 0.0f }; + + // Velocity of the source sound. + static float[] sourceVel = { 0.0f, 0.0f, 0.0f }; + + // Position of the listener. + static float[] listenerPos = { 0.0f, 0.0f, 0.0f }; + + // Velocity of the listener. + static float[] listenerVel = { 0.0f, 0.0f, 0.0f }; + + // Orientation of the listener. (first 3 elems are "at", second 3 are "up") + static float[] listenerOri = { 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f }; + + static int loadALData() { + + // variables to load into + + int[] format = new int[1]; + int[] size = new int[1]; + ByteBuffer[] data = new ByteBuffer[1]; + int[] freq = new int[1]; + int[] loop = new int[1]; + + // Load wav data into a buffer. + al.alGenBuffers(1, buffer, 0); + if (al.alGetError() != AL.AL_NO_ERROR) + return AL.AL_FALSE; + + ALut.alutLoadWAVFile( + SingleStaticSource.class.getClassLoader().getResourceAsStream("demos/data/FancyPants.wav"), + format, + data, + size, + freq, + loop); + if (data[0] == null) { + throw new RuntimeException("Error loading WAV file"); + } + System.out.println("sound size = " + size[0]); + System.out.println("sound freq = " + freq[0]); + al.alBufferData(buffer[0], format[0], data[0], size[0], freq[0]); + + // Bind buffer with a source. + al.alGenSources(1, source, 0); + + if (al.alGetError() != AL.AL_NO_ERROR) + return AL.AL_FALSE; + + al.alSourcei(source[0], AL.AL_BUFFER, buffer[0]); + al.alSourcef(source[0], AL.AL_PITCH, 1.0f); + al.alSourcef(source[0], AL.AL_GAIN, 1.0f); + al.alSourcefv(source[0], AL.AL_POSITION, sourcePos, 0); + al.alSourcefv(source[0], AL.AL_VELOCITY, sourceVel, 0); + al.alSourcei(source[0], AL.AL_LOOPING, loop[0]); + + // Do another error check and return. + if (al.alGetError() == AL.AL_NO_ERROR) + return AL.AL_TRUE; + + return AL.AL_FALSE; + } + + static void setListenerValues() { + al.alListenerfv(AL.AL_POSITION, listenerPos, 0); + al.alListenerfv(AL.AL_VELOCITY, listenerVel, 0); + al.alListenerfv(AL.AL_ORIENTATION, listenerOri, 0); + } + + static void killAllData() { + al.alDeleteBuffers(1, buffer, 0); + al.alDeleteSources(1, source, 0); + } + + public static void main(String[] args) { + // Initialize OpenAL and clear the error bit. + try { + ALut.alutInit(); + al = ALFactory.getAL(); + al.alGetError(); + } catch (ALException e) { + e.printStackTrace(); + return; + } + // Load the wav data. + if (loadALData() == AL.AL_FALSE) + System.exit(1); + + setListenerValues(); + + char[] c = new char[1]; + while (c[0] != 'q') { + try { + BufferedReader buf = + new BufferedReader(new InputStreamReader(System.in)); + System.out.println( + "Press a key and hit ENTER: \n" + + "'p' to play, 's' to stop, " + + "'h' to pause and 'q' to quit"); + buf.read(c); + switch (c[0]) { + case 'p' : + // Pressing 'p' will begin playing the sample. + al.alSourcePlay(source[0]); + break; + case 's' : + // Pressing 's' will stop the sample from playing. + al.alSourceStop(source[0]); + break; + case 'h' : + // Pressing 'n' will pause (hold) the sample. + al.alSourcePause(source[0]); + break; + case 'q' : + killAllData(); + break; + } + } catch (IOException e) { + System.exit(1); + } + } + } +} diff --git a/src/java/demos/devmaster/lesson2/LoopingAndFadeaway.java b/src/java/demos/devmaster/lesson2/LoopingAndFadeaway.java new file mode 100755 index 0000000..5095481 --- /dev/null +++ b/src/java/demos/devmaster/lesson2/LoopingAndFadeaway.java @@ -0,0 +1,148 @@ +/** + * Copyright (c) 2003-2005 Sun Microsystems, Inc. All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * -Redistribution of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * -Redistribution 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 Sun Microsystems, Inc. or the names of contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * This software is provided "AS IS," without a warranty of any kind. + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING + * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR + * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND ITS + * LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A + * RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. + * IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT + * OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR + * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, + * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS + * BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + * + * You acknowledge that this software is not designed or intended for use in the + * design, construction, operation or maintenance of any nuclear facility. + * + */ + +package demos.devmaster.lesson2; + +import java.io.*; +import java.nio.*; + +import net.java.games.joal.*; +import net.java.games.joal.util.*; + +/** + * Adapted from DevMaster + * LoopingAndFadeaway Tutorial + * by Jesse Maurais. + * + * @author Athomas Goldberg + * @author Kenneth Russell + */ + +public class LoopingAndFadeaway { + + static int[] buffer = new int[1]; + static int[] source = new int[1]; + static float[] sourcePos = { 0.0f, 0.0f, 0.0f }; + static float[] sourceVel = { 0.0f, 0.0f, 0.1f }; + static float[] listenerPos = { 0.0f, 0.0f, 0.0f }; + static float[] listenerVel = { 0.0f, 0.0f, 0.0f }; + static float[] listenerOri = { 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f }; + static AL al; + static ALC alc; + + static int loadALData() { + if (al.alGetError() != AL.AL_NO_ERROR) { + return AL.AL_FALSE; + } + + int[] format = new int[1]; + int[] size = new int[1]; + ByteBuffer[] data = new ByteBuffer[1]; + int[] freq = new int[1]; + int[] loop = new int[1]; + + // Load wav data into a buffer. + al.alGenBuffers(1, buffer, 0); + if (al.alGetError() != AL.AL_NO_ERROR) + return AL.AL_FALSE; + + ALut.alutLoadWAVFile( + LoopingAndFadeaway.class.getClassLoader().getResourceAsStream("demos/data/Footsteps.wav"), + format, + data, + size, + freq, + loop); + al.alBufferData(buffer[0], format[0], data[0], size[0], freq[0]); + + al.alGenSources(1, source, 0); + al.alSourcei(source[0], AL.AL_BUFFER, buffer[0]); + al.alSourcef(source[0], AL.AL_PITCH, 1.0f); + al.alSourcef(source[0], AL.AL_GAIN, 1.0f); + al.alSourcefv(source[0], AL.AL_POSITION, sourcePos, 0); + al.alSourcefv(source[0], AL.AL_POSITION, sourceVel, 0); + al.alSourcei(source[0], AL.AL_LOOPING, AL.AL_TRUE); + + if (al.alGetError() != AL.AL_NO_ERROR) { + return AL.AL_FALSE; + } + + return AL.AL_TRUE; + } + + static void setListenerValues() { + al.alListenerfv(AL.AL_POSITION, listenerPos, 0); + al.alListenerfv(AL.AL_VELOCITY, listenerVel, 0); + al.alListenerfv(AL.AL_ORIENTATION, listenerOri, 0); + } + + static void killAllData() { + al.alDeleteBuffers(1, buffer, 0); + al.alDeleteSources(1, source, 0); + } + + public static void main(String[] args) { + try { + ALut.alutInit(); + al = ALFactory.getAL(); + } catch (ALException e) { + e.printStackTrace(); + return; + } + + if(loadALData() == AL.AL_FALSE) { + System.exit(1); + }; + setListenerValues(); + al.alSourcePlay(source[0]); + long startTime = System.currentTimeMillis(); + long elapsed = 0; + long ticker = 0; + long lastTime = 0; + while (elapsed < 10000) { + elapsed = System.currentTimeMillis() - startTime; + if (ticker > 100) { + ticker = 0; + sourcePos[0] += sourceVel[0]; + sourcePos[1] += sourceVel[1]; + sourcePos[2] += sourceVel[2]; + al.alSourcefv(source[0], + AL.AL_POSITION, + sourcePos, 0); + } + ticker += System.currentTimeMillis() - lastTime; + lastTime = System.currentTimeMillis(); + } + } +} diff --git a/src/java/demos/devmaster/lesson3/MultipleSources.java b/src/java/demos/devmaster/lesson3/MultipleSources.java new file mode 100755 index 0000000..fbe13f8 --- /dev/null +++ b/src/java/demos/devmaster/lesson3/MultipleSources.java @@ -0,0 +1,211 @@ +/** + * Copyright (c) 2003-2005 Sun Microsystems, Inc. All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * -Redistribution of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * -Redistribution 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 Sun Microsystems, Inc. or the names of contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * This software is provided "AS IS," without a warranty of any kind. + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING + * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR + * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND ITS + * LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A + * RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. + * IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT + * OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR + * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, + * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS + * BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + * + * You acknowledge that this software is not designed or intended for use in the + * design, construction, operation or maintenance of any nuclear facility. + * + */ + +package demos.devmaster.lesson3; + +import java.nio.ByteBuffer; +import java.util.Random; + +import net.java.games.joal.*; +import net.java.games.joal.util.*; + +/** + * Adapted from DevMaster + * MultipleSources Tutorial + * by Jesse Maurais. + * + * @author Athomas Goldberg + * @author Kenneth Russell + */ + +public class MultipleSources { + + static AL al; + static final int NUM_BUFFERS = 3; + static final int NUM_SOURCES = 3; + + static final int BATTLE = 0; + static final int GUN1 = 1; + static final int GUN2 = 2; + + static int[] buffers = new int[NUM_BUFFERS]; + static int[] sources = new int[NUM_SOURCES]; + + static float[][] sourcePos = new float[NUM_SOURCES][3]; + static float[][] sourceVel = new float[NUM_SOURCES][3]; + static float[] listenerPos = { 0.0f, 0.0f, 0.0f }; + static float[] listenerVel = { 0.0f, 0.0f, 0.0f }; + static float[] listenerOri = { 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f }; + + static int loadALData() { + //variables to load into + int[] format = new int[1]; + int[] size = new int[1]; + ByteBuffer[] data = new ByteBuffer[1]; + int[] freq = new int[1]; + int[] loop = new int[1]; + + // load wav data into buffers + al.alGenBuffers(NUM_BUFFERS, buffers, 0); + if (al.alGetError() != AL.AL_NO_ERROR) { + return AL.AL_FALSE; + } + + ALut.alutLoadWAVFile( + MultipleSources.class.getClassLoader().getResourceAsStream("demos/data/Battle.wav"), + format, + data, + size, + freq, + loop); + al.alBufferData(buffers[BATTLE], + format[0], + data[0], + size[0], + freq[0]); + + ALut.alutLoadWAVFile( + MultipleSources.class.getClassLoader().getResourceAsStream("demos/data/Gun1.wav"), + format, + data, + size, + freq, + loop); + al.alBufferData(buffers[GUN1], + format[0], + data[0], + size[0], + freq[0]); + + ALut.alutLoadWAVFile( + MultipleSources.class.getClassLoader().getResourceAsStream("demos/data/Gun2.wav"), + format, + data, + size, + freq, + loop); + al.alBufferData(buffers[GUN2], + format[0], + data[0], + size[0], + freq[0]); + + // bind buffers into audio sources + al.alGenSources(NUM_SOURCES, sources, 0); + + al.alSourcei(sources[BATTLE], AL.AL_BUFFER, buffers[BATTLE]); + al.alSourcef(sources[BATTLE], AL.AL_PITCH, 1.0f); + al.alSourcef(sources[BATTLE], AL.AL_GAIN, 1.0f); + al.alSourcefv(sources[BATTLE], AL.AL_POSITION, sourcePos[BATTLE], 0); + al.alSourcefv(sources[BATTLE], AL.AL_POSITION, sourceVel[BATTLE], 0); + al.alSourcei(sources[BATTLE], AL.AL_LOOPING, AL.AL_TRUE); + + al.alSourcei(sources[GUN1], AL.AL_BUFFER, buffers[GUN1]); + al.alSourcef(sources[GUN1], AL.AL_PITCH, 1.0f); + al.alSourcef(sources[GUN1], AL.AL_GAIN, 1.0f); + al.alSourcefv(sources[GUN1], AL.AL_POSITION, sourcePos[GUN1], 0); + al.alSourcefv(sources[GUN1], AL.AL_POSITION, sourceVel[GUN1], 0); + al.alSourcei(sources[GUN1], AL.AL_LOOPING, AL.AL_FALSE); + + al.alSourcei(sources[GUN2], AL.AL_BUFFER, buffers[GUN2]); + al.alSourcef(sources[GUN2], AL.AL_PITCH, 1.0f); + al.alSourcef(sources[GUN2], AL.AL_GAIN, 1.0f); + al.alSourcefv(sources[GUN2], AL.AL_POSITION, sourcePos[GUN2], 0); + al.alSourcefv(sources[GUN2], AL.AL_POSITION, sourceVel[GUN2], 0); + al.alSourcei(sources[GUN2], AL.AL_LOOPING, AL.AL_FALSE); + + // do another error check and return + if (al.alGetError() != AL.AL_NO_ERROR) { + return AL.AL_FALSE; + } + + return AL.AL_TRUE; + } + + static void setListenerValues() { + al.alListenerfv(AL.AL_POSITION, listenerPos, 0); + al.alListenerfv(AL.AL_VELOCITY, listenerVel, 0); + al.alListenerfv(AL.AL_ORIENTATION, listenerOri, 0); + } + + static void killAllData() { + al.alDeleteBuffers(NUM_BUFFERS, buffers, 0); + al.alDeleteSources(NUM_SOURCES, sources, 0); + } + + public static void main(String[] args) { + try { + ALut.alutInit(); + al = ALFactory.getAL(); + } catch (ALException e) { + e.printStackTrace(); + System.exit(1); + } + al.alGetError(); + + if(loadALData() == AL.AL_FALSE) { + System.exit(1); + } + setListenerValues(); + al.alSourcePlay(sources[BATTLE]); + long startTime = System.currentTimeMillis(); + long elapsed = 0; + long totalElapsed = 0; + Random rand = new Random(); + int[] state = new int[1]; + while (totalElapsed < 10000) { + elapsed = System.currentTimeMillis() - startTime; + if (elapsed > 50) { + totalElapsed += elapsed; + startTime = System.currentTimeMillis(); + // pick one of the two guns + int pick = Math.abs((rand.nextInt()) % 2) + 1; + al.alGetSourcei(sources[pick], AL.AL_SOURCE_STATE, state, 0); + if (state[0] != AL.AL_PLAYING) { + double theta = (rand.nextInt() % 360) * 3.14 / 180.0; + sourcePos[pick][0] = - ((float) Math.cos(theta)); + sourcePos[pick][1] = - ((float) (rand.nextInt() % 2)); + sourcePos[pick][2] = - ((float) Math.sin(theta)); + + al.alSourcefv(sources[pick], + AL.AL_POSITION, + sourcePos[pick], 0); + + al.alSourcePlay(sources[pick]); + } + } + } + killAllData(); + } +} diff --git a/src/java/demos/devmaster/lesson5/SourcesSharingBuffers.java b/src/java/demos/devmaster/lesson5/SourcesSharingBuffers.java new file mode 100755 index 0000000..091f8b3 --- /dev/null +++ b/src/java/demos/devmaster/lesson5/SourcesSharingBuffers.java @@ -0,0 +1,268 @@ +/** + * Copyright (c) 2003-2005 Sun Microsystems, Inc. All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * -Redistribution of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * + * -Redistribution 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 Sun Microsystems, Inc. or the names of contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * This software is provided "AS IS," without a warranty of any kind. + * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING + * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR + * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MICROSYSTEMS, INC. ("SUN") AND ITS + * LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A + * RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. + * IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT + * OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR + * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, + * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS + * BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + * + * You acknowledge that this software is not designed or intended for use in the + * design, construction, operation or maintenance of any nuclear facility. + * + */ + +package demos.devmaster.lesson5; + +import java.io.*; +import java.nio.*; +import java.util.*; + +import net.java.games.joal.*; +import net.java.games.joal.util.*; + +/** + * Adapted from DevMaster + * MultipleSources Tutorial + * by Jesse Maurais. + * + * @author Athomas Goldberg + * @author Kenneth Russell + */ + +public class SourcesSharingBuffers { + + static ALC alc; + static AL al; + + // These index the buffers. + public static final int THUNDER = 0; + public static final int WATERDROP = 1; + public static final int STREAM = 2; + public static final int RAIN = 3; + + public static final int CHIMES = 4; + public static final int OCEAN = 5; + public static final int NUM_BUFFERS = 6; + + // Buffers hold sound data. + static int[] buffers = new int[NUM_BUFFERS]; + + // A list of sources for multiple emissions. + static List sources = new ArrayList(); + + // Position of the source sounds. + static float[] sourcePos = { 0.0f, 0.0f, 0.0f }; + + // Velocity of the source sounds. + static float[] sourceVel = { 0.0f, 0.0f, 0.0f }; + + + + // Position of the listener. + static float[] listenerPos = { 0.0f, 0.0f, 0.0f }; + + // Velocity of the listener. + static float[] listenerVel = { 0.0f, 0.0f, 0.0f }; + + // Orientation of the listener. (first 3 elements are "at", second 3 are "up") + static float[] listenerOri = { 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f }; + + static void initOpenAL() throws ALException { + alc = ALFactory.getALC(); + al = ALFactory.getAL(); + + ALCdevice device; + ALCcontext context; + String deviceSpecifier; + + // Get handle to default device. + device = alc.alcOpenDevice(null); + if (device == null) { + throw new ALException("Error opening default OpenAL device"); + } + + // Get the device specifier. + deviceSpecifier = alc.alcGetString(device, ALC.ALC_DEVICE_SPECIFIER); + if (deviceSpecifier == null) { + throw new ALException("Error getting specifier for default OpenAL device"); + } + + System.out.println("Using device " + deviceSpecifier); + + // Create audio context. + context = alc.alcCreateContext(device, null); + if (context == null) { + throw new ALException("Error creating OpenAL context"); + } + + // Set active context. + alc.alcMakeContextCurrent(context); + + // Check for an error. + if (alc.alcGetError(device) != ALC.ALC_NO_ERROR) { + throw new ALException("Error making OpenAL context current"); + } + } + + static void exitOpenAL() { + ALCcontext curContext; + ALCdevice curDevice; + + // Get the current context. + curContext = alc.alcGetCurrentContext(); + + // Get the device used by that context. + curDevice = alc.alcGetContextsDevice(curContext); + + // Reset the current context to NULL. + alc.alcMakeContextCurrent(null); + + // Release the context and the device. + alc.alcDestroyContext(curContext); + alc.alcCloseDevice(curDevice); + } + static int loadALData() { + // Variables to load into. + int[] format = new int[1]; + int[] size = new int[1]; + ByteBuffer[] data = new ByteBuffer[1]; + int[] freq = new int[1]; + int[] loop = new int[1]; + + // Load wav data into buffers. + al.alGenBuffers(NUM_BUFFERS, buffers, 0); + + if(al.alGetError() != AL.AL_NO_ERROR) + return AL.AL_FALSE; + + ALut.alutLoadWAVFile(SourcesSharingBuffers.class.getClassLoader().getResourceAsStream("demos/data/thunder.wav"), + format, data, size, freq, loop); + al.alBufferData(buffers[THUNDER], format[0], data[0], size[0], freq[0]); + + ALut.alutLoadWAVFile(SourcesSharingBuffers.class.getClassLoader().getResourceAsStream("demos/data/waterdrop.wav"), + format, data, size, freq, loop); + al.alBufferData(buffers[WATERDROP], format[0], data[0], size[0], freq[0]); + + ALut.alutLoadWAVFile(SourcesSharingBuffers.class.getClassLoader().getResourceAsStream("demos/data/stream.wav"), + format, data, size, freq, loop); + al.alBufferData(buffers[STREAM], format[0], data[0], size[0], freq[0]); + + ALut.alutLoadWAVFile(SourcesSharingBuffers.class.getClassLoader().getResourceAsStream("demos/data/rain.wav"), + format, data, size, freq, loop); + al.alBufferData(buffers[RAIN], format[0], data[0], size[0], freq[0]); + + ALut.alutLoadWAVFile(SourcesSharingBuffers.class.getClassLoader().getResourceAsStream("demos/data/ocean.wav"), + format, data, size, freq, loop); + al.alBufferData(buffers[OCEAN], format[0], data[0], size[0], freq[0]); + + ALut.alutLoadWAVFile(SourcesSharingBuffers.class.getClassLoader().getResourceAsStream("demos/data/chimes.wav"), + format, data, size, freq, loop); + al.alBufferData(buffers[CHIMES], format[0], data[0], size[0], freq[0]); + + // Do another error check and return. + if (al.alGetError() != AL.AL_NO_ERROR) + return AL.AL_FALSE; + + return AL.AL_TRUE; + } + + static void addSource(int type) { + int[] source = new int[1]; + + al.alGenSources(1, source, 0); + + if (al.alGetError() != AL.AL_NO_ERROR) { + System.err.println("Error generating audio source."); + System.exit(1); + } + + al.alSourcei (source[0], AL.AL_BUFFER, buffers[type]); + al.alSourcef (source[0], AL.AL_PITCH, 1.0f ); + al.alSourcef (source[0], AL.AL_GAIN, 1.0f ); + al.alSourcefv(source[0], AL.AL_POSITION, sourcePos , 0); + al.alSourcefv(source[0], AL.AL_VELOCITY, sourceVel , 0); + al.alSourcei (source[0], AL.AL_LOOPING, AL.AL_TRUE ); + + al.alSourcePlay(source[0]); + + sources.add(new Integer(source[0])); + } + + static void setListenerValues() { + al.alListenerfv(AL.AL_POSITION, listenerPos, 0); + al.alListenerfv(AL.AL_VELOCITY, listenerVel, 0); + al.alListenerfv(AL.AL_ORIENTATION, listenerOri, 0); + } + + static void killALData() { + for (Iterator iter = sources.iterator(); iter.hasNext(); ) { + al.alDeleteSources(1, new int[] { ((Integer)iter.next()).intValue() }, 0); + } + sources.clear(); + al.alDeleteBuffers(NUM_BUFFERS, buffers, 0); + exitOpenAL(); + } + + public static void main(String[] args) { + try { + initOpenAL(); + } catch (ALException e) { + e.printStackTrace(); + System.exit(1); + } + if (loadALData() == AL.AL_FALSE) { + System.exit(1); + } + setListenerValues(); + char[] c = new char[1]; + while(c[0] != 'q') { + try { + BufferedReader buf = + new BufferedReader(new InputStreamReader(System.in)); + System.out.println("Press a key and hit ENTER: \n" + + "\t'w' for Water Drop\n" + + "\t't' for Thunder\n" + + "\t's' for Stream\n" + + "\t'r' for Rain\n" + + "\t'o' for Ocean\n" + + "\t'c' for Chimes\n" + + "\n'q' to Quit\n"); + + buf.read(c); + switch(c[0]) { + case 'w': addSource(WATERDROP); break; + case 't': addSource(THUNDER); break; + case 's': addSource(STREAM); break; + case 'r': addSource(RAIN); break; + case 'o': addSource(OCEAN); break; + case 'c': addSource(CHIMES); break; + } + } catch (IOException e) { + killALData(); + System.exit(1); + } + } + killALData(); + } +} -- cgit v1.2.3