[Java-game-lib-cvs] CVS: LWJGL/src/native/linux MatrixOpCommon.cpp,NONE,1.1 MatrixOpCommon.h,NONE,1.1 org_lwjgl_Display.cpp,NONE,1.1 org_lwjgl_Math.cpp,NONE,1.1 org_lwjgl_Math_MatrixOpAdd_MatrixOpDirect.cpp,NONE,1.1 org_lwjgl_Math_MatrixOpAdd_MatrixOpSafe.cpp,NONE,1.1 org_lwjgl_Math_MatrixOpCopy_MatrixOpDirect.cpp,NONE,1.1 org_lwjgl_Math_MatrixOpCopy_MatrixOpSafe.cpp,NONE,1.1 org_lwjgl_Math_MatrixOpInvert_MatrixOpDirect.cpp,NONE,1.1 org_lwjgl_Math_MatrixOpInvert_MatrixOpSafe.cpp,NONE,1.1 org_lwjgl_Math_MatrixOpMultiply_MatrixOpDirect.cpp,NONE,1.1 org_lwjgl_Math_MatrixOpMultiply_MatrixOpSafe.cpp,NONE,1.1 org_lwjgl_Math_MatrixOpNegate_MatrixOpDirect.cpp,NONE,1.1 org_lwjgl_Math_MatrixOpNegate_MatrixOpSafe.cpp,NONE,1.1 org_lwjgl_Math_MatrixOpNormalise_MatrixOpDirect.cpp,NONE,1.1 org_lwjgl_Math_MatrixOpNormalise_MatrixOpSafe.cpp,NONE,1.1 org_lwjgl_Math_MatrixOpSubtract_MatrixOpDirect.cpp,NONE,1.1 org_lwjgl_Math_MatrixOpSubtract_MatrixOpSafe.cpp,NONE,1.1 org_lwjgl_Sys.cpp,NONE,1.1 org_lwjgl_input_Keyboard.cpp,NONE,1.1 org_lwjgl_input_Mouse.cpp,NONE,1.1 org_lwjgl_opengl_BaseGL.cpp,NONE,1.1 org_lwjgl_opengl_CoreGL.cpp,NONE,1.1 org_lwjgl_opengl_GL.cpp,NONE,1.1 org_lwjgl_opengl_GLU.cpp,NONE,1.1 Makefile,1.6,1.7 org_lwjgl_Display.c,1.6,NONE org_lwjgl_Sys.c,1.4,NONE org_lwjgl_input_Keyboard.c,1.2,NONE org_lwjgl_input_Mouse.c,1.4,NONE org_lwjgl_opengl_BaseGL.c,1.4,NONE org_lwjgl_opengl_CoreGL.c,1.3,NONE org_lwjgl_opengl_GL.c,1.3,NONE org_lwjgl_opengl_GLU.c,1.2,NONE

[Elias N. <eli...@us...>]

Update of /cvsroot/java-game-lib/LWJGL/src/native/linux
In directory sc8-pr-cvs1:/tmp/cvs-serv11750

Modified Files:
	Makefile 
Added Files:
	MatrixOpCommon.cpp MatrixOpCommon.h org_lwjgl_Display.cpp 
	org_lwjgl_Math.cpp 
	org_lwjgl_Math_MatrixOpAdd_MatrixOpDirect.cpp 
	org_lwjgl_Math_MatrixOpAdd_MatrixOpSafe.cpp 
	org_lwjgl_Math_MatrixOpCopy_MatrixOpDirect.cpp 
	org_lwjgl_Math_MatrixOpCopy_MatrixOpSafe.cpp 
	org_lwjgl_Math_MatrixOpInvert_MatrixOpDirect.cpp 
	org_lwjgl_Math_MatrixOpInvert_MatrixOpSafe.cpp 
	org_lwjgl_Math_MatrixOpMultiply_MatrixOpDirect.cpp 
	org_lwjgl_Math_MatrixOpMultiply_MatrixOpSafe.cpp 
	org_lwjgl_Math_MatrixOpNegate_MatrixOpDirect.cpp 
	org_lwjgl_Math_MatrixOpNegate_MatrixOpSafe.cpp 
	org_lwjgl_Math_MatrixOpNormalise_MatrixOpDirect.cpp 
	org_lwjgl_Math_MatrixOpNormalise_MatrixOpSafe.cpp 
	org_lwjgl_Math_MatrixOpSubtract_MatrixOpDirect.cpp 
	org_lwjgl_Math_MatrixOpSubtract_MatrixOpSafe.cpp 
	org_lwjgl_Sys.cpp org_lwjgl_input_Keyboard.cpp 
	org_lwjgl_input_Mouse.cpp org_lwjgl_opengl_BaseGL.cpp 
	org_lwjgl_opengl_CoreGL.cpp org_lwjgl_opengl_GL.cpp 
	org_lwjgl_opengl_GLU.cpp 
Removed Files:
	org_lwjgl_Display.c org_lwjgl_Sys.c org_lwjgl_input_Keyboard.c 
	org_lwjgl_input_Mouse.c org_lwjgl_opengl_BaseGL.c 
	org_lwjgl_opengl_CoreGL.c org_lwjgl_opengl_GL.c 
	org_lwjgl_opengl_GLU.c 
Log Message:
Ported to C++. ported Math ops

--- NEW FILE: MatrixOpCommon.cpp ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/linux/MatrixOpCommon.cpp

//#include <iostream>
#include <jni.h>
#include <memory.h>
#include "MatrixOpCommon.h"

bool Matrix::identicalDataSpaces(Matrix & other)
{
    if (address != other.address)				
        return JNI_FALSE;
    if (stride  != other.stride)				
        return JNI_FALSE;
    if ((width * height) != (other.width * other.height)) 	 
        return JNI_FALSE;
    return JNI_TRUE;
}

