shadowfacts/lwjgl2-arm64
1
0
Fork 0
mirror of https://github.com/shadowfacts/lwjgl2-arm64.git synced 2026-04-05 14:35:58 +00:00
Code Issues Projects Releases Packages Wiki Activity

Removed EAX

Browse source
This commit is contained in:
Elias Naur 2005-01-18 15:22:52 +00:00
parent 9cda0f74a8
commit 8220b2e04c
16 changed files with 7 additions and 2367 deletions
Download patch file Download diff file Expand all files Collapse all files

99
src/java/org/lwjgl/openal/eax/EAX.java
View file

@ -1,99 +0,0 @@
/*
* Copyright (c) 2002-2004 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.lwjgl.openal.eax;
import org.lwjgl.Sys;
import org.lwjgl.LWJGLException;
/**
* $Id$
*
* This is the OpenAL EAX class. It extends the latest core.
*
* @author Brian Matzon <brian@matzon.dk>
* @version $Revision$
*/
public class EAX {
/** Has the EAX object been created? */
protected static boolean created;
static {
Sys.initialize();
}
/**
* Loads the EAX functions
*
* @throws LWJGLException if the EAX extensions couldn't be loaded
*/
public static void create() throws LWJGLException {
if (created) {
return;
}
if (!nCreate()) {
throw new LWJGLException("EAX instance could not be created.");
}
EAX20.init();
created = true;
}
/**
* Native method to create EAX instance
*
* @return true if the EAX extensions could be found
*/
protected static native boolean nCreate();
/**
* "Destroy" the EAX object
*/
public static void destroy() {
if (!created) {
return;
}
created = false;
nDestroy();
}
/**
* Native method the destroy the EAX
*/
protected static native void nDestroy();
/**
* @return true if EAX has been created
*/
public static boolean isCreated() {
return created;
}
}

161
src/java/org/lwjgl/openal/eax/EAX20.java
View file

@ -1,161 +0,0 @@
/*
* Copyright (c) 2002-2004 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.lwjgl.openal.eax;
import java.nio.Buffer;
/**
* $Id$
*
* This is the OpenAL EAX class. It extends the latest core.
*
* @author Brian Matzon <brian@matzon.dk>
* @version $Revision$
*/
public class EAX20 {
/** GUID for buffer */
public static final int BUFFER_GUID = 1;
/** GUID for listener */
public static final int LISTENER_GUID = 2;
public static final int EAX_ENVIRONMENT_GENERIC = 0;
public static final int EAX_ENVIRONMENT_PADDEDCELL = 1;
public static final int EAX_ENVIRONMENT_ROOM = 2;
public static final int EAX_ENVIRONMENT_BATHROOM = 3;
public static final int EAX_ENVIRONMENT_LIVINGROOM = 4;
public static final int EAX_ENVIRONMENT_STONEROOM = 5;
public static final int EAX_ENVIRONMENT_AUDITORIUM = 6;
public static final int EAX_ENVIRONMENT_CONCERTHALL = 7;
public static final int EAX_ENVIRONMENT_CAVE = 8;
public static final int EAX_ENVIRONMENT_ARENA = 9;
public static final int EAX_ENVIRONMENT_HANGAR = 10;
public static final int EAX_ENVIRONMENT_CARPETEDHALLWAY = 11;
public static final int EAX_ENVIRONMENT_HALLWAY = 12;
public static final int EAX_ENVIRONMENT_STONECORRIDOR = 13;
public static final int EAX_ENVIRONMENT_ALLEY = 14;
public static final int EAX_ENVIRONMENT_FOREST = 15;
public static final int EAX_ENVIRONMENT_CITY = 16;
public static final int EAX_ENVIRONMENT_MOUNTAINS = 17;
public static final int EAX_ENVIRONMENT_QUARRY = 18;
public static final int EAX_ENVIRONMENT_PLAIN = 19;
public static final int EAX_ENVIRONMENT_PARKINGLOT = 20;
public static final int EAX_ENVIRONMENT_SEWERPIPE = 21;
public static final int EAX_ENVIRONMENT_UNDERWATER = 22;
public static final int EAX_ENVIRONMENT_DRUGGED = 23;
public static final int EAX_ENVIRONMENT_DIZZY = 24;
public static final int EAX_ENVIRONMENT_PSYCHOTIC = 25;
public static final int EAX_ENVIRONMENT_COUNT = 26;
// Single window material preset
public static final int EAX_MATERIAL_SINGLEWINDOW = -2800;
public static final float EAX_MATERIAL_SINGLEWINDOWLF = 0.71f;
public static final float EAX_MATERIAL_SINGLEWINDOWROOMRATIO = 0.43f;
// Double window material preset
public static final int EAX_MATERIAL_DOUBLEWINDOW = -5000;
public static final float EAX_MATERIAL_DOUBLEWINDOWHF = 0.40f;
public static final float EAX_MATERIAL_DOUBLEWINDOWROOMRATIO = 0.24f;
// Thin door material preset
public static final int EAX_MATERIAL_THINDOOR = -1800;
public static final float EAX_MATERIAL_THINDOORLF = 0.66f;
public static final float EAX_MATERIAL_THINDOORROOMRATIO = 0.66f;
// Thick door material preset
public static final int EAX_MATERIAL_THICKDOOR = -4400;
public static final float EAX_MATERIAL_THICKDOORLF = 0.64f;
public static final float EAX_MATERIAL_THICKDOORROOMRTATION = 0.27f;
// Wood wall material preset
public static final int EAX_MATERIAL_WOODWALL = -4000;
public static final float EAX_MATERIAL_WOODWALLLF = 0.50f;
public static final float EAX_MATERIAL_WOODWALLROOMRATIO = 0.30f;
// Brick wall material preset
public static final int EAX_MATERIAL_BRICKWALL = -5000;
public static final float EAX_MATERIAL_BRICKWALLLF = 0.60f;
public static final float EAX_MATERIAL_BRICKWALLROOMRATIO = 0.24f;
// Stone wall material preset
public static final int EAX_MATERIAL_STONEWALL = -6000;
public static final float EAX_MATERIAL_STONEWALLLF = 0.68f;
public static final float EAX_MATERIAL_STONEWALLROOMRATIO = 0.20f;
// Curtain material preset
public static final int EAX_MATERIAL_CURTAIN = -1200;
public static final float EAX_MATERIAL_CURTAINLF = 0.15f;
public static final float EAX_MATERIAL_CURTAINROOMRATIO = 1.00f;
/**
* Load extensions
*/
protected static void init() {
determineAvailableExtensions();
}
/**
* Determines available EAX extensions
*/
protected static native void determineAvailableExtensions();
/**
* Retrieves an EAX Value
*
* @param propertySetID adress to the property set GUID of the object being queried (a listener or a source)
* @param property property being queried
* @param source the source to be queried
* @param data Buffer to write value to
* @param size size of area being written to
* @return OpenAL Error code
*/
public static int eaxGet(int propertySetID, int property, int source, Buffer data, int size) {
return neaxGet(propertySetID, property, source, data, data.position(), size);
}
private static native int neaxGet(int propertySetID, int property, int source, Buffer data, int position, int size);
/**
* Sets an EAX Value
*
* @param propertySetID adress to the property set GUID of the object being queried (a listener or a source)
* @param property property being queried
* @param source the source to be queried
* @param data Buffer to write value to
* @param size size of area being written to
* @return OpenAL Error code
*/
public static int eaxSet(int propertySetID, int property, int source, Buffer data, int size) {
return neaxSet(propertySetID, property, source, data, data.position(), size);
}
private static native int neaxSet(int propertySetID, int property, int source, Buffer data, int position, int size);
}

