[Java-game-lib-cvs] CVS: LWJGL/src/native/common MatrixOpCommon.cpp,NONE,1.1 MatrixOpCommon.h,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

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

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

Added Files:
	MatrixOpCommon.cpp MatrixOpCommon.h 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 
Log Message:
Moved Math functions to common

--- NEW FILE: MatrixOpCommon.cpp ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/common/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/common/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_Math.cpp ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/common/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/25 13:18:23 elias_naur Exp $
 *
 * maths library.
 *
 * @author cix_foo <ci...@us...>
 * @version $Revision: 1.1 $
 */
#ifdef _WIN32
#include <windows.h>
#endif
//#include "org_lwjgl_Math.h"
#include "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/common/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/25 13:18:23 elias_naur Exp $
 *
 * math library.
 *
 * @author cix_foo <ci...@us...>
 * @version $Revision: 1.1 $
 */

#ifdef _WIN32
#include <windows.h>
#endif
#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/common/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/25 13:18:23 elias_naur Exp $
 *
 * math library.
 *
 * @author cix_foo <ci...@us...>
 * @version $Revision: 1.1 $
 */

#ifdef _WIN32
#include <windows.h>
#endif
#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/common/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/25 13:18:23 elias_naur Exp $
 *
 * math library.
 *
 * @author cix_foo <ci...@us...>
 * @version $Revision: 1.1 $
 */
#ifdef _WIN32
#include <windows.h>
#endif
#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/common/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/25 13:18:23 elias_naur Exp $
 *
 * math library.
 *
 * @author cix_foo <ci...@us...>
 * @version $Revision: 1.1 $
 */

#ifdef _WIN32
#include <windows.h>
#endif
#include <string.h>
#include "org_lwjgl_Math_MatrixOpCopy_MatrixOpSafe.h"
#include "MatrixOpCommon.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/common/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/25 13:18:23 elias_naur Exp $
 *
 * math library.
 *
 * @author cix_foo <ci...@us...>
 * @version $Revision: 1.1 $
 */

#ifdef _WIN32
#include <windows.h>
#endif

#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
  )
{
        static float * temp_matrix = 0;
		static int temp_matrix_size = 0;

			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;

		if (temp_matrix_size < temp_side) {
			if (temp_matrix)
				delete[] temp_matrix;
			temp_matrix = new float[temp_side * temp_side];
			temp_matrix_size = 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/common/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/25 13:18:23 elias_naur Exp $
 *
 * Win32 math library.
 *
 * @author cix_foo <ci...@us...>
 * @version $Revision: 1.1 $
 */
 
#ifdef _WIN32
#include <windows.h>
#endif
#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
  )
{

        static float * temp_matrix = 0;
		static int temp_matrix_size = 0;

		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;
 
		if (temp_matrix_size < temp_side) {
			if (temp_matrix)
				delete[] temp_matrix;
			temp_matrix = new float[temp_side * temp_side];
			temp_matrix_size = 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/common/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/25 13:18:23 elias_naur Exp $
 *
 * math library.
 *
 * @author cix_foo <ci...@us...>
 * @version $Revision: 1.1 $
 */

#ifdef _WIN32
#include <windows.h>
#endif

#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/common/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/25 13:18:23 elias_naur Exp $
 *
 * Win32 math library.
 *
 * @author cix_foo <ci...@us...>
 * @version $Revision: 1.1 $
 */

#ifdef _WIN32
#include <windows.h>
#endif
#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/common/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 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_MatrixOpNegate_MatrixOpDirect.cpp,v 1.1 2002/11/25 13:18:23 elias_naur Exp $
 *
 * math library.
 *
 * @author cix_foo <ci...@us...>
 * @version $Revision: 1.1 $
 */

#ifdef _WIN32
#include <windows.h>
#endif
#include "org_lwjgl_Math_MatrixOpNegate_MatrixOpDirect.h"
#include "MatrixOpCommon.h"
/*
 * Class:     org_lwjgl_Math_MatrixOpNegate_MatrixOpDirect
 * Method:    execute
 * Signature: (IIIIIZIIZ)V
 */
JNIEXPORT void JNICALL Java_org_lwjgl_Math_00024MatrixOpNegate_00024MatrixOpDirect_execute
  (
	JNIEnv * env,
	jobject obj,
	jint sourceAddress,
	jint sourceStride,
	jint numElements,
	jint sourceWidth,
	jint sourceHeight,
	jboolean transposeSource,
	jint destAddress,
	jint destStride,
	jboolean transposeDest
  )
{
        MatrixSrc source  (sourceAddress,  sourceStride, sourceWidth,  sourceHeight,  numElements, transposeSource);
        MatrixDst dest  (destAddress,      destStride,   source.width, source.height, numElements, transposeDest);
    
        dest.configureBuffer(source);
    
        int * srcMatrix, * destMatrix;
 
        for (int i = 0; i < source.elements; i++)
        {
            srcMatrix = (int *) source.nextMatrix();
            destMatrix =   (int *) dest.nextMatrix();
            
            // we can cheat and use the less expensive xor 
            // to switch the sign bit of the float
            // single precision format   1 - sign   8 - exponent (excess 127) 23 - mantisa
            
            int j = source.width*source.height;
            while (j--)
                destMatrix[j] = srcMatrix[j] ^ 0x80000000;
    
            dest.writeComplete();
        }
}

--- NEW FILE: org_lwjgl_Math_MatrixOpNegate_MatrixOpSafe.cpp ---
CVS Browser:
http://cvs.sourceforge.net/cgi-bin/viewcvs.cgi/java-game-lib/LWJGL/src/native/common/org_lwjgl_Math_MatrixOpNegate_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_MatrixOpNegate_MatrixOpSafe.cpp,v 1.1 2002/11/25 13:18:23 elias_naur Exp $
 *
 * math library.
 *
 * @author cix_foo <ci...@us...>
 * @version $Revision: 1.1 $
 */

#ifdef _WIN32
#include <windows.h>
#endif

#include "org_lwjgl_Math_MatrixOpNegate_MatrixOpSafe.h"
#include "MatrixOpCommon.h"
/*
 * Class:     org_lwjgl_Math_MatrixOpNegate_MatrixOpSafe
 * Method:    execute
 * Signature: (IIIIIZIIZ)V
 */
JNIEXPORT void JNICALL Java_org_lwjgl_Math_00024MatrixOpNegate_00024MatrixOpSafe_execute
  (
	JNIEnv * env,
	jobject obj,
	jint sourceAddress,
	jint sourceStride,
	jint numElements,
	jint sourceWidth,
	jint sourceHeight,
	jboolean transposeSource,
	jint destAddress,
	jint destStride,
	jboolean transposeDest
  )
{
        MatrixSrc source  (sourceAddress,  sourceStride, sourceWidth,  sourceHeight,  numElements, transposeSource);
        MatrixDst dest  (destAddress,      destStride,   source.width, source.height, numElements, transposeDest);
    
        int * srcMatrix, * destMatrix;
 
        for (int i = 0; i < source.elements; i++)
        {
            srcMatrix = (int *) source.nextMatrix();
            destMatrix =   (int *) dest.nextMatrix();
            
            // we can cheat and use the less expensive xor 
            // to switch the sign bit of the float
            // single precision format   1 - sign   8 - exponent (excess 127) 23 - mantisa
            
            int j = source.width*source.height;
            while (j--)
                destMatrix[j] = srcMatrix[j] ^ 0x80000000;
    
            dest.writeComplete();
        }
}

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