bool Matrix::intersectingDataSpaces(Matrix & other)
{
    char * my_max_address    = &address[ stride * elements ];
    char * other_max_address = &other.address[ other.stride * other.elements];
    
    if (address >= other.address || address <= other_max_address)	return JNI_TRUE;
    if (other.address >= address || other.address <= my_max_address) return JNI_TRUE;
    return JNI_FALSE;
}

void Matrix::transposeMatrix(float * src, float * dst, int src_width, int src_height)
{
    // square matrix transpose
    if (src_width == src_height)
    {
        for (int i = 0; i < src_width; i++)
                for (int j = 0; j < src_width; j++)
                        dst[i + src_width * j] = src[j + i * src_width];
    }
    // non square matrix transpose
    else
    {
        for (int i = 0; i < src_width; i ++)
                for (int j = 0; j < src_height; j++)
                        dst[i + src_height * j] = src[j + i * src_height];
    }	
}

void Matrix::transposeMatrix(float * mat, int src_width, int src_height)
{
    float temp;

    // square matrix transpose
    if (src_width == src_height)
    {
            for (int col = 0; col < src_width; col++)
            {
                    for (int row = col+1; row < src_height; row++)
                    {
                            // swap the two elements
                            temp = mat [col * src_height + row];
                            mat[col * src_height + row] = mat[row * src_width + col];
                            mat[row * src_width + col] = temp;
                    }
            }
    }
    // non square matrix transpose
    else
    {
            transposeMatrix(mat, transpose_record, src_width, src_height);
            memcpy(mat, transpose_record, src_width * src_height * sizeof(float));
    }

}


MatrixSrc::MatrixSrc ( jint addr, jint s,
            jint w,    jint h, 
            jint e,	jboolean t):	
            Matrix(addr, s, e), 
            record_offset((char *) addr),
            record_size  (w*h)
{
    if (t) {	
        width = h;
        height = w;
    }
    else {
        width = w;
        height = h;
    }
    
    elements = e;
    record = new float[width * height];
    
    // vectors do not need to be transposed 
    transpose = (t == JNI_TRUE) && (w != 1) && (h != 1);
    
    if (transpose && (width != height))
        // only need temp storage for transpose if the matrix is not square
        transpose_record = new float[width*height];
    else
        transpose_record = 0;

    if (elements == 1)
    {
        // fool the nextMatrix function into returning a value
        elements = 2;
        nextMatrix();
        elements = 1;
    }
}

MatrixSrc::~MatrixSrc()
{
    //cout << "MatrixSrc destructor \n";
    
    delete [] record;
    
    if (transpose_record != 0)
       delete [] transpose_record;
}

float * MatrixSrc::nextMatrix()
{
    if (elements > 1)
    {
        //cout << "Elements: " << elements << "\n";
        //cout << "Address:  " << (unsigned int) (record_offset) << "\n";
        
        // the record is not properly aligned
        if ((unsigned int) (record_offset) & FLOAT_ALIGNMENT)
        {
            // copy the floats into a buffer so that they are aligned
            // on 4 byte margins (not necessary on intel, but a good thing)
            
            memcpy (record, record_offset, record_size * sizeof(float));

            if (transpose)
                transposeMatrix (record, height, width);

            record_offset = &record_offset[stride];
            current_record_ptr = record;
        }
        // the record is aligned but it has to be transposed
        else if (transpose)
        {
            transposeMatrix ((float *) (record_offset), record, height, width);
            record_offset = &record_offset[stride];
            current_record_ptr = record;
        }
        // nothing has to be done to the record
        else
        {
            // the floats are aligned in memory
            current_record_ptr = (float *) record_offset;
            record_offset = &record_offset[stride];
        }
    }

    return current_record_ptr;
}

MatrixDst::MatrixDst (jint addr, jint s, jint w, jint h, jint e, jboolean t): 
            Matrix(addr, s, e)	
{
    width = w;
    height = h;
    record_size = width * height;
    record = new float[record_size];

    // vectors do not need to be transposed 
    transpose = (t) && (w != 1) && (h != 1);
    
    if (transpose)
        transpose_record = new float[width*height];
    else
        transpose_record = 0;
        
    data_buffered   = JNI_FALSE;
    record_buffered = JNI_FALSE;
        
    record_offset = address - stride;
}

MatrixDst::~MatrixDst()
{
    //cout << "MatrixDst destructor \n";

    delete [] record;
    if (transpose_record != 0)
        delete [] transpose_record;

    // copy back any buffered data
    if (data_buffered)
    {
        char * src  = buffer;
        char * dest = address;
        
        for (int i = 0; i < elements; i++)
        {
            memcpy(dest, src, record_size * sizeof(float));
            src  += stride;
            dest += stride;
        }
        
        delete [] buffer;
    }
}

void MatrixDst::configureBuffer(MatrixSrc & a, MatrixSrc & b)
{


    if (!a.intersectingDataSpaces(b))
    {
        // as long as the output only overlays 1 of the sources, and the other
        // source only has 1 matrix in it, only a record_buffer is required
        if (a.elements == 1 && identicalDataSpaces(b))
            record_buffered = JNI_TRUE;
        else if (b.elements == 1 && identicalDataSpaces(a))
            record_buffered = JNI_TRUE;
        else 
        // otherwise all of the output has to be buffered
            createBuffer();
    }
    else
        createBuffer();
}

void MatrixDst::configureBuffer(MatrixSrc & a)
{
        if (identicalDataSpaces(a))
            record_buffered = JNI_TRUE;
        else if (intersectingDataSpaces(a))
            createBuffer();
}
            
void MatrixDst::createBuffer()
{
        data_buffered = JNI_TRUE;
        buffer = new char[ elements * stride ];
        record_offset = buffer - stride;
}

float * MatrixDst::nextMatrix()
{
    record_offset = &record_offset[stride];
    int alignment = ((unsigned int)(record_offset)) & FLOAT_ALIGNMENT;
    
    if (transpose || record_buffered || alignment)
    {
        last_record_in_temp = JNI_TRUE;
        return record;
    }
    else
    {
        last_record_in_temp = JNI_FALSE;
        return (float *) record_offset;
    }
}