641
src/java/org/lwjgl/openal/eax/EAXBufferProperties.java
View file

@ -1,641 +0,0 @@
/*
* Copyright (c) 2002-2004 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.lwjgl.openal.eax;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.lwjgl.Sys;
import org.lwjgl.BufferUtils;
/**
* $Id$
*
* This class encapsultaes the EAXBUFFERPROPERTIES struct. Since longs
* are 64 bit in Java and "typically" 32 on other platforms, we cheat by reading an
* int when reading a long field.
*
* @author Brian Matzon <brian@matzon.dk>
* @version $Revision$
*/
public class EAXBufferProperties {
/** Whether auto commit has been anabled */
private boolean autoCommit = true;
/** Current source being operated on */
private int currentSource = -1;
/** ByteBuffer representing EAXBUFFERPROPERTIES */
protected ByteBuffer eaxBufferProperties;
/** size needed by ByteBuffer to contain EAXBUFFERPROPERTIES */
protected static int EAXBUFFERPROPERTIES_SIZE;
// EAX values and offsets
// ========================================================
/** direct path level offset */
protected static int direct_offset;
/** direct path level at high frequencies offset */
protected static int directHF_offset;
/** room effect level offset */
protected static int room_offset;
/** room effect level at high frequencies offset */
protected static int roomHF_offset;
/** like DS3D flRolloffFactor but for room effect offset */
protected static int roomRolloffFactor_offset;
/** main obstruction control (attenuation at high frequencies) offset */
protected static int obstruction_offset;
/** obstruction low-frequency level re. main control offset */
protected static int obstructionLFRatio_offset;
/** main occlusion control (attenuation at high frequencies) offset */
protected static int occlusion_offset;
/** occlusion low-frequency level re. main control offset */
protected static int occlusionLFRatio_offset;
/** occlusion room effect level re. main control offset */
protected static int occlusionRoomRatio_offset;
/** outside sound cone level at high frequencies offset */
protected static int outsideVolumeHF_offset;
/** multiplies DSPROPERTY_EAXLISTENER_AIRABSORPTIONHF offset */
protected static int airAbsorptionFactor_offset;
/** modifies the behavior of properties offset */
protected static int flags_offset;
public static final int EAXBUFFER_NONE = 0;
public static final int EAXBUFFER_ALLPARAMETERS = 1;
public static final int EAXBUFFER_DIRECT = 2;
public static final int EAXBUFFER_DIRECTHF = 3;
public static final int EAXBUFFER_ROOM = 4;
public static final int EAXBUFFER_ROOMHF = 5;
public static final int EAXBUFFER_ROOMROLLOFFFACTOR = 6;
public static final int EAXBUFFER_OBSTRUCTION = 7;
public static final int EAXBUFFER_OBSTRUCTIONLFRATIO = 8;
public static final int EAXBUFFER_OCCLUSION = 9;
public static final int EAXBUFFER_OCCLUSIONLFRATIO = 10;
public static final int EAXBUFFER_OCCLUSIONROOMRATIO = 11;
public static final int EAXBUFFER_OUTSIDEVOLUMEHF = 12;
public static final int EAXBUFFER_AIRABSORPTIONFACTOR = 13;
public static final int EAXBUFFER_FLAGS = 14;
/** changes take effect immediately */
public static final int EAXBUFFER_IMMEDIATE = 0x00000000;
/** changes take effect later */
public static final int EAXBUFFER_DEFERRED = 0x80000000;
public static final int EAXBUFFER_COMMITDEFERREDSETTINGS =
(EAXBUFFER_NONE | EAXBUFFER_IMMEDIATE);
/** affects DSPROPERTY_EAXBUFFER_DIRECTHF */
public static final int EAXBUFFER_FLAGS_DIRECTHFAUTO = 0x00000001;
/** affects DSPROPERTY_EAXBUFFER_ROOM */
public static final int EAXBUFFER_FLAGS_ROOMAUTO = 0x00000002;
/** affects DSPROPERTY_EAXBUFFER_ROOMHF */
public static final int EAXBUFFER_FLAGS_ROOMHFAUTO = 0x00000004;
/** reserved future use */
public static final int EAXBUFFER_FLAGS_RESERVED = 0xFFFFFFF8;
// property ranges and defaults:
public static final int EAXBUFFER_MINDIRECT = -10000;
public static final int EAXBUFFER_MAXDIRECT = 1000;
public static final int EAXBUFFER_DEFAULTDIRECT = 0;
public static final int EAXBUFFER_MINDIRECTHF = -10000;
public static final int EAXBUFFER_MAXDIRECTHF = 0;
public static final int EAXBUFFER_DEFAULTDIRECTHF = 0;
public static final int EAXBUFFER_MINROOM = -10000;
public static final int EAXBUFFER_MAXROOM = 1000;
public static final int EAXBUFFER_DEFAULTROOM = 0;
public static final int EAXBUFFER_MINROOMHF = -10000;
public static final int EAXBUFFER_MAXROOMHF = 0;
public static final int EAXBUFFER_DEFAULTROOMHF = 0;
public static final float EAXBUFFER_MINROOMROLLOFFFACTOR = 0.0f;
public static final float EAXBUFFER_MAXROOMROLLOFFFACTOR = 10.f;
public static final float EAXBUFFER_DEFAULTROOMROLLOFFFACTOR = 0.0f;
public static final int EAXBUFFER_MINOBSTRUCTION = -10000;
public static final int EAXBUFFER_MAXOBSTRUCTION = 0;
public static final int EAXBUFFER_DEFAULTOBSTRUCTION = 0;
public static final float EAXBUFFER_MINOBSTRUCTIONLFRATIO = 0.0f;
public static final float EAXBUFFER_MAXOBSTRUCTIONLFRATIO = 1.0f;
public static final float EAXBUFFER_DEFAULTOBSTRUCTIONLFRATIO = 0.0f;
public static final int EAXBUFFER_MINOCCLUSION = -10000;
public static final int EAXBUFFER_MAXOCCLUSION = 0;
public static final int EAXBUFFER_DEFAULTOCCLUSION = 0;
public static final float EAXBUFFER_MINOCCLUSIONLFRATIO = 0.0f;
public static final float EAXBUFFER_MAXOCCLUSIONLFRATIO = 1.0f;
public static final float EAXBUFFER_DEFAULTOCCLUSIONLFRATIO = 0.25f;
public static final float EAXBUFFER_MINOCCLUSIONROOMRATIO = 0.0f;
public static final float EAXBUFFER_MAXOCCLUSIONROOMRATIO = 10.0f;
public static final float EAXBUFFER_DEFAULTOCCLUSIONROOMRATIO = 0.5f;
public static final int EAXBUFFER_MINOUTSIDEVOLUMEHF = -10000;
public static final int EAXBUFFER_MAXOUTSIDEVOLUMEHF = 0;
public static final int EAXBUFFER_DEFAULTOUTSIDEVOLUMEHF = 0;
public static final float EAXBUFFER_MINAIRABSORPTIONFACTOR = 0.0f;
public static final float EAXBUFFER_MAXAIRABSORPTIONFACTOR = 10.0f;
public static final float EAXBUFFER_DEFAULTAIRABSORPTIONFACTOR = 1.0f;
public static final int EAXBUFFER_DEFAULTFLAGS =
(EAXBUFFER_FLAGS_DIRECTHFAUTO
| EAXBUFFER_FLAGS_ROOMAUTO
| EAXBUFFER_FLAGS_ROOMHFAUTO);
// -------------------------------------------------------
static {
Sys.initialize();
EAXBUFFERPROPERTIES_SIZE = sizeOfEaxBufferProperties();
assignOffsets();
}
/**
* Creates a new EAXBufferProperties object
*/
public EAXBufferProperties() {
eaxBufferProperties = BufferUtils.createByteBuffer(EAXBUFFERPROPERTIES_SIZE);
eaxBufferProperties.order(ByteOrder.nativeOrder());
}
/**
* Sets the current source on which to perform effects
*
* @param source Source on which to perform effects
*/
public void setCurrentSource(int source) {
currentSource = source;
}
/**
* Retrieves the current source
*
* @return Source on which effects are being performed
*/
public int getCurrentSource() {
return currentSource;
}
/**
* Loads current EAX values from current source
*/
public void loadEAXValues() {
EAX20.eaxGet(
EAX20.BUFFER_GUID,
EAXBUFFER_ALLPARAMETERS,
currentSource,
eaxBufferProperties,
EAXBUFFERPROPERTIES_SIZE);
}
/**
* Resets this buffer property to default values
*/
public void reset() {
boolean commitValue = autoCommit;
// disable autocommit
autoCommit = false;
// set values
setDirect(EAXBUFFER_DEFAULTDIRECT);
setDirectHF(EAXBUFFER_DEFAULTDIRECTHF);
setRoom(EAXBUFFER_DEFAULTROOM);
setRoomHF(EAXBUFFER_DEFAULTROOMHF);
setRoomRolloffFactor(EAXBUFFER_DEFAULTROOMROLLOFFFACTOR);
setObstruction(EAXBUFFER_DEFAULTOBSTRUCTION);
setObstructionLFRatio(EAXBUFFER_DEFAULTOBSTRUCTIONLFRATIO);
setOcclusion(EAXBUFFER_DEFAULTOCCLUSION);
setOcclusionLFRatio(EAXBUFFER_DEFAULTOCCLUSIONLFRATIO);
setOcclusionRoomRatio(EAXBUFFER_DEFAULTOCCLUSIONROOMRATIO);
setOutsideVolumeHF(EAXBUFFER_DEFAULTOUTSIDEVOLUMEHF);
setAirAbsorptionFactor(EAXBUFFER_DEFAULTAIRABSORPTIONFACTOR);
setFlags(EAXBUFFER_DEFAULTFLAGS);
// reset auto commit
autoCommit = commitValue;
}
/**
* Commits any changes
*/
public void commit() {
// call eaxSet with Buffer guid, setting all parameters
EAX20.eaxSet(
EAX20.BUFFER_GUID, EAXBUFFER_ALLPARAMETERS,
currentSource, eaxBufferProperties, EAXBUFFERPROPERTIES_SIZE);
}
/**
* Tests whether auto commit is enabled or not
*
* @return true if auto commit is inabled
*/
public boolean isAutoCommitEnabled() {
return autoCommit;
}
/**
* Enabled or disables auto commit
*
* @param enabled True to enable, false to disable
*/
public void setAutoCommit(boolean enabled) {
autoCommit = enabled;
}
/**
* Performs auto commit, if enabled
*/
private final void autoCommit() {
if(autoCommit) {
commit();
}
}
/**
* Retrieves the size of the containing ByteBuffer
*/
public static int getSize() {
return EAXBUFFERPROPERTIES_SIZE;
}
/**
* Returns a String representation of the EAXBufferProperties object
*
* @return String representation of the EAXBufferProperties object
*/
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append("EAXBufferProperties [");
sb.append("lDirect = ");
sb.append(getDirect());
sb.append(", ");
sb.append("lDirectHF = ");
sb.append(getDirectHF());
sb.append(", ");
sb.append("lRoom = ");
sb.append(getRoom());
sb.append(", ");
sb.append("lRoomHF = ");
sb.append(getRoomHF());
sb.append(", ");
sb.append("flRoomRolloffFactor = ");
sb.append(getRoomRolloffFactor());
sb.append(", ");
sb.append("lObstruction = ");
sb.append(getObstruction());
sb.append(", ");
sb.append("flObstructionLFRatio = ");
sb.append(getObstructionLFRatio());
sb.append(", ");
sb.append("lOcclusion = ");
sb.append(getOcclusion());
sb.append(", ");
sb.append("flOcclusionLFRatio = ");
sb.append(getOcclusionLFRatio());
sb.append(", ");
sb.append("flOcclusionRoomRatio = ");
sb.append(getOcclusionRoomRatio());
sb.append(", ");
sb.append("lOutsideVolumeHF = ");
sb.append(getOutsideVolumeHF());
sb.append(", ");
sb.append("flAirAbsorptionFactor = ");
sb.append(getAirAbsorptionFactor());
sb.append(", ");
sb.append("dwFlags = ");
sb.append(getFlags());
sb.append("]");
return sb.toString();
}
// Getters and Setters of struct
// ==========================================================================
/**
* Retireves the direct path level
*
* @return direct path level
*/
public int getDirect() {
return eaxBufferProperties.getInt(direct_offset);
}
/**
* Sets the direct path level
*
* @param direct direct path level to set to
*/
public void setDirect(int direct) {
eaxBufferProperties.putInt(direct_offset, direct);
autoCommit();
}
/**
* Retireves the direct path level at high frequencies
*
* @return direct path level at high frequencies
*/
public int getDirectHF() {
return eaxBufferProperties.getInt(directHF_offset);
}
/**
* Sets the direct path level at high frequencies
*
* @param directHF direct path level at high frequencies to set to
*/
public void setDirectHF(int directHF) {
eaxBufferProperties.putInt(directHF_offset, directHF);
autoCommit();
}
/**
* Retireves the room effect level
*
* @return room effect level
*/
public int getRoom() {
return eaxBufferProperties.getInt(room_offset);
}
/**
* Sets the room effect level
*
* @param room room effect level to set to
*/
public void setRoom(int room) {
eaxBufferProperties.putInt(room_offset, room);
autoCommit();
}
/**
* Retireves the room effect level at high frequencies
*
* @return room effect level at high frequencies
*/
public int getRoomHF() {
return eaxBufferProperties.getInt(roomHF_offset);
}
/**
* Sets the room effect level at high frequencies
*
* @param roomHF room effect level at high frequencies to set to
*/
public void setRoomHF(int roomHF) {
eaxBufferProperties.putInt(roomHF_offset, roomHF);
autoCommit();
}
/**
* Retireves the DS3D flRolloffFactor for room effect
*
* @return DS3D flRolloffFactor for room effect
*/
public float getRoomRolloffFactor() {
return eaxBufferProperties.getFloat(roomRolloffFactor_offset);
}
/**
* Sets the DS3D flRolloffFactor for room effect
*
* @param roomRolloffFactor DS3D flRolloffFactor for room effect to set to
*/
public void setRoomRolloffFactor(float roomRolloffFactor) {
eaxBufferProperties.putFloat(roomRolloffFactor_offset, roomRolloffFactor);
autoCommit();
}
/**
* Retireves the main obstruction control (attenuation at high frequencies)
*
* @return main obstruction control (attenuation at high frequencies)
*/
public int getObstruction() {
return eaxBufferProperties.getInt(obstruction_offset);
}
/**
* Sets the main obstruction control (attenuation at high frequencies)
*
* @param obstruction main obstruction control (attenuation at high frequencies) to set to
*/
public void setObstruction(int obstruction) {
eaxBufferProperties.putInt(obstruction_offset, obstruction);
autoCommit();
}
/**
* Retireves the obstruction low-frequency level re. main control
*
* @return obstruction low-frequency level re. main control
*/
public float getObstructionLFRatio() {
return eaxBufferProperties.getFloat(obstructionLFRatio_offset);
}
/**
* Sets the obstruction low-frequency level re. main control
*
* @param obstructionLFRatio obstruction low-frequency level re. main control to set to
*/
public void setObstructionLFRatio(float obstructionLFRatio) {
eaxBufferProperties.putFloat(obstructionLFRatio_offset, obstructionLFRatio);
autoCommit();
}
/**
* Retireves the main occlusion control (attenuation at high frequencies)
*
* @return main occlusion control (attenuation at high frequencies)
*/
public int getOcclusion() {
return eaxBufferProperties.getInt(occlusion_offset);
}
/**
* Sets the main occlusion control (attenuation at high frequencies)
*
* @param occlusion main occlusion control (attenuation at high frequencies) to set to
*/
public void setOcclusion(int occlusion) {
eaxBufferProperties.putInt(occlusion_offset, occlusion);
autoCommit();
}
/**
* Retireves the occlusion low-frequency level re. main control
*
* @return occlusion low-frequency level re. main control
*/
public float getOcclusionLFRatio() {
return eaxBufferProperties.getFloat(occlusionLFRatio_offset);
}
/**
* Sets the occlusion low-frequency level re. main control
*
* @param occlusionLFRatio occlusion low-frequency level re. main control to set to
*/
public void setOcclusionLFRatio(float occlusionLFRatio) {
eaxBufferProperties.putFloat(occlusionLFRatio_offset, occlusionLFRatio);
autoCommit();
}
/**
* Retireves the occlusion room effect level re. main control
*
* @return occlusion room effect level re. main control
*/
public float getOcclusionRoomRatio() {
return eaxBufferProperties.getFloat(occlusionRoomRatio_offset);
}
/**
* Sets the OcclusionRoomRatio
*
* @param occlusionRoomRatio OcclusionRoomRatio to set to
*/
public void setOcclusionRoomRatio(float occlusionRoomRatio) {
eaxBufferProperties.putFloat(occlusionRoomRatio_offset, occlusionRoomRatio);
autoCommit();
}
/**
* Retireves the OutsideVolumeHF
*
* @return OutsideVolumeHF
*/
public int getOutsideVolumeHF() {
return eaxBufferProperties.getInt(outsideVolumeHF_offset);
}
/**
* Sets the OutsideVolumeHF
*
* @param outsideVolumeHF OutsideVolumeHF to set to
*/
public void setOutsideVolumeHF(int outsideVolumeHF) {
eaxBufferProperties.putInt(outsideVolumeHF_offset, outsideVolumeHF);
autoCommit();
}
/**
* Retireves the multiplier for DSPROPERTY_EAXLISTENER_AIRABSORPTIONHF
*
* @return multiplier for DSPROPERTY_EAXLISTENER_AIRABSORPTIONHF
*/
public float getAirAbsorptionFactor() {
return eaxBufferProperties.getFloat(airAbsorptionFactor_offset);
}
/**
* Sets the multiplier for DSPROPERTY_EAXLISTENER_AIRABSORPTIONHF
*
* @param airAbsorptionFactor multiplier for DSPROPERTY_EAXLISTENER_AIRABSORPTIONHF to set to
*/
public void setAirAbsorptionFactor(float airAbsorptionFactor) {
eaxBufferProperties.putFloat(airAbsorptionFactor_offset, airAbsorptionFactor);
autoCommit();
}
/**
* Retireves the modifier for behavior of properties
*
* @return modifier for behavior of properties
*/
public int getFlags() {
return eaxBufferProperties.getInt(flags_offset);
}
/**
* Sets the modifier for behavior of properties
*
* @param flags modifier for behavior of properties to set to
*/
public void setFlags(int flags) {
eaxBufferProperties.putInt(flags_offset, flags);
autoCommit();
}
// --------------------------------------------------------------------------
/**
* Retrieves the size of the EAXBUFFERPROPERTIES
*/
protected static native int sizeOfEaxBufferProperties();
/**
* Sets the offsets to the fields
*/
protected static native void assignOffsets();
}

