diff options
66 files changed, 3571 insertions, 408 deletions
diff --git a/doc/HowToBuild.html b/doc/HowToBuild.html index 730307c4d..6316d1d7b 100644 --- a/doc/HowToBuild.html +++ b/doc/HowToBuild.html @@ -15,7 +15,7 @@ OpenGL binding from a fresh copy of the source distribution: <LI> <B>Install Ant:</B> <br> Download and unpack Ant 1.6.1 or later from <a href="http://ant.apache.org/">http://ant.apache.org</a> and add the <code>bin/</code> subdirectory to your PATH environment variable. (Later versions of Ant should work; 1.6.2 has been tested successfully.) <LI> <B>Install ANTLR:</B> <br> Download and unpack ANTLR 2.7.2 from <a href="http://www.antlr.org">http://www.antlr.org</a>. (Later versions of ANTLR should work; ANTLR 2.7.3 has been tested successfully.) - <LI> <B>Unset your CLASSPATH environment variable:</B> <br> The Ant build requires that the Jogl jars not be visible on the classpath. On Unix, type <code> unsetenv CLASSPATH </code> into a csh or tcsh shell, or <code> set CLASSPATH=; export CLASSPATH </code> into a Bourne shell. On Windows, type <code> set CLASSPATH= </code> into a command prompt. + <LI> <B>Unset your CLASSPATH environment variable:</B> <br> The Ant build requires that the Jogl jars not be visible on the classpath. On Unix, type <code> unsetenv CLASSPATH </code> into a csh or tcsh shell, or <code> unset CLASSPATH </code> into a Bourne shell. On Windows, type <code> set CLASSPATH= </code> into a command prompt. <LI> <B>Copy and edit jogl.properties:</B> <br> <UL> diff --git a/make/build.xml b/make/build.xml index 19e192018..7ce104390 100644 --- a/make/build.xml +++ b/make/build.xml @@ -198,8 +198,10 @@ <property name="java.includes.dir.linux" value="${java.includes.dir}/linux" /> <property name="java.includes.dir.solaris" value="${java.includes.dir}/solaris" /> <property name="java.includes.dir.macosx" value="/System/Library/Frameworks/JavaVM.framework/Versions/CurrentJDK/Headers" /> + <property name="java.includes.dir.freebsd" value="${java.includes.dir}/freebsd" /> <property name="java.lib.dir.win32" value="${java.home.dir}/lib" /> <property name="java.lib.dir.linux" value="${java.home.dir}/jre/lib/i386" /> + <property name="java.lib.dir.linux.amd64" value="${java.home.dir}/jre/lib/amd64" /> <condition property="cpu" value="sparc"> <os name="SunOS" arch="sparc" /> </condition> @@ -303,7 +305,6 @@ <property name="javadoc.dev.packagenames.platform" value="${javadoc.dev.packagenames.x11}" /> </target> - <target name="declare.linux" depends="declare.x11"> <property name="java.includes.dir.platform" value="${java.includes.dir.linux}" /> <property name="java.lib.dir.platform" value="${java.lib.dir.linux}" /> @@ -312,7 +313,22 @@ <property name="linker.cfg.id" value="linker.cfg.linux" /> </target> + <target name="declare.linux.amd64" depends="declare.x11"> + <property name="java.includes.dir.platform" value="${java.includes.dir.linux}" /> + <property name="java.lib.dir.platform" value="${java.lib.dir.linux.amd64}" /> + + <property name="compiler.cfg.id" value="compiler.cfg.linux.amd64" /> + <property name="linker.cfg.id" value="linker.cfg.linux.amd64" /> + </target> + <target name="declare.freebsd" depends="declare.x11"> + <property name="java.includes.dir.platform" value="${java.includes.dir.freebsd}" /> + <property name="java.lib.dir.platform" value="${java.lib.dir.linux}" /> + + <property name="compiler.cfg.id" value="compiler.cfg.freebsd" /> + <property name="linker.cfg.id" value="linker.cfg.linux" /> + </target> + <target name="declare.solaris" depends="declare.x11"> <property name="java.includes.dir.platform" value="${java.includes.dir.solaris}" /> <property name="java.lib.dir.platform" value="${java.lib.dir.solaris}" /> @@ -653,6 +669,10 @@ <!-- compiler configuration --> <compiler id="compiler.cfg.linux" name="gcc" /> + <compiler id="compiler.cfg.linux.amd64" name="gcc"> + <compilerarg value="-fPIC"/> + </compiler> + <compiler id="compiler.cfg.solaris" name="suncc"> </compiler> @@ -699,6 +719,10 @@ </defineset> </compiler> + <compiler id="compiler.cfg.freebsd" name="gcc"> + <includepath path="/usr/X11R6/include" /> + </compiler> + <!-- linker configuration --> <linker id="linker.cfg.linux" name="gcc"> @@ -706,6 +730,11 @@ <syslibset dir="${x11.cg.lib}" libs="Cg, CgGL" if="c.compiler.use-cglib"/> </linker> + <linker id="linker.cfg.linux.amd64" name="gcc"> + <syslibset dir="/usr/X11R6/lib64" libs="GL, GLU, X11"/> + <syslibset dir="${x11.cg.lib}" libs="Cg, CgGL" if="c.compiler.use-cglib"/> + </linker> + <linker id="linker.cfg.solaris" name="suncc"> <syslibset libs="GL, GLU, X11"/> </linker> @@ -845,12 +874,18 @@ <target name="c.compile.jogl.linux" depends="declare.linux, c.build.jogl, c.build.cg" > </target> + <target name="c.compile.jogl.linux.amd64" depends="declare.linux.amd64, c.build.jogl, c.build.cg" > + </target> + <target name="c.compile.jogl.solaris" depends="declare.solaris, c.build.jogl"> </target> <target name="c.compile.jogl.macosx" depends="declare.macosx, c.build.jogl, c.build.cg"> </target> + <target name="c.compile.jogl.freebsd" depends="declare.freebsd, c.build.jogl, c.build.cg" > + </target> + <!-- ================================================================== --> <!-- - Build the jogl.jar file. @@ -1001,7 +1036,7 @@ <target name="all"> <fail> -Use a platform specific target: linux, macosx, solaris, win32.vc6, win32.vc7, win32.mingw +Use a platform specific target: linux, linux.amd64, macosx, solaris, win32.vc6, win32.vc7, win32.mingw </fail> </target> @@ -1050,7 +1085,18 @@ Use a platform specific target: linux, macosx, solaris, win32.vc6, win32.vc7, w </target> <!-- - - Solaris (assuming Solaris CC) + - Linux on AMD64 (assuming GCC) + --> + <target name="linux.amd64" depends="setup.java.home.dir.nonmacosx, declare.linux.amd64"> + <!-- Generate, compile, and build the jar for the Java sources. --> + <antcall target="jar" inheritRefs="true" /> + + <!-- Compile the native C sources and build the jogl lib. --> + <antcall target="c.compile.jogl.linux.amd64" /> + </target> + + <!-- + - Solaris (assuming Solaris CC) --> <target name="solaris" depends="setup.java.home.dir, declare.solaris"> <!-- Generate, compile, and build the jar for the Java sources. --> @@ -1070,4 +1116,15 @@ Use a platform specific target: linux, macosx, solaris, win32.vc6, win32.vc7, w <!-- Compile the native C sources and build the jogl lib. --> <antcall target="c.compile.jogl.macosx" /> </target> + + <!-- + - FreeBSD (assuming GCC) + --> + <target name="freebsd" depends="declare.freebsd"> + <!-- Generate, compile, and build the jar for the Java sources. --> + <antcall target="jar" inheritRefs="true" /> + + <!-- Compile the native C sources and build the jogl lib. --> + <antcall target="c.compile.jogl.freebsd" /> + </target> </project> diff --git a/make/cg-common.cfg b/make/cg-common.cfg index 043822838..275d9941d 100644 --- a/make/cg-common.cfg +++ b/make/cg-common.cfg @@ -8,6 +8,11 @@ JavaOutputDir ../build/gensrc/classes NativeOutputDir ../build/gensrc/native/jogl_cg HierarchicalNativeOutput false +# Generate "flattened" NIO variants for routines taking C primitive +# pointers that aren't of type void* +NioMode ALL_POINTERS +FlattenNIOVariants true + # # Map const char* return values to Java strings for these functions # @@ -55,6 +60,8 @@ Ignore cgGetParameterValues # Need to import New IO for Buffer classes # Import java.nio.* +# and java.security.* to allow unsigned Cg applications +Import java.security.* # Raise CgException instead of RuntimeException in glue code RuntimeExceptionType CgException @@ -67,4 +74,21 @@ RuntimeExceptionType CgException CustomCCode #include <stdlib.h> CustomCCode #include <Cg/cgGL.h> -CustomJavaCode CgGL static { System.loadLibrary("jogl_cg");} +CustomJavaCode CgGL static { +CustomJavaCode CgGL AccessController.doPrivileged(new PrivilegedAction() { +CustomJavaCode CgGL public Object run() { +CustomJavaCode CgGL try { +CustomJavaCode CgGL // Workaround so that these don't need to be in the system +CustomJavaCode CgGL // path but can be referenced from java.library.path +CustomJavaCode CgGL // (this is intended to help with Webstarted applications) +CustomJavaCode CgGL System.loadLibrary("cg"); +CustomJavaCode CgGL System.loadLibrary("cgGL"); +CustomJavaCode CgGL } catch (UnsatisfiedLinkError e) { +CustomJavaCode CgGL // Consider this non-fatal +CustomJavaCode CgGL } +CustomJavaCode CgGL // Load the actual Cg binding +CustomJavaCode CgGL System.loadLibrary("jogl_cg"); +CustomJavaCode CgGL return null; +CustomJavaCode CgGL } +CustomJavaCode CgGL }); +CustomJavaCode CgGL } diff --git a/make/cgl-macosx.cfg b/make/cgl-macosx.cfg index b3eab2184..c7a7f3841 100644 --- a/make/cgl-macosx.cfg +++ b/make/cgl-macosx.cfg @@ -13,7 +13,10 @@ Opaque long void * # this was the easiest way of sharing the prototypes between these files CustomCCode typedef int Bool; +CustomCCode #include </usr/include/machine/types.h> + CustomCCode extern void* createContext(void* shareContext, void* nsView, +CustomCCode int doubleBuffer, CustomCCode int redBits, CustomCCode int greenBits, CustomCCode int blueBits, @@ -45,3 +48,4 @@ CustomCCode extern void* getProcAddress(const char *procName); # Implement the first argument to getProcAddress as String instead # of byte[] ArgumentIsString getProcAddress 0 + diff --git a/make/gl-common-x11.cfg b/make/gl-common-x11.cfg index 15154e363..dcaeac4f2 100644 --- a/make/gl-common-x11.cfg +++ b/make/gl-common-x11.cfg @@ -5,6 +5,9 @@ Include gl-common.cfg JavaOutputDir ../build/gensrc/classes NativeOutputDir ../build/gensrc/native/jogl +# XID needs to be treated as a long for 32/64 bit compatibility +Opaque long XID + # Get returned array's capacity from XGetVisualInfo to be correct TemporaryCVariableDeclaration XGetVisualInfo int count; TemporaryCVariableAssignment XGetVisualInfo count = _ptr3[0]; diff --git a/make/gl-glx-common.cfg b/make/gl-glx-common.cfg index 93e5f794c..a613149bc 100644 --- a/make/gl-glx-common.cfg +++ b/make/gl-glx-common.cfg @@ -79,3 +79,7 @@ Ignore GLXHyperpipeNetworkSGIX Ignore GLXHyperpipeConfigSGIX Ignore GLXPipeRect Ignore GLXPipeRectLimits + +# XID shows up in the public API (and shouldn't -- will be removed in +# the JSR 231/239 APIs) and needs to be treated as a long for now +Opaque long XID diff --git a/make/gl-impl-macosx.cfg b/make/gl-impl-macosx.cfg index 9edf96731..8ce128851 100644 --- a/make/gl-impl-macosx.cfg +++ b/make/gl-impl-macosx.cfg @@ -22,6 +22,8 @@ CustomCCode #define GL_GLEXT_PROTOTYPES CustomCCode /* Include the OpenGL headers */ CustomCCode #include <GL/gl.h> +CustomCCode #include </usr/include/machine/types.h> + CustomCCode /* Provide Windows typedefs */ CustomCCode typedef void* LPVOID; CustomCCode typedef unsigned int* PUINT; diff --git a/make/glu-common.cfg b/make/glu-common.cfg index 65919e410..917a95a62 100644 --- a/make/glu-common.cfg +++ b/make/glu-common.cfg @@ -176,3 +176,31 @@ ManuallyImplement gluOrtho2D ManuallyImplement gluPerspective ManuallyImplement gluLookAt ManuallyImplement gluPickMatrix + +# +# ------------------------ +# Mipmaps +# ------------------------ +# +# Ignore the mipmap routines and use GKW's Java port instead. +# Currently the Java and native code have fallback paths to the +# C code, but this will be removed in a future release. + +Ignore gluBuild1DMipmapLevels +Ignore gluBuild1DMipmaps +Ignore gluBuild2DMipmapLevels +Ignore gluBuild2DMipmaps +Ignore gluBuild3DMipmapLevels +Ignore gluBuild3DMipmaps +Ignore gluScaleImage + +# Must force proc address generation for these routines, though, since +# we still fall back on the C implementations + +ForceProcAddressGen gluBuild1DMipmapLevels +ForceProcAddressGen gluBuild1DMipmaps +ForceProcAddressGen gluBuild2DMipmapLevels +ForceProcAddressGen gluBuild2DMipmaps +ForceProcAddressGen gluBuild3DMipmapLevels +ForceProcAddressGen gluBuild3DMipmaps +ForceProcAddressGen gluScaleImage diff --git a/make/glu-impl-common-CustomCCode.c b/make/glu-impl-common-CustomCCode.c index 9a6a8d2ab..5a3f645c5 100644 --- a/make/glu-impl-common-CustomCCode.c +++ b/make/glu-impl-common-CustomCCode.c @@ -1,2 +1,833 @@ /* Include the OpenGL GLU header */ #include <GL/glu.h> + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, byte[] data) + * C function: GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild1DMipmapLevels__IIIIIIII_3BJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint format, jint type, jint level, jint base, jint max, jbyteArray data, jlong glProcAddress) { + PFNGLUBUILD1DMIPMAPLEVELSPROC ptr_gluBuild1DMipmapLevels; + void * _ptr8 = NULL; + GLint _res; + ptr_gluBuild1DMipmapLevels = (PFNGLUBUILD1DMIPMAPLEVELSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild1DMipmapLevels != NULL); + if (data != NULL) { + _ptr8 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild1DMipmapLevels) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, (void *) _ptr8); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr8, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, short[] data) + * C function: GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild1DMipmapLevels__IIIIIIII_3SJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint format, jint type, jint level, jint base, jint max, jshortArray data, jlong glProcAddress) { + PFNGLUBUILD1DMIPMAPLEVELSPROC ptr_gluBuild1DMipmapLevels; + void * _ptr8 = NULL; + GLint _res; + ptr_gluBuild1DMipmapLevels = (PFNGLUBUILD1DMIPMAPLEVELSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild1DMipmapLevels != NULL); + if (data != NULL) { + _ptr8 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild1DMipmapLevels) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, (void *) _ptr8); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr8, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, int[] data) + * C function: GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild1DMipmapLevels__IIIIIIII_3IJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint format, jint type, jint level, jint base, jint max, jintArray data, jlong glProcAddress) { + PFNGLUBUILD1DMIPMAPLEVELSPROC ptr_gluBuild1DMipmapLevels; + void * _ptr8 = NULL; + GLint _res; + ptr_gluBuild1DMipmapLevels = (PFNGLUBUILD1DMIPMAPLEVELSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild1DMipmapLevels != NULL); + if (data != NULL) { + _ptr8 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild1DMipmapLevels) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, (void *) _ptr8); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr8, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, float[] data) + * C function: GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild1DMipmapLevels__IIIIIIII_3FJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint format, jint type, jint level, jint base, jint max, jfloatArray data, jlong glProcAddress) { + PFNGLUBUILD1DMIPMAPLEVELSPROC ptr_gluBuild1DMipmapLevels; + void * _ptr8 = NULL; + GLint _res; + ptr_gluBuild1DMipmapLevels = (PFNGLUBUILD1DMIPMAPLEVELSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild1DMipmapLevels != NULL); + if (data != NULL) { + _ptr8 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild1DMipmapLevels) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, (void *) _ptr8); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr8, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, java.nio.ByteBuffer data) + * C function: GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild1DMipmapLevels__IIIIIIIILjava_nio_Buffer_2J(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint format, jint type, jint level, jint base, jint max, jobject data, jlong glProcAddress) { + PFNGLUBUILD1DMIPMAPLEVELSPROC ptr_gluBuild1DMipmapLevels; + void * _ptr8 = NULL; + GLint _res; + if (data != NULL) { + _ptr8 = (void *) (*env)->GetDirectBufferAddress(env, data); + } else { + _ptr8 = NULL; + } + ptr_gluBuild1DMipmapLevels = (PFNGLUBUILD1DMIPMAPLEVELSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild1DMipmapLevels != NULL); + _res = (* ptr_gluBuild1DMipmapLevels) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, (void *) _ptr8); + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, byte[] data) + * C function: GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild1DMipmaps__IIIII_3BJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint format, jint type, jbyteArray data, jlong glProcAddress) { + PFNGLUBUILD1DMIPMAPSPROC ptr_gluBuild1DMipmaps; + void * _ptr5 = NULL; + GLint _res; + ptr_gluBuild1DMipmaps = (PFNGLUBUILD1DMIPMAPSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild1DMipmaps != NULL); + if (data != NULL) { + _ptr5 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild1DMipmaps) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLenum) format, (GLenum) type, (void *) _ptr5); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr5, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, short[] data) + * C function: GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild1DMipmaps__IIIII_3SJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint format, jint type, jshortArray data, jlong glProcAddress) { + PFNGLUBUILD1DMIPMAPSPROC ptr_gluBuild1DMipmaps; + void * _ptr5 = NULL; + GLint _res; + ptr_gluBuild1DMipmaps = (PFNGLUBUILD1DMIPMAPSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild1DMipmaps != NULL); + if (data != NULL) { + _ptr5 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild1DMipmaps) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLenum) format, (GLenum) type, (void *) _ptr5); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr5, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, int[] data) + * C function: GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild1DMipmaps__IIIII_3IJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint format, jint type, jintArray data, jlong glProcAddress) { + PFNGLUBUILD1DMIPMAPSPROC ptr_gluBuild1DMipmaps; + void * _ptr5 = NULL; + GLint _res; + ptr_gluBuild1DMipmaps = (PFNGLUBUILD1DMIPMAPSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild1DMipmaps != NULL); + if (data != NULL) { + _ptr5 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild1DMipmaps) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLenum) format, (GLenum) type, (void *) _ptr5); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr5, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, float[] data) + * C function: GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild1DMipmaps__IIIII_3FJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint format, jint type, jfloatArray data, jlong glProcAddress) { + PFNGLUBUILD1DMIPMAPSPROC ptr_gluBuild1DMipmaps; + void * _ptr5 = NULL; + GLint _res; + ptr_gluBuild1DMipmaps = (PFNGLUBUILD1DMIPMAPSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild1DMipmaps != NULL); + if (data != NULL) { + _ptr5 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild1DMipmaps) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLenum) format, (GLenum) type, (void *) _ptr5); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr5, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, java.nio.ByteBuffer data) + * C function: GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild1DMipmaps__IIIIILjava_nio_Buffer_2J(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint format, jint type, jobject data, jlong glProcAddress) { + PFNGLUBUILD1DMIPMAPSPROC ptr_gluBuild1DMipmaps; + void * _ptr5 = NULL; + GLint _res; + if (data != NULL) { + _ptr5 = (void *) (*env)->GetDirectBufferAddress(env, data); + } else { + _ptr5 = NULL; + } + ptr_gluBuild1DMipmaps = (PFNGLUBUILD1DMIPMAPSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild1DMipmaps != NULL); + _res = (* ptr_gluBuild1DMipmaps) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLenum) format, (GLenum) type, (void *) _ptr5); + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, byte[] data) + * C function: GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild2DMipmapLevels__IIIIIIIII_3BJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint format, jint type, jint level, jint base, jint max, jbyteArray data, jlong glProcAddress) { + PFNGLUBUILD2DMIPMAPLEVELSPROC ptr_gluBuild2DMipmapLevels; + void * _ptr9 = NULL; + GLint _res; + ptr_gluBuild2DMipmapLevels = (PFNGLUBUILD2DMIPMAPLEVELSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild2DMipmapLevels != NULL); + if (data != NULL) { + _ptr9 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild2DMipmapLevels) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, (void *) _ptr9); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr9, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, short[] data) + * C function: GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild2DMipmapLevels__IIIIIIIII_3SJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint format, jint type, jint level, jint base, jint max, jshortArray data, jlong glProcAddress) { + PFNGLUBUILD2DMIPMAPLEVELSPROC ptr_gluBuild2DMipmapLevels; + void * _ptr9 = NULL; + GLint _res; + ptr_gluBuild2DMipmapLevels = (PFNGLUBUILD2DMIPMAPLEVELSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild2DMipmapLevels != NULL); + if (data != NULL) { + _ptr9 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild2DMipmapLevels) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, (void *) _ptr9); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr9, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, int[] data) + * C function: GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild2DMipmapLevels__IIIIIIIII_3IJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint format, jint type, jint level, jint base, jint max, jintArray data, jlong glProcAddress) { + PFNGLUBUILD2DMIPMAPLEVELSPROC ptr_gluBuild2DMipmapLevels; + void * _ptr9 = NULL; + GLint _res; + ptr_gluBuild2DMipmapLevels = (PFNGLUBUILD2DMIPMAPLEVELSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild2DMipmapLevels != NULL); + if (data != NULL) { + _ptr9 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild2DMipmapLevels) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, (void *) _ptr9); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr9, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, float[] data) + * C function: GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild2DMipmapLevels__IIIIIIIII_3FJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint format, jint type, jint level, jint base, jint max, jfloatArray data, jlong glProcAddress) { + PFNGLUBUILD2DMIPMAPLEVELSPROC ptr_gluBuild2DMipmapLevels; + void * _ptr9 = NULL; + GLint _res; + ptr_gluBuild2DMipmapLevels = (PFNGLUBUILD2DMIPMAPLEVELSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild2DMipmapLevels != NULL); + if (data != NULL) { + _ptr9 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild2DMipmapLevels) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, (void *) _ptr9); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr9, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, java.nio.ByteBuffer data) + * C function: GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild2DMipmapLevels__IIIIIIIIILjava_nio_Buffer_2J(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint format, jint type, jint level, jint base, jint max, jobject data, jlong glProcAddress) { + PFNGLUBUILD2DMIPMAPLEVELSPROC ptr_gluBuild2DMipmapLevels; + void * _ptr9 = NULL; + GLint _res; + if (data != NULL) { + _ptr9 = (void *) (*env)->GetDirectBufferAddress(env, data); + } else { + _ptr9 = NULL; + } + ptr_gluBuild2DMipmapLevels = (PFNGLUBUILD2DMIPMAPLEVELSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild2DMipmapLevels != NULL); + _res = (* ptr_gluBuild2DMipmapLevels) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, (void *) _ptr9); + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, byte[] data) + * C function: GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild2DMipmaps__IIIIII_3BJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint format, jint type, jbyteArray data, jlong glProcAddress) { + PFNGLUBUILD2DMIPMAPSPROC ptr_gluBuild2DMipmaps; + void * _ptr6 = NULL; + GLint _res; + ptr_gluBuild2DMipmaps = (PFNGLUBUILD2DMIPMAPSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild2DMipmaps != NULL); + if (data != NULL) { + _ptr6 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild2DMipmaps) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLenum) format, (GLenum) type, (void *) _ptr6); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr6, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, short[] data) + * C function: GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild2DMipmaps__IIIIII_3SJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint format, jint type, jshortArray data, jlong glProcAddress) { + PFNGLUBUILD2DMIPMAPSPROC ptr_gluBuild2DMipmaps; + void * _ptr6 = NULL; + GLint _res; + ptr_gluBuild2DMipmaps = (PFNGLUBUILD2DMIPMAPSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild2DMipmaps != NULL); + if (data != NULL) { + _ptr6 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild2DMipmaps) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLenum) format, (GLenum) type, (void *) _ptr6); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr6, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, int[] data) + * C function: GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild2DMipmaps__IIIIII_3IJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint format, jint type, jintArray data, jlong glProcAddress) { + PFNGLUBUILD2DMIPMAPSPROC ptr_gluBuild2DMipmaps; + void * _ptr6 = NULL; + GLint _res; + ptr_gluBuild2DMipmaps = (PFNGLUBUILD2DMIPMAPSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild2DMipmaps != NULL); + if (data != NULL) { + _ptr6 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild2DMipmaps) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLenum) format, (GLenum) type, (void *) _ptr6); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr6, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, float[] data) + * C function: GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild2DMipmaps__IIIIII_3FJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint format, jint type, jfloatArray data, jlong glProcAddress) { + PFNGLUBUILD2DMIPMAPSPROC ptr_gluBuild2DMipmaps; + void * _ptr6 = NULL; + GLint _res; + ptr_gluBuild2DMipmaps = (PFNGLUBUILD2DMIPMAPSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild2DMipmaps != NULL); + if (data != NULL) { + _ptr6 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild2DMipmaps) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLenum) format, (GLenum) type, (void *) _ptr6); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr6, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, java.nio.ByteBuffer data) + * C function: GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild2DMipmaps__IIIIIILjava_nio_Buffer_2J(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint format, jint type, jobject data, jlong glProcAddress) { + PFNGLUBUILD2DMIPMAPSPROC ptr_gluBuild2DMipmaps; + void * _ptr6 = NULL; + GLint _res; + if (data != NULL) { + _ptr6 = (void *) (*env)->GetDirectBufferAddress(env, data); + } else { + _ptr6 = NULL; + } + ptr_gluBuild2DMipmaps = (PFNGLUBUILD2DMIPMAPSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild2DMipmaps != NULL); + _res = (* ptr_gluBuild2DMipmaps) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLenum) format, (GLenum) type, (void *) _ptr6); + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, byte[] data) + * C function: GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild3DMipmapLevels__IIIIIIIIII_3BJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint depth, jint format, jint type, jint level, jint base, jint max, jbyteArray data, jlong glProcAddress) { + PFNGLUBUILD3DMIPMAPLEVELSPROC ptr_gluBuild3DMipmapLevels; + void * _ptr10 = NULL; + GLint _res; + ptr_gluBuild3DMipmapLevels = (PFNGLUBUILD3DMIPMAPLEVELSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild3DMipmapLevels != NULL); + if (data != NULL) { + _ptr10 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild3DMipmapLevels) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLsizei) depth, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, (void *) _ptr10); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr10, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, short[] data) + * C function: GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild3DMipmapLevels__IIIIIIIIII_3SJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint depth, jint format, jint type, jint level, jint base, jint max, jshortArray data, jlong glProcAddress) { + PFNGLUBUILD3DMIPMAPLEVELSPROC ptr_gluBuild3DMipmapLevels; + void * _ptr10 = NULL; + GLint _res; + ptr_gluBuild3DMipmapLevels = (PFNGLUBUILD3DMIPMAPLEVELSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild3DMipmapLevels != NULL); + if (data != NULL) { + _ptr10 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild3DMipmapLevels) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLsizei) depth, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, (void *) _ptr10); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr10, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, int[] data) + * C function: GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild3DMipmapLevels__IIIIIIIIII_3IJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint depth, jint format, jint type, jint level, jint base, jint max, jintArray data, jlong glProcAddress) { + PFNGLUBUILD3DMIPMAPLEVELSPROC ptr_gluBuild3DMipmapLevels; + void * _ptr10 = NULL; + GLint _res; + ptr_gluBuild3DMipmapLevels = (PFNGLUBUILD3DMIPMAPLEVELSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild3DMipmapLevels != NULL); + if (data != NULL) { + _ptr10 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild3DMipmapLevels) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLsizei) depth, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, (void *) _ptr10); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr10, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, float[] data) + * C function: GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild3DMipmapLevels__IIIIIIIIII_3FJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint depth, jint format, jint type, jint level, jint base, jint max, jfloatArray data, jlong glProcAddress) { + PFNGLUBUILD3DMIPMAPLEVELSPROC ptr_gluBuild3DMipmapLevels; + void * _ptr10 = NULL; + GLint _res; + ptr_gluBuild3DMipmapLevels = (PFNGLUBUILD3DMIPMAPLEVELSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild3DMipmapLevels != NULL); + if (data != NULL) { + _ptr10 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild3DMipmapLevels) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLsizei) depth, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, (void *) _ptr10); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr10, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, java.nio.ByteBuffer data) + * C function: GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild3DMipmapLevels__IIIIIIIIIILjava_nio_Buffer_2J(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint depth, jint format, jint type, jint level, jint base, jint max, jobject data, jlong glProcAddress) { + PFNGLUBUILD3DMIPMAPLEVELSPROC ptr_gluBuild3DMipmapLevels; + void * _ptr10 = NULL; + GLint _res; + if (data != NULL) { + _ptr10 = (void *) (*env)->GetDirectBufferAddress(env, data); + } else { + _ptr10 = NULL; + } + ptr_gluBuild3DMipmapLevels = (PFNGLUBUILD3DMIPMAPLEVELSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild3DMipmapLevels != NULL); + _res = (* ptr_gluBuild3DMipmapLevels) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLsizei) depth, (GLenum) format, (GLenum) type, (GLint) level, (GLint) base, (GLint) max, (void *) _ptr10); + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, byte[] data) + * C function: GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild3DMipmaps__IIIIIII_3BJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint depth, jint format, jint type, jbyteArray data, jlong glProcAddress) { + PFNGLUBUILD3DMIPMAPSPROC ptr_gluBuild3DMipmaps; + void * _ptr7 = NULL; + GLint _res; + ptr_gluBuild3DMipmaps = (PFNGLUBUILD3DMIPMAPSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild3DMipmaps != NULL); + if (data != NULL) { + _ptr7 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild3DMipmaps) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLsizei) depth, (GLenum) format, (GLenum) type, (void *) _ptr7); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr7, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, short[] data) + * C function: GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild3DMipmaps__IIIIIII_3SJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint depth, jint format, jint type, jshortArray data, jlong glProcAddress) { + PFNGLUBUILD3DMIPMAPSPROC ptr_gluBuild3DMipmaps; + void * _ptr7 = NULL; + GLint _res; + ptr_gluBuild3DMipmaps = (PFNGLUBUILD3DMIPMAPSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild3DMipmaps != NULL); + if (data != NULL) { + _ptr7 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild3DMipmaps) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLsizei) depth, (GLenum) format, (GLenum) type, (void *) _ptr7); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr7, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, int[] data) + * C function: GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild3DMipmaps__IIIIIII_3IJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint depth, jint format, jint type, jintArray data, jlong glProcAddress) { + PFNGLUBUILD3DMIPMAPSPROC ptr_gluBuild3DMipmaps; + void * _ptr7 = NULL; + GLint _res; + ptr_gluBuild3DMipmaps = (PFNGLUBUILD3DMIPMAPSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild3DMipmaps != NULL); + if (data != NULL) { + _ptr7 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild3DMipmaps) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLsizei) depth, (GLenum) format, (GLenum) type, (void *) _ptr7); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr7, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, float[] data) + * C function: GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild3DMipmaps__IIIIIII_3FJ(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint depth, jint format, jint type, jfloatArray data, jlong glProcAddress) { + PFNGLUBUILD3DMIPMAPSPROC ptr_gluBuild3DMipmaps; + void * _ptr7 = NULL; + GLint _res; + ptr_gluBuild3DMipmaps = (PFNGLUBUILD3DMIPMAPSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild3DMipmaps != NULL); + if (data != NULL) { + _ptr7 = (void *) (*env)->GetPrimitiveArrayCritical(env, data, NULL); + } + _res = (* ptr_gluBuild3DMipmaps) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLsizei) depth, (GLenum) format, (GLenum) type, (void *) _ptr7); + if (data != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, data, _ptr7, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, java.nio.ByteBuffer data) + * C function: GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluBuild3DMipmaps__IIIIIIILjava_nio_Buffer_2J(JNIEnv *env, jobject _unused, jint target, jint internalFormat, jint width, jint height, jint depth, jint format, jint type, jobject data, jlong glProcAddress) { + PFNGLUBUILD3DMIPMAPSPROC ptr_gluBuild3DMipmaps; + void * _ptr7 = NULL; + GLint _res; + if (data != NULL) { + _ptr7 = (void *) (*env)->GetDirectBufferAddress(env, data); + } else { + _ptr7 = NULL; + } + ptr_gluBuild3DMipmaps = (PFNGLUBUILD3DMIPMAPSPROC) (intptr_t) glProcAddress; + assert(ptr_gluBuild3DMipmaps != NULL); + _res = (* ptr_gluBuild3DMipmaps) ((GLenum) target, (GLint) internalFormat, (GLsizei) width, (GLsizei) height, (GLsizei) depth, (GLenum) format, (GLenum) type, (void *) _ptr7); + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluScaleImage(int format, int wIn, int hIn, int typeIn, byte[] dataIn, int wOut, int hOut, int typeOut, byte[] dataOut) + * C function: GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluScaleImage__IIII_3BIII_3BJ(JNIEnv *env, jobject _unused, jint format, jint wIn, jint hIn, jint typeIn, jbyteArray dataIn, jint wOut, jint hOut, jint typeOut, jbyteArray dataOut, jlong glProcAddress) { + PFNGLUSCALEIMAGEPROC ptr_gluScaleImage; + void * _ptr4 = NULL; + GLvoid * _ptr8 = NULL; + GLint _res; + ptr_gluScaleImage = (PFNGLUSCALEIMAGEPROC) (intptr_t) glProcAddress; + assert(ptr_gluScaleImage != NULL); + if (dataIn != NULL) { + _ptr4 = (void *) (*env)->GetPrimitiveArrayCritical(env, dataIn, NULL); + } + if (dataOut != NULL) { + _ptr8 = (GLvoid *) (*env)->GetPrimitiveArrayCritical(env, dataOut, NULL); + } + _res = (* ptr_gluScaleImage) ((GLenum) format, (GLsizei) wIn, (GLsizei) hIn, (GLenum) typeIn, (void *) _ptr4, (GLsizei) wOut, (GLsizei) hOut, (GLenum) typeOut, (GLvoid *) _ptr8); + if (dataIn != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, dataIn, _ptr4, JNI_ABORT); + } + if (dataOut != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, dataOut, _ptr8, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluScaleImage(int format, int wIn, int hIn, int typeIn, short[] dataIn, int wOut, int hOut, int typeOut, short[] dataOut) + * C function: GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluScaleImage__IIII_3SIII_3SJ(JNIEnv *env, jobject _unused, jint format, jint wIn, jint hIn, jint typeIn, jshortArray dataIn, jint wOut, jint hOut, jint typeOut, jshortArray dataOut, jlong glProcAddress) { + PFNGLUSCALEIMAGEPROC ptr_gluScaleImage; + void * _ptr4 = NULL; + GLvoid * _ptr8 = NULL; + GLint _res; + ptr_gluScaleImage = (PFNGLUSCALEIMAGEPROC) (intptr_t) glProcAddress; + assert(ptr_gluScaleImage != NULL); + if (dataIn != NULL) { + _ptr4 = (void *) (*env)->GetPrimitiveArrayCritical(env, dataIn, NULL); + } + if (dataOut != NULL) { + _ptr8 = (GLvoid *) (*env)->GetPrimitiveArrayCritical(env, dataOut, NULL); + } + _res = (* ptr_gluScaleImage) ((GLenum) format, (GLsizei) wIn, (GLsizei) hIn, (GLenum) typeIn, (void *) _ptr4, (GLsizei) wOut, (GLsizei) hOut, (GLenum) typeOut, (GLvoid *) _ptr8); + if (dataIn != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, dataIn, _ptr4, JNI_ABORT); + } + if (dataOut != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, dataOut, _ptr8, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluScaleImage(int format, int wIn, int hIn, int typeIn, int[] dataIn, int wOut, int hOut, int typeOut, int[] dataOut) + * C function: GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluScaleImage__IIII_3IIII_3IJ(JNIEnv *env, jobject _unused, jint format, jint wIn, jint hIn, jint typeIn, jintArray dataIn, jint wOut, jint hOut, jint typeOut, jintArray dataOut, jlong glProcAddress) { + PFNGLUSCALEIMAGEPROC ptr_gluScaleImage; + void * _ptr4 = NULL; + GLvoid * _ptr8 = NULL; + GLint _res; + ptr_gluScaleImage = (PFNGLUSCALEIMAGEPROC) (intptr_t) glProcAddress; + assert(ptr_gluScaleImage != NULL); + if (dataIn != NULL) { + _ptr4 = (void *) (*env)->GetPrimitiveArrayCritical(env, dataIn, NULL); + } + if (dataOut != NULL) { + _ptr8 = (GLvoid *) (*env)->GetPrimitiveArrayCritical(env, dataOut, NULL); + } + _res = (* ptr_gluScaleImage) ((GLenum) format, (GLsizei) wIn, (GLsizei) hIn, (GLenum) typeIn, (void *) _ptr4, (GLsizei) wOut, (GLsizei) hOut, (GLenum) typeOut, (GLvoid *) _ptr8); + if (dataIn != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, dataIn, _ptr4, JNI_ABORT); + } + if (dataOut != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, dataOut, _ptr8, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluScaleImage(int format, int wIn, int hIn, int typeIn, float[] dataIn, int wOut, int hOut, int typeOut, float[] dataOut) + * C function: GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluScaleImage__IIII_3FIII_3FJ(JNIEnv *env, jobject _unused, jint format, jint wIn, jint hIn, jint typeIn, jfloatArray dataIn, jint wOut, jint hOut, jint typeOut, jfloatArray dataOut, jlong glProcAddress) { + PFNGLUSCALEIMAGEPROC ptr_gluScaleImage; + void * _ptr4 = NULL; + GLvoid * _ptr8 = NULL; + GLint _res; + ptr_gluScaleImage = (PFNGLUSCALEIMAGEPROC) (intptr_t) glProcAddress; + assert(ptr_gluScaleImage != NULL); + if (dataIn != NULL) { + _ptr4 = (void *) (*env)->GetPrimitiveArrayCritical(env, dataIn, NULL); + } + if (dataOut != NULL) { + _ptr8 = (GLvoid *) (*env)->GetPrimitiveArrayCritical(env, dataOut, NULL); + } + _res = (* ptr_gluScaleImage) ((GLenum) format, (GLsizei) wIn, (GLsizei) hIn, (GLenum) typeIn, (void *) _ptr4, (GLsizei) wOut, (GLsizei) hOut, (GLenum) typeOut, (GLvoid *) _ptr8); + if (dataIn != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, dataIn, _ptr4, JNI_ABORT); + } + if (dataOut != NULL) { + (*env)->ReleasePrimitiveArrayCritical(env, dataOut, _ptr8, JNI_ABORT); + } + return _res; +} + + +/* Java->C glue code: + * Java package: net.java.games.jogl.impl.GLUImpl + * Java method: int dispatch_gluScaleImage(int format, int wIn, int hIn, int typeIn, java.nio.ByteBuffer dataIn, int wOut, int hOut, int typeOut, java.nio.ByteBuffer dataOut) + * C function: GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); + */ +JNIEXPORT jint JNICALL +Java_net_java_games_jogl_impl_GLUImpl_dispatch_1gluScaleImage__IIIILjava_nio_Buffer_2IIILjava_nio_Buffer_2J(JNIEnv *env, jobject _unused, jint format, jint wIn, jint hIn, jint typeIn, jobject dataIn, jint wOut, jint hOut, jint typeOut, jobject dataOut, jlong glProcAddress) { + PFNGLUSCALEIMAGEPROC ptr_gluScaleImage; + void * _ptr4 = NULL; + GLvoid * _ptr8 = NULL; + GLint _res; + if (dataIn != NULL) { + _ptr4 = (void *) (*env)->GetDirectBufferAddress(env, dataIn); + } else { + _ptr4 = NULL; + } + if (dataOut != NULL) { + _ptr8 = (GLvoid *) (*env)->GetDirectBufferAddress(env, dataOut); + } else { + _ptr8 = NULL; + } + ptr_gluScaleImage = (PFNGLUSCALEIMAGEPROC) (intptr_t) glProcAddress; + assert(ptr_gluScaleImage != NULL); + _res = (* ptr_gluScaleImage) ((GLenum) format, (GLsizei) wIn, (GLsizei) hIn, (GLenum) typeIn, (void *) _ptr4, (GLsizei) wOut, (GLsizei) hOut, (GLenum) typeOut, (GLvoid *) _ptr8); + return _res; +} diff --git a/make/glu-impl-common-CustomJavaCode.java b/make/glu-impl-common-CustomJavaCode.java index 854030351..0706aa390 100644 --- a/make/glu-impl-common-CustomJavaCode.java +++ b/make/glu-impl-common-CustomJavaCode.java @@ -1,3 +1,17 @@ +private static boolean useJavaMipmapCode = true; + +static { + AccessController.doPrivileged(new PrivilegedAction() { + public Object run() { + String val = System.getProperty("jogl.glu.nojava"); + if (val != null && !val.toLowerCase().equals("false")) { + useJavaMipmapCode = false; + } + return null; + } + }); +} + /** Indicates whether the given GLU routine is available to be called. */ public boolean isFunctionAvailable(String gluFunctionName) { @@ -205,3 +219,1208 @@ public boolean gluUnProject4(double winX, double winY, double winZ, double clipW public void gluPickMatrix(double x, double y, double delX, double delY, int[] viewport) { project.gluPickMatrix(gl, x, y, delX, delY, viewport); } + +//---------------------------------------------------------------------- +// Mipmap and image scaling functionality + + +// Boolean +public static final int GLU_FALSE = 0; +public static final int GLU_TRUE = 1; + +// String Name +public static final int GLU_VERSION = 100800; +public static final int GLU_EXTENSIONS = 100801; + +// Extensions +public static final String versionString = "1.3"; +public static final String extensionString = "GLU_EXT_nurbs_tessellator " + + "GLU_EXT_object_space_tess "; + +// ErrorCode +public static final int GLU_INVALID_ENUM = 100900; +public static final int GLU_INVALID_VALUE = 100901; +public static final int GLU_OUT_OF_MEMORY = 100902; +public static final int GLU_INVALID_OPERATION = 100904; + +// NurbsDisplay +// GLU_FILL +public static final int GLU_OUTLINE_POLYGON = 100240; +public static final int GLU_OUTLINE_PATCH = 100241; + +// NurbsCallback +public static final int GLU_NURBS_ERROR = 100103; +public static final int GLU_ERROR = 100103; +public static final int GLU_NURBS_BEGIN = 100164; +public static final int GLU_NURBS_BEGIN_EXT = 100164; +public static final int GLU_NURBS_VERTEX = 100165; +public static final int GLU_NURBS_VERTEX_EXT = 100165; +public static final int GLU_NURBS_NORMAL = 100166; +public static final int GLU_NURBS_NORMAL_EXT = 100166; +public static final int GLU_NURBS_COLOR = 100167; +public static final int GLU_NURBS_COLOR_EXT = 100167; +public static final int GLU_NURBS_TEXTURE_COORD = 100168; +public static final int GLU_NURBS_TEX_COORD_EXT = 100168; +public static final int GLU_NURBS_END = 100169; +public static final int GLU_NURBS_END_EXT = 100169; +public static final int GLU_NURBS_BEGIN_DATA = 100170; +public static final int GLU_NURBS_BEGIN_DATA_EXT = 100170; +public static final int GLU_NURBS_VERTEX_DATA = 100171; +public static final int GLU_NURBS_VERTEX_DATA_EXT = 100171; +public static final int GLU_NURBS_NORMAL_DATA = 100172; +public static final int GLU_NURBS_NORMAL_DATA_EXT = 100172; +public static final int GLU_NURBS_COLOR_DATA = 100173; +public static final int GLU_NURBS_COLOR_DATA_EXT = 100173; +public static final int GLU_NURBS_TEXTURE_COORD_DATA = 100174; +public static final int GLU_NURBS_TEX_COORD_DATA_EXT = 100174; +public static final int GLU_NURBS_END_DATA = 100175; +public static final int GLU_NURBS_END_DATA_EXT = 100175; + +// NurbsError +public static final int GLU_NURBS_ERROR1 = 100251; +public static final int GLU_NURBS_ERROR2 = 100252; +public static final int GLU_NURBS_ERROR3 = 100253; +public static final int GLU_NURBS_ERROR4 = 100254; +public static final int GLU_NURBS_ERROR5 = 100255; +public static final int GLU_NURBS_ERROR6 = 100256; +public static final int GLU_NURBS_ERROR7 = 100257; +public static final int GLU_NURBS_ERROR8 = 100258; +public static final int GLU_NURBS_ERROR9 = 100259; +public static final int GLU_NURBS_ERROR10 = 100260; +public static final int GLU_NURBS_ERROR11 = 100261; +public static final int GLU_NURBS_ERROR12 = 100262; +public static final int GLU_NURBS_ERROR13 = 100263; +public static final int GLU_NURBS_ERROR14 = 100264; +public static final int GLU_NURBS_ERROR15 = 100265; +public static final int GLU_NURBS_ERROR16 = 100266; +public static final int GLU_NURBS_ERROR17 = 100267; +public static final int GLU_NURBS_ERROR18 = 100268; +public static final int GLU_NURBS_ERROR19 = 100269; +public static final int GLU_NURBS_ERROR20 = 100270; +public static final int GLU_NURBS_ERROR21 = 100271; +public static final int GLU_NURBS_ERROR22 = 100272; +public static final int GLU_NURBS_ERROR23 = 100273; +public static final int GLU_NURBS_ERROR24 = 100274; +public static final int GLU_NURBS_ERROR25 = 100275; +public static final int GLU_NURBS_ERROR26 = 100276; +public static final int GLU_NURBS_ERROR27 = 100277; +public static final int GLU_NURBS_ERROR28 = 100278; +public static final int GLU_NURBS_ERROR29 = 100279; +public static final int GLU_NURBS_ERROR30 = 100280; +public static final int GLU_NURBS_ERROR31 = 100281; +public static final int GLU_NURBS_ERROR32 = 100282; +public static final int GLU_NURBS_ERROR33 = 100283; +public static final int GLU_NURBS_ERROR34 = 100284; +public static final int GLU_NURBS_ERROR35 = 100285; +public static final int GLU_NURBS_ERROR36 = 100286; +public static final int GLU_NURBS_ERROR37 = 100287; + +// NurbsProperty +public static final int GLU_AUTO_LOAD_MATRIX = 100200; +public static final int GLU_CULLING = 100201; +public static final int GLU_SAMPLING_TOLERANCE = 100203; +public static final int GLU_DISPLAY_MODE = 100204; +public static final int GLU_PARAMETRIC_TOLERANCE = 100202; +public static final int GLU_SAMPLING_METHOD = 100205; +public static final int GLU_U_STEP = 100206; +public static final int GLU_V_STEP = 100207; +public static final int GLU_NURBS_MODE = 100160; +public static final int GLU_NURBS_MODE_EXT = 100160; +public static final int GLU_NURBS_TESSELLATOR = 100161; +public static final int GLU_NURBS_TESSELLATOR_EXT = 100161; +public static final int GLU_NURBS_RENDERER = 100162; +public static final int GLU_NURBS_RENDERER_EXT = 100162; + +// NurbsSampling +public static final int GLU_OBJECT_PARAMETRIC_ERROR = 100208; +public static final int GLU_OBJECT_PARAMETRIC_ERROR_EXT = 100208; +public static final int GLU_OBJECT_PATH_LENGTH = 100209; +public static final int GLU_OBJECT_PATH_LENGTH_EXT = 100209; +public static final int GLU_PATH_LENGTH = 100215; +public static final int GLU_PARAMETRIC_ERROR = 100216; +public static final int GLU_DOMAIN_DISTANCE = 100217; + +// NurbsTrim +public static final int GLU_MAP1_TRIM_2 = 100210; +public static final int GLU_MAP1_TRIM_3 = 100211; + +// QuadricDrawStyle +public static final int GLU_POINT = 100010; +public static final int GLU_LINE = 100011; +public static final int GLU_FILL = 100012; +public static final int GLU_SILHOUETTE = 100013; + +// QuadricCallback +// GLU_ERROR + +// QuadricNormal +public static final int GLU_SMOOTH = 100000; +public static final int GLU_FLAT = 100001; +public static final int GLU_NONE = 100002; + +// QuadricOrientation +public static final int GLU_OUTSIDE = 100020; +public static final int GLU_INSIDE = 100021; + +// TessCallback +public static final int GLU_TESS_BEGIN = 100100; +public static final int GLU_BEGIN = 100100; +public static final int GLU_TESS_VERTEX = 100101; +public static final int GLU_VERTEX = 100101; +public static final int GLU_TESS_END = 100102; +public static final int GLU_END = 100102; +public static final int GLU_TESS_ERROR = 100103; +public static final int GLU_TESS_EDGE_FLAG = 100104; +public static final int GLU_EDGE_FLAG = 100104; +public static final int GLU_TESS_COMBINE = 100105; +public static final int GLU_TESS_BEGIN_DATA = 100106; +public static final int GLU_TESS_VERTEX_DATA = 100107; +public static final int GLU_TESS_END_DATA = 100108; +public static final int GLU_TESS_ERROR_DATA = 100109; +public static final int GLU_TESS_EDGE_FLAG_DATA = 100110; +public static final int GLU_TESS_COMBINE_DATA = 100111; + +// TessContour +public static final int GLU_CW = 100120; +public static final int GLU_CCW = 100121; +public static final int GLU_INTERIOR = 100122; +public static final int GLU_EXTERIOR = 100123; +public static final int GLU_UNKNOWN = 100124; + +// TessProperty +public static final int GLU_TESS_WINDING_RULE = 100140; +public static final int GLU_TESS_BOUNDRY_ONLY = 100141; +public static final int GLU_TESS_TOLERANCE = 100142; + +// TessError +public static final int GLU_TESS_ERROR1 = 100151; +public static final int GLU_TESS_ERROR2 = 100152; +public static final int GLU_TESS_ERROR3 = 100153; +public static final int GLU_TESS_ERROR4 = 100154; +public static final int GLU_TESS_ERROR5 = 100155; +public static final int GLU_TESS_ERROR6 = 100156; +public static final int GLU_TESS_ERROR7 = 100157; +public static final int GLU_TESS_ERROR8 = 100158; +public static final int GLU_TESS_MISSING_BEGIN_POLYGON = 100151; +public static final int GLU_TESS_MISSING_BEGIN_CONTOUR = 100152; +public static final int GLU_TESS_MISSING_END_POLYGON = 100153; +public static final int GLU_TESS_MISSING_END_CONTOUR = 100154; +public static final int GLU_TESS_COORD_TOO_LARGE = 100155; +public static final int GLU_TESS_NEED_COMBINE_CALLBACK = 100156; + +// TessWinding +public static final int GLU_TESS_WINDING_ODD = 100130; +public static final int GLU_TESS_WINDING_NONZERO = 100131; +public static final int GLU_TESS_WINDING_POSITIVE = 100132; +public static final int GLU_TESS_WINDING_NEGATIVE = 100133; +public static final int GLU_TESS_WINDING_ABS_GEQ_TWO = 100134; + +public int gluScaleImageJava( int format, int widthin, int heightin, + int typein, Object datain, int widthout, int heightout, + int typeout, Object dataout ) { + ByteBuffer in = null; + ByteBuffer out = null; + if( datain instanceof ByteBuffer ) { + in = (ByteBuffer)datain; + } else if( datain instanceof byte[] ) { + in = ByteBuffer.allocateDirect( ((byte[])datain).length ).order( ByteOrder.nativeOrder() ); + in.put((byte[]) datain).rewind(); + } else if( datain instanceof short[] ) { + in = ByteBuffer.allocateDirect( ((byte[])datain).length * 2 ).order( ByteOrder.nativeOrder() ); + in.asShortBuffer().put((short[]) datain).rewind(); + } else if( datain instanceof int[] ) { + in = ByteBuffer.allocateDirect( ((byte[])datain).length * 4 ).order( ByteOrder.nativeOrder() ); + in.asIntBuffer().put((int[]) datain).rewind(); + } else if( datain instanceof float[] ) { + in = ByteBuffer.allocateDirect( ((byte[])datain).length * 4 ).order( ByteOrder.nativeOrder() ); + in.asFloatBuffer().put((float[]) datain).rewind(); + } else { + throw new IllegalArgumentException( "Input data must be a primitive array or a ByteBuffer" ); + } + if( dataout instanceof ByteBuffer ) { + out = (ByteBuffer)dataout; + } else if( dataout instanceof byte[] ) { + out = ByteBuffer.wrap( ((byte[])dataout) ); + } else if( dataout instanceof short[] ) { + out = ByteBuffer.allocate( ((short[])dataout).length * 2 ); + } else if( dataout instanceof int[] ) { + out = ByteBuffer.allocate( ((int[])dataout).length * 4 ); + } else if( dataout instanceof float[] ) { + out = ByteBuffer.allocate( ((float[])dataout).length * 4 ); + } else { + throw new IllegalArgumentException( "Output data must be a primitive array or a ByteBuffer" ); + } + int errno = Mipmap.gluScaleImage( gl, format, widthin, heightin, typein, in, + widthout, heightout, typeout, out ); + if( errno == 0 ) { + if( dataout instanceof short[] ) { + out.asShortBuffer().get( (short[])dataout ); + } else if( dataout instanceof int[] ) { + out.asIntBuffer().get( (int[])dataout ); + } else if( dataout instanceof float[] ) { + out.asFloatBuffer().get( (float[])dataout ); + } + } + return( errno ); +} + +public int gluBuild1DMipmapLevelsJava( int target, int internalFormat, int width, + int format, int type, int userLevel, int baseLevel, int maxLevel, + Object data ) { + ByteBuffer buffer = null; + if( data instanceof ByteBuffer ) { + buffer = (ByteBuffer)data; + } else if( data instanceof byte[] ) { + buffer = ByteBuffer.allocateDirect( ((byte[])data).length ).order( ByteOrder.nativeOrder() ); + buffer.put( (byte[])data ); + } else if( data instanceof short[] ) { + buffer = ByteBuffer.allocateDirect( ((short[])data).length * 2 ).order( ByteOrder.nativeOrder() ); + buffer.asShortBuffer().put( (short[])data ); + } else if( data instanceof int[] ) { + buffer = ByteBuffer.allocateDirect( ((int[])data).length * 4 ).order( ByteOrder.nativeOrder() ); + buffer.asIntBuffer().put( (int[])data ); + } else if( data instanceof float[] ) { + buffer = ByteBuffer.allocateDirect( ((float[])data).length * 4 ).order( ByteOrder.nativeOrder() ); + buffer.asFloatBuffer().put( (float[])data ); + } else { + throw new IllegalArgumentException( "Input data must be a primitive array or a ByteBuffer" ); + } + return( Mipmap.gluBuild1DMipmapLevels( gl, target, internalFormat, width, + format, type, userLevel, baseLevel, maxLevel, buffer ) ); +} + +public int gluBuild1DMipmapsJava( int target, int internalFormat, int width, + int format, int type, Object data ) { + ByteBuffer buffer = null; + if( data instanceof ByteBuffer ) { + buffer = (ByteBuffer)data; + } else if( data instanceof byte[] ) { + buffer = ByteBuffer.allocateDirect( ((byte[])data).length ).order( ByteOrder.nativeOrder() ); + buffer.put( (byte[])data ); + } else if( data instanceof short[] ) { + buffer = ByteBuffer.allocateDirect( ((short[])data).length * 2 ).order( ByteOrder.nativeOrder() ); + buffer.asShortBuffer().put( (short[])data ); + } else if( data instanceof int[] ) { + buffer = ByteBuffer.allocateDirect( ((int[])data).length * 4 ).order( ByteOrder.nativeOrder() ); + buffer.asIntBuffer().put( (int[])data ); + } else if( data instanceof float[] ) { + buffer = ByteBuffer.allocateDirect( ((float[])data).length * 4 ).order( ByteOrder.nativeOrder() ); + buffer.asFloatBuffer().put( (float[])data ); + } else { + throw new IllegalArgumentException( "Input data must be a primitive array or a ByteBuffer" ); + } + return( Mipmap.gluBuild1DMipmaps( gl, target, internalFormat, width, format, + type, buffer ) ); +} + +public int gluBuild2DMipmapLevelsJava( int target, int internalFormat, int width, + int height, int format, int type, int userLevel, int baseLevel, + int maxLevel, Object data ) { + return( Mipmap.gluBuild2DMipmapLevels( gl, target, internalFormat, width, + height, format, type, userLevel, baseLevel, maxLevel, data ) ); +} + +public int gluBuild2DMipmapsJava( int target, int internalFormat, int width, + int height, int format, int type, Object data ) { + return( Mipmap.gluBuild2DMipmaps( gl, target, internalFormat, width, height, + format, type, data ) ); +} + +public int gluBuild3DMipmapLevelsJava( int target, int internalFormat, int width, + int height, int depth, int format, int type, int userLevel, int baseLevel, + int maxLevel, Object data ) { + ByteBuffer buffer = null; + if( data instanceof ByteBuffer ) { + buffer = (ByteBuffer)data; + } else if( data instanceof byte[] ) { + buffer = ByteBuffer.allocateDirect( ((byte[])data).length ).order( ByteOrder.nativeOrder() ); + buffer.put( (byte[])data ); + } else if( data instanceof short[] ) { + buffer = ByteBuffer.allocateDirect( ((short[])data).length * 2 ).order( ByteOrder.nativeOrder() ); + buffer.asShortBuffer().put( (short[])data ); + } else if( data instanceof int[] ) { + buffer = ByteBuffer.allocateDirect( ((int[])data).length * 4 ).order( ByteOrder.nativeOrder() ); + buffer.asIntBuffer().put( (int[])data ); + } else if( data instanceof float[] ) { + buffer = ByteBuffer.allocateDirect( ((float[])data).length * 4 ).order( ByteOrder.nativeOrder() ); + buffer.asFloatBuffer().put( (float[])data ); + } else { + throw new IllegalArgumentException( "Input data must be a primitive array or a ByteBuffer" ); + } + return( Mipmap.gluBuild3DMipmapLevels( gl, target, internalFormat, width, + height, depth, format, type, userLevel, baseLevel, maxLevel, buffer ) ); +} + +public int gluBuild3DMipmapsJava( int target, int internalFormat, int width, + int height, int depth, int format, int type, Object data ) { + ByteBuffer buffer = null; + if( data instanceof ByteBuffer ) { + buffer = (ByteBuffer)data; + } else if( data instanceof byte[] ) { + buffer = ByteBuffer.allocateDirect( ((byte[])data).length ).order( ByteOrder.nativeOrder() ); + buffer.put( (byte[])data ); + } else if( data instanceof short[] ) { + buffer = ByteBuffer.allocateDirect( ((short[])data).length * 2 ).order( ByteOrder.nativeOrder() ); + buffer.asShortBuffer().put( (short[])data ); + } else if( data instanceof int[] ) { + buffer = ByteBuffer.allocateDirect( ((int[])data).length * 4 ).order( ByteOrder.nativeOrder() ); + buffer.asIntBuffer().put( (int[])data ); + } else if( data instanceof float[] ) { + buffer = ByteBuffer.allocateDirect( ((float[])data).length * 4 ).order( ByteOrder.nativeOrder() ); + buffer.asFloatBuffer().put( (float[])data ); + } else { + throw new IllegalArgumentException( "Input data must be a primitive array or a ByteBuffer" ); + } + return( Mipmap.gluBuild3DMipmaps( gl, target, internalFormat, width, height, + depth, format, type, buffer ) ); +} + + +//---------------------------------------------------------------------- +// Wrappers for mipmap and image scaling entry points which dispatch either +// to the Java or C versions. +// + + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, byte[] data) { + if (useJavaMipmapCode) { + return gluBuild1DMipmapLevelsJava(target, internalFormat, width, format, type, level, base, max, data); + } else { + return gluBuild1DMipmapLevelsC(target, internalFormat, width, format, type, level, base, max, data); + } +} + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, short[] data) { + if (useJavaMipmapCode) { + return gluBuild1DMipmapLevelsJava(target, internalFormat, width, format, type, level, base, max, data); + } else { + return gluBuild1DMipmapLevelsC(target, internalFormat, width, format, type, level, base, max, data); + } +} + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, int[] data) { + if (useJavaMipmapCode) { + return gluBuild1DMipmapLevelsJava(target, internalFormat, width, format, type, level, base, max, data); + } else { + return gluBuild1DMipmapLevelsC(target, internalFormat, width, format, type, level, base, max, data); + } +} + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, float[] data) { + if (useJavaMipmapCode) { + return gluBuild1DMipmapLevelsJava(target, internalFormat, width, format, type, level, base, max, data); + } else { + return gluBuild1DMipmapLevelsC(target, internalFormat, width, format, type, level, base, max, data); + } +} + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, java.nio.Buffer data) { + if (useJavaMipmapCode) { + return gluBuild1DMipmapLevelsJava(target, internalFormat, width, format, type, level, base, max, data); + } else { + return gluBuild1DMipmapLevelsC(target, internalFormat, width, format, type, level, base, max, data); + } +} + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, byte[] data) { + if (useJavaMipmapCode) { + return gluBuild1DMipmapsJava(target, internalFormat, width, format, type, data); + } else { + return gluBuild1DMipmapsC(target, internalFormat, width, format, type, data); + } +} + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, short[] data) { + if (useJavaMipmapCode) { + return gluBuild1DMipmapsJava(target, internalFormat, width, format, type, data); + } else { + return gluBuild1DMipmapsC(target, internalFormat, width, format, type, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, int[] data) { + if (useJavaMipmapCode) { + return gluBuild1DMipmapsJava(target, internalFormat, width, format, type, data); + } else { + return gluBuild1DMipmapsC(target, internalFormat, width, format, type, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, float[] data) { + if (useJavaMipmapCode) { + return gluBuild1DMipmapsJava(target, internalFormat, width, format, type, data); + } else { + return gluBuild1DMipmapsC(target, internalFormat, width, format, type, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, byte[] data) { + if (useJavaMipmapCode) { + return gluBuild2DMipmapLevelsJava(target, internalFormat, width, height, format, type, level, base, max, data); + } else { + return gluBuild2DMipmapLevelsC(target, internalFormat, width, height, format, type, level, base, max, data); + } +} + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, short[] data) { + if (useJavaMipmapCode) { + return gluBuild2DMipmapLevelsJava(target, internalFormat, width, height, format, type, level, base, max, data); + } else { + return gluBuild2DMipmapLevelsC(target, internalFormat, width, height, format, type, level, base, max, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, int[] data) { + if (useJavaMipmapCode) { + return gluBuild2DMipmapLevelsJava(target, internalFormat, width, height, format, type, level, base, max, data); + } else { + return gluBuild2DMipmapLevelsC(target, internalFormat, width, height, format, type, level, base, max, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, float[] data) { + if (useJavaMipmapCode) { + return gluBuild2DMipmapLevelsJava(target, internalFormat, width, height, format, type, level, base, max, data); + } else { + return gluBuild2DMipmapLevelsC(target, internalFormat, width, height, format, type, level, base, max, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, java.nio.Buffer data) { + if (useJavaMipmapCode) { + return gluBuild2DMipmapLevelsJava(target, internalFormat, width, height, format, type, level, base, max, data); + } else { + return gluBuild2DMipmapLevelsC(target, internalFormat, width, height, format, type, level, base, max, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, byte[] data) { + if (useJavaMipmapCode) { + return gluBuild2DMipmapsJava(target, internalFormat, width, height, format, type, data); + } else { + return gluBuild2DMipmapsC(target, internalFormat, width, height, format, type, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, short[] data) { + if (useJavaMipmapCode) { + return gluBuild2DMipmapsJava(target, internalFormat, width, height, format, type, data); + } else { + return gluBuild2DMipmapsC(target, internalFormat, width, height, format, type, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, int[] data) { + if (useJavaMipmapCode) { + return gluBuild2DMipmapsJava(target, internalFormat, width, height, format, type, data); + } else { + return gluBuild2DMipmapsC(target, internalFormat, width, height, format, type, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, float[] data) { + if (useJavaMipmapCode) { + return gluBuild2DMipmapsJava(target, internalFormat, width, height, format, type, data); + } else { + return gluBuild2DMipmapsC(target, internalFormat, width, height, format, type, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, java.nio.Buffer data) { + if (useJavaMipmapCode) { + return gluBuild2DMipmapsJava(target, internalFormat, width, height, format, type, data); + } else { + return gluBuild2DMipmapsC(target, internalFormat, width, height, format, type, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, byte[] data) { + if (useJavaMipmapCode) { + return gluBuild3DMipmapLevelsJava(target, internalFormat, width, height, depth, format, type, level, base, max, data); + } else { + return gluBuild3DMipmapLevelsC(target, internalFormat, width, height, depth, format, type, level, base, max, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, short[] data) { + if (useJavaMipmapCode) { + return gluBuild3DMipmapLevelsJava(target, internalFormat, width, height, depth, format, type, level, base, max, data); + } else { + return gluBuild3DMipmapLevelsC(target, internalFormat, width, height, depth, format, type, level, base, max, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, int[] data) { + if (useJavaMipmapCode) { + return gluBuild3DMipmapLevelsJava(target, internalFormat, width, height, depth, format, type, level, base, max, data); + } else { + return gluBuild3DMipmapLevelsC(target, internalFormat, width, height, depth, format, type, level, base, max, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, float[] data) { + if (useJavaMipmapCode) { + return gluBuild3DMipmapLevelsJava(target, internalFormat, width, height, depth, format, type, level, base, max, data); + } else { + return gluBuild3DMipmapLevelsC(target, internalFormat, width, height, depth, format, type, level, base, max, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, java.nio.Buffer data) { + if (useJavaMipmapCode) { + return gluBuild3DMipmapLevelsJava(target, internalFormat, width, height, depth, format, type, level, base, max, data); + } else { + return gluBuild3DMipmapLevelsC(target, internalFormat, width, height, depth, format, type, level, base, max, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, byte[] data) { + if (useJavaMipmapCode) { + return gluBuild3DMipmapsJava(target, internalFormat, width, height, depth, format, type, data); + } else { + return gluBuild3DMipmapsC(target, internalFormat, width, height, depth, format, type, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, short[] data) { + if (useJavaMipmapCode) { + return gluBuild3DMipmapsJava(target, internalFormat, width, height, depth, format, type, data); + } else { + return gluBuild3DMipmapsC(target, internalFormat, width, height, depth, format, type, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, int[] data) { + if (useJavaMipmapCode) { + return gluBuild3DMipmapsJava(target, internalFormat, width, height, depth, format, type, data); + } else { + return gluBuild3DMipmapsC(target, internalFormat, width, height, depth, format, type, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, float[] data) { + if (useJavaMipmapCode) { + return gluBuild3DMipmapsJava(target, internalFormat, width, height, depth, format, type, data); + } else { + return gluBuild3DMipmapsC(target, internalFormat, width, height, depth, format, type, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, java.nio.Buffer data) { + if (useJavaMipmapCode) { + return gluBuild3DMipmapsJava(target, internalFormat, width, height, depth, format, type, data); + } else { + return gluBuild3DMipmapsC(target, internalFormat, width, height, depth, format, type, data); + } +} + + +/** Interface to C language function: <br> <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ +public int gluScaleImage(int format, int wIn, int hIn, int typeIn, byte[] dataIn, int wOut, int hOut, int typeOut, byte[] dataOut) { + if (useJavaMipmapCode) { + return gluScaleImageJava(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut); + } else { + return gluScaleImageC(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut); + } +} + + +/** Interface to C language function: <br> <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ +public int gluScaleImage(int format, int wIn, int hIn, int typeIn, short[] dataIn, int wOut, int hOut, int typeOut, short[] dataOut) { + if (useJavaMipmapCode) { + return gluScaleImageJava(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut); + } else { + return gluScaleImageC(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut); + } +} + + +/** Interface to C language function: <br> <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ +public int gluScaleImage(int format, int wIn, int hIn, int typeIn, int[] dataIn, int wOut, int hOut, int typeOut, int[] dataOut) { + if (useJavaMipmapCode) { + return gluScaleImageJava(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut); + } else { + return gluScaleImageC(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut); + } +} + + +/** Interface to C language function: <br> <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ +public int gluScaleImage(int format, int wIn, int hIn, int typeIn, float[] dataIn, int wOut, int hOut, int typeOut, float[] dataOut) { + if (useJavaMipmapCode) { + return gluScaleImageJava(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut); + } else { + return gluScaleImageC(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut); + } +} + + +/** Interface to C language function: <br> <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ +public int gluScaleImage(int format, int wIn, int hIn, int typeIn, java.nio.Buffer dataIn, int wOut, int hOut, int typeOut, java.nio.Buffer dataOut) { + if (useJavaMipmapCode) { + return gluScaleImageJava(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut); + } else { + return gluScaleImageC(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut); + } +} + + + +//---------------------------------------------------------------------- +// Wrappers for C entry points for mipmap and scaling functionality. +// (These are only used as a fallback and will be removed in a future release) + + /** Entry point to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + public int gluBuild1DMipmapLevelsC(int target, int internalFormat, int width, int format, int type, int level, int base, int max, byte[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild1DMipmapLevels; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild1DMipmapLevels\" not available"); + } + return dispatch_gluBuild1DMipmapLevels(target, internalFormat, width, format, type, level, base, max, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + private native int dispatch_gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, byte[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + public int gluBuild1DMipmapLevelsC(int target, int internalFormat, int width, int format, int type, int level, int base, int max, short[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild1DMipmapLevels; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild1DMipmapLevels\" not available"); + } + return dispatch_gluBuild1DMipmapLevels(target, internalFormat, width, format, type, level, base, max, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + private native int dispatch_gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, short[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + public int gluBuild1DMipmapLevelsC(int target, int internalFormat, int width, int format, int type, int level, int base, int max, int[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild1DMipmapLevels; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild1DMipmapLevels\" not available"); + } + return dispatch_gluBuild1DMipmapLevels(target, internalFormat, width, format, type, level, base, max, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + private native int dispatch_gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, int[] data, long glProcAddress); + + /** Entry point to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + public int gluBuild1DMipmapLevelsC(int target, int internalFormat, int width, int format, int type, int level, int base, int max, float[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild1DMipmapLevels; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild1DMipmapLevels\" not available"); + } + return dispatch_gluBuild1DMipmapLevels(target, internalFormat, width, format, type, level, base, max, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + private native int dispatch_gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, float[] data, long glProcAddress); + + /** Entry point to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + public int gluBuild1DMipmapLevelsC(int target, int internalFormat, int width, int format, int type, int level, int base, int max, java.nio.Buffer data) + { + if (!BufferFactory.isDirect(data)) + throw new GLException("Argument \"data\" was not a direct buffer"); + final long __addr_ = gluProcAddressTable._addressof_gluBuild1DMipmapLevels; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild1DMipmapLevels\" not available"); + } + return dispatch_gluBuild1DMipmapLevels(target, internalFormat, width, format, type, level, base, max, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + native private int dispatch_gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, java.nio.Buffer data, long glProcAddress); + + /** Entry point to C language function: <br> <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ + public int gluBuild1DMipmapsC(int target, int internalFormat, int width, int format, int type, byte[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild1DMipmaps; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild1DMipmaps\" not available"); + } + return dispatch_gluBuild1DMipmaps(target, internalFormat, width, format, type, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ + private native int dispatch_gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, byte[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ + public int gluBuild1DMipmapsC(int target, int internalFormat, int width, int format, int type, short[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild1DMipmaps; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild1DMipmaps\" not available"); + } + return dispatch_gluBuild1DMipmaps(target, internalFormat, width, format, type, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ + private native int dispatch_gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, short[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ + public int gluBuild1DMipmapsC(int target, int internalFormat, int width, int format, int type, int[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild1DMipmaps; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild1DMipmaps\" not available"); + } + return dispatch_gluBuild1DMipmaps(target, internalFormat, width, format, type, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ + private native int dispatch_gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, int[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ + public int gluBuild1DMipmapsC(int target, int internalFormat, int width, int format, int type, float[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild1DMipmaps; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild1DMipmaps\" not available"); + } + return dispatch_gluBuild1DMipmaps(target, internalFormat, width, format, type, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ + private native int dispatch_gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, float[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ + public int gluBuild1DMipmapsC(int target, int internalFormat, int width, int format, int type, java.nio.Buffer data) + { + if (!BufferFactory.isDirect(data)) + throw new GLException("Argument \"data\" was not a direct buffer"); + final long __addr_ = gluProcAddressTable._addressof_gluBuild1DMipmaps; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild1DMipmaps\" not available"); + } + return dispatch_gluBuild1DMipmaps(target, internalFormat, width, format, type, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ + native private int dispatch_gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, java.nio.Buffer data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + public int gluBuild2DMipmapLevelsC(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, byte[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild2DMipmapLevels; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild2DMipmapLevels\" not available"); + } + return dispatch_gluBuild2DMipmapLevels(target, internalFormat, width, height, format, type, level, base, max, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + private native int dispatch_gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, byte[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + public int gluBuild2DMipmapLevelsC(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, short[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild2DMipmapLevels; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild2DMipmapLevels\" not available"); + } + return dispatch_gluBuild2DMipmapLevels(target, internalFormat, width, height, format, type, level, base, max, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + private native int dispatch_gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, short[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + public int gluBuild2DMipmapLevelsC(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, int[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild2DMipmapLevels; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild2DMipmapLevels\" not available"); + } + return dispatch_gluBuild2DMipmapLevels(target, internalFormat, width, height, format, type, level, base, max, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + private native int dispatch_gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, int[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + public int gluBuild2DMipmapLevelsC(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, float[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild2DMipmapLevels; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild2DMipmapLevels\" not available"); + } + return dispatch_gluBuild2DMipmapLevels(target, internalFormat, width, height, format, type, level, base, max, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + private native int dispatch_gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, float[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + public int gluBuild2DMipmapLevelsC(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, java.nio.Buffer data) + { + if (!BufferFactory.isDirect(data)) + throw new GLException("Argument \"data\" was not a direct buffer"); + final long __addr_ = gluProcAddressTable._addressof_gluBuild2DMipmapLevels; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild2DMipmapLevels\" not available"); + } + return dispatch_gluBuild2DMipmapLevels(target, internalFormat, width, height, format, type, level, base, max, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + native private int dispatch_gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, java.nio.Buffer data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ + public int gluBuild2DMipmapsC(int target, int internalFormat, int width, int height, int format, int type, byte[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild2DMipmaps; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild2DMipmaps\" not available"); + } + return dispatch_gluBuild2DMipmaps(target, internalFormat, width, height, format, type, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ + private native int dispatch_gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, byte[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ + public int gluBuild2DMipmapsC(int target, int internalFormat, int width, int height, int format, int type, short[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild2DMipmaps; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild2DMipmaps\" not available"); + } + return dispatch_gluBuild2DMipmaps(target, internalFormat, width, height, format, type, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ + private native int dispatch_gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, short[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ + public int gluBuild2DMipmapsC(int target, int internalFormat, int width, int height, int format, int type, int[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild2DMipmaps; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild2DMipmaps\" not available"); + } + return dispatch_gluBuild2DMipmaps(target, internalFormat, width, height, format, type, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ + private native int dispatch_gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, int[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ + public int gluBuild2DMipmapsC(int target, int internalFormat, int width, int height, int format, int type, float[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild2DMipmaps; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild2DMipmaps\" not available"); + } + return dispatch_gluBuild2DMipmaps(target, internalFormat, width, height, format, type, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ + private native int dispatch_gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, float[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ + public int gluBuild2DMipmapsC(int target, int internalFormat, int width, int height, int format, int type, java.nio.Buffer data) + { + if (!BufferFactory.isDirect(data)) + throw new GLException("Argument \"data\" was not a direct buffer"); + final long __addr_ = gluProcAddressTable._addressof_gluBuild2DMipmaps; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild2DMipmaps\" not available"); + } + return dispatch_gluBuild2DMipmaps(target, internalFormat, width, height, format, type, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ + native private int dispatch_gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, java.nio.Buffer data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + public int gluBuild3DMipmapLevelsC(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, byte[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild3DMipmapLevels; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild3DMipmapLevels\" not available"); + } + return dispatch_gluBuild3DMipmapLevels(target, internalFormat, width, height, depth, format, type, level, base, max, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + private native int dispatch_gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, byte[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + public int gluBuild3DMipmapLevelsC(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, short[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild3DMipmapLevels; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild3DMipmapLevels\" not available"); + } + return dispatch_gluBuild3DMipmapLevels(target, internalFormat, width, height, depth, format, type, level, base, max, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + private native int dispatch_gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, short[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + public int gluBuild3DMipmapLevelsC(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, int[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild3DMipmapLevels; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild3DMipmapLevels\" not available"); + } + return dispatch_gluBuild3DMipmapLevels(target, internalFormat, width, height, depth, format, type, level, base, max, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + private native int dispatch_gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, int[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + public int gluBuild3DMipmapLevelsC(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, float[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild3DMipmapLevels; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild3DMipmapLevels\" not available"); + } + return dispatch_gluBuild3DMipmapLevels(target, internalFormat, width, height, depth, format, type, level, base, max, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + private native int dispatch_gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, float[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + public int gluBuild3DMipmapLevelsC(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, java.nio.Buffer data) + { + if (!BufferFactory.isDirect(data)) + throw new GLException("Argument \"data\" was not a direct buffer"); + final long __addr_ = gluProcAddressTable._addressof_gluBuild3DMipmapLevels; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild3DMipmapLevels\" not available"); + } + return dispatch_gluBuild3DMipmapLevels(target, internalFormat, width, height, depth, format, type, level, base, max, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ + native private int dispatch_gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, java.nio.Buffer data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ + public int gluBuild3DMipmapsC(int target, int internalFormat, int width, int height, int depth, int format, int type, byte[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild3DMipmaps; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild3DMipmaps\" not available"); + } + return dispatch_gluBuild3DMipmaps(target, internalFormat, width, height, depth, format, type, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ + private native int dispatch_gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, byte[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ + public int gluBuild3DMipmapsC(int target, int internalFormat, int width, int height, int depth, int format, int type, short[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild3DMipmaps; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild3DMipmaps\" not available"); + } + return dispatch_gluBuild3DMipmaps(target, internalFormat, width, height, depth, format, type, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ + private native int dispatch_gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, short[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ + public int gluBuild3DMipmapsC(int target, int internalFormat, int width, int height, int depth, int format, int type, int[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild3DMipmaps; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild3DMipmaps\" not available"); + } + return dispatch_gluBuild3DMipmaps(target, internalFormat, width, height, depth, format, type, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ + private native int dispatch_gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, int[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ + public int gluBuild3DMipmapsC(int target, int internalFormat, int width, int height, int depth, int format, int type, float[] data) + { + final long __addr_ = gluProcAddressTable._addressof_gluBuild3DMipmaps; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild3DMipmaps\" not available"); + } + return dispatch_gluBuild3DMipmaps(target, internalFormat, width, height, depth, format, type, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ + private native int dispatch_gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, float[] data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ + public int gluBuild3DMipmapsC(int target, int internalFormat, int width, int height, int depth, int format, int type, java.nio.Buffer data) + { + if (!BufferFactory.isDirect(data)) + throw new GLException("Argument \"data\" was not a direct buffer"); + final long __addr_ = gluProcAddressTable._addressof_gluBuild3DMipmaps; + if (__addr_ == 0) { + throw new GLException("Method \"gluBuild3DMipmaps\" not available"); + } + return dispatch_gluBuild3DMipmaps(target, internalFormat, width, height, depth, format, type, data, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ + native private int dispatch_gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, java.nio.Buffer data, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ + public int gluScaleImageC(int format, int wIn, int hIn, int typeIn, byte[] dataIn, int wOut, int hOut, int typeOut, byte[] dataOut) + { + final long __addr_ = gluProcAddressTable._addressof_gluScaleImage; + if (__addr_ == 0) { + throw new GLException("Method \"gluScaleImage\" not available"); + } + return dispatch_gluScaleImage(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ + private native int dispatch_gluScaleImage(int format, int wIn, int hIn, int typeIn, byte[] dataIn, int wOut, int hOut, int typeOut, byte[] dataOut, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ + public int gluScaleImageC(int format, int wIn, int hIn, int typeIn, short[] dataIn, int wOut, int hOut, int typeOut, short[] dataOut) + { + final long __addr_ = gluProcAddressTable._addressof_gluScaleImage; + if (__addr_ == 0) { + throw new GLException("Method \"gluScaleImage\" not available"); + } + return dispatch_gluScaleImage(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ + private native int dispatch_gluScaleImage(int format, int wIn, int hIn, int typeIn, short[] dataIn, int wOut, int hOut, int typeOut, short[] dataOut, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ + public int gluScaleImageC(int format, int wIn, int hIn, int typeIn, int[] dataIn, int wOut, int hOut, int typeOut, int[] dataOut) + { + final long __addr_ = gluProcAddressTable._addressof_gluScaleImage; + if (__addr_ == 0) { + throw new GLException("Method \"gluScaleImage\" not available"); + } + return dispatch_gluScaleImage(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ + private native int dispatch_gluScaleImage(int format, int wIn, int hIn, int typeIn, int[] dataIn, int wOut, int hOut, int typeOut, int[] dataOut, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ + public int gluScaleImageC(int format, int wIn, int hIn, int typeIn, float[] dataIn, int wOut, int hOut, int typeOut, float[] dataOut) + { + final long __addr_ = gluProcAddressTable._addressof_gluScaleImage; + if (__addr_ == 0) { + throw new GLException("Method \"gluScaleImage\" not available"); + } + return dispatch_gluScaleImage(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ + private native int dispatch_gluScaleImage(int format, int wIn, int hIn, int typeIn, float[] dataIn, int wOut, int hOut, int typeOut, float[] dataOut, long glProcAddress); + + + /** Entry point to C language function: <br> <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ + public int gluScaleImageC(int format, int wIn, int hIn, int typeIn, java.nio.Buffer dataIn, int wOut, int hOut, int typeOut, java.nio.Buffer dataOut) + { + if (!BufferFactory.isDirect(dataIn)) + throw new GLException("Argument \"dataIn\" was not a direct buffer"); + if (!BufferFactory.isDirect(dataOut)) + throw new GLException("Argument \"dataOut\" was not a direct buffer"); + final long __addr_ = gluProcAddressTable._addressof_gluScaleImage; + if (__addr_ == 0) { + throw new GLException("Method \"gluScaleImage\" not available"); + } + return dispatch_gluScaleImage(format, wIn, hIn, typeIn, dataIn, wOut, hOut, typeOut, dataOut, __addr_); + } + + /** Encapsulates function pointer for OpenGL function <br>: <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ + native private int dispatch_gluScaleImage(int format, int wIn, int hIn, int typeIn, java.nio.Buffer dataIn, int wOut, int hOut, int typeOut, java.nio.Buffer dataOut, long glProcAddress); + + + diff --git a/make/glu-impl-common.cfg b/make/glu-impl-common.cfg index 539bf9784..6710d0369 100644 --- a/make/glu-impl-common.cfg +++ b/make/glu-impl-common.cfg @@ -9,8 +9,11 @@ EmitProcAddressTable true ProcAddressTableClassName GLUProcAddressTable GetProcAddressTableExpr gluProcAddressTable -#GLUImpl needs access to the GLUtesselatorImpl class for GLUtesselator. +# GLUImpl needs access to the GLUtesselatorImpl class for GLUtesselator +# and to the Mipmap class for scaling and mipmap generation Import net.java.games.jogl.impl.tesselator.GLUtesselatorImpl +Import net.java.games.jogl.impl.mipmap.Mipmap +Import java.security.* # Custom Java code for GLUImpl class IncludeAs CustomJavaCode GLUImpl glu-impl-common-CustomJavaCode.java diff --git a/make/glu-impl-macosx.cfg b/make/glu-impl-macosx.cfg index 6dac11f54..21e9b3700 100644 --- a/make/glu-impl-macosx.cfg +++ b/make/glu-impl-macosx.cfg @@ -1,7 +1,9 @@ # This .cfg file is used to generate the GLU implementation on # Mac OS X. -Include glu-impl-common.cfg - CustomCCode #include <inttypes.h> CustomCCode #include <jni.h> + +CustomCCode #include </usr/include/machine/types.h> + +Include glu-impl-common.cfg diff --git a/make/glu-impl-win32.cfg b/make/glu-impl-win32.cfg index cc6b13a72..983513712 100644 --- a/make/glu-impl-win32.cfg +++ b/make/glu-impl-win32.cfg @@ -1,7 +1,5 @@ # This .cfg file is used to generate the GLU implementation on Windows. -Include glu-impl-common.cfg - CustomCCode #define WIN32_LEAN_AND_MEAN CustomCCode #include <windows.h> CustomCCode #undef WIN32_LEAN_AND_MEAN @@ -13,7 +11,9 @@ CustomCCode #if _MSC_VER <= 1200 CustomCCode typedef int intptr_t; CustomCCode #endif +Include glu-impl-common.cfg + # FIXME!!!! # Include some hacks to get around the fact that GLU1.3 is not yet # supported in Windows distributions. -Include glu-impl-win32-GLU13Hacks.cfg +# Include glu-impl-win32-GLU13Hacks.cfg diff --git a/make/glu-impl-x11.cfg b/make/glu-impl-x11.cfg index 3e46a73b5..35fc7034d 100644 --- a/make/glu-impl-x11.cfg +++ b/make/glu-impl-x11.cfg @@ -1,8 +1,6 @@ # This .cfg file is used to generate the GLU implementation on # X11. -Include glu-impl-common.cfg - CustomCCode #include <inttypes.h> - +Include glu-impl-common.cfg diff --git a/make/glu-interface-common-CustomJavaCode.java b/make/glu-interface-common-CustomJavaCode.java index 0019046c5..8be08f0a6 100644 --- a/make/glu-interface-common-CustomJavaCode.java +++ b/make/glu-interface-common-CustomJavaCode.java @@ -803,6 +803,118 @@ public void gluTessProperty(GLUtesselator tesselator, int which, double value); public void gluTessVertex(GLUtesselator tesselator, double[] coords, Object data); +//---------------------------------------------------------------------- +// Mipmap and scaling routines +// + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, byte[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, short[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, int[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, float[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild1DMipmapLevels(int target, int internalFormat, int width, int format, int type, int level, int base, int max, java.nio.Buffer data); + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, byte[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, short[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, int[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild1DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild1DMipmaps(int target, int internalFormat, int width, int format, int type, float[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, byte[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, short[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, int[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, float[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild2DMipmapLevels(int target, int internalFormat, int width, int height, int format, int type, int level, int base, int max, java.nio.Buffer data); + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, byte[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, short[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, int[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, float[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild2DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild2DMipmaps(int target, int internalFormat, int width, int height, int format, int type, java.nio.Buffer data); + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, byte[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, short[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, int[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, float[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmapLevels(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLint level, GLint base, GLint max, const void * data); </code> */ +public int gluBuild3DMipmapLevels(int target, int internalFormat, int width, int height, int depth, int format, int type, int level, int base, int max, java.nio.Buffer data); + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, byte[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, short[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, int[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, float[] data); + +/** Interface to C language function: <br> <code> GLint gluBuild3DMipmaps(GLenum target, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data); </code> */ +public int gluBuild3DMipmaps(int target, int internalFormat, int width, int height, int depth, int format, int type, java.nio.Buffer data); + +/** Interface to C language function: <br> <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ +public int gluScaleImage(int format, int wIn, int hIn, int typeIn, byte[] dataIn, int wOut, int hOut, int typeOut, byte[] dataOut); + +/** Interface to C language function: <br> <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ +public int gluScaleImage(int format, int wIn, int hIn, int typeIn, short[] dataIn, int wOut, int hOut, int typeOut, short[] dataOut); + +/** Interface to C language function: <br> <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ +public int gluScaleImage(int format, int wIn, int hIn, int typeIn, int[] dataIn, int wOut, int hOut, int typeOut, int[] dataOut); + +/** Interface to C language function: <br> <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ +public int gluScaleImage(int format, int wIn, int hIn, int typeIn, float[] dataIn, int wOut, int hOut, int typeOut, float[] dataOut); + +/** Interface to C language function: <br> <code> GLint gluScaleImage(GLenum format, GLsizei wIn, GLsizei hIn, GLenum typeIn, const void * dataIn, GLsizei wOut, GLsizei hOut, GLenum typeOut, GLvoid * dataOut); </code> */ +public int gluScaleImage(int format, int wIn, int hIn, int typeIn, java.nio.Buffer dataIn, int wOut, int hOut, int typeOut, java.nio.Buffer dataOut); + + +//---------------------------------------------------------------------- +// Function availability routines +// + + /** * Returns true if the specified GLU core- or extension-function can be * successfully used through this GLU instance. By "successfully" we mean diff --git a/make/jawt-macosx.cfg b/make/jawt-macosx.cfg index 829e4f80a..ebdbad734 100644 --- a/make/jawt-macosx.cfg +++ b/make/jawt-macosx.cfg @@ -18,6 +18,8 @@ IgnoreField JAWT_DrawingSurfaceInfo platformInfo CustomCCode #include <inttypes.h> CustomCCode #include <jawt.h> +CustomCCode #include </usr/include/machine/types.h> + Import net.java.games.jogl.impl.JAWT_PlatformInfo StructPackage JAWT_MacOSXDrawingSurfaceInfo net.java.games.jogl.impl.macosx EmitStruct JAWT_MacOSXDrawingSurfaceInfo diff --git a/make/jawt-x11.cfg b/make/jawt-x11.cfg index 4161d7d13..5794ed4e0 100644 --- a/make/jawt-x11.cfg +++ b/make/jawt-x11.cfg @@ -7,8 +7,10 @@ JavaOutputDir ../build/gensrc/classes NativeOutputDir ../build/gensrc/native/jogl HierarchicalNativeOutput false Opaque boolean jboolean +Opaque long Drawable Opaque long Display * IgnoreField JAWT GetComponent +IgnoreField JAWT_DrawingSurfaceInfo platformInfo IgnoreField JAWT_X11DrawingSurfaceInfo GetAWTColor CustomCCode #include <inttypes.h> CustomCCode #include <jawt.h> diff --git a/make/stub_includes/macosx/jni_md.h b/make/stub_includes/macosx/jni_md.h index 3c2987529..449786272 100644 --- a/make/stub_includes/macosx/jni_md.h +++ b/make/stub_includes/macosx/jni_md.h @@ -3,7 +3,7 @@ #define JNIIMPORT #define JNICALL -typedef long jint; +typedef int jint; #ifdef _LP64 /* 64-bit Solaris */ typedef long jlong; #else diff --git a/make/stub_includes/macosx/window-system.c b/make/stub_includes/macosx/window-system.c index 4b3f95649..e5ba4307f 100644 --- a/make/stub_includes/macosx/window-system.c +++ b/make/stub_includes/macosx/window-system.c @@ -4,6 +4,7 @@ typedef int Bool; void* createContext(void* shareContext, void* nsView, + int doubleBuffer, int redBits, int greenBits, int blueBits, diff --git a/make/stub_includes/opengl/GL/glext.h b/make/stub_includes/opengl/GL/glext.h index 3c99e777b..36b31d51b 100644 --- a/make/stub_includes/opengl/GL/glext.h +++ b/make/stub_includes/opengl/GL/glext.h @@ -6110,6 +6110,134 @@ typedef void (APIENTRY * PFNGLDRAWBUFFERREGIONPROC) (GLuint region, GLint x, GLi typedef GLuint (APIENTRY * PFNGLBUFFERREGIONENABLEDPROC) (GLvoid); #endif +/* + * Note: (kbr) manually created this definition from the spec at http://www.opengl.org/documentation/extensions/EXT_framebuffer_object.txt + */ +#ifndef GL_EXT_framebuffer_object +#define GL_FRAMEBUFFER_EXT 0x8D40 +#define GL_RENDERBUFFER_EXT 0x8D41 +#define GL_STENCIL_INDEX_EXT 0x8D45 +#define GL_STENCIL_INDEX1_EXT 0x8D46 +#define GL_STENCIL_INDEX4_EXT 0x8D47 +#define GL_STENCIL_INDEX8_EXT 0x8D48 +#define GL_STENCIL_INDEX16_EXT 0x8D49 +#define GL_RENDERBUFFER_WIDTH_EXT 0x8D42 +#define GL_RENDERBUFFER_HEIGHT_EXT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT_EXT 0x8D44 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT 0x8CD4 +#define GL_COLOR_ATTACHMENT0_EXT 0x8CE0 +#define GL_COLOR_ATTACHMENT1_EXT 0x8CE1 +#define GL_COLOR_ATTACHMENT2_EXT 0x8CE2 +#define GL_COLOR_ATTACHMENT3_EXT 0x8CE3 +#define GL_COLOR_ATTACHMENT4_EXT 0x8CE4 +#define GL_COLOR_ATTACHMENT5_EXT 0x8CE5 +#define GL_COLOR_ATTACHMENT6_EXT 0x8CE6 +#define GL_COLOR_ATTACHMENT7_EXT 0x8CE7 +#define GL_COLOR_ATTACHMENT8_EXT 0x8CE8 +#define GL_COLOR_ATTACHMENT9_EXT 0x8CE9 +#define GL_COLOR_ATTACHMENT10_EXT 0x8CEA +#define GL_COLOR_ATTACHMENT11_EXT 0x8CEB +#define GL_COLOR_ATTACHMENT12_EXT 0x8CEC +#define GL_COLOR_ATTACHMENT13_EXT 0x8CED +#define GL_COLOR_ATTACHMENT14_EXT 0x8CEE +#define GL_COLOR_ATTACHMENT15_EXT 0x8CEF +#define GL_DEPTH_ATTACHMENT_EXT 0x8D00 +#define GL_STENCIL_ATTACHMENT_EXT 0x8D20 +#define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT 0x8CD8 +#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT 0x8CD9 +#define GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT 0x8CDA +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED_EXT 0x8CDD +#define GL_FRAMEBUFFER_STATUS_ERROR_EXT 0x8CDE +#define GL_FRAMEBUFFER_BINDING_EXT 0x8CA6 +#define GL_RENDERBUFFER_BINDING_EXT 0x8CA7 +#define GL_MAX_COLOR_ATTACHMENTS_EXT 0x8CDF +#define GL_MAX_RENDERBUFFER_SIZE_EXT 0x84E8 +#define GL_INVALID_FRAMEBUFFER_OPERATION_EXT 0x0506 +#endif + +#ifndef GL_EXT_framebuffer_object +#define GL_EXT_framebuffer_object 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI GLboolean APIENTRY glIsRenderbufferEXT(GLuint renderbuffer); +GLAPI void APIENTRY glBindRenderbufferEXT(GLenum target, GLuint renderbuffer); +GLAPI void APIENTRY glDeleteRenderbuffersEXT(GLsizei n, const GLuint *renderbuffers); +GLAPI void APIENTRY glGenRenderbuffersEXT(GLsizei n, GLuint *renderbuffers); + +GLAPI void APIENTRY glRenderbufferStorageEXT(GLenum target, GLenum internalformat, + GLsizei width, GLsizei height); + +GLAPI void APIENTRY glGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint* params); + +GLAPI GLboolean APIENTRY glIsFramebufferEXT(GLuint framebuffer); +GLAPI void APIENTRY glBindFramebufferEXT(GLenum target, GLuint framebuffer); +GLAPI void APIENTRY glDeleteFramebuffersEXT(GLsizei n, const GLuint *framebuffers); +GLAPI void APIENTRY glGenFramebuffersEXT(GLsizei n, GLuint *framebuffers); + +GLAPI GLenum APIENTRY glCheckFramebufferStatusEXT(GLenum target); + +GLAPI void APIENTRY glFramebufferTexture1DEXT(GLenum target, GLenum attachment, + GLenum textarget, GLuint texture, + GLint level); +GLAPI void APIENTRY glFramebufferTexture2DEXT(GLenum target, GLenum attachment, + GLenum textarget, GLuint texture, + GLint level); +GLAPI void APIENTRY glFramebufferTexture3DEXT(GLenum target, GLenum attachment, + GLenum textarget, GLuint texture, + GLint level, GLint zoffset); + +GLAPI void APIENTRY glFramebufferRenderbufferEXT(GLenum target, GLenum attachment, + GLenum renderbuffertarget, GLuint renderbuffer); + +GLAPI void APIENTRY glGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, + GLenum pname, GLint *params); + +GLAPI void APIENTRY glGenerateMipmapEXT(GLenum target); +#endif +typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFEREXTPROC) (GLuint renderbuffer); +typedef void (APIENTRYP PFNGLBINDRENDERBUFFEREXTPROC) (GLenum target, GLuint renderbuffer); +typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSEXTPROC) (GLsizei n, const GLuint *renderbuffers); +typedef void (APIENTRYP PFNGLGENRENDERBUFFERSEXTPROC) (GLsizei n, GLuint *renderbuffers); + +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEEXTPROC) (GLenum target, GLenum internalformat, + GLsizei width, GLsizei height); + +typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint* params); + +typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFEREXTPROC) (GLuint framebuffer); +typedef void (APIENTRYP PFNGLBINDFRAMEBUFFEREXTPROC) (GLenum target, GLuint framebuffer); +typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSEXTPROC) (GLsizei n, const GLuint *framebuffers); +typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSEXTPROC) (GLsizei n, GLuint *framebuffers); + +typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) (GLenum target); + +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DEXTPROC) (GLenum target, GLenum attachment, + GLenum textarget, GLuint texture, + GLint level); +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) (GLenum target, GLenum attachment, + GLenum textarget, GLuint texture, + GLint level); +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DEXTPROC) (GLenum target, GLenum attachment, + GLenum textarget, GLuint texture, + GLint level, GLint zoffset); + +typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) (GLenum target, GLenum attachment, + GLenum renderbuffertarget, GLuint renderbuffer); + +typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) (GLenum target, GLenum attachment, + GLenum pname, GLint *params); + +typedef void (APIENTRYP PFNGLGENERATEMIPMAPEXTPROC) (GLenum target); +#endif + #ifdef __cplusplus } #endif diff --git a/make/stub_includes/win32/jni_md.h b/make/stub_includes/win32/jni_md.h index c2ccd0d45..0c020e8e9 100644 --- a/make/stub_includes/win32/jni_md.h +++ b/make/stub_includes/win32/jni_md.h @@ -3,7 +3,7 @@ #define JNIIMPORT #define JNICALL -typedef long jint; +typedef int jint; typedef __int64 jlong; typedef signed char jbyte; diff --git a/make/stub_includes/x11/X11/X.h b/make/stub_includes/x11/X11/X.h index 2cd64bbf0..239836ee4 100644 --- a/make/stub_includes/x11/X11/X.h +++ b/make/stub_includes/x11/X11/X.h @@ -1,7 +1,7 @@ #ifndef _X_H_ #define _X_H_ -typedef unsigned long XID; +typedef struct {} * XID; typedef int Bool; typedef struct {} Display; typedef int Status; diff --git a/make/stub_includes/x11/jni_md.h b/make/stub_includes/x11/jni_md.h index 3c2987529..449786272 100644 --- a/make/stub_includes/x11/jni_md.h +++ b/make/stub_includes/x11/jni_md.h @@ -3,7 +3,7 @@ #define JNIIMPORT #define JNICALL -typedef long jint; +typedef int jint; #ifdef _LP64 /* 64-bit Solaris */ typedef long jlong; #else diff --git a/src/native/jogl/BufferUtils.c b/src/native/jogl/BufferUtils.c index d5ea5b36e..7698b00ba 100644 --- a/src/native/jogl/BufferUtils.c +++ b/src/native/jogl/BufferUtils.c @@ -40,8 +40,8 @@ #include <jni.h> #ifdef _MSC_VER - /* This typedef is only needed for VC6 */ - #if _MSC_VER <= 1200 + /* This typedef seems to be needed at least for VC6 and Visual Studio 2003 */ + #if _MSC_VER <= 1400 typedef int intptr_t; #endif #else diff --git a/src/native/jogl/InternalBufferUtils.c b/src/native/jogl/InternalBufferUtils.c index 395396ac8..73c52011f 100644 --- a/src/native/jogl/InternalBufferUtils.c +++ b/src/native/jogl/InternalBufferUtils.c @@ -40,8 +40,8 @@ #include <jni.h> #ifdef _MSC_VER - /* This typedef is only needed for VC6 */ - #if _MSC_VER <= 1200 + /* This typedef seems to be needed at least for VC6 and Visual Studio 2003 */ + #if _MSC_VER <= 1400 typedef int intptr_t; #endif #else diff --git a/src/native/jogl/JAWT_DrawingSurfaceInfo.c b/src/native/jogl/JAWT_DrawingSurfaceInfo.c index 523bfba3e..59c575f0c 100644 --- a/src/native/jogl/JAWT_DrawingSurfaceInfo.c +++ b/src/native/jogl/JAWT_DrawingSurfaceInfo.c @@ -42,7 +42,7 @@ #ifdef WIN32 #define PLATFORM_DSI_SIZE sizeof(JAWT_Win32DrawingSurfaceInfo) static const char* platformDSIClassName = "net/java/games/jogl/impl/windows/JAWT_Win32DrawingSurfaceInfo"; -#elif defined(linux) || defined(__sun) +#elif defined(linux) || defined(__sun) || defined(__FreeBSD__) #define PLATFORM_DSI_SIZE sizeof(JAWT_X11DrawingSurfaceInfo) static const char* platformDSIClassName = "net/java/games/jogl/impl/x11/JAWT_X11DrawingSurfaceInfo"; #elif defined(macosx) diff --git a/src/native/jogl/MacOSXWindowSystemInterface.m b/src/native/jogl/MacOSXWindowSystemInterface.m index c56f6e5bb..afa0fea69 100644 --- a/src/native/jogl/MacOSXWindowSystemInterface.m +++ b/src/native/jogl/MacOSXWindowSystemInterface.m @@ -17,6 +17,7 @@ typedef int Bool; NSAutoreleasePool* gAutoreleasePool = NULL; void* createContext(void* shareContext, void* view, + int doubleBuffer, int redBits, int greenBits, int blueBits, diff --git a/src/net/java/games/gluegen/FunctionEmitter.java b/src/net/java/games/gluegen/FunctionEmitter.java index 097d8d0be..9acde1211 100644 --- a/src/net/java/games/gluegen/FunctionEmitter.java +++ b/src/net/java/games/gluegen/FunctionEmitter.java @@ -59,6 +59,15 @@ public abstract class FunctionEmitter this.defaultOutput = defaultOutput; } + /** + * Makes this FunctionEmitter a copy of the passed one. + */ + public FunctionEmitter(FunctionEmitter arg) { + modifiers = (HashSet) arg.modifiers.clone(); + commentEmitter = arg.commentEmitter; + defaultOutput = arg.defaultOutput; + } + public PrintWriter getDefaultOutput() { return defaultOutput; } public void addModifiers(Iterator/*<EmissionModifier>*/ mi) diff --git a/src/net/java/games/gluegen/GlueGen.java b/src/net/java/games/gluegen/GlueGen.java index 2e5f3421a..6c343a5ee 100644 --- a/src/net/java/games/gluegen/GlueGen.java +++ b/src/net/java/games/gluegen/GlueGen.java @@ -141,7 +141,14 @@ public class GlueGen implements GlueEmitterControls { } HeaderParser headerParser = new HeaderParser(); - MachineDescription machDesc = new MachineDescription32Bit(); + MachineDescription machDesc; + String os = System.getProperty("os.name").toLowerCase(); + String cpu = System.getProperty("os.arch").toLowerCase(); + if (os.startsWith("linux") && cpu.equals("amd64")) { + machDesc = new MachineDescription64Bit(); + } else { + machDesc = new MachineDescription32Bit(); + } headerParser.setMachineDescription(machDesc); TypeDictionary td = new TypeDictionary(); headerParser.setTypedefDictionary(td); diff --git a/src/net/java/games/gluegen/JavaEmitter.java b/src/net/java/games/gluegen/JavaEmitter.java index 00887c333..318c2ad73 100644 --- a/src/net/java/games/gluegen/JavaEmitter.java +++ b/src/net/java/games/gluegen/JavaEmitter.java @@ -264,10 +264,8 @@ public class JavaEmitter implements GlueEmitter { continue; // don't generate bindings for this symbol } - Iterator allBindings = generateMethodBindingEmitters(cFunc); - while (allBindings.hasNext()) { - methodBindingEmitters.add(allBindings.next()); - } + List allBindings = generateMethodBindingEmitters(cFunc); + methodBindingEmitters.addAll(allBindings); } // Emit all the methods @@ -305,7 +303,7 @@ public class JavaEmitter implements GlueEmitter { * Generate all appropriate Java bindings for the specified C function * symbols. */ - protected Iterator generateMethodBindingEmitters(FunctionSymbol sym) throws Exception { + protected List generateMethodBindingEmitters(FunctionSymbol sym) throws Exception { ArrayList/*<FunctionEmitter>*/ allEmitters = new ArrayList(1); @@ -375,7 +373,7 @@ public class JavaEmitter implements GlueEmitter { if (cfg.allStatic()) { entryPoint.addModifier(JavaMethodBindingEmitter.STATIC); } - if (!isUnimplemented && !binding.needsBody()) { + if (!isUnimplemented && !bindingNeedsBody(binding)) { entryPoint.addModifier(JavaMethodBindingEmitter.NATIVE); } entryPoint.setReturnedArrayLengthExpression(cfg.returnedArrayLength(binding.getName())); @@ -395,8 +393,8 @@ public class JavaEmitter implements GlueEmitter { // If the user has stated that the function will be // manually implemented, then don't auto-generate a function body. if (!cfg.manuallyImplement(sym.getName()) && !isUnimplemented) { - if (binding.needsBody()) { - // Generate the method which calls the underlying function + if (bindingNeedsBody(binding)) { + // Generate the method which calls the underlying C function // after unboxing has occurred PrintWriter output = cfg.allStatic() ? javaWriter() : javaImplWriter(); JavaMethodBindingEmitter wrappedEntryPoint = @@ -422,7 +420,7 @@ public class JavaEmitter implements GlueEmitter { "Error while generating bindings for \"" + sym + "\"", e); } - return allEmitters.iterator(); + return allEmitters; } @@ -571,7 +569,7 @@ public class JavaEmitter implements GlueEmitter { JavaMethodBindingEmitter entryPoint = new JavaMethodBindingImplEmitter(binding, writer, cfg.runtimeExceptionType()); entryPoint.addModifier(JavaMethodBindingEmitter.PUBLIC); - if (!binding.needsBody() && !binding.hasContainingType()) { + if (!bindingNeedsBody(binding) && !binding.hasContainingType()) { entryPoint.addModifier(JavaMethodBindingEmitter.NATIVE); } entryPoint.emit(); @@ -676,6 +674,12 @@ public class JavaEmitter implements GlueEmitter { // Internals only below this point // + protected boolean bindingNeedsBody(MethodBinding binding) { + // We need to perform NIO checks and conversions and array length + // checks + return binding.signatureUsesNIO() || binding.signatureUsesCArrays(); + } + private CMethodBindingEmitter makeCEmitter(MethodBinding binding, boolean overloaded, boolean doingImplRoutine, diff --git a/src/net/java/games/gluegen/JavaMethodBindingEmitter.java b/src/net/java/games/gluegen/JavaMethodBindingEmitter.java index 131faae0d..e5b83a26c 100644 --- a/src/net/java/games/gluegen/JavaMethodBindingEmitter.java +++ b/src/net/java/games/gluegen/JavaMethodBindingEmitter.java @@ -66,7 +66,7 @@ public class JavaMethodBindingEmitter extends FunctionEmitter private String runtimeExceptionType; private MethodBinding binding; - private boolean forNIOBufferBaseRoutine; + private boolean forImplementingMethodCall; // A non-null value indicates that rather than returning a compound // type accessor we are returning an array of such accessors; this @@ -80,18 +80,26 @@ public class JavaMethodBindingEmitter extends FunctionEmitter this(binding, output, runtimeExceptionType, false); } - public JavaMethodBindingEmitter(MethodBinding binding, PrintWriter output, String runtimeExceptionType, boolean forNIOBufferBaseRoutine) + public JavaMethodBindingEmitter(MethodBinding binding, PrintWriter output, String runtimeExceptionType, boolean forImplementingMethodCall) { super(output); this.binding = binding; - this.forNIOBufferBaseRoutine = forNIOBufferBaseRoutine; + this.forImplementingMethodCall = forImplementingMethodCall; this.runtimeExceptionType = runtimeExceptionType; setCommentEmitter(defaultInterfaceCommentEmitter); } + public JavaMethodBindingEmitter(JavaMethodBindingEmitter arg) { + super(arg); + runtimeExceptionType = arg.runtimeExceptionType; + binding = arg.binding; + forImplementingMethodCall = arg.forImplementingMethodCall; + returnedArrayLengthExpression = arg.returnedArrayLengthExpression; + } + public final MethodBinding getBinding() { return binding; } - public final boolean isForNIOBufferBaseRoutine() { return forNIOBufferBaseRoutine; } + public boolean isForImplementingMethodCall() { return forImplementingMethodCall; } public String getName() { return binding.getName(); @@ -130,9 +138,10 @@ public class JavaMethodBindingEmitter extends FunctionEmitter protected void emitName(PrintWriter writer) { - writer.print(binding.getName()); - if (forNIOBufferBaseRoutine) { - writer.print("0"); + if (forImplementingMethodCall) { + writer.print(getImplMethodName()); + } else { + writer.print(getName()); } } @@ -141,7 +150,7 @@ public class JavaMethodBindingEmitter extends FunctionEmitter boolean needComma = false; int numEmitted = 0; - if (forNIOBufferBaseRoutine && binding.hasContainingType()) { + if (forImplementingMethodCall && binding.hasContainingType()) { // Always emit outgoing "this" argument writer.print("java.nio.Buffer "); writer.print(javaThisArgumentName()); diff --git a/src/net/java/games/gluegen/JavaMethodBindingImplEmitter.java b/src/net/java/games/gluegen/JavaMethodBindingImplEmitter.java index 2701bc2ec..dc3dfa629 100644 --- a/src/net/java/games/gluegen/JavaMethodBindingImplEmitter.java +++ b/src/net/java/games/gluegen/JavaMethodBindingImplEmitter.java @@ -65,6 +65,13 @@ public class JavaMethodBindingImplEmitter extends JavaMethodBindingEmitter this.isUnimplemented = isUnimplemented; } + public JavaMethodBindingImplEmitter(JavaMethodBindingEmitter arg) { + super(arg); + if (arg instanceof JavaMethodBindingImplEmitter) { + this.isUnimplemented = ((JavaMethodBindingImplEmitter) arg).isUnimplemented; + } + } + protected void emitBody(PrintWriter writer) { MethodBinding binding = getBinding(); @@ -84,8 +91,15 @@ public class JavaMethodBindingImplEmitter extends JavaMethodBindingEmitter } } + protected boolean isUnimplemented() { + return isUnimplemented; + } + protected boolean needsBody() { - return isUnimplemented || getBinding().needsBody() || getBinding().hasContainingType(); + return (isUnimplemented || + getBinding().signatureUsesNIO() || + getBinding().signatureUsesCArrays() || + getBinding().hasContainingType()); } protected void emitPreCallSetup(MethodBinding binding, PrintWriter writer) { diff --git a/src/net/java/games/gluegen/JavaType.java b/src/net/java/games/gluegen/JavaType.java index 2d41a543d..b879187ef 100644 --- a/src/net/java/games/gluegen/JavaType.java +++ b/src/net/java/games/gluegen/JavaType.java @@ -325,6 +325,10 @@ public class JavaType { return ((clazz != null) && !isArray() && clazz.isPrimitive() && (clazz != Void.TYPE)); } + public boolean isPrimitiveArray() { + return (isArray() && (clazz.getComponentType().isPrimitive())); + } + public boolean isVoid() { return (clazz == Void.TYPE); } diff --git a/src/net/java/games/gluegen/MethodBinding.java b/src/net/java/games/gluegen/MethodBinding.java index fd2b7b7bc..b7117185d 100644 --- a/src/net/java/games/gluegen/MethodBinding.java +++ b/src/net/java/games/gluegen/MethodBinding.java @@ -52,8 +52,10 @@ public class MethodBinding { private FunctionSymbol sym; private JavaType javaReturnType; private List javaArgumentTypes; - private boolean computedNeedsBody; - private boolean needsBody; + private boolean computedSignatureProperties; + private boolean signatureUsesNIO; + private boolean signatureUsesCArrays; + private boolean signatureUsesPrimitiveArrays; private JavaType containingType; private Type containingCType; private int thisPointerIndex = -1; @@ -66,13 +68,15 @@ public class MethodBinding { public MethodBinding(MethodBinding bindingToCopy) { this.sym = bindingToCopy.sym; - this.containingType = bindingToCopy.containingType; - this.containingCType = bindingToCopy.containingCType; - this.javaReturnType = bindingToCopy.javaReturnType; - this.javaArgumentTypes = (List)((ArrayList)bindingToCopy.javaArgumentTypes).clone(); - this.computedNeedsBody = bindingToCopy.computedNeedsBody; - this.needsBody = bindingToCopy.needsBody; - this.thisPointerIndex = bindingToCopy.thisPointerIndex; + this.containingType = bindingToCopy.containingType; + this.containingCType = bindingToCopy.containingCType; + this.javaReturnType = bindingToCopy.javaReturnType; + this.javaArgumentTypes = (List)((ArrayList)bindingToCopy.javaArgumentTypes).clone(); + this.computedSignatureProperties = bindingToCopy.computedSignatureProperties; + this.signatureUsesNIO = bindingToCopy.signatureUsesNIO; + this.signatureUsesCArrays = bindingToCopy.signatureUsesCArrays; + this.signatureUsesPrimitiveArrays = bindingToCopy.signatureUsesPrimitiveArrays; + this.thisPointerIndex = bindingToCopy.thisPointerIndex; } /** Constructor for calling a C function. */ @@ -90,7 +94,7 @@ public class MethodBinding { public void setJavaReturnType(JavaType type) { javaReturnType = type; - computedNeedsBody = false; + computedSignatureProperties = false; } public void addJavaArgumentType(JavaType type) { @@ -98,7 +102,7 @@ public class MethodBinding { javaArgumentTypes = new ArrayList(); } javaArgumentTypes.add(type); - computedNeedsBody = false; + computedSignatureProperties = false; } public JavaType getJavaReturnType() { @@ -162,46 +166,86 @@ public class MethodBinding { } return binding; } + + /** + * Returns true if the return type or any of the outgoing arguments + * in the method's signature require conversion or checking due to + * the use of New I/O. + */ + public boolean signatureUsesNIO() { + computeSignatureProperties(); + return signatureUsesNIO; + } + + /** + * Returns true if any of the outgoing arguments in the method's + * signature represent fixed-length C arrays which require length + * checking during the call. + */ + public boolean signatureUsesCArrays() { + computeSignatureProperties(); + return signatureUsesCArrays; + } + + /** + * Returns true if any of the outgoing arguments in the method's + * signature represent primitive arrays which require a + * GetPrimitiveArrayCritical or similar operation during the call. + */ + public boolean signatureUsesPrimitiveArrays() { + computeSignatureProperties(); + return signatureUsesPrimitiveArrays; + } + /** - * Returns true if this method needs a special implementation to wrap and/or - * set the byte order of its arguments or return type (i.e., needs special - * pre-processing of the data passed to the native function, or - * post-processing of the data returned from the native function). <P> - * - * Returns false if this binding can be implemented via a one-to-one - * correspondence between a Java method and its native implementation. + * Computes summary information about the method's C and Java + * signatures. */ - public boolean needsBody() { - if (!computedNeedsBody) { - if (javaReturnType.isCompoundTypeWrapper() || - javaReturnType.isNIOByteBuffer() || - javaReturnType.isArrayOfCompoundTypeWrappers()) { - // Needs wrapping and/or setting of byte order (neither of - // which can be done easily from native code) - needsBody = true; - } else { - for (int i = 0; i < getNumArguments(); i++) { - JavaType javaArgType = getJavaArgumentType(i); - Type cArgType = getCArgumentType(i); - if (javaArgType.isCompoundTypeWrapper() || - javaArgType.isNIOBuffer() || - cArgType.isArray() || - javaArgType.isNIOBufferArray()) { - // Needs unwrapping of accessors, checking of array - // lengths, or checking of direct buffer property - needsBody = true; - break; - } - } + protected void computeSignatureProperties() { + if (computedSignatureProperties) + return; + + signatureUsesNIO = false; + signatureUsesCArrays = false; + signatureUsesPrimitiveArrays = false; + + if (javaReturnType.isCompoundTypeWrapper() || + javaReturnType.isNIOByteBuffer() || + javaReturnType.isArrayOfCompoundTypeWrappers()) { + // Needs wrapping and/or setting of byte order (neither of + // which can be done easily from native code) + signatureUsesNIO = true; + } + + for (int i = 0; i < getNumArguments(); i++) { + JavaType javaArgType = getJavaArgumentType(i); + Type cArgType = getCArgumentType(i); + if (javaArgType.isCompoundTypeWrapper() || + javaArgType.isNIOBuffer() || + javaArgType.isNIOBufferArray()) { + // Needs unwrapping of accessors or checking of direct + // buffer property + signatureUsesNIO = true; + } + + if (cArgType.isArray()) { + // Needs checking of array lengths + signatureUsesCArrays = true; + } + + if (javaArgType.isPrimitiveArray()) { + // Needs getPrimitiveArrayCritical or similar construct + // depending on native code calling convention + signatureUsesPrimitiveArrays = true; } - computedNeedsBody = true; } - return needsBody; + computedSignatureProperties = true; } + public MethodBinding createNIOBufferVariant() { - if (!needsBody()) { + if (!signatureUsesNIO()) { return this; } MethodBinding binding = new MethodBinding(sym, containingType, containingCType); diff --git a/src/net/java/games/gluegen/StructLayout.java b/src/net/java/games/gluegen/StructLayout.java index 4f5b76f1c..ebbace6b5 100644 --- a/src/net/java/games/gluegen/StructLayout.java +++ b/src/net/java/games/gluegen/StructLayout.java @@ -123,9 +123,11 @@ public class StructLayout { String cpu = System.getProperty("os.arch").toLowerCase(); if ((os.startsWith("windows") && cpu.equals("x86")) || (os.startsWith("linux") && cpu.equals("i386")) || + (os.startsWith("linux") && cpu.equals("amd64")) || (os.startsWith("sunos") && cpu.equals("sparc")) || - (os.startsWith("sunos") && cpu.equals("x86"))|| - (os.startsWith("mac os") && cpu.equals("ppc")) + (os.startsWith("sunos") && cpu.equals("x86")) || + (os.startsWith("mac os") && cpu.equals("ppc")) || + (os.startsWith("freebsd") && cpu.equals("i386")) ) { // FIXME: make struct alignment configurable? May need to change // packing rules on a per-type basis? diff --git a/src/net/java/games/gluegen/opengl/GLEmitter.java b/src/net/java/games/gluegen/opengl/GLEmitter.java index 861e85bb7..d30f145ab 100644 --- a/src/net/java/games/gluegen/opengl/GLEmitter.java +++ b/src/net/java/games/gluegen/opengl/GLEmitter.java @@ -93,14 +93,27 @@ public class GLEmitter extends JavaEmitter return new GLConfiguration(); } - protected Iterator generateMethodBindingEmitters(FunctionSymbol sym) throws Exception + protected List generateMethodBindingEmitters(FunctionSymbol sym) throws Exception { - Iterator defaultEmitters = super.generateMethodBindingEmitters(sym); + return generateMethodBindingEmittersImpl(sym); + } + + protected List generateMethodBindingEmitters(FunctionSymbol sym, boolean skipProcessing) throws Exception { + if (skipProcessing) { + return super.generateMethodBindingEmitters(sym); + } else { + return generateMethodBindingEmittersImpl(sym); + } + } + + private List generateMethodBindingEmittersImpl(FunctionSymbol sym) throws Exception + { + List defaultEmitters = super.generateMethodBindingEmitters(sym); // if the superclass didn't generate any bindings for the symbol, let's // honor that (for example, the superclass might have caught an Ignore // direction that matched the symbol's name). - if (!defaultEmitters.hasNext()) + if (defaultEmitters.isEmpty()) { return defaultEmitters; } @@ -121,9 +134,9 @@ public class GLEmitter extends JavaEmitter emitGLProcAddressTableEntryForSymbol(sym); } - while (defaultEmitters.hasNext()) + for (Iterator iter = defaultEmitters.iterator(); iter.hasNext(); ) { - FunctionEmitter emitter = (FunctionEmitter)defaultEmitters.next(); + FunctionEmitter emitter = (FunctionEmitter) iter.next(); if (emitter instanceof JavaMethodBindingEmitter) { JavaMethodBindingEmitter newEmitter = @@ -144,7 +157,7 @@ public class GLEmitter extends JavaEmitter } } - return modifiedEmitters.iterator(); + return modifiedEmitters; } /** @@ -168,7 +181,7 @@ public class GLEmitter extends JavaEmitter // Internals only below this point // - private JavaMethodBindingEmitter generateModifiedEmitter(JavaMethodBindingEmitter baseJavaEmitter) + protected JavaMethodBindingEmitter generateModifiedEmitter(JavaMethodBindingEmitter baseJavaEmitter) { if (!(baseJavaEmitter instanceof JavaMethodBindingImplEmitter)) { // We only want to wrap the native entry point in the implementation @@ -178,7 +191,7 @@ public class GLEmitter extends JavaEmitter // it needs argument conversion or similar, filter that out since we will // be providing such an emitter ourselves. Otherwise return the emitter // unmodified. - if (baseJavaEmitter.isForNIOBufferBaseRoutine()) + if (baseJavaEmitter.isForImplementingMethodCall()) return null; return baseJavaEmitter; } @@ -189,7 +202,7 @@ public class GLEmitter extends JavaEmitter return new JavaGLPAWrapperEmitter(baseJavaEmitter, getGLConfig().getProcAddressTableExpr()); } - private CMethodBindingEmitter generateModifiedEmitter(CMethodBindingEmitter baseCEmitter) + protected CMethodBindingEmitter generateModifiedEmitter(CMethodBindingEmitter baseCEmitter) { // The C-side JNI binding for this particular function will have an // extra final argument, which is the address (the OpenGL procedure @@ -202,7 +215,7 @@ public class GLEmitter extends JavaEmitter return res; } - private boolean needsProcAddressWrapper(FunctionSymbol sym) + protected boolean needsProcAddressWrapper(FunctionSymbol sym) { String symName = sym.getName(); @@ -275,6 +288,10 @@ public class GLEmitter extends JavaEmitter tableWriter.println("public class " + tableClassName); tableWriter.println("{"); numProcAddressEntries = 0; + + for (Iterator iter = getGLConfig().getForceProcAddressGen().iterator(); iter.hasNext(); ) { + emitGLProcAddressTableEntryForString((String) iter.next()); + } } private void endGLProcAddressTable() throws Exception @@ -316,16 +333,21 @@ public class GLEmitter extends JavaEmitter w.close(); } - private void emitGLProcAddressTableEntryForSymbol(FunctionSymbol cFunc) + protected void emitGLProcAddressTableEntryForSymbol(FunctionSymbol cFunc) + { + emitGLProcAddressTableEntryForString(cFunc.getName()); + } + + protected void emitGLProcAddressTableEntryForString(String str) { tableWriter.print(" public long "); tableWriter.print(PROCADDRESS_VAR_PREFIX); - tableWriter.print(cFunc.getName()); + tableWriter.print(str); tableWriter.println(";"); ++numProcAddressEntries; } - private GLConfiguration getGLConfig() { + protected GLConfiguration getGLConfig() { return (GLConfiguration) getConfig(); } @@ -335,6 +357,7 @@ public class GLEmitter extends JavaEmitter private String tableClassPackage; private String tableClassName = "ProcAddressTable"; private Set/*<String>*/ skipProcAddressGen = new HashSet(); + private List/*<String>*/ forceProcAddressGen = new ArrayList(); private String contextVariableName = "context"; private String defaultGetProcAddressTableExpr = ".getGLProcAddressTable()"; private String getProcAddressTableExpr; @@ -358,6 +381,11 @@ public class GLEmitter extends JavaEmitter String sym = readString("SkipProcAddressGen", tok, filename, lineNo); skipProcAddressGen.add(sym); } + else if (cmd.equalsIgnoreCase("ForceProcAddressGen")) + { + String sym = readString("ForceProcAddressGen", tok, filename, lineNo); + forceProcAddressGen.add(sym); + } else if (cmd.equalsIgnoreCase("ContextVariableName")) { contextVariableName = readString("ContextVariableName", tok, filename, lineNo); @@ -386,6 +414,7 @@ public class GLEmitter extends JavaEmitter public String tableClassPackage() { return tableClassPackage; } public String tableClassName() { return tableClassName; } public boolean skipProcAddressGen (String name) { return skipProcAddressGen.contains(name); } + public List getForceProcAddressGen() { return forceProcAddressGen; } public String contextVariableName() { return contextVariableName; } public String getProcAddressTableExpr() { if (getProcAddressTableExpr == null) { diff --git a/src/net/java/games/gluegen/opengl/JavaGLPAWrapperEmitter.java b/src/net/java/games/gluegen/opengl/JavaGLPAWrapperEmitter.java index 4fb50ea21..1bb06b791 100644 --- a/src/net/java/games/gluegen/opengl/JavaGLPAWrapperEmitter.java +++ b/src/net/java/games/gluegen/opengl/JavaGLPAWrapperEmitter.java @@ -151,7 +151,6 @@ public class JavaGLPAWrapperEmitter extends JavaMethodBindingImplEmitter protected void emitPreCallSetup(MethodBinding binding, PrintWriter writer) { super.emitPreCallSetup(binding, writer); - JavaType returnType = binding.getJavaReturnType(); MethodBinding wrappedBinding = emitterBeingWrapped.getBinding(); String procAddressVariable = diff --git a/src/net/java/games/jogl/Animator.java b/src/net/java/games/jogl/Animator.java index 3f5bfdeb2..4c50b9362 100644 --- a/src/net/java/games/jogl/Animator.java +++ b/src/net/java/games/jogl/Animator.java @@ -145,8 +145,7 @@ public class Animator { // dependencies on the Animator's internal thread. Currently we // use a couple of heuristics to determine whether we should do // the blocking wait(). - if ((Thread.currentThread() == thread) || - (SingleThreadedWorkaround.doWorkaround() && EventQueue.isDispatchThread())) { + if ((Thread.currentThread() == thread) || EventQueue.isDispatchThread()) { return; } while (shouldStop && thread != null) { diff --git a/src/net/java/games/jogl/DefaultGLCapabilitiesChooser.java b/src/net/java/games/jogl/DefaultGLCapabilitiesChooser.java index 8d5ecabc9..9cac4f83a 100644 --- a/src/net/java/games/jogl/DefaultGLCapabilitiesChooser.java +++ b/src/net/java/games/jogl/DefaultGLCapabilitiesChooser.java @@ -39,6 +39,8 @@ package net.java.games.jogl; +import net.java.games.jogl.impl.Debug; + /** <P> The default implementation of the {@link GLCapabilitiesChooser} interface, which provides consistent visual selection behavior across platforms. The precise algorithm is @@ -78,11 +80,17 @@ package net.java.games.jogl; */ public class DefaultGLCapabilitiesChooser implements GLCapabilitiesChooser { - private static final boolean DEBUG = false; + private static final boolean DEBUG = Debug.debug("DefaultGLCapabilitiesChooser"); public int chooseCapabilities(GLCapabilities desired, GLCapabilities[] available, int windowSystemRecommendedChoice) { + if (DEBUG) { + for (int i = 0; i < available.length; i++) { + System.err.println("Available " + i + ": " + available[i]); + } + } + if (windowSystemRecommendedChoice >= 0 && windowSystemRecommendedChoice < available.length && available[windowSystemRecommendedChoice] != null) { @@ -93,12 +101,6 @@ public class DefaultGLCapabilitiesChooser implements GLCapabilitiesChooser { return windowSystemRecommendedChoice; } - if (DEBUG) { - for (int i = 0; i < available.length; i++) { - System.err.println("Available " + i + ": " + available[i]); - } - } - // Create score array int[] scores = new int[available.length]; int NO_SCORE = -9999999; diff --git a/src/net/java/games/jogl/GLCanvas.java b/src/net/java/games/jogl/GLCanvas.java index 1deac7f32..17aed5bea 100644 --- a/src/net/java/games/jogl/GLCanvas.java +++ b/src/net/java/games/jogl/GLCanvas.java @@ -72,7 +72,9 @@ public final class GLCanvas extends Canvas implements GLDrawable { } public void display() { - displayImpl(); + maybeDoSingleThreadedWorkaround(displayOnEventDispatchThreadAction, + displayAction, + false); } /** Overridden from Canvas; calls {@link #display}. Should not be @@ -109,12 +111,18 @@ public final class GLCanvas extends Canvas implements GLDrawable { final int fy = 0; final int fwidth = width; final int fheight = height; - context.invokeGL(new Runnable() { + final Runnable reshapeRunnable = new Runnable() { public void run() { getGL().glViewport(fx, fy, fwidth, fheight); drawableHelper.reshape(GLCanvas.this, fx, fy, fwidth, fheight); } - }, true, initAction); + }; + final Runnable reshapeOnEDTRunnable = new Runnable() { + public void run() { + context.invokeGL(reshapeRunnable, true, initAction); + } + }; + maybeDoSingleThreadedWorkaround(reshapeOnEDTRunnable, reshapeRunnable, true); } /** Overridden from Canvas to prevent Java2D's clearing of the @@ -176,7 +184,7 @@ public final class GLCanvas extends Canvas implements GLDrawable { } public void swapBuffers() { - context.invokeGL(swapBuffersAction, false, initAction); + maybeDoSingleThreadedWorkaround(swapBuffersOnEventDispatchThreadAction, swapBuffersAction, false); } public boolean canCreateOffscreenDrawable() { @@ -197,15 +205,27 @@ public final class GLCanvas extends Canvas implements GLDrawable { // Internals only below this point // - private void displayImpl() { + private void maybeDoSingleThreadedWorkaround(Runnable eventDispatchThreadAction, + Runnable invokeGLAction, + boolean isReshape) { if (SingleThreadedWorkaround.doWorkaround() && !EventQueue.isDispatchThread()) { try { - EventQueue.invokeAndWait(displayOnEventDispatchThreadAction); + // Reshape events must not block on the event queue due to the + // possibility of deadlocks during initial component creation. + // This solution is not optimal, because it changes the + // semantics of reshape() to have some of the processing being + // done asynchronously, but at least it preserves the + // semantics of the single-threaded workaround. + if (!isReshape) { + EventQueue.invokeAndWait(eventDispatchThreadAction); + } else { + EventQueue.invokeLater(eventDispatchThreadAction); + } } catch (Exception e) { throw new GLException(e); } } else { - context.invokeGL(displayAction, false, initAction); + context.invokeGL(invokeGLAction, isReshape, initAction); } } @@ -240,4 +260,11 @@ public final class GLCanvas extends Canvas implements GLDrawable { } private DisplayOnEventDispatchThreadAction displayOnEventDispatchThreadAction = new DisplayOnEventDispatchThreadAction(); + class SwapBuffersOnEventDispatchThreadAction implements Runnable { + public void run() { + context.invokeGL(swapBuffersAction, false, initAction); + } + } + private SwapBuffersOnEventDispatchThreadAction swapBuffersOnEventDispatchThreadAction = + new SwapBuffersOnEventDispatchThreadAction(); } diff --git a/src/net/java/games/jogl/GLCapabilities.java b/src/net/java/games/jogl/GLCapabilities.java index 5095c802a..794f152f6 100644 --- a/src/net/java/games/jogl/GLCapabilities.java +++ b/src/net/java/games/jogl/GLCapabilities.java @@ -75,8 +75,12 @@ public class GLCapabilities implements Cloneable { */ public GLCapabilities() {} - public Object clone() throws CloneNotSupportedException { - return super.clone(); + public Object clone() { + try { + return super.clone(); + } catch (CloneNotSupportedException e) { + throw new GLException(e); + } } /** Indicates whether double-buffering is enabled. */ diff --git a/src/net/java/games/jogl/GLDrawable.java b/src/net/java/games/jogl/GLDrawable.java index aadc2b4fc..7c671c0b2 100644 --- a/src/net/java/games/jogl/GLDrawable.java +++ b/src/net/java/games/jogl/GLDrawable.java @@ -190,7 +190,9 @@ public interface GLDrawable extends ComponentEvents { /** Indicates whether this drawable is capable of fabricating a subordinate offscreen drawable for advanced rendering techniques - which require offscreen hardware-accelerated surfaces. */ + which require offscreen hardware-accelerated surfaces. Note that + this method is only guaranteed to return a correct result once + your GLEventListener's init() method has been called. */ public boolean canCreateOffscreenDrawable(); /** Creates a subordinate offscreen drawable (pbuffer) for this diff --git a/src/net/java/games/jogl/GLJPanel.java b/src/net/java/games/jogl/GLJPanel.java index 3ac5c984c..425160494 100644 --- a/src/net/java/games/jogl/GLJPanel.java +++ b/src/net/java/games/jogl/GLJPanel.java @@ -40,12 +40,15 @@ package net.java.games.jogl; import java.awt.Component; +import java.awt.EventQueue; +import java.awt.Frame; import java.awt.Graphics; import java.awt.GraphicsConfiguration; import java.awt.Rectangle; import java.awt.image.BufferedImage; import java.awt.image.DataBufferByte; import java.awt.image.DataBufferInt; +import java.security.*; import javax.swing.JComponent; import javax.swing.JPanel; import net.java.games.jogl.impl.*; @@ -57,28 +60,47 @@ import net.java.games.jogl.impl.*; /** A lightweight Swing component which provides OpenGL rendering support. Provided for compatibility with Swing user interfaces when adding a heavyweight doesn't work either because of - Z-ordering or LayoutManager problems. Currently implemented using - offscreen (i.e., non-hardware accelerated) rendering, so - performance will likely be poor. This class can not be + Z-ordering or LayoutManager problems. This component attempts to + use hardware-accelerated rendering via pbuffers and falls back on + to software rendering if problems occur. This class can not be instantiated directly; use {@link GLDrawableFactory} to construct them. */ public final class GLJPanel extends JPanel implements GLDrawable { private GLDrawableHelper drawableHelper = new GLDrawableHelper(); - private GLContext context; - private BufferedImage offscreenImage; - private int awtFormat; - private int glFormat; - private int glType; - private int glComps; + + // Data used for either pbuffers or pixmap-based offscreen surfaces + private GLCapabilities offscreenCaps; + private GLCapabilitiesChooser chooser; + private GLDrawable shareWith; + private BufferedImage offscreenImage; + private int neededOffscreenImageWidth; + private int neededOffscreenImageHeight; private DataBufferByte dbByte; private DataBufferInt dbInt; private Object semaphore = new Object(); - private boolean repaintDone; + private int panelWidth = 0; + private int panelHeight = 0; + private Updater updater; + private int awtFormat; + private int glFormat; + private int glType; + + // Implementation using pbuffers + private static boolean hardwareAccelerationDisabled = + Debug.isPropertyDefined("jogl.gljpanel.nohw"); + private boolean pbufferInitializationCompleted; + private GLPbuffer pbuffer; + private int pbufferWidth = 256; + private int pbufferHeight = 256; + private GLCanvas heavyweight; + private Frame toplevel; + + // Implementation using software rendering + private GLContext offscreenContext; // For saving/restoring of OpenGL state during ReadPixels private int[] swapbytes = new int[1]; - private int[] lsbfirst = new int[1]; private int[] rowlength = new int[1]; private int[] skiprows = new int[1]; private int[] skippixels = new int[1]; @@ -86,31 +108,76 @@ public final class GLJPanel extends JPanel implements GLDrawable { GLJPanel(GLCapabilities capabilities, GLCapabilitiesChooser chooser, GLDrawable shareWith) { super(); - context = GLContextFactory.getFactory().createGLContext(null, capabilities, chooser, - GLContextHelper.getContext(shareWith)); + + // Works around problems on many vendors' cards; we don't need a + // back buffer for the offscreen surface anyway + offscreenCaps = (GLCapabilities) capabilities.clone(); + offscreenCaps.setDoubleBuffered(false); + this.chooser = chooser; + this.shareWith = shareWith; + + initialize(); } public void display() { - // Multithreaded redrawing of Swing components is not allowed - try { - synchronized(semaphore) { - repaintDone = false; - repaint(); - while (!repaintDone) { - semaphore.wait(); + if (EventQueue.isDispatchThread()) { + // Want display() to be synchronous, so call paintImmediately() + paintImmediately(0, 0, getWidth(), getHeight()); + } else { + // Multithreaded redrawing of Swing components is not allowed, + // so do everything on the event dispatch thread + try { + // Wait a reasonable period of time for the repaint to + // complete, so that we don't swamp the AWT event queue thread + // with repaint requests. We used to have an explicit flag to + // detect when the repaint completed; unfortunately, under + // some circumstances, the top-level window can be torn down + // while we're waiting for the repaint to complete, which will + // never happen. It doesn't look like there's enough + // information in the EventQueue to figure out whether there + // are pending events without posting to the queue, which we + // don't want to do during shutdown, and adding a + // HierarchyListener and watching for displayability events + // might be fragile since we don't know exactly how this + // component will be used in users' applications. For these + // reasons we simply wait up to a brief period of time for the + // repaint to complete. + synchronized(semaphore) { + repaint(); + semaphore.wait(100); } + } catch (InterruptedException e) { } - } catch (InterruptedException e) { } } - /** Overridden from JComponent; calls {@link #display}. Should not - be invoked by applications directly. */ + /** Overridden from JComponent; calls {@link + GLEventListener#display}. Should not be invoked by applications + directly. */ public void paintComponent(Graphics g) { - displayAction.setGraphics(g); - context.invokeGL(displayAction, false, initAction); + updater.setGraphics(g); + if (!hardwareAccelerationDisabled) { + if (!pbufferInitializationCompleted) { + try { + heavyweight.display(); + pbuffer.display(); + } catch (GLException e) { + // We consider any exception thrown during updating of the + // heavyweight or pbuffer during the initialization phases + // to be an indication that there was a problem + // instantiating the pbuffer, regardless of whether the + // exception originated in the user's GLEventListener. In + // these cases we immediately back off and use software + // rendering. + disableHardwareRendering(); + } + } else { + pbuffer.display(); + } + } else { + offscreenContext.invokeGL(displayAction, false, initAction); + } synchronized(semaphore) { - repaintDone = true; semaphore.notifyAll(); } } @@ -121,25 +188,74 @@ public final class GLJPanel extends JPanel implements GLDrawable { directly. */ public void reshape(int x, int y, int width, int height) { super.reshape(x, y, width, height); - // NOTE: we don't pay attention to the x and y provided since we - // are blitting into this component directly - final int fx = 0; - final int fy = 0; - final int fwidth = width; + + // Move all reshape requests onto AWT EventQueue thread + final int fx = x; + final int fy = y; + final int fwidth = width; final int fheight = height; - context.resizeOffscreenContext(width, height); - context.invokeGL(new Runnable() { + + Runnable r = new Runnable() { public void run() { - getGL().glViewport(fx, fy, fwidth, fheight); - drawableHelper.reshape(GLJPanel.this, fx, fy, fwidth, fheight); + GLContext context = null; + neededOffscreenImageWidth = 0; + neededOffscreenImageHeight = 0; + + if (!hardwareAccelerationDisabled) { + if (fwidth > pbufferWidth || fheight > pbufferHeight) { + // Must destroy and recreate pbuffer to fit + pbuffer.destroy(); + if (fwidth > pbufferWidth) { + pbufferWidth = getNextPowerOf2(fwidth); + } + if (fheight > pbufferHeight) { + pbufferHeight = getNextPowerOf2(fheight); + } + initialize(); + } + GLPbufferImpl pbufferImpl = (GLPbufferImpl) pbuffer; + context = pbufferImpl.getContext(); + // It looks like NVidia's drivers (at least the ones on my + // notebook) are buggy and don't allow a rectangle of less than + // the pbuffer's width to be read...this doesn't really matter + // because it's the Graphics.drawImage() calls that are the + // bottleneck. Should probably make the size of the offscreen + // image be the exact size of the pbuffer to save some work on + // resize operations... + neededOffscreenImageWidth = pbufferWidth; + neededOffscreenImageHeight = fheight; + } else { + offscreenContext.resizeOffscreenContext(fwidth, fheight); + context = offscreenContext; + neededOffscreenImageWidth = fwidth; + neededOffscreenImageHeight = fheight; + } + if (offscreenImage != null && - (offscreenImage.getWidth() != context.getOffscreenContextWidth() || - offscreenImage.getHeight() != context.getOffscreenContextHeight())) { + (offscreenImage.getWidth() != neededOffscreenImageWidth || + offscreenImage.getHeight() != neededOffscreenImageHeight)) { offscreenImage.flush(); offscreenImage = null; } + + panelWidth = fwidth; + panelHeight = fheight; + + context.invokeGL(new Runnable() { + public void run() { + getGL().glViewport(0, 0, panelWidth, panelHeight); + drawableHelper.reshape(GLJPanel.this, 0, 0, panelWidth, panelHeight); + } + }, true, initAction); } - }, true, initAction); + }; + if (EventQueue.isDispatchThread()) { + r.run(); + } else { + // Avoid blocking EventQueue thread due to possible deadlocks + // during component creation + EventQueue.invokeLater(r); + } } public void addGLEventListener(GLEventListener listener) { @@ -151,19 +267,35 @@ public final class GLJPanel extends JPanel implements GLDrawable { } public GL getGL() { - return context.getGL(); + if (!hardwareAccelerationDisabled) { + return pbuffer.getGL(); + } else { + return offscreenContext.getGL(); + } } public void setGL(GL gl) { - context.setGL(gl); + if (!hardwareAccelerationDisabled) { + pbuffer.setGL(gl); + } else { + offscreenContext.setGL(gl); + } } public GLU getGLU() { - return context.getGLU(); + if (!hardwareAccelerationDisabled) { + return pbuffer.getGLU(); + } else { + return offscreenContext.getGLU(); + } } public void setGLU(GLU glu) { - context.setGLU(glu); + if (!hardwareAccelerationDisabled) { + pbuffer.setGLU(glu); + } else { + offscreenContext.setGLU(glu); + } } public void setRenderingThread(Thread currentThreadOrNull) throws GLException { @@ -172,7 +304,7 @@ public final class GLJPanel extends JPanel implements GLDrawable { } public Thread getRenderingThread() { - return context.getRenderingThread(); + return null; } public void setNoAutoRedrawMode(boolean noAutoRedraws) { @@ -183,21 +315,32 @@ public final class GLJPanel extends JPanel implements GLDrawable { } public void setAutoSwapBufferMode(boolean onOrOff) { - context.setAutoSwapBufferMode(onOrOff); + if (!hardwareAccelerationDisabled) { + pbuffer.setAutoSwapBufferMode(onOrOff); + } else { + offscreenContext.setAutoSwapBufferMode(onOrOff); + } } public boolean getAutoSwapBufferMode() { - return context.getAutoSwapBufferMode(); + if (!hardwareAccelerationDisabled) { + return pbuffer.getAutoSwapBufferMode(); + } else { + return offscreenContext.getAutoSwapBufferMode(); + } } public void swapBuffers() { - context.invokeGL(swapBuffersAction, false, initAction); + if (!hardwareAccelerationDisabled) { + pbuffer.swapBuffers(); + } else { + offscreenContext.invokeGL(swapBuffersAction, false, initAction); + } } public boolean canCreateOffscreenDrawable() { - // For now let's say no; maybe we can reimplement this class in - // terms of pbuffers (though not all vendors support them, and - // they seem to require an onscreen context) + // For now let's say no, although we could using the heavyweight + // if hardware acceleration is still enabled return false; } @@ -208,119 +351,259 @@ public final class GLJPanel extends JPanel implements GLDrawable { } GLContext getContext() { - return context; + if (!hardwareAccelerationDisabled) { + return ((GLPbufferImpl) pbuffer).getContext(); + } else { + return offscreenContext; + } } //---------------------------------------------------------------------- // Internals only below this point // - class InitAction implements Runnable { - public void run() { - drawableHelper.init(GLJPanel.this); + private void disableHardwareRendering() { + if (Debug.verbose()) { + System.err.println("GLJPanel: Falling back on software rendering due to pbuffer problems"); } + hardwareAccelerationDisabled = true; + pbufferInitializationCompleted = false; + EventQueue.invokeLater(new Runnable() { + public void run() { + toplevel.setVisible(false); + // Should dispose of this -- not sure about stability on + // various cards -- should test (FIXME) + // toplevel.dispose(); + } + }); + initialize(); } - private InitAction initAction = new InitAction(); - - class DisplayAction implements Runnable { + + private void initialize() { + // Initialize either the hardware-accelerated rendering path or + // the lightweight rendering path + if (!hardwareAccelerationDisabled) { + boolean firstTime = false; + if (heavyweight == null) { + // Make the heavyweight share with the "shareWith" parameter. + // The pbuffer shares textures and display lists with the + // heavyweight, so by transitivity the pbuffer will share with + // it as well. + heavyweight = GLDrawableFactory.getFactory().createGLCanvas(new GLCapabilities(), shareWith); + firstTime = true; + } + if (heavyweight.canCreateOffscreenDrawable()) { + if (firstTime) { + toplevel = new Frame(); + toplevel.setUndecorated(true); + } + pbuffer = heavyweight.createOffscreenDrawable(offscreenCaps, pbufferWidth, pbufferHeight); + updater = new Updater(); + pbuffer.addGLEventListener(updater); + pbufferInitializationCompleted = false; + if (firstTime) { + toplevel.add(heavyweight); + toplevel.setSize(0, 0); + } + EventQueue.invokeLater(new Runnable() { + public void run() { + try { + toplevel.setVisible(true); + } catch (GLException e) { + disableHardwareRendering(); + } + } + }); + return; + } else { + // If the heavyweight reports that it can't create an + // offscreen drawable (pbuffer), don't try again the next + // time, and fall through to the software rendering path + hardwareAccelerationDisabled = true; + } + } + + // Create an offscreen context instead + offscreenContext = GLContextFactory.getFactory().createGLContext(null, offscreenCaps, chooser, + GLContextHelper.getContext(shareWith)); + offscreenContext.resizeOffscreenContext(panelWidth, panelHeight); + updater = new Updater(); + if (panelWidth > 0 && panelHeight > 0) { + offscreenContext.invokeGL(new Runnable() { + public void run() { + getGL().glViewport(0, 0, panelWidth, panelHeight); + drawableHelper.reshape(GLJPanel.this, 0, 0, panelWidth, panelHeight); + } + }, true, initAction); + } + } + + class Updater implements GLEventListener { private Graphics g; public void setGraphics(Graphics g) { this.g = g; } - public void run() { + public void init(GLDrawable drawable) { + if (!hardwareAccelerationDisabled) { + pbufferInitializationCompleted = true; + EventQueue.invokeLater(new Runnable() { + public void run() { + toplevel.setVisible(false); + } + }); + } + drawableHelper.init(GLJPanel.this); + } + + public void display(GLDrawable drawable) { drawableHelper.display(GLJPanel.this); + // Must now copy pixels from offscreen context into surface if (offscreenImage == null) { - int awtFormat = context.getOffscreenContextBufferedImageType(); - offscreenImage = new BufferedImage(context.getOffscreenContextWidth(), context.getOffscreenContextHeight(), awtFormat); - switch (awtFormat) { - case BufferedImage.TYPE_3BYTE_BGR: - glFormat = GL.GL_BGR; - glType = GL.GL_UNSIGNED_BYTE; - glComps = 3; - dbByte = (DataBufferByte) offscreenImage.getRaster().getDataBuffer(); - break; - - case BufferedImage.TYPE_INT_RGB: - glFormat = GL.GL_BGRA; - glType = GL.GL_UNSIGNED_BYTE; - glComps = 4; - dbInt = (DataBufferInt) offscreenImage.getRaster().getDataBuffer(); - break; - - case BufferedImage.TYPE_INT_ARGB: - glFormat = GL.GL_BGRA; - glType = context.getOffscreenContextPixelDataType(); - glComps = 4; - dbInt = (DataBufferInt) offscreenImage.getRaster().getDataBuffer(); - break; - - default: - // FIXME: Support more off-screen image types (current - // offscreen context implementations don't use others, and - // some of the OpenGL formats aren't supported in the 1.1 - // headers, which we're currently using) - throw new GLException("Unsupported offscreen image type " + awtFormat); + if (panelWidth > 0 && panelHeight > 0) { + // It looks like NVidia's drivers (at least the ones on my + // notebook) are buggy and don't allow a sub-rectangle to be + // read from a pbuffer...this doesn't really matter because + // it's the Graphics.drawImage() calls that are the + // bottleneck + + int awtFormat = 0; + int hwGLFormat = 0; + if (!hardwareAccelerationDisabled) { + // Should be more flexible in these BufferedImage formats; + // perhaps see what the preferred image types are on the + // given platform + if (offscreenCaps.getAlphaBits() > 0) { + awtFormat = BufferedImage.TYPE_INT_ARGB; + } else { + awtFormat = BufferedImage.TYPE_INT_RGB; + } + + // This seems to be a good choice on all platforms + hwGLFormat = GL.GL_UNSIGNED_INT_8_8_8_8_REV; + } else { + awtFormat = offscreenContext.getOffscreenContextBufferedImageType(); + } + + offscreenImage = new BufferedImage(neededOffscreenImageWidth, + neededOffscreenImageHeight, + awtFormat); + switch (awtFormat) { + case BufferedImage.TYPE_3BYTE_BGR: + glFormat = GL.GL_BGR; + glType = GL.GL_UNSIGNED_BYTE; + dbByte = (DataBufferByte) offscreenImage.getRaster().getDataBuffer(); + break; + + case BufferedImage.TYPE_INT_RGB: + case BufferedImage.TYPE_INT_ARGB: + glFormat = GL.GL_BGRA; + glType = (hardwareAccelerationDisabled + ? offscreenContext.getOffscreenContextPixelDataType() + : hwGLFormat); + dbInt = (DataBufferInt) offscreenImage.getRaster().getDataBuffer(); + break; + + default: + // FIXME: Support more off-screen image types (current + // offscreen context implementations don't use others, and + // some of the OpenGL formats aren't supported in the 1.1 + // headers, which we're currently using) + throw new GLException("Unsupported offscreen image type " + awtFormat); + } } } - GL gl = getGL(); - // Save current modes - gl.glGetIntegerv(GL.GL_PACK_SWAP_BYTES, swapbytes); - gl.glGetIntegerv(GL.GL_PACK_LSB_FIRST, lsbfirst); - gl.glGetIntegerv(GL.GL_PACK_ROW_LENGTH, rowlength); - gl.glGetIntegerv(GL.GL_PACK_SKIP_ROWS, skiprows); - gl.glGetIntegerv(GL.GL_PACK_SKIP_PIXELS, skippixels); - gl.glGetIntegerv(GL.GL_PACK_ALIGNMENT, alignment); - - // Little endian machines (DEC Alpha, Intel X86, PPC (in LSB - // mode)... for example) could benefit from setting - // GL_PACK_LSB_FIRST to GL_TRUE instead of GL_FALSE, but this - // would require changing the generated bitmaps too. - gl.glPixelStorei(GL.GL_PACK_SWAP_BYTES, GL.GL_FALSE); - gl.glPixelStorei(GL.GL_PACK_LSB_FIRST, GL.GL_TRUE); - gl.glPixelStorei(GL.GL_PACK_ROW_LENGTH, offscreenImage.getWidth()); - gl.glPixelStorei(GL.GL_PACK_SKIP_ROWS, 0); - gl.glPixelStorei(GL.GL_PACK_SKIP_PIXELS, 0); - gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, 1); - - // Actually read the pixels. - gl.glReadBuffer(context.getOffscreenContextReadBuffer()); - if (dbByte != null) { - gl.glReadPixels(0, 0, offscreenImage.getWidth(), offscreenImage.getHeight(), glFormat, glType, dbByte.getData()); - } else if (dbInt != null) { - gl.glReadPixels(0, 0, offscreenImage.getWidth(), offscreenImage.getHeight(), glFormat, glType, dbInt.getData()); - } + if (offscreenImage != null) { + GL gl = getGL(); + // Save current modes + gl.glGetIntegerv(GL.GL_PACK_SWAP_BYTES, swapbytes); + gl.glGetIntegerv(GL.GL_PACK_ROW_LENGTH, rowlength); + gl.glGetIntegerv(GL.GL_PACK_SKIP_ROWS, skiprows); + gl.glGetIntegerv(GL.GL_PACK_SKIP_PIXELS, skippixels); + gl.glGetIntegerv(GL.GL_PACK_ALIGNMENT, alignment); + + gl.glPixelStorei(GL.GL_PACK_SWAP_BYTES, GL.GL_FALSE); + gl.glPixelStorei(GL.GL_PACK_ROW_LENGTH, offscreenImage.getWidth()); + gl.glPixelStorei(GL.GL_PACK_SKIP_ROWS, 0); + gl.glPixelStorei(GL.GL_PACK_SKIP_PIXELS, 0); + gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, 1); + + // Actually read the pixels. + gl.glReadBuffer(GL.GL_FRONT); + if (dbByte != null) { + gl.glReadPixels(0, 0, offscreenImage.getWidth(), offscreenImage.getHeight(), glFormat, glType, dbByte.getData()); + } else if (dbInt != null) { + gl.glReadPixels(0, 0, offscreenImage.getWidth(), offscreenImage.getHeight(), glFormat, glType, dbInt.getData()); + } - // Restore saved modes. - gl.glPixelStorei(GL.GL_PACK_SWAP_BYTES, swapbytes[0]); - gl.glPixelStorei(GL.GL_PACK_LSB_FIRST, lsbfirst[0]); - gl.glPixelStorei(GL.GL_PACK_ROW_LENGTH, rowlength[0]); - gl.glPixelStorei(GL.GL_PACK_SKIP_ROWS, skiprows[0]); - gl.glPixelStorei(GL.GL_PACK_SKIP_PIXELS, skippixels[0]); - gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, alignment[0]); + // Restore saved modes. + gl.glPixelStorei(GL.GL_PACK_SWAP_BYTES, swapbytes[0]); + gl.glPixelStorei(GL.GL_PACK_ROW_LENGTH, rowlength[0]); + gl.glPixelStorei(GL.GL_PACK_SKIP_ROWS, skiprows[0]); + gl.glPixelStorei(GL.GL_PACK_SKIP_PIXELS, skippixels[0]); + gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, alignment[0]); - gl.glFlush(); - gl.glFinish(); - - if (context.offscreenImageNeedsVerticalFlip()) { - g.drawImage(offscreenImage, - 0, 0, offscreenImage.getWidth(), offscreenImage.getHeight(), - 0, offscreenImage.getHeight(), offscreenImage.getWidth(), 0, - GLJPanel.this); - } else { - g.drawImage(offscreenImage, 0, 0, offscreenImage.getWidth(), offscreenImage.getHeight(), GLJPanel.this); + if (!hardwareAccelerationDisabled || + offscreenContext.offscreenImageNeedsVerticalFlip()) { + // This performs reasonably well; the snippet below does not. + // Should figure out if we need to set the image scaling + // preference to FAST since it doesn't require subsampling + // of pixels -- FIXME + for (int i = 0; i < panelHeight - 1; i++) { + g.drawImage(offscreenImage, + 0, i, panelWidth, i+1, + 0, panelHeight - i - 2, panelWidth, panelHeight - i - 1, + GLJPanel.this); + } + } else { + g.drawImage(offscreenImage, 0, 0, offscreenImage.getWidth(), offscreenImage.getHeight(), GLJPanel.this); + } } } + + public void reshape(GLDrawable drawable, int x, int y, int width, int height) { + // This is handled above and dispatched directly to the appropriate context + } + + public void displayChanged(GLDrawable drawable, boolean modeChanged, boolean deviceChanged) { + } + } + + class InitAction implements Runnable { + public void run() { + updater.init(GLJPanel.this); + } + } + private InitAction initAction = new InitAction(); + + class DisplayAction implements Runnable { + public void run() { + updater.display(GLJPanel.this); + } } private DisplayAction displayAction = new DisplayAction(); + // This one is used exclusively in the non-hardware-accelerated case class SwapBuffersAction implements Runnable { public void run() { - context.swapBuffers(); + offscreenContext.swapBuffers(); } } private SwapBuffersAction swapBuffersAction = new SwapBuffersAction(); + + private int getNextPowerOf2(int number) { + if (((number-1) & number) == 0) { + //ex: 8 -> 0b1000; 8-1=7 -> 0b0111; 0b1000&0b0111 == 0 + return number; + } + int power = 0; + while (number > 0) { + number = number>>1; + power++; + } + return (1<<power); + } } diff --git a/src/net/java/games/jogl/GLPbuffer.java b/src/net/java/games/jogl/GLPbuffer.java index d41ca1bd6..fe2c19974 100644 --- a/src/net/java/games/jogl/GLPbuffer.java +++ b/src/net/java/games/jogl/GLPbuffer.java @@ -63,4 +63,9 @@ public interface GLPbuffer extends GLDrawable { /** Queries initialization status of this pBuffer. */ public boolean isInitialized(); + + /** Destroys the native resources associated with this pbuffer. It + is not valid to call display() or any other routines on this + pbuffer after it has been destroyed. */ + public void destroy(); } diff --git a/src/net/java/games/jogl/Version.java b/src/net/java/games/jogl/Version.java index 3a6e36e8d..a5e7f43eb 100644 --- a/src/net/java/games/jogl/Version.java +++ b/src/net/java/games/jogl/Version.java @@ -89,7 +89,7 @@ public final class Version { /** * Version string of this build. */ - private static final String version = "1.1.0-b08"; + private static final String version = "1.1.0-b10"; /** * Returns the verison string and build number of diff --git a/src/net/java/games/jogl/impl/FunctionAvailabilityCache.java b/src/net/java/games/jogl/impl/FunctionAvailabilityCache.java index bceb66f9b..a4b67b5e8 100644 --- a/src/net/java/games/jogl/impl/FunctionAvailabilityCache.java +++ b/src/net/java/games/jogl/impl/FunctionAvailabilityCache.java @@ -52,7 +52,7 @@ import java.lang.reflect.*; * and display. */ public final class FunctionAvailabilityCache { - private static final boolean DEBUG = false; + private static final boolean DEBUG = Debug.debug("FunctionAvailabilityCache"); FunctionAvailabilityCache(GLContext context) { @@ -114,6 +114,10 @@ public final class FunctionAvailabilityCache { } String allAvailableExtensions = gl.glGetString(GL.GL_EXTENSIONS) + " " + context.getPlatformExtensionsString(); + if (DEBUG) { + System.err.println("!!! Available extensions: " + allAvailableExtensions); + System.err.println("!!! GL vendor: " + gl.glGetString(GL.GL_VENDOR)); + } StringTokenizer tok = new StringTokenizer(allAvailableExtensions); while (tok.hasMoreTokens()) { String availableExt = tok.nextToken().trim(); diff --git a/src/net/java/games/jogl/impl/GLContext.java b/src/net/java/games/jogl/impl/GLContext.java index 2aa8e9640..17667fbce 100644 --- a/src/net/java/games/jogl/impl/GLContext.java +++ b/src/net/java/games/jogl/impl/GLContext.java @@ -44,7 +44,7 @@ import net.java.games.jogl.*; import net.java.games.gluegen.runtime.*; public abstract class GLContext { - protected static final boolean DEBUG = false; + protected static final boolean DEBUG = Debug.debug("GLContext"); static { NativeLibLoader.load(); @@ -145,11 +145,7 @@ public abstract class GLContext { GLCapabilitiesChooser chooser, GLContext shareWith) { this.component = component; - try { - this.capabilities = (GLCapabilities) capabilities.clone(); - } catch (CloneNotSupportedException e) { - throw new GLException(e); - } + this.capabilities = (GLCapabilities) capabilities.clone(); this.chooser = chooser; setGL(createGL()); functionAvailability = new FunctionAvailabilityCache(this); @@ -255,6 +251,15 @@ public abstract class GLContext { if (isReshape) { deferredReshapeAction = runnable; } + + // Clean up after ourselves on the way out. + // NOTE that this is an abbreviated version of the code below + // and should probably be refactored/cleaned up -- this bug + // fix was done without a lot of intense thought about the + // situation + if (curContext != null) { + curContext.makeCurrent(curInitAction); + } return; } if (DEBUG) { @@ -620,6 +625,9 @@ public abstract class GLContext { from within the destroy() implementation. */ protected synchronized void setRealized(boolean realized) { this.realized = realized; + if (DEBUG) { + System.err.println("GLContext.setRealized(" + realized + ") for context " + this); + } } /** Indicates whether the component associated with this context has diff --git a/src/net/java/games/jogl/impl/GLPbufferImpl.java b/src/net/java/games/jogl/impl/GLPbufferImpl.java index 2fb927c92..be0f23398 100644 --- a/src/net/java/games/jogl/impl/GLPbufferImpl.java +++ b/src/net/java/games/jogl/impl/GLPbufferImpl.java @@ -40,6 +40,7 @@ package net.java.games.jogl.impl; import java.awt.Dimension; +import java.awt.EventQueue; import java.awt.event.*; import java.beans.PropertyChangeListener; @@ -61,7 +62,9 @@ public class GLPbufferImpl implements GLPbuffer { } public void display() { - context.invokeGL(displayAction, false, initAction); + maybeDoSingleThreadedWorkaround(displayOnEventDispatchThreadAction, + displayAction, + false); } public void setSize(int width, int height) { @@ -107,7 +110,7 @@ public class GLPbufferImpl implements GLPbuffer { } void willSetRenderingThread() { - context.willSetRenderingThread(); + // Not supported for pbuffers } public void setRenderingThread(Thread currentThreadOrNull) throws GLException { @@ -135,7 +138,7 @@ public class GLPbufferImpl implements GLPbuffer { } public void swapBuffers() { - context.invokeGL(swapBuffersAction, false, initAction); + maybeDoSingleThreadedWorkaround(swapBuffersOnEventDispatchThreadAction, swapBuffersAction, false); } public boolean canCreateOffscreenDrawable() { @@ -149,10 +152,14 @@ public class GLPbufferImpl implements GLPbuffer { } public void bindTexture() { + // Doesn't make much sense to try to do this on the event dispatch + // thread given that it has to be called while the context is current context.bindPbufferToTexture(); } public void releaseTexture() { + // Doesn't make much sense to try to do this on the event dispatch + // thread given that it has to be called while the context is current context.releasePbufferFromTexture(); } @@ -196,10 +203,38 @@ public class GLPbufferImpl implements GLPbuffer { return isInitialized; } + public void destroy() { + context.destroy(); + } + //---------------------------------------------------------------------- // Internals only below this point // + private void maybeDoSingleThreadedWorkaround(Runnable eventDispatchThreadAction, + Runnable invokeGLAction, + boolean isReshape) { + if (SingleThreadedWorkaround.doWorkaround() && !EventQueue.isDispatchThread()) { + try { + // Reshape events must not block on the event queue due to the + // possibility of deadlocks during initial component creation. + // This solution is not optimal, because it changes the + // semantics of reshape() to have some of the processing being + // done asynchronously, but at least it preserves the + // semantics of the single-threaded workaround. + if (!isReshape) { + EventQueue.invokeAndWait(eventDispatchThreadAction); + } else { + EventQueue.invokeLater(eventDispatchThreadAction); + } + } catch (Exception e) { + throw new GLException(e); + } + } else { + context.invokeGL(invokeGLAction, isReshape, initAction); + } + } + class InitAction implements Runnable { public void run() { drawableHelper.init(GLPbufferImpl.this); @@ -221,4 +256,22 @@ public class GLPbufferImpl implements GLPbuffer { } } private SwapBuffersAction swapBuffersAction = new SwapBuffersAction(); + + // Workaround for ATI driver bugs related to multithreading issues + // like simultaneous rendering via Animators to canvases that are + // being resized on the AWT event dispatch thread + class DisplayOnEventDispatchThreadAction implements Runnable { + public void run() { + context.invokeGL(displayAction, false, initAction); + } + } + private DisplayOnEventDispatchThreadAction displayOnEventDispatchThreadAction = + new DisplayOnEventDispatchThreadAction(); + class SwapBuffersOnEventDispatchThreadAction implements Runnable { + public void run() { + context.invokeGL(swapBuffersAction, false, initAction); + } + } + private SwapBuffersOnEventDispatchThreadAction swapBuffersOnEventDispatchThreadAction = + new SwapBuffersOnEventDispatchThreadAction(); } diff --git a/src/net/java/games/jogl/impl/NativeLibLoader.java b/src/net/java/games/jogl/impl/NativeLibLoader.java index cf2b06939..0c2420955 100644 --- a/src/net/java/games/jogl/impl/NativeLibLoader.java +++ b/src/net/java/games/jogl/impl/NativeLibLoader.java @@ -42,34 +42,45 @@ package net.java.games.jogl.impl; import java.security.*; public class NativeLibLoader { - static { - AccessController.doPrivileged(new PrivilegedAction() { - public Object run() { - boolean isOSX = System.getProperty("os.name").equals("Mac OS X"); - if (!isOSX) { - try { - System.loadLibrary("jawt"); - } catch (UnsatisfiedLinkError e) { - // Accessibility technologies load JAWT themselves; safe to continue - // as long as JAWT is loaded by any loader - if (e.getMessage().indexOf("already loaded") == -1) { - throw e; - } - } - } - System.loadLibrary("jogl"); + private static volatile boolean doLoading = true; + private static volatile boolean doneLoading = false; - // Workaround for 4845371. - // Make sure the first reference to the JNI GetDirectBufferAddress is done - // from a privileged context so the VM's internal class lookups will succeed. - JAWT jawt = new JAWT(); - JAWTFactory.JAWT_GetAWT(jawt); + public static void disableLoading() { + doLoading = false; + } - return null; - } - }); + public static void enableLoading() { + doLoading = true; } - public static void load() { + public static synchronized void load() { + if (doLoading && !doneLoading) { + AccessController.doPrivileged(new PrivilegedAction() { + public Object run() { + boolean isOSX = System.getProperty("os.name").equals("Mac OS X"); + if (!isOSX) { + try { + System.loadLibrary("jawt"); + } catch (UnsatisfiedLinkError e) { + // Accessibility technologies load JAWT themselves; safe to continue + // as long as JAWT is loaded by any loader + if (e.getMessage().indexOf("already loaded") == -1) { + throw e; + } + } + } + System.loadLibrary("jogl"); + + // Workaround for 4845371. + // Make sure the first reference to the JNI GetDirectBufferAddress is done + // from a privileged context so the VM's internal class lookups will succeed. + JAWT jawt = new JAWT(); + JAWTFactory.JAWT_GetAWT(jawt); + + return null; + } + }); + doneLoading = true; + } } } diff --git a/src/net/java/games/jogl/impl/SingleThreadedWorkaround.java b/src/net/java/games/jogl/impl/SingleThreadedWorkaround.java index 9dbed9e43..7b9fa46c4 100755 --- a/src/net/java/games/jogl/impl/SingleThreadedWorkaround.java +++ b/src/net/java/games/jogl/impl/SingleThreadedWorkaround.java @@ -45,24 +45,40 @@ import java.security.PrivilegedAction; /** Encapsulates the workaround of running all display operations on the AWT event queue thread for the purposes of working around problems seen primarily on ATI cards when rendering into a surface - that is simultaneously being resized by the event queue thread */ + that is simultaneously being resized by the event queue thread. + <p> + + As of JOGL 1.1 b10, this property defaults to true. Problems have + been seen on Windows, Linux and Mac OS X platforms that are solved + by switching all OpenGL work to a single thread, which this + workaround provides. The forthcoming JSR-231 work will rethink how + such a mechanism is implemented, but the core result of needing to + perform all OpenGL work on a single thread for best compatibility + will remain. +*/ public class SingleThreadedWorkaround { - private static boolean ATI_WORKAROUND = false; + private static boolean singleThreadedWorkaround = true; // If the user specified the workaround's system property (either // true or false), don't let the automatic detection have any effect private static boolean systemPropertySpecified = false; - private static boolean verbose = false; static { AccessController.doPrivileged(new PrivilegedAction() { public Object run() { - String workaround = System.getProperty("ATI_WORKAROUND"); - if (workaround != null) { + String workaround = System.getProperty("jogl.1thread"); + if (workaround == null) { + // Old system property (for compatibility) + workaround = System.getProperty("JOGL_SINGLE_THREADED_WORKAROUND"); + } + if (workaround == null) { + // Older system property (for compatibility) + workaround = System.getProperty("ATI_WORKAROUND"); + } + if (workaround != null && (!workaround.equals("auto"))) { systemPropertySpecified = true; - ATI_WORKAROUND = Boolean.valueOf(workaround).booleanValue(); + singleThreadedWorkaround = Boolean.valueOf(workaround).booleanValue(); } - verbose = (System.getProperty("jogl.verbose") != null); printWorkaroundNotice(); return null; } @@ -71,18 +87,18 @@ public class SingleThreadedWorkaround { public static void shouldDoWorkaround() { if (!systemPropertySpecified) { - ATI_WORKAROUND = true; + singleThreadedWorkaround = true; printWorkaroundNotice(); } } public static boolean doWorkaround() { - return ATI_WORKAROUND; + return singleThreadedWorkaround; } private static void printWorkaroundNotice() { - if (ATI_WORKAROUND && verbose) { - System.err.println("Using ATI workaround of dispatching display() on event thread"); + if (singleThreadedWorkaround && Debug.verbose()) { + System.err.println("Using single-threaded workaround of dispatching display() on event thread"); } } } diff --git a/src/net/java/games/jogl/impl/macosx/MacOSXGLContext.java b/src/net/java/games/jogl/impl/macosx/MacOSXGLContext.java index f8af120da..3c8027e7c 100644 --- a/src/net/java/games/jogl/impl/macosx/MacOSXGLContext.java +++ b/src/net/java/games/jogl/impl/macosx/MacOSXGLContext.java @@ -132,6 +132,7 @@ public abstract class MacOSXGLContext extends GLContext } nsContext = CGL.createContext(share, nsView, + capabilities.getDoubleBuffered() ? 1 : 0, capabilities.getRedBits(), capabilities.getGreenBits(), capabilities.getBlueBits(), diff --git a/src/net/java/games/jogl/impl/macosx/MacOSXPbufferGLContext.java b/src/net/java/games/jogl/impl/macosx/MacOSXPbufferGLContext.java index 6ac854090..8e65ce1f3 100644 --- a/src/net/java/games/jogl/impl/macosx/MacOSXPbufferGLContext.java +++ b/src/net/java/games/jogl/impl/macosx/MacOSXPbufferGLContext.java @@ -4,8 +4,7 @@ import net.java.games.jogl.*; import net.java.games.jogl.impl.*; public class MacOSXPbufferGLContext extends MacOSXGLContext { - - private static final boolean DEBUG = false; + private static final boolean DEBUG = Debug.debug("MacOSXPbufferGLContext"); protected int initWidth; protected int initHeight; @@ -131,6 +130,10 @@ public class MacOSXPbufferGLContext extends MacOSXGLContext { return false; } + protected void destroyImpl() throws GLException { + destroyPBuffer(); + } + public void swapBuffers() throws GLException { // FIXME: do we need to do anything if the pbuffer is double-buffered? } diff --git a/src/net/java/games/jogl/impl/windows/WindowsGLContext.java b/src/net/java/games/jogl/impl/windows/WindowsGLContext.java index eed383794..37a3f5359 100644 --- a/src/net/java/games/jogl/impl/windows/WindowsGLContext.java +++ b/src/net/java/games/jogl/impl/windows/WindowsGLContext.java @@ -61,6 +61,7 @@ public abstract class WindowsGLContext extends GLContext { private GLProcAddressTable glProcAddressTable; // Handle to GLU32.dll private long hglu32; + private boolean haveWGLARBPbuffer = true; private static final int MAX_PFORMATS = 256; private static final int MAX_ATTRIBS = 256; @@ -141,10 +142,17 @@ public abstract class WindowsGLContext extends GLContext { if (!WGL.wglMakeCurrent(hdc, hglrc)) { throw new GLException("Error making context current: " + WGL.GetLastError()); + } else { + if (DEBUG) { + System.err.println("wglMakeCurrent(hdc " + hdcToString(hdc) + + ", hglrc " + hdcToString(hglrc) + ") succeeded"); + } } if (created) { resetGLFunctionAvailability(); + haveWGLARBPbuffer = (isExtensionAvailable("WGL_ARB_pbuffer") && + isExtensionAvailable("WGL_ARB_pixel_format")); // Windows can set up sharing of display lists after creation time WindowsGLContext other = (WindowsGLContext) GLContextShareSet.getShareContext(this); if (other != null) { @@ -154,7 +162,8 @@ public abstract class WindowsGLContext extends GLContext { } if (!WGL.wglShareLists(hglrc2, hglrc)) { throw new GLException("wglShareLists(0x" + Long.toHexString(hglrc2) + - ", 0x" + Long.toHexString(hglrc) + ") failed"); + ", 0x" + Long.toHexString(hglrc) + ") failed: error code " + + WGL.GetLastError()); } } GLContextShareSet.contextCreated(this); @@ -302,6 +311,8 @@ public abstract class WindowsGLContext extends GLContext { freeWGLC = true; } } + // Fallback path for older cards, in particular Intel Extreme motherboard graphics + boolean gotAvailableCaps = false; if (dummyGL != null && haveWGLChoosePixelFormatARB) { int[] iattributes = new int [2 * MAX_ATTRIBS]; int[] iresults = new int [2 * MAX_ATTRIBS]; @@ -408,46 +419,54 @@ public abstract class WindowsGLContext extends GLContext { // window, to a pbuffer, or to a pixmap) niattribs = 0; iattributes[0] = GL.WGL_NUMBER_PIXEL_FORMATS_ARB; - if (!dummyGL.wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, iattributes, iresults)) { - throw new GLException("Unable to enumerate pixel formats of window using wglGetPixelFormatAttribivARB: " + WGL.GetLastError()); - } - numFormats = iresults[0]; - // Should we be filtering out the pixel formats which aren't - // applicable, as we are doing here? - // We don't have enough information in the GLCapabilities to - // represent those that aren't... - iattributes[niattribs++] = GL.WGL_DRAW_TO_WINDOW_ARB; - iattributes[niattribs++] = GL.WGL_ACCELERATION_ARB; - iattributes[niattribs++] = GL.WGL_SUPPORT_OPENGL_ARB; - iattributes[niattribs++] = GL.WGL_DEPTH_BITS_ARB; - iattributes[niattribs++] = GL.WGL_STENCIL_BITS_ARB; - iattributes[niattribs++] = GL.WGL_DOUBLE_BUFFER_ARB; - iattributes[niattribs++] = GL.WGL_STEREO_ARB; - iattributes[niattribs++] = GL.WGL_PIXEL_TYPE_ARB; - iattributes[niattribs++] = GL.WGL_RED_BITS_ARB; - iattributes[niattribs++] = GL.WGL_GREEN_BITS_ARB; - iattributes[niattribs++] = GL.WGL_BLUE_BITS_ARB; - iattributes[niattribs++] = GL.WGL_ALPHA_BITS_ARB; - iattributes[niattribs++] = GL.WGL_ACCUM_RED_BITS_ARB; - iattributes[niattribs++] = GL.WGL_ACCUM_GREEN_BITS_ARB; - iattributes[niattribs++] = GL.WGL_ACCUM_BLUE_BITS_ARB; - iattributes[niattribs++] = GL.WGL_ACCUM_ALPHA_BITS_ARB; - if (haveWGLARBMultisample) { - iattributes[niattribs++] = GL.WGL_SAMPLE_BUFFERS_ARB; - iattributes[niattribs++] = GL.WGL_SAMPLES_ARB; - } + if (dummyGL.wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, iattributes, iresults)) { + numFormats = iresults[0]; + // Should we be filtering out the pixel formats which aren't + // applicable, as we are doing here? + // We don't have enough information in the GLCapabilities to + // represent those that aren't... + iattributes[niattribs++] = GL.WGL_DRAW_TO_WINDOW_ARB; + iattributes[niattribs++] = GL.WGL_ACCELERATION_ARB; + iattributes[niattribs++] = GL.WGL_SUPPORT_OPENGL_ARB; + iattributes[niattribs++] = GL.WGL_DEPTH_BITS_ARB; + iattributes[niattribs++] = GL.WGL_STENCIL_BITS_ARB; + iattributes[niattribs++] = GL.WGL_DOUBLE_BUFFER_ARB; + iattributes[niattribs++] = GL.WGL_STEREO_ARB; + iattributes[niattribs++] = GL.WGL_PIXEL_TYPE_ARB; + iattributes[niattribs++] = GL.WGL_RED_BITS_ARB; + iattributes[niattribs++] = GL.WGL_GREEN_BITS_ARB; + iattributes[niattribs++] = GL.WGL_BLUE_BITS_ARB; + iattributes[niattribs++] = GL.WGL_ALPHA_BITS_ARB; + iattributes[niattribs++] = GL.WGL_ACCUM_RED_BITS_ARB; + iattributes[niattribs++] = GL.WGL_ACCUM_GREEN_BITS_ARB; + iattributes[niattribs++] = GL.WGL_ACCUM_BLUE_BITS_ARB; + iattributes[niattribs++] = GL.WGL_ACCUM_ALPHA_BITS_ARB; + if (haveWGLARBMultisample) { + iattributes[niattribs++] = GL.WGL_SAMPLE_BUFFERS_ARB; + iattributes[niattribs++] = GL.WGL_SAMPLES_ARB; + } - availableCaps = new GLCapabilities[numFormats]; - for (int i = 0; i < numFormats; i++) { - if (!dummyGL.wglGetPixelFormatAttribivARB(hdc, i+1, 0, niattribs, iattributes, iresults)) { - throw new GLException("Error getting pixel format attributes for pixel format " + (i + 1) + " of device context"); + availableCaps = new GLCapabilities[numFormats]; + for (int i = 0; i < numFormats; i++) { + if (!dummyGL.wglGetPixelFormatAttribivARB(hdc, i+1, 0, niattribs, iattributes, iresults)) { + throw new GLException("Error getting pixel format attributes for pixel format " + (i + 1) + " of device context"); + } + availableCaps[i] = iattributes2GLCapabilities(iattributes, iresults, niattribs, true); + } + if( freeWGLC ) { + WGL.wglMakeCurrent( 0, 0 ); + } + gotAvailableCaps = true; + } else { + int lastErr = WGL.GetLastError(); + // Intel Extreme graphics fails with a zero error code + if (lastErr != 0) { + throw new GLException("Unable to enumerate pixel formats of window using wglGetPixelFormatAttribivARB: error code " + WGL.GetLastError()); } - availableCaps[i] = iattributes2GLCapabilities(iattributes, iresults, niattribs, true); - } - if( freeWGLC ) { - WGL.wglMakeCurrent( 0, 0 ); } - } else { + } + + if (!gotAvailableCaps) { if (DEBUG) { System.err.println("Using ChoosePixelFormat because no wglChoosePixelFormatARB: dummyGL = " + dummyGL); } @@ -467,6 +486,7 @@ public abstract class WindowsGLContext extends GLContext { availableCaps[i] = pfd2GLCapabilities(pfd); } } + // Supply information to chooser pixelFormat = chooser.chooseCapabilities(capabilities, availableCaps, recommendedPixelFormat); if ((pixelFormat < 0) || (pixelFormat >= numFormats)) { @@ -490,11 +510,17 @@ public abstract class WindowsGLContext extends GLContext { pixelFormat = WGL.ChoosePixelFormat(hdc, pfd); } if (!WGL.SetPixelFormat(hdc, pixelFormat, pfd)) { - throw new GLException("Unable to set pixel format"); + int lastError = WGL.GetLastError(); + if (DEBUG) { + System.err.println("SetPixelFormat failed: current context = " + WGL.wglGetCurrentContext() + + ", current DC = " + WGL.wglGetCurrentDC()); + System.err.println("GetPixelFormat(hdc " + hdcToString(hdc) + ") returns " + WGL.GetPixelFormat(hdc)); + } + throw new GLException("Unable to set pixel format " + pixelFormat + " for device context " + hdcToString(hdc) + ": error code " + lastError); } hglrc = WGL.wglCreateContext(hdc); if (DEBUG) { - System.err.println("!!! Created OpenGL context " + hglrc); + System.err.println("!!! Created OpenGL context " + hglrc + " for device context " + hdcToString(hdc) + " using pixel format " + pixelFormat); } if (hglrc == 0) { throw new GLException("Unable to create OpenGL context"); @@ -654,4 +680,12 @@ public abstract class WindowsGLContext extends GLContext { } return res; } + + protected static String hdcToString(long hdc) { + return "0x" + Long.toHexString(hdc); + } + + protected boolean haveWGLARBPbuffer() { + return haveWGLARBPbuffer; + } } diff --git a/src/net/java/games/jogl/impl/windows/WindowsGLContextFactory.java b/src/net/java/games/jogl/impl/windows/WindowsGLContextFactory.java index 726091bf1..1c976c355 100644 --- a/src/net/java/games/jogl/impl/windows/WindowsGLContextFactory.java +++ b/src/net/java/games/jogl/impl/windows/WindowsGLContextFactory.java @@ -43,6 +43,7 @@ import java.awt.Component; import java.awt.GraphicsConfiguration; import java.awt.GraphicsDevice; import java.awt.Rectangle; +import java.io.File; import java.security.AccessController; import java.security.PrivilegedAction; import java.util.HashMap; @@ -74,6 +75,56 @@ public class WindowsGLContextFactory extends GLContextFactory { AccessController.doPrivileged( new PrivilegedAction() { public Object run() { Runtime.getRuntime().addShutdownHook( new ShutdownHook() ); + + // Test for whether we should enable the single-threaded + // workaround for ATI cards. It appears that if we make any + // OpenGL context current on more than one thread on ATI cards + // on Windows then we see random failures like the inability + // to create more OpenGL contexts, or having just the next + // OpenGL SetPixelFormat operation fail with a GetNextError() + // code of 0 (but subsequent ones on subsequently-created + // windows succeed). These kinds of failures are obviously due + // to bugs in ATI's OpenGL drivers. Through trial and error it + // was found that specifying + // -DJOGL_SINGLE_THREADED_WORKAROUND=true on the command line + // caused these problems to completely disappear. Therefore at + // least on Windows we try to enable the single-threaded + // workaround before creating any OpenGL contexts. In the + // future, if problems are encountered on other platforms and + // -DJOGL_SINGLE_THREADED_WORKAROUND=true works around them, + // we may want to implement a workaround like this on other + // platforms. + + // The algorithm here is to try to find the system directory + // (assuming it is on the same drive as TMPDIR, exposed + // through the system property java.io.tmpdir) and see whether + // a known file in the ATI drivers is present; if it is, we + // enable the single-threaded workaround. + + // If any path down this code fails, we simply bail out -- we + // don't go to great lengths to figure out if the ATI drivers + // are present. We could add more checks here in the future if + // these appear to be insufficient. + + String tmpDirProp = System.getProperty("java.io.tmpdir"); + if (tmpDirProp != null) { + File file = new File(tmpDirProp); + if (file.isAbsolute()) { + File parent = null; + do { + parent = file.getParentFile(); + if (parent != null) { + file = parent; + } + } while (parent != null); + // Now the file contains just the drive letter + file = new File(new File(new File(file, "windows"), "system32"), "atioglxx.dll"); + if (file.exists()) { + SingleThreadedWorkaround.shouldDoWorkaround(); + } + } + } + return( null ); } }); diff --git a/src/net/java/games/jogl/impl/windows/WindowsOffscreenGLContext.java b/src/net/java/games/jogl/impl/windows/WindowsOffscreenGLContext.java index 9e871caba..5743253a0 100644 --- a/src/net/java/games/jogl/impl/windows/WindowsOffscreenGLContext.java +++ b/src/net/java/games/jogl/impl/windows/WindowsOffscreenGLContext.java @@ -172,7 +172,8 @@ public class WindowsOffscreenGLContext extends WindowsGLContext { } hbitmap = WGL.CreateDIBSection(hdc, info, WGL.DIB_RGB_COLORS, 0, 0, 0); if (hbitmap == 0) { - throw new GLException("Error creating offscreen bitmap"); + throw new GLException("Error creating offscreen bitmap of width " + width + + ", height " + height); } if ((origbitmap = WGL.SelectObject(hdc, hbitmap)) == 0) { throw new GLException("Error selecting bitmap into new device context"); diff --git a/src/net/java/games/jogl/impl/windows/WindowsOnscreenGLContext.java b/src/net/java/games/jogl/impl/windows/WindowsOnscreenGLContext.java index 3bfdee5d1..de13be0a1 100644 --- a/src/net/java/games/jogl/impl/windows/WindowsOnscreenGLContext.java +++ b/src/net/java/games/jogl/impl/windows/WindowsOnscreenGLContext.java @@ -61,6 +61,25 @@ public class WindowsOnscreenGLContext extends WindowsGLContext { super(component, capabilities, chooser, shareWith); } + public void invokeGL(Runnable runnable, boolean isReshape, Runnable initAction) throws GLException { + // Unfortunately, invokeGL can be called with the AWT tree lock + // held, and the Windows onscreen implementation of + // choosePixelFormatAndCreateContext calls + // Component.getGraphicsConfiguration(), which grabs the tree + // lock. To avoid deadlock we have to lock the tree lock before + // grabbing the GLContext's lock if we're going to create an + // OpenGL context during this call. This code might not be + // completely correct, and we might need to uniformly grab the AWT + // tree lock, which might become a performance issue... + if (hglrc == 0) { + synchronized(component.getTreeLock()) { + super.invokeGL(runnable, isReshape, initAction); + } + } else { + super.invokeGL(runnable, isReshape, initAction); + } + } + protected GL createGL() { return new WindowsGLImpl(this); @@ -83,7 +102,7 @@ public class WindowsOnscreenGLContext extends WindowsGLContext { } public boolean canCreatePbufferContext() { - return true; + return haveWGLARBPbuffer(); } public synchronized GLContext createPbufferContext(GLCapabilities capabilities, diff --git a/src/net/java/games/jogl/impl/windows/WindowsPbufferGLContext.java b/src/net/java/games/jogl/impl/windows/WindowsPbufferGLContext.java index d3795905f..f0ce74d9d 100644 --- a/src/net/java/games/jogl/impl/windows/WindowsPbufferGLContext.java +++ b/src/net/java/games/jogl/impl/windows/WindowsPbufferGLContext.java @@ -43,7 +43,7 @@ import net.java.games.jogl.*; import net.java.games.jogl.impl.*; public class WindowsPbufferGLContext extends WindowsGLContext { - private static final boolean DEBUG = false; + private static final boolean DEBUG = Debug.debug("WindowsPbufferGLContext"); private int initWidth; private int initHeight; @@ -75,6 +75,13 @@ public class WindowsPbufferGLContext extends WindowsGLContext { throw new GLException("Initial width and height of pbuffer must be positive (were (" + initWidth + ", " + initHeight + "))"); } + + if (DEBUG) { + System.out.println("Pbuffer caps on init: " + capabilities + + (capabilities.getOffscreenRenderToTexture() ? " [rtt]" : "") + + (capabilities.getOffscreenRenderToTextureRectangle() ? " [rect]" : "") + + (capabilities.getOffscreenFloatingPointBuffers() ? " [float]" : "")); + } } public boolean canCreatePbufferContext() { @@ -128,6 +135,13 @@ public class WindowsPbufferGLContext extends WindowsGLContext { int nfattribs = 0; int niattribs = 0; + if (DEBUG) { + System.out.println("Pbuffer caps: " + capabilities + + (capabilities.getOffscreenRenderToTexture() ? " [rtt]" : "") + + (capabilities.getOffscreenRenderToTextureRectangle() ? " [rect]" : "") + + (capabilities.getOffscreenFloatingPointBuffers() ? " [float]" : "")); + } + rtt = capabilities.getOffscreenRenderToTexture(); rect = capabilities.getOffscreenRenderToTextureRectangle(); boolean useFloat = capabilities.getOffscreenFloatingPointBuffers(); @@ -228,9 +242,10 @@ public class WindowsPbufferGLContext extends WindowsGLContext { iattributes[5] = GL.WGL_FLOAT_COMPONENTS_NV; iattributes[6] = GL.WGL_SAMPLE_BUFFERS_EXT; iattributes[7] = GL.WGL_SAMPLES_EXT; - int[] ivalues = new int[8]; + iattributes[8] = GL.WGL_DRAW_TO_PBUFFER_ARB; + int[] ivalues = new int[9]; for (int i = 0; i < nformats; i++) { - if (!gl.wglGetPixelFormatAttribivARB(parentHdc, pformats[i], 0, 8, iattributes, ivalues)) { + if (!gl.wglGetPixelFormatAttribivARB(parentHdc, pformats[i], 0, 9, iattributes, ivalues)) { throw new GLException("Error while querying pixel format " + pformats[i] + "'s (index " + i + "'s) capabilities for debugging"); } @@ -245,38 +260,49 @@ public class WindowsPbufferGLContext extends WindowsGLContext { if (ivalues[5] != 0) { System.err.print(" [float]"); } + if (ivalues[8] != 0) { + System.err.print(" [pbuffer]"); + } System.err.println(); } } - int format = pformats[0]; + long tmpBuffer = 0; + int whichFormat = 0; + // Loop is a workaround for bugs in NVidia's recent drivers + do { + int format = pformats[whichFormat]; - // Create the p-buffer. - niattribs = 0; + // Create the p-buffer. + niattribs = 0; - if (rtt) { - iattributes[niattribs++] = GL.WGL_TEXTURE_FORMAT_ARB; - if (useFloat) { - iattributes[niattribs++] = GL.WGL_TEXTURE_FLOAT_RGB_NV; - } else { - iattributes[niattribs++] = GL.WGL_TEXTURE_RGBA_ARB; - } + if (rtt) { + iattributes[niattribs++] = GL.WGL_TEXTURE_FORMAT_ARB; + if (useFloat) { + iattributes[niattribs++] = GL.WGL_TEXTURE_FLOAT_RGB_NV; + } else { + iattributes[niattribs++] = GL.WGL_TEXTURE_RGBA_ARB; + } - iattributes[niattribs++] = GL.WGL_TEXTURE_TARGET_ARB; - iattributes[niattribs++] = rect ? GL.WGL_TEXTURE_RECTANGLE_NV : GL.WGL_TEXTURE_2D_ARB; + iattributes[niattribs++] = GL.WGL_TEXTURE_TARGET_ARB; + iattributes[niattribs++] = rect ? GL.WGL_TEXTURE_RECTANGLE_NV : GL.WGL_TEXTURE_2D_ARB; - iattributes[niattribs++] = GL.WGL_MIPMAP_TEXTURE_ARB; - iattributes[niattribs++] = GL.GL_FALSE; + iattributes[niattribs++] = GL.WGL_MIPMAP_TEXTURE_ARB; + iattributes[niattribs++] = GL.GL_FALSE; - iattributes[niattribs++] = GL.WGL_PBUFFER_LARGEST_ARB; - iattributes[niattribs++] = GL.GL_FALSE; - } + iattributes[niattribs++] = GL.WGL_PBUFFER_LARGEST_ARB; + iattributes[niattribs++] = GL.GL_FALSE; + } + + iattributes[niattribs++] = 0; - iattributes[niattribs++] = 0; + tmpBuffer = gl.wglCreatePbufferARB(parentHdc, format, initWidth, initHeight, iattributes); + ++whichFormat; + } while ((tmpBuffer == 0) && (whichFormat < nformats)); - long tmpBuffer = gl.wglCreatePbufferARB(parentHdc, format, initWidth, initHeight, iattributes); if (tmpBuffer == 0) { - throw new GLException("pbuffer creation error: wglCreatePbufferARB() failed: " + wglGetLastError()); + throw new GLException("pbuffer creation error: wglCreatePbufferARB() failed: tried " + nformats + + " pixel formats, last error was: " + wglGetLastError()); } // Get the device context. @@ -308,10 +334,16 @@ public class WindowsPbufferGLContext extends WindowsGLContext { if (buffer == 0) { // pbuffer not instantiated yet + if (DEBUG) { + System.err.println("pbuffer not instantiated yet"); + } return false; } boolean res = super.makeCurrent(initAction); + if (DEBUG) { + System.err.println("super.makeCurrent() = " + res + ", created = " + created); + } if (created) { // Initialize render-to-texture support if requested rtt = capabilities.getOffscreenRenderToTexture(); @@ -396,6 +428,22 @@ public class WindowsPbufferGLContext extends WindowsGLContext { } } + protected void destroyImpl() throws GLException { + if (hglrc != 0) { + super.destroyImpl(); + // Must release DC and pbuffer + GL gl = getGL(); + if (gl.wglReleasePbufferDCARB(buffer, hdc) == 0) { + throw new GLException("Error releasing pbuffer device context: error code " + WGL.GetLastError()); + } + hdc = 0; + if (!gl.wglDestroyPbufferARB(buffer)) { + throw new GLException("Error destroying pbuffer: error code " + WGL.GetLastError()); + } + buffer = 0; + } + } + public void swapBuffers() throws GLException { // FIXME: do we need to do anything if the pbuffer is double-buffered? // For now, just grab the pixels for the render-to-texture support. diff --git a/src/net/java/games/jogl/impl/x11/X11GLContext.java b/src/net/java/games/jogl/impl/x11/X11GLContext.java index 359d0c95c..4709691f8 100644 --- a/src/net/java/games/jogl/impl/x11/X11GLContext.java +++ b/src/net/java/games/jogl/impl/x11/X11GLContext.java @@ -40,6 +40,7 @@ package net.java.games.jogl.impl.x11; import java.awt.Component; +import java.security.*; import java.util.*; import net.java.games.gluegen.runtime.*; // for PROCADDRESS_VAR_PREFIX import net.java.games.jogl.*; @@ -64,11 +65,24 @@ public abstract class X11GLContext extends GLContext { // so that we can implement displayImpl() (which must be done when // the context is not current) protected long mostRecentDisplay; + // There is currently a bug on Linux/AMD64 distributions in glXGetProcAddressARB + protected static boolean isLinuxAMD64; static { functionNameMap = new HashMap(); functionNameMap.put("glAllocateMemoryNV", "glXAllocateMemoryNV"); functionNameMap.put("glFreeMemoryNV", "glXFreeMemoryNV"); + + AccessController.doPrivileged(new PrivilegedAction() { + public Object run() { + String os = System.getProperty("os.name").toLowerCase(); + String arch = System.getProperty("os.arch").toLowerCase(); + if (os.startsWith("linux") && arch.equals("amd64")) { + isLinuxAMD64 = true; + } + return null; + } + }); } public X11GLContext(Component component, @@ -173,6 +187,7 @@ public abstract class X11GLContext extends GLContext { } protected void destroyImpl() throws GLException { + lockAWT(); if (context != 0) { GLX.glXDestroyContext(mostRecentDisplay, context); if (DEBUG) { @@ -180,12 +195,16 @@ public abstract class X11GLContext extends GLContext { } context = 0; } + unlockAWT(); } public abstract void swapBuffers() throws GLException; protected long dynamicLookupFunction(String glFuncName) { - long res = GLX.glXGetProcAddressARB(glFuncName); + long res = 0; + if (!isLinuxAMD64) { + res = GLX.glXGetProcAddressARB(glFuncName); + } if (res == 0) { // GLU routines aren't known to the OpenGL function lookup res = GLX.dlsym(glFuncName); @@ -218,6 +237,22 @@ public abstract class X11GLContext extends GLContext { if (!GLX.glXQueryVersion(display, major, minor)) { throw new GLException("glXQueryVersion failed"); } + if (DEBUG) { + System.err.println("!!! GLX version: major " + major[0] + + ", minor " + minor[0]); + } + + // Work around bugs in ATI's Linux drivers where they report they + // only implement GLX version 1.2 but actually do support pbuffers + if (major[0] == 1 && minor[0] == 2) { + GL gl = getGL(); + String str = gl.glGetString(GL.GL_VENDOR); + if (str != null && str.indexOf("ATI") >= 0) { + isGLX13 = true; + return; + } + } + isGLX13 = ((major[0] > 1) || (minor[0] > 2)); } @@ -235,11 +270,20 @@ public abstract class X11GLContext extends GLContext { throw new GLException("Context not current"); } if (!glXQueryExtensionsStringInitialized) { - glXQueryExtensionsStringAvailable = (GLX.glXGetProcAddressARB("glXQueryExtensionsString") != 0); + glXQueryExtensionsStringAvailable = (dynamicLookupFunction("glXQueryExtensionsString") != 0); glXQueryExtensionsStringInitialized = true; } if (glXQueryExtensionsStringAvailable) { - return GLX.glXQueryExtensionsString(display, GLX.DefaultScreen(display)); + lockAWT(); + try { + String ret = GLX.glXQueryExtensionsString(display, GLX.DefaultScreen(display)); + if (DEBUG) { + System.err.println("!!! GLX extensions: " + ret); + } + return ret; + } finally { + unlockAWT(); + } } else { return ""; } @@ -364,4 +408,14 @@ public abstract class X11GLContext extends GLContext { protected long getContext() { return context; } + + // These synchronization primitives prevent the AWT from making + // requests from the X server asynchronously to this code. + protected void lockAWT() { + getJAWT().Lock(); + } + + protected void unlockAWT() { + getJAWT().Unlock(); + } } diff --git a/src/net/java/games/jogl/impl/x11/X11OffscreenGLContext.java b/src/net/java/games/jogl/impl/x11/X11OffscreenGLContext.java index 2aa85e9f8..a22367091 100644 --- a/src/net/java/games/jogl/impl/x11/X11OffscreenGLContext.java +++ b/src/net/java/games/jogl/impl/x11/X11OffscreenGLContext.java @@ -44,7 +44,7 @@ import net.java.games.jogl.*; import net.java.games.jogl.impl.*; public class X11OffscreenGLContext extends X11GLContext { - private int pixmap; + private long pixmap; private boolean isDoubleBuffered; // Width and height of the underlying bitmap private int width; diff --git a/src/net/java/games/jogl/impl/x11/X11PbufferGLContext.java b/src/net/java/games/jogl/impl/x11/X11PbufferGLContext.java index 5ab976870..5b6df1843 100644 --- a/src/net/java/games/jogl/impl/x11/X11PbufferGLContext.java +++ b/src/net/java/games/jogl/impl/x11/X11PbufferGLContext.java @@ -43,7 +43,7 @@ import net.java.games.jogl.*; import net.java.games.jogl.impl.*; public class X11PbufferGLContext extends X11GLContext { - private static final boolean DEBUG = false; + private static final boolean DEBUG = Debug.debug("X11PbufferGLContext"); private int initWidth; private int initHeight; @@ -209,7 +209,7 @@ public class X11PbufferGLContext extends X11GLContext { iattributes[niattribs++] = 0; - int tmpBuffer = GLX.glXCreatePbuffer(display, fbConfig, iattributes); + long tmpBuffer = GLX.glXCreatePbuffer(display, fbConfig, iattributes); if (tmpBuffer == 0) { // FIXME: query X error code for detail error message throw new GLException("pbuffer creation error: glXCreatePbuffer() failed"); @@ -251,10 +251,7 @@ public class X11PbufferGLContext extends X11GLContext { created = true; } - // FIXME: this cast to int would be wrong on 64-bit platforms - // where the argument type to glXMakeCurrent would change (should - // probably make GLXDrawable, and maybe XID, Opaque as long) - if (!GLX.glXMakeContextCurrent(display, (int) buffer, (int) buffer, context)) { + if (!GLX.glXMakeContextCurrent(display, buffer, buffer, context)) { throw new GLException("Error making context current"); } @@ -318,6 +315,19 @@ public class X11PbufferGLContext extends X11GLContext { } } + protected void destroyImpl() throws GLException { + lockAWT(); + try { + if (context != 0) { + super.destroyImpl(); + GLX.glXDestroyPbuffer(display, buffer); + buffer = 0; + } + } finally { + unlockAWT(); + } + } + public void swapBuffers() throws GLException { // FIXME: do we need to do anything if the pbuffer is double-buffered? } @@ -329,15 +339,4 @@ public class X11PbufferGLContext extends X11GLContext { } return tmp[0]; } - - // These synchronization primitives, which prevent the AWT from - // making requests from the X server asynchronously to this code, - // are required for pbuffers to work properly on X11. - private void lockAWT() { - getJAWT().Lock(); - } - - private void unlockAWT() { - getJAWT().Unlock(); - } } diff --git a/www/index.html b/www/index.html index 0754f2226..882abc8b8 100644 --- a/www/index.html +++ b/www/index.html @@ -11,15 +11,15 @@ <body bgcolor="#f5f5f5"> <div Align=center> - <img ID="NavBar" WIDTH=800 HEIGHT=64 SRC="http://games.dev.java.net/images/navbar2p.gif" VSPACE=0 HSPACE=0 ALIGN="TOP" BORDER=0 USEMAP="#NavBar_MAP" NOFINSIDE="~! ~!" > </div> + <img ID="NavBar" WIDTH=800 HEIGHT=32 SRC="https://games.dev.java.net/images/navbar2p.gif" VSPACE=0 HSPACE=0 ALIGN="TOP" BORDER=0 USEMAP="#NavBar_MAP" NOFINSIDE="~! ~!" > </div> <MAP NAME="NavBar_Map"> - <AREA SHAPE="rect" ALT="Projects" COORDS="356,14,440,46" HREF="http://games.dev.java.net" TARGET="_self"> - <AREA SHAPE="rect" ALT="Wiki" COORDS="643,14,695,46" HREF="http://wiki.java.net/bin/view/Games"> - <AREA SHAPE="rect" ALT="Weblogs" COORDS="562,15,624,46" HREF="http://weblogs.java.net/weblogs/project/games"> - <AREA SHAPE="rect" COORDS="463,16,541,45" HREF="http://www.javagaming.org/cgi-bin/JGNetForums/YaBB.cgi" target="_top" ALT="Forums"> - <AREA SHAPE="rect" ALT="JavaGames Home" COORDS="147,16,334,48" HREF="http://community.java.net/games"> - <AREA SHAPE="rect" ALT="Java.net" COORDS="21,15,128,46" HREF="http://www.java.net" TARGET="_self"> + <AREA SHAPE="rect" ALT="Projects" COORDS="356,7,440,23" HREF="https://games.dev.java.net" TARGET="_self"> + <AREA SHAPE="rect" ALT="Wiki" COORDS="643,7,695,23" HREF="http://wiki.java.net/bin/view/Games"> + <AREA SHAPE="rect" ALT="Weblogs" COORDS="562,7,624,23" HREF="http://weblogs.java.net/weblogs/project/games"> + <AREA SHAPE="rect" COORDS="463,7,541,23" HREF="http://www.javagaming.org/cgi-bin/JGNetForums/YaBB.cgi" target="_top" ALT="Forums"> + <AREA SHAPE="rect" ALT="JavaGames Home" COORDS="147,7,334,23" HREF="http://community.java.net/games"> + <AREA SHAPE="rect" ALT="Java.net" COORDS="21,7,128,23" HREF="http://www.java.net" TARGET="_self"> </MAP> <div align="center"><font color="#005177" size="+2">Welcome to the JOGL API @@ -66,7 +66,7 @@ with the AWT and Swing widget sets.<br> </p> <p>Please see the <a - href="http://jogl-demos.dev.java.net/">JOGL demos</a> for illustrations of + href="https://jogl-demos.dev.java.net/">JOGL demos</a> for illustrations of advanced OpenGL techniques now possible with the Java platform.<br> </p> </div> @@ -97,7 +97,7 @@ advanced OpenGL techniques now possible with the Java platform.<br> <div align="justify">The intial implementation of the JOGL API is available for download from <a - href="http://jogl.dev.java.net/source/browse/jogl/">CVS</a>. + href="https://jogl.dev.java.net/source/browse/jogl/">CVS</a>. </div> </td> </tr> @@ -130,7 +130,7 @@ advanced OpenGL techniques now possible with the Java platform.<br> href="http://www.antlr.org/">ANTLR</a> parser generator and the <a href="http://ant.apache.org/">Ant</a> build system to be installed; please see the <a - href="http://jogl.dev.java.net/unbranded-source/browse/*checkout*/jogl/doc/HowToBuild.html?rev=HEAD&content-type=text/html">build + href="https://jogl.dev.java.net/unbranded-source/browse/*checkout*/jogl/doc/HowToBuild.html?rev=HEAD&content-type=text/html">build documentation</a> for details. </p> @@ -238,25 +238,22 @@ documentation</a> for details. </p> <ul> <li><a href="http://www.opengl.org" target="_blank">OpenGL</a> Home</li> - <li><a href="http://jogl-demos.dev.java.net/">JOGL + <li><a href="https://jogl-demos.dev.java.net/">JOGL Demos</a></li> <li><a - href="http://javaoneonline.webinars.mentorware.net/content/subsystems/12064/courses/TS-1361(USA,2004)/0001/ts1361.pdf -">JOGL + href="ts1361.pdf">JOGL JavaOne 2004 Presentation Slides</a></li> <li><a - href="http://servlet.java.sun.com/javaone/resources/content/sf2003/conf/sessions/pdfs/2125.pdf">JOGL - JavaOne 2003 Presentation Slides</a> (requires free Java Developer Connection - registration)</li> + href="2125.pdf">JOGL + JavaOne 2003 Presentation Slides</a></li> <li><a href="http://www.javagaming.org/cgi-bin/JGNetForums/YaBB.cgi?board=jogl">JOGL Forums</a></li> <li><a href="https://jogl.dev.java.net/unbranded-source/browse/*checkout*/jogl/doc/userguide/index.html?rev=HEAD&content-type=text/html">JOGL User's Guide</a></li> <li><a - href="http://servlet.java.sun.com/javaone/resources/content/sf2002/conf/sessions/pdfs/3167.pdf">JavaOne - 2002 Slides</a> on <a href="http://jausoft.com/gl4java/">OpenGL for Java</a> - (requires free JDC registration)<br> + href="3167.pdf">JavaOne + 2002 Slides</a> on <a href="http://jausoft.com/gl4java/">OpenGL for Java</a><br> </li> @@ -287,7 +284,7 @@ documentation</a> for details. </p> <ul> <li><a - href="http://jogl.dev.java.net/servlets/ProjectDocumentList" + href="https://jogl.dev.java.net/servlets/ProjectDocumentList" target="_blank">Precompiled binaries and documentation</a></li> diff --git a/www/webstart/jogl-natives-linux.jar b/www/webstart/jogl-natives-linux.jar Binary files differindex b6b5b4aee..f17e6ebb0 100644 --- a/www/webstart/jogl-natives-linux.jar +++ b/www/webstart/jogl-natives-linux.jar diff --git a/www/webstart/jogl-natives-macosx.jar b/www/webstart/jogl-natives-macosx.jar Binary files differindex 9b2fdb2d6..9c9ba0904 100644 --- a/www/webstart/jogl-natives-macosx.jar +++ b/www/webstart/jogl-natives-macosx.jar diff --git a/www/webstart/jogl-natives-solsparc.jar b/www/webstart/jogl-natives-solsparc.jar Binary files differindex 1b720f866..cebc6df79 100644 --- a/www/webstart/jogl-natives-solsparc.jar +++ b/www/webstart/jogl-natives-solsparc.jar diff --git a/www/webstart/jogl-natives-win32.jar b/www/webstart/jogl-natives-win32.jar Binary files differindex 827ef3c84..ef7549dad 100644 --- a/www/webstart/jogl-natives-win32.jar +++ b/www/webstart/jogl-natives-win32.jar diff --git a/www/webstart/jogl.jar b/www/webstart/jogl.jar Binary files differindex a46fe514c..daedcc11d 100644 --- a/www/webstart/jogl.jar +++ b/www/webstart/jogl.jar |