void MatrixDst::writeComplete()
{	
    if (last_record_in_temp)
    {	
        // 3 reasons why the record would be in temp
        //
        //	1. The record is not aligned
        //	2. The result will need to be transposed
        //	3. Direct Mode where result would overlay an operand
        
        if (((unsigned int)(record_offset)) & FLOAT_ALIGNMENT)
        {
            if (transpose)
                transposeMatrix(record, width, height);
            memcpy (record, record_offset,  record_size * sizeof(jfloat));
        }
        else if (transpose)
        {
            transposeMatrix(record, (float *) &record_offset[0],  width, height);
        }
        else
            memcpy (record_offset, record, record_size * sizeof(jfloat));
    }
}

///////////////////////////////////////////////////////////////////////////

void subMatrix (const float * src, int side, float * dst , int col_omit, int row_omit)
{
    int index = 0;
    int src_index = 0;

    for (int c = 0; c < side; c++)
    {
        if (c == col_omit)
        {   src_index += side;
            continue;
        }
        for (int r = 0; r < side; r++)
        {
            if (r == row_omit)
            {	src_index++;
                continue;
            }
            dst[index++] = src[src_index++];
        }
    }
} 

float determinant (const float * matrix , int side)
{


    // we are assuming for this case that the data is in column major format
    
    float det = 0;

    if (side == 2)
        // your basic cross product aka 2x2 determinant
        det = matrix[0] * matrix[3] - matrix[2] * matrix[1];	
    else
    {
        // create room to store the sub matrix
        int   temp_side  = side - 1;				// the dimensions of the sub matrix
        float * temp_matrix = new float[temp_side * temp_side];

        // keep the sign (this way we avoid an additional branch in the inner loop)
        float	sign = 1;
        
        for (int row = 0; row < side; row++)
        {
            // get a sub matrix by eliminating the 0th col and the specified row
            subMatrix(matrix, side, temp_matrix, 0, row);
            
            // add to the determinant sign * [a]i0 * [M]i0
            det += sign * matrix[row] * determinant (temp_matrix, temp_side);
            
            // alternate the sign
            sign *= -1;
        }
        
        delete [] temp_matrix;
    }
    
    return det;
}

--- NEW FILE: MatrixOpCommon.h ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/linux/MatrixOpCommon.h
/*
 *  Matrix.h
 *  
 *
 *  Created by tristan on Sat Aug 24 2002.
 *  Copyright (c) 2001 __MyCompanyName__. All rights reserved.
 *
 */
 


////////////////////////////////////////////////////////////////////////////////////////
// Utility Functions
////////////////////////////////////////////////////////////////////////////////////////

#define FLOAT_ALIGNMENT 0x00000003

// 23 bit mantisa on a float (we need error for checking if two nums are equal)
// for now use error of 1/2^18, this could be refined up to 1/2^22 if needed
#define FLOATING_POINT_ERROR (1.0f/262144.0f)

// check if two numbers are approximately equal, used when floating point errors
// occur.  Should NEVER check to see if two floats are identical

inline bool approxEqual(float a, float b)
{
    a -= b;
    a = (a < 0) ? -a: a;
    return (a < FLOATING_POINT_ERROR);
}

float determinant (const float * matrix , int side);
void subMatrix    (const float * src, int side, float * dst , int col_omit, int row_omit);



///////////////////////////////////////////////////////////////////////////////////////
// Matrix
//////////////////////////////////////////////////////////////////////////////////////

class Matrix
{
    protected:
        float * transpose_record;		// to use while transposing the record

    public:
        char * address;		// the start of the data
        jint stride;		// the distance between each record   
        jint 	 width, 	// the width of the matrix
                 height, 	// the height of the matrix
                 elements;	// the number of matricies
        jboolean transpose;	// whether this matrix is or will be transposed
       
        Matrix (jint a, jint s, jint e):
            address((char *)a), stride(s), elements(e) {}
        bool identicalDataSpaces   (Matrix & other);
        bool intersectingDataSpaces(Matrix & other);
        void transposeMatrix(float * src, float * dst, int src_width, int src_height);
        void transposeMatrix(float * mat, int src_width, int src_height);
};

///////////////////////////////////////////////////////////////////////////////////////
// Src Matrix
//////////////////////////////////////////////////////////////////////////////////////

class MatrixSrc: public Matrix
{
    private:
        char * record_offset;		// the offset of this record in memory
    
        float * record;			// temporary storage to store a fully aligned and transposed
                                        // copy of the record, if the one in memory is not so
        float * current_record_ptr;	// the address of the memory containing the record last
                                        // returned by the nextMatrix() function
        jint record_size;		// the total floats in each record

    public:
        MatrixSrc ( jint address, jint stride, jint width, jint height, jint elements, jboolean transpose);
        ~MatrixSrc();
        
        void rewind() {	record_offset = address; }
        float * nextMatrix();

};

///////////////////////////////////////////////////////////////////////////////////////
// Dst Matrix
//////////////////////////////////////////////////////////////////////////////////////

class MatrixDst: public Matrix
{
    private:
        char  * record_offset;	// the offset of the record in memory
    
        jboolean data_buffered;	// if all of the data has to be buffered
        char * buffer;		// a buffer used when data_buffered
        
        jboolean last_record_in_temp;
        jboolean record_buffered;	// if only a single record is buffered
        float * record;		// to store data if source is unaligned
        
        jint record_size;
        void createBuffer();

    public:
        MatrixDst (jint address, jint stride, jint width, jint height, jint elements, jboolean transpose);
        ~MatrixDst();
        void configureBuffer(MatrixSrc & a, MatrixSrc & b);        
        void configureBuffer(MatrixSrc & a);    
        
        float * nextMatrix();
        void writeComplete();

};