691
src/java/org/lwjgl/openal/eax/EAXListenerProperties.java
View file

@ -1,691 +0,0 @@
/*
* Copyright (c) 2002-2004 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.lwjgl.openal.eax;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import org.lwjgl.Sys;
/**
* $Id$
*
* This class encapsultaes the EAXLISTENERPROPERTIES struct
*
* @author Brian Matzon <brian@matzon.dk>
* @version $Revision$
*/
public class EAXListenerProperties {
/** Whether auto commit has been anabled */
private boolean autoCommit = true;
/** ByteBuffer representing EAXLISTENERPROPERTIES */
protected ByteBuffer eaxListenerProperties;
/** size needed by ByteBuffer to contain EAXLISTENERPROPERTIES */
protected static int EAXLISTENERPROPERTIES_SIZE;
// EAX values and offsets
// ========================================================
/** room effect level offset */
protected static int room_offset;
/** room effect level at high frequencies offset */
protected static int roomHF_offset;
/**like DS3D flRolloffFactor but for room effect offset */
protected static int roomRolloffFactor_offset;
/** reverberation decay time at low frequencies offset */
protected static int decayTime_offset;
/** high-frequency to low-frequency decay time ratio offset */
protected static int decayHFRatio_offset;
/** early reflections level relative to room effect offset */
protected static int reflections_offset;
/** initial reflection delay time offset */
protected static int reflectionsDelay_offset;
/** late reverberation level relative to room effect offset */
protected static int reverb_offset;
/** late reverberation delay time relative to initial reflection offset */
protected static int reverbDelay_offset;
/** sets all listener properties offset */
protected static int environment_offset;
/** environment size in meters offset */
protected static int environmentSize_offset;
/** environment diffusion offset */
protected static int environmentDiffusion_offset;
/** change in level per meter at 5 kHz offset */
protected static int airAbsorptionHF_offset;
/** modifies the behavior of properties offset */
protected static int flags_offset;
public static final int EAXLISTENER_NONE = 0;
public static final int EAXLISTENER_ALLPARAMETERS = 1;
public static final int EAXLISTENER_ROOM = 2;
public static final int EAXLISTENER_ROOMHF = 3;
public static final int EAXLISTENER_ROOMROLLOFFFACTOR = 4;
public static final int EAXLISTENER_DECAYTIME = 5;
public static final int EAXLISTENER_DECAYHFRATIO = 6;
public static final int EAXLISTENER_REFLECTIONS = 7;
public static final int EAXLISTENER_REFLECTIONSDELAY = 8;
public static final int EAXLISTENER_REVERB = 9;
public static final int EAXLISTENER_REVERBDELAY = 10;
public static final int EAXLISTENER_ENVIRONMENT = 11;
public static final int EAXLISTENER_ENVIRONMENTSIZE = 12;
public static final int EAXLISTENER_ENVIRONMENTDIFFUSION = 13;
public static final int EAXLISTENER_AIRABSORPTIONHF = 14;
public static final int EAXLISTENER_FLAGS = 15;
/** changes take effect immediately */
public static final int EAXLISTENER_IMMEDIATE = 0x00000000;
/** changes take effect later */
public static final int EAXLISTENER_DEFERRED = 0x80000000;
public static final int EAXLISTENER_COMMITDEFERREDSETTINGS =
(EAXLISTENER_NONE | EAXLISTENER_IMMEDIATE);
/** reverberation decay time */
public static final int EAXLISTENERFLAGS_DECAYTIMESCALE = 0x00000001;
/** reflection level */
public static final int EAXLISTENERFLAGS_REFLECTIONSSCALE = 0x00000002;
/** initial reflection delay time */
public static final int EAXLISTENERFLAGS_REFLECTIONSDELAYSCALE = 0x00000004;
/** reflections level */
public static final int EAXLISTENERFLAGS_REVERBSCALE = 0x00000008;
/** late reverberation delay time */
public static final int EAXLISTENERFLAGS_REVERBDELAYSCALE = 0x00000010;
/** This flag limits high-frequency decay time according to air absorption. */
public static final int EAXLISTENERFLAGS_DECAYHFLIMIT = 0x00000020;
/** reserved future use */
public static final int EAXLISTENERFLAGS_RESERVED = 0xFFFFFFC0;
// property ranges and defaults:
public static final int EAXLISTENER_MINROOM = -10000;
public static final int EAXLISTENER_MAXROOM = 0;
public static final int EAXLISTENER_DEFAULTROOM = -1000;
public static final int EAXLISTENER_MINROOMHF = -10000;
public static final int EAXLISTENER_MAXROOMHF = 0;
public static final int EAXLISTENER_DEFAULTROOMHF = -100;
public static final float EAXLISTENER_MINROOMROLLOFFFACTOR = 0.0f;
public static final float EAXLISTENER_MAXROOMROLLOFFFACTOR = 10.0f;
public static final float EAXLISTENER_DEFAULTROOMROLLOFFFACTOR = 0.0f;
public static final float EAXLISTENER_MINDECAYTIME = 0.1f;
public static final float EAXLISTENER_MAXDECAYTIME = 20.0f;
public static final float EAXLISTENER_DEFAULTDECAYTIME = 1.49f;
public static final float EAXLISTENER_MINDECAYHFRATIO = 0.1f;
public static final float EAXLISTENER_MAXDECAYHFRATIO = 2.0f;
public static final float EAXLISTENER_DEFAULTDECAYHFRATIO = 0.83f;
public static final int EAXLISTENER_MINREFLECTIONS = -10000;
public static final int EAXLISTENER_MAXREFLECTIONS = 1000;
public static final int EAXLISTENER_DEFAULTREFLECTIONS = -2602;
public static final float EAXLISTENER_MINREFLECTIONSDELAY = 0.0f;
public static final float EAXLISTENER_MAXREFLECTIONSDELAY = 0.3f;
public static final float EAXLISTENER_DEFAULTREFLECTIONSDELAY = 0.007f;
public static final int EAXLISTENER_MINREVERB = -10000;
public static final int EAXLISTENER_MAXREVERB = 2000;
public static final int EAXLISTENER_DEFAULTREVERB = 200;
public static final float EAXLISTENER_MINREVERBDELAY = 0.0f;
public static final float EAXLISTENER_MAXREVERBDELAY = 0.1f;
public static final float EAXLISTENER_DEFAULTREVERBDELAY = 0.011f;
public static final int EAXLISTENER_MINENVIRONMENT = 0;
public static final int EAXLISTENER_MAXENVIRONMENT =
(EAX20.EAX_ENVIRONMENT_COUNT - 1);
public static final int EAXLISTENER_DEFAULTENVIRONMENT =
EAX20.EAX_ENVIRONMENT_GENERIC;
public static final float EAXLISTENER_MINENVIRONMENTSIZE = 1.0f;
public static final float EAXLISTENER_MAXENVIRONMENTSIZE = 100.0f;
public static final float EAXLISTENER_DEFAULTENVIRONMENTSIZE = 7.5f;
public static final float EAXLISTENER_MINENVIRONMENTDIFFUSION = 0.0f;
public static final float EAXLISTENER_MAXENVIRONMENTDIFFUSION = 1.0f;
public static final float EAXLISTENER_DEFAULTENVIRONMENTDIFFUSION = 1.0f;
public static final float EAXLISTENER_MINAIRABSORPTIONHF = -100.0f;
public static final float EAXLISTENER_MAXAIRABSORPTIONHF = 0.0f;
public static final float EAXLISTENER_DEFAULTAIRABSORPTIONHF = -5.0f;
public static final int EAXLISTENER_DEFAULTFLAGS =
(EAXLISTENERFLAGS_DECAYTIMESCALE
| EAXLISTENERFLAGS_REFLECTIONSSCALE
| EAXLISTENERFLAGS_REFLECTIONSDELAYSCALE
| EAXLISTENERFLAGS_REVERBSCALE
| EAXLISTENERFLAGS_REVERBDELAYSCALE
| EAXLISTENERFLAGS_DECAYHFLIMIT);
// -------------------------------------------------------
static {
Sys.initialize();
EAXLISTENERPROPERTIES_SIZE = sizeOfEaxListenerProperties();
assignOffsets();
}
public EAXListenerProperties() {
eaxListenerProperties =
ByteBuffer.allocateDirect(EAXLISTENERPROPERTIES_SIZE);
eaxListenerProperties.order(ByteOrder.nativeOrder());
}
/**
* Loads current EAX values
*/
public void loadEAXValues() {
EAX20.eaxGet(
EAX20.LISTENER_GUID,
EAXLISTENER_ALLPARAMETERS,
0,
eaxListenerProperties,
EAXLISTENERPROPERTIES_SIZE );
}
/**
* Resets this buffer property to default values
*/
public void reset() {
boolean commitValue = autoCommit;
// disable autocommit
autoCommit = false;
// set values
setRoom(EAXLISTENER_DEFAULTROOM);
setRoomHF(EAXLISTENER_DEFAULTROOMHF);
setRoomRolloffFactor(EAXLISTENER_DEFAULTROOMROLLOFFFACTOR);
setDecayTime(EAXLISTENER_DEFAULTDECAYTIME);
setDecayTimeHFRatio(EAXLISTENER_DEFAULTDECAYHFRATIO);
setReflections(EAXLISTENER_DEFAULTREFLECTIONS);
setReflectionsDelay(EAXLISTENER_DEFAULTREFLECTIONSDELAY);
setReverb(EAXLISTENER_DEFAULTREVERB);
setReverbDelay(EAXLISTENER_DEFAULTREVERBDELAY);
setEnvironment(EAXLISTENER_DEFAULTENVIRONMENT);
setEnvironmentSize(EAXLISTENER_DEFAULTENVIRONMENTSIZE);
setEnvironmentDiffusion(EAXLISTENER_DEFAULTENVIRONMENTDIFFUSION);
setAirAbsorptionFactor(EAXLISTENER_DEFAULTAIRABSORPTIONHF);
setFlags(EAXLISTENER_DEFAULTFLAGS);
// reset auto commit
autoCommit = commitValue;
}
/**
* Commits any changes
*/
public void commit() {
// call eaxSet with Listener guid, setting all parameters
EAX20.eaxSet(
EAX20.LISTENER_GUID, EAXLISTENER_ALLPARAMETERS | EAXLISTENER_IMMEDIATE,
0, eaxListenerProperties, EAXLISTENERPROPERTIES_SIZE);
}
/**
* Tests whether auto commit is enabled or not
*
* @return true if auto commit is inabled
*/
public boolean isAutoCommitEnabled() {
return autoCommit;
}
/**
* Enabled or disables auto commit
*
* @param enabled True to enable, false to disable
*/
public void setAutoCommit(boolean enabled) {
autoCommit = enabled;
}
/**
* Performs auto commit, if enabled
*/
private final void autoCommit() {
if(autoCommit) {
commit();
}
}
/**
* Retrieves the size of the containing ByteBuffer
*/
public int getSize() {
return EAXLISTENERPROPERTIES_SIZE;
}
/**
* Returns a String representation of the EAXBufferProperties object
*
* @return String representation of the EAXBufferProperties object
*/
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append("EAXListenerProperties [");
sb.append("lRoom = ");
sb.append(getRoom());
sb.append(", ");
sb.append("lRoomHF = ");
sb.append(getRoomHF());
sb.append(", ");
sb.append("flRoomRolloffFactor = ");
sb.append(getRoomRolloffFactor());
sb.append(", ");
sb.append("flDecayTime = ");
sb.append(getDecayTime());
sb.append(", ");
sb.append("flDecayHFRatio = ");
sb.append(getDecayTimeHFRatio());
sb.append(", ");
sb.append("lReflections = ");
sb.append(getReflections());
sb.append(", ");
sb.append("flReflectionsDelay = ");
sb.append(getReflectionsDelay());
sb.append(", ");
sb.append("lReverb = ");
sb.append(getReverb());
sb.append(", ");
sb.append("flReverbDelay = ");
sb.append(getReverbDelay());
sb.append(", ");
sb.append("dwEnvironment = ");
sb.append(getEnvironment());
sb.append(", ");
sb.append("flEnvironmentSize = ");
sb.append(getEnvironmentSize());
sb.append(", ");
sb.append("flEnvironmentDiffusion = ");
sb.append(getEnvironmentDiffusion());
sb.append(", ");
sb.append("flAirAbsorptionHF = ");
sb.append(getAirAbsorptionHF());
sb.append(", ");
sb.append("dwFlags = ");
sb.append(getFlags());
sb.append("]");
return sb.toString();
}
// Getters and Setters of struct
// ==========================================================================
/**
* Retireves the room effect level
*
* @return room effect level
*/
public int getRoom() {
return eaxListenerProperties.getInt(room_offset);
}
/**
* Sets the room effect level
*
* @param room room effect level to set to
*/
public void setRoom(int room) {
eaxListenerProperties.putInt(room_offset, room);
autoCommit();
}
/**
* Retireves the room effect level at high frequencies
*
* @return room effect level at high frequencies
*/
public int getRoomHF() {
return eaxListenerProperties.getInt(roomHF_offset);
}
/**
* Sets the room effect level at high frequencies
*
* @param roomHF room effect level at high frequencies to set to
*/
public void setRoomHF(int roomHF) {
eaxListenerProperties.putInt(roomHF_offset, roomHF);
autoCommit();
}
/**
* Retireves the DS3D flRolloffFactor for room effect
*
* @return DS3D flRolloffFactor for room effect
*/
public float getRoomRolloffFactor() {
return eaxListenerProperties.getFloat(roomRolloffFactor_offset);
}
/**
* Sets the DS3D flRolloffFactor for room effect
*
* @param roomRolloffFactor DS3D flRolloffFactor for room effect to set to
*/
public void setRoomRolloffFactor(float roomRolloffFactor) {
eaxListenerProperties.putFloat(roomRolloffFactor_offset, roomRolloffFactor);
autoCommit();
}
/**
* Retireves the reverberation decay time at low frequencies
*
* @return reverberation decay time at low frequencies
*/
public float getDecayTime() {
return eaxListenerProperties.getFloat(decayTime_offset);
}
/**
* Sets the reverberation decay time at low frequencies
*
* @param decayTime reverberation decay time at low frequencies to set to
*/
public void setDecayTime(float decayTime) {
eaxListenerProperties.putFloat(decayTime_offset, decayTime);
autoCommit();
}
/**
* Retireves the high-frequency to low-frequency decay time ratio
*
* @return high-frequency to low-frequency decay time ratio
*/
public float getDecayTimeHFRatio() {
return eaxListenerProperties.getFloat(decayHFRatio_offset);
}
/**
* Sets the high-frequency to low-frequency decay time ratio
*
* @param decayTimeHFRatio high-frequency to low-frequency decay time ratio to set to
*/
public void setDecayTimeHFRatio(float decayTimeHFRatio) {
eaxListenerProperties.putFloat(decayHFRatio_offset, decayTimeHFRatio);
autoCommit();
}
/**
* Retireves the early reflections level relative to room effect
*
* @return early reflections level relative to room effect
*/
public int getReflections() {
return eaxListenerProperties.getInt(reflections_offset);
}
/**
* Sets the early reflections level relative to room effect
*
* @param reflections early reflections level relative to room effect to set to
*/
public void setReflections(int reflections) {
eaxListenerProperties.putInt(reflections_offset, reflections);
autoCommit();
}
/**
* Retireves the initial reflection delay time
*
* @return initial reflection delay time
*/
public float getReflectionsDelay() {
return eaxListenerProperties.getFloat(reflectionsDelay_offset);
}
/**
* Sets the initial reflection delay time
*
* @param reflectionsDelay initial reflection delay time to set to
*/
public void setReflectionsDelay(float reflectionsDelay) {
eaxListenerProperties.putFloat(reflectionsDelay_offset, reflectionsDelay);
autoCommit();
}
/**
* Retireves the late reverberation level relative to room effect
*
* @return late reverberation level relative to room effect
*/
public int getReverb() {
return eaxListenerProperties.getInt(reverb_offset);
}
/**
* Sets the late reverberation level relative to room effect
*
* @param reverb late reverberation level relative to room effect to set to
*/
public void setReverb(int reverb) {
eaxListenerProperties.putInt(reverb_offset, reverb);
autoCommit();
}
/**
* Retireves the late reverberation delay time relative to initial reflection
*
* @return late reverberation delay time relative to initial reflection
*/
public float getReverbDelay() {
return eaxListenerProperties.getFloat(reverbDelay_offset);
}
/**
* Sets the late reverberation delay time relative to initial reflection
*
* @param reverbDelay late reverberation delay time relative to initial reflection
*/
public void setReverbDelay(float reverbDelay) {
eaxListenerProperties.putFloat(reverbDelay_offset, reverbDelay);
autoCommit();
}
/**
* Retireves the listener properties
*
* @return listener properties
*/
public int getEnvironment() {
return eaxListenerProperties.getInt(environment_offset);
}
/**
* Sets the listener properties
*
* @param environment listener properties to set to
*/
public void setEnvironment(int environment) {
eaxListenerProperties.putInt(environment_offset, environment);
// we need to handle environment differently than all other
// values on auto commit, since it cannot be single handely set
// using ALLPARAMETERS
//
// To set the environment specifically we need to pass
// only the environment value and its size. Also pass the
// EAXLISTENER_ENVIRONMENT value (and since we're committing IMMEDIATE too)
if (autoCommit) {
EAX20.eaxSet(
EAX20.LISTENER_GUID, EAXLISTENER_ENVIRONMENT | EAXLISTENER_IMMEDIATE,
0, eaxListenerProperties.position(environment_offset), 4);
// rewind buffer
eaxListenerProperties.rewind();
}
}
/**
* Retireves the environment size in meters
*
* @return environment size in meters
*/
public float getEnvironmentSize() {
return eaxListenerProperties.getFloat(environmentSize_offset);
}
/**
* Sets the environment size in meters
*
* @param environmentSize environment size in meters to set to
*/
public void setEnvironmentSize(float environmentSize) {
eaxListenerProperties.putFloat(environmentSize_offset, environmentSize);
// we need to handle environment size differently than all other
// values on auto commit, since it cannot be single handely set
// using ALLPARAMETERS
//
// To set the environment size specifically we need to pass
// only the environment size value and its size. Also pass the
// EAXLISTENER_ENVIRONMENTSIZE value (and since we're committing IMMEDIATE too)
if (autoCommit) {
EAX20.eaxSet(
EAX20.LISTENER_GUID, EAXLISTENER_ENVIRONMENTSIZE | EAXLISTENER_IMMEDIATE,
0, eaxListenerProperties.position(environmentSize_offset), 4);
// rewind buffer
eaxListenerProperties.rewind();
}
}
/**
* Retireves the environment diffusion
*
* @return environment diffusion
*/
public float getEnvironmentDiffusion() {
return eaxListenerProperties.getFloat(environmentDiffusion_offset);
}
/**
* Sets the environment diffusion
*
* @param environmentDiffusion environment diffusion to set to
*/
public void setEnvironmentDiffusion(float environmentDiffusion) {
eaxListenerProperties.putFloat(environmentDiffusion_offset, environmentDiffusion);
autoCommit();
}
/**
* Retireves the change in level per meter at 5 kHz
*
* @return change in level per meter at 5 kHz
*/
public float getAirAbsorptionHF() {
return eaxListenerProperties.getFloat(airAbsorptionHF_offset);
}
/**
* Sets the change in level per meter at 5 kHz
*
* @param airAbsorptionHF change in level per meter at 5 kHz to set to
*/
public void setAirAbsorptionFactor(float airAbsorptionHF) {
eaxListenerProperties.putFloat(airAbsorptionHF_offset, airAbsorptionHF);
autoCommit();
}
/**
* Retireves the modifier for behavior of properties
*
* @return modifier for behavior of properties
*/
public int getFlags() {
return eaxListenerProperties.getInt(flags_offset);
}
/**
* Sets the modifier for behavior of properties
*
* @param flags modifier for behavior of properties to set to
*/
public void setFlags(int flags) {
eaxListenerProperties.putInt(flags_offset, flags);
autoCommit();
}
// --------------------------------------------------------------------------
/**
* Retrieves the size of the EAXLISTENERPROPERTIES
*/
protected static native int sizeOfEaxListenerProperties();
/**
* Sets the offsets to the fields
*/
protected static native void assignOffsets();
}

