Modified Files:

	jogl/make/gl-common.cfg jogl/make/gl-glx-common.cfg
jogl/src/net/java/games/gluegen/opengl/JavaGLPAWrapperEmitter.java
jogl/src/net/java/games/gluegen/runtime/BufferFactory.java
jogl/src/net/java/games/gluegen/JavaEmitter.java
jogl/src/net/java/games/gluegen/JavaConfiguration.java
jogl/src/net/java/games/gluegen/CMethodBindingEmitter.java
jogl/src/net/java/games/gluegen/JavaMethodBindingEmitter.java
jogl/src/net/java/games/gluegen/CMethodBindingImplEmitter.java
jogl/src/net/java/games/gluegen/JavaMethodBindingImplEmitter.java
jogl/src/net/java/games/jogl/util/BufferUtils.java

Changes:

  * Add NIODirectOnly grammar for description of methods that should have
     only NIO Direct Buffer option (no expansion into other types, and also will
     not be expanded to include indirect Buffer when we add that functionality)

  * Make changes to respect Direct Buffer position value.  This allows a setting
     of an internal Buffer object parameter and JOGL will start reading data at
     the point in the buffer to which this position is set

  * The code is now generated to always respect this offset option.  This has the
      affect of changing the internal signatures of all methods that use Buffers.  But
      it does not affect the external API at all.

   * Old JOGL programs will continue working the same as long as they had the
      Buffer position set to zero before (the default value)


git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/svn-server-sync/jogl/branches/JSR-231@281 232f8b59-042b-4e1e-8c03-345bb8c30851

1 files changed, 83 insertions, 0 deletions

diff --git a/src/net/java/games/gluegen/runtime/BufferFactory.java b/src/net/java/games/gluegen/runtime/BufferFactory.java
index 67ffea1d8..67205db5f 100644
--- a/src/net/java/games/gluegen/runtime/BufferFactory.java
+++ b/src/net/java/games/gluegen/runtime/BufferFactory.java
@@ -40,6 +40,7 @@
 package net.java.games.gluegen.runtime;
 
 import java.nio.*;
+import net.java.games.jogl.util.BufferUtils;
 
 public class BufferFactory {
   public static ByteBuffer newDirectByteBuffer(int size) {
@@ -72,4 +73,86 @@ public class BufferFactory {
     }
     throw new RuntimeException("Unknown 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 getPositionByteOffset(Buffer buf) {
+      if(buf == null) {
+        return 0;
+      }
+      if(buf instanceof ByteBuffer) {
+          return (buf.position());
+      } else if (buf instanceof FloatBuffer) {
+          return (buf.position() * BufferUtils.SIZEOF_FLOAT);
+      } else if (buf instanceof IntBuffer) {
+          return (buf.position() * BufferUtils.SIZEOF_INT);
+      } else if (buf instanceof ShortBuffer) {
+          return (buf.position() * BufferUtils.SIZEOF_SHORT);
+      } else if (buf instanceof DoubleBuffer) {
+          return (buf.position() * BufferUtils.SIZEOF_DOUBLE);
+      } else if (buf instanceof LongBuffer) {
+          return (buf.position() * BufferUtils.SIZEOF_LONG);
+      } 
+
+      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(Buffer 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 DoubleBuffer) {
+          return ((DoubleBuffer) buf).array();
+      } else if (buf instanceof LongBuffer) {
+          return ((LongBuffer) 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 getTotalByteOffset(Buffer buf) {
+    if(buf == null) {
+      return 0;
+    }
+    int pos = buf.position();
+    if(buf instanceof ByteBuffer) {
+      return (((ByteBuffer)buf).arrayOffset() + pos);
+    } else if(buf instanceof FloatBuffer) {
+      return (BufferUtils.SIZEOF_FLOAT*(((FloatBuffer)buf).arrayOffset() + pos));
+    } else if(buf instanceof IntBuffer) {
+      return (BufferUtils.SIZEOF_INT*(((IntBuffer)buf).arrayOffset() + pos));
+    } else if(buf instanceof ShortBuffer) {
+      return (BufferUtils.SIZEOF_SHORT*(((ShortBuffer)buf).arrayOffset() + pos));
+    } else if(buf instanceof DoubleBuffer) {
+      return (BufferUtils.SIZEOF_DOUBLE*(((DoubleBuffer)buf).arrayOffset() + pos));
+    } else if(buf instanceof LongBuffer) {
+      return (BufferUtils.SIZEOF_LONG*(((LongBuffer)buf).arrayOffset() + pos));
+    } 
+
+    throw new RuntimeException("Unknown buffer type " + buf.getClass().getName());
+  }
+
 }