--- NEW FILE: org_lwjgl_Display.cpp ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/linux/org_lwjgl_Display.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_Display.cpp,v 1.1 2002/11/19 08:50:57 elias_naur Exp $
 *
 * Linux specific library for display handling.
 *
 * @author elias_naur <eli...@us...>
 * @version $Revision: 1.1 $
 */


#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/extensions/xf86vmode.h>
#include <GL/glx.h>
#include <X11/Xutil.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <stdio.h>
#include <jni.h>
#include "org_lwjgl_Display.h"


Display * disp;
int screen;
int current_fullscreen;
Window win;
XF86VidModeModeInfo **avail_modes;
XVisualInfo * vis_info;

void waitMapped(Display *disp, Window win) {
	XEvent event;

	do {
		XMaskEvent(disp, StructureNotifyMask, &event);
	} while ((event.type != MapNotify) || (event.xmap.event != win));
}

int getDisplayModes(Display *disp, int screen, int *num_modes, XF86VidModeModeInfo ***avail_modes) {
	int event_base, error_base, xvid_ver, xvid_rev;
	
	if (!XF86VidModeQueryExtension(disp, &event_base, &error_base)) {
#ifdef _DEBUG
		printf("XF86VidMode extention not available\n");
#endif
		return 0;
	}
	XF86VidModeQueryVersion(disp, &xvid_ver, &xvid_rev);
#ifdef _DEBUG
	printf("XF86VidMode extention version %i.%i\n", xvid_ver, xvid_rev);
#endif
	XF86VidModeGetAllModeLines(disp, screen, num_modes, avail_modes);
	return 1;
}

JNIEXPORT jboolean JNICALL Java_org_lwjgl_Display_nCreate(JNIEnv * env, jclass clazz, jint width, jint height, jint bpp, jint freq, jboolean fullscreen) {
	Window root_win;
	XSetWindowAttributes attribs;
	Colormap cmap;
	int attribmask;
	int bpe = bpp/4;
	int attriblist[] = {GLX_RGBA, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 24, GLX_RED_SIZE, bpe, GLX_GREEN_SIZE, bpe, GLX_BLUE_SIZE, bpe, GLX_ALPHA_SIZE, bpe, None};
	int num_modes, i;

	current_fullscreen = fullscreen;
	disp = XOpenDisplay(NULL);
	if (disp == NULL) {
#ifdef _DEBUG
		printf("Could not open X connection\n");
#endif
		return JNI_FALSE;
	}
	screen = DefaultScreen(disp);
	if (!getDisplayModes(disp, screen, &num_modes, &avail_modes)) {
		XCloseDisplay(disp);
#ifdef _DEBUG
		printf("Could not get display modes\n");
#endif
		return JNI_FALSE;
	}
	root_win = RootWindow(disp, screen);

	vis_info = glXChooseVisual(disp, screen, attriblist);
	if (vis_info == NULL) {
		XCloseDisplay(disp);
#ifdef _DEBUG
		printf("Could not choose glx visual\n");
#endif
		return JNI_FALSE;
	}

	cmap = XCreateColormap(disp, root_win, vis_info->visual, AllocNone);
	attribs.colormap = cmap;
	attribs.event_mask = ExposureMask | FocusChangeMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask;
	attribs.background_pixel = 0xFF000000;
	attribs.event_mask = StructureNotifyMask;
	attribmask = CWColormap | CWBackPixel | CWEventMask;
	if (fullscreen) {
		attribmask |= CWOverrideRedirect;
		attribs.override_redirect = True;
	}
	win = XCreateWindow(disp, root_win, 0, 0, width, height, 0, vis_info->depth, InputOutput, vis_info->visual, attribmask, &attribs);
#ifdef _DEBUG
	printf("Created window\n");
#endif
	if (fullscreen) {
		XMapRaised(disp, win);
		waitMapped(disp, win);
		for ( i = 0; i < num_modes; ++i ) {
#ifdef _DEBUG
			printf("Mode %d: %dx%d\n", i, avail_modes[i]->hdisplay, avail_modes[i]->vdisplay);
#endif
			if (avail_modes[i]->hdisplay == width && avail_modes[i]->vdisplay == height) {
				if (!XF86VidModeSwitchToMode(disp, screen, avail_modes[i])) {
					XFree(vis_info);
					XFree(avail_modes);
					XDestroyWindow(disp, win);
					XCloseDisplay(disp);
#ifdef _DEBUG
					printf("Could not switch mode\n");
#endif
					return JNI_FALSE;
				}
			}
		}
		XF86VidModeSetViewPort(disp, screen, 0, 0);
	} else {
		XMapWindow(disp, win);
		waitMapped(disp, win);
	}
	XClearWindow(disp, win);
	XSync(disp, True);

	return JNI_TRUE;
}

JNIEXPORT void JNICALL Java_org_lwjgl_Display_nDestroy(JNIEnv * env, jclass clazz) {
	XDestroyWindow(disp, win);
	if (current_fullscreen) {
		if (!XF86VidModeSwitchToMode(disp, screen, avail_modes[0])) {
#ifdef _DEBUG
			printf("Could not switch mode\n");
#endif
		}
	}
	XFree(avail_modes);
	XFree(vis_info);
	XCloseDisplay(disp);
#ifdef _DEBUG
	printf("Closed X connection\n");
#endif
}

/*
 * Class:     org_lwjgl_Display
 * Method:    getAvailableDisplayModes
 * Signature: ()[Lorg/lwjgl/DisplayMode;
 */