290
src/java/org/lwjgl/test/openal/EAXTest.java
View file

@ -1,290 +0,0 @@
/*
* Copyright (c) 2002-2004 LWJGL Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of 'LWJGL' nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.lwjgl.test.openal;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.IntBuffer;
import org.lwjgl.BufferUtils;
import org.lwjgl.Sys;
import org.lwjgl.openal.AL;
import org.lwjgl.openal.AL10;
import org.lwjgl.openal.eax.EAX;
import org.lwjgl.openal.eax.EAX20;
import org.lwjgl.openal.eax.EAXBufferProperties;
import org.lwjgl.openal.eax.EAXListenerProperties;
/**
* $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 {
/** OpenAL buffers */
private IntBuffer soundBuffers = BufferUtils.createIntBuffer(1);
/** OpenAL sources */
private IntBuffer soundSources = BufferUtils.createIntBuffer(1);
/** Listener EAX property object */
private EAXListenerProperties listenerProperties;
/** Buffer EAX property object */
private EAXBufferProperties bufferProperties;
/**
* Creates an instance of EAXTest
*/
public EAXTest() {
super();
}
/**
* Runs the actual test, using supplied arguments
*/
protected void execute(String[] args) {
if(!AL.isCreated()) {
System.out.println("Unable to continue with EAXTest, since OpenAL could not be initialized.");
return;
}
try {
System.out.print("Testing EAX support...");
EAX.create();
System.out.println("supported!");
} catch (Exception e) {
System.out.println("not supported!");
}
// continue with test if EAX is supported
if (EAX.isCreated() && AL.isCreated() && initialize()) {
runTest();
// kill sources and buffers
AL10.alSourceStop(soundSources.get(0));
AL10.alDeleteSources(soundSources);
AL10.alDeleteBuffers(soundBuffers);
EAX.destroy();
}
//shutdown
alExit();
}
private boolean initialize() {
// creating buffers
Sys.log("Creating buffers");
AL10.alGenBuffers(soundBuffers);
soundBuffers.rewind();
// creating sources
Sys.log("Creating sources");
AL10.alGenSources(soundSources);
soundSources.rewind();
// load sound files (left, center, right).wav
Sys.log("Loading Footsteps.wav");
WaveData footsteps = WaveData.create("Footsteps.wav");
AL10.alBufferData(soundBuffers.get(0), footsteps.format, footsteps.data, footsteps.samplerate);
AL10.alSourcef(soundSources.get(0), AL10.AL_PITCH, 1.0f);
AL10.alSourcef(soundSources.get(0), AL10.AL_GAIN, 1.0f);
AL10.alSourcei(soundSources.get(0), AL10.AL_BUFFER, soundBuffers.get(0));
AL10.alSourcei(soundSources.get(0), AL10.AL_LOOPING, AL10.AL_TRUE);
// create eax property objects
listenerProperties = new EAXListenerProperties();
bufferProperties = new EAXBufferProperties();
// set buffer to work on source 0
bufferProperties.setCurrentSource(soundSources.get(0));
return AL10.alGetError() == AL10.AL_NO_ERROR;
}
/**
* Runs the actual EAXTest
*/
private void runTest() {
boolean running = true;
char key;
assert AL10.alIsBuffer(soundBuffers.get(0)) : "Failed to validate buffer";
// handle menu
do {
printMenu();
key = readInput();
switch (key) {
// play sound
case '1' : {
AL10.alSourcePlay(soundSources.get(0));
break;
}
// stop sound
case '2' : {
AL10.alSourceStop(soundSources.get(0));
break;
}
// add reverb
case '3' : {
listenerProperties.setEnvironment(EAX20.EAX_ENVIRONMENT_HANGAR);
break;
}
// remove reverb
case '4' : {
listenerProperties.setEnvironment(EAX20.EAX_ENVIRONMENT_GENERIC);
break;
}
// add occlusion
case '5' : {
bufferProperties.setOcclusion(bufferProperties.getOcclusion()-5000);
break;
}
// remove occlusion
case '6' : {
bufferProperties.setOcclusion(bufferProperties.getOcclusion()+5000);
break;
}
// add obstruction
case '7' : {
bufferProperties.setObstruction(bufferProperties.getObstruction()-5000);
break;
}
// remove obstruction
case '8' : {
bufferProperties.setObstruction(bufferProperties.getObstruction()+5000);
break;
}
// commit eax values
case 'c' : {
bufferProperties.commit();
listenerProperties.commit();
break;
}
// toggle autocommit
case 't' : {
bufferProperties.setAutoCommit(!bufferProperties.isAutoCommitEnabled());
listenerProperties.setAutoCommit(!listenerProperties.isAutoCommitEnabled());
System.out.println("\n[Buffer] Auto Commit is now: " + bufferProperties.isAutoCommitEnabled());
System.out.println("\n[Listen] Auto Commit is now: " + listenerProperties.isAutoCommitEnabled());
break;
}
// show current eax values
case 's' : {
System.out.println(bufferProperties);
System.out.println(listenerProperties);
break;
}
// load current eax values
case 'l' : {
bufferProperties.loadEAXValues();
listenerProperties.loadEAXValues();
break;
}
// reset to default values
case 'r' : {
bufferProperties.reset();
listenerProperties.reset();
break;
}
// quit demo
case 'q' : {
running = false;
break;
}
}
} while (running);
}
private void printMenu() {
System.out.println("");
System.out.println("EAXTest menu, please select an option from the following list:");
System.out.println("1: Play looping sound");
System.out.println("2: Stop looping sound");
System.out.println("3: Add reverberation effect");
System.out.println("4: Remove reverberation effect");
System.out.println("5: Add occlusion effect");
System.out.println("6: Remove occlusion effect");
System.out.println("7: Add obstruction effect");
System.out.println("8: Remove obstruction effect");
System.out.println("C: Commit current eax values");
System.out.println("L: Load current values");
System.out.println("T: Toggle autocomit");
System.out.println("R: Reset to inital values");
System.out.println("S: Show current values");
System.out.println("Q: Quit demo");
System.out.print("Input: ");
}
private char readInput() {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
try {
return br.readLine().toLowerCase().charAt(0);
} catch (IOException ioe) {
return 'q';
}
}
/**
* main entry point
*
* @param args String array containing arguments
*/
public static void main(String[] args) {
EAXTest eaxTest = new EAXTest();
eaxTest.execute(args);
}
}

