From 34fffab0bb25bbf8a4cd2bf372e018748982b9bc Mon Sep 17 00:00:00 2001 From: Sven Gothel Date: Thu, 23 Sep 2010 14:53:25 +0200 Subject: NEWT: Animator API Change - Changed Lifecycle of Display/Screen (part 4) Change GLAutoDrawable interface: setAnimator(Thread) -> setAnimator(GLAnimatorControl) to minimize the setAnimator(..) calls and to allow fine grained control over the animation, ie in case of reparenting where the animation shall pause while changing the window(s). Introducing GLAnimatorControl interface: - abstract class AnimatorBase implements GLAnimatorControl - class Animator extends AnimatorBase - class FPSAnimator extends AnimatorBase This also changes FPSAnimator, since it is no more derived from Animator, use it's superclass or superinterface instead. +++ - Fix GLJPanel.paintComponent(): Don't issue reshape/display in case an external animator thread is animating. - Fix: Documentation [API] --- .../com/jogamp/opengl/impl/GLDrawableHelper.java | 51 ++-- .../com/jogamp/opengl/impl/GLPbufferImpl.java | 6 +- .../com/jogamp/opengl/impl/GLRunnableTask.java | 41 +++- .../com/jogamp/opengl/util/AWTAnimatorImpl.java | 7 +- .../classes/com/jogamp/opengl/util/Animator.java | 266 +++++++++++---------- .../com/jogamp/opengl/util/AnimatorBase.java | 145 +++++++++++ .../com/jogamp/opengl/util/AnimatorImpl.java | 7 +- .../com/jogamp/opengl/util/FPSAnimator.java | 199 +++++++++------ 8 files changed, 493 insertions(+), 229 deletions(-) create mode 100644 src/jogl/classes/com/jogamp/opengl/util/AnimatorBase.java (limited to 'src/jogl/classes/com/jogamp') diff --git a/src/jogl/classes/com/jogamp/opengl/impl/GLDrawableHelper.java b/src/jogl/classes/com/jogamp/opengl/impl/GLDrawableHelper.java index 1e954af1d..1596f0baf 100644 --- a/src/jogl/classes/com/jogamp/opengl/impl/GLDrawableHelper.java +++ b/src/jogl/classes/com/jogamp/opengl/impl/GLDrawableHelper.java @@ -1,5 +1,6 @@ /* * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. + * Copyright (c) 2010 JogAmp Community. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -54,13 +55,14 @@ public class GLDrawableHelper { private boolean autoSwapBufferMode = true; private Object glRunnablesLock = new Object(); private ArrayList glRunnables = new ArrayList(); // one shot GL tasks - private Thread animatorThread = null; // default + private GLAnimatorControl animatorCtrl = null; // default public GLDrawableHelper() { } public String toString() { StringBuffer sb = new StringBuffer(); + sb.append("GLAnimatorControl: "+animatorCtrl+", "); synchronized(listenersLock) { sb.append("GLEventListeners num "+listeners.size()+" ["); for (Iterator iter = listeners.iterator(); iter.hasNext(); ) { @@ -176,51 +178,60 @@ public class GLDrawableHelper { } } - public void setAnimator(Thread animator) throws GLException { + public void setAnimator(GLAnimatorControl animator) throws GLException { synchronized(glRunnablesLock) { - if(animator!=animatorThread && null!=animator && null!=animatorThread) { - throw new GLException("Trying to register animator thread "+animator+", where "+animatorThread+" is already registered. Unregister first."); + if(animatorCtrl!=animator && null!=animator && null!=animatorCtrl) { + throw new GLException("Trying to register GLAnimatorControl "+animator+", where "+animatorCtrl+" is already registered. Unregister first."); } - animatorThread = animator; + animatorCtrl = animator; } } - public Thread getAnimator() { + public GLAnimatorControl getAnimator() { synchronized(glRunnablesLock) { - return animatorThread; + return animatorCtrl; } } + public final boolean isExternalAnimatorAnimating() { + return ( null != animatorCtrl ) ? animatorCtrl.isAnimating() && animatorCtrl.getThread() != Thread.currentThread() : false ; + } + public void invoke(GLAutoDrawable drawable, boolean wait, GLRunnable glRunnable) { if( null == drawable || null == glRunnable ) { return; } Throwable throwable = null; - Object lock = new Object(); GLRunnableTask rTask = null; - synchronized(lock) { - boolean callDisplay; + Object rTaskLock = new Object(); + synchronized(rTaskLock) { + boolean deferred; synchronized(glRunnablesLock) { - callDisplay = null == animatorThread || animatorThread == Thread.currentThread() ; - rTask = new GLRunnableTask(glRunnable, ( !callDisplay && wait ) ? lock : null); + deferred = isExternalAnimatorAnimating(); + if(!deferred) { + wait = false; // don't wait if exec immediatly + } + rTask = new GLRunnableTask(glRunnable, + wait ? rTaskLock : null, + wait /* catch Exceptions if waiting for result */); glRunnables.add(rTask); } - if( callDisplay ) { + if( !deferred ) { drawable.display(); } else if( wait ) { try { - lock.wait(); + rTaskLock.wait(); // free lock, allow execution of rTask } catch (InterruptedException ie) { throwable = ie; } + if(null==throwable) { + throwable = rTask.getThrowable(); + } + if(null!=throwable) { + throw new RuntimeException(throwable); + } } } - if(null==throwable) { - throwable = rTask.getThrowable(); - } - if(null!=throwable) { - throw new RuntimeException(throwable); - } } public void setAutoSwapBufferMode(boolean onOrOff) { diff --git a/src/jogl/classes/com/jogamp/opengl/impl/GLPbufferImpl.java b/src/jogl/classes/com/jogamp/opengl/impl/GLPbufferImpl.java index c2efb3f4e..dcfb2e3f5 100644 --- a/src/jogl/classes/com/jogamp/opengl/impl/GLPbufferImpl.java +++ b/src/jogl/classes/com/jogamp/opengl/impl/GLPbufferImpl.java @@ -138,11 +138,11 @@ public class GLPbufferImpl implements GLPbuffer { drawableHelper.removeGLEventListener(listener); } - public void setAnimator(Thread animator) { - drawableHelper.setAnimator(animator); + public void setAnimator(GLAnimatorControl animatorControl) { + drawableHelper.setAnimator(animatorControl); } - public Thread getAnimator() { + public GLAnimatorControl getAnimator() { return drawableHelper.getAnimator(); } diff --git a/src/jogl/classes/com/jogamp/opengl/impl/GLRunnableTask.java b/src/jogl/classes/com/jogamp/opengl/impl/GLRunnableTask.java index ea1e63b8b..a2a6939cd 100644 --- a/src/jogl/classes/com/jogamp/opengl/impl/GLRunnableTask.java +++ b/src/jogl/classes/com/jogamp/opengl/impl/GLRunnableTask.java @@ -38,27 +38,52 @@ import javax.media.opengl.GLAutoDrawable; public class GLRunnableTask implements GLRunnable { GLRunnable runnable; Object notifyObject; + boolean catchExceptions; + boolean isExecuted; Throwable runnableException; - public GLRunnableTask(GLRunnable runnable, Object notifyObject) { + public GLRunnableTask(GLRunnable runnable, Object notifyObject, boolean catchExceptions) { this.runnable = runnable ; this.notifyObject = notifyObject ; + this.catchExceptions = catchExceptions; + isExecuted = false; } public void run(GLAutoDrawable drawable) { - try { - runnable.run(drawable); - } catch (Throwable t) { - runnableException = t; - } - if(null != notifyObject) { + if(null == notifyObject) { + try { + runnable.run(drawable); + } catch (Throwable t) { + runnableException = t; + if(catchExceptions) { + runnableException.printStackTrace(); + } else { + throw new RuntimeException(runnableException); + } + } finally { + isExecuted=true; + } + } else { synchronized (notifyObject) { - notifyObject.notifyAll(); + try { + runnable.run(drawable); + } catch (Throwable t) { + runnableException = t; + if(catchExceptions) { + runnableException.printStackTrace(); + } else { + throw new RuntimeException(runnableException); + } + } finally { + isExecuted=true; + notifyObject.notifyAll(); + } } } } + public boolean isExecuted() { return isExecuted; } public Throwable getThrowable() { return runnableException; } } diff --git a/src/jogl/classes/com/jogamp/opengl/util/AWTAnimatorImpl.java b/src/jogl/classes/com/jogamp/opengl/util/AWTAnimatorImpl.java index d8e1cf080..e3aff61c6 100644 --- a/src/jogl/classes/com/jogamp/opengl/util/AWTAnimatorImpl.java +++ b/src/jogl/classes/com/jogamp/opengl/util/AWTAnimatorImpl.java @@ -1,5 +1,6 @@ /* * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved. + * Copyright (c) 2010 JogAmp Community. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -51,11 +52,11 @@ class AWTAnimatorImpl extends AnimatorImpl { private Map repaintManagers = new IdentityHashMap(); private Map dirtyRegions = new IdentityHashMap(); - public void display(Animator animator, + public void display(AnimatorBase animator, boolean ignoreExceptions, boolean printExceptions) { Iterator iter = animator.drawableIterator(); - while (iter.hasNext()) { + while (animator.isAnimating() && !animator.getShouldStop() && !animator.getShouldPause() && iter.hasNext()) { GLAutoDrawable drawable = (GLAutoDrawable) iter.next(); if (drawable instanceof JComponent) { // Lightweight components need a more efficient drawing @@ -157,7 +158,7 @@ class AWTAnimatorImpl extends AnimatorImpl { } }; - public boolean skipWaitForStop(Thread thread) { + public boolean skipWaitForCompletion(Thread thread) { return ((Thread.currentThread() == thread) || EventQueue.isDispatchThread()); } } diff --git a/src/jogl/classes/com/jogamp/opengl/util/Animator.java b/src/jogl/classes/com/jogamp/opengl/util/Animator.java index 66d3d5b88..5d48405e2 100644 --- a/src/jogl/classes/com/jogamp/opengl/util/Animator.java +++ b/src/jogl/classes/com/jogamp/opengl/util/Animator.java @@ -1,5 +1,6 @@ /* * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. + * Copyright (c) 2010 JogAmp Community. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -39,12 +40,16 @@ package com.jogamp.opengl.util; -import java.util.*; - -import javax.media.opengl.*; +import javax.media.opengl.GLAnimatorControl; +import javax.media.opengl.GLAutoDrawable; +import javax.media.opengl.GLException; +import javax.media.opengl.GLProfile; import com.jogamp.opengl.impl.Debug; +import java.util.*; + + /**

An Animator can be attached to one or more {@link GLAutoDrawable}s to drive their display() methods in a loop.

@@ -54,44 +59,34 @@ import com.jogamp.opengl.impl.Debug; CPU, unless {@link #setRunAsFastAsPossible} has been called.

*/ -public class Animator { - protected static final boolean DEBUG = Debug.debug("Animator"); +public class Animator extends AnimatorBase { - private volatile ArrayList/**/ drawables = new ArrayList(); - private AnimatorImpl impl; + protected ThreadGroup threadGroup; private Runnable runnable; private boolean runAsFastAsPossible; - protected ThreadGroup threadGroup; - protected Thread thread; + protected volatile boolean isAnimating; + protected volatile boolean shouldPause; protected volatile boolean shouldStop; - protected boolean ignoreExceptions; - protected boolean printExceptions; - - /** Creates a new, empty Animator. */ - public Animator(ThreadGroup tg) { - if(GLProfile.isAWTAvailable()) { - try { - impl = (AnimatorImpl) Class.forName("com.jogamp.opengl.util.awt.AWTAnimatorImpl").newInstance(); - } catch (Exception e) { } - } - if(null==impl) { - impl = new AnimatorImpl(); + public Animator() { + super(); + if(DEBUG) { + System.err.println("Animator created"); } + } + + public Animator(ThreadGroup tg) { + super(); threadGroup = tg; if(DEBUG) { - System.out.println("Animator created, ThreadGroup: "+threadGroup); + System.err.println("Animator created, ThreadGroup: "+threadGroup); } } - public Animator() { - this((ThreadGroup)null); - } - /** Creates a new Animator for a particular drawable. */ public Animator(GLAutoDrawable drawable) { - this((ThreadGroup)null); + super(); add(drawable); } @@ -101,142 +96,131 @@ public class Animator { add(drawable); } - /** Adds a drawable to the list managed by this Animator. */ - public synchronized void add(GLAutoDrawable drawable) { - ArrayList newList = (ArrayList) drawables.clone(); - newList.add(drawable); - drawables = newList; - notifyAll(); - } - - /** Removes a drawable from the list managed by this Animator. */ - public synchronized void remove(GLAutoDrawable drawable) { - ArrayList newList = (ArrayList) drawables.clone(); - newList.remove(drawable); - drawables = newList; - } - - /** Returns an iterator over the drawables managed by this - Animator. */ - public Iterator/**/ drawableIterator() { - return drawables.iterator(); + protected String getBaseName(String prefix) { + return prefix + "Animator" ; } - /** Sets a flag causing this Animator to ignore exceptions produced - while redrawing the drawables. By default this flag is set to - false, causing any exception thrown to halt the Animator. */ - public void setIgnoreExceptions(boolean ignoreExceptions) { - this.ignoreExceptions = ignoreExceptions; - } - - /** Sets a flag indicating that when exceptions are being ignored by - this Animator (see {@link #setIgnoreExceptions}), to print the - exceptions' stack traces for diagnostic information. Defaults to - false. */ - public void setPrintExceptions(boolean printExceptions) { - this.printExceptions = printExceptions; - } - - /** Sets a flag in this Animator indicating that it is to run as - fast as possible. By default there is a brief pause in the - animation loop which prevents the CPU from getting swamped. - This method may not have an effect on subclasses. */ + /** + * Sets a flag in this Animator indicating that it is to run as + * fast as possible. By default there is a brief pause in the + * animation loop which prevents the CPU from getting swamped. + * This method may not have an effect on subclasses. + */ public final void setRunAsFastAsPossible(boolean runFast) { runAsFastAsPossible = runFast; } - /** Called every frame to cause redrawing of all of the - GLAutoDrawables this Animator manages. Subclasses should call - this to get the most optimized painting behavior for the set of - components this Animator manages, in particular when multiple - lightweight widgets are continually being redrawn. */ - protected void display() { - impl.display(this, ignoreExceptions, printExceptions); - } - - private long startTime = 0; - private long curTime = 0; - private int totalFrames = 0; - class MainLoop implements Runnable { public void run() { try { if(DEBUG) { - System.out.println("Animator started: "+Thread.currentThread()); + System.err.println("Animator started: "+Thread.currentThread()); } startTime = System.currentTimeMillis(); curTime = startTime; + totalFrames = 0; + + synchronized (Animator.this) { + isAnimating = true; + Animator.this.notifyAll(); + } while (!shouldStop) { - // Don't consume CPU unless there is work to be done - if (drawables.size() == 0) { + // Don't consume CPU unless there is work to be done and not paused + if ( !shouldStop && ( shouldPause || drawables.size() == 0 ) ) { synchronized (Animator.this) { - while (drawables.size() == 0 && !shouldStop) { + boolean wasPaused = false; + while ( !shouldStop && ( shouldPause || drawables.size() == 0 ) ) { + if(DEBUG) { + System.err.println("Animator paused: "+Thread.currentThread()); + } + isAnimating = false; + wasPaused = true; + Animator.this.notifyAll(); try { Animator.this.wait(); } catch (InterruptedException e) { } } + if ( wasPaused ) { + startTime = System.currentTimeMillis(); + curTime = startTime; + totalFrames = 0; + if(DEBUG) { + System.err.println("Animator resumed: "+Thread.currentThread()); + } + isAnimating = true; + Animator.this.notifyAll(); + } } } - display(); - curTime = System.currentTimeMillis(); - totalFrames++; - if (!runAsFastAsPossible) { - // Avoid swamping the CPU - Thread.yield(); + if ( !shouldStop ) { + display(); + if (!runAsFastAsPossible) { + // Avoid swamping the CPU + Thread.yield(); + } } } - if(DEBUG) { - System.out.println("Animator stopped: "+Thread.currentThread()); - } } finally { - shouldStop = false; synchronized (Animator.this) { + if(DEBUG) { + System.err.println("Animator stopped: "+Thread.currentThread()); + } + shouldStop = false; + shouldPause = false; thread = null; - Animator.this.notify(); + isAnimating = false; + Animator.this.notifyAll(); } } } } - public long getStartTime() { return startTime; } - public long getCurrentTime() { return curTime; } - public long getDuration() { return curTime-startTime; } - public int getTotalFrames() { return totalFrames; } + public final synchronized boolean isStarted() { + return (thread != null); + } + + public final synchronized boolean isAnimating() { + return (thread != null) && isAnimating; + } + + public final synchronized boolean isPaused() { + return (thread != null) && shouldPause; + } - /** Starts this animator. */ public synchronized void start() { - if (thread != null) { - throw new GLException("Already started"); + boolean started = null != thread; + if ( started || isAnimating ) { + throw new GLException("Already running (started "+started+" (false), animating "+isAnimating+" (false))"); } if (runnable == null) { runnable = new MainLoop(); } + int id; + String threadName = Thread.currentThread().getName()+"-"+baseName; if(null==threadGroup) { - thread = new Thread(runnable); + thread = new Thread(runnable, threadName); } else { - thread = new Thread(threadGroup, runnable); - } - for(Iterator iter = drawables.iterator(); iter.hasNext(); ) { - ((GLAutoDrawable) iter.next()).setAnimator(thread); + thread = new Thread(threadGroup, runnable, threadName); } thread.start(); - } - /** Indicates whether this animator is currently running. This - should only be used as a heuristic to applications because in - some circumstances the Animator may be in the process of - shutting down and this method will still return true. */ - public synchronized boolean isAnimating() { - return (thread != null); + if (!impl.skipWaitForCompletion(thread)) { + while (!isAnimating && thread != null) { + try { + wait(); + } catch (InterruptedException ie) { + } + } + } } - /** Stops this animator. In most situations this method blocks until - completion, except when called from the animation thread itself - or in some cases from an implementation-internal thread like the - AWT event queue thread. */ public synchronized void stop() { + boolean started = null != thread; + if ( !started || !isAnimating ) { + throw new GLException("Not running (started "+started+" (true), animating "+isAnimating+" (true) )"); + } shouldStop = true; notifyAll(); @@ -244,16 +228,58 @@ public class Animator { // dependencies on the Animator's internal thread. Currently we // use a couple of heuristics to determine whether we should do // the blocking wait(). - if (!impl.skipWaitForStop(thread)) { - while (shouldStop && thread != null) { + if (!impl.skipWaitForCompletion(thread)) { + while (isAnimating && thread != null) { try { wait(); } catch (InterruptedException ie) { } } } - for(Iterator iter = drawables.iterator(); iter.hasNext(); ) { - ((GLAutoDrawable) iter.next()).setAnimator(null); + } + + public synchronized void pause() { + boolean started = null != thread; + if ( !started || !isAnimating || shouldPause ) { + throw new GLException("Invalid state (started "+started+" (true), animating "+isAnimating+" (true), paused "+shouldPause+" (false) )"); + } + shouldPause = true; + notifyAll(); + + if (!impl.skipWaitForCompletion(thread)) { + while (isAnimating && thread != null) { + try { + wait(); + } catch (InterruptedException ie) { + } + } + } + } + + public synchronized void resume() { + boolean started = null != thread; + if ( !started || !shouldPause ) { + throw new GLException("Invalid state (started "+started+" (true), paused "+shouldPause+" (true) )"); + } + shouldPause = false; + notifyAll(); + + if (!impl.skipWaitForCompletion(thread)) { + while (!isAnimating && thread != null) { + try { + wait(); + } catch (InterruptedException ie) { + } + } } } + + protected final boolean getShouldPause() { + return shouldPause; + } + + protected final boolean getShouldStop() { + return shouldStop; + } + } diff --git a/src/jogl/classes/com/jogamp/opengl/util/AnimatorBase.java b/src/jogl/classes/com/jogamp/opengl/util/AnimatorBase.java new file mode 100644 index 000000000..279fe33ef --- /dev/null +++ b/src/jogl/classes/com/jogamp/opengl/util/AnimatorBase.java @@ -0,0 +1,145 @@ +/** + * Copyright 2010 JogAmp Community. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of JogAmp Community. + */ + +package com.jogamp.opengl.util; + +import com.jogamp.opengl.impl.Debug; +import java.util.ArrayList; +import java.util.Iterator; +import javax.media.opengl.GLAnimatorControl; +import javax.media.opengl.GLAutoDrawable; +import javax.media.opengl.GLProfile; + +/** + * Base implementation of GLAnimatorControl + */ +public abstract class AnimatorBase implements GLAnimatorControl { + protected static final boolean DEBUG = Debug.debug("Animator"); + + private static int animatorCount = 0; + + protected volatile ArrayList/**/ drawables = new ArrayList(); + protected AnimatorImpl impl; + protected String baseName; + protected Thread thread; + protected boolean ignoreExceptions; + protected boolean printExceptions; + protected long startTime = 0; + protected long curTime = 0; + protected int totalFrames = 0; + + /** Creates a new, empty Animator. */ + public AnimatorBase() { + if(GLProfile.isAWTAvailable()) { + try { + impl = (AnimatorImpl) Class.forName("com.jogamp.opengl.util.awt.AWTAnimatorImpl").newInstance(); + baseName = "AWTAnimator"; + } catch (Exception e) { } + } + if(null==impl) { + impl = new AnimatorImpl(); + baseName = "Animator"; + } + synchronized (Animator.class) { + animatorCount++; + baseName = baseName.concat("-"+animatorCount); + } + } + + protected abstract String getBaseName(String prefix); + + public synchronized void add(GLAutoDrawable drawable) { + ArrayList newList = (ArrayList) drawables.clone(); + newList.add(drawable); + drawables = newList; + drawable.setAnimator(this); + notifyAll(); + } + + public synchronized void remove(GLAutoDrawable drawable) { + ArrayList newList = (ArrayList) drawables.clone(); + newList.remove(drawable); + drawables = newList; + drawable.setAnimator(null); + notifyAll(); + } + + /** Called every frame to cause redrawing of all of the + GLAutoDrawables this Animator manages. Subclasses should call + this to get the most optimized painting behavior for the set of + components this Animator manages, in particular when multiple + lightweight widgets are continually being redrawn. */ + protected void display() { + impl.display(this, ignoreExceptions, printExceptions); + curTime = System.currentTimeMillis(); + totalFrames++; + } + + public Iterator drawableIterator() { + return drawables.iterator(); + } + + public long getCurrentTime() { + return curTime; + } + + public long getDuration() { + return curTime - startTime; + } + + protected abstract boolean getShouldPause(); + + protected abstract boolean getShouldStop(); + + public long getStartTime() { + return startTime; + } + + public int getTotalFrames() { + return totalFrames; + } + + public final synchronized Thread getThread() { + return thread; + } + + /** Sets a flag causing this Animator to ignore exceptions produced + while redrawing the drawables. By default this flag is set to + false, causing any exception thrown to halt the Animator. */ + public void setIgnoreExceptions(boolean ignoreExceptions) { + this.ignoreExceptions = ignoreExceptions; + } + + /** Sets a flag indicating that when exceptions are being ignored by + this Animator (see {@link #setIgnoreExceptions}), to print the + exceptions' stack traces for diagnostic information. Defaults to + false. */ + public void setPrintExceptions(boolean printExceptions) { + this.printExceptions = printExceptions; + } +} diff --git a/src/jogl/classes/com/jogamp/opengl/util/AnimatorImpl.java b/src/jogl/classes/com/jogamp/opengl/util/AnimatorImpl.java index 50b91b729..e4bf8d711 100644 --- a/src/jogl/classes/com/jogamp/opengl/util/AnimatorImpl.java +++ b/src/jogl/classes/com/jogamp/opengl/util/AnimatorImpl.java @@ -1,5 +1,6 @@ /* * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved. + * Copyright (c) 2010 JogAmp Community. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -40,11 +41,11 @@ import javax.media.opengl.*; up this behavior if desired. */ class AnimatorImpl { - public void display(Animator animator, + public void display(AnimatorBase animator, boolean ignoreExceptions, boolean printExceptions) { Iterator iter = animator.drawableIterator(); - while (iter.hasNext()) { + while (animator.isAnimating() && !animator.getShouldStop() && !animator.getShouldPause() && iter.hasNext()) { GLAutoDrawable drawable = (GLAutoDrawable) iter.next(); try { drawable.display(); @@ -60,7 +61,7 @@ class AnimatorImpl { } } - public boolean skipWaitForStop(Thread thread) { + public boolean skipWaitForCompletion(Thread thread) { return (Thread.currentThread() == thread); } } diff --git a/src/jogl/classes/com/jogamp/opengl/util/FPSAnimator.java b/src/jogl/classes/com/jogamp/opengl/util/FPSAnimator.java index 75c4cdff7..d098cf1a3 100644 --- a/src/jogl/classes/com/jogamp/opengl/util/FPSAnimator.java +++ b/src/jogl/classes/com/jogamp/opengl/util/FPSAnimator.java @@ -1,5 +1,6 @@ /* * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved. + * Copyright (c) 2010 JogAmp Community. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -36,88 +37,142 @@ * Sun gratefully acknowledges that this software was originally authored * and developed by Kenneth Bradley Russell and Christopher John Kline. */ - package com.jogamp.opengl.util; import java.util.*; import javax.media.opengl.*; /** An Animator subclass which attempts to achieve a target - frames-per-second rate to avoid using all CPU time. The target FPS - is only an estimate and is not guaranteed. */ - -public class FPSAnimator extends Animator { - private Timer timer; - private int fps; - private boolean scheduleAtFixedRate; - - /** Creates an FPSAnimator with a given target frames-per-second - value. Equivalent to FPSAnimator(null, fps). */ - public FPSAnimator(int fps) { - this(null, fps); - } - - /** Creates an FPSAnimator with a given target frames-per-second - value and a flag indicating whether to use fixed-rate - scheduling. Equivalent to FPSAnimator(null, fps, - scheduleAtFixedRate). */ - public FPSAnimator(int fps, boolean scheduleAtFixedRate) { - this(null, fps, scheduleAtFixedRate); - } - - /** Creates an FPSAnimator with a given target frames-per-second - value and an initial drawable to animate. Equivalent to - FPSAnimator(null, fps, false). */ - public FPSAnimator(GLAutoDrawable drawable, int fps) { - this(drawable, fps, false); - } - - /** Creates an FPSAnimator with a given target frames-per-second - value, an initial drawable to animate, and a flag indicating - whether to use fixed-rate scheduling. */ - public FPSAnimator(GLAutoDrawable drawable, int fps, boolean scheduleAtFixedRate) { - this.fps = fps; - if (drawable != null) { - add(drawable); +frames-per-second rate to avoid using all CPU time. The target FPS +is only an estimate and is not guaranteed. */ +public class FPSAnimator extends AnimatorBase { + private Timer timer = null; + private TimerTask task = null; + private int fps; + private boolean scheduleAtFixedRate; + private volatile boolean shouldRun; + + protected String getBaseName(String prefix) { + return "FPS" + prefix + "Animator" ; + } + + /** Creates an FPSAnimator with a given target frames-per-second + value. Equivalent to FPSAnimator(null, fps). */ + public FPSAnimator(int fps) { + this(null, fps); + } + + /** Creates an FPSAnimator with a given target frames-per-second + value and a flag indicating whether to use fixed-rate + scheduling. Equivalent to FPSAnimator(null, fps, + scheduleAtFixedRate). */ + public FPSAnimator(int fps, boolean scheduleAtFixedRate) { + this(null, fps, scheduleAtFixedRate); + } + + /** Creates an FPSAnimator with a given target frames-per-second + value and an initial drawable to animate. Equivalent to + FPSAnimator(null, fps, false). */ + public FPSAnimator(GLAutoDrawable drawable, int fps) { + this(drawable, fps, false); + } + + /** Creates an FPSAnimator with a given target frames-per-second + value, an initial drawable to animate, and a flag indicating + whether to use fixed-rate scheduling. */ + public FPSAnimator(GLAutoDrawable drawable, int fps, boolean scheduleAtFixedRate) { + this.fps = fps; + if (drawable != null) { + add(drawable); + } + this.scheduleAtFixedRate = scheduleAtFixedRate; + } + + public long getStartTime() { return startTime; } + public long getCurrentTime() { return curTime; } + public long getDuration() { return curTime-startTime; } + public int getTotalFrames() { return totalFrames; } + + public final synchronized boolean isStarted() { + return (timer != null); + } + + public final synchronized boolean isAnimating() { + return (timer != null) && (task != null); + } + + public final synchronized boolean isPaused() { + return (timer != null) && (task == null); } - this.scheduleAtFixedRate = scheduleAtFixedRate; - } - /** Starts this FPSAnimator. */ - public synchronized void start() { - if (timer != null) { - throw new GLException("Already started"); + private void startTask() { + long delay = (long) (1000.0f / (float) fps); + task = new TimerTask() { + public void run() { + if(FPSAnimator.this.shouldRun) { + FPSAnimator.this.thread = Thread.currentThread(); + display(); + } + } + }; + + startTime = System.currentTimeMillis(); + curTime = startTime; + totalFrames = 0; + shouldRun = true; + + if (scheduleAtFixedRate) { + timer.scheduleAtFixedRate(task, 0, delay); + } else { + timer.schedule(task, 0, delay); + } } - timer = new Timer(); - long delay = (long) (1000.0f / (float) fps); - TimerTask task = new TimerTask() { - public void run() { - display(); + + public synchronized void start() { + if (timer != null) { + throw new GLException("Already started"); } - }; - if (scheduleAtFixedRate) { - timer.scheduleAtFixedRate(task, 0, delay); - } else { - timer.schedule(task, 0, delay); + timer = new Timer(); + startTask(); } - } - - /** Indicates whether this FPSAnimator is currently running. This - should only be used as a heuristic to applications because in - some circumstances the FPSAnimator may be in the process of - shutting down and this method will still return true. */ - public synchronized boolean isAnimating() { - return (timer != null); - } - - /** Stops this FPSAnimator. Due to the implementation of the - FPSAnimator it is not guaranteed that the FPSAnimator will be - completely stopped by the time this method returns. */ - public synchronized void stop() { - if (timer == null) { - throw new GLException("Already stopped"); + + /** Stops this FPSAnimator. Due to the implementation of the + FPSAnimator it is not guaranteed that the FPSAnimator will be + completely stopped by the time this method returns. */ + public synchronized void stop() { + if (timer == null) { + throw new GLException("Already stopped"); + } + shouldRun = false; + task.cancel(); + task = null; + timer.cancel(); + timer = null; + thread = null; + } + + public synchronized void pause() { + if (timer == null) { + throw new GLException("Not running"); + } + shouldRun = false; + task.cancel(); + task = null; + thread = null; + } + + public synchronized void resume() { + if (timer == null) { + throw new GLException("Not running"); + } + startTask(); + } + + protected final boolean getShouldPause() { + return (timer != null) && (task == null); + } + + protected final boolean getShouldStop() { + return (timer == null); } - timer.cancel(); - timer = null; - } } -- cgit v1.2.3