JNIEXPORT jobjectArray JNICALL Java_org_lwjgl_Display_getAvailableDisplayModes
  (JNIEnv * env, jclass clazz)
{
	int num_modes, i;

	Display *disp = XOpenDisplay(NULL);
	int screen = DefaultScreen(disp);
	XF86VidModeModeInfo **avail_modes;

	int depth = DefaultDepth(disp, screen);

	if (disp == NULL) {
#ifdef _DEBUG
		printf("Could not open X connection\n");
#endif
		return NULL;
	}
	if (!getDisplayModes(disp, screen, &num_modes, &avail_modes)) {
#ifdef _DEBUG
		printf("Could not get display modes\n");
#endif
		return NULL;
	}
	// Allocate an array of DisplayModes big enough
	jclass displayModeClass = env->FindClass("org/lwjgl/DisplayMode");
	jobjectArray ret = env->NewObjectArray(num_modes, displayModeClass, NULL);
	jmethodID displayModeConstructor = env->GetMethodID(displayModeClass, "<init>", "(IIII)V");
	
	for (i = 0; i < num_modes; i++) {
		jobject displayMode = env->NewObject(displayModeClass, displayModeConstructor, avail_modes[i]->hdisplay, avail_modes[i]->vdisplay, depth, 0);
		env->SetObjectArrayElement(ret, i, displayMode);
	}
	XFree(avail_modes);
	XCloseDisplay(disp);
	return ret;
}


--- NEW FILE: org_lwjgl_Math.cpp ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/linux/org_lwjgl_Math.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_Math.cpp,v 1.1 2002/11/19 08:50:57 elias_naur Exp $
 *
 * Win32 maths library.
 *
 * @author cix_foo <ci...@us...>
 * @version $Revision: 1.1 $
 */

//#include "org_lwjgl_Math.h"


--- NEW FILE: org_lwjgl_Math_MatrixOpAdd_MatrixOpDirect.cpp ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/linux/org_lwjgl_Math_MatrixOpAdd_MatrixOpDirect.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_Math_MatrixOpAdd_MatrixOpDirect.cpp,v 1.1 2002/11/19 08:50:57 elias_naur Exp $
 *
 * linux math library.
 *
 * @author elias_naur <eli...@us...>
 * @version $Revision: 1.1 $
 */

#include "org_lwjgl_Math_MatrixOpAdd_MatrixOpDirect.h"
#include "MatrixOpCommon.h"
/*
 * Class:     org_lwjgl_Math_MatrixOpAdd_MatrixOpDirect
 * Method:    execute
 * Signature: (IIIIIZIIIIIZIIZ)V
 */
JNIEXPORT void JNICALL Java_org_lwjgl_Math_00024MatrixOpAdd_00024MatrixOpDirect_execute
  (
	JNIEnv * env,
	jobject obj,
	jint leftSourceAddress,
	jint leftSourceStride,
	jint leftElements,
	jint leftSourceWidth,
	jint leftSourceHeight,
	jboolean transposeLeftSource,
	jint rightSourceAddress,
	jint rightSourceStride,
	jint rightElements,
	jint rightSourceWidth,
	jint rightSourceHeight,
	jboolean transposeRightSource,
	jint destAddress,
	jint destStride,
	jboolean transposeDest
  )
{
        MatrixSrc left  (leftSourceAddress,  leftSourceStride, 
                            leftSourceWidth,  leftSourceHeight,  leftElements,  transposeLeftSource);
        MatrixSrc right (rightSourceAddress, leftSourceStride, 
                            rightSourceWidth, rightSourceHeight, rightElements, transposeRightSource);
        MatrixDst dest  (destAddress,        destStride,      
                            left.width, left.height, left.elements * right.elements, transposeDest);
        
        dest.configureBuffer(left, right);
        
        float * leftMatrix, * rightMatrix, * destMatrix;
        
        left.rewind();
        for (int i = 0; i < left.elements; i++)
        {
            leftMatrix = left.nextMatrix();
            
            right.rewind();
            for (int j = 0; j < right.elements; j++)
            {
                rightMatrix = right.nextMatrix();
                destMatrix  =  dest.nextMatrix();
                
                int k = dest.width * dest.height;
                while (k--)
                    destMatrix[k] = leftMatrix[k] + rightMatrix[k];
                
                dest.writeComplete();
            }
        }
        
}


--- NEW FILE: org_lwjgl_Math_MatrixOpAdd_MatrixOpSafe.cpp ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/linux/org_lwjgl_Math_MatrixOpAdd_MatrixOpSafe.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_Math_MatrixOpAdd_MatrixOpSafe.cpp,v 1.1 2002/11/19 08:50:57 elias_naur Exp $
 *
 * linux math library.
 *
 * @author elias_naur <eli...@us...>
 * @version $Revision: 1.1 $
 */

#include "org_lwjgl_Math_MatrixOpAdd_MatrixOpSafe.h"
#include "MatrixOpCommon.h"
/*
 * Class:     org_lwjgl_Math_MatrixOpAdd_MatrixOpSafe
 * Method:    execute
 * Signature: (IIIIIZIIIIIZIIZ)V
 */
JNIEXPORT void JNICALL Java_org_lwjgl_Math_00024MatrixOpAdd_00024MatrixOpSafe_execute
  (
	JNIEnv * env,
	jobject obj,
	jint leftSourceAddress,
	jint leftSourceStride,
	jint leftElements,
	jint leftSourceWidth,
	jint leftSourceHeight,
	jboolean transposeLeftSource,
	jint rightSourceAddress,
	jint rightSourceStride,
	jint rightElements,
	jint rightSourceWidth,
	jint rightSourceHeight,
	jboolean transposeRightSource,
	jint destAddress,
	jint destStride,
	jboolean transposeDest
  )
{
        MatrixSrc left  (leftSourceAddress,  leftSourceStride, 
                            leftSourceWidth,  leftSourceHeight,  leftElements,  transposeLeftSource);
        MatrixSrc right (rightSourceAddress, leftSourceStride, 
                            rightSourceWidth, rightSourceHeight, rightElements, transposeRightSource);
        MatrixDst dest  (destAddress,        destStride,      
                            left.width, left.height, left.elements * right.elements, transposeDest);
        
        float * leftMatrix, * rightMatrix, * destMatrix;
        
        left.rewind();
        for (int i = 0; i < leftElements; i++)
        {
            leftMatrix = left.nextMatrix();
            right.rewind();
            
            for (int j = 0; j < rightElements; j++)
            {
                rightMatrix = right.nextMatrix();
                destMatrix  =  dest.nextMatrix();
                
                int k = dest.width * dest.height;
                while (k--)
                    destMatrix[k] = leftMatrix[k] + rightMatrix[k];
                
                dest.writeComplete();
            }
        }
}



