From b9458afc52f7664fad803ba797de66128273fe55 Mon Sep 17 00:00:00 2001 From: Elias Naur Date: Tue, 19 Nov 2002 08:50:57 +0000 Subject: [PATCH] Ported to C++. ported Math ops --- src/native/linux/Makefile | 12 +- src/native/linux/MatrixOpCommon.cpp | 346 ++++++++++++++++++ src/native/linux/MatrixOpCommon.h | 116 ++++++ ..._lwjgl_Display.c => org_lwjgl_Display.cpp} | 12 +- src/native/linux/org_lwjgl_Math.cpp | 43 +++ ..._lwjgl_Math_MatrixOpAdd_MatrixOpDirect.cpp | 101 +++++ ...rg_lwjgl_Math_MatrixOpAdd_MatrixOpSafe.cpp | 99 +++++ ...lwjgl_Math_MatrixOpCopy_MatrixOpDirect.cpp | 92 +++++ ...g_lwjgl_Math_MatrixOpCopy_MatrixOpSafe.cpp | 88 +++++ ...jgl_Math_MatrixOpInvert_MatrixOpDirect.cpp | 134 +++++++ ...lwjgl_Math_MatrixOpInvert_MatrixOpSafe.cpp | 135 +++++++ ...l_Math_MatrixOpMultiply_MatrixOpDirect.cpp | 134 +++++++ ...jgl_Math_MatrixOpMultiply_MatrixOpSafe.cpp | 136 +++++++ ...jgl_Math_MatrixOpNegate_MatrixOpDirect.cpp | 86 +++++ ...lwjgl_Math_MatrixOpNegate_MatrixOpSafe.cpp | 84 +++++ ..._Math_MatrixOpNormalise_MatrixOpDirect.cpp | 96 +++++ ...gl_Math_MatrixOpNormalise_MatrixOpSafe.cpp | 94 +++++ ...l_Math_MatrixOpSubtract_MatrixOpDirect.cpp | 108 ++++++ ...jgl_Math_MatrixOpSubtract_MatrixOpSafe.cpp | 108 ++++++ .../{org_lwjgl_Sys.c => org_lwjgl_Sys.cpp} | 4 +- ...eyboard.c => org_lwjgl_input_Keyboard.cpp} | 12 +- ...nput_Mouse.c => org_lwjgl_input_Mouse.cpp} | 24 +- ...l_BaseGL.c => org_lwjgl_opengl_BaseGL.cpp} | 0 ...l_CoreGL.c => org_lwjgl_opengl_CoreGL.cpp} | 2 +- ...gl_opengl_GL.c => org_lwjgl_opengl_GL.cpp} | 0 ..._opengl_GLU.c => org_lwjgl_opengl_GLU.cpp} | 4 +- 26 files changed, 2037 insertions(+), 33 deletions(-) create mode 100644 src/native/linux/MatrixOpCommon.cpp create mode 100644 src/native/linux/MatrixOpCommon.h rename src/native/linux/{org_lwjgl_Display.c => org_lwjgl_Display.cpp} (92%) create mode 100644 src/native/linux/org_lwjgl_Math.cpp create mode 100644 src/native/linux/org_lwjgl_Math_MatrixOpAdd_MatrixOpDirect.cpp create mode 100644 src/native/linux/org_lwjgl_Math_MatrixOpAdd_MatrixOpSafe.cpp create mode 100644 src/native/linux/org_lwjgl_Math_MatrixOpCopy_MatrixOpDirect.cpp create mode 100644 src/native/linux/org_lwjgl_Math_MatrixOpCopy_MatrixOpSafe.cpp create mode 100644 src/native/linux/org_lwjgl_Math_MatrixOpInvert_MatrixOpDirect.cpp create mode 100644 src/native/linux/org_lwjgl_Math_MatrixOpInvert_MatrixOpSafe.cpp create mode 100644 src/native/linux/org_lwjgl_Math_MatrixOpMultiply_MatrixOpDirect.cpp create mode 100644 src/native/linux/org_lwjgl_Math_MatrixOpMultiply_MatrixOpSafe.cpp create mode 100644 src/native/linux/org_lwjgl_Math_MatrixOpNegate_MatrixOpDirect.cpp create mode 100644 src/native/linux/org_lwjgl_Math_MatrixOpNegate_MatrixOpSafe.cpp create mode 100644 src/native/linux/org_lwjgl_Math_MatrixOpNormalise_MatrixOpDirect.cpp create mode 100644 src/native/linux/org_lwjgl_Math_MatrixOpNormalise_MatrixOpSafe.cpp create mode 100644 src/native/linux/org_lwjgl_Math_MatrixOpSubtract_MatrixOpDirect.cpp create mode 100644 src/native/linux/org_lwjgl_Math_MatrixOpSubtract_MatrixOpSafe.cpp rename src/native/linux/{org_lwjgl_Sys.c => org_lwjgl_Sys.cpp} (97%) rename src/native/linux/{org_lwjgl_input_Keyboard.c => org_lwjgl_input_Keyboard.cpp} (90%) rename src/native/linux/{org_lwjgl_input_Mouse.c => org_lwjgl_input_Mouse.cpp} (88%) rename src/native/linux/{org_lwjgl_opengl_BaseGL.c => org_lwjgl_opengl_BaseGL.cpp} (100%) rename src/native/linux/{org_lwjgl_opengl_CoreGL.c => org_lwjgl_opengl_CoreGL.cpp} (99%) rename src/native/linux/{org_lwjgl_opengl_GL.c => org_lwjgl_opengl_GL.cpp} (100%) rename src/native/linux/{org_lwjgl_opengl_GLU.c => org_lwjgl_opengl_GLU.cpp} (98%) diff --git a/src/native/linux/Makefile b/src/native/linux/Makefile index 33286b5e..51fec0b6 100644 --- a/src/native/linux/Makefile +++ b/src/native/linux/Makefile @@ -39,10 +39,14 @@ # version $Revision$ # -GCC = gcc -LINK = gcc +GCC = g++ +LINK = g++ JAVAHOME=/usr/java/j2sdk1.4.1_01 -LIBOBJS=../common/extgl.o org_lwjgl_Display.o org_lwjgl_Sys.o org_lwjgl_opengl_BaseGL.o org_lwjgl_opengl_GL.o org_lwjgl_opengl_CoreGL.o org_lwjgl_input_Keyboard.o org_lwjgl_opengl_GLU.o org_lwjgl_input_Mouse.o +LIBCSRC=../common/extgl.c +LIBCPPSRC=$(shell find . -name \*.cpp -print|grep -v CVS) +LIBCPPOBJS=$(LIBCPPSRC:.cpp=.o) +LIBCOBJS=$(LIBCSRC:.c=.o) +LIBOBJS=$(LIBCOBJS) $(LIBCPPOBJS) #DEBUG_FLAGS=-D_DEBUG LINKOPTS=-L/usr/X11R6/lib -lX11 -lXext -lXxf86vm -lGL -lGLU @@ -59,7 +63,7 @@ liblwjgl.so: $(LIBOBJS) .SUFFIXES: .cpp .so .o .java .h .class -%.o : %.c +%.o : %.cpp $(GCC) $(DEBUG_FLAGS) -Wall -I$(JAVAHOME)/include -I../common -I$(JAVAHOME)/include/linux -c -o $@ $< testprog : main.o diff --git a/src/native/linux/MatrixOpCommon.cpp b/src/native/linux/MatrixOpCommon.cpp new file mode 100644 index 00000000..347ca765 --- /dev/null +++ b/src/native/linux/MatrixOpCommon.cpp @@ -0,0 +1,346 @@ + +//#include +#include +#include +#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; +} diff --git a/src/native/linux/MatrixOpCommon.h b/src/native/linux/MatrixOpCommon.h new file mode 100644 index 00000000..181058ec --- /dev/null +++ b/src/native/linux/MatrixOpCommon.h @@ -0,0 +1,116 @@ +/* + * 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(); + +}; + + diff --git a/src/native/linux/org_lwjgl_Display.c b/src/native/linux/org_lwjgl_Display.cpp similarity index 92% rename from src/native/linux/org_lwjgl_Display.c rename to src/native/linux/org_lwjgl_Display.cpp index 10a304f6..909b02d7 100644 --- a/src/native/linux/org_lwjgl_Display.c +++ b/src/native/linux/org_lwjgl_Display.cpp @@ -68,7 +68,7 @@ void waitMapped(Display *disp, Window win) { } int getDisplayModes(Display *disp, int screen, int *num_modes, XF86VidModeModeInfo ***avail_modes) { - unsigned int event_base, error_base, xvid_ver, xvid_rev; + int event_base, error_base, xvid_ver, xvid_rev; if (!XF86VidModeQueryExtension(disp, &event_base, &error_base)) { #ifdef _DEBUG @@ -211,13 +211,13 @@ JNIEXPORT jobjectArray JNICALL Java_org_lwjgl_Display_getAvailableDisplayModes return NULL; } // Allocate an array of DisplayModes big enough - jclass displayModeClass = (*env)->FindClass(env, "org/lwjgl/DisplayMode"); - jobjectArray ret = (*env)->NewObjectArray(env, num_modes, displayModeClass, NULL); - jmethodID displayModeConstructor = (*env)->GetMethodID(env, displayModeClass, "", "(IIII)V"); + jclass displayModeClass = env->FindClass("org/lwjgl/DisplayMode"); + jobjectArray ret = env->NewObjectArray(num_modes, displayModeClass, NULL); + jmethodID displayModeConstructor = env->GetMethodID(displayModeClass, "", "(IIII)V"); for (i = 0; i < num_modes; i++) { - jobject displayMode = (*env)->NewObject(env, displayModeClass, displayModeConstructor, avail_modes[i]->hdisplay, avail_modes[i]->vdisplay, depth, 0); - (*env)->SetObjectArrayElement(env, ret, i, displayMode); + 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); diff --git a/src/native/linux/org_lwjgl_Math.cpp b/src/native/linux/org_lwjgl_Math.cpp new file mode 100644 index 00000000..925cb430 --- /dev/null +++ b/src/native/linux/org_lwjgl_Math.cpp @@ -0,0 +1,43 @@ +/* + * 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$ + * + * Win32 maths library. + * + * @author cix_foo + * @version $Revision$ + */ + +//#include "org_lwjgl_Math.h" + diff --git a/src/native/linux/org_lwjgl_Math_MatrixOpAdd_MatrixOpDirect.cpp b/src/native/linux/org_lwjgl_Math_MatrixOpAdd_MatrixOpDirect.cpp new file mode 100644 index 00000000..90689c12 --- /dev/null +++ b/src/native/linux/org_lwjgl_Math_MatrixOpAdd_MatrixOpDirect.cpp @@ -0,0 +1,101 @@ +/* + * 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$ + * + * linux math library. + * + * @author elias_naur + * @version $Revision$ + */ + +#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(); + } + } + +} + diff --git a/src/native/linux/org_lwjgl_Math_MatrixOpAdd_MatrixOpSafe.cpp b/src/native/linux/org_lwjgl_Math_MatrixOpAdd_MatrixOpSafe.cpp new file mode 100644 index 00000000..a71e6ef6 --- /dev/null +++ b/src/native/linux/org_lwjgl_Math_MatrixOpAdd_MatrixOpSafe.cpp @@ -0,0 +1,99 @@ +/* + * 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$ + * + * linux math library. + * + * @author elias_naur + * @version $Revision$ + */ + +#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(); + } + } +} + + diff --git a/src/native/linux/org_lwjgl_Math_MatrixOpCopy_MatrixOpDirect.cpp b/src/native/linux/org_lwjgl_Math_MatrixOpCopy_MatrixOpDirect.cpp new file mode 100644 index 00000000..0a149dbb --- /dev/null +++ b/src/native/linux/org_lwjgl_Math_MatrixOpCopy_MatrixOpDirect.cpp @@ -0,0 +1,92 @@ +/* + * 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$ + * + * linux math library. + * + * @author elias_naur + * @version $Revision$ + */ + +#include "org_lwjgl_Math_MatrixOpCopy_MatrixOpDirect.h" +#include "MatrixOpCommon.h" +#include + +/* + * 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(); + } +} + + + diff --git a/src/native/linux/org_lwjgl_Math_MatrixOpCopy_MatrixOpSafe.cpp b/src/native/linux/org_lwjgl_Math_MatrixOpCopy_MatrixOpSafe.cpp new file mode 100644 index 00000000..c9602965 --- /dev/null +++ b/src/native/linux/org_lwjgl_Math_MatrixOpCopy_MatrixOpSafe.cpp @@ -0,0 +1,88 @@ +/* + * 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$ + * + * linux math library. + * + * @author elias_naur + * @version $Revision$ + */ + +#include "org_lwjgl_Math_MatrixOpCopy_MatrixOpSafe.h" +#include "MatrixOpCommon.h" +#include + +/* + * 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(); + } +} diff --git a/src/native/linux/org_lwjgl_Math_MatrixOpInvert_MatrixOpDirect.cpp b/src/native/linux/org_lwjgl_Math_MatrixOpInvert_MatrixOpDirect.cpp new file mode 100644 index 00000000..d20d2fe5 --- /dev/null +++ b/src/native/linux/org_lwjgl_Math_MatrixOpInvert_MatrixOpDirect.cpp @@ -0,0 +1,134 @@ +/* + * 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$ + * + * Win32 math library. + * + * @author cix_foo + * @version $Revision$ + */ + +#include "org_lwjgl_Math_MatrixOpInvert_MatrixOpDirect.h" +#include "MatrixOpCommon.h" +#ifdef _DEBUG +#include +#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(); + } +} diff --git a/src/native/linux/org_lwjgl_Math_MatrixOpInvert_MatrixOpSafe.cpp b/src/native/linux/org_lwjgl_Math_MatrixOpInvert_MatrixOpSafe.cpp new file mode 100644 index 00000000..701ec628 --- /dev/null +++ b/src/native/linux/org_lwjgl_Math_MatrixOpInvert_MatrixOpSafe.cpp @@ -0,0 +1,135 @@ +/* + * 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$ + * + * linux math library. + * + * @author elias_naur + * @version $Revision$ + */ + +#include "org_lwjgl_Math_MatrixOpInvert_MatrixOpSafe.h" +#include "MatrixOpCommon.h" + +#ifdef _DEBUG +#include +#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(); + + } +} diff --git a/src/native/linux/org_lwjgl_Math_MatrixOpMultiply_MatrixOpDirect.cpp b/src/native/linux/org_lwjgl_Math_MatrixOpMultiply_MatrixOpDirect.cpp new file mode 100644 index 00000000..47b4a841 --- /dev/null +++ b/src/native/linux/org_lwjgl_Math_MatrixOpMultiply_MatrixOpDirect.cpp @@ -0,0 +1,134 @@ +/* + * 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$ + * + * linux math library. + * + * @author elias_naur + * @version $Revision$ + */ + +#include "org_lwjgl_Math_MatrixOpMultiply_MatrixOpDirect.h" +#include "MatrixOpCommon.h" +#include +/* + * 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(); + } + } +} + diff --git a/src/native/linux/org_lwjgl_Math_MatrixOpMultiply_MatrixOpSafe.cpp b/src/native/linux/org_lwjgl_Math_MatrixOpMultiply_MatrixOpSafe.cpp new file mode 100644 index 00000000..3e0c6567 --- /dev/null +++ b/src/native/linux/org_lwjgl_Math_MatrixOpMultiply_MatrixOpSafe.cpp @@ -0,0 +1,136 @@ +/* + * 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$ + * + * linux math library. + * + * @author elias_naur + * @version $Revision$ + */ + + +#include "org_lwjgl_Math_MatrixOpMultiply_MatrixOpSafe.h" +#include "MatrixOpCommon.h" +#include + +/* + * 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(); + } + } + +} + + diff --git a/src/native/linux/org_lwjgl_Math_MatrixOpNegate_MatrixOpDirect.cpp b/src/native/linux/org_lwjgl_Math_MatrixOpNegate_MatrixOpDirect.cpp new file mode 100644 index 00000000..ae7e8bc9 --- /dev/null +++ b/src/native/linux/org_lwjgl_Math_MatrixOpNegate_MatrixOpDirect.cpp @@ -0,0 +1,86 @@ +/* + * 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$ + * + * linux math library. + * + * @author elias_naur + * @version $Revision$ + */ + +#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(); + } +} diff --git a/src/native/linux/org_lwjgl_Math_MatrixOpNegate_MatrixOpSafe.cpp b/src/native/linux/org_lwjgl_Math_MatrixOpNegate_MatrixOpSafe.cpp new file mode 100644 index 00000000..9a89d64f --- /dev/null +++ b/src/native/linux/org_lwjgl_Math_MatrixOpNegate_MatrixOpSafe.cpp @@ -0,0 +1,84 @@ +/* + * 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$ + * + * linux math library. + * + * @author elias_naur + * @version $Revision$ + */ + +#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(); + } +} diff --git a/src/native/linux/org_lwjgl_Math_MatrixOpNormalise_MatrixOpDirect.cpp b/src/native/linux/org_lwjgl_Math_MatrixOpNormalise_MatrixOpDirect.cpp new file mode 100644 index 00000000..36bc27e7 --- /dev/null +++ b/src/native/linux/org_lwjgl_Math_MatrixOpNormalise_MatrixOpDirect.cpp @@ -0,0 +1,96 @@ +/* + * 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$ + * + * linux math library. + * + * @author elias_naur + * @version $Revision$ + */ + +#include "org_lwjgl_Math_MatrixOpNormalise_MatrixOpDirect.h" +#include "MatrixOpCommon.h" +#include + +using namespace std; + +/* + * Class: org_lwjgl_Math_MatrixOpNormalise_MatrixOpDirect + * Method: execute + * Signature: (IIIIIZIIZ)V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_Math_00024MatrixOpNormalise_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, source.elements, transposeDest); + + dest.configureBuffer(source); + + float * srcMatrix, * destMatrix; + float magnitude, magnitude_squared; + + int i, j, matrixFloatCount = source.width * source.height; + + for (i = 0; i < source.elements; i++) + { + magnitude_squared = 0; + srcMatrix = source.nextMatrix(); + destMatrix = dest.nextMatrix(); + + j = matrixFloatCount; + while (j--) + magnitude_squared += srcMatrix[j] * srcMatrix[j]; + + magnitude = (float) sqrt((double) magnitude_squared); + + j = matrixFloatCount; + while (j--) + destMatrix[j] = srcMatrix[j] / magnitude; + + dest.writeComplete(); + } +} diff --git a/src/native/linux/org_lwjgl_Math_MatrixOpNormalise_MatrixOpSafe.cpp b/src/native/linux/org_lwjgl_Math_MatrixOpNormalise_MatrixOpSafe.cpp new file mode 100644 index 00000000..433a492d --- /dev/null +++ b/src/native/linux/org_lwjgl_Math_MatrixOpNormalise_MatrixOpSafe.cpp @@ -0,0 +1,94 @@ +/* + * 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$ + * + * linux math library. + * + * @author elias_naur + * @version $Revision$ + */ + +#include "org_lwjgl_Math_MatrixOpNormalise_MatrixOpSafe.h" +#include "MatrixOpCommon.h" +#include + +using namespace std; + +/* + * Class: org_lwjgl_Math_MatrixOpNormalise_MatrixOpSafe + * Method: execute + * Signature: (IIIIIZIIZ)V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_Math_00024MatrixOpNormalise_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, source.elements, transposeDest); + + float * srcMatrix, * destMatrix; + float magnitude, magnitude_squared; + + int i, j, matrixFloatCount = source.width * source.height; + + for (i = 0; i < source.elements; i++) + { + magnitude_squared = 0; + srcMatrix = source.nextMatrix(); + destMatrix = dest.nextMatrix(); + + j = matrixFloatCount; + while (j--) + magnitude_squared += srcMatrix[j] * srcMatrix[j]; + + magnitude = (float) sqrt((double) magnitude_squared); + + j = matrixFloatCount; + while (j--) + destMatrix[j] = srcMatrix[j] / magnitude; + + dest.writeComplete(); + } +} diff --git a/src/native/linux/org_lwjgl_Math_MatrixOpSubtract_MatrixOpDirect.cpp b/src/native/linux/org_lwjgl_Math_MatrixOpSubtract_MatrixOpDirect.cpp new file mode 100644 index 00000000..8021e4a3 --- /dev/null +++ b/src/native/linux/org_lwjgl_Math_MatrixOpSubtract_MatrixOpDirect.cpp @@ -0,0 +1,108 @@ +/* + * 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$ + * + * linux math library. + * + * @author elias_naur + * @version $Revision$ + */ + +#include "org_lwjgl_Math_MatrixOpSubtract_MatrixOpDirect.h" +#include "MatrixOpCommon.h" +/* + * Class: org_lwjgl_Math_MatrixOpSubtract_MatrixOpDirect + * Method: execute + * Signature: (IIIIIZIIIIIZIIZ)V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_Math_00024MatrixOpSubtract_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, + 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(); + } + } +} + + diff --git a/src/native/linux/org_lwjgl_Math_MatrixOpSubtract_MatrixOpSafe.cpp b/src/native/linux/org_lwjgl_Math_MatrixOpSubtract_MatrixOpSafe.cpp new file mode 100644 index 00000000..b61d7908 --- /dev/null +++ b/src/native/linux/org_lwjgl_Math_MatrixOpSubtract_MatrixOpSafe.cpp @@ -0,0 +1,108 @@ +/* + * 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$ + * + * linux math library. + * + * @author elias_naur + * @version $Revision$ + */ + +#include "org_lwjgl_Math_MatrixOpSubtract_MatrixOpSafe.h" +#include "MatrixOpCommon.h" + +/* + * Class: org_lwjgl_Math_MatrixOpSubtract_MatrixOpSafe + * Method: execute + * Signature: (IIIIIZIIIIIZIIZ)V + */ +JNIEXPORT void JNICALL Java_org_lwjgl_Math_00024MatrixOpSubtract_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, + left.width, left.height, left.elements * right.elements, transposeDest); + + 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(); + } + } +} + + + diff --git a/src/native/linux/org_lwjgl_Sys.c b/src/native/linux/org_lwjgl_Sys.cpp similarity index 97% rename from src/native/linux/org_lwjgl_Sys.c rename to src/native/linux/org_lwjgl_Sys.cpp index 477e1d9f..7e79aab6 100644 --- a/src/native/linux/org_lwjgl_Sys.c +++ b/src/native/linux/org_lwjgl_Sys.cpp @@ -55,7 +55,7 @@ long int hires_timer; // Hires timer current time JNIEXPORT jint JNICALL Java_org_lwjgl_Sys_getDirectBufferAddress (JNIEnv * env, jclass clazz, jobject buf) { - return (jint) (*env)->GetDirectBufferAddress(env, buf); + return (jint) env->GetDirectBufferAddress(buf); } /* @@ -66,7 +66,7 @@ JNIEXPORT jint JNICALL Java_org_lwjgl_Sys_getDirectBufferAddress JNIEXPORT jobject JNICALL Java_org_lwjgl_Sys_createDirectBuffer (JNIEnv * env, jclass clazz, jint address, jint length) { - return (*env)->NewDirectByteBuffer(env, (void *)address, length); + return env->NewDirectByteBuffer((void *)address, length); } /* diff --git a/src/native/linux/org_lwjgl_input_Keyboard.c b/src/native/linux/org_lwjgl_input_Keyboard.cpp similarity index 90% rename from src/native/linux/org_lwjgl_input_Keyboard.c rename to src/native/linux/org_lwjgl_input_Keyboard.cpp index ab84edab..4bbaa24b 100644 --- a/src/native/linux/org_lwjgl_input_Keyboard.c +++ b/src/native/linux/org_lwjgl_input_Keyboard.cpp @@ -67,11 +67,11 @@ JNIEXPORT void JNICALL Java_org_lwjgl_input_Keyboard_initIDs static jobject globalClassLock = NULL; if (globalClassLock == NULL) { - globalClassLock = (*env)->NewGlobalRef(env, clazz); + globalClassLock = env->NewGlobalRef(clazz); } - fid_readBuffer = (*env)->GetStaticFieldID(env, clazz, "readBuffer", "Ljava/nio/ByteBuffer;"); - fid_readBufferAddress = (*env)->GetStaticFieldID(env, clazz, "readBufferAddress", "I"); + fid_readBuffer = env->GetStaticFieldID(clazz, "readBuffer", "Ljava/nio/ByteBuffer;"); + fid_readBufferAddress = env->GetStaticFieldID(clazz, "readBufferAddress", "I"); } /* @@ -156,8 +156,8 @@ JNIEXPORT jint JNICALL Java_org_lwjgl_input_Keyboard_nRead JNIEXPORT jint JNICALL Java_org_lwjgl_input_Keyboard_nEnableBuffer (JNIEnv * env, jclass clazz) { - jobject newBuffer = (*env)->NewDirectByteBuffer(env, &readBuffer, KEYBOARD_BUFFER_SIZE); - (*env)->SetStaticObjectField(env, clazz, fid_readBuffer, newBuffer); - (*env)->SetStaticIntField(env, clazz, fid_readBufferAddress, (jint) (&readBuffer)); + jobject newBuffer = env->NewDirectByteBuffer(&readBuffer, KEYBOARD_BUFFER_SIZE); + env->SetStaticObjectField(clazz, fid_readBuffer, newBuffer); + env->SetStaticIntField(clazz, fid_readBufferAddress, (jint) (&readBuffer)); return KEYBOARD_BUFFER_SIZE; } diff --git a/src/native/linux/org_lwjgl_input_Mouse.c b/src/native/linux/org_lwjgl_input_Mouse.cpp similarity index 88% rename from src/native/linux/org_lwjgl_input_Mouse.c rename to src/native/linux/org_lwjgl_input_Mouse.cpp index 93059468..09ab9331 100644 --- a/src/native/linux/org_lwjgl_input_Mouse.c +++ b/src/native/linux/org_lwjgl_input_Mouse.cpp @@ -78,26 +78,26 @@ JNIEXPORT void JNICALL Java_org_lwjgl_input_Mouse_initIDs static jobject globalClassLock = NULL; if (globalClassLock == NULL) { - globalClassLock = (*env)->NewGlobalRef(env, clazz); + globalClassLock = env->NewGlobalRef(clazz); } // Now cache the field IDs: if (fid_button == NULL) { - fid_button = (*env)->GetStaticFieldID(env, clazz, "button", "[Z"); + fid_button = env->GetStaticFieldID(clazz, "button", "[Z"); } if (fid_dx == NULL) { - fid_dx = (*env)->GetStaticFieldID(env, clazz, "dx", "I"); + fid_dx = env->GetStaticFieldID(clazz, "dx", "I"); } if (fid_dy == NULL) { - fid_dy = (*env)->GetStaticFieldID(env, clazz, "dy", "I"); + fid_dy = env->GetStaticFieldID(clazz, "dy", "I"); } if (fid_dz == NULL) { - fid_dz = (*env)->GetStaticFieldID(env, clazz, "dz", "I"); + fid_dz = env->GetStaticFieldID(clazz, "dz", "I"); } } int blankCursor(void) { - int best_width, best_height; + unsigned int best_width, best_height; if (XQueryBestCursor(disp, win, 1, 1, &best_width, &best_height) == 0) { #ifdef _DEBUG printf("Could not query best cursor size\n"); @@ -242,14 +242,14 @@ JNIEXPORT void JNICALL Java_org_lwjgl_input_Mouse_nPoll int moved_x = current_x - last_x; int moved_y = current_y - last_y; int moved_z = current_z - last_z; - (*env)->SetStaticIntField(env, clazz, fid_dx, (jint)moved_x); - (*env)->SetStaticIntField(env, clazz, fid_dy, (jint)moved_y); - (*env)->SetStaticIntField(env, clazz, fid_dz, (jint)moved_z); + env->SetStaticIntField(clazz, fid_dx, (jint)moved_x); + env->SetStaticIntField(clazz, fid_dy, (jint)moved_y); + env->SetStaticIntField(clazz, fid_dz, (jint)moved_z); last_x = current_x; last_y = current_y; last_z = current_z; - jbooleanArray buttonsArray = (jbooleanArray) (*env)->GetStaticObjectField(env, clazz, fid_button); - unsigned char * class_buttons = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env, buttonsArray, NULL); + jbooleanArray buttonsArray = (jbooleanArray) env->GetStaticObjectField(clazz, fid_button); + unsigned char * class_buttons = (unsigned char *) env->GetPrimitiveArrayCritical(buttonsArray, NULL); memcpy(class_buttons, buttons, NUM_BUTTONS*sizeof(unsigned char)); - (*env)->ReleasePrimitiveArrayCritical(env, buttonsArray, class_buttons, 0); + env->ReleasePrimitiveArrayCritical(buttonsArray, class_buttons, 0); } diff --git a/src/native/linux/org_lwjgl_opengl_BaseGL.c b/src/native/linux/org_lwjgl_opengl_BaseGL.cpp similarity index 100% rename from src/native/linux/org_lwjgl_opengl_BaseGL.c rename to src/native/linux/org_lwjgl_opengl_BaseGL.cpp diff --git a/src/native/linux/org_lwjgl_opengl_CoreGL.c b/src/native/linux/org_lwjgl_opengl_CoreGL.cpp similarity index 99% rename from src/native/linux/org_lwjgl_opengl_CoreGL.c rename to src/native/linux/org_lwjgl_opengl_CoreGL.cpp index 76277384..6e0938c0 100644 --- a/src/native/linux/org_lwjgl_opengl_CoreGL.c +++ b/src/native/linux/org_lwjgl_opengl_CoreGL.cpp @@ -1287,7 +1287,7 @@ JNIEXPORT void JNICALL Java_org_lwjgl_opengl_CoreGL_getTexEnviv(JNIEnv * env, jo JNIEXPORT jstring JNICALL Java_org_lwjgl_opengl_CoreGL_getString(JNIEnv * env, jobject obj, jint p0) { const GLubyte * string = glGetString((GLenum) p0); - return (*env)->NewStringUTF(env, (const char *) string); + return env->NewStringUTF((const char *) string); } /* diff --git a/src/native/linux/org_lwjgl_opengl_GL.c b/src/native/linux/org_lwjgl_opengl_GL.cpp similarity index 100% rename from src/native/linux/org_lwjgl_opengl_GL.c rename to src/native/linux/org_lwjgl_opengl_GL.cpp diff --git a/src/native/linux/org_lwjgl_opengl_GLU.c b/src/native/linux/org_lwjgl_opengl_GLU.cpp similarity index 98% rename from src/native/linux/org_lwjgl_opengl_GLU.c rename to src/native/linux/org_lwjgl_opengl_GLU.cpp index 61137dbb..062f05c2 100644 --- a/src/native/linux/org_lwjgl_opengl_GLU.c +++ b/src/native/linux/org_lwjgl_opengl_GLU.cpp @@ -50,7 +50,7 @@ JNIEXPORT jstring JNICALL Java_org_lwjgl_opengl_GLU_getString(JNIEnv * env, jobject obj, jint p0) { const char * msg = (const char *) gluGetString((GLint) p0); - jstring ret = (*env)->NewStringUTF(env, msg); + jstring ret = env->NewStringUTF(msg); return ret; } @@ -61,7 +61,7 @@ JNIEXPORT jstring JNICALL Java_org_lwjgl_opengl_GLU_getString(JNIEnv * env, jobj JNIEXPORT jstring JNICALL Java_org_lwjgl_opengl_GLU_errorString(JNIEnv * env, jobject obj, jint p0) { const GLubyte * msg = gluErrorString((GLint) p0); - jstring ret = (*env)->NewStringUTF(env, (const char *) msg); + jstring ret = env->NewStringUTF((const char *) msg); return ret; }