java-game-lib-cvs Mailing List for Lightweight Java Game Library

Update of /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/input
In directory usw-pr-cvs1:/tmp/cvs-serv27405/src/java/org/lwjgl/input

Modified Files:
	GamePad.java Joystick.java Mouse.java Keyboard.java 
Log Message:
Minor adjustments to Javadoc comments

Index: GamePad.java
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/java/org/lwjgl/input/GamePad.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/input/GamePad.java,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- GamePad.java	19 Aug 2002 14:01:23 -0000	1.3
+++ GamePad.java	20 Aug 2002 14:55:29 -0000	1.4
@@ -116,7 +116,7 @@
 	 * "Create" the gamepad. The display must first have been created. The
 	 * reason for this is so the gamepad has a window to "focus" in.
 	 * 
-	 * @throw Exception if the gamepad could not be created for any reason
+	 * @throws Exception if the gamepad could not be created for any reason
 	 */
 	public static void create() throws Exception {
 		if (created)

Index: Joystick.java
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/java/org/lwjgl/input/Joystick.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/input/Joystick.java,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- Joystick.java	19 Aug 2002 14:01:23 -0000	1.3
+++ Joystick.java	20 Aug 2002 14:55:29 -0000	1.4
@@ -92,7 +92,7 @@
 	
 	/**
 	 * "Create" the joystick. The display must first have been created.
-	 * @throw Exception if the joystick could not be created for any reason
+	 * @throws Exception if the joystick could not be created for any reason
 	 */
 	public static void create() throws Exception {
 		if (created)

Index: Mouse.java
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/java/org/lwjgl/input/Mouse.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/input/Mouse.java,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- Mouse.java	19 Aug 2002 14:01:23 -0000	1.5
+++ Mouse.java	20 Aug 2002 14:55:29 -0000	1.6
@@ -90,7 +90,7 @@
 	
 	/**
 	 * "Create" the mouse. The display must first have been created.
-	 * @throw Exception if the mouse could not be created for any reason
+	 * @throws Exception if the mouse could not be created for any reason
 	 */
 	public static void create() throws Exception {
 		if (created)

Index: Keyboard.java
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/java/org/lwjgl/input/Keyboard.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/input/Keyboard.java,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- Keyboard.java	19 Aug 2002 14:01:23 -0000	1.6
+++ Keyboard.java	20 Aug 2002 14:55:29 -0000	1.7
@@ -224,7 +224,7 @@
 	 * "Create" the keyboard. The display must first have been created. The
 	 * reason for this is so the keyboard has a window to "focus" in.
 	 * 
-	 * @throw Exception if the keyboard could not be created for any reason
+	 * @throws Exception if the keyboard could not be created for any reason
 	 */
 	public static void create() throws Exception {
 		if (created)

Update of /cvsroot/java-game-lib/LWJGL/src/native/win32
In directory usw-pr-cvs1:/tmp/cvs-serv23363

Added Files:
	org_lwjgl_openal_ALC.cpp 
Log Message:
add: first stab at ALC

--- NEW FILE: org_lwjgl_openal_ALC.cpp ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/win32/org_lwjgl_openal_ALC.cpp
/* 
 * Copyright (c) 2002 Light Weight 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: org_lwjgl_openal_ALC.cpp,v 1.1 2002/08/20 14:46:04 matzon Exp $
 *
 * This is the actual JNI implementation of the OpenAL context/device library. 
 * 
 * @author Brian Matzon <br...@ma...>
 * @version $Revision: 1.1 $
 */
#include "org_lwjgl_openal_ALUT.h"

/* OpenAL includes */
#include <alc.h>

/**
 * This function returns strings related to the context.
 *
 * C Specification:
 * ALubyte * alcGetString(ALCdevice *device, ALenum token);
 */
JNIEXPORT jstring JNICALL Java_org_lwjgl_openal_ALC_getString (JNIEnv *env, jobject obj, jobject device, jint token) {
	jclass class_device		= env->GetObjectClass(device);
	jfieldID field_device	= env->GetFieldID(class_device, "device", "I");
	jint deviceaddress = env->GetIntField(obj, field_device);

	return env->NewStringUTF((const char*) alcGetString((ALCdevice*) deviceaddress, (ALenum) token));
}

/**
 * This function returns integers related to the context.
 * 
 * C Specification:
 * ALvoid alcGetIntegerv(ALCdevice *device, ALenum token, ALsizei size, ALint *dest);
 */
JNIEXPORT void JNICALL Java_org_lwjgl_openal_ALC_getIntegerv (JNIEnv *env, jobject obj, jobject device, jint token, jint size, jint dest) {
	jclass device_class		= env->GetObjectClass(device);
	jfieldID device_field	= env->GetFieldID(device_class, "device", "I");
	jint deviceaddress		= env->GetIntField(obj, device_field);

	alcGetIntegerv((ALCdevice*) deviceaddress, (ALenum) token, (ALsizei) size, (ALint*) dest);
}

/**
 * This function opens a device by name.
 * 
 * C Specification:
 * ALCdevice *alcOpenDevice( const ALubyte *tokstr );
 */
JNIEXPORT jobject JNICALL Java_org_lwjgl_openal_ALC_openDevice (JNIEnv *env, jobject obj, jstring tokstr) {
	ALubyte* tokenstring = (ALubyte*) (env->GetStringUTFChars(tokstr, 0));

	/* get device */
	ALCdevice* device = alcOpenDevice(tokenstring);

	/* get ready to create ALCdevice instance */
	jobject alcDevice_object	= NULL;
	jclass alcDevice_class		= NULL;
	jmethodID alcDevice_method	= NULL;

	/* find class and constructor */
	alcDevice_class		= env->FindClass("org/lwjgl/openal/ALCdevice");
	alcDevice_method	= env->GetMethodID(alcDevice_class, "<init>", "(I)V");

	/* create instance */
	alcDevice_object = env->NewObject(alcDevice_class, alcDevice_method, (int) device);

	/* clean up */
	env->ReleaseStringUTFChars((jstring)tokenstring, 0);

	return alcDevice_object;
}

/**
 * This function closes a device by name.
 * 
 * C Specification:
 * void alcCloseDevice( ALCdevice *dev );
 */
JNIEXPORT void JNICALL Java_org_lwjgl_openal_ALC_closeDevice (JNIEnv *env, jobject obj, jobject device) {
	jclass device_class		= env->GetObjectClass(device);
	jfieldID device_field	= env->GetFieldID(device_class, "device", "I");
	jint deviceaddress		= env->GetIntField(obj, device_field);

	alcCloseDevice((ALCdevice*) deviceaddress);
}

/**
 * This function creates a context using a specified device.
 * 
 * C Specification:
 * ALCcontext* alcCreateContext( ALCdevice *dev, ALint* attrlist );
 */
JNIEXPORT jobject JNICALL Java_org_lwjgl_openal_ALC_createContext (JNIEnv *env, jobject obj, jobject device, jint attrlist) {
	/* get device address */
	jclass device_class		= env->GetObjectClass(device);
	jfieldID device_field	= env->GetFieldID(device_class, "device", "I");
	jint deviceaddress		= env->GetIntField(obj, device_field);

	ALCcontext* context = alcCreateContext((ALCdevice*) deviceaddress, (ALint*) attrlist); 

	/* get ready to create ALCcontext instance */
	jobject alcContext_object	= NULL;
	jclass alcContext_class		= NULL;
	jmethodID alcContext_method	= NULL;

	/* find class and constructor */
	alcContext_class	= env->FindClass("org/lwjgl/openal/ALCcontext");
	alcContext_method	= env->GetMethodID(alcContext_class, "<init>", "(I)V");

	/* create instance */
	alcContext_object = env->NewObject(alcContext_class, alcContext_method, (int) context);

	return alcContext_object;
}

/**
 * This function makes a specified context the current context.
 *
 * C Specification:
 * ALCboolean alcMakeContextCurrent(ALCcontext *context);
 */
JNIEXPORT jboolean JNICALL Java_org_lwjgl_openal_ALC_makeContextCurrent (JNIEnv *env, jobject obj, jobject context) {
	/* get context address */
	jclass context_class	= env->GetObjectClass(context);
	jfieldID context_field	= env->GetFieldID(context_class, "context", "I");
	jint contextaddress		= env->GetIntField(obj, context_field);

	return alcMakeContextCurrent((ALCcontext*) contextaddress);
}

/**
 * This function tells a context to begin processing.
 * 
 * C Specification:
 * void alcProcessContext(ALCcontext *context);
 */
JNIEXPORT void JNICALL Java_org_lwjgl_openal_ALC_processContext (JNIEnv *env, jobject obj, jobject context) {
	/* get context address */
	jclass context_class	= env->GetObjectClass(context);
	jfieldID context_field	= env->GetFieldID(context_class, "context", "I");
	jint contextaddress		= env->GetIntField(obj, context_field);

	alcProcessContext((ALCcontext*) contextaddress);
}

/**
 * This function retrieves the current context.
 * 
 * C Specification:
 * ALCcontext* alcGetCurrentContext( ALvoid );
 */
JNIEXPORT jobject JNICALL Java_org_lwjgl_openal_ALC_getCurrentContext (JNIEnv *env, jobject obj) {

	ALCcontext* context = alcGetCurrentContext(); 

	/* get ready to create ALCcontext instance */
	jobject alcContext_object	= NULL;
	jclass alcContext_class		= NULL;
	jmethodID alcContext_method	= NULL;

	/* find class and constructor */
	alcContext_class	= env->FindClass("org/lwjgl/openal/ALCcontext");
	alcContext_method	= env->GetMethodID(alcContext_class, "<init>", "(I)V");

	/* create instance */
	alcContext_object = env->NewObject(alcContext_class, alcContext_method, (int) context);

	return alcContext_object;
}

/**
 * This function retrieves the specified contexts device
 * 
 * C Specification:
 * ALCdevice* alcGetContextsDevice(ALCcontext *context);
 */
JNIEXPORT jobject JNICALL Java_org_lwjgl_openal_ALC_getContextsDevice (JNIEnv *env, jobject obj, jobject context) {

	/* get context address */
	jclass context_class	= env->GetObjectClass(context);
	jfieldID context_field	= env->GetFieldID(context_class, "context", "I");
	jint contextaddress		= env->GetIntField(obj, context_field);

	ALCdevice* device = alcGetContextsDevice((ALCcontext*) contextaddress); 

		/* get ready to create ALCdevice instance */
	jobject alcDevice_object	= NULL;
	jclass alcDevice_class		= NULL;
	jmethodID alcDevice_method	= NULL;

	/* find class and constructor */
	alcDevice_class		= env->FindClass("org/lwjgl/openal/ALCdevice");
	alcDevice_method	= env->GetMethodID(alcDevice_class, "<init>", "(I)V");

	/* create instance */
	alcDevice_object = env->NewObject(alcDevice_class, alcDevice_method, (int) device);

	return alcDevice_object;
}

/**
 * This function suspends processing on a specified context.
 *
 * C Specification:
 * void alcSuspendContext(ALCcontext *context);
 */
JNIEXPORT void JNICALL Java_org_lwjgl_openal_ALC_suspendContext (JNIEnv *env, jobject obj, jobject context) {
	/* get context address */
	jclass context_class	= env->GetObjectClass(context);
	jfieldID context_field	= env->GetFieldID(context_class, "context", "I");
	jint contextaddress		= env->GetIntField(obj, context_field);

	alcSuspendContext((ALCcontext*) contextaddress);
}

/**
 * This function destroys a context.
 * 
 * C Specification:
 * void alcDestroyContext(ALCcontext *context);
 */
JNIEXPORT void JNICALL Java_org_lwjgl_openal_ALC_destroyContext (JNIEnv *env, jobject obj, jobject context) {
	/* get context address */
	jclass context_class	= env->GetObjectClass(context);
	jfieldID context_field	= env->GetFieldID(context_class, "context", "I");
	jint contextaddress		= env->GetIntField(obj, context_field);

	alcDestroyContext((ALCcontext*) contextaddress);
}

/**
 * This function retrieves the specified devices context error state.
 * 
 * C Specification:
 * ALCenum alcGetError(ALCdevice *device);
 */
JNIEXPORT jint JNICALL Java_org_lwjgl_openal_ALC_getError (JNIEnv *env, jobject obj, jobject device) {
	/* get device address */
	jclass device_class		= env->GetObjectClass(device);
	jfieldID device_field	= env->GetFieldID(device_class, "device", "I");
	jint deviceaddress		= env->GetIntField(obj, device_field);

	return (jint) alcGetError((ALCdevice*) deviceaddress);
}

/**
 * This function queries if a specified context extension is available.
 * 
 * C Specification:
 * ALboolean alcIsExtensionPresent(ALCdevice *device, ALubyte *extName);
 */
JNIEXPORT jboolean JNICALL Java_org_lwjgl_openal_ALC_isExtensionPresent (JNIEnv *env, jobject obj, jobject device, jstring extName) {
	/* get device address */
	jclass device_class		= env->GetObjectClass(device);
	jfieldID device_field	= env->GetFieldID(device_class, "device", "I");
	jint deviceaddress		= env->GetIntField(obj, device_field);
	
	/* get extension */
	ALubyte* functionname = (ALubyte*) (env->GetStringUTFChars(extName, 0));
	
	jboolean result = (jboolean) alcIsExtensionPresent((ALCdevice*) deviceaddress, functionname);
	
	env->ReleaseStringUTFChars((jstring)functionname, 0);
	
	return result;
}

/**
 * This function retrieves the address of a specified context extension function.
 *
 * C Specification:
 * ALvoid * alcGetProcAddress(ALCdevice *device, ALubyte *funcName);
 */
JNIEXPORT jint JNICALL Java_org_lwjgl_openal_ALC_getProcAddress (JNIEnv *env, jobject obj, jobject device, jstring funcName) {
	/* get device address */
	jclass device_class		= env->GetObjectClass(device);
	jfieldID device_field	= env->GetFieldID(device_class, "device", "I");
	jint deviceaddress		= env->GetIntField(obj, device_field);
	
	/* get extension */
	ALubyte* functionname = (ALubyte*) (env->GetStringUTFChars(funcName, 0));
	
	jint result = (jint) alcGetProcAddress((ALCdevice*) deviceaddress, functionname);
	
	env->ReleaseStringUTFChars((jstring)functionname, 0);
	
	return result;
}

/**
 * This function retrieves the enum value for a specified enumeration name.
 *
 * C Specification:
 * ALenum alcGetEnumValue(ALCdevice *device, ALubyte *enumName);
 */
JNIEXPORT jint JNICALL Java_org_lwjgl_openal_ALC_getEnumValue (JNIEnv *env, jobject obj, jobject device, jstring enumName) {
	/* get device address */
	jclass device_class		= env->GetObjectClass(device);
	jfieldID device_field	= env->GetFieldID(device_class, "device", "I");
	jint deviceaddress		= env->GetIntField(obj, device_field);
	
	/* get extension */
	ALubyte* enumerationname = (ALubyte*) (env->GetStringUTFChars(enumName, 0));
	
	jint result = (jint) alcGetEnumValue((ALCdevice*) deviceaddress, enumerationname);
	
	env->ReleaseStringUTFChars((jstring)enumerationname, 0);
	
	return result;
}

Update of /cvsroot/java-game-lib/LWJGL/src/native/common
In directory usw-pr-cvs1:/tmp/cvs-serv23186

Added Files:
	org_lwjgl_openal_ALC.h 
Log Message:
add: first stab at ALC

--- NEW FILE: org_lwjgl_openal_ALC.h ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/common/org_lwjgl_openal_ALC.h
/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class org_lwjgl_openal_ALC */

#ifndef _Included_org_lwjgl_openal_ALC
#define _Included_org_lwjgl_openal_ALC
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     org_lwjgl_openal_ALC
 * Method:    getString
 * Signature: (Lorg/lwjgl/openal/ALCdevice;I)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_org_lwjgl_openal_ALC_getString
  (JNIEnv *, jobject, jobject, jint);

/*
 * Class:     org_lwjgl_openal_ALC
 * Method:    getIntegerv
 * Signature: (Lorg/lwjgl/openal/ALCdevice;III)V
 */
JNIEXPORT void JNICALL Java_org_lwjgl_openal_ALC_getIntegerv
  (JNIEnv *, jobject, jobject, jint, jint, jint);

/*
 * Class:     org_lwjgl_openal_ALC
 * Method:    openDevice
 * Signature: (Ljava/lang/String;)Lorg/lwjgl/openal/ALCdevice;
 */
JNIEXPORT jobject JNICALL Java_org_lwjgl_openal_ALC_openDevice
  (JNIEnv *, jobject, jstring);

/*
 * Class:     org_lwjgl_openal_ALC
 * Method:    closeDevice
 * Signature: (Lorg/lwjgl/openal/ALCdevice;)V
 */
JNIEXPORT void JNICALL Java_org_lwjgl_openal_ALC_closeDevice
  (JNIEnv *, jobject, jobject);

/*
 * Class:     org_lwjgl_openal_ALC
 * Method:    createContext
 * Signature: (Lorg/lwjgl/openal/ALCdevice;I)Lorg/lwjgl/openal/ALCcontext;
 */
JNIEXPORT jobject JNICALL Java_org_lwjgl_openal_ALC_createContext
  (JNIEnv *, jobject, jobject, jint);

/*
 * Class:     org_lwjgl_openal_ALC
 * Method:    makeContextCurrent
 * Signature: (Lorg/lwjgl/openal/ALCcontext;)Z
 */
JNIEXPORT jboolean JNICALL Java_org_lwjgl_openal_ALC_makeContextCurrent
  (JNIEnv *, jobject, jobject);

/*
 * Class:     org_lwjgl_openal_ALC
 * Method:    processContext
 * Signature: (Lorg/lwjgl/openal/ALCcontext;)V
 */
JNIEXPORT void JNICALL Java_org_lwjgl_openal_ALC_processContext
  (JNIEnv *, jobject, jobject);

/*
 * Class:     org_lwjgl_openal_ALC
 * Method:    getCurrentContext
 * Signature: ()Lorg/lwjgl/openal/ALCcontext;
 */
JNIEXPORT jobject JNICALL Java_org_lwjgl_openal_ALC_getCurrentContext
  (JNIEnv *, jobject);

/*
 * Class:     org_lwjgl_openal_ALC
 * Method:    getContextsDevice
 * Signature: (Lorg/lwjgl/openal/ALCcontext;)Lorg/lwjgl/openal/ALCdevice;
 */
JNIEXPORT jobject JNICALL Java_org_lwjgl_openal_ALC_getContextsDevice
  (JNIEnv *, jobject, jobject);

/*
 * Class:     org_lwjgl_openal_ALC
 * Method:    suspendContext
 * Signature: (Lorg/lwjgl/openal/ALCcontext;)V
 */
JNIEXPORT void JNICALL Java_org_lwjgl_openal_ALC_suspendContext
  (JNIEnv *, jobject, jobject);

/*
 * Class:     org_lwjgl_openal_ALC
 * Method:    destroyContext
 * Signature: (Lorg/lwjgl/openal/ALCcontext;)V
 */
JNIEXPORT void JNICALL Java_org_lwjgl_openal_ALC_destroyContext
  (JNIEnv *, jobject, jobject);

/*
 * Class:     org_lwjgl_openal_ALC
 * Method:    getError
 * Signature: (Lorg/lwjgl/openal/ALCdevice;)I
 */
JNIEXPORT jint JNICALL Java_org_lwjgl_openal_ALC_getError
  (JNIEnv *, jobject, jobject);

/*
 * Class:     org_lwjgl_openal_ALC
 * Method:    isExtensionPresent
 * Signature: (Lorg/lwjgl/openal/ALCdevice;Ljava/lang/String;)Z
 */
JNIEXPORT jboolean JNICALL Java_org_lwjgl_openal_ALC_isExtensionPresent
  (JNIEnv *, jobject, jobject, jstring);

/*
 * Class:     org_lwjgl_openal_ALC
 * Method:    getProcAddress
 * Signature: (Lorg/lwjgl/openal/ALCdevice;Ljava/lang/String;)I
 */
JNIEXPORT jint JNICALL Java_org_lwjgl_openal_ALC_getProcAddress
  (JNIEnv *, jobject, jobject, jstring);

/*
 * Class:     org_lwjgl_openal_ALC
 * Method:    getEnumValue
 * Signature: (Lorg/lwjgl/openal/ALCdevice;Ljava/lang/String;)I
 */
JNIEXPORT jint JNICALL Java_org_lwjgl_openal_ALC_getEnumValue
  (JNIEnv *, jobject, jobject, jstring);

#ifdef __cplusplus
}
#endif
#endif

Update of /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/openal
In directory usw-pr-cvs1:/tmp/cvs-serv22824

Added Files:
	ALC.java ALCcontext.java ALCdevice.java 
Log Message:
add: first stab at ALC

--- NEW FILE: ALC.java ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/java/org/lwjgl/openal/ALC.java
/* 
 * Copyright (c) 2002 Light Weight 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.openal;

/**
 * $Id: ALC.java,v 1.1 2002/08/20 14:44:35 matzon Exp $
 *
 * This is the context class for OpenAL. This class implements functions
 * in alc.h
 *
 * @author Brian Matzon <br...@ma...>
 * @version $Revision: 1.1 $
 */
public class ALC {
    
    static {
        try {
            System.loadLibrary(org.lwjgl.Sys.getLibraryName());
        } catch (UnsatisfiedLinkError ule) {
            System.out.println("Failed to load OpenAL library: " + org.lwjgl.Sys.getLibraryName());
            ule.printStackTrace();
        }
    }
    
    /** Creates a new instance of ALC */
    public ALC() {
    }
    /**
     * Returns strings related to the context.
     *
     * @param device ALCdevice to query
     * @param pname Property to get
     * @return String property from device
     */
    public native String        getString(ALCdevice device, int pname);

    /**
     * Returns integers related to the context.
     *
     * @param device ALCdevice to query
     * @param pname Property to get
     * @param size Size of destination buffer provided
     * @param integerdata address of ByteBuffer to write integers to
     */
    public native void          getIntegerv(ALCdevice device, int pname, int size, int integerdata);
    
    /**
     * Opens the named device. If null is specied, the implementation will 
     * provide an implementation specic default.
     *
     * @param devicename name of device to open
     * @return opened device, or null
     */
    public native ALCdevice     openDevice(String devicename);
    
    /**
     * Closes the supplied device.
     *
     * @param device ALCdevice to close
     */
    public native void          closeDevice(ALCdevice device);
    
    /**
     * Creates a context using a specified device.
     *
     * @param device ALCdevice to associate context to
     * @param attrList address of ByteBuffer to read attributes from
     * @return New context, or null if creation failed
     */
    public native ALCcontext    createContext(ALCdevice device, int attrList);
    
    /**
     * Makes the supplied context the current one
     *
     * @param context ALCcontext to make current
     * @return true if successfull, false if not
     */ 
    public native boolean       makeContextCurrent(ALCcontext context);

    /**
     * Tells a context to begin processing.
     *
     * @param context context that should begin processing
     */
    public native void          processContext(ALCcontext context);
    
    /**
     * Gets the current context
     *
     * @return Current ALCcontext
     */
    public native ALCcontext    getCurrentContext();

    /**
     * Retrives the device associated with the supplied context
     *
     * @param context ALCcontext to get device for
     * @param ALCdevice associated with context
     */
    public native ALCdevice     getContextsDevice(ALCcontext context);

    /**
     * Suspends processing on supplied context
     *
     * @param context ALCcontext to suspend
     */
    public native void          suspendContext(ALCcontext context);
    
    /**
     * Destroys supplied context
     *
     * @param context ALCcontext to Destroy
     */
    public native void          destroyContext(ALCcontext context);

    /**
     * Retrieves the current context error state.
     *
     * @param device ALDdevice associated with context
     * @return Errorcode from ALC statemachine
     */
    public native int           getError(ALCdevice device);
    
    /**
     * Query if a specified context extension is available.
     *
     * @param device device to query for extension
     * @param extName name of extension to find
     * @return true if extension is available, false if not
     */
    public native boolean       isExtensionPresent(ALCdevice device, String extName);
    
    /**
     * Retrieves the address of a specified context extension function.
     *
     * @param device device to query
     * @param extName name of extension to find
     * @return address of function
     */
    public native int           getProcAddress(ALCdevice device, String extName);
    
    /**
     * retrieves the enum value for a specified enumeration name.
     * 
     * @param device Device to query
     * @param enumName name of enum to find
     * @return value of enumeration
     */
    public native int           getEnumValue(ALCdevice device, String enumName);    
}
--- NEW FILE: ALCcontext.java ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/java/org/lwjgl/openal/ALCcontext.java
/* 
 * Copyright (c) 2002 Light Weight 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.openal;

/**
 * $Id: ALCcontext.java,v 1.1 2002/08/20 14:44:35 matzon Exp $
 *
 * Wrapper class, to make ALC contexts behave like the orginal api.
 *
 * @author Brian Matzon <br...@ma...>
 * @version $Revision: 1.1 $
 */
public class ALCcontext {
    
    /** address of actual context */
    public final int context;
    
    /** 
     * Creates a new instance of ALCcontext 
     * 
     * @param context address of actual context
     */
    public ALCcontext(int context) {
        this.context = context;
    }    
}

--- NEW FILE: ALCdevice.java ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/java/org/lwjgl/openal/ALCdevice.java
/* 
 * Copyright (c) 2002 Light Weight 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.openal;

/**
 * $Id: ALCdevice.java,v 1.1 2002/08/20 14:44:35 matzon Exp $
 *
 * Wrapper class, to make ALC devices behave like the orginal api.
 *
 * @author Brian Matzon <br...@ma...>
 * @version $Revision: 1.1 $
 */
public class ALCdevice {
    
    /** address of actual device */
    public final int device;
    
    /** 
     * Creates a new instance of ALCdevice 
     *
     * @param device address of actual device
     */
    public ALCdevice(int device) {
        this.device = device;
    }   
}

Update of /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl
In directory usw-pr-cvs1:/tmp/cvs-serv23898/src/java/org/lwjgl

Modified Files:
	Math.java 
Log Message:
Ready for native code

Index: Math.java
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/java/org/lwjgl/Math.java
===================================================================
RCS file: /cvsroot/java-game-lib/LWJGL/src/java/org/lwjgl/Math.java,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- Math.java	19 Aug 2002 11:29:42 -0000	1.4
+++ Math.java	20 Aug 2002 09:29:50 -0000	1.5
@@ -46,7 +46,7 @@
 public final class Math {
 
 	static {
-		System.loadLibrary(Sys.LIBRARY_NAME);
+		System.loadLibrary(Sys.getLibraryName());
 	}
 
 	/** Floating point version of pi */
@@ -136,43 +136,17 @@
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return MATRIXOP_SAFE; }
 			protected MatrixOpClassification direct() { return MATRIXOP_DIRECT; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
 		};
 		
 		/**
 		 * A matrix operation is direct if the source and destination addresses
 		 * are the same, and the strides are the same.
 		 */
-		private final MatrixOpClassification MATRIXOP_DIRECT = new MatrixOpClassification() {
-			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
-			protected MatrixOpClassification safe() { return this; }
-			protected MatrixOpClassification direct() { return this; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
-			void execute(
-				int sourceAddress,
-				int sourceStride,
-				int numElements,
-				int sourceWidth,
-				int sourceHeight,
-				boolean transposeSource,
-				int destAddress,
-				int destStride,
-				boolean transposeDest)
-			{
-			}
-		};
-	
-	
-		/**
-		 * A matrix operation is offset if source > destination, and the
-		 * strides are the same
-		 */
-		private final MatrixOpClassification MATRIXOP_OFFSET = new MatrixOpClassification() {
+		private final class MatrixOpDirect extends MatrixOpClassification {
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return this; }
 			protected MatrixOpClassification direct() { return this; }
-			protected MatrixOpClassification offset() { return this; }
-			void execute(
+			native void execute(
 				int sourceAddress,
 				int sourceStride,
 				int numElements,
@@ -181,22 +155,19 @@
 				boolean transposeSource,
 				int destAddress,
 				int destStride,
-				boolean transposeDest)
-			{
-			}
+				boolean transposeDest);
 		};
-	
+		private final MatrixOpDirect MATRIXOP_DIRECT = new MatrixOpDirect();
 	
 		/**
 		 * A matrix operation is safe if the source and destination do not
 		 * overlap in any way
 		 */
-		private final MatrixOpClassification MATRIXOP_SAFE = new MatrixOpClassification() {
+		private final class MatrixOpSafe extends MatrixOpClassification {
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return MATRIXOP_SAFE; }
 			protected MatrixOpClassification direct() { return MATRIXOP_DIRECT; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
-			void execute(
+			native void execute(
 				int sourceAddress,
 				int sourceStride,
 				int numElements,
@@ -205,10 +176,9 @@
 				boolean transposeSource,
 				int destAddress,
 				int destStride,
-				boolean transposeDest)
-			{
-			}
+				boolean transposeDest);
 		};
+		private final MatrixOpSafe MATRIXOP_SAFE = new MatrixOpSafe();
 	};
 	public static final MatrixOpCopy MATRIXOP_COPY = new MatrixOpCopy();
 
@@ -230,43 +200,17 @@
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return MATRIXOP_SAFE; }
 			protected MatrixOpClassification direct() { return MATRIXOP_DIRECT; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
 		};
 		
 		/**
 		 * A matrix operation is direct if the source and destination addresses
 		 * are the same, and the strides are the same.
 		 */
-		private final MatrixOpClassification MATRIXOP_DIRECT = new MatrixOpClassification() {
-			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
-			protected MatrixOpClassification safe() { return this; }
-			protected MatrixOpClassification direct() { return this; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
-			void execute(
-				int sourceAddress,
-				int sourceStride,
-				int numElements,
-				int sourceWidth,
-				int sourceHeight,
-				boolean transposeSource,
-				int destAddress,
-				int destStride,
-				boolean transposeDest)
-			{
-			}
-		};
-	
-	
-		/**
-		 * A matrix operation is offset if source > destination, and the
-		 * strides are the same
-		 */
-		private final MatrixOpClassification MATRIXOP_OFFSET = new MatrixOpClassification() {
+		private final class MatrixOpDirect extends MatrixOpClassification {
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return this; }
 			protected MatrixOpClassification direct() { return this; }
-			protected MatrixOpClassification offset() { return this; }
-			void execute(
+			native void execute(
 				int sourceAddress,
 				int sourceStride,
 				int numElements,
@@ -275,22 +219,19 @@
 				boolean transposeSource,
 				int destAddress,
 				int destStride,
-				boolean transposeDest)
-			{
-			}
+				boolean transposeDest);
 		};
-	
+		private final MatrixOpDirect MATRIXOP_DIRECT = new MatrixOpDirect();
 	
 		/**
 		 * A matrix operation is safe if the source and destination do not
 		 * overlap in any way
 		 */
-		private final MatrixOpClassification MATRIXOP_SAFE = new MatrixOpClassification() {
+		private final class MatrixOpSafe extends MatrixOpClassification {
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return MATRIXOP_SAFE; }
 			protected MatrixOpClassification direct() { return MATRIXOP_DIRECT; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
-			void execute(
+			native void execute(
 				int sourceAddress,
 				int sourceStride,
 				int numElements,
@@ -299,10 +240,9 @@
 				boolean transposeSource,
 				int destAddress,
 				int destStride,
-				boolean transposeDest)
-			{
-			}
+				boolean transposeDest);
 		};
+		private final MatrixOpSafe MATRIXOP_SAFE = new MatrixOpSafe();
 	};
 	public static final MatrixOpNegate MATRIXOP_NEGATE = new MatrixOpNegate();
 
@@ -324,43 +264,17 @@
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return MATRIXOP_SAFE; }
 			protected MatrixOpClassification direct() { return MATRIXOP_DIRECT; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
 		};
 		
 		/**
 		 * A matrix operation is direct if the source and destination addresses
 		 * are the same, and the strides are the same.
 		 */
-		private final MatrixOpClassification MATRIXOP_DIRECT = new MatrixOpClassification() {
-			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
-			protected MatrixOpClassification safe() { return this; }
-			protected MatrixOpClassification direct() { return this; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
-			void execute(
-				int sourceAddress,
-				int sourceStride,
-				int numElements,
-				int sourceWidth,
-				int sourceHeight,
-				boolean transposeSource,
-				int destAddress,
-				int destStride,
-				boolean transposeDest)
-			{
-			}
-		};
-	
-	
-		/**
-		 * A matrix operation is offset if source > destination, and the
-		 * strides are the same
-		 */
-		private final MatrixOpClassification MATRIXOP_OFFSET = new MatrixOpClassification() {
+		private final class MatrixOpDirect extends MatrixOpClassification {
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return this; }
 			protected MatrixOpClassification direct() { return this; }
-			protected MatrixOpClassification offset() { return this; }
-			void execute(
+			native void execute(
 				int sourceAddress,
 				int sourceStride,
 				int numElements,
@@ -369,22 +283,19 @@
 				boolean transposeSource,
 				int destAddress,
 				int destStride,
-				boolean transposeDest)
-			{
-			}
+				boolean transposeDest);
 		};
-	
+		private final MatrixOpDirect MATRIXOP_DIRECT = new MatrixOpDirect();
 	
 		/**
 		 * A matrix operation is safe if the source and destination do not
 		 * overlap in any way
 		 */
-		private final MatrixOpClassification MATRIXOP_SAFE = new MatrixOpClassification() {
+		private final class MatrixOpSafe extends MatrixOpClassification {
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return MATRIXOP_SAFE; }
 			protected MatrixOpClassification direct() { return MATRIXOP_DIRECT; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
-			void execute(
+			native void execute(
 				int sourceAddress,
 				int sourceStride,
 				int numElements,
@@ -393,10 +304,9 @@
 				boolean transposeSource,
 				int destAddress,
 				int destStride,
-				boolean transposeDest)
-			{
-			}
+				boolean transposeDest);
 		};
+		private final MatrixOpSafe MATRIXOP_SAFE = new MatrixOpSafe();
 	};
 	public static final MatrixOpNormalise MATRIXOP_NORMALISE = new MatrixOpNormalise();
 
@@ -418,43 +328,17 @@
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return MATRIXOP_SAFE; }
 			protected MatrixOpClassification direct() { return MATRIXOP_DIRECT; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
 		};
 		
 		/**
 		 * A matrix operation is direct if the source and destination addresses
 		 * are the same, and the strides are the same.
 		 */
-		private final MatrixOpClassification MATRIXOP_DIRECT = new MatrixOpClassification() {
-			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
-			protected MatrixOpClassification safe() { return this; }
-			protected MatrixOpClassification direct() { return this; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
-			void execute(
-				int sourceAddress,
-				int sourceStride,
-				int numElements,
-				int sourceWidth,
-				int sourceHeight,
-				boolean transposeSource,
-				int destAddress,
-				int destStride,
-				boolean transposeDest)
-			{
-			}
-		};
-	
-	
-		/**
-		 * A matrix operation is offset if source > destination, and the
-		 * strides are the same
-		 */
-		private final MatrixOpClassification MATRIXOP_OFFSET = new MatrixOpClassification() {
+		private final class MatrixOpDirect extends MatrixOpClassification {
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return this; }
 			protected MatrixOpClassification direct() { return this; }
-			protected MatrixOpClassification offset() { return this; }
-			void execute(
+			native void execute(
 				int sourceAddress,
 				int sourceStride,
 				int numElements,
@@ -463,22 +347,19 @@
 				boolean transposeSource,
 				int destAddress,
 				int destStride,
-				boolean transposeDest)
-			{
-			}
+				boolean transposeDest);
 		};
-	
+		private final MatrixOpDirect MATRIXOP_DIRECT = new MatrixOpDirect();
 	
 		/**
 		 * A matrix operation is safe if the source and destination do not
 		 * overlap in any way
 		 */
-		private final MatrixOpClassification MATRIXOP_SAFE = new MatrixOpClassification() {
+		private final class MatrixOpSafe extends MatrixOpClassification {
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return MATRIXOP_SAFE; }
 			protected MatrixOpClassification direct() { return MATRIXOP_DIRECT; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
-			void execute(
+			native void execute(
 				int sourceAddress,
 				int sourceStride,
 				int numElements,
@@ -487,10 +368,9 @@
 				boolean transposeSource,
 				int destAddress,
 				int destStride,
-				boolean transposeDest)
-			{
-			}
+				boolean transposeDest);
 		};
+		private final MatrixOpSafe MATRIXOP_SAFE = new MatrixOpSafe();
 	};
 	public static final MatrixOpInvert MATRIXOP_INVERT = new MatrixOpInvert();
 
@@ -562,49 +442,17 @@
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return MATRIXOP_SAFE; }
 			protected MatrixOpClassification direct() { return MATRIXOP_DIRECT; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
 		};
 		
 		/**
 		 * A matrix operation is direct if the source and destination addresses
 		 * are the same, and the strides are the same.
 		 */
-		private final MatrixOpClassification MATRIXOP_DIRECT = new MatrixOpClassification() {
-			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
-			protected MatrixOpClassification safe() { return this; }
-			protected MatrixOpClassification direct() { return this; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
-			void execute(
-				int leftSourceAddress,
-				int leftSourceStride,
-				int leftElements,
-				int leftSourceWidth,
-				int leftSourceHeight,
-				boolean transposeLeftSource,
-				int rightSourceAddress,
-				int rightSourceStride,
-				int rightElements,
-				int rightSourceWidth,
-				int rightSourceHeight,
-				boolean transposeRightSource,
-				int destAddress,
-				int destStride,
-				boolean transposeDest)
-			{
-			}
-		};
-	
-	
-		/**
-		 * A matrix operation is offset if source > destination, and the
-		 * strides are the same
-		 */
-		private final MatrixOpClassification MATRIXOP_OFFSET = new MatrixOpClassification() {
+		private final class MatrixOpDirect extends MatrixOpClassification {
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return this; }
 			protected MatrixOpClassification direct() { return this; }
-			protected MatrixOpClassification offset() { return this; }
-			void execute(
+			native void execute(
 				int leftSourceAddress,
 				int leftSourceStride,
 				int leftElements,
@@ -619,22 +467,20 @@
 				boolean transposeRightSource,
 				int destAddress,
 				int destStride,
-				boolean transposeDest)
-			{
-			}
+				boolean transposeDest);
 		};
+		private final MatrixOpDirect MATRIXOP_DIRECT = new MatrixOpDirect();
 	
 	
 		/**
 		 * A matrix operation is safe if the source and destination do not
 		 * overlap in any way
 		 */
-		private final MatrixOpClassification MATRIXOP_SAFE = new MatrixOpClassification() {
+		private final class MatrixOpSafe extends MatrixOpClassification {
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return MATRIXOP_SAFE; }
 			protected MatrixOpClassification direct() { return MATRIXOP_DIRECT; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
-			void execute(
+			native void execute(
 				int leftSourceAddress,
 				int leftSourceStride,
 				int leftElements,
@@ -649,10 +495,9 @@
 				boolean transposeRightSource,
 				int destAddress,
 				int destStride,
-				boolean transposeDest)
-			{
-			}
+				boolean transposeDest);
 		};
+		private final MatrixOpSafe MATRIXOP_SAFE = new MatrixOpSafe();
 	};
 	public static final MatrixOpMultiply MATRIXOP_MULTIPLY = new MatrixOpMultiply();
 
@@ -694,49 +539,17 @@
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return MATRIXOP_SAFE; }
 			protected MatrixOpClassification direct() { return MATRIXOP_DIRECT; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
 		};
 		
 		/**
 		 * A matrix operation is direct if the source and destination addresses
 		 * are the same, and the strides are the same.
 		 */
-		private final MatrixOpClassification MATRIXOP_DIRECT = new MatrixOpClassification() {
-			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
-			protected MatrixOpClassification safe() { return this; }
-			protected MatrixOpClassification direct() { return this; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
-			void execute(
-				int leftSourceAddress,
-				int leftSourceStride,
-				int leftElements,
-				int leftSourceWidth,
-				int leftSourceHeight,
-				boolean transposeLeftSource,
-				int rightSourceAddress,
-				int rightSourceStride,
-				int rightElements,
-				int rightSourceWidth,
-				int rightSourceHeight,
-				boolean transposeRightSource,
-				int destAddress,
-				int destStride,
-				boolean transposeDest)
-			{
-			}
-		};
-	
-	
-		/**
-		 * A matrix operation is offset if source > destination, and the
-		 * strides are the same
-		 */
-		private final MatrixOpClassification MATRIXOP_OFFSET = new MatrixOpClassification() {
+		private final class MatrixOpDirect extends MatrixOpClassification {
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return this; }
 			protected MatrixOpClassification direct() { return this; }
-			protected MatrixOpClassification offset() { return this; }
-			void execute(
+			native void execute(
 				int leftSourceAddress,
 				int leftSourceStride,
 				int leftElements,
@@ -751,22 +564,20 @@
 				boolean transposeRightSource,
 				int destAddress,
 				int destStride,
-				boolean transposeDest)
-			{
-			}
+				boolean transposeDest);
 		};
+		private final MatrixOpDirect MATRIXOP_DIRECT = new MatrixOpDirect();
 	
 	
 		/**
 		 * A matrix operation is safe if the source and destination do not
 		 * overlap in any way
 		 */
-		private final MatrixOpClassification MATRIXOP_SAFE = new MatrixOpClassification() {
+		private final class MatrixOpSafe extends MatrixOpClassification {
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return MATRIXOP_SAFE; }
 			protected MatrixOpClassification direct() { return MATRIXOP_DIRECT; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
-			void execute(
+			native void execute(
 				int leftSourceAddress,
 				int leftSourceStride,
 				int leftElements,
@@ -781,10 +592,9 @@
 				boolean transposeRightSource,
 				int destAddress,
 				int destStride,
-				boolean transposeDest)
-			{
-			}
+				boolean transposeDest);
 		};
+		private final MatrixOpSafe MATRIXOP_SAFE = new MatrixOpSafe();
 	};
 	public static final MatrixOpAdd MATRIXOP_ADD = new MatrixOpAdd();
 
@@ -826,46 +636,16 @@
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return MATRIXOP_SAFE; }
 			protected MatrixOpClassification direct() { return MATRIXOP_DIRECT; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
 		};
 		
 		/**
 		 * A matrix operation is direct if the source and destination addresses
 		 * are the same, and the strides are the same.
 		 */
-		private final MatrixOpClassification MATRIXOP_DIRECT = new MatrixOpClassification() {
-			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
-			protected MatrixOpClassification safe() { return this; }
-			protected MatrixOpClassification direct() { return this; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
-			native void execute(
-				int leftSourceAddress,
-				int leftSourceStride,
-				int leftElements,
-				int leftSourceWidth,
-				int leftSourceHeight,
-				boolean transposeLeftSource,
-				int rightSourceAddress,
-				int rightSourceStride,
-				int rightElements,
-				int rightSourceWidth,
-				int rightSourceHeight,
-				boolean transposeRightSource,
-				int destAddress,
-				int destStride,
-				boolean transposeDest);
-		};
-	
-	
-		/**
-		 * A matrix operation is offset if source > destination, and the
-		 * strides are the same
-		 */
-		private final MatrixOpClassification MATRIXOP_OFFSET = new MatrixOpClassification() {
+		private final class MatrixOpDirect extends MatrixOpClassification {
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return this; }
 			protected MatrixOpClassification direct() { return this; }
-			protected MatrixOpClassification offset() { return this; }
 			native void execute(
 				int leftSourceAddress,
 				int leftSourceStride,
@@ -883,17 +663,17 @@
 				int destStride,
 				boolean transposeDest);
 		};
+		private final MatrixOpDirect MATRIXOP_DIRECT = new MatrixOpDirect();
 	
 	
 		/**
 		 * A matrix operation is safe if the source and destination do not
 		 * overlap in any way
 		 */
-		private final MatrixOpClassification MATRIXOP_SAFE = new MatrixOpClassification() {
+		private final class MatrixOpSafe extends MatrixOpClassification {
 			protected MatrixOpClassification unsafe() { return MATRIXOP_UNSAFE; }
 			protected MatrixOpClassification safe() { return MATRIXOP_SAFE; }
 			protected MatrixOpClassification direct() { return MATRIXOP_DIRECT; }
-			protected MatrixOpClassification offset() { return MATRIXOP_OFFSET; }
 			native void execute(
 				int leftSourceAddress,
 				int leftSourceStride,
@@ -911,6 +691,7 @@
 				int destStride,
 				boolean transposeDest);
 		};
+		private final MatrixOpSafe MATRIXOP_SAFE = new MatrixOpSafe();
 	};
 	public static final MatrixOpSubtract MATRIXOP_SUBTRACT = new MatrixOpSubtract();
 
@@ -998,8 +779,6 @@
 		abstract MatrixOpClassification unsafe();
 		abstract MatrixOpClassification safe();
 		abstract MatrixOpClassification direct();
-		abstract MatrixOpClassification offset();
-		
 		/**
 		 * Execute a unary matrix operation.
 		 * The default implementation does nothing.
@@ -1055,7 +834,7 @@
 				if (destAddress > sourceAddress || sourceStride != destStride)
 					return unsafe();
 				else if (destAddress < sourceAddress)
-					return offset();
+					return safe();
 				else
 					return direct();