--- NEW FILE: org_lwjgl_Math_MatrixOpCopy_MatrixOpDirect.cpp ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/linux/org_lwjgl_Math_MatrixOpCopy_MatrixOpDirect.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_Math_MatrixOpCopy_MatrixOpDirect.cpp,v 1.1 2002/11/19 08:50:57 elias_naur Exp $
 *
 * linux math library.
 *
 * @author elias_naur <eli...@us...>
 * @version $Revision: 1.1 $
 */

#include "org_lwjgl_Math_MatrixOpCopy_MatrixOpDirect.h"
#include "MatrixOpCommon.h"
#include <string.h>

/*
 * Class:     org_lwjgl_Math_MatrixOpCopy_MatrixOpDirect
 * Method:    execute
 * Signature: (IIIIIZIIZ)V
 */
JNIEXPORT void JNICALL Java_org_lwjgl_Math_00024MatrixOpCopy_00024MatrixOpDirect_execute
  (
	JNIEnv * env,
	jobject obj,
	jint sourceAddress,
	jint sourceStride,
	jint numElements,
	jint sourceWidth,
	jint sourceHeight,
	jboolean transposeSource,
	jint destAddress,
	jint destStride,
	jboolean transposeDest
  )
{
        if (transposeSource == transposeDest)
        {
            transposeSource = false;
            transposeDest   = false;
        }

        MatrixSrc source (sourceAddress,  sourceStride, sourceWidth,  sourceHeight, numElements, transposeSource);
        MatrixDst dest  (destAddress,     destStride,   source.width, source.height, source.elements, transposeDest);
        
        dest.configureBuffer(source);
        
        float * srcMatrix, * destMatrix;
        int matrixByteCount = source.width*source.height*sizeof(jfloat);
        
        for (int i = 0; i < source.elements; i++)
        {
            srcMatrix = source.nextMatrix();
            destMatrix = dest.nextMatrix();
            
            // just do a straight memory copy
            memcpy(destMatrix, srcMatrix, matrixByteCount);
            dest.writeComplete();
        }
}




--- NEW FILE: org_lwjgl_Math_MatrixOpCopy_MatrixOpSafe.cpp ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/linux/org_lwjgl_Math_MatrixOpCopy_MatrixOpSafe.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_Math_MatrixOpCopy_MatrixOpSafe.cpp,v 1.1 2002/11/19 08:50:57 elias_naur Exp $
 *
 * linux math library.
 *
 * @author elias_naur <eli...@us...>
 * @version $Revision: 1.1 $
 */

#include "org_lwjgl_Math_MatrixOpCopy_MatrixOpSafe.h"
#include "MatrixOpCommon.h"
#include <string.h>

/*
 * Class:     org_lwjgl_Math_MatrixOpCopy_MatrixOpSafe
 * Method:    execute
 * Signature: (IIIIIZIIZ)V
 */
JNIEXPORT void JNICALL Java_org_lwjgl_Math_00024MatrixOpCopy_00024MatrixOpSafe_execute
  (
	JNIEnv * env,
	jobject obj,
	jint sourceAddress,
	jint sourceStride,
	jint numElements,
	jint sourceWidth,
	jint sourceHeight,
	jboolean transposeSource,
	jint destAddress,
	jint destStride,
	jboolean transposeDest
  )
{
        // remove any unnecessary copying
        if (transposeSource == transposeDest)
        {
            transposeSource = false;
            transposeDest   = false;
        }

        MatrixSrc source  (sourceAddress,  sourceStride, sourceWidth,  sourceHeight, numElements, transposeSource);
        MatrixDst dest  (destAddress,    destStride,   source.width, source.height,  source.elements, transposeDest);
        
        float * srcMatrix, * destMatrix;
        int matrixByteCount = source.width*source.height*sizeof(jfloat);
        
        for (int i = 0; i < source.elements; i++)
        {
            srcMatrix = source.nextMatrix();
            destMatrix = dest.nextMatrix();
            
            // just do a straight memory copy
            memcpy(destMatrix, srcMatrix, matrixByteCount);
            dest.writeComplete();
        }
}

--- NEW FILE: org_lwjgl_Math_MatrixOpInvert_MatrixOpDirect.cpp ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/linux/org_lwjgl_Math_MatrixOpInvert_MatrixOpDirect.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_Math_MatrixOpInvert_MatrixOpDirect.cpp,v 1.1 2002/11/19 08:50:57 elias_naur Exp $
 *
 * Win32 math library.
 *
 * @author cix_foo <ci...@us...>
 * @version $Revision: 1.1 $
 */

#include "org_lwjgl_Math_MatrixOpInvert_MatrixOpDirect.h"
#include "MatrixOpCommon.h"
#ifdef _DEBUG
#include <stdio.h>
#endif
/*
 * Class:     org_lwjgl_Math_MatrixOpInvert_MatrixOpDirect
 * Method:    execute
 * Signature: (IIIIIZIIZ)V
 */
