j3dcore: flatten the directory structure a bit

Signed-off-by: Harvey Harrison <[email protected]>

1 files changed, 1022 insertions, 0 deletions

diff --git a/src/javax/media/j3d/Alpha.java b/src/javax/media/j3d/Alpha.java
new file mode 100644
index 0000000..8f3cb2f
--- /dev/null
+++ b/src/javax/media/j3d/Alpha.java
@@ -0,0 +1,1022 @@
+/*
+ * Copyright 1997-2008 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+package javax.media.j3d;
+
+
+/**
+ * The alpha NodeComponent object provides common methods for
+ * converting a time value into an alpha value (a value in the range 0
+ * to 1).  The Alpha object is effectively a function of time that
+ * generates alpha values in the range [0,1] when sampled: f(t) =
+ * [0,1].  A primary use of the Alpha object is to provide alpha
+ * values for Interpolator behaviors.  The function f(t) and the
+ * characteristics of the Alpha object are determined by
+ * user-definable parameters:
+ *
+ * <p>
+ * <ul>
+ *
+ * <code>loopCount</code> -- This is the number of times to run this
+ * Alpha; a value of -1 specifies that the Alpha loops
+ * indefinitely.<p>
+ *
+ * <code>triggerTime</code> -- This is the time in milliseconds since
+ * the start time that this object first triggers.  If (startTime +
+ * triggerTime >= currentTime) then the Alpha object starts running.<p>
+ *
+ * <code>phaseDelayDuration</code> -- This is an additional number of
+ * milliseconds to wait after triggerTime before actually starting
+ * this Alpha.<p>
+ *
+ * <code>mode</code> -- This can be set to INCREASING_ENABLE,
+ * DECREASING_ENABLE, or the Or'ed value of the two.
+ * INCREASING_ENABLE activates the increasing Alpha parameters listed
+ * below; DECREASING_ENABLE activates the decreasing Alpha parameters
+ * listed below.<p>
+ *
+ * </ul> Increasing Alpha parameters:<p> <ul>
+ *
+ * <code>increasingAlphaDuration</code> -- This is the period of time
+ * during which Alpha goes from zero to one. <p>
+ *
+ * <code>increasingAlphaRampDuration</code> -- This is the period of
+ * time during which the Alpha step size increases at the beginning of
+ * the increasingAlphaDuration and, correspondingly, decreases at the
+ * end of the increasingAlphaDuration.  This parameter is clamped to
+ * half of increasingAlphaDuration.  When this parameter is non-zero,
+ * one gets constant acceleration while it is in effect; constant
+ * positive acceleration at the beginning of the ramp and constant
+ * negative acceleration at the end of the ramp.  If this parameter is
+ * zero, then the effective velocity of the Alpha value is constant
+ * and the acceleration is zero (ie, a linearly increasing alpha
+ * ramp).<p>
+ *
+ * <code>alphaAtOneDuration</code> -- This is the period of time that
+ * Alpha stays at one.<p> </ul> Decreasing Alpha parameters:<p> <ul>
+ *
+ * <code>decreasingAlphaDuration</code> -- This is the period of time
+ * during which Alpha goes from one to zero.<p>
+ *
+ * <code>decreasingAlphaRampDuration</code> -- This is the period of
+ * time during which the Alpha step size increases at the beginning of
+ * the decreasingAlphaDuration and, correspondingly, decreases at the
+ * end of the decreasingAlphaDuration.  This parameter is clamped to
+ * half of decreasingAlphaDuration.  When this parameter is non-zero,
+ * one gets constant acceleration while it is in effect; constant
+ * positive acceleration at the beginning of the ramp and constant
+ * negative acceleration at the end of the ramp.  If this parameter is
+ * zero, the effective velocity of the Alpha value is constant and the
+ * acceleration is zero (i.e., a linearly-decreasing alpha ramp).<p>
+ *
+ * <code>alphaAtZeroDuration</code> -- This is the period of time that
+ * Alpha stays at zero.
+ *
+ * </ul>
+ *
+ * @see Interpolator
+ */
+
+public class Alpha extends NodeComponent {
+
+    // loopCount <  -1 --> reserved
+    // loopCount == -1 --> repeat forever
+    // loopCount >=  0 --> repeat count
+    private int loopCount;
+
+    /**
+     * Specifies that the increasing component of the alpha is used.
+     */
+    public static final int INCREASING_ENABLE = 1;
+
+    /**
+     * Specifies that the decreasing component of the alpha is used
+     */
+    public static final int DECREASING_ENABLE = 2;
+
+    /**
+     * This alpha's mode, specifies whether to process
+     * increasing and decreasing alphas.
+     */
+    private int mode;
+
+    private float triggerTime;
+    private float phaseDelay;
+    private float increasingAlpha;
+    private long increasingAlphaRamp;
+    private float incAlphaRampInternal;
+    private float alphaAtOne;
+    private float decreasingAlpha;
+    private long decreasingAlphaRamp;
+    private float decAlphaRampInternal;
+    private float alphaAtZero;
+
+    // For pausing and resuming Alpha
+    private long pauseTime = 0L;
+    private boolean paused = false;
+
+    // Stop time gets used only for loopCount > 0
+    private float stopTime;
+
+    // Start time in milliseconds
+    private long startTime = MasterControl.systemStartTime;
+
+    /**
+     * Constructs an Alpha object with default parameters.  The default
+     * values are as follows:
+     * <ul>
+     * loopCount			: -1<br>
+     * mode				: INCREASING_ENABLE<br>
+     * startTime			: system start time<br>
+     * triggerTime			: 0<br>
+     * phaseDelayDuration		: 0<br>
+     * increasingAlphaDuration		: 1000<br>
+     * increasingAlphaRampDuration	: 0<br>
+     * alphaAtOneDuration		: 0<br>
+     * decreasingAlphaDuration		: 0<br>
+     * decreasingAlphaRampDuration	: 0<br>
+     * alphaAtZeroDuration		: 0<br>
+     * isPaused				: false<br>
+     * pauseTime			: 0<br>
+     * </ul>
+     */
+    public Alpha() {
+        loopCount = -1;
+        mode = INCREASING_ENABLE;
+        increasingAlpha = 1.0f;          // converted to seconds internally
+	/*
+	// Java initialize them to zero by default
+        triggerTime = 0L;
+        phaseDelay = 0.0f;
+        increasingAlphaRamp = 0.0f;
+        alphaAtOne = 0.0f;
+        decreasingAlpha = 0.0f;
+        decreasingAlphaRamp = 0.0f;
+        alphaAtZero = 0.0f;
+	*/
+    }
+
+
+    /**
+     * This constructor takes all of the Alpha user-definable parameters.
+     * @param loopCount number of times to run this alpha; a value
+     * of -1 specifies that the alpha loops indefinitely
+     * @param mode indicates whether the increasing alpha parameters or
+     * the decreasing alpha parameters or both are active.  This parameter
+     * accepts the following values, INCREASING_ENABLE or
+     * DECREASING_ENABLE, which may be ORed together to specify
+     * that both are active.
+     * The increasing alpha parameters are increasingAlphaDuration,
+     * increasingAlphaRampDuration, and alphaAtOneDuration.
+     * The decreasing alpha parameters are decreasingAlphaDuration,
+     * decreasingAlphaRampDuration, and alphaAtZeroDuration.
+     * @param triggerTime time in milliseconds since the start time
+     * that this object first triggers
+     * @param phaseDelayDuration number of milliseconds to wait after
+     * triggerTime before actually starting this alpha
+     * @param increasingAlphaDuration period of time during which alpha goes
+     * from zero to one
+     * @param increasingAlphaRampDuration period of time during which
+     * the alpha step size increases at the beginning of the
+     * increasingAlphaDuration and, correspondingly, decreases at the end
+     * of the increasingAlphaDuration. This value is clamped to half of
+     * increasingAlphaDuration. NOTE: a value of zero means that the alpha
+     * step size remains constant during the entire increasingAlphaDuration.
+     * @param alphaAtOneDuration period of time that alpha stays at one
+     * @param decreasingAlphaDuration period of time during which alpha goes
+     * from one to zero
+     * @param decreasingAlphaRampDuration period of time during which
+     * the alpha step size increases at the beginning of the
+     * decreasingAlphaDuration and, correspondingly, decreases at the end
+     * of the decreasingAlphaDuration. This value is clamped to half of
+     * decreasingAlphaDuration. NOTE: a value of zero means that the alpha
+     * step size remains constant during the entire decreasingAlphaDuration.
+     * @param alphaAtZeroDuration period of time that alpha stays at zero
+     */
+    public Alpha(int loopCount, int mode,
+		 long triggerTime, long phaseDelayDuration,
+		 long increasingAlphaDuration,
+		 long increasingAlphaRampDuration,
+		 long alphaAtOneDuration,
+		 long decreasingAlphaDuration,
+		 long decreasingAlphaRampDuration,
+		 long alphaAtZeroDuration) {
+
+	this.loopCount = loopCount;
+	this.mode = mode;
+	this.triggerTime = (float) triggerTime * .001f;
+	phaseDelay = (float) phaseDelayDuration * .001f;
+
+	increasingAlpha = (float) increasingAlphaDuration * .001f;
+	alphaAtOne = (float)alphaAtOneDuration * .001f;
+	increasingAlphaRamp = increasingAlphaRampDuration;
+	incAlphaRampInternal = increasingAlphaRampDuration * .001f;
+	if (incAlphaRampInternal > (0.5f * increasingAlpha)) {
+	    incAlphaRampInternal = 0.5f * increasingAlpha;
+	}
+
+	decreasingAlpha = (float)decreasingAlphaDuration * .001f;
+	alphaAtZero = (float)alphaAtZeroDuration * .001f;
+	decreasingAlphaRamp = decreasingAlphaRampDuration;
+	decAlphaRampInternal = decreasingAlphaRampDuration * .001f;
+	if (decAlphaRampInternal > (0.5f * decreasingAlpha)) {
+	    decAlphaRampInternal = 0.5f * decreasingAlpha;
+	}
+	computeStopTime();
+    }
+
+
+    /**
+     * Constructs a new Alpha object that assumes that the mode is
+     * INCREASING_ENABLE.
+     *
+     * @param loopCount number of times to run this alpha; a value
+     * of -1 specifies that the alpha loops indefinitely.
+     * @param triggerTime time in milliseconds since the start time
+     * that this object first triggers
+     * @param phaseDelayDuration number of milliseconds to wait after
+     * triggerTime before actually starting this alpha
+     * @param increasingAlphaDuration period of time during which alpha goes
+     * from zero to one
+     * @param increasingAlphaRampDuration period of time during which
+     * the alpha step size increases at the beginning of the
+     * increasingAlphaDuration and, correspondingly, decreases at the end
+     * of the increasingAlphaDuration. This value is clamped to half of
+     * increasingAlphaDuration. NOTE: a value of zero means that the alpha
+     * step size remains constant during the entire increasingAlphaDuration.
+     * @param alphaAtOneDuration period of time that alpha stays at one
+     */
+
+    public Alpha(int loopCount,
+		 long triggerTime, long phaseDelayDuration,
+		 long increasingAlphaDuration,
+		 long increasingAlphaRampDuration,
+		 long alphaAtOneDuration) {
+	this(loopCount, INCREASING_ENABLE,
+	     triggerTime, phaseDelayDuration,
+	     increasingAlphaDuration, increasingAlphaRampDuration,
+	     alphaAtOneDuration, 0, 0, 0);
+    }
+
+
+    /**
+      *  This constructor takes only the loopCount and increasingAlphaDuration
+      *  as parameters and assigns the default values to all of the other
+      *  parameters.
+      * @param loopCount number of times to run this alpha; a value
+      * of -1 specifies that the alpha loops indefinitely
+      * @param increasingAlphaDuration period of time during which alpha goes
+      * from zero to one
+      */
+    public Alpha(int loopCount, long increasingAlphaDuration) {
+        // defaults
+        mode = INCREASING_ENABLE;
+        increasingAlpha = (float) increasingAlphaDuration * .001f;
+        this.loopCount = loopCount;
+
+	if (loopCount >= 0) {
+	    stopTime = loopCount*increasingAlpha;
+	}
+    }
+
+
+    /**
+     * Pauses this alpha object.  The current system time when this
+     * method is called will be used in place of the actual current
+     * time when calculating subsequent alpha values.  This has the
+     * effect of freezing the interpolator at the time the method is
+     * called.
+     *
+     * @since Java 3D 1.3
+     */
+    public void pause() {
+	pause(J3dClock.currentTimeMillis());
+    }
+
+    /**
+     * Pauses this alpha object as of the specified time.  The specified
+     * time will be used in place of the actual current time when
+     * calculating subsequent alpha values.  This has the effect of freezing
+     * the interpolator at the specified time.  Note that specifying a
+     * time in the future (that is, a time greater than
+     * System.currentTimeMillis()) will cause the alpha to immediately
+     * advance to that point before pausing.  Similarly, specifying a
+     * time in the past (that is, a time less than
+     * System.currentTimeMillis()) will cause the alpha to immediately
+     * revert to that point before pausing.
+     *
+     * @param time the time at which to pause the alpha
+     *
+     * @exception IllegalArgumentException if time <= 0
+     *
+     * @since Java 3D 1.3
+     */
+    public void pause(long time) {
+	if (time <= 0L) {
+	    throw new IllegalArgumentException(J3dI18N.getString("Alpha0"));
+	}
+
+	paused = true;
+	pauseTime = time;
+	VirtualUniverse.mc.sendRunMessage(J3dThread.RENDER_THREAD);
+    }
+
+    /**
+     * Resumes this alpha object.  If the alpha
+     * object was paused, the difference between the current
+     * time and the pause time will be used to adjust the startTime of
+     * this alpha.  The equation is as follows:
+     *
+     * <ul>
+     * <code>startTime += System.currentTimeMillis() - pauseTime</code>
+     * </ul>
+     *
+     * Since the alpha object is no longer paused, this has the effect
+     * of resuming the interpolator as of the current time.  If the
+     * alpha object is not paused when this method is called, then this
+     * method does nothing--the start time is not adjusted in this case.
+     *
+     * @since Java 3D 1.3
+     */
+    public void resume() {
+	resume(J3dClock.currentTimeMillis());
+    }
+
+    /**
+     * Resumes this alpha object as of the specified time.  If the alpha
+     * object was paused, the difference between the specified
+     * time and the pause time will be used to adjust the startTime of
+     * this alpha.  The equation is as follows:
+     *
+     * <ul><code>startTime += time - pauseTime</code></ul>
+     *
+     * Since the alpha object is no longer paused, this has the effect
+     * of resuming the interpolator as of the specified time.  If the
+     * alpha object is not paused when this method is called, then this
+     * method does nothing--the start time is not adjusted in this case.
+     *
+     * @param time the time at which to resume the alpha
+     *
+     * @exception IllegalArgumentException if time <= 0
+     *
+     * @since Java 3D 1.3
+     */
+    public void resume(long time) {
+	if (time <= 0L) {
+	    throw new IllegalArgumentException(J3dI18N.getString("Alpha0"));
+	}
+
+	if (paused) {
+	    long newStartTime = startTime + time - pauseTime;
+	    paused = false;
+	    pauseTime = 0L;
+	    setStartTime(newStartTime);
+	}
+    }
+
+    /**
+     * Returns true if this alpha object is paused.
+     * @return true if this alpha object is paused, false otherwise
+     *
+     * @since Java 3D 1.3
+     */
+    public boolean isPaused() {
+	return paused;
+    }
+
+    /**
+     * Returns the time at which this alpha was paused.
+     * @return the pause time; returns 0 if this alpha is not paused
+     *
+     * @since Java 3D 1.3
+     */
+    public long getPauseTime() {
+	return pauseTime;
+    }
+
+
+    /**
+     * This method returns a value between 0.0 and 1.0 inclusive,
+     * based on the current time and the time-to-alpha parameters
+     * established for this alpha.  If this alpha object is paused,
+     * the value will be based on the pause time rather than the
+     * current time.
+     * This method will return the starting alpha value if the alpha
+     * has not yet started (that is, if the current time is less
+     * than startTime + triggerTime + phaseDelayDuration). This
+     * method will return the ending alpha value if the alpha has
+     * finished (that is, if the loop count has expired).
+     *
+     * @return a value between 0.0 and 1.0 based on the current time
+     */
+    public float value() {
+	long currentTime = paused ? pauseTime : J3dClock.currentTimeMillis();
+	return this.value(currentTime);
+    }
+
+    /**
+     * This method returns a value between 0.0 and 1.0 inclusive,
+     * based on the specified time and the time-to-alpha parameters
+     * established for this alpha.
+     * This method will return the starting alpha value if the alpha
+     * has not yet started (that is, if the specified time is less
+     * than startTime + triggerTime + phaseDelayDuration). This
+     * method will return the ending alpha value if the alpha has
+     * finished (that is, if the loop count has expired).
+     *
+     * @param atTime The time for which we wish to compute alpha
+     * @return a value between 0.0 and 1.0 based on the specified time
+     */
+    public float value(long atTime) {
+	float interpolatorTime
+	  = (float)(atTime  - startTime) * .001f; // startTime is in millisec
+	float alpha, a1, a2, dt, alphaRampDuration;
+
+	//	System.err.println("alpha mode: " + mode);
+
+	// If non-looping and before start
+	//	if ((loopCount != -1) &&
+	//	    interpolatorTime <= ( triggerTime +  phaseDelay)) {
+	//
+	//	    if (( mode & INCREASING_ENABLE ) == 0 &&
+	//		( mode & DECREASING_ENABLE) != 0)
+	//		alpha = 1.0f;
+	//	    else
+	//		alpha = 0.0f;
+	//	    return alpha;
+	//	}
+
+
+	//  Case of {constantly} moving forward, snap back, forward again
+	if (( mode & INCREASING_ENABLE ) != 0 &&
+	    ( mode & DECREASING_ENABLE) == 0) {
+
+               if(interpolatorTime <= (triggerTime + phaseDelay))
+                      return 0.0f;
+
+               if((loopCount != -1) && (interpolatorTime >= stopTime))
+                      return 1.0f;
+
+	    //  Constant velocity case
+	    if (incAlphaRampInternal == 0.0f) {
+
+		alpha = mfmod((interpolatorTime -  triggerTime -  phaseDelay) +
+			      6.0f*( increasingAlpha +  alphaAtOne),
+			      (increasingAlpha + alphaAtOne))/ increasingAlpha;
+
+		if ( alpha > 1.0f)  alpha = 1.0f;
+		return alpha;
+	    }
+
+	    //  Ramped velocity case
+	    alphaRampDuration =  incAlphaRampInternal;
+
+	    dt = mfmod((interpolatorTime -  triggerTime -  phaseDelay) +
+		       6.0f*( increasingAlpha +  alphaAtOne),
+		       ( increasingAlpha +  alphaAtOne));
+	    if (dt >=  increasingAlpha) {  alpha = 1.0f; return alpha; }
+
+		// Original equation kept to help understand
+		// computation logic - simplification saves
+ 		// a multiply and an add
+		// a1 = 1.0f/(alphaRampDuration*alphaRampDuration +
+		//	   ( increasingAlpha - 2*alphaRampDuration)*
+		//	   alphaRampDuration);
+
+		a1 = 1.0f/(increasingAlpha * alphaRampDuration -
+			alphaRampDuration * alphaRampDuration);
+
+	    if (dt < alphaRampDuration) {
+		alpha = 0.5f*a1*dt*dt;
+	    } else if (dt <  increasingAlpha - alphaRampDuration) {
+		alpha = 0.5f*a1*alphaRampDuration*
+		    alphaRampDuration +
+		    (dt - alphaRampDuration)*a1*
+		    alphaRampDuration;
+	    } else {
+		alpha = a1*alphaRampDuration*alphaRampDuration +
+		    ( increasingAlpha - 2.0f*alphaRampDuration)*a1*
+		    alphaRampDuration -
+		    0.5f*a1*( increasingAlpha - dt)*
+		    ( increasingAlpha - dt);
+	    }
+	    return alpha;
+
+	} else
+
+
+	    // Case of {constantly} moving backward, snap forward, backward
+	    // again
+	    if (( mode & INCREASING_ENABLE ) == 0 &&
+		( mode & DECREASING_ENABLE) != 0) {
+
+		// If non-looping and past end
+		//		if ((loopCount != -1)
+		//		    && (interpolatorTime
+		//			>= (triggerTime + phaseDelay + decreasingAlpha))) {
+		//		    alpha = 0.0f;
+		//		    return alpha;
+		//		}
+
+                if(interpolatorTime <= (triggerTime + phaseDelay))
+                      return 1.0f;
+
+                if((loopCount != -1) && (interpolatorTime >= stopTime) )
+                      return 0.0f;
+
+
+
+		//  Constant velocity case
+		if (decAlphaRampInternal == 0.0f) {
+		    alpha = mfmod((interpolatorTime -  triggerTime -
+				   phaseDelay) +
+				  6.0f*( decreasingAlpha + alphaAtZero),
+				  (decreasingAlpha + alphaAtZero))/ decreasingAlpha;
+		    if ( alpha > 1.0f) {  alpha = 0.0f; return alpha; }
+		    alpha = 1.0f -  alpha;
+		    return alpha;
+		}
+
+		//  Ramped velocity case
+		alphaRampDuration =  decAlphaRampInternal;
+
+		dt = mfmod((interpolatorTime -  triggerTime -  phaseDelay) +
+			   6.0f*( decreasingAlpha +  alphaAtZero),
+			   ( decreasingAlpha +  alphaAtZero));
+		if (dt >=  decreasingAlpha) {  alpha = 0.0f; return alpha; }
+
+		// Original equation kept to help understand
+		// computation logic - simplification saves
+ 		// a multiply and an add
+		// a1 = 1.0f/(alphaRampDuration*alphaRampDuration +
+		//	   ( decreasingAlpha - 2*alphaRampDuration)*
+		//	   alphaRampDuration);
+
+		a1 = 1.0f/(decreasingAlpha * alphaRampDuration -
+			alphaRampDuration * alphaRampDuration);
+
+		if (dt < alphaRampDuration) {
+		    alpha = 0.5f*a1*dt*dt;
+		} else if (dt <  decreasingAlpha - alphaRampDuration) {
+		    alpha = 0.5f*a1*alphaRampDuration*
+			alphaRampDuration +
+			(dt - alphaRampDuration)*a1*
+			alphaRampDuration;
+		} else {
+		    alpha = a1*alphaRampDuration*alphaRampDuration +
+			( decreasingAlpha - 2.0f*alphaRampDuration)*a1*
+			alphaRampDuration -
+			0.5f*a1*( decreasingAlpha - dt)*
+			( decreasingAlpha - dt);
+		}
+		alpha = 1.0f -  alpha;
+		return alpha;
+
+	    } else
+
+
+		//  Case of {osscilating} increasing and decreasing alpha
+		if (( mode & INCREASING_ENABLE) != 0 &&
+		    ( mode & DECREASING_ENABLE) != 0) {
+
+		    // If non-looping and past end
+		  //		    if ((loopCount != -1) &&
+		  //			(interpolatorTime >=
+		  //			 (triggerTime +  phaseDelay +  increasingAlpha +
+		  //			  alphaAtOne +  decreasingAlpha))) {
+		  //			alpha = 0.0f;
+		  //			return alpha;
+		  //  }
+
+
+		    // If non-looping and past end, we always end up at zero since
+		    // decreasing alpha has been requested.
+		    if(interpolatorTime <= (triggerTime + phaseDelay))
+                         return 0.0f;
+
+		    if( (loopCount != -1) && (interpolatorTime >= stopTime))
+                         return 0.0f;
+
+		    //  Constant velocity case
+		    if (incAlphaRampInternal == 0.0f
+			&& decAlphaRampInternal == 0.0f) {
+			dt = mfmod(interpolatorTime - triggerTime - phaseDelay +
+				   6.0f*(increasingAlpha + alphaAtOne +
+					 decreasingAlpha + alphaAtZero),
+				   increasingAlpha + alphaAtOne +
+				   decreasingAlpha + alphaAtZero);
+			alpha = dt / increasingAlpha;
+			if ( alpha < 1.0f) return alpha;
+			// sub all increasing alpha time
+			dt -=  increasingAlpha;
+			if (dt <  alphaAtOne) {  alpha = 1.0f; return alpha; }
+			// sub out alpha @ 1 time
+			dt -=  alphaAtOne;
+			alpha = dt/ decreasingAlpha;
+			if ( alpha < 1.0f)  alpha = 1.0f -  alpha;
+			else  alpha = 0.0f;
+			return alpha;
+		    }
+
+		    //  Ramped velocity case
+		    alphaRampDuration =  incAlphaRampInternal;
+
+                    // work around for bug 4308308
+                    if (alphaRampDuration == 0.0f)
+                        alphaRampDuration = .00001f;
+
+		    dt = mfmod(interpolatorTime -  triggerTime -  phaseDelay +
+			       6.0f*( increasingAlpha +  alphaAtOne +
+				      decreasingAlpha +  alphaAtZero),
+			       increasingAlpha +  alphaAtOne +
+			       decreasingAlpha +  alphaAtZero);
+		    if (dt <=  increasingAlpha) {
+
+			// Original equation kept to help understand
+			// computation logic - simplification saves
+ 			// a multiply and an add
+			// a1 = 1.0f/(alphaRampDuration*alphaRampDuration +
+			//	   ( increasingAlpha - 2*alphaRampDuration)*
+			//	   alphaRampDuration);
+
+			a1 = 1.0f/(increasingAlpha * alphaRampDuration -
+				alphaRampDuration * alphaRampDuration);
+
+			if (dt < alphaRampDuration) {
+			    alpha = 0.5f*a1*dt*dt;
+			} else if (dt <  increasingAlpha - alphaRampDuration) {
+			    alpha = 0.5f*a1*alphaRampDuration*
+				alphaRampDuration +
+				(dt - alphaRampDuration)*a1*
+				alphaRampDuration;
+			} else {
+			    alpha = a1*alphaRampDuration*alphaRampDuration+
+				( increasingAlpha - 2.0f*alphaRampDuration)*a1*
+				alphaRampDuration -
+				0.5f*a1*( increasingAlpha - dt)*
+				( increasingAlpha - dt);
+			}
+			return alpha;
+		    }
+		    else if (dt <=  increasingAlpha +  alphaAtOne) {
+			alpha = 1.0f; return alpha;
+		    }
+		    else if (dt >=  increasingAlpha +  alphaAtOne +  decreasingAlpha) {
+			alpha = 0.0f; return alpha;
+		    }
+		    else {
+			dt -=  increasingAlpha + alphaAtOne;
+
+			alphaRampDuration =  decAlphaRampInternal;
+
+                        // work around for bug 4308308
+                        if (alphaRampDuration == 0.0f)
+                            alphaRampDuration = .00001f;
+
+			// Original equation kept to help understand
+			// computation logic - simplification saves
+			// a multiply and an add
+			// a1 = 1.0f/(alphaRampDuration*alphaRampDuration +
+			//	   ( decreasingAlpha - 2*alphaRampDuration)*
+			//	   alphaRampDuration);
+
+			a1 = 1.0f/(decreasingAlpha * alphaRampDuration -
+				alphaRampDuration * alphaRampDuration);
+
+			if (dt < alphaRampDuration) {
+			    alpha = 0.5f*a1*dt*dt;
+			} else if (dt <  decreasingAlpha - alphaRampDuration) {
+			    alpha = 0.5f*a1*alphaRampDuration*
+				alphaRampDuration +
+				(dt - alphaRampDuration)*a1*
+				alphaRampDuration;
+			} else {
+			    alpha =
+				a1*alphaRampDuration*alphaRampDuration +
+				(decreasingAlpha - 2.0f*alphaRampDuration)*a1*
+				alphaRampDuration -
+				0.5f*a1*( decreasingAlpha - dt)*
+				(decreasingAlpha - dt);
+			}
+			alpha = 1.0f -  alpha;
+			return alpha;
+		    }
+
+		}
+	return 0.0f;
+    }
+
+    float mfmod(float a, float b) {
+	float fm, ta = (a), tb = (b);
+	int fmint;
+	if (tb < 0.0f) tb = -tb;
+	if (ta < 0.0f) ta = -ta;
+
+	fmint =(int)( ta/tb);
+	fm = ta - (float)fmint * tb;
+
+	if ((a) < 0.0f) return ((b) - fm);
+	else return fm;
+    }
+
+    /**
+      * Retrieves this alpha's startTime, the base
+      * for all relative time specifications; the default value
+      * for startTime is the system start time.
+      * @return this alpha's startTime.
+      */
+    public long getStartTime() {
+	return this.startTime;
+    }
+
+    /**
+     * Sets this alpha's startTime to that specified in the argument;
+     * startTime sets the base (or zero) for all relative time
+     * computations; the default value for startTime is the system
+     * start time.
+     * @param startTime the new startTime value
+     */
+    public void setStartTime(long startTime) {
+	this.startTime = startTime;
+	// This is used for passive wakeupOnElapsedFrame in
+	// Interpolator to restart behavior after alpha.finished()
+	VirtualUniverse.mc.sendRunMessage(J3dThread.RENDER_THREAD);
+    }
+
+    /**
+      * Retrieves this alpha's loopCount.
+      * @return this alpha's loopCount.
+      */
+    public int getLoopCount() {
+	return this.loopCount;
+    }
+
+    /**
+      * Set this alpha's loopCount to that specified in the argument.
+      * @param loopCount the new loopCount value
+      */
+    public void setLoopCount(int loopCount) {
+	this.loopCount = loopCount;
+	computeStopTime();
+	VirtualUniverse.mc.sendRunMessage(J3dThread.RENDER_THREAD);
+    }
+
+    /**
+      * Retrieves this alpha's mode.
+      * @return this alpha's mode: any combination of
+      * INCREASING_ENABLE and DECREASING_ENABLE
+      */
+    public int getMode() {
+	return this.mode;
+    }
+
+    /**
+      * Set this alpha's mode to that specified in the argument.
+     * @param mode indicates whether the increasing alpha parameters or
+     * the decreasing alpha parameters or both are active.  This parameter
+     * accepts the following values, INCREASING_ENABLE or
+     * DECREASING_ENABLE, which may be ORed together to specify
+     * that both are active.
+     * The increasing alpha parameters are increasingAlphaDuration,
+     * increasingAlphaRampDuration, and alphaAtOneDuration.
+     * The decreasing alpha parameters are decreasingAlphaDuration,
+     * decreasingAlphaRampDuration, and alphaAtZeroDuration.
+      */
+    public void setMode(int mode) {
+	this.mode = mode;
+	computeStopTime();
+	VirtualUniverse.mc.sendRunMessage(J3dThread.RENDER_THREAD);
+    }
+
+    /**
+      * Retrieves this alpha's triggerTime.
+      * @return this alpha's triggerTime.
+      */
+    public long getTriggerTime() {
+	return (long) (this.triggerTime * 1000f);
+    }
+
+    /**
+      * Set this alpha's triggerTime to that specified in the argument.
+      * @param triggerTime  the new triggerTime
+      */
+    public void setTriggerTime(long triggerTime) {
+	this.triggerTime = (float) triggerTime * .001f;
+	computeStopTime();
+	VirtualUniverse.mc.sendRunMessage(J3dThread.RENDER_THREAD);
+    }
+
+    /**
+      * Retrieves this alpha's phaseDelayDuration.
+      * @return this alpha's phaseDelayDuration.
+      */
+    public long getPhaseDelayDuration() {
+	return (long)(this.phaseDelay * 1000f);
+    }
+
+    /**
+      * Set this alpha's phaseDelayDuration to that specified in
+      * the argument.
+      * @param phaseDelayDuration  the new phaseDelayDuration
+      */
+    public void setPhaseDelayDuration(long phaseDelayDuration) {
+	this.phaseDelay = (float) phaseDelayDuration * .001f;
+	computeStopTime();
+	VirtualUniverse.mc.sendRunMessage(J3dThread.RENDER_THREAD);
+    }
+
+    /**
+      * Retrieves this alpha's increasingAlphaDuration.
+      * @return this alpha's increasingAlphaDuration.
+      */
+    public long getIncreasingAlphaDuration() {
+	return (long)(this.increasingAlpha * 1000f);
+    }
+
+    /**
+      * Set this alpha's increasingAlphaDuration to that specified in
+      * the argument.
+      * @param increasingAlphaDuration  the new increasingAlphaDuration
+      */
+    public void setIncreasingAlphaDuration(long increasingAlphaDuration) {
+	this.increasingAlpha = (float) increasingAlphaDuration * .001f;
+	computeStopTime();
+	VirtualUniverse.mc.sendRunMessage(J3dThread.RENDER_THREAD);
+    }
+
+    /**
+      * Retrieves this alpha's increasingAlphaRampDuration.
+      * @return this alpha's increasingAlphaRampDuration.
+      */
+    public long getIncreasingAlphaRampDuration() {
+	return increasingAlphaRamp;
+    }
+
+    /**
+      * Set this alpha's increasingAlphaRampDuration to that specified
+      * in the argument.
+      * @param increasingAlphaRampDuration  the new increasingAlphaRampDuration
+      */
+    public void setIncreasingAlphaRampDuration(long increasingAlphaRampDuration) {
+	increasingAlphaRamp = increasingAlphaRampDuration;
+	incAlphaRampInternal = (float) increasingAlphaRampDuration * .001f;
+	if (incAlphaRampInternal > (0.5f * increasingAlpha)) {
+	    incAlphaRampInternal = 0.5f * increasingAlpha;
+	}
+	VirtualUniverse.mc.sendRunMessage(J3dThread.RENDER_THREAD);
+    }
+
+    /**
+      * Retrieves this alpha's alphaAtOneDuration.
+      * @return this alpha's alphaAtOneDuration.
+      */
+    public long getAlphaAtOneDuration() {
+	return (long)(this.alphaAtOne * 1000f);
+    }
+
+    /**
+     * Set this alpha object's alphaAtOneDuration to the specified
+     * value.
+     * @param alphaAtOneDuration  the new alphaAtOneDuration
+     */
+    public void setAlphaAtOneDuration(long alphaAtOneDuration) {
+	this.alphaAtOne = (float) alphaAtOneDuration * .001f;
+	computeStopTime();
+	VirtualUniverse.mc.sendRunMessage(J3dThread.RENDER_THREAD);
+    }
+
+    /**
+      * Retrieves this alpha's decreasingAlphaDuration.
+      * @return this alpha's decreasingAlphaDuration.
+      */
+    public long getDecreasingAlphaDuration() {
+	return (long)(this.decreasingAlpha * 1000f);
+    }
+
+    /**
+      * Set this alpha's decreasingAlphaDuration to that specified in
+      * the argument.
+      * @param decreasingAlphaDuration  the new decreasingAlphaDuration
+      */
+    public void setDecreasingAlphaDuration(long decreasingAlphaDuration) {
+	this.decreasingAlpha = (float) decreasingAlphaDuration * .001f;
+	computeStopTime();
+	VirtualUniverse.mc.sendRunMessage(J3dThread.RENDER_THREAD);
+    }
+
+    /**
+      * Retrieves this alpha's decreasingAlphaRampDuration.
+      * @return this alpha's decreasingAlphaRampDuration.
+      */
+    public long getDecreasingAlphaRampDuration() {
+	return decreasingAlphaRamp;
+    }
+
+    /**
+      * Set this alpha's decreasingAlphaRampDuration to that specified
+      * in the argument.
+      * @param decreasingAlphaRampDuration  the new decreasingAlphaRampDuration
+      */
+    public void setDecreasingAlphaRampDuration(long decreasingAlphaRampDuration) {
+	decreasingAlphaRamp = decreasingAlphaRampDuration;
+	decAlphaRampInternal = (float) decreasingAlphaRampDuration * .001f;
+	if (decAlphaRampInternal > (0.5f * decreasingAlpha)) {
+	    decAlphaRampInternal = 0.5f * decreasingAlpha;
+	}
+	VirtualUniverse.mc.sendRunMessage(J3dThread.RENDER_THREAD);
+    }
+
+    /**
+      * Retrieves this alpha's alphaAtZeroDuration.
+      * @return this alpha's alphaAtZeroDuration.
+      */
+    public long getAlphaAtZeroDuration() {
+	return (long)(this.alphaAtZero * 1000f);
+    }
+
+    /**
+     * Set this alpha object's alphaAtZeroDuration to the specified
+     * value.
+     * @param alphaAtZeroDuration  the new alphaAtZeroDuration
+     */
+    public void setAlphaAtZeroDuration(long alphaAtZeroDuration) {
+	this.alphaAtZero = (float) alphaAtZeroDuration * .001f;
+	computeStopTime();
+	VirtualUniverse.mc.sendRunMessage(J3dThread.RENDER_THREAD);
+    }
+
+    /**
+     * Query to test if this alpha object is past its activity window,
+     * that is, if it has finished looping.
+     * @return true if no longer looping, false otherwise
+     */
+    public boolean finished() {
+	long currentTime = paused ? pauseTime : J3dClock.currentTimeMillis();
+	return ((loopCount != -1) &&
+ 	        ((float)(currentTime - startTime) * .001f > stopTime));
+    }
+
+    final private void computeStopTime() {
+        if (loopCount >= 0) {
+	    float sum = 0;
+	    if (( mode & INCREASING_ENABLE ) != 0) {
+		sum = increasingAlpha+alphaAtOne;
+	    }
+	    if ((mode & DECREASING_ENABLE) != 0) {
+		sum += decreasingAlpha+alphaAtZero;
+	    }
+	    stopTime = this.triggerTime + phaseDelay + loopCount*sum;
+	} else {
+	    stopTime = 0;
+	}
+    }
+
+    /**
+     * This internal method returns a clone of the Alpha
+     *
+     * @return a duplicate of this Alpha
+     */
+    Alpha cloneAlpha() {
+      Alpha a = new Alpha();
+      a.setStartTime(getStartTime());
+      a.setLoopCount(getLoopCount());
+      a.setMode(getMode());
+      a.setTriggerTime(getTriggerTime());
+      a.setPhaseDelayDuration(getPhaseDelayDuration());
+      a.setIncreasingAlphaDuration(getIncreasingAlphaDuration());
+      a.setIncreasingAlphaRampDuration(getIncreasingAlphaRampDuration());
+      a.setAlphaAtOneDuration(getAlphaAtOneDuration());
+      a.setDecreasingAlphaDuration(getDecreasingAlphaDuration());
+      a.setDecreasingAlphaRampDuration(getDecreasingAlphaRampDuration());
+      a.setAlphaAtZeroDuration(getAlphaAtZeroDuration());
+      return a;
+    }
+
+    static {
+        VirtualUniverse.loadLibraries();
+    }
+
+}