javax.media.j3d.PathInterpolator Maven / Gradle / Ivy
/*
* Copyright 1998-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;
/**
* PathInterpolator behavior. This class defines the base class for
* all Path Interpolators. Subclasses have access to the
* computePathInterpolation() method, which computes the
* currentInterpolationValue given the current time and alpha.
* The method also computes the currentKnotIndex, which is based on
* the currentInterpolationValue.
* The currentInterpolationValue is calculated
* by linearly interpolating among a series of predefined knots
* (using the value generated by the specified Alpha object).
* The first knot must have a value of 0.0 and the last knot must have a
* value of 1.0. An intermediate knot with index k must have a value
* strictly greater than any knot with index less than k.
*/
public abstract class PathInterpolator extends TransformInterpolator {
// Array of knots
private float knots[];
/**
* This value is the ratio between knot values indicated by
* the currentKnotIndex variable. So if a subclass wanted to
* interpolate between knot values, it would use the currentKnotIndex
* to get the bounding knots for the "real" value, then use the
* currentInterpolationValue to interpolate between the knots.
* To calculate this variable, a subclass needs to call
* the computePathInterpolation(alphaValue) method from the subclass's
* computeTransform() method. Then this variable will hold a valid
* value which can be used in further calculations by the subclass.
*/
protected float currentInterpolationValue;
/**
* This value is the index of the current base knot value, as
* determined by the alpha function. A subclass wishing to
* interpolate between bounding knots would use this index and
* the one following it, and would use the currentInterpolationValue
* variable as the ratio between these indices.
* To calculate this variable, a subclass needs to call
* the computePathInterpolation(alphaValue) method from the subclass's
* computeTransform() method. Then this variable will hold a valid
* value which can be used in further calculations by the subclass.
*/
protected int currentKnotIndex;
/**
* Constructs a PathInterpolator node with a null alpha value and
* a null target of TransformGroup
*
* since Java 3D 1.3
*/
PathInterpolator() {
}
/**
* Constructs a new PathInterpolator object that interpolates
* between the knot values in the knots array. The array of knots
* is copied into this PathInterpolator object.
* @param alpha the alpha object for this interpolator.
* @param knots an array of knot values that specify interpolation
* points.
*
* @deprecated As of Java 3D version 1.3, replaced by
* PathInterpolator(Alpha, TransformGroup, float[])
*/
public PathInterpolator(Alpha alpha, float[] knots) {
this(alpha, null, knots);
}
/**
* Constructs a new PathInterpolator object that interpolates
* between the knot values in the knots array. The array of knots
* is copied into this PathInterpolator object.
* @param alpha the alpha object for this interpolator.
* @param target the transformgroup node effected by this pathInterpolator
* @param knots an array of knot values that specify interpolation
* points.
*
* @since Java 3D 1.3
*/
public PathInterpolator(Alpha alpha,TransformGroup target,
float[] knots) {
super(alpha, target);
setKnots(knots);
}
/**
* Constructs a new PathInterpolator object that interpolates
* between the knot values in the knots array. The array of knots
* is copied into this PathInterpolator object.
* @param alpha the alpha object for this interpolator.
* @param target the transform node effected by this positionInterpolator
* @param axisOfTransform the transform that defines the local coordinate
* @param knots an array of knot values that specify interpolation
* points.
*
* @since Java 3D 1.3
*/
public PathInterpolator(Alpha alpha,TransformGroup target, Transform3D axisOfTransform,
float[] knots) {
super(alpha, target, axisOfTransform);
setKnots(knots);
}
/**
* Retrieves the length of the knots array.
* @return the array length
*/
public int getArrayLengths(){
return knots.length;
}
/**
* Sets the knot at the specified index for this interpolator.
* @param index the index to be changed
* @param knot the new knot value
*/
public void setKnot(int index, float knot) {
this.knots[index] = knot;
}
/**
* Retrieves the knot at the specified index.
* @param index the index of the value requested
* @return the interpolator's knot value at the associated index
*/
public float getKnot(int index) {
return this.knots[index];
}
/**
* Replaces the existing array of knot values with
* the specified array. The array of knots is copied into this
* interpolator object. Prior to calling this method,
* subclasses should verify that the lengths of the new knots array
* and subclass-specific parameter arrays are the same.
* @param knots a new array of knot values that specify
* interpolation points.
*
* @since Java 3D 1.2
*/
protected void setKnots(float[] knots) {
if (knots[0] < -0.0001 || knots[0] > 0.0001) {
throw new IllegalArgumentException(J3dI18N.getString("PathInterpolator0"));
}
if ((knots[knots.length-1] - 1.0f) < -0.0001 || (knots[knots.length-1] - 1.0f) > 0.0001) {
throw new IllegalArgumentException(J3dI18N.getString("PathInterpolator1"));
}
this.knots = new float[knots.length];
for (int i = 0; i < knots.length; i++) {
if (i>0 && knots[i] < knots[i-1]) {
throw new IllegalArgumentException(J3dI18N.getString("PathInterpolator2"));
}
this.knots[i] = knots[i];
}
}
/**
* Copies the array of knots from this interpolator
* into the specified array.
* The array must be large enough to hold all of the knots.
* @param knots array that will receive the knots.
*
* @since Java 3D 1.2
*/
public void getKnots(float[] knots) {
for (int i = 0; i < this.knots.length; i++) {
knots[i] = this.knots[i];
}
}
/**
* Computes the base knot index and interpolation value
* given the specified value of alpha and the knots[] array. If
* the index is 0 and there should be no interpolation, both the
* index variable and the interpolation variable are set to 0.
* Otherwise, currentKnotIndex is set to the lower index of the
* two bounding knot points and the currentInterpolationValue
* variable is set to the ratio of the alpha value between these
* two bounding knot points.
* @param alphaValue alpha value between 0.0 and 1.0
*
* @since Java 3D 1.3
*/
protected void computePathInterpolation(float alphaValue ) {
int i;
for (i = 0; i < knots.length; i++) {
if ((i == 0 && alphaValue <= knots[i]) ||
(i > 0 && alphaValue >= knots[i-1] && alphaValue <= knots[i])) {
if (i==0) {
currentInterpolationValue = 0f;
currentKnotIndex = 0;
}
else {
currentInterpolationValue =
(alphaValue - knots[i-1])/(knots[i] - knots[i-1]);
currentKnotIndex = i - 1;
}
break;
}
}
}
/**
* @deprecated As of Java 3D version 1.3, replaced by
* computePathInterpolation(float)
*/
protected void computePathInterpolation() {
float value = this.alpha.value();
computePathInterpolation(value);
}
/**
* Copies all PathInterpolator information from
* originalNode into
* the current node. This method is called from the
* cloneNode method which is, in turn, called by the
* cloneTree method.
*
* @param originalNode the original node to duplicate.
* @param forceDuplicate when set to true, causes the
* duplicateOnCloneTree flag to be ignored. When
* false, the value of each node's
* duplicateOnCloneTree variable determines whether
* NodeComponent data is duplicated or copied.
*
* @exception RestrictedAccessException if this object is part of a live
* or compiled scenegraph.
*
* @see Node#duplicateNode
* @see Node#cloneTree
* @see NodeComponent#setDuplicateOnCloneTree
*/
@Override
void duplicateAttributes(Node originalNode, boolean forceDuplicate) {
super.duplicateAttributes(originalNode, forceDuplicate);
PathInterpolator pi = (PathInterpolator) originalNode;
int len = pi.getArrayLengths();
// No API available to set knots size
knots = new float[len];
for (int i = 0; i < len; i++)
setKnot(i, pi.getKnot(i));
}
}