JNIEXPORT void JNICALL Java_org_lwjgl_Math_00024MatrixOpInvert_00024MatrixOpDirect_execute
  (
	JNIEnv * env,
	jobject obj,
	jint sourceAddress,
	jint sourceStride,
	jint numElements,
	jint sourceWidth,
	jint sourceHeight,
	jboolean transposeSource,
	jint destAddress,
	jint destStride,
	jboolean transposeDest
  )
{
        if (transposeSource == transposeDest)
        {
            transposeSource = JNI_FALSE;
            transposeDest   = JNI_FALSE;
        }


        // We are under the assumption that sourceWidth == sourceHeight and the matrix 
        // defined within is invertable
        
        MatrixSrc source  (sourceAddress,  sourceStride, 
                sourceWidth,  sourceHeight,  numElements, transposeSource);
        MatrixDst dest  (destAddress,      destStride,   
                source.width, source.height, source.elements, transposeDest);
    
        dest.configureBuffer(source);
    
        float * srcMatrix, * destMatrix;
        
        int   temp_side = source.width-1;
        float temp_matrix [temp_side*temp_side];
 
       for (int i = 0; i < source.elements; i++)
        {
            srcMatrix    = source.nextMatrix();
            destMatrix   = dest  .nextMatrix();

            // calculate the determinant
            float det = determinant(srcMatrix, source.width);
            
#ifdef _DEBUG
            printf("Matrix Determinant: %f\n", det);
            printf("Matrix Determinant - 1 = %f\n", det -1);
#endif
                
                float sign;
                
                for (int col = 0; col < source.width; col++)
                {
                    /*
                        Maintain sign:
                        
                        + - + - ...
                        - + - + ..
                        + - + - ..
                        - + - + ..
                        : : : : \
                    */
                
                    sign = (col & 1) ? -1.0f : 1.0f;
                    
                    for (int row = 0; row < source.height; row++)
                    {
                        // get the sub matrix
                        subMatrix(srcMatrix, source.width, temp_matrix, col, row);
                        
                        // transpose the result
                        destMatrix[col + row * source.height] 
                                = (sign / det) * determinant(temp_matrix, temp_side); 
                        
                        // swap signs
                        sign *= -1.0f;
                    }
                }
        
            dest.writeComplete();
        }
}

--- NEW FILE: org_lwjgl_Math_MatrixOpInvert_MatrixOpSafe.cpp ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/linux/org_lwjgl_Math_MatrixOpInvert_MatrixOpSafe.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_Math_MatrixOpInvert_MatrixOpSafe.cpp,v 1.1 2002/11/19 08:50:57 elias_naur Exp $
 *
 * linux math library.
 *
 * @author elias_naur <eli...@us...>
 * @version $Revision: 1.1 $
 */
 
#include "org_lwjgl_Math_MatrixOpInvert_MatrixOpSafe.h"
#include "MatrixOpCommon.h"

#ifdef _DEBUG
#include <stdio.h>
#endif

/*
 * Class:     org_lwjgl_Math_MatrixOpInvert_MatrixOpSafe
 * Method:    execute
 * Signature: (IIIIIZIIZ)V
 */
JNIEXPORT void JNICALL Java_org_lwjgl_Math_00024MatrixOpInvert_00024MatrixOpSafe_execute
  (
	JNIEnv * env,
	jobject obj,
	jint sourceAddress,
	jint sourceStride,
	jint numElements,
	jint sourceWidth,
	jint sourceHeight,
	jboolean transposeSource,
	jint destAddress,
	jint destStride,
	jboolean transposeDest
  )
{

        if (transposeSource == transposeDest)
        {
            transposeSource = JNI_FALSE;
            transposeDest   = JNI_FALSE;
        }
        
        // We are under the assumption that sourceWidth == sourceHeight and the matrix 
        // defined within is invertable
        
        MatrixSrc source  (sourceAddress,  sourceStride, 
                sourceWidth,  sourceHeight,  numElements, transposeSource);
        MatrixDst dest  (destAddress,      destStride,   
                source.width, source.height, source.elements, transposeDest);
    
        float * srcMatrix, * destMatrix;
        
        int   temp_side = source.width-1;
        float temp_matrix [temp_side*temp_side];
 
        for (int i = 0; i < source.elements; i++)
        {
            srcMatrix = source.nextMatrix();
            destMatrix   = dest.nextMatrix();

            // calculate the determinant
            float det = determinant(srcMatrix, source.width);
            
#ifdef _DEBUG
            printf("Matrix Determinant: %f\n", det);
            printf("Matrix Determinant - 1: %f\n", det-1);
#endif
                
            float sign;
                
                for (int col = 0; col < source.width; col++)
                {
                    /*
                        Maintain sign:
                        
                        + - + - ...
                        - + - + ..
                        + - + - ..
                        - + - + ..
                        : : : : \
                    */
                
                    sign = (col & 1) ? -1.0f : 1.0f;
                    
                    for (int row = 0; row < source.height; row++)
                    {
                        // get the sub matrix
                        subMatrix(srcMatrix, source.width, temp_matrix, col, row);
                        
                        // transpose the result
                        destMatrix[col + row * source.height] 
                                = (sign / det) * determinant(temp_matrix, temp_side); 
                        
                        // swap signs
                        sign *= -1.0f;
                    }
                }
        
            dest.writeComplete();

        }
}

--- NEW FILE: org_lwjgl_Math_MatrixOpMultiply_MatrixOpDirect.cpp ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/linux/org_lwjgl_Math_MatrixOpMultiply_MatrixOpDirect.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_Math_MatrixOpMultiply_MatrixOpDirect.cpp,v 1.1 2002/11/19 08:50:57 elias_naur Exp $
 *
 * linux math library.
 *
 * @author elias_naur <eli...@us...>
 * @version $Revision: 1.1 $
 */

#include "org_lwjgl_Math_MatrixOpMultiply_MatrixOpDirect.h"
#include "MatrixOpCommon.h"
#include <cstring>
/*
 * Class:     org_lwjgl_Math_MatrixOpMultiply_MatrixOpDirect
 * Method:    execute
 * Signature: (IIIIIZIIIIIZIIZ)V
 */
