From 32790c376583beccd030eecd7c56cbe66d380172 Mon Sep 17 00:00:00 2001
From: Sven Gothel <sgothel@jausoft.com>
Date: Tue, 20 Apr 2010 11:46:26 +0200
Subject: JOGL GL4 preperation (cont):
- All available OpenGL versions (native/platform) are verified at GLProfile
initialization and can be queried ..
A mapping of major,compat -> major,minor,options is created.
- Removal of temp context creation, when creating a context.
This was necessary to query general availability of ARB_create_context.
Due to the shared context of X11GLXDrawableFactory and WindowsWGLDrawableFactory,
this is no more necessary.
Due to the version mapping, the ARB_create_context paramters are known.
- NativeWindow X11Lib: Added X11ErrorHandler, throwing a RuntimeException.
Necessary to catch BadMatch .. etc X11 errors, eg for glXCreateContextAttribsARB
Hence all X11 calls are covered now.
- X11DummyGLXDrawable needs to use an own Window, otherwise GLn n>2 fails
- Flattening the desktop GL* implementation,
all use GL4bcImpl, which reduces the footprint dramatically.
- GL*Impl.isGL*() (desktop) utilizes the GLContext.isGL*(),
hence the results reflect the actual native context version.
- GLContextImpl makeCurrent/create: Added workflow documentation,
clarified code, defined abstract methods to have a protocol.
- Removed moved files (from here to gluegen),
see gluegen a01cb3d59715a41153380f1977ec75263b762dc6
- NativeLibLoader -> <TYPE>JNILibLoader
- Fixed Exception Handling (as in gluegen bce53b52c8638729750c4286dbc04cb14329fd34),
ie removed empty catch Throwable ..
- GLContext.setSwapInterval(): Nop in offscreen case, otherwise X11IOError (NVIDIA Bug)
Test:
Tests
- Junit
- demos.gears.Gears
- demos.jrefract.JRefract
Platforms
- Linux 64/32 ATI/NVidia
- MacOsX
- Windows (virtualbox 3.1.6, offscreen failed)
TODO/BUGS:
- FIXME ATI GLn n>2 with AWT, can't make context current, works well on NVIDIA though
- FIXME GL3GL4: Due to GL3 and GL4 implementation bugs, we still choose GL2 first, if available!
- Add GL 3.3 to GL3/gl3ext.h
- Add GL 4.0 to GL3/gl3ext.h and fix the GL3/GL4 seperation
- Rename jogl.gl2.jar -> jogl.gldesktop.jar (as done with it's native lib already)
---
make/config/jogl/gl-impl-CustomJavaCode-gl4bc.java | 385 +++++++++++++++++++++
1 file changed, 385 insertions(+)
create mode 100644 make/config/jogl/gl-impl-CustomJavaCode-gl4bc.java
(limited to 'make/config/jogl/gl-impl-CustomJavaCode-gl4bc.java')
diff --git a/make/config/jogl/gl-impl-CustomJavaCode-gl4bc.java b/make/config/jogl/gl-impl-CustomJavaCode-gl4bc.java
new file mode 100644
index 000000000..bceb12fe5
--- /dev/null
+++ b/make/config/jogl/gl-impl-CustomJavaCode-gl4bc.java
@@ -0,0 +1,385 @@
+// Tracks glBegin/glEnd calls to determine whether it is legal to
+// query Vertex Buffer Object state
+private boolean inBeginEndPair;
+
+/* FIXME: refactor dependence on Java 2D / JOGL bridge
+
+// Tracks creation and destruction of server-side OpenGL objects when
+// the Java2D/OpenGL pipeline is enabled and it is using frame buffer
+// objects (FBOs) to do its rendering
+private GLObjectTracker tracker;
+
+public void setObjectTracker(GLObjectTracker tracker) {
+ this.tracker = tracker;
+}
+
+*/
+
+
+public GL4bcImpl(GLProfile glp, GLContextImpl context) {
+ this._context = context;
+ this.bufferSizeTracker = context.getBufferSizeTracker();
+ this.bufferStateTracker = context.getBufferStateTracker();
+ this.glStateTracker = context.getGLStateTracker();
+ this.glProfile = glp;
+}
+
+/**
+ * Provides platform-independent access to the wglAllocateMemoryNV /
+ * glXAllocateMemoryNV extension.
+ */
+public java.nio.ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3) {
+ return _context.glAllocateMemoryNV(arg0, arg1, arg2, arg3);
+}
+
+//
+// Helpers for ensuring the correct amount of texture data
+//
+
+/** Returns the number of bytes required to fill in the appropriate
+ texture. This is computed as closely as possible based on the
+ pixel pack or unpack parameters. The logic in this routine is
+ based on code in the SGI OpenGL sample implementation. */
+
+private int imageSizeInBytes(int format, int type, int w, int h, int d,
+ boolean pack) {
+ int elements = 0;
+ int esize = 0;
+
+ if (w < 0) return 0;
+ if (h < 0) return 0;
+ if (d < 0) return 0;
+ switch (format) {
+ case GL_COLOR_INDEX:
+ case GL_STENCIL_INDEX:
+ elements = 1;
+ break;
+ case GL_RED:
+ case GL_GREEN:
+ case GL_BLUE:
+ case GL_ALPHA:
+ case GL_LUMINANCE:
+ case GL_DEPTH_COMPONENT:
+ elements = 1;
+ break;
+ case GL_LUMINANCE_ALPHA:
+ elements = 2;
+ break;
+ case GL_RGB:
+ case GL_BGR:
+ elements = 3;
+ break;
+ case GL_RGBA:
+ case GL_BGRA:
+ case GL_ABGR_EXT:
+ elements = 4;
+ break;
+ /* FIXME ??
+ case GL_HILO_NV:
+ elements = 2;
+ break; */
+ default:
+ return 0;
+ }
+ switch (type) {
+ case GL_BITMAP:
+ if (format == GL_COLOR_INDEX) {
+ return (d * (h * ((w+7)/8)));
+ } else {
+ return 0;
+ }
+ case GL_BYTE:
+ case GL_UNSIGNED_BYTE:
+ esize = 1;
+ break;
+ case GL_UNSIGNED_BYTE_3_3_2:
+ case GL_UNSIGNED_BYTE_2_3_3_REV:
+ esize = 1;
+ elements = 1;
+ break;
+ case GL_SHORT:
+ case GL_UNSIGNED_SHORT:
+ esize = 2;
+ break;
+ case GL_UNSIGNED_SHORT_5_6_5:
+ case GL_UNSIGNED_SHORT_5_6_5_REV:
+ case GL_UNSIGNED_SHORT_4_4_4_4:
+ case GL_UNSIGNED_SHORT_4_4_4_4_REV:
+ case GL_UNSIGNED_SHORT_5_5_5_1:
+ case GL_UNSIGNED_SHORT_1_5_5_5_REV:
+ esize = 2;
+ elements = 1;
+ break;
+ case GL_INT:
+ case GL_UNSIGNED_INT:
+ case GL_FLOAT:
+ esize = 4;
+ break;
+ case GL_UNSIGNED_INT_8_8_8_8:
+ case GL_UNSIGNED_INT_8_8_8_8_REV:
+ case GL_UNSIGNED_INT_10_10_10_2:
+ case GL_UNSIGNED_INT_2_10_10_10_REV:
+ esize = 4;
+ elements = 1;
+ break;
+ default:
+ return 0;
+ }
+ return imageSizeInBytes(elements * esize, w, h, d, pack);
+}
+
+private GLBufferSizeTracker bufferSizeTracker;
+private GLBufferStateTracker bufferStateTracker;
+private GLStateTracker glStateTracker;
+
+private boolean bufferObjectExtensionsInitialized = false;
+private boolean haveARBPixelBufferObject;
+private boolean haveEXTPixelBufferObject;
+private boolean haveGL15;
+private boolean haveGL21;
+private boolean haveARBVertexBufferObject;
+
+private void initBufferObjectExtensionChecks() {
+ if (bufferObjectExtensionsInitialized)
+ return;
+ bufferObjectExtensionsInitialized = true;
+ haveARBPixelBufferObject = isExtensionAvailable("GL_ARB_pixel_buffer_object");
+ haveEXTPixelBufferObject = isExtensionAvailable("GL_EXT_pixel_buffer_object");
+ haveGL15 = isExtensionAvailable("GL_VERSION_1_5");
+ haveGL21 = isExtensionAvailable("GL_VERSION_2_1");
+ haveARBVertexBufferObject = isExtensionAvailable("GL_ARB_vertex_buffer_object");
+}
+
+private boolean checkBufferObject(boolean extension1,
+ boolean extension2,
+ boolean extension3,
+ boolean enabled,
+ int state,
+ String kind, boolean throwException) {
+ if (inBeginEndPair) {
+ throw new GLException("May not call this between glBegin and glEnd");
+ }
+ boolean avail = (extension1 || extension2 || extension3);
+ if (!avail) {
+ if (!enabled)
+ return true;
+ if(throwException) {
+ throw new GLException("Required extensions not available to call this function");
+ }
+ return false;
+ }
+ int buffer = bufferStateTracker.getBoundBufferObject(state, this);
+ if (enabled) {
+ if (buffer == 0) {
+ if(throwException) {
+ throw new GLException(kind + " must be enabled to call this method");
+ }
+ return false;
+ }
+ } else {
+ if (buffer != 0) {
+ if(throwException) {
+ throw new GLException(kind + " must be disabled to call this method");
+ }
+ return false;
+ }
+ }
+ return true;
+}
+
+private boolean checkArrayVBODisabled(boolean throwException) {
+ initBufferObjectExtensionChecks();
+ return checkBufferObject(haveGL15,
+ haveARBVertexBufferObject,
+ false,
+ false,
+ GL.GL_ARRAY_BUFFER,
+ "array vertex_buffer_object", throwException);
+}
+
+private boolean checkArrayVBOEnabled(boolean throwException) {
+ initBufferObjectExtensionChecks();
+ return checkBufferObject(haveGL15,
+ haveARBVertexBufferObject,
+ false,
+ true,
+ GL.GL_ARRAY_BUFFER,
+ "array vertex_buffer_object", throwException);
+}
+
+private boolean checkElementVBODisabled(boolean throwException) {
+ initBufferObjectExtensionChecks();
+ return checkBufferObject(haveGL15,
+ haveARBVertexBufferObject,
+ false,
+ false,
+ GL.GL_ELEMENT_ARRAY_BUFFER,
+ "element vertex_buffer_object", throwException);
+}
+
+private boolean checkElementVBOEnabled(boolean throwException) {
+ initBufferObjectExtensionChecks();
+ return checkBufferObject(haveGL15,
+ haveARBVertexBufferObject,
+ false,
+ true,
+ GL.GL_ELEMENT_ARRAY_BUFFER,
+ "element vertex_buffer_object", throwException);
+}
+
+private boolean checkUnpackPBODisabled(boolean throwException) {
+ initBufferObjectExtensionChecks();
+ return checkBufferObject(haveARBPixelBufferObject,
+ haveEXTPixelBufferObject,
+ haveGL21,
+ false,
+ GL2.GL_PIXEL_UNPACK_BUFFER,
+ "unpack pixel_buffer_object", throwException);
+}
+
+private boolean checkUnpackPBOEnabled(boolean throwException) {
+ initBufferObjectExtensionChecks();
+ return checkBufferObject(haveARBPixelBufferObject,
+ haveEXTPixelBufferObject,
+ haveGL21,
+ true,
+ GL2.GL_PIXEL_UNPACK_BUFFER,
+ "unpack pixel_buffer_object", throwException);
+}
+
+private boolean checkPackPBODisabled(boolean throwException) {
+ initBufferObjectExtensionChecks();
+ return checkBufferObject(haveARBPixelBufferObject,
+ haveEXTPixelBufferObject,
+ haveGL21,
+ false,
+ GL2.GL_PIXEL_PACK_BUFFER,
+ "pack pixel_buffer_object", throwException);
+}
+
+private boolean checkPackPBOEnabled(boolean throwException) {
+ initBufferObjectExtensionChecks();
+ return checkBufferObject(haveARBPixelBufferObject,
+ haveEXTPixelBufferObject,
+ haveGL21,
+ true,
+ GL2.GL_PIXEL_PACK_BUFFER,
+ "pack pixel_buffer_object", throwException);
+}
+
+public boolean glIsPBOPackEnabled() {
+ return checkPackPBOEnabled(false);
+}
+
+public boolean glIsPBOUnpackEnabled() {
+ return checkUnpackPBOEnabled(false);
+}
+
+// Attempt to return the same ByteBuffer object from glMapBuffer if
+// the vertex buffer object's base address and size haven't changed
+private static class ARBVBOKey {
+ private long addr;
+ private int capacity;
+
+ ARBVBOKey(long addr, int capacity) {
+ this.addr = addr;
+ this.capacity = capacity;
+ }
+
+ public int hashCode() {
+ return (int) addr;
+ }
+
+ public boolean equals(Object o) {
+ if ((o == null) || (!(o instanceof ARBVBOKey))) {
+ return false;
+ }
+
+ ARBVBOKey other = (ARBVBOKey) o;
+ return ((addr == other.addr) && (capacity == other.capacity));
+ }
+}
+
+private Map/*<ARBVBOKey, ByteBuffer>*/ arbVBOCache = new HashMap();
+
+/** Entry point to C language function: <br> <code> LPVOID glMapBuffer(GLenum target, GLenum access); </code> */
+public java.nio.ByteBuffer glMapBuffer(int target, int access) {
+ final long __addr_ = ((GL4bcProcAddressTable)_context.getGLProcAddressTable())._addressof_glMapBuffer;
+ if (__addr_ == 0) {
+ throw new GLException("Method \"glMapBuffer\" not available");
+ }
+ int sz = bufferSizeTracker.getBufferSize(bufferStateTracker,
+ target,
+ this);
+ long addr;
+ addr = dispatch_glMapBuffer(target, access, __addr_);
+ if (addr == 0 || sz == 0) {
+ return null;
+ }
+ ARBVBOKey key = new ARBVBOKey(addr, sz);
+ ByteBuffer _res = (ByteBuffer) arbVBOCache.get(key);
+ if (_res == null) {
+ _res = newDirectByteBuffer(addr, sz);
+ InternalBufferUtil.nativeOrder(_res);
+ arbVBOCache.put(key, _res);
+ }
+ _res.position(0);
+ return _res;
+}
+
+/** Encapsulates function pointer for OpenGL function <br>: <code> LPVOID glMapBuffer(GLenum target, GLenum access); </code> */
+native private long dispatch_glMapBuffer(int target, int access, long glProcAddress);
+
+native private ByteBuffer newDirectByteBuffer(long addr, int capacity);
+
+ /** Dummy implementation for the ES 2.0 function: <br> <code> void {@native glShaderBinary}(GLint n, const GLuint * shaders, GLenum binaryformat, const void * binary, GLint length); </code> <br> Always throws a GLException! */
+ public void glShaderBinary(int n, java.nio.IntBuffer shaders, int binaryformat, java.nio.Buffer binary, int length) {
+ throw new GLException("Method \"glShaderBinary\" not available");
+ }
+
+ /** Dummy implementation for the ES 2.0 function: <br> <code> void {@native glShaderBinary}(GLint n, const GLuint * shaders, GLenum binaryformat, const void * binary, GLint length); </code> <br> Always throws a GLException! */
+ public void glShaderBinary(int n, int[] shaders, int shaders_offset, int binaryformat, java.nio.Buffer binary, int length) {
+ throw new GLException("Method \"glShaderBinary\" not available");
+ }
+
+ public void glReleaseShaderCompiler() {
+ // nothing to do
+ }
+
+ public void glVertexPointer(GLArrayData array) {
+ if(array.getComponentNumber()==0) return;
+ if(array.isVBO()) {
+ glVertexPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getOffset());
+ } else {
+ glVertexPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getBuffer());
+ }
+ }
+ public void glColorPointer(GLArrayData array) {
+ if(array.getComponentNumber()==0) return;
+ if(array.isVBO()) {
+ glColorPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getOffset());
+ } else {
+ glColorPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getBuffer());
+ }
+
+ }
+ public void glNormalPointer(GLArrayData array) {
+ if(array.getComponentNumber()==0) return;
+ if(array.getComponentNumber()!=3) {
+ throw new GLException("Only 3 components per normal allowed");
+ }
+ if(array.isVBO()) {
+ glNormalPointer(array.getComponentType(), array.getStride(), array.getOffset());
+ } else {
+ glNormalPointer(array.getComponentType(), array.getStride(), array.getBuffer());
+ }
+ }
+ public void glTexCoordPointer(GLArrayData array) {
+ if(array.getComponentNumber()==0) return;
+ if(array.isVBO()) {
+ glTexCoordPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getOffset());
+ } else {
+ glTexCoordPointer(array.getComponentNumber(), array.getComponentType(), array.getStride(), array.getBuffer());
+ }
+ }
+
--
cgit v1.2.3