diff options
Diffstat (limited to 'gl4java/GLContext.java.skel')
| -rw-r--r-- | gl4java/GLContext.java.skel | 2251 |
1 files changed, 2251 insertions, 0 deletions
diff --git a/gl4java/GLContext.java.skel b/gl4java/GLContext.java.skel new file mode 100644 index 0000000..c91e4f6 --- /dev/null +++ b/gl4java/GLContext.java.skel @@ -0,0 +1,2251 @@ +/** + * @(#) GLContext.java + */ + + +package gl4java; + +import gl4java.jau.awt.WinHandleAccess; + +import java.awt.*; +import java.applet.Applet; +import java.awt.event.*; +import java.lang.reflect.*; + +/** + * The base manager class for the OpenGL language mapping for Java ! + * + * <p> + * If you are interessting in further Documentation and/or + * the history of GL4Java follow the following link. + * + * <pre> + <a href="../GL4Java.html">The GL4Java Documentation</a> + * </pre> + * <p> + * + * All native libraries and GLFunc* and GLUFunc* implementations + * can/should be loaded right here ! + * + * <pre> + <a href="GLContext.html#loadNativeLibraries(java.lang.String, java.lang.String, java.lang.String)">loadNativeLibraries</a> + <a href="GLContext.html#createGLFunc(java.lang.String)">createGLFunc</a> + <a href="GLContext.html#createGLUFunc(java.lang.String)">createGLUFunc</a> + <p> + To check the library versions, you can start the + <a href="GLContext.html#main(java.lang.String[])">main</a> + function with <code>java gl4java.GLContext</code> + * </pre> + * + * <p> + * + * This class creates a GLContext in the constructor which fits to the native Window + * of the given Component ! + * + * <pre> + <a href="GLContext.html#GLContext(java.awt.Component, gl4java.GLFunc, gl4java.GLUFunc> + * </pre> + * + * <p> + * + * If you want to port any OpenGL program to GL4Java, + * you can use 'glc2glj'. This easy kornshell-sed script converts + * many types and Math function calls ;-). E.g.: All C double constant literals + * will be changed to floats (0.0 -> 0.0f) and all sin, cos, .. functions + * will get the '(float)Math.' prefix ! + * + * <pre> + <a href="../../../demos/glc2glj">glc2glj - A simple c to java converter for C- and GL-types</a> + * </pre> + * <p> + * + * The native libraries are plattform depended. + * + * <pre> + The default native library for Win32 and Unice's is : + <p> + GLContext: GL4JavaJauGljJNI + GLFuncJauJNI: GL4JavaJauGLJNI + GLUFuncJauJNI: GL4JavaJauGLUJNI + <p> + Note: + <p> + The default native library for Macintosh is : + <p> + GLContext: GL4JavaMacGZGljJNI + GLFuncJauJNI: GL4JavaMacGZGLJNI + GLUFuncJauJNI: GL4JavaMacGZGLUJNI + <p> + <p> + To check wich version and vendors are currently used, + just call while a GLContext is created : + <p> + <a href="GLContext.html#gljShowVersions()">gljShowVersions</a> + <p> + Where an own Frame is opened ! + * </pre> + * + * Make sure that this library is installed in your library path. + * The library path is for Unices one path of the environment + * variable �LD_LIBRARY_PATH� and for Windows 32 + * �c:/winnt/system32� (WinNT) or 'c:/windows/system' (Windows 95) . + * Or it should be installed in the 'jre/bin' or + * 'Netscape/communicator/Program/java/bin' path ! + * + * <p> + * + * To have a convinient usage, e.g. automatic resizing, GLContext + * and painting/gl-rendering, some classes in the package gl4java.awt + * may help you. + * + * <pre> + E.g.: <a href="awt/GLCanvas.html">gl4java.awt.GLCanvas</a> + <p> + <a href="awt/GLCanvas.html#init()">init</a> to create the java-stuff and GL-inits + <a href="awt/GLCanvas.html#display()">display</a> to render one frame, called by paint + <a href="awt/GLCanvas.html#reshape(int, int)">reshape</a> to reshape (window resize) + <p> + Or look for animation at + <a href="awt/GLAnimCanvas.html">gl4java.awt.GLAnimCanvas</a> ! + * </pre> + * + * <p> + * + * IF you remove/release a The component which is binded to this GLContext, + * you have to release the GLContext also - while calling: + * + * <pre> + <a href="GLContext.html#gljDestroy()">gljDestroy</a> + * </pre> + * + * before releasing/dispose it�s Window ! + * + * <p> + * + * We also define our own OpenGL extension. This extension functions + * start with the prefix glj like you can see here: + * + * <pre> + THIS FUNCTIONS ARE FOR USERS PURPOSES: + ====================================== + + <a href="GLContext.html#loadNativeLibraries(java.lang.String, java.lang.String, java.lang.String)">loadNativeLibraries</a> + <a href="GLContext.html#createGLFunc(java.lang.String)">createGLFunc</a> + <a href="GLContext.html#createGLUFunc(java.lang.String)">createGLUFunc</a> + <a href="GLContext.html#gljGetNativeLibVersion()">gljGetNativeLibVersion</a> + <a href="GLContext.html#gljGetClassVersion()">gljGetClassVersion</a> + <a href="GLContext.html#gljShowVersions()">gljShowVersions</a> + <a href="GLContext.html#gljCheckGL()">gljCheckGL</a> + <a href="GLContext.html#gljCheckGLTypes()">gljCheckGLTypes</a> + <a href="GLContext.html#gljResize(int, int)">gljResize</a> + <a href="GLContext.html#gljSwap()">gljSwap</a> + <a href="GLContext.html#gljIsInit()">gljIsInit</a> + <a href="GLContext.html#gljMakeCurrent(boolean)">gljMakeCurrent</a> + <a href="GLContext.html#gljDestroy()">gljDestroy</a> + <a href="GLContext.html#gljFree()">gljFree</a> + + * </pre> + * <p> + * + * You can see our example demo sources: + * <pre> + <a href="../../../demos/olympicCvs.java">olympicCvs.java as java source</a> + <a href="../../../demos/glLogoCvs.java">glLogoCvs.java as java source</a> + <a href="../../../demos/glDemosCvs.java">glDemosCvs.java as java source</a> + * </pre> + * <p> + * + * If you are interessting in further Documentation, downloading the latest + * version, and/or the history of GL4Java click on the following link. + * + * <pre> + <a href="http://www.jausoft.com/gl4java.html">The GL4Java Homepage</a> + * </pre> + * <p> + * + * @see WinDataAccess + * @version 2.00, 21. April 1999 + * @author Sven Goethel + * + */ +public class GLContext extends Object + implements Runnable +{ + + protected boolean isInitialized = false; + + /** + * Flag is the native library is loaded. + * The native library is loaded at startup. + * If we failed loading the lib., + * gljMakeCurrent and gljIsInit will return false. + * + * @see GLContext#gljMakeCurrent + * @see GLContext#gljIsInit + */ + protected static boolean libsLoaded = false; + + /** + * The default GLContext native library for Windows 95/NT && MS-JVM + * + */ + public static final String defGljMSWinLib = "GL4JavaGljMSJDirect" ; + + /** + * The default GLContext native library for all + * + */ + public static final String defGljLib = "GL4JavaJauGljJNI" ; + + /** + * The default GLFunc implementation + * + */ + public static final String defGLFuncClass = "GLFuncJauJNI" ; + + /** + * The default GLFunc native library for all + */ + public static final String defGLFuncLib = "GL4JavaJauGLJNI" ; + + /** + * The default GLUFunc implementation + * + */ + public static final String defGLUFuncClass = "GLUFuncJauJNI" ; + + /** + * The default GLUFunc native library for all + */ + public static final String defGLUFuncLib = "GL4JavaJauGLUJNI" ; + + + /** + * the version of this java-class + * + * <Major>.<Minor>.<BugFix>.<Release> + * + * Each <Value> is dezimal ! + */ + public static final String version = __SED_CLASS_VERSION__ ; + + /** + * Flag's to enable/disable verbose Information. + * Usually for debugging. + */ + public static boolean gljClassDebug = false; + public static boolean gljNativeDebug = false; + + /** + * We will store the GL Context right here. + * + * @see GLContext#createGLContext + * @see GLContext#gljInit + */ + protected int glContext=0; + + /** + * The context with witch display lists and textures will be shared. + * + * @see GLContext#createGLContext + * @see GLContext#gljInit + */ + protected GLContext sharedGLContext; + protected int sharedGLContextNative= 0; // No sharing by default. + + /** + * Xwindow data AND Windows data for the widget + * + * @see GLContext#createGLContext + * @see GLContext#gljInit + */ + protected int pixmapHandle=0; // unique handle for the Pixmap + protected int windowHandle=0; // unique handle for this widget's window + protected int displayHandle=0; // unqiue handle to the display + + /** + * MS-JDirect-Window data for the MS-JVM interface + * + * @see GLContext#createGLContext + * @see GLContext#gljInit + */ + private int createwinx; + private int createwiny; + private int createwinw; + private int createwinh; + private boolean threadRunning = false; + private boolean destroyWindow = false; + protected Container containerWindow = null; + + /** + * The custom set offscreen Size + * + * If this is set to != null, + * the offscreen pixmap is used in this size, + * not in the components-size (-> faster if smaller) + * + * Must be set via createOffScreenCtx + * + * @see GLJPanel#paint + * @see GLJPanel#createOffScreenCtx + */ + protected Dimension offScrnSize = null; + + /** + * Windows data AND flag is Window-Handel is read (for X11 also) ! + * + * @see GLContext#createGLContext + * @see GLContext#gljInit + */ + int pData = 0; // stores the pointer structure that holds windows info + + /** + * Flag to check, if the OpenGL-Context is active ! + * + * @see GLCanvas#gljIsEnabled + * @see GLCanvas#gljSetEnabled + */ + protected boolean glEnabled = true; + + /** + * Do we use offscreen rendering + * X11: pixmap eq window-ressources, + * window eq. GLXPixmap a GLXDrawable + * glContext eq. GLXContext + * + * This is set via the constructor ! + * + * @see GLContext#GLContext + */ + protected boolean offScreenRenderer = false; + + /** + * Do we use doubleBuffer - of course ! + * This is the default visual property ... ! + * + * This is set via the constructor ! + * + * @see GLContext#isDoubleBuffer + * @see GLContext#GLContext + */ + protected boolean doubleBuffer = true; + + /** + * Visual pre-set for stencil-bit number, default: 0 + * + * @see GLContext#GLContext + */ + protected int stencilBits = 0; + + /** + * Visual pre-set for accumulator-size number, default: 0 + * + * This value has a special behavior. + * For input - within the contructor, + * it is the value for each component ! + * + * The output value, after the constructor returns, + * it is the summary of all accumulation bits of all components ! + * + * @see GLContext#GLContext + */ + protected int accumSize = 0; + + /** + * Do we use stereoView - not yet ;-) ! + * This is the default visual property ... ! + * + * This is set via the constructor ! + * + * @see GLContext#isStereoView + * @see GLContext#GLContext + */ + protected boolean stereoView = false; + + /** + * Do we use True-Color RGBA - of course ;-) ! + * This is the default visual property ... ! + * + * This is set via the constructor ! + * + * @see GLContext#isRGBA + * @see GLContext#GLContext + */ + protected boolean rgba = true; + + /** + * We normally do not have to create an own Window ! + * This is the default visual property ... ! + * But some machines, like SGI's Irix, + * must use an own created overlapped window ! + * For these machines, a compiler flag is set, + * so that this value is alsways set to true ! + * + * This is set via the constructor ! + * + * @see GLContext#isOwnWindowCreated + * @see GLContext#GLContext + */ + protected boolean createOwnWindow = false; + + /** + * The resize flag, which indicates a resize for the next paint function ! + * This flag will bes set in 'componentResized' + * and will be cleared after resize (glViewport) in sDisplay !! + * + * @see gl4java.awt.GLCanvas#sDisplay + */ + protected boolean mustResize = false; + + protected Dimension size = null; + + /** + * the light- or heavy component + * where GL commands should be drawn + */ + protected Component _comp = null; + + /** + * the heavy component + * where GL commands should be drawn + * + * if the _comp component is a swing (light) + * component, this component contains its heavy parent ! + */ + protected Component _compHeavy = null; + + /** + * Variable to tell is where windows or not (X11) + * Usally X11 ;-)) + * + * Ok - lets give one to the Max :-) + */ + public static final int + OsWindoof = -1, + OsUnknown = 0, + OsX11 = 1, + OsMac = 2; // for Gerard Ziemski's port + + private static int osType=OsUnknown; + + private static boolean isNetscapeJvm = false; + private static boolean isMicrosoftJvm = false; + private static boolean useMSJDirect = false; + private static String jvmVendor = null; + private static String jvmVersion = null; + private static int jvmVersionMajor = 1; // min. defaults + private static int jvmVersionMinor = 1; // min. defaults + private static String osName = null; + + /** + * Get the native GL Context ! + * + * @see GLContext#glContext + */ + public final long getNativeGLContext() { return (long)glContext; } + + /** + * Get the native Window Handle ! + * + * @see GLContext#windowHandle + */ + public final long getNativeWindoHandle() { return (long)windowHandle; } + + /** + * Get the optional shared GL Context ! + * + * @see GLContext#sharedGLContext + */ + public final GLContext getSharedGLContext() { return sharedGLContext; } + + /** + * Get the native OS-Type ! + * + * @see GLContext#osType + * @see GLContext#OsWindoof + * @see GLContext#OsUnknown + * @see GLContext#OsX11 + * @see GLContext#OsMac + */ + public final int getNativeOSType() { return osType; } + + /** + * Query the visual property ... ! + * + * After a GLContext is created, this property can be queried ! + * + * @see GLContext#doubleBuffer + * @see GLContext#GLContext + */ + public final boolean isDoubleBuffer() { return doubleBuffer; } + + /** + * Query the visual property ... ! + * + * After a GLContext is created, this property can be queried ! + * + * @see GLContext#stereoView + * @see GLContext#GLContext + */ + public final int getStencilBitNumber() { return stencilBits; } + + /** + * Query the visual property ... ! + * + * After a GLContext is created, this property can be queried ! + * + * @see GLContext#GLContext + */ + public final int getAccumSize() { return accumSize; } + + /** + * Query the visual property ... ! + * + * After a GLContext is created, this property can be queried ! + * + * @see GLContext#stereoView + * @see GLContext#GLContext + */ + public final boolean isStereoView() { return stereoView; } + + /** + * Query the visual property ... ! + * + * After a GLContext is created, this property can be queried ! + * + * @see GLContext#rgba + * @see GLContext#GLContext + */ + public final boolean isRGBA() { return rgba; } + + /** + * Query the visual property ... ! + * + * After a GLContext is created, this property can be queried ! + * + * @see GLContext#createOwnWindow + * @see GLContext#GLContext + */ + public final boolean isOwnWindowCreated() { return createOwnWindow; } + + /** + * Support of loading the native library seperatly. + * + * Link with the native OpenGL library. If we cannot link, an exception + * is thrown. + * The name of the library is named e.g.: "GL4JavaJauGljJNI" at the + * Java level, or "libGL4JavaJauGljJNI.so" at the solaris level, + * or "GL4JavaJauGljJNI.dll" at the win32 level :-). + * + * @param gljLibName The name of the GLContex native library. + * If gljLibName==null, the default library will be used ! + * + * @param glLibName The name of the GLFunc native library. + * If glLibName==null, the default library will be used ! + * + * @param gluLibName The name of the GLUFunc native library. + * If gluLibName==null, the default library will be used ! + * + * @return boolean, true if succesfull ! + * + * @see GLContext#defGljLib + * + * @see GLContext#defGLFuncLib + * + * @see GLContext#defGLUFuncLib + */ + public static boolean loadNativeLibraries ( String gljLibName, + String glLibName, + String gluLibName + ) + { + if(libsLoaded) return true; + + String libNames[] = null; + + jvmVendor = java.lang.System.getProperty("java.vendor"); + jvmVersion = java.lang.System.getProperty("java.version"); + + if(gljClassDebug) + { + System.out.println("jvm vendor: "+jvmVendor); + System.out.println("jvm version: "+jvmVersion); + } + + int i0 = 0; + int i1 = jvmVersion.indexOf(".", i0); + String strhlp = null; + if(i1>0) + { + strhlp = jvmVersion.substring(i0,i1); + try { + jvmVersionMajor = Integer.valueOf(strhlp).intValue(); + } catch (Exception e) + {System.out.println("Not a number: "+strhlp+" ("+jvmVersion+")");} + } + i0 = i1+1; + i1 = jvmVersion.indexOf(".", i0); + if( i1 < 0 ) + i1 = jvmVersion.length(); // no 2nd dot, no bug version number + + if( 0<i0 && i0<i1 ) + { + strhlp = jvmVersion.substring(i0,i1); + try { + jvmVersionMinor = Integer.valueOf(strhlp).intValue(); + } catch (Exception e) + {System.out.println("Not a number: "+strhlp+" ("+jvmVersion+")");} + } + + if(gljClassDebug) + { + System.out.println("jvm version (parsed): "+ + "major: "+jvmVersionMajor+ + ", minor: "+jvmVersionMinor); + } + + isNetscapeJvm = jvmVendor!=null && jvmVendor.indexOf("Netscape")>=0 ; + isMicrosoftJvm = jvmVendor!=null && jvmVendor.indexOf("Microsoft")>=0 ; + + // Determine the OS + osName = System.getProperty( "os.name" ); + if( osName.startsWith( "Wind" ) ) + osType = OsWindoof; + else if( osName.startsWith( "Mac OS" ) ) + osType = OsMac; + else /* oops - lets guess unix/x11 :-) */ + osType = OsX11; + + String jniEXTsuff = ""; + + if( jvmVersionMajor>=2 || + ( jvmVersionMajor==1 && jvmVersionMinor>=2 ) + ) + { + jniEXTsuff = "12"; + } + + if(gljLibName==null) + gljLibName = defGljLib+jniEXTsuff; + if(glLibName==null) + glLibName = defGLFuncLib+jniEXTsuff; + if(gluLibName==null) + gluLibName = defGLUFuncLib+jniEXTsuff; + + if ( (osType==OsWindoof) && (isMicrosoftJvm) ) + { + // JDirect loads the GL libraries automatically, + // so we don't have to. + libNames = new String[4]; + libNames[0]= gljLibName; + libNames[1]= glLibName; + libNames[2]= gluLibName; + libNames[3]= defGljMSWinLib; + useMSJDirect = true; + } else { + /* For MAC, Win32+SunJVM, Unices ... + */ + libNames = new String[3]; + libNames[0]= gljLibName; + libNames[1]= glLibName; + libNames[2]= gluLibName; + useMSJDirect = false; + } + + if(isNetscapeJvm) + { + System.out.println("Netscape JVM try to get Privileges"); + try { + Class privmgr = + Class.forName("netscape.security.PrivilegeManager"); + Class[] parameterTypes = new Class[1]; + parameterTypes[0] = Class.forName("java.lang.String"); + Method m = privmgr.getMethod("enablePrivilege",parameterTypes); + Object args[] = new Object[1]; + args[0] = (Object)(new String("UniversalLinkAccess")); + m.invoke(privmgr,args); + /* + netscape.security.PrivilegeManager.enablePrivilege + ("UniversalLinkAccess"); + */ + System.out.println("Netscape-Privilege: enabled UniversalLinkAccess priv."); + } catch (Exception ex) + { + System.out.println("Not enabled Netscape-Privilege: UniversalLinkAccess priv."); + } + } + + /* load libs */ + int libNumber = 0; + String _libName = null ; + boolean libLoaded[] = new boolean[libNames.length]; + + for(libNumber=0; libNumber<libNames.length; libNumber++) + libLoaded[libNumber]=false; + + for(libNumber=0; libNumber<libNames.length; libNumber++) + { + do { + try { + System.loadLibrary( libNames[libNumber] ); + libLoaded[libNumber]=true; + if(gljClassDebug) + { + System.out.println("loaded native library: "+ + libNames[libNumber]); + } + } catch ( UnsatisfiedLinkError e) { + System.out.println + ( "Sorry, can't find the library: "+ + libNames[libNumber]+"\n"+e ); + + libNames[libNumber]=null; // stop trying ... :-( + } + } while( libLoaded[libNumber]==false && + libNames[libNumber]!=null ); + } + + for(libNumber=0; libNumber<libNames.length; libNumber++) + { + if(libLoaded[libNumber]==false) break; + } + if(libNumber==libNames.length) + { + libsLoaded=true; + } + + return libsLoaded; + } + + /** + * no no no .. the user has to choose ! + * + * The user must call loadNativeLibrary ! + * + * @see GLContext#loadNativeLibrary + * + * static { + * if(!libLoaded) + * loadNativeLibrares(null, null, null); + * } + */ + + /** + * Test to load the native library, GLFunc and GLUFunc implementation ! + * If succesfull, a Frame will created and the GL-Infos (vendor, ...) + * are shown in it ! + * + * @param args, a list of args, + * + * -gljlib <glj-libname> gl4java-glj-lib native library + * -gllib <gl-libname> gl4java-gl-lib native library + * -glulib <glu-libname> gl4java-glu-lib native library + * -glclass <gl-class> gl4java-gl-class java GLFunc implementation + * -gluclass <glu-class> gl4java-glu-class java GLUFunc implementation + * -info creates a GLContext and prints all avaiable information of GL/GLU and GL4Java + * -infotxt like -info, but exits straight after -info ! + * + * without any arguments, a help screen is shown + */ + public static void main( String args[] ) + { + String gljLibName = null; + String glLibName = null; + String gluLibName = null; + String glName = defGLFuncClass; + String gluName = defGLUFuncClass; + boolean info=false; + boolean exitImmediatly=false; + int i = 0; + boolean ok=true; + + if(args.length==0) + { + System.out.println("usage: java gl4java.GLContext <options>, where options can be: "); + System.out.println(" -gljlib <glj-libname> \t choose a custom the gl4java-glj-lib native library (default: GL4JavaJauGljJNI)"); + System.out.println(" -gllib <gl-libname> \t choose a custom the gl4java-gl-lib native library (default: GL4JavaJauGLJNI)"); + System.out.println(" -glulib <glu-libname> \t choose a custom the gl4java-glu-lib native library (default: GL4JavaJauGLUJNI"); + System.out.println(" -glclass <gl-class> \t choose a custom the gl4java-gl-class java GLFunc implementation (default: GLFuncJauJNI)"); + System.out.println(" -gluclass <glu-class> \t choose a custom the gl4java-glu-class java GLUFunc implementation (default: GLUFuncJauJNI)"); + System.out.println(" -info \t creates a GLContext and prints all avaiable information of GL/GLU and GL4Java"); + System.out.println(" -infotxt \t like -info, but exits straight after -info !"); + System.exit(0); + } + + while(args.length>i) + { + if(args[i].equals("-gljlib")) { + if(args.length>++i) gljLibName=args[i]; + } else if(args[i].equals("-gllib")) { + if(args.length>++i) glLibName=args[i]; + } else if(args[i].equals("-glulib")) { + if(args.length>++i) gluLibName=args[i]; + } else if(args[i].equals("-glclass")) { + if(args.length>++i) glName=args[i]; + } else if(args[i].equals("-gluclass")) { + if(args.length>++i) gluName=args[i]; + } else if(args[i].equals("-info")) { + info=true; + } else if(args[i].equals("-infotxt")) { + info=true; + exitImmediatly=true; + } else { + System.out.println("illegal arg "+i+": "+args[i]); + ok=false; + } + i++; + } + + GLContext.gljNativeDebug = true; + GLContext.gljClassDebug = true; + + GLFunc gl = null; + GLUFunc glu = null; + + if(GLContext.loadNativeLibraries(gljLibName, glLibName, gluLibName)) + System.out.println("native Libraries loaded succesfull"); + else { + System.out.println("native library NOT loaded complete"); + ok=false; + } + + if( (gl=GLContext.createGLFunc(glName)) !=null) + System.out.println("GLFunc implementation "+glName+" created succesfull"); + else { + System.out.println("GLFunc implementation "+glName+" not created"); + ok=false; + } + if( (glu=GLContext.createGLUFunc(gluName)) !=null) + System.out.println("GLUFunc implementation "+gluName+" created succesfull"); + else { + System.out.println("GLUFunc implementation "+gluName+" not created"); + ok=false; + } + + if( info && ok==true) { + Frame f = new Frame("GL4Java Info"); + f.setSize(10, 10); + + f.pack(); + f.setVisible(true); + + GLContext glj = new GLContext(f, gl, glu); + + Frame fInfo = glj.gljShowVersions(); + + fInfo.addWindowListener + ( new WindowAdapter() + { + public void windowClosed(WindowEvent e) + { + // button exit + System.exit(0); + } + } + ); + + glj.gljDestroy(); + + if(exitImmediatly) + System.exit(0); + } + } + + public static String getJVMVendor() { return jvmVendor; } + public static boolean isNetscapeJVM() { return isNetscapeJvm; } + public static boolean isMicrosoftJVM() { return isMicrosoftJvm; } + + /** + * Used to hold the user given GLFunc implementation + */ + private GLFunc gl = null; + + /** + * Used to hold the user given GLUFunc implementation + */ + private GLUFunc glu = null; + + /** + * + * Constructor + * + * This privat constructor is for all possible + * compinations and is called from the customized + * constructors. + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _createOwnWindow the flag for the visual property + * @param _offScreenRenderer the flag for the visual property + * @param _doubleBuffer the flag for the visual property + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * @param _accumSize the flag for the visual property + * @param _sharedGLContext the shared GLContext + * @param _offScrnSize the fixed offscreen pixmap size + * + */ + protected GLContext( Component comp, GLFunc glf, GLUFunc gluf, + boolean _createOwnWindow, boolean _offScreenRenderer, + boolean _doubleBuffer, boolean _stereoView, + boolean _rgba, + int _stencilBits, + int _accumSize, + GLContext _sharedGLContext, + Dimension _offScrnSize + ) + { + super( ); + + _comp = comp ; // the light- or heavy component + gl = glf ; + glu = gluf ; + createOwnWindow = _createOwnWindow; + offScreenRenderer = _offScreenRenderer; + doubleBuffer=_doubleBuffer; + stereoView=_stereoView; + rgba=_rgba; + stencilBits=_stencilBits; + accumSize=_accumSize; + offScrnSize= _offScrnSize; + + this.sharedGLContext = _sharedGLContext; + if(sharedGLContext != null) + sharedGLContextNative = + (int)sharedGLContext.getNativeGLContext(); + + // fetch the heavy peer component in temporary var. comp + while(comp!=null && + (comp.getPeer() instanceof java.awt.peer.LightweightPeer) + ) + comp=comp.getParent(); + + _compHeavy = comp ; // the heavy component + + Graphics _gr = null; + + if(_compHeavy!=null) + { + if( ! _comp.isVisible() ) + setVisible(true); // use our own ... + + + _gr = _compHeavy.getGraphics(); + if(_gr==null) + System.out.println("got empty Graphics"); + } else + System.out.println("got empty Component"); + + if(_comp!=null && _gr!=null) + { + int i = 0; + do { + createGLContext(_gr); // uses _comp + if(gljIsInit()==false) + { + try + { + Thread.sleep( 100 ); + } + catch( Exception e ) + { } + } + i++; + } while(gljIsInit()==false && i<5) ; + } + + if(gljClassDebug) + { + if(gljIsInit()) + System.out.println(">>> GLContext() succeded"); + else + System.out.println(">>> GLContext() failed"); + } + } + + /** + * + * Constructor + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _createOwnWindow the flag for the visual property + * @param _doubleBuffer the flag for the visual property + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * @param _accumSize the flag for the visual property + * @param _sharedGLContext the shared GLContext + * + */ + public GLContext( Component comp, GLFunc glf, GLUFunc gluf, + boolean _createOwnWindow, + boolean _doubleBuffer, boolean _stereoView, + boolean _rgba, + int _stencilBits, + int _accumSize, + GLContext _sharedGLContext + ) + { + this(comp, glf, gluf, + _createOwnWindow, false /* offscreen renderer */, + _doubleBuffer, + _stereoView, + _rgba, + _stencilBits, + _accumSize, + _sharedGLContext, + null /* offscreen size */ + ); + } + + /** + * + * Constructor + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _createOwnWindow the flag for the visual property + * @param _doubleBuffer the flag for the visual property + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * @param _accumSize the flag for the visual property + * + */ + public GLContext( Component comp, GLFunc glf, GLUFunc gluf, + boolean _createOwnWindow, + boolean _doubleBuffer, boolean _stereoView, + boolean _rgba, + int _stencilBits, + int _accumSize + ) + { + this(comp, glf, gluf, + _createOwnWindow, false /* offscreen renderer */, + _doubleBuffer, + _stereoView, + _rgba, + _stencilBits, + _accumSize, + null /* sharedGLContext */, + null /* offscreen size */ + ); + } + + /** + * + * Constructor + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _createOwnWindow the flag for the visual property + * @param _doubleBuffer the flag for the visual property + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * + */ + public GLContext( Component comp, GLFunc glf, GLUFunc gluf, + boolean _createOwnWindow, + boolean _doubleBuffer, boolean _stereoView, + boolean _rgba, + int _stencilBits + ) + { + this(comp, glf, gluf, + _createOwnWindow, false /* offscreen renderer */, + _doubleBuffer, + _stereoView, + _rgba, + _stencilBits, + 0 /* accumSize */, + null /* sharedGLContext */, + null /* offscreen size */ + ); + } + + /** + * + * Constructor + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _doubleBuffer the flag for the visual property + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * + */ + public GLContext( Component comp, GLFunc glf, GLUFunc gluf, + boolean _doubleBuffer, boolean _stereoView, + boolean _rgba, + int _stencilBits, + int _accumSize + ) + { + this(comp, glf, gluf, + false /* ownWindow */, false /* offscreen renderer */, + _doubleBuffer, + _stereoView, + _rgba, + _stencilBits, + _accumSize, + null /* sharedGLContext */, + null /* offscreen size */ + ); + } + + /** + * + * Constructor + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _doubleBuffer the flag for the visual property + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * + */ + public GLContext( Component comp, GLFunc glf, GLUFunc gluf, + boolean _doubleBuffer, boolean _stereoView, + boolean _rgba, + int _stencilBits + ) + { + this(comp, glf, gluf, + false /* ownWindow */, false /* offscreen renderer */, + _doubleBuffer, + _stereoView, + _rgba, + _stencilBits, + 0 /* accumSize */, + null /* sharedGLContext */, + null /* offscreen size */ + ); + } + + /** + * + * Constructor + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _doubleBuffer the flag for the visual property + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * + */ + public GLContext( Component comp, GLFunc glf, GLUFunc gluf, + boolean _doubleBuffer, boolean _stereoView, + boolean _rgba + ) + { + this(comp, glf, gluf, + false /* ownWindow */, false /* offscreen renderer */, + _doubleBuffer, + _stereoView, + _rgba, + 0, /* _stencilBits */ + 0 /* accumSize */, + null /* sharedGLContext */, + null /* offscreen size */ + ); + } + + /** + * + * Constructor + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * ! WARNING ! This flag is just for testing purpose !!! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _doubleBuffer the flag for the visual property + * @param _stereoView the flag for the visual property + * + */ + public GLContext( Component comp, GLFunc glf, GLUFunc gluf, + boolean _doubleBuffer, boolean _stereoView + ) + { + this(comp, glf, gluf, + false /* ownWindow */, false /* offscreen renderer */, + _doubleBuffer, + _stereoView, + true /* _rgba */, + 0, /* _stencilBits */ + 0 /* accumSize */, + null /* sharedGLContext */, + null /* offscreen size */ + ); + } + + /** + * + * Constructor + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * We use a visual with doubleBuffer and NO stereoView ! + * Do not force a new native window ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + */ + public GLContext( Component comp, GLFunc glf, GLUFunc gluf ) + { + this(comp, glf, gluf, + false /* ownWindow */, false /* offscreen renderer */, + true /* _doubleBuffer */, + false /* _stereoView */, + true /* _rgba */, + 0, /* _stencilBits */ + 0 /* accumSize */, + null /* sharedGLContext */, + null /* offscreen size */ + ); + } + + /** + * + * Constructor Function for offscreen rendering ! + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * @param _sharedGLContext the shared GLContext + * + * @return the created offscreen context + */ + public static final GLContext createOffScreenCtx + ( Component comp, GLFunc glf, GLUFunc gluf, + boolean _stereoView, + boolean _rgba, + int _stencilBits, + int _accumSize, + GLContext _sharedGLContext + ) + { + return new GLContext(comp, glf, gluf, + false /* _createOwnWindow */, + true /* offscreen renderer */, + false /* _doubleBuffer */, + _stereoView, + _rgba, + _stencilBits, + _accumSize, + _sharedGLContext, + null + ); + } + + /** + * + * Constructor Function for offscreen rendering ! + * + * First the GLContext is fetched from the Component itself ! + * To do so, the Component is set visible if it is not ! + * + * If a GLContext is fetched, it is current ! + * + * @param comp the users component for the gl-context + * @param glf the users selected GLFunc implementation + * @param glf the users selected GLUFunc implementation + * @param _stereoView the flag for the visual property + * @param _rgba the flag for the visual property + * @param _stencilBits the flag for the visual property + * @param _sharedGLContext the shared GLContext + * @param _offScrnSize the fixed offscreen pixmap size + * + * @return the created offscreen context + */ + public static final GLContext createOffScreenCtx + ( Component comp, GLFunc glf, GLUFunc gluf, + boolean _stereoView, + boolean _rgba, + int _stencilBits, + int _accumSize, + GLContext _sharedGLContext, + Dimension _offScrnSize + ) + { + return new GLContext(comp, glf, gluf, + false /* _createOwnWindow */, + true /* offscreen renderer */, + false /* _doubleBuffer */, + _stereoView, + _rgba, + _stencilBits, + _accumSize, + _sharedGLContext, + _offScrnSize + ); + } + + /** + * Used to set the user given GLFunc implementation + */ + public final void setGLFunc(GLFunc _gl) { gl = _gl; } + + /** + * Used to set the user given GLUFunc implementation + */ + public final void setGLUFunc(GLUFunc _glu) { glu = _glu; } + + /** + * Used to return the user given GLFunc implementation + */ + public final GLFunc getGLFunc() { return gl; } + + /** + * Used to return the user given GLUFunc implementation + */ + public final GLUFunc getGLUFunc() { return glu; } + + /** + * Support of loading a vendors GLFunc implementation + * + * Try to load the Class, if succesfull we do return the instance of it. + * Else null is returned ! + * + * The Class-Name is: "GL4Java." + vendorClass + ".class" ! + * + * @param vendorClass The name of the GLFunc implementation. + * If vendorSuffix==null, the default implementation + * "GLFuncJauJNI" (-> GL4Java.GLFuncJauJNI.class ) + * will be used ! + * + * @return GLFunc, the implementation's instance if exists + * and valid, or null + * + * @see GLContext#defGLFuncClass + */ + public static final GLFunc createGLFunc(String vendorClass) + { + String access_name = "gl4java."; + GLFunc gl = null; + Object clazz = null; + + if(vendorClass==null) + { + vendorClass = defGLFuncClass ; + } + + String clazzName = access_name + vendorClass ; + + try { + clazz = Class.forName(clazzName).newInstance(); + } catch (Exception ex) { + // thats ok :-) + System.out.println("could not create instance of: "+ clazzName); + } + if(clazz !=null && (clazz instanceof GLFunc)) + gl = (GLFunc) clazz; + else + System.out.println("Not a GLFunc implementation: "+ clazzName); + + return gl; + } + + /** + * Support of loading a vendors GLUFunc implementation + * + * Try to load the Class, if succesfull we do return the instance of it. + * Else null is returned ! + * + * The Class-Name is: "GL4Java." + vendorClass + ".class" ! + * + * @param vendorClass The name of the GLUFunc implementation. + * If vendorSuffix==null, the default implementation + * "GLUFuncJauJNI" (-> GL4Java.GLUFuncJauJNI.class ) + * will be used ! + * + * @return GLUFunc, the implementation's instance if exists + * and valid, or null + * + * @see GLContext#defGLUFuncClass + */ + public static final GLUFunc createGLUFunc(String vendorClass) + { + String access_name = "gl4java."; + GLUFunc glu = null; + Object clazz = null; + + if(vendorClass==null) + { + vendorClass = defGLUFuncClass ; + } + + + String clazzName = access_name + vendorClass ; + + try { + clazz = Class.forName(clazzName).newInstance(); + } catch (Exception ex) { + // thats ok :-) + System.out.println("could not create instance of: "+ clazzName); + } + if(clazz!=null && (clazz instanceof GLUFunc)) + glu = (GLUFunc) clazz; + else + System.out.println("Not a GLUFunc implementation: "+ clazzName); + + + return glu; + } + + /** + * + * Own setVisible + * This one set's us visible - and wait's for that result ! + * + * @param visible boolean: visible==true, hide==false + * @return void + */ + public void setVisible( boolean visible ) + { + int i= 0; + + _comp.setVisible( visible ); + + while( _comp.isVisible() != visible && i<5) + { + _comp.setVisible( visible ); + + try + { + Thread.sleep( 100 ); + } + catch( Exception e ) + { + System.out.println( "GLContext:setVisible: Error - " + e ); + } + i++; + } + if(i>=5) + System.out.println( "GLContext:setVisible: Error, could not set to "+visible); + } + + /** + * + * createGLContext gets the window handle and calls gljInit, + * so the gl-context will be initialised here. + * + * this method will be invoked by the constructor + * + * this method is left public - this time, + * to allow the user to to it again later - if it was not succesfull ! + * + * @param g the graphics reference, + * where we will get the native window handle from. + * + * @return void + * + * @see GLContext#GLContext + */ + public final void createGLContext(Graphics g) + { + String access_name = "gl4java.jau.awt."; + WinHandleAccess win_access = null; + + try { + if(gljClassDebug) + System.out.println(">>> createGLContext"); + + if(pData == 0) + { + if ( useMSJDirect ) + { + if(gljClassDebug) + System.out.println("using MSJDirect ..."); + + win_access = (WinHandleAccess) + Class.forName(access_name + "windows.MSWin32HandleAccess").newInstance(); + /* _comp should be a subclass of Canvas, and its parent + class should be of type Panel, Frame or Window. If not, + this all falls apart. */ + + /* This part is now rewritten, + to respect direkt Windows (Frames and Dialogs) + and Applets .. */ + + Component ob = _comp; + + while ( (ob instanceof Window)==false && + (ob instanceof Applet)==false + ) + { + ob = ob.getParent(); + } + + containerWindow = (Container)ob; + + /* refetch the Graphics component */ + g = ob.getGraphics(); + if(g==null) + System.out.println("GL4Java-MSJVM: got empty Graphics"); + + pData = (int)win_access.getWinHandle(ob,g); + + if (pData != 0) + { + Point p1; + try + { + p1 = _comp.getLocationOnScreen(); + } + catch (Exception e) + { + p1 = _comp.getLocation(); + Point p2 = containerWindow.getLocation(); + p1.x += p2.x; + p1.y += p2.y; + Insets is = containerWindow.getInsets(); + p1.x += is.left; + p1.y += is.top; + } + Rectangle r = _comp.getBounds(); + createwinx = p1.x; + createwiny = p1.y; + createwinw = r.width; + createwinh = r.height; + windowHandle = 0; + threadRunning = true; + destroyWindow = false; + Thread th = new Thread(this); + th.start(); + while ( (windowHandle == 0) && (threadRunning) ) + { + try + { + Thread.currentThread().sleep(100); + } + catch( Exception e ) + { } + } + } + } else if(osType==OsWindoof) + { + win_access = (WinHandleAccess) + Class.forName(access_name + "windows.Win32HandleAccess").newInstance(); + pData = (int) win_access.getWinHandle(_compHeavy, g); + windowHandle = pData; + } + else if(osType==OsMac) + { + win_access = (WinHandleAccess) + Class.forName(access_name + "macintosh.MacHandleAccess").newInstance(); + pData = (int) win_access.getWinHandle(_compHeavy, g); + windowHandle = pData; + } + else /* X11 */ + { + win_access = (WinHandleAccess) + Class.forName(access_name + "motif.X11HandleAccess").newInstance(); + pData = (int) win_access.getWinHandle(_compHeavy, g); + windowHandle = pData; + } + } + + if(offScrnSize!=null) + { + createwinw = offScrnSize.width; + createwinh = offScrnSize.height; + } else { + Rectangle r = _comp.getBounds(); + createwinw = r.width; + createwinh = r.height; + } + + /* try to establish a context to OpenGL */ + try + { + gljInit(); + } + catch( GL4JavaInitException e ) + { + System.out.println( "can't create a GL context\n"); + } + + } catch (Exception e) { + System.out.println( "An exception is thrown, while creating a GL context\n"); + System.out.println(e); + e.printStackTrace(); + } + } + + /* glj* stuff */ + + /** + * + * Initializes the gl-context. + * gljInit is called by createGLContext (which is calles by the first paint)! + * + * Also gljInit will call the init method after GL initialisation, + * so the user can override �init� to initialize his own stuff ! + * + * @return void + * @exception GL4Java.GL4JavaInitException + * this class throws an exception + * if the native call to create a OpenGL context failed. + * @see GLContext#createGLContext + * @see gl4java.awt.GLCanvas#paint + * @see gl4java.awt.GLCanvas#init + */ + protected final synchronized void gljInit() + throws GL4JavaInitException + { + if( libsLoaded==false ) return ; + + if(pData==0 && !offScreenRenderer) + { + System.out.println("could not open a GL widget -- Win CONTEXT"); + throw new GL4JavaInitException (); + } + + if(gljClassDebug) + System.out.println(">>> gljInit"); + + if( openOpenGLNative() == false ) + { + if ( useMSJDirect ) + { + destroyWindow = true; + while (threadRunning) + { + try + { + Thread.currentThread().sleep(100); + } + catch( Exception e ) + { } + } + pData = 0; + windowHandle = 0; + } + System.out.println("could not open a GL widget -- GL CONTEXT"); + throw new GL4JavaInitException (); + } else { + isInitialized = true; + } + } + + /** + * For MSJVM Only ! + * + * This functions fetches the window-handle within a special thread ! + */ + public void run() + { + if ( !useMSJDirect ) + { + System.err.println("GL4Java-MSJVM-Run: INTERNAL ERROR"); + System.exit(0); + } + + pData = gl4java.system.GljMSJDirect.createOGLWindowNative( + pData, + createwinx,createwiny, + createwinw,createwinh); + if (pData != 0) + { + windowHandle = pData; + while (!destroyWindow) + { + gl4java.system.GljMSJDirect.OGLWindowMsgPump(); + try + { + Thread.currentThread().sleep(10); + } + catch( Exception e ) + { } + } + destroyWindow = false; + gl4java.system.GljMSJDirect.destroyOGLWindowNative( + windowHandle); + windowHandle = 0; + pData = 0; + gl4java.system.GljMSJDirect.OGLWindowMsgPump(); + } + threadRunning = false; + } + + /** + * + * Checks if the gl-context is Initializes + * If returns true, + * gljInit is allready called and a valid gl-context is achieved. + * + * No glMakeCurrent is done - + * like gljMakeCurrent (important for more gl-context) ! + * + * <p> + * + * The user can use this method to check if he can start rendering + * and to be sure his initialisation (init) is done ! + * + * <p> + * + * If you use gl4java.awt.GLCanvas, you should use the cvsIsInit + * method ! + * <p> + * + * @return boolean + * @see GLContext#gljInit + * @see gl4java.awt.GLCanvas#cvsIsInit + */ + public final boolean gljIsInit() + { + return isInitialized; + } + + /** + * Resizes the gl-viewport + * + * Should be called, if the component is resized. + * The user should take advantage of this functionality. + * + * Be sure to resize not within the event-method of the + * ComponentHandler, you better resize while normal painting. + * This can be done while using a boolean flag ;-) + * + * Look at GLComponent ! + */ + public final void gljResize(int width, int height) + { + if ( ! isInitialized || !glEnabled ) return; + + if(offScreenRenderer) + { + //JAU: TODO + return; + } + + if ( useMSJDirect ) + { + try + { + Point p = _comp.getLocationOnScreen(); + gl4java.system.GljMSJDirect.moveOGLWindowNative( + windowHandle,p.x,p.y,width,height); + } + catch (Exception e) + { } + } + else + gljResizeNative( createOwnWindow, + displayHandle, windowHandle, + width,height); + } + + private final native void gljResizeNative( boolean isOwnWindow, + int disp, int thisWin, + int width, int height ); + + /** + * native C function to open the OpenGLwidget + */ + protected final native boolean openOpenGLNative(); + + /** + * native C function to check the gl types. + * At this time, all GL* types will be checked if they fit's + * in the used java JNI types. + * + * this checks is allready performed, while the GL context is + * fetched with gljInit ! + * + * BUT we used this function, to perform a check without an + * X11-connection to our AIX host ;-)) + * So a call to this function is not needed ! + */ + public static final boolean gljCheckGLTypes() + { + return gljCheckGLTypesNative(); + } + + private static final native boolean gljCheckGLTypesNative(); + + public final boolean gljCheckGL() + { + int ec = gl.glGetError(); + + if(ec!=GLFunc.GL_NO_ERROR) + { + String errStr = glu.gluErrorString(ec); + + try + { + throw new Exception(); + } + catch (Exception e) + { + System.out.println("GL ERROR : "+errStr); + System.out.println("GL ERROR : "+ec+" == 0x"+Integer.toHexString(ec)); + e.printStackTrace(); + System.out.println(); + System.out.flush(); + } + + return false; + } + return true; + } + + /** + * + * gljMakeCurrent checks whether GL4Java is initializes + * AND makes the GL-Context current for this thread. + * + * It's more save to use �gljMakeCurrent�, instead of + * �gljMakeCurrentNative�, because we do check if GL is initalised ! + * + * @return boolean + */ + public final boolean gljMakeCurrent() + { + if ( ! isInitialized || !glEnabled ) + return false; + + return gljMakeCurrentNative( displayHandle, + windowHandle, + glContext); + } + + + /** + * + * gljMakeCurrent checks whether GL4Java is initializes + * AND makes the GL-Context current for this thread. + * + * It's more save to use �gljMakeCurrent�, instead of + * �gljMakeCurrentNative�, because we do check if GL is initalised ! + * + * @param freeContextFirst is obsolete ! + * + * @return boolean + * + * @deprecated The argument freeContextFirst is obsolete ! + */ + public final boolean gljMakeCurrent(boolean freeContextFirst) + { + if ( ! isInitialized || !glEnabled ) + return false; + + return gljMakeCurrentNative( displayHandle, + windowHandle, + glContext); + } + + private static final native boolean gljMakeCurrentNative( + int disp, + int thisWin, + int glContext); + + /** + * + * gljGetCurrentContext fetches the current native + * GL-Context, which is attached to this _native_ thread ! + * + * @return int + */ + public static final native int gljGetCurrentContext(); + + /** + * + * gljDestroy free�s AND destroy�s the GL Context + * + * This function should be called when removing + * a GLContext !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + * + * @return void + * + * @see GLContext#gljMakeCurrent + * @see GLContext#gljSwap + */ + public final synchronized boolean gljDestroy() + { + boolean result = true; + + if (!gljDestroyNative()) + result = false; + + windowHandle = 0; + glContext = 0; + pixmapHandle = 0; + + + if ( useMSJDirect ) + { + destroyWindow = false; + gl4java.system.GljMSJDirect.destroyOGLWindowNative( pData ); + windowHandle = 0; + gl4java.system.GljMSJDirect.OGLWindowMsgPump(); + } + + pData = 0; + + return result; + } + + private final native boolean gljDestroyNative(); + + /** + * + * gljFree free�s the GL Context + * + * This could be called after at last in your display function, + * if you have GC problems .... + * + * @return void + * + * @see GLContext#gljMakeCurrent + * @see GLContext#gljSwap + * @see gl4java.awt.GLCanvas#sDisplay + */ + public final boolean gljFree() + { + if ( ! isInitialized ) return false; + + return gljFreeNative ( displayHandle, + windowHandle, + glContext); + } + + private static final native boolean gljFreeNative( int disp, + int thisWin, + int glContext ); + + /** + * swap method are for double buffering + */ + public final boolean gljSwap() + { + if ( ! isInitialized ) return false; + + return gljSwapNative( displayHandle, + windowHandle, + glContext, + doubleBuffer); + } + + private static final native boolean gljSwapNative( int disp, + int thisWin, + int glContext, + boolean doubleBuffer ); + + /** + * This function enables, disables the GL-Context ! + * If false is given, the openGL renderer/context is + * disabled and disconected (gljFree is called, if initialized) ! + * + * If disabled, gljMakeCurrent returns always false ! + * + * @return boolean + * + * @see GLContext#gljIsEnabled + * @see GLContext#gljMakeCurrent + */ + public void setEnabled(boolean b) + { + glEnabled = b; + if ( b==false && isInitialized ) + gljFree(); + } + + /** + * This function queries, if the GL-Context is enabled ! + * + * @return boolean + * + * @see GLContext#setEnabled + * @see GLContext#gljMakeCurrent + */ + public boolean isEnabled() + { + return glEnabled; + } + + /** + * This functions checks the existence of + * the GL functions ! + */ + public final static native boolean gljTestGLProc + ( String name, boolean verbose ); + + /** + * This functions reads the pixel from the GL frame + * and puts it into the pixelDest array, + * while converting them correctly to the AWT pixel format, + * using GL_RGB[A] and BufferedImage.TYPE_INT[A]RGB ! + */ + public final static native void gljReadPixelGL2AWT ( + int x, int y, int width, int height, + int format, int type, int bufferName, + byte[] pixelGL, int[] pixelDest); + + /** + * Experimental Code, not done yet ! + * This one is to upspeed the Offscreen rendering engine for e.g. Swing ! + * + * This functions reads the pixel from the GL frame + * and puts it into the pixelDest array, + * while using hardware correct AWT and GL pixel format, + * using GL_BGR[A]_EXT and BufferedImage.TYPE_[34]BYTE_[A]BGR ! + * + * ATTENTION: This functions runs only if hardware supports this, + * e.g. on Win32 platforms !!! + */ + public final static native void gljReadPixelGL2AWT ( + int x, int y, int width, int height, + int format, int type, int bufferName, + byte[] pixelGLDest); + + /** + * Experimental Code, not done yet ! + * This one is to upspeed the Offscreen rendering engine for e.g. Swing ! + */ + public final native void gljCpyOffScrnImg2Buffer(int width, int height, int format, byte[] pixelDest); + + /** + * Experimental Code, not done yet ! + * This one is to upspeed the Offscreen rendering engine for e.g. Swing ! + */ + public final native void gljCpyOffScrnImg2Buffer(int width, int height, int format, int[] pixelDest); + + /** + * native C function to achieve the native lib vendor ! + * + * now it is possible to check the native-lib at runtime ! + */ + public final static String gljGetNativeLibVendor() + { + return gljGetNativeLibVendorNative(); + } + + private final static native String gljGetNativeLibVendorNative(); + + /** + * native C function to achieve the native lib version ! + * + * now it is possible to check the native-lib at runtime ! + */ + public final static String gljGetNativeLibVersion() + { + return gljGetNativeLibVersionNative(); + } + + private final static native String gljGetNativeLibVersionNative(); + + /** + * function to achieve the java-class version ! + * + * now it is possible to check the java-class at runtime ! + */ + public final static String gljGetClassVersion() + { return version; } + + /** + * function to achieve the java-class vendor ! + * + * now it is possible to check the java-class at runtime ! + */ + public final static String gljGetClassVendor() + { return "Jausoft - Sven Goethel Software Development"; } + + /** + * function to achieve complete version info + * + * Be sure that the native library must be loaded ! + */ + public final String gljGetVersions() + { + return gljGetVersions(false); + } + + public final String gljGetVersions(boolean verbose) + { + if(libsLoaded==false || gl==null || glu==null || !gljIsInit()) + return null; + + String info1= "GL4Java - LGPL-Version" + "\n" + + "-------------------------------------------------\n" + + "-------------------------------------------------\n" + + "Java-Class : GL4Java.GLContext \n" + + " : Version: "+gljGetClassVersion() + "\n" + + " Vendor : "+gljGetClassVendor() + "\n" + + "Native-Library : GL4Java.GLContext \n" + + " Version: "+gljGetNativeLibVersion()+"\n" + + " Vendor : "+gljGetNativeLibVendor() +"\n" + + "-------------------------------------------------\n" + + "Java-Class : GL4Java.GLFunc impl. \n" + + " : Version: "+gl.getClassVersion() + "\n" + + " Vendor : "+gl.getClassVendor() + "\n" + + "Native-Library : GL4Java.GLFunc impl. \n" + + " Version: "+gl.getNativeVersion() + "\n" + + " Vendor : "+gl.getNativeVendor() + "\n" + + "-------------------------------------------------\n" + + "Java-Class : GL4Java.GLUFunc impl. \n" + + " : Version: "+glu.getClassVersion() + "\n" + + " Vendor : "+glu.getClassVendor() + "\n" + + "Native-Library : GL4Java.GLUFunc impl. \n" + + " Version: "+glu.getNativeVersion() + "\n" + + " Vendor : "+glu.getNativeVendor() + "\n" + + "-------------------------------------------------\n" + + "\n" ; + + String glVen = gl.glGetString(GLFunc.GL_VENDOR); + String glRen = gl.glGetString(GLFunc.GL_RENDERER); + String glVer = gl.glGetString(GLFunc.GL_VERSION); + String glExt = gl.glGetString(GLFunc.GL_EXTENSIONS); + String gluVer = glu.gluGetString(GLUFunc.GLU_VERSION); + String gluExt = glu.gluGetString(GLUFunc.GLU_EXTENSIONS); + + String info2= "OpenGL - Versions \n" + + "-----------------------------------------------\n" + + "GL VENDOR: "+glVen+"\n"+ + "GL RENDERER: "+glRen+"\n"+ + "GL VERSION: "+glVer+"\n"+ + "GL EXTENSIONS: "+glExt+"\n"+ + "GLU VERSION: "+gluVer+"\n"+ + "GLU EXTENSIONS: "+gluExt+"\n"+"\n" ; + + String info3= "OpenGL - Function Test ("+ + GLFunc.GL_PROC_NAMES.length +" Functions) \n" + + "-----------------------------------------------\n"; + + if(verbose) + { + System.out.println(info1); + System.out.println(info2); + System.out.println(info3); + } + + String h; + String tmp; + + for(int i=0; i<GLFunc.GL_PROC_NAMES.length; i++) + { + h=GLFunc.GL_PROC_NAMES[i]; + if(h==null) break; + + if(gljTestGLProc (h, verbose)) + tmp= "OK : "+h+"\n"; + else + tmp= "NOPE: "+h+"\n"; + + info3 += tmp; + } + + return info1+"\n"+info2+"\n"+info3; + } + + /** + * function to show complete version info into an extra Frame + * + * Be sure that the native library must be loaded ! + */ + public final Frame gljShowVersions() + { + Frame f = new Frame("GL4Java Version"); + TextArea info= new TextArea(25, 80); + info.setEditable(false); + f.add(info); + f.setSize(600, 400); + + f.pack(); + f.setVisible(true); + + String str = "null string"; + if( gljMakeCurrent(true) == false ) + { + str="problem in use() method\n"; + } else { + str=gljGetVersions(gljNativeDebug); + if(str==null) + str="could not get versions"; + System.out.println(str); + gljFree(); + } + info.append(str); + + f.addWindowListener + ( new WindowAdapter() + { + public void windowClosing(WindowEvent e) + { + // button window menu ... :-) + e.getWindow().dispose(); + } + } + ); + + return f; + } + +} + |