JNIEXPORT void JNICALL Java_org_lwjgl_Math_00024MatrixOpMultiply_00024MatrixOpDirect_execute
  (
	JNIEnv * env,
	jobject obj,
	jint leftSourceAddress,
	jint leftSourceStride,
	jint leftElements,
	jint leftSourceWidth,
	jint leftSourceHeight,
	jboolean transposeLeftSource,
	jint rightSourceAddress,
	jint rightSourceStride,
	jint rightElements,
	jint rightSourceWidth,
	jint rightSourceHeight,
	jboolean transposeRightSource,
	jint destAddress,
	jint destStride,
	jboolean transposeDest
  )
{
        if (transposeLeftSource && transposeRightSource)
        {
            transposeLeftSource = false;
            transposeRightSource = false;
            transposeDest = !transposeDest;
        }


        MatrixSrc left  (leftSourceAddress,  leftSourceStride, 
                        leftSourceWidth,  leftSourceHeight,  leftElements,  transposeLeftSource);
        MatrixSrc right (rightSourceAddress, leftSourceStride, 
                        rightSourceWidth, rightSourceHeight, rightElements, transposeRightSource);
        MatrixDst dest  (destAddress,        destStride,       
                        right.width, left.height, left.elements * right.elements, transposeDest);
        
        dest.configureBuffer(left, right);
        
        float * leftMatrix, * rightMatrix, * destMatrix;
        
        // check out discussions envolving ordering
        
        
         left.rewind();
        for (int i = 0; i < left.elements; i++)
        {
            leftMatrix = left.nextMatrix();
            
            right.rewind();
            for (int j = 0; j < right.elements; j++)
            {
                rightMatrix = right.nextMatrix();
                destMatrix  =  dest.nextMatrix();
                
                // zero the elements of the destination matrix
                for (int d = 0; d < dest.width * dest.height; d++)
                    destMatrix[d] = 0;
                
                // loop through each column of the right matrix
                int rightCell = 0;
                for (int rightCol = 0; rightCol < right.width; rightCol++)
                {
                    // [RxC] * [RxC]
                    // dest has same height as left
                    // dest has same width as  right
                    
                    int leftCell = 0;
                    for (int leftCol = 0; leftCol < left.width; leftCol++)
                    {
                        for (int leftRow = 0; leftRow < left.height; leftRow++)
                        {	
                            destMatrix[leftRow] += rightMatrix[rightCell] * leftMatrix[leftCell++];
                        }
                        rightCell ++ ;
                    }
                    
                    //rightMatrix = &rightMatrix[right.height];
                    destMatrix =  &destMatrix[dest.height];
                    
                }
                dest.writeComplete();
            }
        }        
}


--- NEW FILE: org_lwjgl_Math_MatrixOpMultiply_MatrixOpSafe.cpp ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/linux/org_lwjgl_Math_MatrixOpMultiply_MatrixOpSafe.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_Math_MatrixOpMultiply_MatrixOpSafe.cpp,v 1.1 2002/11/19 08:50:57 elias_naur Exp $
 *
 * linux math library.
 *
 * @author elias_naur <eli...@us...>
 * @version $Revision: 1.1 $
 */


#include "org_lwjgl_Math_MatrixOpMultiply_MatrixOpSafe.h"
#include "MatrixOpCommon.h"
#include <cstring>

/*
 * Class:     org_lwjgl_Math_MatrixOpMultiply_MatrixOpSafe
 * Method:    execute
 * Signature: (IIIIIZIIIIIZIIZ)V
 */
JNIEXPORT void JNICALL Java_org_lwjgl_Math_00024MatrixOpMultiply_00024MatrixOpSafe_execute
  (
	JNIEnv * env,
	jobject obj,
	jint leftSourceAddress,
	jint leftSourceStride,
	jint leftElements,
	jint leftSourceWidth,
	jint leftSourceHeight,
	jboolean transposeLeftSource,
	jint rightSourceAddress,
	jint rightSourceStride,
	jint rightElements,
	jint rightSourceWidth,
	jint rightSourceHeight,
	jboolean transposeRightSource,
	jint destAddress,
	jint destStride,
	jboolean transposeDest
  )
{
        if (transposeLeftSource && transposeRightSource)
        {
            transposeLeftSource = false;
            transposeRightSource = false;
            transposeDest = !transposeDest;
        }


        MatrixSrc left  (leftSourceAddress,  leftSourceStride, 
                        leftSourceWidth,  leftSourceHeight,  leftElements,  transposeLeftSource);
        MatrixSrc right (rightSourceAddress, leftSourceStride, 
                        rightSourceWidth, rightSourceHeight, rightElements, transposeRightSource);
        MatrixDst dest  (destAddress,        destStride,       
                        right.width, left.height, left.elements * right.elements, transposeDest);
        
        float * leftMatrix, * rightMatrix, * destMatrix;
        
        // check out discussions envolving ordering
        
        
        left.rewind();
        for (int i = 0; i < left.elements; i++)
        {
            leftMatrix = left.nextMatrix();
            
            right.rewind();
            for (int j = 0; j < right.elements; j++)
            {
                rightMatrix = right.nextMatrix();
                destMatrix  =  dest.nextMatrix();
                
                // zero the elements of the destination matrix
                for (int d = 0; d < dest.width * dest.height; d++)
                    destMatrix[d] = 0;
                
                // loop through each column of the right matrix
                int rightCell = 0;
                for (int rightCol = 0; rightCol < right.width; rightCol++)
                {
                    // [RxC] * [RxC]
                    // dest has same height as left
                    // dest has same width as  right
                    
                    int leftCell = 0;
                    for (int leftCol = 0; leftCol < left.width; leftCol++)
                    {
                        for (int leftRow = 0; leftRow < left.height; leftRow++)
                        {	
                            destMatrix[leftRow] += rightMatrix[rightCell] * leftMatrix[leftCell++];
                        }
                        rightCell ++ ;
                    }
                    
                    //rightMatrix = &rightMatrix[right.height];
                    destMatrix =  &destMatrix[dest.height];
                    
                }
                dest.writeComplete();
            }
        }
        
}



--- NEW FILE: org_lwjgl_Math_MatrixOpNegate_MatrixOpDirect.cpp ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/linux/org_lwjgl_Math_MatrixOpNegate_MatrixOpDirect.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 ...
 
[truncated message content]