25
src/java/org/lwjgl/test/openal/MovingSoundTest.java
View file

@ -36,9 +36,6 @@ import java.nio.IntBuffer;
import org.lwjgl.BufferUtils;
import org.lwjgl.input.Keyboard;
import org.lwjgl.openal.AL10;
import org.lwjgl.openal.eax.EAX;
import org.lwjgl.openal.eax.EAX20;
import org.lwjgl.openal.eax.EAXListenerProperties;
import org.lwjgl.opengl.Display;
import org.lwjgl.util.vector.Vector3f;
@ -82,8 +79,6 @@ public class MovingSoundTest extends BasicTest {
int lastError;
Vector3f sourcePosition = new Vector3f();
Vector3f listenerPosition = new Vector3f();
boolean eaxApplied = false;
EAXListenerProperties eaxListenerProp = null;
//initialize keyboard
try {
@ -147,16 +142,7 @@ public class MovingSoundTest extends BasicTest {
exit(lastError);
}
//setup EAX if possible
if (AL10.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");
System.out.println("Move source with arrow keys\nMove listener with right shift and arrowkeys\nExit with ESC");
while(!Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)) {
Display.update();
@ -185,15 +171,6 @@ public class MovingSoundTest extends BasicTest {
}
}
if(Keyboard.isKeyDown(Keyboard.KEY_E)) {
if(eaxApplied) {
eaxListenerProp.setEnvironment(EAX20.EAX_ENVIRONMENT_GENERIC);
} else {
eaxListenerProp.setEnvironment(EAX20.EAX_ENVIRONMENT_HANGAR);
}
eaxApplied = !eaxApplied;
}
if(Display.isCloseRequested()) {
break;
}