From 2d76c16b9384d383d3e6a9d7cb727f2591a39228 Mon Sep 17 00:00:00 2001 From: Michael Bien Date: Mon, 29 Mar 2010 04:02:08 +0200 Subject: renamed BufferFactory into Buffers. --- .../com/jogamp/gluegen/runtime/BufferFactory.java | 668 --------------------- src/java/com/jogamp/gluegen/runtime/Buffers.java | 668 +++++++++++++++++++++ src/java/com/jogamp/gluegen/runtime/Platform.java | 2 +- .../com/jogamp/gluegen/runtime/PointerBuffer.java | 6 +- src/java/com/sun/gluegen/JavaConfiguration.java | 6 +- src/java/com/sun/gluegen/JavaEmitter.java | 8 +- .../com/sun/gluegen/JavaMethodBindingEmitter.java | 36 +- .../NativeSignatureJavaMethodBindingEmitter.java | 34 +- .../com/sun/gluegen/opengl/GLConfiguration.java | 2 +- .../sun/gluegen/test/TestStructAccessorEndian.java | 2 +- 10 files changed, 716 insertions(+), 716 deletions(-) delete mode 100755 src/java/com/jogamp/gluegen/runtime/BufferFactory.java create mode 100755 src/java/com/jogamp/gluegen/runtime/Buffers.java (limited to 'src/java/com') diff --git a/src/java/com/jogamp/gluegen/runtime/BufferFactory.java b/src/java/com/jogamp/gluegen/runtime/BufferFactory.java deleted file mode 100755 index 4ab64ff..0000000 --- a/src/java/com/jogamp/gluegen/runtime/BufferFactory.java +++ /dev/null @@ -1,668 +0,0 @@ -/* - * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions are - * met: - * - * - Redistribution of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * - Redistribution 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 Sun Microsystems, Inc. or the names of - * contributors may be used to endorse or promote products derived from - * this software without specific prior written permission. - * - * This software is provided "AS IS," without a warranty of any kind. ALL - * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, - * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A - * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN - * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR - * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR - * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR - * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR - * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE - * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, - * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF - * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. - * - * You acknowledge that this software is not designed or intended for use - * in the design, construction, operation or maintenance of any nuclear - * facility. - * - * Sun gratefully acknowledges that this software was originally authored - * and developed by Kenneth Bradley Russell and Christopher John Kline. - */ -package com.jogamp.gluegen.runtime; - -import java.nio.*; - -/** - * @author Kenneth Russel - * @author Sven Gothel - * @author Michael Bien - */ -public class BufferFactory { - - public static final int SIZEOF_BYTE = 1; - public static final int SIZEOF_SHORT = 2; - public static final int SIZEOF_CHAR = 2; - public static final int SIZEOF_INT = 4; - public static final int SIZEOF_FLOAT = 4; - public static final int SIZEOF_LONG = 8; - public static final int SIZEOF_DOUBLE = 8; - - private BufferFactory() {} - - /** - * Allocates a new direct ByteBuffer with the specified number of - * elements. The returned buffer will have its byte order set to - * the host platform's native byte order. - */ - public static ByteBuffer newDirectByteBuffer(int numElements) { - return nativeOrder(ByteBuffer.allocateDirect(numElements)); - } - - public static ByteBuffer newDirectByteBuffer(byte[] values, int offset, int lenght) { - return (ByteBuffer)newDirectByteBuffer(lenght).put(values, offset, lenght).rewind(); - } - - public static ByteBuffer newDirectByteBuffer(byte[] values, int offset) { - return newDirectByteBuffer(values, offset, values.length-offset); - } - - public static ByteBuffer newDirectByteBuffer(byte[] values) { - return newDirectByteBuffer(values, 0); - } - - /** - * Allocates a new direct DoubleBuffer with the specified number of - * elements. The returned buffer will have its byte order set to - * the host platform's native byte order. - */ - public static DoubleBuffer newDirectDoubleBuffer(int numElements) { - return newDirectByteBuffer(numElements * SIZEOF_DOUBLE).asDoubleBuffer(); - } - - public static DoubleBuffer newDirectDoubleBuffer(double[] values, int offset, int lenght) { - return (DoubleBuffer)newDirectDoubleBuffer(lenght).put(values, offset, lenght).rewind(); - } - - public static DoubleBuffer newDirectDoubleBuffer(double[] values, int offset) { - return newDirectDoubleBuffer(values, offset, values.length - offset); - } - - public static DoubleBuffer newDirectDoubleBuffer(double[] values) { - return newDirectDoubleBuffer(values, 0); - } - - /** - * Allocates a new direct FloatBuffer with the specified number of - * elements. The returned buffer will have its byte order set to - * the host platform's native byte order. - */ - public static FloatBuffer newDirectFloatBuffer(int numElements) { - return newDirectByteBuffer(numElements * SIZEOF_FLOAT).asFloatBuffer(); - } - - public static FloatBuffer newDirectFloatBuffer(float[] values, int offset, int lenght) { - return (FloatBuffer)newDirectFloatBuffer(lenght).put(values, offset, lenght).rewind(); - } - - public static FloatBuffer newDirectFloatBuffer(float[] values, int offset) { - return newDirectFloatBuffer(values, offset, values.length - offset); - } - - public static FloatBuffer newDirectFloatBuffer(float[] values) { - return newDirectFloatBuffer(values, 0); - } - - /** - * Allocates a new direct IntBuffer with the specified number of - * elements. The returned buffer will have its byte order set to - * the host platform's native byte order. - */ - public static IntBuffer newDirectIntBuffer(int numElements) { - return newDirectByteBuffer(numElements * SIZEOF_INT).asIntBuffer(); - } - - public static IntBuffer newDirectIntBuffer(int[] values, int offset, int lenght) { - return (IntBuffer)newDirectIntBuffer(lenght).put(values, offset, lenght).rewind(); - } - - public static IntBuffer newDirectIntBuffer(int[] values, int offset) { - return newDirectIntBuffer(values, offset, values.length - offset); - } - - public static IntBuffer newDirectIntBuffer(int[] values) { - return newDirectIntBuffer(values, 0); - } - - /** - * Allocates a new direct LongBuffer with the specified number of - * elements. The returned buffer will have its byte order set to - * the host platform's native byte order. - */ - public static LongBuffer newDirectLongBuffer(int numElements) { - return newDirectByteBuffer(numElements * SIZEOF_LONG).asLongBuffer(); - } - - public static LongBuffer newDirectLongBuffer(long[] values, int offset, int lenght) { - return (LongBuffer)newDirectLongBuffer(lenght).put(values, offset, lenght).rewind(); - } - - public static LongBuffer newDirectLongBuffer(long[] values, int offset) { - return newDirectLongBuffer(values, offset, values.length - offset); - } - - public static LongBuffer newDirectLongBuffer(long[] values) { - return newDirectLongBuffer(values, 0); - } - - /** - * Allocates a new direct ShortBuffer with the specified number of - * elements. The returned buffer will have its byte order set to - * the host platform's native byte order. - */ - public static ShortBuffer newDirectShortBuffer(int numElements) { - return newDirectByteBuffer(numElements * SIZEOF_SHORT).asShortBuffer(); - } - - public static ShortBuffer newDirectShortBuffer(short[] values, int offset, int lenght) { - return (ShortBuffer)newDirectShortBuffer(lenght).put(values, offset, lenght).rewind(); - } - - public static ShortBuffer newDirectShortBuffer(short[] values, int offset) { - return newDirectShortBuffer(values, offset, values.length - offset); - } - - public static ShortBuffer newDirectShortBuffer(short[] values) { - return newDirectShortBuffer(values, 0); - } - - /** - * Allocates a new direct CharBuffer with the specified number of - * elements. The returned buffer will have its byte order set to - * the host platform's native byte order. - */ - public static CharBuffer newDirectCharBuffer(int numElements) { - return newDirectByteBuffer(numElements * SIZEOF_SHORT).asCharBuffer(); - } - - public static CharBuffer newDirectCharBuffer(char[] values, int offset, int lenght) { - return (CharBuffer)newDirectCharBuffer(lenght).put(values, offset, lenght).rewind(); - } - - public static CharBuffer newDirectCharBuffer(char[] values, int offset) { - return newDirectCharBuffer(values, offset, values.length - offset); - } - - public static CharBuffer newDirectCharBuffer(char[] values) { - return newDirectCharBuffer(values, 0); - } - - /** - * Helper routine to set a ByteBuffer to the native byte order, if - * that operation is supported by the underlying NIO - * implementation. - */ - public static ByteBuffer nativeOrder(ByteBuffer buf) { - if (Platform.isJavaSE()) { - return buf.order(ByteOrder.nativeOrder()); - } else { - // JSR 239 does not support the ByteOrder class or the order methods. - // The initial order of a byte buffer is the platform byte order. - return buf; - } - } - - /** - * Helper routine to tell whether a buffer is direct or not. Null - * pointers are considered NOT direct. isDirect() should really be - * public in Buffer and not replicated in all subclasses. - */ - public static boolean isDirect(Object buf) { - if (buf == null) { - return true; - } - if (buf instanceof ByteBuffer) { - return ((ByteBuffer) buf).isDirect(); - } else if (buf instanceof FloatBuffer) { - return ((FloatBuffer) buf).isDirect(); - } else if (buf instanceof IntBuffer) { - return ((IntBuffer) buf).isDirect(); - } else if (buf instanceof ShortBuffer) { - return ((ShortBuffer) buf).isDirect(); - } else if (buf instanceof PointerBuffer) { - return ((PointerBuffer) buf).isDirect(); - } else if (Platform.isJavaSE()) { - if (buf instanceof DoubleBuffer) { - return ((DoubleBuffer) buf).isDirect(); - } else if (buf instanceof LongBuffer) { - return ((LongBuffer) buf).isDirect(); - }else if (buf instanceof CharBuffer) { - return ((CharBuffer) buf).isDirect(); - } - } - throw new RuntimeException("Unexpected buffer type " + buf.getClass().getName()); - } - - /** - * Helper routine to get the Buffer byte offset by taking into - * account the Buffer position and the underlying type. This is - * the total offset for Direct Buffers. - */ - public static int getDirectBufferByteOffset(Object buf) { - if (buf == null) { - return 0; - } - if (buf instanceof Buffer) { - int pos = ((Buffer) buf).position(); - if (buf instanceof ByteBuffer) { - return pos; - } else if (buf instanceof FloatBuffer) { - return pos * SIZEOF_FLOAT; - } else if (buf instanceof IntBuffer) { - return pos * SIZEOF_INT; - } else if (buf instanceof ShortBuffer) { - return pos * SIZEOF_SHORT; - }else if(Platform.isJavaSE()) { - if (buf instanceof DoubleBuffer) { - return pos * SIZEOF_DOUBLE; - } else if (buf instanceof LongBuffer) { - return pos * SIZEOF_LONG; - } else if (buf instanceof CharBuffer) { - return pos * SIZEOF_CHAR; - } - } - } else if (buf instanceof PointerBuffer) { - PointerBuffer pointerBuffer = (PointerBuffer) buf; - return pointerBuffer.position() * PointerBuffer.elementSize(); - } - - throw new RuntimeException("Disallowed array backing store type in buffer " - + buf.getClass().getName()); - } - - /** - * Helper routine to return the array backing store reference from - * a Buffer object. - */ - public static Object getArray(Object buf) { - if (buf == null) { - return null; - } - if (buf instanceof ByteBuffer) { - return ((ByteBuffer) buf).array(); - } else if (buf instanceof FloatBuffer) { - return ((FloatBuffer) buf).array(); - } else if (buf instanceof IntBuffer) { - return ((IntBuffer) buf).array(); - } else if (buf instanceof ShortBuffer) { - return ((ShortBuffer) buf).array(); - } else if (buf instanceof PointerBuffer) { - return ((PointerBuffer) buf).array(); - }else if(Platform.isJavaSE()) { - if (buf instanceof DoubleBuffer) { - return ((DoubleBuffer) buf).array(); - } else if (buf instanceof LongBuffer) { - return ((LongBuffer) buf).array(); - } else if (buf instanceof CharBuffer) { - return ((CharBuffer) buf).array(); - } - } - - throw new RuntimeException("Disallowed array backing store type in buffer " - + buf.getClass().getName()); - } - - /** - * Helper routine to get the full byte offset from the beginning of - * the array that is the storage for the indirect Buffer - * object. The array offset also includes the position offset - * within the buffer, in addition to any array offset. - */ - public static int getIndirectBufferByteOffset(Object buf) { - if (buf == null) { - return 0; - } - if (buf instanceof Buffer) { - int pos = ((Buffer) buf).position(); - if (buf instanceof ByteBuffer) { - return (((ByteBuffer) buf).arrayOffset() + pos); - } else if (buf instanceof FloatBuffer) { - return (SIZEOF_FLOAT * (((FloatBuffer) buf).arrayOffset() + pos)); - } else if (buf instanceof IntBuffer) { - return (SIZEOF_INT * (((IntBuffer) buf).arrayOffset() + pos)); - } else if (buf instanceof ShortBuffer) { - return (SIZEOF_SHORT * (((ShortBuffer) buf).arrayOffset() + pos)); - }else if(Platform.isJavaSE()) { - if (buf instanceof DoubleBuffer) { - return (SIZEOF_DOUBLE * (((DoubleBuffer) buf).arrayOffset() + pos)); - } else if (buf instanceof LongBuffer) { - return (SIZEOF_LONG * (((LongBuffer) buf).arrayOffset() + pos)); - } else if (buf instanceof CharBuffer) { - return (SIZEOF_CHAR * (((CharBuffer) buf).arrayOffset() + pos)); - } - } - } else if (buf instanceof PointerBuffer) { - PointerBuffer pointerBuffer = (PointerBuffer) buf; - return PointerBuffer.elementSize() * (pointerBuffer.arrayOffset() + pointerBuffer.position()); - } - - throw new RuntimeException("Unknown buffer type " + buf.getClass().getName()); - } - - - //---------------------------------------------------------------------- - // Copy routines (type-to-type) - // - /** - * Copies the remaining elements (as defined by - * limit() - position()) in the passed ByteBuffer into - * a newly-allocated direct ByteBuffer. The returned buffer will - * have its byte order set to the host platform's native byte - * order. The position of the newly-allocated buffer will be zero, - * and the position of the passed buffer is unchanged (though its - * mark is changed). - */ - public static ByteBuffer copyByteBuffer(ByteBuffer orig) { - ByteBuffer dest = newDirectByteBuffer(orig.remaining()); - dest.put(orig); - dest.rewind(); - return dest; - } - - /** - * Copies the remaining elements (as defined by - * limit() - position()) in the passed FloatBuffer - * into a newly-allocated direct FloatBuffer. The returned buffer - * will have its byte order set to the host platform's native byte - * order. The position of the newly-allocated buffer will be zero, - * and the position of the passed buffer is unchanged (though its - * mark is changed). - */ - public static FloatBuffer copyFloatBuffer(FloatBuffer orig) { - return copyFloatBufferAsByteBuffer(orig).asFloatBuffer(); - } - - /** - * Copies the remaining elements (as defined by - * limit() - position()) in the passed IntBuffer - * into a newly-allocated direct IntBuffer. The returned buffer - * will have its byte order set to the host platform's native byte - * order. The position of the newly-allocated buffer will be zero, - * and the position of the passed buffer is unchanged (though its - * mark is changed). - */ - public static IntBuffer copyIntBuffer(IntBuffer orig) { - return copyIntBufferAsByteBuffer(orig).asIntBuffer(); - } - - /** - * Copies the remaining elements (as defined by - * limit() - position()) in the passed ShortBuffer - * into a newly-allocated direct ShortBuffer. The returned buffer - * will have its byte order set to the host platform's native byte - * order. The position of the newly-allocated buffer will be zero, - * and the position of the passed buffer is unchanged (though its - * mark is changed). - */ - public static ShortBuffer copyShortBuffer(ShortBuffer orig) { - return copyShortBufferAsByteBuffer(orig).asShortBuffer(); - } - - //---------------------------------------------------------------------- - // Copy routines (type-to-ByteBuffer) - // - /** - * Copies the remaining elements (as defined by - * limit() - position()) in the passed FloatBuffer - * into a newly-allocated direct ByteBuffer. The returned buffer - * will have its byte order set to the host platform's native byte - * order. The position of the newly-allocated buffer will be zero, - * and the position of the passed buffer is unchanged (though its - * mark is changed). - */ - public static ByteBuffer copyFloatBufferAsByteBuffer(FloatBuffer orig) { - ByteBuffer dest = newDirectByteBuffer(orig.remaining() * SIZEOF_FLOAT); - dest.asFloatBuffer().put(orig); - dest.rewind(); - return dest; - } - - /** - * Copies the remaining elements (as defined by - * limit() - position()) in the passed IntBuffer into - * a newly-allocated direct ByteBuffer. The returned buffer will - * have its byte order set to the host platform's native byte - * order. The position of the newly-allocated buffer will be zero, - * and the position of the passed buffer is unchanged (though its - * mark is changed). - */ - public static ByteBuffer copyIntBufferAsByteBuffer(IntBuffer orig) { - ByteBuffer dest = newDirectByteBuffer(orig.remaining() * SIZEOF_INT); - dest.asIntBuffer().put(orig); - dest.rewind(); - return dest; - } - - /** - * Copies the remaining elements (as defined by - * limit() - position()) in the passed ShortBuffer - * into a newly-allocated direct ByteBuffer. The returned buffer - * will have its byte order set to the host platform's native byte - * order. The position of the newly-allocated buffer will be zero, - * and the position of the passed buffer is unchanged (though its - * mark is changed). - */ - public static ByteBuffer copyShortBufferAsByteBuffer(ShortBuffer orig) { - ByteBuffer dest = newDirectByteBuffer(orig.remaining() * SIZEOF_SHORT); - dest.asShortBuffer().put(orig); - dest.rewind(); - return dest; - } - - //---------------------------------------------------------------------- - // Conversion routines - // - public final static FloatBuffer getFloatBuffer(DoubleBuffer source) { - source.rewind(); - FloatBuffer dest = newDirectFloatBuffer(source.limit()); - while (source.hasRemaining()) { - dest.put((float) source.get()); - } - return dest; - } - - //---------------------------------------------------------------------- - // Convenient put methods with generic target Buffer - // - public static Buffer put(Buffer dest, Buffer src) { - if ((dest instanceof ByteBuffer) && (src instanceof ByteBuffer)) { - return ((ByteBuffer) dest).put((ByteBuffer) src); - } else if ((dest instanceof ShortBuffer) && (src instanceof ShortBuffer)) { - return ((ShortBuffer) dest).put((ShortBuffer) src); - } else if ((dest instanceof IntBuffer) && (src instanceof IntBuffer)) { - return ((IntBuffer) dest).put((IntBuffer) src); - } else if ((dest instanceof FloatBuffer) && (src instanceof FloatBuffer)) { - return ((FloatBuffer) dest).put((FloatBuffer) src); - } else if (Platform.isJavaSE()) { - if ((dest instanceof LongBuffer) && (src instanceof LongBuffer)) { - return ((LongBuffer) dest).put((LongBuffer) src); - } else if ((dest instanceof DoubleBuffer) && (src instanceof DoubleBuffer)) { - return ((DoubleBuffer) dest).put((DoubleBuffer) src); - } else if ((dest instanceof CharBuffer) && (src instanceof CharBuffer)) { - return ((CharBuffer) dest).put((CharBuffer) src); - } - } - throw new RuntimeException("Incompatible Buffer classes: dest = " + dest.getClass().getName() + ", src = " + src.getClass().getName()); - } - - public static Buffer putb(Buffer dest, byte v) { - if (dest instanceof ByteBuffer) { - return ((ByteBuffer) dest).put(v); - } else if (dest instanceof ShortBuffer) { - return ((ShortBuffer) dest).put((short) v); - } else if (dest instanceof IntBuffer) { - return ((IntBuffer) dest).put((int) v); - } else { - throw new RuntimeException("Byte doesn't match Buffer Class: " + dest); - } - } - - public static Buffer puts(Buffer dest, short v) { - if (dest instanceof ShortBuffer) { - return ((ShortBuffer) dest).put(v); - } else if (dest instanceof IntBuffer) { - return ((IntBuffer) dest).put((int) v); - } else { - throw new RuntimeException("Short doesn't match Buffer Class: " + dest); - } - } - - public static void puti(Buffer dest, int v) { - if (dest instanceof IntBuffer) { - ((IntBuffer) dest).put(v); - } else { - throw new RuntimeException("Integer doesn't match Buffer Class: " + dest); - } - } - - public static void putf(Buffer dest, float v) { - if (dest instanceof FloatBuffer) { - ((FloatBuffer) dest).put(v); -/* TODO FixedPoint required - } else if (dest instanceof IntBuffer) { - ((IntBuffer) dest).put(FixedPoint.toFixed(v)); -*/ - } else { - throw new RuntimeException("Float doesn't match Buffer Class: " + dest); - } - } - public static void putd(Buffer dest, double v) { - if (dest instanceof FloatBuffer) { - ((FloatBuffer) dest).put((float) v); - } else { - throw new RuntimeException("Double doesn't match Buffer Class: " + dest); - } - } - - public static void rangeCheck(byte[] array, int offset, int minElementsRemaining) { - if (array == null) { - return; - } - - if (array.length < offset + minElementsRemaining) { - throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset)); - } - } - - public static void rangeCheck(char[] array, int offset, int minElementsRemaining) { - if (array == null) { - return; - } - - if (array.length < offset + minElementsRemaining) { - throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset)); - } - } - - public static void rangeCheck(short[] array, int offset, int minElementsRemaining) { - if (array == null) { - return; - } - - if (array.length < offset + minElementsRemaining) { - throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset)); - } - } - - public static void rangeCheck(int[] array, int offset, int minElementsRemaining) { - if (array == null) { - return; - } - - if (array.length < offset + minElementsRemaining) { - throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset)); - } - } - - public static void rangeCheck(long[] array, int offset, int minElementsRemaining) { - if (array == null) { - return; - } - - if (array.length < offset + minElementsRemaining) { - throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset)); - } - } - - public static void rangeCheck(float[] array, int offset, int minElementsRemaining) { - if (array == null) { - return; - } - - if (array.length < offset + minElementsRemaining) { - throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset)); - } - } - - public static void rangeCheck(double[] array, int offset, int minElementsRemaining) { - if (array == null) { - return; - } - - if (array.length < offset + minElementsRemaining) { - throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset)); - } - } - - public static void rangeCheck(Buffer buffer, int minElementsRemaining) { - if (buffer == null) { - return; - } - - if (buffer.remaining() < minElementsRemaining) { - throw new IndexOutOfBoundsException("Required " + minElementsRemaining + " remaining elements in buffer, only had " + buffer.remaining()); - } - } - - public static void rangeCheckBytes(Object buffer, int minBytesRemaining) { - if (buffer == null) { - return; - } - - int bytesRemaining = 0; - if (buffer instanceof Buffer) { - int elementsRemaining = ((Buffer) buffer).remaining(); - if (buffer instanceof ByteBuffer) { - bytesRemaining = elementsRemaining; - } else if (buffer instanceof FloatBuffer) { - bytesRemaining = elementsRemaining * SIZEOF_FLOAT; - } else if (buffer instanceof IntBuffer) { - bytesRemaining = elementsRemaining * SIZEOF_INT; - } else if (buffer instanceof ShortBuffer) { - bytesRemaining = elementsRemaining * SIZEOF_SHORT; - }else if(Platform.isJavaSE()) { - if (buffer instanceof DoubleBuffer) { - bytesRemaining = elementsRemaining * SIZEOF_DOUBLE; - } else if (buffer instanceof LongBuffer) { - bytesRemaining = elementsRemaining * SIZEOF_LONG; - } else if (buffer instanceof CharBuffer) { - bytesRemaining = elementsRemaining * SIZEOF_CHAR; - } - } - } else if (buffer instanceof PointerBuffer) { - PointerBuffer pointerBuffer = (PointerBuffer) buffer; - bytesRemaining = pointerBuffer.remaining() * PointerBuffer.elementSize(); - } - if (bytesRemaining < minBytesRemaining) { - throw new IndexOutOfBoundsException("Required " + minBytesRemaining + " remaining bytes in buffer, only had " + bytesRemaining); - } - } - -} diff --git a/src/java/com/jogamp/gluegen/runtime/Buffers.java b/src/java/com/jogamp/gluegen/runtime/Buffers.java new file mode 100755 index 0000000..843d8a6 --- /dev/null +++ b/src/java/com/jogamp/gluegen/runtime/Buffers.java @@ -0,0 +1,668 @@ +/* + * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * - Redistribution of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * - Redistribution 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 Sun Microsystems, Inc. or the names of + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * This software is provided "AS IS," without a warranty of any kind. ALL + * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, + * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A + * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN + * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR + * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR + * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR + * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR + * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE + * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY, + * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF + * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + * + * You acknowledge that this software is not designed or intended for use + * in the design, construction, operation or maintenance of any nuclear + * facility. + * + * Sun gratefully acknowledges that this software was originally authored + * and developed by Kenneth Bradley Russell and Christopher John Kline. + */ +package com.jogamp.gluegen.runtime; + +import java.nio.*; + +/** + * @author Kenneth Russel + * @author Sven Gothel + * @author Michael Bien + */ +public class Buffers { + + public static final int SIZEOF_BYTE = 1; + public static final int SIZEOF_SHORT = 2; + public static final int SIZEOF_CHAR = 2; + public static final int SIZEOF_INT = 4; + public static final int SIZEOF_FLOAT = 4; + public static final int SIZEOF_LONG = 8; + public static final int SIZEOF_DOUBLE = 8; + + private Buffers() {} + + /** + * Allocates a new direct ByteBuffer with the specified number of + * elements. The returned buffer will have its byte order set to + * the host platform's native byte order. + */ + public static ByteBuffer newDirectByteBuffer(int numElements) { + return nativeOrder(ByteBuffer.allocateDirect(numElements)); + } + + public static ByteBuffer newDirectByteBuffer(byte[] values, int offset, int lenght) { + return (ByteBuffer)newDirectByteBuffer(lenght).put(values, offset, lenght).rewind(); + } + + public static ByteBuffer newDirectByteBuffer(byte[] values, int offset) { + return newDirectByteBuffer(values, offset, values.length-offset); + } + + public static ByteBuffer newDirectByteBuffer(byte[] values) { + return newDirectByteBuffer(values, 0); + } + + /** + * Allocates a new direct DoubleBuffer with the specified number of + * elements. The returned buffer will have its byte order set to + * the host platform's native byte order. + */ + public static DoubleBuffer newDirectDoubleBuffer(int numElements) { + return newDirectByteBuffer(numElements * SIZEOF_DOUBLE).asDoubleBuffer(); + } + + public static DoubleBuffer newDirectDoubleBuffer(double[] values, int offset, int lenght) { + return (DoubleBuffer)newDirectDoubleBuffer(lenght).put(values, offset, lenght).rewind(); + } + + public static DoubleBuffer newDirectDoubleBuffer(double[] values, int offset) { + return newDirectDoubleBuffer(values, offset, values.length - offset); + } + + public static DoubleBuffer newDirectDoubleBuffer(double[] values) { + return newDirectDoubleBuffer(values, 0); + } + + /** + * Allocates a new direct FloatBuffer with the specified number of + * elements. The returned buffer will have its byte order set to + * the host platform's native byte order. + */ + public static FloatBuffer newDirectFloatBuffer(int numElements) { + return newDirectByteBuffer(numElements * SIZEOF_FLOAT).asFloatBuffer(); + } + + public static FloatBuffer newDirectFloatBuffer(float[] values, int offset, int lenght) { + return (FloatBuffer)newDirectFloatBuffer(lenght).put(values, offset, lenght).rewind(); + } + + public static FloatBuffer newDirectFloatBuffer(float[] values, int offset) { + return newDirectFloatBuffer(values, offset, values.length - offset); + } + + public static FloatBuffer newDirectFloatBuffer(float[] values) { + return newDirectFloatBuffer(values, 0); + } + + /** + * Allocates a new direct IntBuffer with the specified number of + * elements. The returned buffer will have its byte order set to + * the host platform's native byte order. + */ + public static IntBuffer newDirectIntBuffer(int numElements) { + return newDirectByteBuffer(numElements * SIZEOF_INT).asIntBuffer(); + } + + public static IntBuffer newDirectIntBuffer(int[] values, int offset, int lenght) { + return (IntBuffer)newDirectIntBuffer(lenght).put(values, offset, lenght).rewind(); + } + + public static IntBuffer newDirectIntBuffer(int[] values, int offset) { + return newDirectIntBuffer(values, offset, values.length - offset); + } + + public static IntBuffer newDirectIntBuffer(int[] values) { + return newDirectIntBuffer(values, 0); + } + + /** + * Allocates a new direct LongBuffer with the specified number of + * elements. The returned buffer will have its byte order set to + * the host platform's native byte order. + */ + public static LongBuffer newDirectLongBuffer(int numElements) { + return newDirectByteBuffer(numElements * SIZEOF_LONG).asLongBuffer(); + } + + public static LongBuffer newDirectLongBuffer(long[] values, int offset, int lenght) { + return (LongBuffer)newDirectLongBuffer(lenght).put(values, offset, lenght).rewind(); + } + + public static LongBuffer newDirectLongBuffer(long[] values, int offset) { + return newDirectLongBuffer(values, offset, values.length - offset); + } + + public static LongBuffer newDirectLongBuffer(long[] values) { + return newDirectLongBuffer(values, 0); + } + + /** + * Allocates a new direct ShortBuffer with the specified number of + * elements. The returned buffer will have its byte order set to + * the host platform's native byte order. + */ + public static ShortBuffer newDirectShortBuffer(int numElements) { + return newDirectByteBuffer(numElements * SIZEOF_SHORT).asShortBuffer(); + } + + public static ShortBuffer newDirectShortBuffer(short[] values, int offset, int lenght) { + return (ShortBuffer)newDirectShortBuffer(lenght).put(values, offset, lenght).rewind(); + } + + public static ShortBuffer newDirectShortBuffer(short[] values, int offset) { + return newDirectShortBuffer(values, offset, values.length - offset); + } + + public static ShortBuffer newDirectShortBuffer(short[] values) { + return newDirectShortBuffer(values, 0); + } + + /** + * Allocates a new direct CharBuffer with the specified number of + * elements. The returned buffer will have its byte order set to + * the host platform's native byte order. + */ + public static CharBuffer newDirectCharBuffer(int numElements) { + return newDirectByteBuffer(numElements * SIZEOF_SHORT).asCharBuffer(); + } + + public static CharBuffer newDirectCharBuffer(char[] values, int offset, int lenght) { + return (CharBuffer)newDirectCharBuffer(lenght).put(values, offset, lenght).rewind(); + } + + public static CharBuffer newDirectCharBuffer(char[] values, int offset) { + return newDirectCharBuffer(values, offset, values.length - offset); + } + + public static CharBuffer newDirectCharBuffer(char[] values) { + return newDirectCharBuffer(values, 0); + } + + /** + * Helper routine to set a ByteBuffer to the native byte order, if + * that operation is supported by the underlying NIO + * implementation. + */ + public static ByteBuffer nativeOrder(ByteBuffer buf) { + if (Platform.isJavaSE()) { + return buf.order(ByteOrder.nativeOrder()); + } else { + // JSR 239 does not support the ByteOrder class or the order methods. + // The initial order of a byte buffer is the platform byte order. + return buf; + } + } + + /** + * Helper routine to tell whether a buffer is direct or not. Null + * pointers are considered NOT direct. isDirect() should really be + * public in Buffer and not replicated in all subclasses. + */ + public static boolean isDirect(Object buf) { + if (buf == null) { + return true; + } + if (buf instanceof ByteBuffer) { + return ((ByteBuffer) buf).isDirect(); + } else if (buf instanceof FloatBuffer) { + return ((FloatBuffer) buf).isDirect(); + } else if (buf instanceof IntBuffer) { + return ((IntBuffer) buf).isDirect(); + } else if (buf instanceof ShortBuffer) { + return ((ShortBuffer) buf).isDirect(); + } else if (buf instanceof PointerBuffer) { + return ((PointerBuffer) buf).isDirect(); + } else if (Platform.isJavaSE()) { + if (buf instanceof DoubleBuffer) { + return ((DoubleBuffer) buf).isDirect(); + } else if (buf instanceof LongBuffer) { + return ((LongBuffer) buf).isDirect(); + }else if (buf instanceof CharBuffer) { + return ((CharBuffer) buf).isDirect(); + } + } + throw new RuntimeException("Unexpected buffer type " + buf.getClass().getName()); + } + + /** + * Helper routine to get the Buffer byte offset by taking into + * account the Buffer position and the underlying type. This is + * the total offset for Direct Buffers. + */ + public static int getDirectBufferByteOffset(Object buf) { + if (buf == null) { + return 0; + } + if (buf instanceof Buffer) { + int pos = ((Buffer) buf).position(); + if (buf instanceof ByteBuffer) { + return pos; + } else if (buf instanceof FloatBuffer) { + return pos * SIZEOF_FLOAT; + } else if (buf instanceof IntBuffer) { + return pos * SIZEOF_INT; + } else if (buf instanceof ShortBuffer) { + return pos * SIZEOF_SHORT; + }else if(Platform.isJavaSE()) { + if (buf instanceof DoubleBuffer) { + return pos * SIZEOF_DOUBLE; + } else if (buf instanceof LongBuffer) { + return pos * SIZEOF_LONG; + } else if (buf instanceof CharBuffer) { + return pos * SIZEOF_CHAR; + } + } + } else if (buf instanceof PointerBuffer) { + PointerBuffer pointerBuffer = (PointerBuffer) buf; + return pointerBuffer.position() * PointerBuffer.elementSize(); + } + + throw new RuntimeException("Disallowed array backing store type in buffer " + + buf.getClass().getName()); + } + + /** + * Helper routine to return the array backing store reference from + * a Buffer object. + */ + public static Object getArray(Object buf) { + if (buf == null) { + return null; + } + if (buf instanceof ByteBuffer) { + return ((ByteBuffer) buf).array(); + } else if (buf instanceof FloatBuffer) { + return ((FloatBuffer) buf).array(); + } else if (buf instanceof IntBuffer) { + return ((IntBuffer) buf).array(); + } else if (buf instanceof ShortBuffer) { + return ((ShortBuffer) buf).array(); + } else if (buf instanceof PointerBuffer) { + return ((PointerBuffer) buf).array(); + }else if(Platform.isJavaSE()) { + if (buf instanceof DoubleBuffer) { + return ((DoubleBuffer) buf).array(); + } else if (buf instanceof LongBuffer) { + return ((LongBuffer) buf).array(); + } else if (buf instanceof CharBuffer) { + return ((CharBuffer) buf).array(); + } + } + + throw new RuntimeException("Disallowed array backing store type in buffer " + + buf.getClass().getName()); + } + + /** + * Helper routine to get the full byte offset from the beginning of + * the array that is the storage for the indirect Buffer + * object. The array offset also includes the position offset + * within the buffer, in addition to any array offset. + */ + public static int getIndirectBufferByteOffset(Object buf) { + if (buf == null) { + return 0; + } + if (buf instanceof Buffer) { + int pos = ((Buffer) buf).position(); + if (buf instanceof ByteBuffer) { + return (((ByteBuffer) buf).arrayOffset() + pos); + } else if (buf instanceof FloatBuffer) { + return (SIZEOF_FLOAT * (((FloatBuffer) buf).arrayOffset() + pos)); + } else if (buf instanceof IntBuffer) { + return (SIZEOF_INT * (((IntBuffer) buf).arrayOffset() + pos)); + } else if (buf instanceof ShortBuffer) { + return (SIZEOF_SHORT * (((ShortBuffer) buf).arrayOffset() + pos)); + }else if(Platform.isJavaSE()) { + if (buf instanceof DoubleBuffer) { + return (SIZEOF_DOUBLE * (((DoubleBuffer) buf).arrayOffset() + pos)); + } else if (buf instanceof LongBuffer) { + return (SIZEOF_LONG * (((LongBuffer) buf).arrayOffset() + pos)); + } else if (buf instanceof CharBuffer) { + return (SIZEOF_CHAR * (((CharBuffer) buf).arrayOffset() + pos)); + } + } + } else if (buf instanceof PointerBuffer) { + PointerBuffer pointerBuffer = (PointerBuffer) buf; + return PointerBuffer.elementSize() * (pointerBuffer.arrayOffset() + pointerBuffer.position()); + } + + throw new RuntimeException("Unknown buffer type " + buf.getClass().getName()); + } + + + //---------------------------------------------------------------------- + // Copy routines (type-to-type) + // + /** + * Copies the remaining elements (as defined by + * limit() - position()) in the passed ByteBuffer into + * a newly-allocated direct ByteBuffer. The returned buffer will + * have its byte order set to the host platform's native byte + * order. The position of the newly-allocated buffer will be zero, + * and the position of the passed buffer is unchanged (though its + * mark is changed). + */ + public static ByteBuffer copyByteBuffer(ByteBuffer orig) { + ByteBuffer dest = newDirectByteBuffer(orig.remaining()); + dest.put(orig); + dest.rewind(); + return dest; + } + + /** + * Copies the remaining elements (as defined by + * limit() - position()) in the passed FloatBuffer + * into a newly-allocated direct FloatBuffer. The returned buffer + * will have its byte order set to the host platform's native byte + * order. The position of the newly-allocated buffer will be zero, + * and the position of the passed buffer is unchanged (though its + * mark is changed). + */ + public static FloatBuffer copyFloatBuffer(FloatBuffer orig) { + return copyFloatBufferAsByteBuffer(orig).asFloatBuffer(); + } + + /** + * Copies the remaining elements (as defined by + * limit() - position()) in the passed IntBuffer + * into a newly-allocated direct IntBuffer. The returned buffer + * will have its byte order set to the host platform's native byte + * order. The position of the newly-allocated buffer will be zero, + * and the position of the passed buffer is unchanged (though its + * mark is changed). + */ + public static IntBuffer copyIntBuffer(IntBuffer orig) { + return copyIntBufferAsByteBuffer(orig).asIntBuffer(); + } + + /** + * Copies the remaining elements (as defined by + * limit() - position()) in the passed ShortBuffer + * into a newly-allocated direct ShortBuffer. The returned buffer + * will have its byte order set to the host platform's native byte + * order. The position of the newly-allocated buffer will be zero, + * and the position of the passed buffer is unchanged (though its + * mark is changed). + */ + public static ShortBuffer copyShortBuffer(ShortBuffer orig) { + return copyShortBufferAsByteBuffer(orig).asShortBuffer(); + } + + //---------------------------------------------------------------------- + // Copy routines (type-to-ByteBuffer) + // + /** + * Copies the remaining elements (as defined by + * limit() - position()) in the passed FloatBuffer + * into a newly-allocated direct ByteBuffer. The returned buffer + * will have its byte order set to the host platform's native byte + * order. The position of the newly-allocated buffer will be zero, + * and the position of the passed buffer is unchanged (though its + * mark is changed). + */ + public static ByteBuffer copyFloatBufferAsByteBuffer(FloatBuffer orig) { + ByteBuffer dest = newDirectByteBuffer(orig.remaining() * SIZEOF_FLOAT); + dest.asFloatBuffer().put(orig); + dest.rewind(); + return dest; + } + + /** + * Copies the remaining elements (as defined by + * limit() - position()) in the passed IntBuffer into + * a newly-allocated direct ByteBuffer. The returned buffer will + * have its byte order set to the host platform's native byte + * order. The position of the newly-allocated buffer will be zero, + * and the position of the passed buffer is unchanged (though its + * mark is changed). + */ + public static ByteBuffer copyIntBufferAsByteBuffer(IntBuffer orig) { + ByteBuffer dest = newDirectByteBuffer(orig.remaining() * SIZEOF_INT); + dest.asIntBuffer().put(orig); + dest.rewind(); + return dest; + } + + /** + * Copies the remaining elements (as defined by + * limit() - position()) in the passed ShortBuffer + * into a newly-allocated direct ByteBuffer. The returned buffer + * will have its byte order set to the host platform's native byte + * order. The position of the newly-allocated buffer will be zero, + * and the position of the passed buffer is unchanged (though its + * mark is changed). + */ + public static ByteBuffer copyShortBufferAsByteBuffer(ShortBuffer orig) { + ByteBuffer dest = newDirectByteBuffer(orig.remaining() * SIZEOF_SHORT); + dest.asShortBuffer().put(orig); + dest.rewind(); + return dest; + } + + //---------------------------------------------------------------------- + // Conversion routines + // + public final static FloatBuffer getFloatBuffer(DoubleBuffer source) { + source.rewind(); + FloatBuffer dest = newDirectFloatBuffer(source.limit()); + while (source.hasRemaining()) { + dest.put((float) source.get()); + } + return dest; + } + + //---------------------------------------------------------------------- + // Convenient put methods with generic target Buffer + // + public static Buffer put(Buffer dest, Buffer src) { + if ((dest instanceof ByteBuffer) && (src instanceof ByteBuffer)) { + return ((ByteBuffer) dest).put((ByteBuffer) src); + } else if ((dest instanceof ShortBuffer) && (src instanceof ShortBuffer)) { + return ((ShortBuffer) dest).put((ShortBuffer) src); + } else if ((dest instanceof IntBuffer) && (src instanceof IntBuffer)) { + return ((IntBuffer) dest).put((IntBuffer) src); + } else if ((dest instanceof FloatBuffer) && (src instanceof FloatBuffer)) { + return ((FloatBuffer) dest).put((FloatBuffer) src); + } else if (Platform.isJavaSE()) { + if ((dest instanceof LongBuffer) && (src instanceof LongBuffer)) { + return ((LongBuffer) dest).put((LongBuffer) src); + } else if ((dest instanceof DoubleBuffer) && (src instanceof DoubleBuffer)) { + return ((DoubleBuffer) dest).put((DoubleBuffer) src); + } else if ((dest instanceof CharBuffer) && (src instanceof CharBuffer)) { + return ((CharBuffer) dest).put((CharBuffer) src); + } + } + throw new RuntimeException("Incompatible Buffer classes: dest = " + dest.getClass().getName() + ", src = " + src.getClass().getName()); + } + + public static Buffer putb(Buffer dest, byte v) { + if (dest instanceof ByteBuffer) { + return ((ByteBuffer) dest).put(v); + } else if (dest instanceof ShortBuffer) { + return ((ShortBuffer) dest).put((short) v); + } else if (dest instanceof IntBuffer) { + return ((IntBuffer) dest).put((int) v); + } else { + throw new RuntimeException("Byte doesn't match Buffer Class: " + dest); + } + } + + public static Buffer puts(Buffer dest, short v) { + if (dest instanceof ShortBuffer) { + return ((ShortBuffer) dest).put(v); + } else if (dest instanceof IntBuffer) { + return ((IntBuffer) dest).put((int) v); + } else { + throw new RuntimeException("Short doesn't match Buffer Class: " + dest); + } + } + + public static void puti(Buffer dest, int v) { + if (dest instanceof IntBuffer) { + ((IntBuffer) dest).put(v); + } else { + throw new RuntimeException("Integer doesn't match Buffer Class: " + dest); + } + } + + public static void putf(Buffer dest, float v) { + if (dest instanceof FloatBuffer) { + ((FloatBuffer) dest).put(v); +/* TODO FixedPoint required + } else if (dest instanceof IntBuffer) { + ((IntBuffer) dest).put(FixedPoint.toFixed(v)); +*/ + } else { + throw new RuntimeException("Float doesn't match Buffer Class: " + dest); + } + } + public static void putd(Buffer dest, double v) { + if (dest instanceof FloatBuffer) { + ((FloatBuffer) dest).put((float) v); + } else { + throw new RuntimeException("Double doesn't match Buffer Class: " + dest); + } + } + + public static void rangeCheck(byte[] array, int offset, int minElementsRemaining) { + if (array == null) { + return; + } + + if (array.length < offset + minElementsRemaining) { + throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset)); + } + } + + public static void rangeCheck(char[] array, int offset, int minElementsRemaining) { + if (array == null) { + return; + } + + if (array.length < offset + minElementsRemaining) { + throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset)); + } + } + + public static void rangeCheck(short[] array, int offset, int minElementsRemaining) { + if (array == null) { + return; + } + + if (array.length < offset + minElementsRemaining) { + throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset)); + } + } + + public static void rangeCheck(int[] array, int offset, int minElementsRemaining) { + if (array == null) { + return; + } + + if (array.length < offset + minElementsRemaining) { + throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset)); + } + } + + public static void rangeCheck(long[] array, int offset, int minElementsRemaining) { + if (array == null) { + return; + } + + if (array.length < offset + minElementsRemaining) { + throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset)); + } + } + + public static void rangeCheck(float[] array, int offset, int minElementsRemaining) { + if (array == null) { + return; + } + + if (array.length < offset + minElementsRemaining) { + throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset)); + } + } + + public static void rangeCheck(double[] array, int offset, int minElementsRemaining) { + if (array == null) { + return; + } + + if (array.length < offset + minElementsRemaining) { + throw new ArrayIndexOutOfBoundsException("Required " + minElementsRemaining + " elements in array, only had " + (array.length - offset)); + } + } + + public static void rangeCheck(Buffer buffer, int minElementsRemaining) { + if (buffer == null) { + return; + } + + if (buffer.remaining() < minElementsRemaining) { + throw new IndexOutOfBoundsException("Required " + minElementsRemaining + " remaining elements in buffer, only had " + buffer.remaining()); + } + } + + public static void rangeCheckBytes(Object buffer, int minBytesRemaining) { + if (buffer == null) { + return; + } + + int bytesRemaining = 0; + if (buffer instanceof Buffer) { + int elementsRemaining = ((Buffer) buffer).remaining(); + if (buffer instanceof ByteBuffer) { + bytesRemaining = elementsRemaining; + } else if (buffer instanceof FloatBuffer) { + bytesRemaining = elementsRemaining * SIZEOF_FLOAT; + } else if (buffer instanceof IntBuffer) { + bytesRemaining = elementsRemaining * SIZEOF_INT; + } else if (buffer instanceof ShortBuffer) { + bytesRemaining = elementsRemaining * SIZEOF_SHORT; + }else if(Platform.isJavaSE()) { + if (buffer instanceof DoubleBuffer) { + bytesRemaining = elementsRemaining * SIZEOF_DOUBLE; + } else if (buffer instanceof LongBuffer) { + bytesRemaining = elementsRemaining * SIZEOF_LONG; + } else if (buffer instanceof CharBuffer) { + bytesRemaining = elementsRemaining * SIZEOF_CHAR; + } + } + } else if (buffer instanceof PointerBuffer) { + PointerBuffer pointerBuffer = (PointerBuffer) buffer; + bytesRemaining = pointerBuffer.remaining() * PointerBuffer.elementSize(); + } + if (bytesRemaining < minBytesRemaining) { + throw new IndexOutOfBoundsException("Required " + minBytesRemaining + " remaining bytes in buffer, only had " + bytesRemaining); + } + } + +} diff --git a/src/java/com/jogamp/gluegen/runtime/Platform.java b/src/java/com/jogamp/gluegen/runtime/Platform.java index 7c5e97e..8245b51 100644 --- a/src/java/com/jogamp/gluegen/runtime/Platform.java +++ b/src/java/com/jogamp/gluegen/runtime/Platform.java @@ -60,7 +60,7 @@ public class Platform { JAVA_SE = se; // byte order - ByteBuffer tst_b = BufferFactory.newDirectByteBuffer(BufferFactory.SIZEOF_INT); // 32bit in native order + ByteBuffer tst_b = Buffers.newDirectByteBuffer(Buffers.SIZEOF_INT); // 32bit in native order IntBuffer tst_i = tst_b.asIntBuffer(); ShortBuffer tst_s = tst_b.asShortBuffer(); tst_i.put(0, 0x0A0B0C0D); diff --git a/src/java/com/jogamp/gluegen/runtime/PointerBuffer.java b/src/java/com/jogamp/gluegen/runtime/PointerBuffer.java index bd73e56..ff1bc2e 100644 --- a/src/java/com/jogamp/gluegen/runtime/PointerBuffer.java +++ b/src/java/com/jogamp/gluegen/runtime/PointerBuffer.java @@ -58,9 +58,9 @@ public abstract class PointerBuffer { public static PointerBuffer allocateDirect(int size) { if (Platform.isJavaSE()) { - return new PointerBufferSE(BufferFactory.newDirectByteBuffer(elementSize() * size)); + return new PointerBufferSE(Buffers.newDirectByteBuffer(elementSize() * size)); } else { - return new PointerBufferME_CDC_FP(BufferFactory.newDirectByteBuffer(elementSize() * size)); + return new PointerBufferME_CDC_FP(Buffers.newDirectByteBuffer(elementSize() * size)); } } @@ -87,7 +87,7 @@ public abstract class PointerBuffer { } public static int elementSize() { - return CPU.is32Bit() ? BufferFactory.SIZEOF_INT : BufferFactory.SIZEOF_LONG; + return CPU.is32Bit() ? Buffers.SIZEOF_INT : Buffers.SIZEOF_LONG; } public int limit() { diff --git a/src/java/com/sun/gluegen/JavaConfiguration.java b/src/java/com/sun/gluegen/JavaConfiguration.java index 3683e29..2bcb17a 100644 --- a/src/java/com/sun/gluegen/JavaConfiguration.java +++ b/src/java/com/sun/gluegen/JavaConfiguration.java @@ -104,7 +104,7 @@ public class JavaConfiguration { /** * The package in which the generated glue code expects to find its - * run-time helper classes (BufferFactory, CPU, + * run-time helper classes (Buffer, CPU, * StructAccessor). Defaults to "com.jogamp.gluegen.runtime". */ private String gluegenRuntimePackage = "com.jogamp.gluegen.runtime"; @@ -308,7 +308,7 @@ public class JavaConfiguration { } /** Returns the package in which the generated glue code expects to - find its run-time helper classes (BufferFactory, CPU, + find its run-time helper classes (Buffer, CPU, StructAccessor). Defaults to "com.jogamp.gluegen.runtime". */ public String gluegenRuntimePackage() { return gluegenRuntimePackage; @@ -1500,7 +1500,7 @@ public class JavaConfiguration { restOfLine = restOfLine.trim(); // Construct a JavaPrologue for this addJavaPrologueOrEpilogue(functionName, - "BufferFactory.rangeCheck" + + "Buffers.rangeCheck" + (inBytes ? "Bytes" : "") + "({" + argNum + "}, " + restOfLine + ");", true); diff --git a/src/java/com/sun/gluegen/JavaEmitter.java b/src/java/com/sun/gluegen/JavaEmitter.java index b2f7578..0759d81 100644 --- a/src/java/com/sun/gluegen/JavaEmitter.java +++ b/src/java/com/sun/gluegen/JavaEmitter.java @@ -693,10 +693,10 @@ public class JavaEmitter implements GlueEmitter { // public void fooMethod(Buffer arg) { // ... bounds checks, etc. ... // - // boolean arg_direct = arg != null && BufferFactory.isDirect(arg); + // boolean arg_direct = arg != null && Buffers.isDirect(arg); // - // fooMethod0(arg_direct?arg:BufferFactory.getArray(arg), - // arg_direct?BufferFactory.getDirectBufferByteOffset(arg):BufferFactory.getIndirectBufferByteOffset(arg), + // fooMethod0(arg_direct?arg:Buffers.getArray(arg), + // arg_direct?Buffers.getDirectBufferByteOffset(arg):Buffers.getIndirectBufferByteOffset(arg), // arg_direct, // ... ); // } @@ -921,7 +921,7 @@ public class JavaEmitter implements GlueEmitter { writer.println(); if (doBaseClass) { writer.println(" public static " + containingTypeName + " create() {"); - writer.println(" return create(BufferFactory.newDirectByteBuffer(size()));"); + writer.println(" return create(Buffers.newDirectByteBuffer(size()));"); writer.println(" }"); writer.println(); writer.println(" public static " + containingTypeName + " create(java.nio.ByteBuffer buf) {"); diff --git a/src/java/com/sun/gluegen/JavaMethodBindingEmitter.java b/src/java/com/sun/gluegen/JavaMethodBindingEmitter.java index da5484b..8db4a3b 100644 --- a/src/java/com/sun/gluegen/JavaMethodBindingEmitter.java +++ b/src/java/com/sun/gluegen/JavaMethodBindingEmitter.java @@ -450,12 +450,12 @@ public class JavaMethodBindingEmitter extends FunctionEmitter JavaType javaType = binding.getJavaArgumentType(i); if (javaType.isNIOBuffer()) { if (directNIOOnly) { - writer.println(" if (!BufferFactory.isDirect(" + getArgumentName(i) + "))"); + writer.println(" if (!Buffers.isDirect(" + getArgumentName(i) + "))"); writer.println(" throw new " + getRuntimeExceptionType() + "(\"Argument \\\"" + getArgumentName(i) + "\\\" was not a direct buffer\");"); } else { writer.print(" boolean " + isNIOArgName(i) + " = "); - writer.println(getArgumentName(i) + " != null && BufferFactory.isDirect(" + getArgumentName(i) + ");"); + writer.println(getArgumentName(i) + " != null && Buffers.isDirect(" + getArgumentName(i) + ");"); } } else if (javaType.isNIOBufferArray()) { // All buffers passed down in an array of NIO buffers must be direct @@ -465,13 +465,13 @@ public class JavaMethodBindingEmitter extends FunctionEmitter // Check direct buffer properties of all buffers within writer.println(" if (" + argName + " != null) {"); writer.println(" for (int _ctr = 0; _ctr < " + argName + ".length; _ctr++) {"); - writer.println(" if (!BufferFactory.isDirect(" + argName + "[_ctr])) {"); + writer.println(" if (!Buffers.isDirect(" + argName + "[_ctr])) {"); writer.println(" throw new " + getRuntimeExceptionType() + "(\"Element \" + _ctr + \" of argument \\\"" + getArgumentName(i) + "\\\" was not a direct buffer\");"); writer.println(" }"); // get the Buffer Array offset values and save them into another array to send down to JNI - writer.print (" " + arrayName + "[_ctr] = BufferFactory.getDirectBufferByteOffset("); + writer.print (" " + arrayName + "[_ctr] = Buffers.getDirectBufferByteOffset("); writer.println(argName + "[_ctr]);"); writer.println(" }"); writer.println(" }"); @@ -594,13 +594,13 @@ public class JavaMethodBindingEmitter extends FunctionEmitter writer.print( getArgumentName(i)+ " != null ? " + getArgumentName(i) + ".getBuffer() : null"); } else { writer.print( isNIOArgName(i) + " ? ( " + getArgumentName(i)+ " != null ? " + getArgumentName(i) + ".getBuffer() : null )"); - writer.print( " : BufferFactory.getArray(" + getArgumentName(i) + ")" ); + writer.print( " : Buffers.getArray(" + getArgumentName(i) + ")" ); } } else { if (directNIOOnly) { writer.print( getArgumentName(i) ); } else { - writer.print( isNIOArgName(i) + " ? " + getArgumentName(i) + " : BufferFactory.getArray(" + getArgumentName(i) + ")" ); + writer.print( isNIOArgName(i) + " ? " + getArgumentName(i) + " : Buffers.getArray(" + getArgumentName(i) + ")" ); } } } else if (type.isArrayOfCompoundTypeWrappers()) { @@ -617,26 +617,26 @@ public class JavaMethodBindingEmitter extends FunctionEmitter if (type.isNIOBuffer()) { if (directNIOOnly) { - writer.print( ", BufferFactory.getDirectBufferByteOffset(" + getArgumentName(i) + ")"); + writer.print( ", Buffers.getDirectBufferByteOffset(" + getArgumentName(i) + ")"); } else { - writer.print( ", " + isNIOArgName(i) + " ? BufferFactory.getDirectBufferByteOffset(" + getArgumentName(i) + ")"); - writer.print( " : BufferFactory.getIndirectBufferByteOffset(" + getArgumentName(i) + ")"); + writer.print( ", " + isNIOArgName(i) + " ? Buffers.getDirectBufferByteOffset(" + getArgumentName(i) + ")"); + writer.print( " : Buffers.getIndirectBufferByteOffset(" + getArgumentName(i) + ")"); } } else if (type.isNIOBufferArray()) { writer.print(", " + byteOffsetArrayArgName(i)); } else if (type.isPrimitiveArray()) { if(type.isFloatArray()) { - writer.print(", BufferFactory.SIZEOF_FLOAT * "); + writer.print(", Buffers.SIZEOF_FLOAT * "); } else if(type.isDoubleArray()) { - writer.print(", BufferFactory.SIZEOF_DOUBLE * "); + writer.print(", Buffers.SIZEOF_DOUBLE * "); } else if(type.isByteArray()) { writer.print(", "); } else if(type.isLongArray()) { - writer.print(", BufferFactory.SIZEOF_LONG * "); + writer.print(", Buffers.SIZEOF_LONG * "); } else if(type.isShortArray()) { - writer.print(", BufferFactory.SIZEOF_SHORT * "); + writer.print(", Buffers.SIZEOF_SHORT * "); } else if(type.isIntArray()) { - writer.print(", BufferFactory.SIZEOF_INT * "); + writer.print(", Buffers.SIZEOF_INT * "); } else { throw new RuntimeException("Unsupported type for calculating array offset argument for " + getArgumentName(i) + @@ -695,9 +695,9 @@ public class JavaMethodBindingEmitter extends FunctionEmitter String fmt = getReturnedArrayLengthExpression(); writer.println(" if (_res == null) return null;"); if (fmt == null) { - writer.print(" return " + returnType.getName() + ".create(BufferFactory.nativeOrder(_res))"); + writer.print(" return " + returnType.getName() + ".create(Buffers.nativeOrder(_res))"); } else { - writer.println(" BufferFactory.nativeOrder(_res);"); + writer.println(" Buffers.nativeOrder(_res);"); String expr = new MessageFormat(fmt).format(argumentNameArray()); PointerType cReturnTypePointer = binding.getCReturnType().asPointer(); CompoundType cReturnType = null; @@ -716,7 +716,7 @@ public class JavaMethodBindingEmitter extends FunctionEmitter writer.println(" _res.position(_count * " + getReturnTypeString(true) + ".size());"); writer.println(" _res.limit ((1 + _count) * " + getReturnTypeString(true) + ".size());"); writer.println(" java.nio.ByteBuffer _tmp = _res.slice();"); - writer.println(" BufferFactory.nativeOrder(_tmp);"); + writer.println(" Buffers.nativeOrder(_tmp);"); writer.println(" _res.position(0);"); writer.println(" _res.limit(_res.capacity());"); writer.println(" _retarray[_count] = " + getReturnTypeString(true) + ".create(_tmp);"); @@ -726,7 +726,7 @@ public class JavaMethodBindingEmitter extends FunctionEmitter writer.println(";"); } else if (returnType.isNIOBuffer()) { writer.println(" if (_res == null) return null;"); - writer.println(" BufferFactory.nativeOrder(_res);"); + writer.println(" Buffers.nativeOrder(_res);"); if (!returnType.isNIOByteBuffer()) { // See whether we have to expand pointers to longs if (getBinding().getCReturnType().pointerDepth() >= 2) { diff --git a/src/java/com/sun/gluegen/nativesig/NativeSignatureJavaMethodBindingEmitter.java b/src/java/com/sun/gluegen/nativesig/NativeSignatureJavaMethodBindingEmitter.java index 63d95fe..b4dc130 100755 --- a/src/java/com/sun/gluegen/nativesig/NativeSignatureJavaMethodBindingEmitter.java +++ b/src/java/com/sun/gluegen/nativesig/NativeSignatureJavaMethodBindingEmitter.java @@ -146,10 +146,10 @@ public class NativeSignatureJavaMethodBindingEmitter extends GLJavaMethodBinding if (type.isNIOBuffer() && !directNIOOnly) { // Emit declarations for variables holding primitive arrays as type Object // We don't know 100% sure we're going to use these at this point in the code, though - writer.println(" Object " + getNIOBufferArrayName(i) + " = (_direct ? null : BufferFactory.getArray(" + + writer.println(" Object " + getNIOBufferArrayName(i) + " = (_direct ? null : Buffers.getArray(" + getArgumentName(i) + "));"); } else if (type.isString()) { - writer.println(" long " + binding.getArgumentName(i) + "_c_str = BufferFactoryInternal.newCString(" + binding.getArgumentName(i) + ");"); + writer.println(" long " + binding.getArgumentName(i) + "_c_str = BuffersInternal.newCString(" + binding.getArgumentName(i) + ");"); } // FIXME: going to need more of these for Buffer[] and String[], at least } @@ -275,9 +275,9 @@ public class NativeSignatureJavaMethodBindingEmitter extends GLJavaMethodBinding if (needsResultAssignment) { writer.print(" _res = "); if (returnType.isString()) { - writer.print("BufferFactoryInternal.newJavaString("); + writer.print("BuffersInternal.newJavaString("); } else if (returnType.isNIOByteBuffer()) { - writer.print("BufferFactoryInternal.newDirectByteBuffer("); + writer.print("BuffersInternal.newDirectByteBuffer("); } } else { writer.print(" "); @@ -352,7 +352,7 @@ public class NativeSignatureJavaMethodBindingEmitter extends GLJavaMethodBinding if (binding.hasContainingType()) { // Emit this pointer assert(binding.getContainingType().isCompoundTypeWrapper()); - writer.print("BufferFactoryInternal.getDirectBufferAddress("); + writer.print("BuffersInternal.getDirectBufferAddress("); writer.print("getBuffer()"); writer.print(")"); needComma = true; @@ -377,7 +377,7 @@ public class NativeSignatureJavaMethodBindingEmitter extends GLJavaMethodBinding } if (type.isCompoundTypeWrapper()) { - writer.print("BufferFactoryInternal.getDirectBufferAddress("); + writer.print("BuffersInternal.getDirectBufferAddress("); writer.print("(("); } @@ -385,7 +385,7 @@ public class NativeSignatureJavaMethodBindingEmitter extends GLJavaMethodBinding if (!direct) { writer.print(getNIOBufferArrayName(i)); } else { - writer.print("BufferFactoryInternal.getDirectBufferAddress("); + writer.print("BuffersInternal.getDirectBufferAddress("); writer.print(getArgumentName(i)); writer.print(")"); } @@ -402,11 +402,11 @@ public class NativeSignatureJavaMethodBindingEmitter extends GLJavaMethodBinding if (type.isNIOBuffer()) { if (direct) { - writer.print("+ BufferFactory.getDirectBufferByteOffset(" + getArgumentName(i) + ")"); + writer.print("+ Buffers.getDirectBufferByteOffset(" + getArgumentName(i) + ")"); } else { - writer.print(", BufferFactoryInternal.arrayBaseOffset(" + + writer.print(", BuffersInternal.arrayBaseOffset(" + getNIOBufferArrayName(i) + - ") + BufferFactory.getIndirectBufferByteOffset(" + getArgumentName(i) + ")"); + ") + Buffers.getIndirectBufferByteOffset(" + getArgumentName(i) + ")"); } } else if (type.isNIOBufferArray()) { writer.print(", " + byteOffsetArrayArgName(i)); @@ -415,19 +415,19 @@ public class NativeSignatureJavaMethodBindingEmitter extends GLJavaMethodBinding // Add Array offset parameter for primitive arrays if (type.isPrimitiveArray()) { writer.print(", "); - writer.print("BufferFactoryInternal.arrayBaseOffset(" + getArgumentName(i) + ") + "); + writer.print("BuffersInternal.arrayBaseOffset(" + getArgumentName(i) + ") + "); if(type.isFloatArray()) { - writer.print("BufferFactory.SIZEOF_FLOAT * "); + writer.print("Buffers.SIZEOF_FLOAT * "); } else if(type.isDoubleArray()) { - writer.print("BufferFactory.SIZEOF_DOUBLE * "); + writer.print("Buffers.SIZEOF_DOUBLE * "); } else if(type.isByteArray()) { writer.print("1 * "); } else if(type.isLongArray()) { - writer.print("BufferFactory.SIZEOF_LONG * "); + writer.print("Buffers.SIZEOF_LONG * "); } else if(type.isShortArray()) { - writer.print("BufferFactory.SIZEOF_SHORT * "); + writer.print("Buffers.SIZEOF_SHORT * "); } else if(type.isIntArray()) { - writer.print("BufferFactory.SIZEOF_INT * "); + writer.print("Buffers.SIZEOF_INT * "); } else { throw new RuntimeException("Unsupported type for calculating array offset argument for " + getArgumentName(i) + @@ -455,7 +455,7 @@ public class NativeSignatureJavaMethodBindingEmitter extends GLJavaMethodBinding JavaType type = binding.getJavaArgumentType(i); if (type.isString()) { writer.println(";"); - writer.println(" BufferFactoryInternal.freeCString(" + binding.getArgumentName(i) + "_c_str);"); + writer.println(" BuffersInternal.freeCString(" + binding.getArgumentName(i) + "_c_str);"); } // FIXME: will need more of these cleanups for things like Buffer[] and String[] (see above) } diff --git a/src/java/com/sun/gluegen/opengl/GLConfiguration.java b/src/java/com/sun/gluegen/opengl/GLConfiguration.java index 19cf85a..6d08a10 100755 --- a/src/java/com/sun/gluegen/opengl/GLConfiguration.java +++ b/src/java/com/sun/gluegen/opengl/GLConfiguration.java @@ -173,7 +173,7 @@ public class GLConfiguration extends ProcAddressConfiguration { if (emitter.isBufferObjectMethodBinding(binding)) { for (Iterator iter = res.iterator(); iter.hasNext(); ) { String line = iter.next(); - if (line.indexOf("BufferFactory.rangeCheck") >= 0) { + if (line.indexOf("Buffers.rangeCheck") >= 0) { iter.remove(); } } diff --git a/src/java/com/sun/gluegen/test/TestStructAccessorEndian.java b/src/java/com/sun/gluegen/test/TestStructAccessorEndian.java index 362116d..89ccb5a 100644 --- a/src/java/com/sun/gluegen/test/TestStructAccessorEndian.java +++ b/src/java/com/sun/gluegen/test/TestStructAccessorEndian.java @@ -14,7 +14,7 @@ public class TestStructAccessorEndian { System.out.println("OS: <"+os+"> CPU: <"+cpu+"> Bits: <"+bitsPtr+"/"+bitsProp+">"); System.out.println("CPU is: "+ (CPU.is32Bit()?"32":"64") + " bit"); System.out.println("Buffer is in: "+ (Platform.isLittleEndian()?"little":"big") + " endian"); - ByteBuffer tst = BufferFactory.newDirectByteBuffer(BufferFactory.SIZEOF_LONG * 3); + ByteBuffer tst = Buffers.newDirectByteBuffer(Buffers.SIZEOF_LONG * 3); StructAccessor acc = new StructAccessor(tst); acc.setLongAt(0, 0x0123456789ABCDEFL); acc.setLongAt(1, 0x8877665544332211L); -- cgit v1.2.3