summaryrefslogtreecommitdiffstats log msg author committer range
path: root/www/devmaster/lesson2.html
blob: 0e9654035726c59e4403777ba7ed6e829fa6785d (plain)
 ```1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 ``` `````` JOAL OpenAL Tutorials from DevMaster.net Lesson 2: Looping and Fade-away
OpenAL Tutorials from DevMaster.net. Reprinted with Permission.

OpenAL Tutorials

DevMaster.net

Lesson 2

Launch the Demo via Java Web Start

Hope you found the last tutorial of some use. I know I did. This will be a real quick and easy tutorial. It won't get too much more complicated at this point.

import java.nio.ByteBuffer;   import net.java.games.joal.AL;   import net.java.games.joal.ALC;   import net.java.games.joal.ALFactory;   import net.java.games.joal.util.ALut;     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;

There is only one change in the code since the last tutorial in this fist section. It is that we altered the sources velocity. It's 'z' field is now 0.1.

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);         if (al.alGetError() != AL.AL_NO_ERROR)             return AL.AL_FALSE;         ALut.alutLoadWAVFile(             "wavdata/Footsteps.wav",             format,             data,             size,             freq,             loop);         al.alBufferData(buffer[0], format[0], data[0], size[0], freq[0]);         ALut.alutUnloadWAV(format[0], data[0], size[0], freq[0]);          al.alGenSources(1, source);         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);         al.alSourcefv(source[0], AL.AL_POSITION, sourceVel);         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;     }

Two changes in this section. First we are loading the file "Footsteps.wav". We are also explicitly setting the sources 'AL_LOOPING' value to 'AL_TRUE'. What this means is that when the source is prompted to play it will continue to play until stopped. It will play over again after the sound clip has ended.

static void setListenerValues() {         al.alListenerfv(AL.AL_POSITION,	listenerPos);         al.alListenerfv(AL.AL_VELOCITY,    listenerVel);         al.alListenerfv(AL.AL_ORIENTATION, listenerOri);     } 	     static void killALData() {         al.alDeleteBuffers(1, buffer);         al.alDeleteSources(1, source);         Alut.alutExit();     }

Nothing has changed here.

public static void main(String[] args) {         ALut.alutInit();         al = ALFactory.getAL();          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 < 5000) {             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);             }             ticker += System.currentTimeMillis() - lastTime;             lastTime = System.currentTimeMillis();          }         ALut.alutExit();     } }

The only thing that has changed in this code is the loop. Instead of playing and stopping the audio sample it will slowly get quieter as the sources position grows more distant. We do this by slowly incrementing the position by it's velocity over time. The time is sampled by checking the system clock which gives us a tick count. It shouldn't be necessary to change this, but if the audio clip fades too fast you might want to change 100 to some higher number.