diff options
Diffstat (limited to 'gl4java/awt')
| -rw-r--r-- | gl4java/awt/GLAnimCanvas.java | 686 | ||||
| -rw-r--r-- | gl4java/awt/GLCanvas.java | 695 | ||||
| -rwxr-xr-x | gl4java/awt/GLImageCanvas.java | 402 |
3 files changed, 1783 insertions, 0 deletions
diff --git a/gl4java/awt/GLAnimCanvas.java b/gl4java/awt/GLAnimCanvas.java new file mode 100644 index 0000000..77fd21f --- /dev/null +++ b/gl4java/awt/GLAnimCanvas.java @@ -0,0 +1,686 @@ +/** + * @(#) GLAnimCanvas.java + */ + +package gl4java.awt; + +import gl4java.GLContext; + +import java.awt.*; +import java.awt.event.*; +import java.lang.Math; + + +/** + * This is meant as an base class writing + * Animations. A clean usage of multi-threading compatible + * with JAVA2 is implemented here ! + * + * <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> + * + * This code uses repaint() to fire a sDisplay call by the AWT-Event thread ! + * and sleep to suspend for a given Frames per secounds value as default !! + * + * To switch this behavior for a better performance, and responsiveness + * so that sDisplay is called by the animation thread itself + * call: + * + * <pre> + <a href="GLAnimCanvas.html#setUseRepaint(boolean)">setUseRepaint(false)</a> + * </pre> + * <p> + * + * This code sleep's for a given Frames per secounds after each frame + * as default !! + * + * To switch this behavior for a better performance, + * so that much frames are rendered as the machine can do ! + * call: + * + * <pre> + <a href="GLAnimCanvas.html#setUseFpsSleep(boolean)">setUseFpsSleep(false)</a> + * </pre> + * <p> + * But be sure, that the other threads may not have enough time or i + * may not get the cpu power ... + * + * The following settings for setUseRepaint and setUseFpsSleep looks fine: + * + * <pre> + <p> + A JVM with operating system threads has: <b>native-threads</b> + <p> + A JVM where all JVM threads runs in one operating-system-thread + has: <b>green-threads</b> + + <a name="table"> + <table border> + <tr> + <th><th>green-threads<th>native-threads + <tr> + <td align=center><a href="GLAnimCanvas.html#setUseRepaint(boolean)"><code>setUseRepaint</code></a> + <td align=center><code>true</code> + <td align=center><code> true & false </code> + <tr> + <td align=center><a href="GLAnimCanvas.html#setUseFpsSleep(boolean)"><code>setUseFpsSleep</code></a> + <td align=center><code>true</code> + <td align=center><code> true & false </code> + + </table> + </a> + * </pre> + * + * If you play with setUseRepaint or setUseFpsSleep, + * be shure to have a Java VM with native-thread support, + * because a GL-Context can be shared by many threads, + * but one thread can have just one GL-Context ! + * + * (comments welcome) + * + * <p> + * To use real fps settings, the following functions provides you to do so: + * <pre> + <a href="GLAnimCanvas.html#setAnimateFps(double, int)">setAnimateFps</a> + <a href="GLAnimCanvas.html#getMaxFps()">getMaxFps</a> + * </pre> + * Like the first animation run, this class renders a view frames (default 10) + * to subtract the render time from the sleep time ! + * <p> + * You should overwrite the following methods for your needs: + * <pre> + <a href="GLAnimCanvas.html#init()">init - 1st initialisation</a> + <a href="GLAnimCanvas.html#display()">display - render one frame</a> + <a href="GLCanvas.html#reshape(int, int)">reshape - to reshape (window resize)</a> + <a href="GLAnimCanvas.html#ReInit()">ReInit - ReInitialisation after stop for setSuspended(false)</a> + * </pre> + * + * @see GLCanvas + * @version 2.0, 21. April 1999 + * @author Sven Goethel + * + */ +public class GLAnimCanvas extends GLCanvas + implements Runnable +{ + /** + * To support frames per scounds, + * instead of killing the machine :-) + * + * A little GUI is supported ! + * + * @see GLAnimCanvas#run + */ + protected double FramesPerSec=20; + protected long mSecPerFrame=0; + + /** + * the delays .. + */ + protected long dFpsMilli = 0; + + /** + * The thread for referencing Thread (Animation) + * + * @see GLAnimCanvas#stop + * @see GLAnimCanvas#start + * @see GLAnimCanvas#run + */ + protected Thread killme = null; + + /** + * Instead of using suspend (JAVA2) + * + * @see GLAnimCanvas#run + */ + protected boolean threadSuspended = false; + + static { + if(GLContext.loadNativeLibraries(null, null, null)==false) + System.out.println("GLAnimCanvas could not load def. native libs."); + } + + /** + * + * Constructor + * + * @see GLCanvas#GLCanvas + * + */ + public GLAnimCanvas( int width, int height, + String gl_Name, + String glu_Name + ) + { + super( width, height, gl_Name, glu_Name ); + setAnimateFps(FramesPerSec); + } + + /** + * + * Constructor + * + * Uses the default GLFunc and GLUFunc implementation ! + * + * @see GLCanvas#GLCanvas + * + */ + public GLAnimCanvas( int width, int height ) + { + super( width, height); + setAnimateFps(FramesPerSec); + } + + /** + * init should be overwritten by you, + * to enter your initialisation code + * + */ + public void init() + { + /* here we should add and initialize our JAVA components */ + + /* ... and furthet OpenGL init's - like you want to */ + + glj.gljCheckGL(); + + ReInit(); + + /* and start our working thread ... */ + start(); + } + + /** + * + * This is the rendering-method called by sDisplay + * (and sDisplay is called by paint, or by the thread directly !). + * The derived-class (Your Subclass) will redefine this, + * to draw it's own animation ! + * + * <p> + * + * You should set shallWeRender here, + * to signalize the animation-loop 'run' to supsend + * <p> + * To restart the thread, just call setSuspended(false) + * + * @see GLAnimCanvas#shallWeRender + * @see GLAnimCanvas#run + * @see GLAnimCanvas#setSuspended + * @see GLCanvas#sDisplay + * @see GLCanvas#paint + */ + public void display() + { + int i; + + /* Standard GL4Java Init */ + if( cvsIsInit()==false ) + { + if(glj.gljClassDebug) + System.out.println("GLAnimCanvas not initialized yet ..."); + return; + } + + if( glj.gljMakeCurrent(true) == false ) + { + if(glj.gljClassDebug) + System.out.println("GLAnimCanvas problem in gljMakeCurrent() method"); + return; + } + + // ... just render it + + /* For your animation dutys ;-) */ + glj.gljSwap(); + glj.gljCheckGL(); + glj.gljFree(); + } + + /** + * ReInit should be overwritten by you, + * to enter your re-initialisation within setSuspended(false) + * + * @see GLAnimCanvas#setSuspended + */ + public void ReInit() + { + } + + protected boolean useRepaint = true; + + protected boolean useFpsSleep = true; + + /** + * The normal behavior is to use 'repaint' + * within the AWT-Event Thread to render. + * <p> + * If you have serious reasons, e.g. measuring performance, + * you can change it while invoke this function with 'false'. + * In this case, the thread itself calls the sDisplay method ! + * + * On fast good multi-threading machines (native-thread-JVM), + * this should increase the performance and the responsiveness ! + * <p> + * + * @param b if true, uses repaint (default), otherwise directly sDisplay + * @see GLCanvas#sDisplay + * @see GLAnimCanvas#setUseFpsSleep + */ + public void setUseRepaint(boolean b) + { + useRepaint = b; + } + + /** + * The normal behavior is to use FpsSleep + * + * But you can overwrite this behavior and + * drop the Frame Per Secound sleeps - + * so that much frames are rendered as the machine can do ! + * <p> + * + * @param b if true, uses Fps sleeping, else not ! + * @see GLCanvas#sDisplay + * @see GLAnimCanvas#setUseRepaint + */ + public void setUseFpsSleep(boolean b) + { + useFpsSleep = b; + } + + public boolean getUseRepaint() + { + return useRepaint; + } + + public boolean getUseFpsSleep() + { + return useFpsSleep; + } + + /** + * HERE WE DO HAVE OUR RUNNING THREAD ! + * WE NEED STUFF LIKE THAT FOR ANIMATION ;-) + */ + public void start() + { + if(killme == null) + { + killme = new Thread(this); + killme.start(); + + resetFpsCounter(); + } + } + + public synchronized void stop() + { + killme = null; + threadSuspended=false; + notify(); + } + + /** + * Should be set in display, + * whether to render or not while the animation loop + * <p> + * If shallWeRender is false, + * this thread will suspend ! + * + * @see GLAnimCanvas#display + * @see GLAnimCanvas#run + */ + protected boolean shallWeRender = true; + + private long _fDelay = 0; + private long _fDelay_Frames = 10; + private boolean _fDelaySync=true; + private boolean _fDelayRun=false; + + /** + * The running loop for animations + * which initiates the call of display + * + * @see GLAnimCanvas#shallWeRender + * @see GLAnimCanvas#display + * @see GLAnimCanvas#diplay + */ + public void run() + { + Thread thisThread = Thread.currentThread(); + + + while (killme==thisThread) + { + if(cvsIsInit()) + { + /* DRAW THE TINGS .. */ + if (shallWeRender) + { + if(useRepaint) + repaint(); + else + sDisplay(); + } else { + // lets sleep ... + synchronized (this) { + threadSuspended=true; + } + } + + if(fps_isCounting) + fps_frames++; + + } + + try { + if(useFpsSleep) + { + if(useRepaint) + { + if(mSecPerFrame<_f_dur) + dFpsMilli=_f_dur; + else + dFpsMilli=mSecPerFrame; + } + else + { + dFpsMilli= mSecPerFrame - _f_dur; + if (dFpsMilli<=0) + dFpsMilli= 1; + } + + Thread.currentThread().sleep(dFpsMilli, 0 ); + } + + if (threadSuspended) { + stopFpsCounter(); + synchronized (this) { + while (threadSuspended) + wait(); + } + } + } catch (InterruptedException e) + {} + } + } + + /** + * Here we can (re)start or suspend animation ... + * + * If the thread should be (re)started and is not alive -> killed, + * or never be started, it will be started ! + * + * @param suspend if true the thread will be suspended, + * if false, the thread will be (re)started + * + * @see GLAnimCanvas#isAlive + * @see GLAnimCanvas#start + */ + public void setSuspended(boolean suspend) + { + setSuspended(suspend, false); + } + + /** + * Here we can (re)start or suspend animation ... + * + * If the thread should be (re)started and is not alive -> killed, + * or never be started, it will be started ! + * + * @param suspend if true the thread will be suspended, + * if false, the thread will be (re)started + * + * @param reInit if true the ReInit will be called additionally, + * where the user can set additional initialisations + * + * @see GLAnimCanvas#isAlive + * @see GLAnimCanvas#start + */ + public synchronized void setSuspended(boolean suspend, boolean reInit) + { + if(suspend) { + shallWeRender=false; + } else if(isAlive()==false) { + start(); + } else { + // the thread is alive, but suspended and should be + // re-started + shallWeRender=true; + resetFpsCounter(); + + if(reInit) + ReInit(); + + threadSuspended=false; + notify(); + } + } + + /** + * is the thread alive, means is started and not died ? + * + * @see GLAnimCanvas#run + * @see GLAnimCanvas#setSuspended + * @see GLAnimCanvas#start + * @see GLAnimCanvas#stop + */ + public boolean isAlive() + { + if(killme==null) return false; + return killme.isAlive(); + } + + /** + * is the thread suspended, means is started but waiting, + * or not alive (ok :-| - but it is practical) + * + * @see GLAnimCanvas#run + * @see GLAnimCanvas#setSuspended + * @see GLAnimCanvas#start + * @see GLAnimCanvas#stop + */ + public boolean isSuspended() + { + if(killme==null) return true; + return threadSuspended; + } + + private double fps=0; // frame-per-sec + private long fps_duration =0; // milli-secs + private long fps_start=0; // milli-secs + private long fps_frames =0; // number of frames + private boolean fps_isCounting =true; // shall i count + private boolean verboseFps =false; // shall i be verbose + + /** + * resets the Fps Counter + * <p> + * this function is called automatically by + * start and setSuspended + * + * @see GLAnimCanvas#start + * @see GLAnimCanvas#setSuspended + * @see GLAnimCanvas#resetFpsCounter + * @see GLAnimCanvas#stopFpsCounter + * @see GLAnimCanvas#getFps + * @see GLAnimCanvas#getFpsDuration + * @see GLAnimCanvas#getFpsFrames + * @see GLAnimCanvas#setVerboseFps + */ + public void resetFpsCounter() + { + fps=0; // frame-per-sec + fps_duration =0; // milli-secs + fps_frames =0; // number of frames + fps_isCounting =true; // shall i count + fps_start=System.currentTimeMillis(); + } + + /** + * stops the Fps Counter and sets all values + * fot the getFps* methods + * <p> + * this function is called automatically by + * run, if the thread is suspended via shallWeRender + * <p> + * All data's are print out on System.out + * if verboseFps is set ! + * + * @see GLAnimCanvas#run + * @see GLAnimCanvas#shallWeRender + * @see GLAnimCanvas#resetFpsCounter + * @see GLAnimCanvas#stopFpsCounter + * @see GLAnimCanvas#getFps + * @see GLAnimCanvas#getFpsDuration + * @see GLAnimCanvas#getFpsFrames + * @see GLAnimCanvas#setVerboseFps + */ + public void stopFpsCounter() + { + if(fps_isCounting==true) + { + long fps_end=System.currentTimeMillis(); + fps_duration = fps_end-fps_start; + double timed= ((double)fps_duration)/1000.0; + if(timed==0) timed=1.0; + fps = ((double)fps_frames)/timed ; + fps_isCounting=false; + } + if(verboseFps) + { + System.out.println("\nfps = "+String.valueOf(fps)); + System.out.println("time = "+String.valueOf(fps_duration)+" ms"); + System.out.println("frames = "+String.valueOf(fps_frames)); + if(fps_frames==0) fps_frames=1; + System.out.println("time/f = "+String.valueOf(fps_duration/fps_frames)+" ms"); + } + } + + /** + * sets if the Fps data shall be printed to System.out + * while stopFpsCounter is called ! + * <p> + * verboseFps is set to true by default ! + * + * @see GLAnimCanvas#run + * @see GLAnimCanvas#shallWeRender + * @see GLAnimCanvas#resetFpsCounter + * @see GLAnimCanvas#stopFpsCounter + * @see GLAnimCanvas#getFps + * @see GLAnimCanvas#getFpsDuration + * @see GLAnimCanvas#getFpsFrames + * @see GLAnimCanvas#setVerboseFps + */ + public void setVerboseFps(boolean v) + { + verboseFps=v; + } + + /** + * returns the calculated frames per secounds + * <p> + * this data is avaiable after calling stopFpsCounter + * + * @see GLAnimCanvas#resetFpsCounter + * @see GLAnimCanvas#stopFpsCounter + * @see GLAnimCanvas#getFps + * @see GLAnimCanvas#getFpsDuration + * @see GLAnimCanvas#getFpsFrames + * @see GLAnimCanvas#setVerboseFps + */ + public double getFps() + { + return fps; + } + + /** + * returns the calculated duration in millisecs + * <p> + * this data is avaiable after calling stopFpsCounter + * + * @see GLAnimCanvas#resetFpsCounter + * @see GLAnimCanvas#stopFpsCounter + * @see GLAnimCanvas#getFps + * @see GLAnimCanvas#getFpsDuration + * @see GLAnimCanvas#getFpsFrames + * @see GLAnimCanvas#setVerboseFps + */ + public long getFpsDuration() + { + return fps_duration; + } + + /** + * returns the calculated frames number + * <p> + * this data is avaiable after calling stopFpsCounter + * + * @see GLAnimCanvas#resetFpsCounter + * @see GLAnimCanvas#stopFpsCounter + * @see GLAnimCanvas#getFps + * @see GLAnimCanvas#getFpsDuration + * @see GLAnimCanvas#getFpsFrames + * @see GLAnimCanvas#setVerboseFps + */ + public long getFpsFrames() + { + return fps_frames; + } + + /** + * Just set the FramePerSecounds for Animation + * + * @deprecated Now the frames per seconds are allways + * calculated, no pre-sync needed. + * @see #setAnimateFps(double) + */ + public void setAnimateFps(double fps, int synFrames) + { + setAnimateFps(fps); + } + + /** + * Just set the FramePerSecounds for Animation + * + * @see GLAnimCanvas#getMaxFps + */ + public void setAnimateFps(double fps) + { + FramesPerSec=fps; + mSecPerFrame = (long) ( (1.0/FramesPerSec) * 1000.0 ) ; + if(verboseFps) + { + System.out.println("\nset fps := "+ + String.valueOf(fps)+ + " -> "+String.valueOf(mSecPerFrame)+ + " [ms/frame]" + ); + } + resetFpsCounter(); + } + + /** + * Just get the maximum number of Frames per secounds, + * which is calculated with the time, one frame needs to render ! + * + * this value is avaiable after the thread is started + * and the first frames are rendered ! + * + * @see GLAnimCanvas#setAnimateFps + */ + public double getMaxFps() + { + return (1.0/(double)_f_dur)*1000.0; + } + +} + diff --git a/gl4java/awt/GLCanvas.java b/gl4java/awt/GLCanvas.java new file mode 100644 index 0000000..4a537f9 --- /dev/null +++ b/gl4java/awt/GLCanvas.java @@ -0,0 +1,695 @@ +/** + * @(#) GLCanvas.java + */ + + +package gl4java.awt; + +import gl4java.*; + +import java.awt.*; +import java.awt.event.*; + +/** + * This is meant as an base class writing + * easy render functions. A clean usage of multi-threading compatible + * with JAVA2 is implemented in GLAnimCanvas ! + * + * <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> + * + * You should overwrite the following methods for your needs: + * <pre> + <a href="GLCanvas.html#init()">preInit - initialisation before creating GLContext</a> + <a href="GLCanvas.html#init()">init - 1st initialisation after creating GLContext</a> + <a href="GLCanvas.html#doCleanup()">doCleanup - OGL cleanup prior to context deletion</a> + <a href="GLCanvas.html#display()">display - render your frame</a> + <a href="GLCanvas.html#reshape(int, int)">reshape - to reshape (window resize), gljResize() is allready invoked !</a> + * </pre> + * + * To check if you can use the GLContext and GL and GLU methods, + * use the function + * <pre> + <a href="GLCanvas.html#cvsIsInit()">cvsIsInit</a> + * </pre> + * <p> + * IF you remove/release a GLCanvas, + * e.g. you want to close/dispose it�s Window (which contains this GLCanvas), + * you HAVE TO call: + * + * <pre> + <a href="GLCanvas.html#cvsDispose()">cvsDispose</a> + * </pre> + * You should call this before releasing/dispose this Window ! + * Also you can overwrite this class, + * to dispose your own elements, e.g. a Frame etc. - + * but be shure that you call + * cvsDispose implementation call this one ! + * + * <p> + * We do override the following Canvas methods. + * + * <pre> + <a href="GLCanvas.html#update(java.awt.Graphics)">update</a> + <a href="GLCanvas.html#paint(java.awt.Graphics)">paint</a> + * </pre> + * <p> + * + * @see GLAnimCanvas + * @version 2.0, 21. April 1999 + * @author Sven Goethel + * + */ +public class GLCanvas extends Canvas + implements GLEnum, GLUEnum, + ComponentListener, WindowListener, MouseListener +{ + protected GLContext glj = null; + public GLFunc gl = null; + public GLUFunc glu = null; + + protected Dimension size = null; + protected boolean mustResize = false; + + protected boolean cvsInitialized=false; + + protected boolean needCvsDispose = false; + + /** + * Visual pre-set for doubleBuffer, default: true + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @see GLCanvas#preInit + * @see GLCanvas#paint + */ + protected boolean doubleBuffer = true; + + /** + * Visual pre-set for stencil-bit number, default: 0 + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @see GLCanvas#preInit + * @see GLCanvas#paint + */ + protected int stencilBits = 0; + + /** + * Visual pre-set for accumulator buffer size, default: 0 + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * 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 GLCanvas#preInit + * @see GLCanvas#paint + */ + protected int accumSize = 0; + + /** + * Visual pre-set for stereoView, default: false + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @see GLCanvas#preInit + * @see GLCanvas#paint + */ + protected boolean stereoView = false; + + /** + * Visual pre-set for RGBA usage, default: true - of course ;-) + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @see GLCanvas#preInit + * @see GLCanvas#paint + */ + protected boolean rgba = true; + + /** + * Visual pre-set for RGBA usage, default: true - of course ;-) + * This value is updated after a GLContext is created with the + * original updated value of GLContext ! + * + * @see GLCanvas#preInit + * @see GLCanvas#paint + */ + protected boolean createOwnWindow = false; + + /** + * The context with witch display lists and textures will be shared. + * + * @see GLCanvas#preInit + * @see GLCanvas#paint + */ + protected GLContext sharedGLContext; + + static { + if(GLContext.loadNativeLibraries(null, null, null)==false) + System.out.println("GLCanvas could not load def. native libs."); + } + + /** + * + * Constructor + * + * @param width the canvas initial-prefered width + * @param height the canvas initial-prefered height + * + * @param gl_Name The name of the GLFunc implementation + * If gl_Name==null, the default class will be used ! + * + * @param glu_Name The name of the GLUFunc implementation + * If gl_LibName==null, the default class will be used ! + * + */ + public GLCanvas( int width, int height, + String gl_Name, + String glu_Name + ) + { + super( ); + + if( (gl=GLContext.createGLFunc(gl_Name)) ==null) + { + System.out.println("GLFunc implementation "+gl_Name+" not created"); + } + if( (glu=GLContext.createGLUFunc(glu_Name)) ==null) + { + System.out.println("GLUFunc implementation "+glu_Name+" not created"); + } + + size = new Dimension(width, height); + + setSize(size); + + /* to be able for RESIZE event's */ + addComponentListener(this); + addMouseListener(this); + } + + /** + * + * Constructor + * + * Uses the default GLFunc and GLUFunc implementation ! + * + * @param width the canvas initial-prefered width + * @param height the canvas initial-prefered height + * + */ + public GLCanvas( int width, int height ) + { + this(width, height, null, null); + } + + /* GLCanvas AWT classes */ + + public Dimension getPreferredSize() { + return getMinimumSize(); + } + + public Dimension getMinimumSize() { + return size; + } + + /** + * Used to return the created GLContext + */ + public final GLContext getGLContext() { return glj; } + + /** + * + * Overridden update + * This one only call's the paint method, without clearing + * the background - thats hopefully done by OpenGL ;-) + * + * @param g the Graphics Context + * @return void + * + * @see GLCanvas#paint + */ + public void update(Graphics g) + { + /* let's let OpenGL clear the background ... */ + paint(g); + } + + /** + * Safe the toplevel window + */ + protected Window topLevelWindow = null; + + /** + * + * This function returns the found TopLevelWindow, + * which contains this Canvas .. + * + * @return void + * + * @see GLCanvas#paint + */ + public final Window getTopLevelWindow() + { return topLevelWindow; } + + /** + * this function overrides the Canvas paint method ! + * + * For the first paint, + * the user function preInit is called, a GLContext is created + * and the user function init is called ! + * + * Also, if a GL Context exist, GLCanvas's sDisplay-method will be called + * to do OpenGL-rendering. + * + * The sDisplay method itself calls the display-method ! + * sDisplay is needed to be thread-safe, to manage + * the resize functionality and to safe the time per frame. + * + * To define your rendering, you should overwrite the display-method + * in your derivation. + * + * @see gl4java.GLContext#GLContext + * @see GLCanvas#cvsIsInit + * @see GLCanvas#sDisplay + * @see GLCanvas#display + * @see GLCanvas#preInit + * @see GLCanvas#init + */ + public synchronized final void paint( Graphics g ) + { + if(glj == null ) + { + preInit(); + glj = new GLContext ( this, gl, glu, + createOwnWindow, + doubleBuffer, stereoView, + rgba, stencilBits, accumSize, + sharedGLContext ); + + if(glj!=null) + { + createOwnWindow = glj.isOwnWindowCreated(); + doubleBuffer = glj.isDoubleBuffer(); + stencilBits = glj.getStencilBitNumber(); + accumSize = glj.getAccumSize(); + stereoView = glj.isStereoView(); + rgba = glj.isRGBA(); + } + + init(); + + // fetch the top-level window , + // to add us as the windowListener + // + Container _c = getParent(); + Container c = null; + + while(_c!=null) + { + c = _c; + _c = _c.getParent(); + } + + if(c instanceof Window) { + topLevelWindow = (Window)c; + topLevelWindow.addComponentListener(this); + } else { + topLevelWindow = null; + System.out.println("toplevel is not a Window: "+c); + } + + if(topLevelWindow!=null) + { + topLevelWindow.addWindowListener(this); + } else { + System.out.println("no parent found for "+getName()); + System.out.flush(); + } + if(glj!=null && glj.gljIsInit()) + cvsInitialized=true; + } + /* + if( mustResize ) size = getSize(); + g.setClip(0, 0, size.width, size.height ) ; + */ + sDisplay(); + } + + /** + * + * This is your pre-init method. + * preInit is called just BEFORE the GL-Context is created. + * You should override preInit, to initialize your visual-stuff, + * like the protected vars: doubleBuffer and stereoView + * + * @return void + * + * @see GLCanvas#paint + * @see GLCanvas#doubleBuffer + * @see GLCanvas#stereoView + * @see GLCanvas#rgba + * @see GLCanvas#stencilBits + * @see GLCanvas#accumSize + */ + public void preInit() + { + } + + /** + * + * This is your init method. + * init is called right after the GL-Context is initialized. + * You should override init, to initialize your stuff needed + * by OpenGL an Java ! + * + * @return void + * + * @see GLCanvas#paint + */ + public void init() + { + } + + /** + * This method is used to clean up any OpenGL stuff (delete textures + * or whatever) prior to actually deleting the OpenGL context. + * You should override this with your own version, if you need to do + * any cleanup work at this phase. + * This functions is called within cvsDispose + * + * @return void + * + * @see GLCanvas#cvsDispose + */ + public void doCleanup() + { + } + + /** + * This function returns, if everything is init: the GLContext, + * the and the users init function + * This value is set in the paint method! + * + * @return boolean + * + * @see GLCanvas#paint + * @see GLCanvas#init + */ + public boolean cvsIsInit() + { + return cvsInitialized; + } + + protected long _f_dur = 0; + + /** + * + * This is the thread save rendering-method called by paint. + * The actual thread will be set to highes priority befor calling + * 'display'. After 'display' the priority will be reset ! + * + * 'gljFree' will be NOT called after 'display'. + * + * We tested the above to use multi-threading and + * for the demonstration 'glDemos' it works ;-)) ! + * + * BE SURE, if you want to call 'display' by yourself + * (e.g. in the run method for animation) + * YOU HAVE TO CALL sDisplay -- OR YOU MUST KNOW WHAT YOU ARE DOING THEN ! + * + * @return void + * + * @see GLCanvas#paint + * @see GLCanvas#display + */ + public synchronized final void sDisplay() + { + boolean ok = true; + + long _s = System.currentTimeMillis(); + + if(!cvsIsInit()) + return; + + if( mustResize ) + { + if( (ok = glj.gljMakeCurrent()) == true ) + { + size = getSize(); + glj.gljResize( size.width, size.height ) ; + reshape(size.width, size.height); + mustResize = false; + invalidate(); + repaint(100); + } + } + if(ok) + { + display(); + } + + _f_dur = System.currentTimeMillis()-_s; + } + + /** + * + * This is the rendering-method called by sDisplay + * (and sDisplay is called by paint !). + * The derived-class (Your Subclass) will redefine this, to draw it's own... + * + * BE SURE, if you want to call 'display' by yourself + * (e.g. in the run method for animation) + * YOU HAVE TO CALL sDisplay ! + * + * 'sDisplay' manages a semaphore to avoid reentrance of + * the display function !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + * + * @return void + * + * @see GLCanvas#sDisplay + * @see GLCanvas#paint + */ + public void display() + { + } + + /** + * + * This is the reshape-method called by paint. + * The derived-class (Your Subclass) will redefine this, + * to manage your individual reshape ... + * + * This �reshape� method will be invoked after the first paint command + * after GLCanvas.componentResize is called AND only if �gljUse� was + * succesfull (so a call of gljUse is redundant). + * �reshape� is not an overloading of java.awt.Component.reshape, + * �reshape� is more like �glut�-reshape. + * + * GLCanvas.reshape allready has a simple default implementation, + * which calls �gljResize� and �glViewport� - so you may be can + * left this one as it is (no need to overload). + * The needed call to �gljResize� is done by hte invoker paint ! + * + * @param width the new width + * @param height the new height + * @return void + * + * @see GLCanvas#paint + * @see GLCanvas#sDisplay + */ + public void reshape( int width, int height ) + { + gl.glViewport(0,0, width, height); + } + + /** + * + * �componentResized� is the componentListeners event handler. + * + * This method sets the variable �mustResize� to true, + * so the upcoming �paint� method-call will invoke �reshape� ! + * + * This little look-alike complicating thing is done, + * to avoid an Exception by using the glContext from more than + * one concurrent thread�s ! + * + * You cannot override this implementation, it is final + * - override �reshape' instead ! + * + * @param e the element, which is resized + * @return void + * + * @see GLCanvas#paint + * @see GLCanvas#reshape + */ + public void componentResized(ComponentEvent e) + { + if(glj!=null && glj.gljIsInit() && e.getComponent()==this ) + { + mustResize = true; + repaint(); + } + } + + public void componentMoved(ComponentEvent e) + { + if(glj!=null && glj.gljIsInit()) + { + repaint(100); + } + } + + public void componentShown(ComponentEvent e) + { + } + + public void componentHidden(ComponentEvent e) + { } + + public void mouseClicked(MouseEvent e) + { + if(glj!=null && glj.gljIsInit()) + { + repaint(); + } + } + + public void mouseEntered(MouseEvent e) + { } + public void mouseExited(MouseEvent e) + {} + public void mousePressed(MouseEvent e) + { + } + public void mouseReleased(MouseEvent e) + { + } + + public void windowOpened(WindowEvent e) + { + } + + /** + * + * �windowClosing� is the windowListeners event handler + * for the topLevelWindow of this Canvas ! + * + * This methods free�s AND destroy�s + * the GL Context with �glj.gljDestroy� ! + * + * @return void + * + */ + public void windowClosing(WindowEvent e) + { + if(e.getComponent().equals(topLevelWindow)) + { + cvsDispose(); + } + } + + /** + * + * �windowClosed� is the windowListeners event handler. + * + * @return void + * + */ + public void windowClosed(WindowEvent e) + { + if (needCvsDispose) cvsDispose(); + } + + public void windowIconified(WindowEvent e) + { + } + + public void windowDeiconified(WindowEvent e) + { + } + + public void windowActivated(WindowEvent e) + { + if(glj!=null && glj.gljIsInit()) + { + repaint(100); + } + } + + public void windowDeactivated(WindowEvent e) + { + } + + /** + * You should call this before releasing/dispose this Window ! + * Also you can overwrite this class, + * to dispose your own elements, e.g. a Frame etc. - + * but be shure that you call + * cvsDispose implementation call this one ! + * + * This function calls gljDestroy of GLContext ! + * + * @see gl4java.GLContext#gljDestroy + * @see GLCanvas#doCleanup + */ + public void cvsDispose() + { + cvsInitialized = false; + if (glj != null) + { + if (glj.gljIsInit()) + { + /* Sometimes the Microsoft VM calls the + Applet.stop() method but doesn't have + permissions to do J/Direct calls, so + this whole block of code will throw a + security exception. If this happens, + however, windowClosing() will still + call us again later and we will have + another opportunity to shut down the + context, so it all works out fine. */ + try + { + glj.gljFree(); + doCleanup(); + //locks and free's GLContext + glj.setEnabled(false); + glj.gljDestroy(); + needCvsDispose = false; + } + catch (Exception ex) + { + needCvsDispose = true; + } + } + } + + // Setting glj to null will simply cause paint() to re-initialize. + // We don't want that to happen, so we will leave glj non-null. + } + + /** + * get methods + */ + public final int cvsGetWidth() { + return getSize().width; + } + public final int cvsGetHeight() { + return getSize().height; + } +} + diff --git a/gl4java/awt/GLImageCanvas.java b/gl4java/awt/GLImageCanvas.java new file mode 100755 index 0000000..113d589 --- /dev/null +++ b/gl4java/awt/GLImageCanvas.java @@ -0,0 +1,402 @@ +/** + * @(#) GLImageCanvas.java + */ + + +package gl4java.awt; + +import gl4java.*; +import gl4java.utils.*; +import gl4java.utils.textures.*; + +import java.awt.*; +import java.net.*; + +/** + * This Class provides a simple universal + * Image/Texture OpenGL Canvas ! + * + * A special demo/application for this class can be found + * in "demos/MiscDemos/GLImageViewerCanvas.java" ! + * + * @see TextureLoader + * @author Sven Goethel + * + */ +public class GLImageCanvas extends GLCanvas +{ + int texName[] = {0}; + TextureLoader txtLoader = null; + boolean newText = false; + boolean keepAspect = true; + boolean zoomImg = true; + + TextureGrabber textGrab4Snapshot = null; + String textGrab4SnapshotFName = null; + URL textGrab4SnapshotURL = null; + String textGrab4SnapshotURI = null; + + public GLImageCanvas(int w, int h) + { + super(w, h); + } + + public void setKeepAspectRatio(boolean v) + { keepAspect=v; } + + public boolean getKeepAspectRatio() + { return keepAspect; } + + public void setZoomAble(boolean v) + { zoomImg = v; } + + public boolean getZoomAble() + { return zoomImg; } + + public TextureLoader getTextureLoader() + { return txtLoader; } + + public void setOriginalSize() + { + if(txtLoader!=null && txtLoader.isOk()) + { + internalSetSize( txtLoader.getImageWidth(), + txtLoader.getImageHeight() ); + } + } + + /** + * Creates a snapshot (save texture/image) of the current + * GL-Context ! + * + * The snapshot itself is created delayed, + * so no return value is avaiable. + * Because this is a non critical path, I hope its enough ! + * + * @param tg The TextureGrabber + * @param fname The filename + * @see TextureGrabber + */ + public void snapshot(TextureGrabber tg, String fname) + { + textGrab4Snapshot=tg; + textGrab4SnapshotFName=fname; + repaint(); + } + + /** + * Creates a snapshot (save texture/image) of the current + * GL-Context ! + * + * The snapshot itself is created delayed, + * so no return value is avaiable. + * Because this is a non critical path, I hope its enough ! + * + * @param tg The TextureGrabber + * @param base The base URL + * @param uri The additional uri for the base URL + * @see TextureGrabber + */ + public void snapshot(TextureGrabber tg, URL base, String uri) + { + textGrab4Snapshot=tg; + textGrab4SnapshotURL = base; + textGrab4SnapshotURI = uri; + repaint(); + } + + public Dimension getPreferredSize() { + return getMinimumSize(); + } + + public Dimension getMinimumSize() { + return getSize(); + } + + protected void internalSetSize(int w, int h) + { + setSize( w, h ); + invalidate(); + + Window holder = Tool.getWindow(this); + + if(holder!=null) + { + holder.invalidate(); + holder.pack(); + holder.repaint(); + } + } + + public void preInit() + { + // createOwnWindow = true; + } + + public void init() + { + gl.glEnable(GL_TEXTURE_2D); + + gl.glGenTextures(1,texName); + gl.glBindTexture(GL_TEXTURE_2D,texName[0]); + + gl.glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP); + gl.glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP); + gl.glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); + gl.glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); + gl.glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); + + gl.glShadeModel (GL_SMOOTH); + + gl.glClearColor(0.2f, 0.2f, 0.2f, 1.0f); + + reshape(getSize().width, getSize().height); + } + + /** + * Loads an Image of the appropiate type, + * and renders and resizes the complete window ! + * + * @param fname The filename + * @param type The type of file, e.g. TextureLoader is used ! + * The following types are currently allowed: + * "png" for PngTextureLoader, + * "ppm" for PPMAsciiTextureLoader, + * "tga" for PPMAsciiTextureLoader, + * "any" for AWTTextureLoader ! + */ + public boolean loadTexture(String fname, String type) + { + return loadTexture(fname, null, null, type); + } + + /** + * Loads an Image of the appropiate type, + * and renders and resizes the complete window ! + * + * @param base The base URL + * @param uri The additional uri for the base URL + * @param type The type of file, e.g. TextureLoader is used ! + * The following types are currently allowed: + * "png" for PngTextureLoader, + * "ppm" for PPMAsciiTextureLoader, + * "tga" for PPMAsciiTextureLoader, + * "any" for AWTTextureLoader ! + */ + public boolean loadTexture(URL base, String uri, String type) + { + return loadTexture(null, base, uri, type); + } + + protected boolean loadTexture(String fname, + URL base, String uri, String type) + { + boolean ok = true; + + if( glj.gljMakeCurrent() == false ) + { + System.out.println("problem in use() method"); + return false; + } + + // texture laden + if(type.equals("png")) + txtLoader = new PngTextureLoader(gl, glu); + else if(type.equals("ppm")) + txtLoader = new PPMAsciiTextureLoader(gl, glu); + else if(type.equals("tga")) + txtLoader = new TGATextureLoader(gl, glu); + else if(type.equals("any")) + txtLoader = new AWTTextureLoader(this, gl, glu); + else { + System.out.println("Imagetype: "+type+" is currently not supported !"); + ok = false; + } + + if(ok) + { + try { + if(fname!=null) + txtLoader.readTexture(fname); + else + txtLoader.readTexture(base, uri); + } catch (Exception ex) { + ex.printStackTrace(); + } + } + + if(ok && txtLoader.isOk()) + { + gl.glEnable(GL_TEXTURE_2D); + + txtLoader.texImage2DNonScaled(true); + + gl.glDisable(GL_TEXTURE_2D); + System.out.println("texture succesfully loaded !"); + System.out.println("texture: "+txtLoader); + } + glj.gljCheckGL(); + glj.gljFree(); + if(ok) { + internalSetSize( txtLoader.getImageWidth(), + txtLoader.getImageHeight() ); + } + return ok; + } + + public void display() + { + int i; + + /* Standard GL4Java Init */ + if( glj.gljMakeCurrent() == false ) + { + System.out.println("problem in use() method"); + return; + } + + SetCamera(); + + // just render it + gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + DrawObj(false); + + if(textGrab4Snapshot!=null) + { + textGrab4Snapshot.grabPixels(GL_BACK, + 0, 0, cvsGetWidth(), cvsGetHeight()); + if(textGrab4SnapshotFName!=null) + textGrab4Snapshot.write2File(textGrab4SnapshotFName); + else + textGrab4Snapshot.write2File(textGrab4SnapshotURL, + textGrab4SnapshotURI); + textGrab4Snapshot =null; + textGrab4SnapshotFName=null; + textGrab4SnapshotURL =null; + textGrab4SnapshotURI =null; + } + + /* For your animation dutys ;-) */ + glj.gljSwap(); + glj.gljCheckGL(); + glj.gljFree(); + } + + /** + * to prevent a deadlock in recursive + * reshape .. internalSetSize .. pack .. resize -> reshape ! + */ + private int reshape_resize_sema = 1; + + public void reshape(int w, int h) + { + if(reshape_resize_sema>0 && + keepAspect && txtLoader!=null && txtLoader.isOk()) + { + reshape_resize_sema--; + + int rw=w; int rh=h; + if(zoomImg) + { + double iaspect = (double)txtLoader.getImageWidth()/ + (double)txtLoader.getImageHeight(); + if(rw<rh) + { + h = (int) ((rw / iaspect)+0.5); + } else { + w = (int) ((rh * iaspect)+0.5); + } + } else { + w = txtLoader.getImageWidth(); + h = txtLoader.getImageHeight(); + } + if(rw!=w || rh!=h) + { + internalSetSize( w, h ); + return ; /* the true resize is coming up ... */ + } + } + reshape_resize_sema=1; + gl.glViewport (0, 0, w, h); + SetCamera(); + } + + + protected void DrawObj(boolean blend) + { + gl.glPushMatrix(); + if(blend) + { + gl.glEnable(GL_BLEND); + gl.glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); + } + + gl.glColor4f(1f,1f,1f,1f); + + if(txtLoader!=null && txtLoader.isOk()) + { + gl.glEnable(GL_TEXTURE_2D); + gl.glBegin(GL_QUADS); + + gl.glNormal3f(0f,0f,1f); + gl.glTexCoord2f(0f,0f); + gl.glVertex2f(0f, 0f); + + gl.glNormal3f(0f,0f,1f); + gl.glTexCoord2f(0f,1f); + gl.glVertex2f(0f, 1f); + + gl.glNormal3f(0f,0f,1f); + gl.glTexCoord2f(1f,1f); + gl.glVertex2f(1f, 1f); + + gl.glNormal3f(0f,0f,1f); + gl.glTexCoord2f(1f,0f); + gl.glVertex2f(1f, 0f); + + gl.glEnd(); + gl.glDisable(GL_TEXTURE_2D); + } + + if(blend) + gl.glDisable(GL_BLEND); + + gl.glPopMatrix(); + } + + protected void SetCamera() + { + float imgwidth = 1f; + float imgheight = 1f; + float txtdx=0f; + float txtdy=0f; + + if(txtLoader!=null && txtLoader.isOk()) + { + Dimension idim = new Dimension(txtLoader.getImageWidth(), + txtLoader.getImageHeight()); + Dimension tdim = new Dimension(txtLoader.getTextureWidth(), + txtLoader.getTextureHeight()); + + imgwidth = (float)idim.width/(float)tdim.width; + imgheight = (float)idim.height/(float)tdim.height; + + /* + System.out.println("image : "+idim); + System.out.println("text : "+tdim); + System.out.println("image/text : "+imgwidth+"/"+imgheight); + */ + } + + gl.glMatrixMode (GL_PROJECTION); + gl.glLoadIdentity (); + glu.gluOrtho2D(0, imgwidth, + 0, imgheight); + + gl.glMatrixMode (GL_MODELVIEW); + gl.glLoadIdentity (); + } + +} + |