Created an AnimationHelper to ease the creation process of a spatial animation, based on key frames interpolation.
git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@8955 75d07b2b-3a1a-0410-a2c5-0572b91ccdca3.0
rem..om
13 years ago
parent
1b1bad7da5
commit
7de07d056c
@ -0,0 +1,494 @@ |
|||||||
|
/* |
||||||
|
* Copyright (c) 2009-2011 jMonkeyEngine |
||||||
|
* All rights reserved. |
||||||
|
* |
||||||
|
* Redistribution and use in source and binary forms, with or without |
||||||
|
* modification, are permitted provided that the following conditions are |
||||||
|
* met: |
||||||
|
* |
||||||
|
* * Redistributions of source code must retain the above copyright |
||||||
|
* notice, this list of conditions and the following disclaimer. |
||||||
|
* |
||||||
|
* * 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. |
||||||
|
* |
||||||
|
* * Neither the name of 'jMonkeyEngine' nor the names of its contributors |
||||||
|
* may be used to endorse or promote products derived from this software |
||||||
|
* without specific prior written permission. |
||||||
|
* |
||||||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||||||
|
* "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 THE COPYRIGHT OWNER 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. |
||||||
|
*/ |
||||||
|
package com.jme3.animation; |
||||||
|
|
||||||
|
import com.jme3.math.FastMath; |
||||||
|
import com.jme3.math.Quaternion; |
||||||
|
import com.jme3.math.Transform; |
||||||
|
import com.jme3.math.Vector3f; |
||||||
|
|
||||||
|
/** |
||||||
|
* A convenience class to easily setup a spatial keyframed animation |
||||||
|
* you can add some keyFrames for a given time or a given keyFrameIndex, for translation rotation and scale. |
||||||
|
* The animationHelper will then generate an appropriate SpatialAnimation by interpolating values between the keyFrames. |
||||||
|
* <br><br> |
||||||
|
* Usage is : <br> |
||||||
|
* - Create the AnimationHelper<br> |
||||||
|
* - add some keyFrames<br> |
||||||
|
* - call the buildAnimation() method that will retruna new Animation<br> |
||||||
|
* - add the generated Animation to any existing AnimationControl<br> |
||||||
|
* <br><br> |
||||||
|
* Note that the first keyFrame (index 0) is defaulted with the identy transforms. |
||||||
|
* If you want to change that you have to replace this keyFrame with any transform you want. |
||||||
|
* |
||||||
|
* @author Nehon |
||||||
|
*/ |
||||||
|
public class AnimationHelper { |
||||||
|
|
||||||
|
/** |
||||||
|
* step for splitting rotation that have a n ange above PI/2 |
||||||
|
*/ |
||||||
|
private final static float EULER_STEP = FastMath.QUARTER_PI * 3; |
||||||
|
|
||||||
|
/** |
||||||
|
* enum to determine the type of interpolation |
||||||
|
*/ |
||||||
|
private enum Type { |
||||||
|
|
||||||
|
Translation, Rotation, Scale; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Inner Rotation type class to kep track on a rotation Euler angle |
||||||
|
*/ |
||||||
|
protected class Rotation { |
||||||
|
|
||||||
|
/** |
||||||
|
* The rotation Quaternion |
||||||
|
*/ |
||||||
|
Quaternion rotation = new Quaternion(); |
||||||
|
/** |
||||||
|
* This rotation expressed in Euler angles |
||||||
|
*/ |
||||||
|
Vector3f eulerAngles = new Vector3f(); |
||||||
|
/** |
||||||
|
* the index of the parent key frame is this keyFrame is a splitted rotation |
||||||
|
*/ |
||||||
|
int masterKeyFrame = -1; |
||||||
|
|
||||||
|
public Rotation() { |
||||||
|
rotation.loadIdentity(); |
||||||
|
} |
||||||
|
|
||||||
|
void set(Quaternion rot) { |
||||||
|
rotation.set(rot); |
||||||
|
float[] a = new float[3]; |
||||||
|
rotation.toAngles(a); |
||||||
|
eulerAngles.set(a[0], a[1], a[2]); |
||||||
|
} |
||||||
|
|
||||||
|
void set(float x, float y, float z) { |
||||||
|
float[] a = {x, y, z}; |
||||||
|
rotation.fromAngles(a); |
||||||
|
eulerAngles.set(x, y, z); |
||||||
|
} |
||||||
|
} |
||||||
|
/** |
||||||
|
* Name of the animation |
||||||
|
*/ |
||||||
|
protected String name; |
||||||
|
/** |
||||||
|
* frames per seconds |
||||||
|
*/ |
||||||
|
protected int fps; |
||||||
|
/** |
||||||
|
* Animation duration in seconds |
||||||
|
*/ |
||||||
|
protected float duration; |
||||||
|
/** |
||||||
|
* total number of frames |
||||||
|
*/ |
||||||
|
protected int totalFrames; |
||||||
|
/** |
||||||
|
* time per frame |
||||||
|
*/ |
||||||
|
protected float tpf; |
||||||
|
/** |
||||||
|
* Time array for this animation |
||||||
|
*/ |
||||||
|
protected float[] times; |
||||||
|
/** |
||||||
|
* Translation array for this animation |
||||||
|
*/ |
||||||
|
protected Vector3f[] translations; |
||||||
|
/** |
||||||
|
* rotation array for this animation |
||||||
|
*/ |
||||||
|
protected Quaternion[] rotations; |
||||||
|
/** |
||||||
|
* scales array for this animation |
||||||
|
*/ |
||||||
|
protected Vector3f[] scales; |
||||||
|
/** |
||||||
|
* The map of keyFrames to compute the animation. The key is the index of the frame |
||||||
|
*/ |
||||||
|
protected Vector3f[] keyFramesTranslation; |
||||||
|
protected Vector3f[] keyFramesScale; |
||||||
|
protected Rotation[] keyFramesRotation; |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates and AnimationHelper |
||||||
|
* @param duration the desired duration for the resulting animation |
||||||
|
* @param name the name of the resulting animation |
||||||
|
*/ |
||||||
|
public AnimationHelper(float duration, String name) { |
||||||
|
this(duration, name, 30); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates and AnimationHelper |
||||||
|
* @param duration the desired duration for the resulting animation |
||||||
|
* @param name the name of the resulting animation |
||||||
|
* @param fps the number of frames per second for this animation (default is 30) |
||||||
|
*/ |
||||||
|
public AnimationHelper(float duration, String name, int fps) { |
||||||
|
this.name = name; |
||||||
|
this.duration = duration; |
||||||
|
this.fps = fps; |
||||||
|
totalFrames = (int) (fps * duration) + 1; |
||||||
|
tpf = 1 / (float) fps; |
||||||
|
times = new float[totalFrames]; |
||||||
|
translations = new Vector3f[totalFrames]; |
||||||
|
rotations = new Quaternion[totalFrames]; |
||||||
|
scales = new Vector3f[totalFrames]; |
||||||
|
keyFramesTranslation = new Vector3f[totalFrames]; |
||||||
|
keyFramesTranslation[0] = new Vector3f(); |
||||||
|
keyFramesScale = new Vector3f[totalFrames]; |
||||||
|
keyFramesScale[0] = new Vector3f(1, 1, 1); |
||||||
|
keyFramesRotation = new Rotation[totalFrames]; |
||||||
|
keyFramesRotation[0] = new Rotation(); |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Adds a key frame for the given Transform at the given time |
||||||
|
* @param time the time at which the keyFrame must be inserted |
||||||
|
* @param transform the transforms to use for this keyFrame |
||||||
|
*/ |
||||||
|
public void addTimeTransform(float time, Transform transform) { |
||||||
|
addKeyFrameTransform((int) (time / tpf), transform); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Adds a key frame for the given Transform at the given keyFrame index |
||||||
|
* @param keyFrameIndex the index at which the keyFrame must be inserted |
||||||
|
* @param transform the transforms to use for this keyFrame |
||||||
|
*/ |
||||||
|
public void addKeyFrameTransform(int keyFrameIndex, Transform transform) { |
||||||
|
addKeyFrameTranslation(keyFrameIndex, transform.getTranslation()); |
||||||
|
addKeyFrameScale(keyFrameIndex, transform.getScale()); |
||||||
|
addKeyFrameRotation(keyFrameIndex, transform.getRotation()); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Adds a key frame for the given translation at the given time |
||||||
|
* @param time the time at which the keyFrame must be inserted |
||||||
|
* @param translation the translation to use for this keyFrame |
||||||
|
*/ |
||||||
|
public void addTimeTranslation(float time, Vector3f translation) { |
||||||
|
addKeyFrameTranslation((int) (time / tpf), translation); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Adds a key frame for the given translation at the given keyFrame index |
||||||
|
* @param keyFrameIndex the index at which the keyFrame must be inserted |
||||||
|
* @param translation the translation to use for this keyFrame |
||||||
|
*/ |
||||||
|
public void addKeyFrameTranslation(int keyFrameIndex, Vector3f translation) { |
||||||
|
Vector3f t = getTranslationForFrame(keyFrameIndex); |
||||||
|
t.set(translation); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Adds a key frame for the given rotation at the given time<br> |
||||||
|
* This can't be used if the interpolated angle is higher than PI (180°)<br> |
||||||
|
* Use {@link addTimeRotationAngles(float time, float x, float y, float z)} instead that uses Euler angles rotations.<br> * |
||||||
|
* @param time the time at which the keyFrame must be inserted |
||||||
|
* @param rotation the rotation Quaternion to use for this keyFrame |
||||||
|
* @see #addTimeRotationAngles(float time, float x, float y, float z) |
||||||
|
*/ |
||||||
|
public void addTimeRotation(float time, Quaternion rotation) { |
||||||
|
addKeyFrameRotation((int) (time / tpf), rotation); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Adds a key frame for the given rotation at the given keyFrame index<br> |
||||||
|
* This can't be used if the interpolated angle is higher than PI (180°)<br> |
||||||
|
* Use {@link addKeyFrameRotationAngles(int keyFrameIndex, float x, float y, float z)} instead that uses Euler angles rotations. |
||||||
|
* @param keyFrameIndex the index at which the keyFrame must be inserted |
||||||
|
* @param rotation the rotation Quaternion to use for this keyFrame |
||||||
|
* @see #addKeyFrameRotationAngles(int keyFrameIndex, float x, float y, float z) |
||||||
|
*/ |
||||||
|
public void addKeyFrameRotation(int keyFrameIndex, Quaternion rotation) { |
||||||
|
Rotation r = getRotationForFrame(keyFrameIndex); |
||||||
|
r.set(rotation); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Adds a key frame for the given rotation at the given time.<br> |
||||||
|
* Rotation is expressed by Euler angles values in radians.<br> |
||||||
|
* Note that the generated rotation will be stored as a quaternion and interpolated using a spherical linear interpolation (slerp)<br> |
||||||
|
* Hence, this method may create intermediate keyFrames if the interpolation angle is higher than PI to ensure continuity in animation<br> |
||||||
|
* |
||||||
|
* @param time the time at which the keyFrame must be inserted |
||||||
|
* @param x the rotation around the x axis (aka yaw) in radians |
||||||
|
* @param y the rotation around the y axis (aka roll) in radians |
||||||
|
* @param z the rotation around the z axis (aka pitch) in radians |
||||||
|
*/ |
||||||
|
public void addTimeRotationAngles(float time, float x, float y, float z) { |
||||||
|
addKeyFrameRotationAngles((int) (time / tpf), x, y, z); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Adds a key frame for the given rotation at the given key frame index.<br> |
||||||
|
* Rotation is expressed by Euler angles values in radians.<br> |
||||||
|
* Note that the generated rotation will be stored as a quaternion and interpolated using a spherical linear interpolation (slerp)<br> |
||||||
|
* Hence, this method may create intermediate keyFrames if the interpolation angle is higher than PI to ensure continuity in animation<br> |
||||||
|
* |
||||||
|
* @param keyFrameIndex the index at which the keyFrame must be inserted |
||||||
|
* @param x the rotation around the x axis (aka yaw) in radians |
||||||
|
* @param y the rotation around the y axis (aka roll) in radians |
||||||
|
* @param z the rotation around the z axis (aka pitch) in radians |
||||||
|
*/ |
||||||
|
public void addKeyFrameRotationAngles(int keyFrameIndex, float x, float y, float z) { |
||||||
|
Rotation r = getRotationForFrame(keyFrameIndex); |
||||||
|
r.set(x, y, z); |
||||||
|
|
||||||
|
// if the delta of euler angles is higher than PI, we create intermediate keyframes
|
||||||
|
// since we are using quaternions and slerp for rotation interpolation, we cannot interpolate over an angle higher than PI
|
||||||
|
int prev = getPreviousKeyFrame(keyFrameIndex, keyFramesRotation); |
||||||
|
//previous rotation keyframe
|
||||||
|
Rotation prevRot = keyFramesRotation[prev]; |
||||||
|
//the maximum delta angle (x,y or z)
|
||||||
|
float delta = Math.max(Math.abs(x - prevRot.eulerAngles.x), Math.abs(y - prevRot.eulerAngles.y)); |
||||||
|
delta = Math.max(delta, Math.abs(z - prevRot.eulerAngles.z)); |
||||||
|
//if delta > PI we have to create intermediates key frames
|
||||||
|
if (delta >= FastMath.PI) { |
||||||
|
//frames delta
|
||||||
|
int dF = keyFrameIndex - prev; |
||||||
|
//angle per frame for x,y ,z
|
||||||
|
float dXAngle = (x - prevRot.eulerAngles.x) / (float) dF; |
||||||
|
float dYAngle = (y - prevRot.eulerAngles.y) / (float) dF; |
||||||
|
float dZAngle = (z - prevRot.eulerAngles.z) / (float) dF; |
||||||
|
|
||||||
|
// the keyFrame step
|
||||||
|
int keyStep = (int) (((float) (dF)) / delta * (float) EULER_STEP); |
||||||
|
// the current keyFrame
|
||||||
|
int cursor = prev + keyStep; |
||||||
|
while (cursor < keyFrameIndex) { |
||||||
|
//for each step we create a new rotation by interpolating the angles
|
||||||
|
Rotation dr = getRotationForFrame(cursor); |
||||||
|
dr.masterKeyFrame = keyFrameIndex; |
||||||
|
dr.set(prevRot.eulerAngles.x + cursor * dXAngle, prevRot.eulerAngles.y + cursor * dYAngle, prevRot.eulerAngles.z + cursor * dZAngle); |
||||||
|
cursor += keyStep; |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Adds a key frame for the given scale at the given time |
||||||
|
* @param time the time at which the keyFrame must be inserted |
||||||
|
* @param scale the scale to use for this keyFrame |
||||||
|
*/ |
||||||
|
public void addTimeScale(float time, Vector3f scale) { |
||||||
|
addKeyFrameScale((int) (time / tpf), scale); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Adds a key frame for the given scale at the given keyFrame index |
||||||
|
* @param keyFrameIndex the index at which the keyFrame must be inserted |
||||||
|
* @param scale the scale to use for this keyFrame |
||||||
|
*/ |
||||||
|
public void addKeyFrameScale(int keyFrameIndex, Vector3f scale) { |
||||||
|
Vector3f s = getScaleForFrame(keyFrameIndex); |
||||||
|
s.set(scale); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* returns the translation for a given frame index |
||||||
|
* creates the translation if it doesn't exists |
||||||
|
* @param keyFrameIndex index |
||||||
|
* @return the translation |
||||||
|
*/ |
||||||
|
private Vector3f getTranslationForFrame(int keyFrameIndex) { |
||||||
|
if (keyFrameIndex < 0 || keyFrameIndex > totalFrames) { |
||||||
|
throw new ArrayIndexOutOfBoundsException("keyFrameIndex must be between 0 and " + totalFrames + " (received " + keyFrameIndex + ")"); |
||||||
|
} |
||||||
|
Vector3f v = keyFramesTranslation[keyFrameIndex]; |
||||||
|
if (v == null) { |
||||||
|
v = new Vector3f(); |
||||||
|
keyFramesTranslation[keyFrameIndex] = v; |
||||||
|
} |
||||||
|
return v; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* returns the scale for a given frame index |
||||||
|
* creates the scale if it doesn't exists |
||||||
|
* @param keyFrameIndex index |
||||||
|
* @return the scale |
||||||
|
*/ |
||||||
|
private Vector3f getScaleForFrame(int keyFrameIndex) { |
||||||
|
if (keyFrameIndex < 0 || keyFrameIndex > totalFrames) { |
||||||
|
throw new ArrayIndexOutOfBoundsException("keyFrameIndex must be between 0 and " + totalFrames + " (received " + keyFrameIndex + ")"); |
||||||
|
} |
||||||
|
Vector3f v = keyFramesScale[keyFrameIndex]; |
||||||
|
if (v == null) { |
||||||
|
v = new Vector3f(); |
||||||
|
keyFramesScale[keyFrameIndex] = v; |
||||||
|
} |
||||||
|
return v; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* returns the rotation for a given frame index |
||||||
|
* creates the rotation if it doesn't exists |
||||||
|
* @param keyFrameIndex index |
||||||
|
* @return the rotation |
||||||
|
*/ |
||||||
|
private Rotation getRotationForFrame(int keyFrameIndex) { |
||||||
|
if (keyFrameIndex < 0 || keyFrameIndex > totalFrames) { |
||||||
|
throw new ArrayIndexOutOfBoundsException("keyFrameIndex must be between 0 and " + totalFrames + " (received " + keyFrameIndex + ")"); |
||||||
|
} |
||||||
|
Rotation v = keyFramesRotation[keyFrameIndex]; |
||||||
|
if (v == null) { |
||||||
|
v = new Rotation(); |
||||||
|
keyFramesRotation[keyFrameIndex] = v; |
||||||
|
} |
||||||
|
return v; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Creates an Animation based on the keyFrames previously added to the helper. |
||||||
|
* @return the generated animation |
||||||
|
*/ |
||||||
|
public Animation buildAnimation() { |
||||||
|
interpolateTime(); |
||||||
|
interpolate(keyFramesTranslation, Type.Translation); |
||||||
|
interpolate(keyFramesRotation, Type.Rotation); |
||||||
|
interpolate(keyFramesScale, Type.Scale); |
||||||
|
|
||||||
|
SpatialTrack spatialTrack = new SpatialTrack(times, translations, rotations, scales); |
||||||
|
|
||||||
|
//creating the animation
|
||||||
|
Animation spatialAnimation = new Animation(name, duration); |
||||||
|
spatialAnimation.setTracks(new SpatialTrack[]{spatialTrack}); |
||||||
|
|
||||||
|
return spatialAnimation; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* interpolates time values |
||||||
|
*/ |
||||||
|
private void interpolateTime() { |
||||||
|
for (int i = 0; i < totalFrames; i++) { |
||||||
|
times[i] = i * tpf; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Interpolates over the key frames for the given keyFrame array and the given type of transform |
||||||
|
* @param keyFrames the keyFrames array |
||||||
|
* @param type the type of transforms |
||||||
|
*/ |
||||||
|
private void interpolate(Object[] keyFrames, Type type) { |
||||||
|
int i = 0; |
||||||
|
while (i < totalFrames) { |
||||||
|
//fetching the next keyFrame index transform in the array
|
||||||
|
int key = getNextKeyFrame(i, keyFrames); |
||||||
|
if (key != -1) { |
||||||
|
//computing the frame span to interpolate over
|
||||||
|
int span = key - i; |
||||||
|
//interating over the frames
|
||||||
|
for (int j = i; j <= key; j++) { |
||||||
|
// computing interpolation value
|
||||||
|
float val = (float) (j - i) / (float) span; |
||||||
|
//interpolationg depending on the transform type
|
||||||
|
switch (type) { |
||||||
|
case Translation: |
||||||
|
translations[j] = FastMath.interpolateLinear(val, (Vector3f) keyFrames[i], (Vector3f) keyFrames[key]); |
||||||
|
break; |
||||||
|
case Rotation: |
||||||
|
Quaternion rot = new Quaternion(); |
||||||
|
rotations[j] = rot.slerp(((Rotation) keyFrames[i]).rotation, ((Rotation) keyFrames[key]).rotation, val); |
||||||
|
break; |
||||||
|
case Scale: |
||||||
|
scales[j] = FastMath.interpolateLinear(val, (Vector3f) keyFrames[i], (Vector3f) keyFrames[key]); |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
//jumping to the next keyFrame
|
||||||
|
i = key; |
||||||
|
} else { |
||||||
|
//No more key frame, filling the array witht he last transform computed.
|
||||||
|
for (int j = i; j < totalFrames; j++) { |
||||||
|
|
||||||
|
switch (type) { |
||||||
|
case Translation: |
||||||
|
translations[j] = ((Vector3f) keyFrames[i]).clone(); |
||||||
|
break; |
||||||
|
case Rotation: |
||||||
|
rotations[j] = ((Quaternion) ((Rotation) keyFrames[i]).rotation).clone(); |
||||||
|
break; |
||||||
|
case Scale: |
||||||
|
scales[j] = ((Vector3f) keyFrames[i]).clone(); |
||||||
|
break; |
||||||
|
} |
||||||
|
} |
||||||
|
//we're done
|
||||||
|
i = totalFrames; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Get the index of the next keyFrame that as a transform |
||||||
|
* @param index the start index |
||||||
|
* @param keyFrames the keyFrames array |
||||||
|
* @return the index of the next keyFrame |
||||||
|
*/ |
||||||
|
private int getNextKeyFrame(int index, Object[] keyFrames) { |
||||||
|
for (int i = index + 1; i < totalFrames; i++) { |
||||||
|
if (keyFrames[i] != null) { |
||||||
|
return i; |
||||||
|
} |
||||||
|
} |
||||||
|
return -1; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Get the index of the previous keyFrame that as a transform |
||||||
|
* @param index the start index |
||||||
|
* @param keyFrames the keyFrames array |
||||||
|
* @return the index of the previous keyFrame |
||||||
|
*/ |
||||||
|
private int getPreviousKeyFrame(int index, Object[] keyFrames) { |
||||||
|
for (int i = index - 1; i >= 0; i--) { |
||||||
|
if (keyFrames[i] != null) { |
||||||
|
return i; |
||||||
|
} |
||||||
|
} |
||||||
|
return -1; |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,85 @@ |
|||||||
|
package jme3test.model.anim; |
||||||
|
|
||||||
|
import com.jme3.animation.AnimControl; |
||||||
|
import com.jme3.animation.AnimationHelper; |
||||||
|
import com.jme3.app.SimpleApplication; |
||||||
|
import com.jme3.light.AmbientLight; |
||||||
|
import com.jme3.light.DirectionalLight; |
||||||
|
import com.jme3.math.FastMath; |
||||||
|
import com.jme3.math.Quaternion; |
||||||
|
import com.jme3.math.Vector3f; |
||||||
|
import com.jme3.scene.Geometry; |
||||||
|
import com.jme3.scene.Node; |
||||||
|
import com.jme3.scene.shape.Box; |
||||||
|
import com.jme3.util.TangentBinormalGenerator; |
||||||
|
|
||||||
|
public class TestAnimationHelper extends SimpleApplication { |
||||||
|
|
||||||
|
public static void main(String[] args) { |
||||||
|
TestSpatialAnim app = new TestSpatialAnim(); |
||||||
|
app.start(); |
||||||
|
} |
||||||
|
|
||||||
|
@Override |
||||||
|
public void simpleInitApp() { |
||||||
|
|
||||||
|
AmbientLight al = new AmbientLight(); |
||||||
|
rootNode.addLight(al); |
||||||
|
|
||||||
|
DirectionalLight dl = new DirectionalLight(); |
||||||
|
dl.setDirection(Vector3f.UNIT_XYZ.negate()); |
||||||
|
rootNode.addLight(dl); |
||||||
|
|
||||||
|
// Create model
|
||||||
|
Box box = new Box(1, 1, 1); |
||||||
|
Geometry geom = new Geometry("box", box); |
||||||
|
geom.setMaterial(assetManager.loadMaterial("Textures/Terrain/BrickWall/BrickWall.j3m")); |
||||||
|
Node model = new Node("model"); |
||||||
|
model.attachChild(geom); |
||||||
|
|
||||||
|
Box child = new Box(0.5f, 0.5f, 0.5f); |
||||||
|
Geometry childGeom = new Geometry("box", child); |
||||||
|
childGeom.setMaterial(assetManager.loadMaterial("Textures/Terrain/BrickWall/BrickWall.j3m")); |
||||||
|
Node childModel = new Node("childmodel"); |
||||||
|
childModel.setLocalTranslation(2, 2, 2); |
||||||
|
childModel.attachChild(childGeom); |
||||||
|
model.attachChild(childModel); |
||||||
|
TangentBinormalGenerator.generate(model); |
||||||
|
|
||||||
|
//creating quite complex animation witht the AnimationHelper
|
||||||
|
// animation of 6 seconds named "anim" and with 25 frames per second
|
||||||
|
AnimationHelper animationHelper = new AnimationHelper(6, "anim", 25); |
||||||
|
|
||||||
|
//creating a translation keyFrame at time = 3 with a translation on the x axis of 5 WU
|
||||||
|
animationHelper.addTimeTranslation(3, new Vector3f(5, 0, 0)); |
||||||
|
//reseting the translation to the start position at time = 6
|
||||||
|
animationHelper.addTimeTranslation(6, new Vector3f(0, 0, 0)); |
||||||
|
|
||||||
|
//Creating a scale keyFrame at time = 2 with the unit scale.
|
||||||
|
animationHelper.addTimeScale(2, new Vector3f(1, 1, 1)); |
||||||
|
//Creating a scale keyFrame at time = 4 scaling to 1.5
|
||||||
|
animationHelper.addTimeScale(4, new Vector3f(1.5f, 1.5f, 1.5f)); |
||||||
|
//reseting the scale to the start value at time = 5
|
||||||
|
animationHelper.addTimeScale(5, new Vector3f(1, 1, 1)); |
||||||
|
|
||||||
|
|
||||||
|
//Creating a rotation keyFrame at time = 0.5 of quarter PI around the Z axis
|
||||||
|
animationHelper.addTimeRotation(0.5f,new Quaternion().fromAngleAxis(FastMath.QUARTER_PI, Vector3f.UNIT_Z)); |
||||||
|
//rotating back to initial rotation value at time = 1
|
||||||
|
animationHelper.addTimeRotation(1,Quaternion.IDENTITY); |
||||||
|
//Creating a rotation keyFrame at time = 2. Note that i used the Euler angle version because the angle is higher than PI
|
||||||
|
//this should result in a complete revolution of the spatial around the x axis in 1 second (from 1 to 2)
|
||||||
|
animationHelper.addTimeRotationAngles(2, FastMath.TWO_PI,0, 0); |
||||||
|
|
||||||
|
|
||||||
|
AnimControl control = new AnimControl(); |
||||||
|
control.addAnim(animationHelper.buildAnimation()); |
||||||
|
|
||||||
|
model.addControl(control); |
||||||
|
|
||||||
|
rootNode.attachChild(model); |
||||||
|
|
||||||
|
//run animation
|
||||||
|
control.createChannel().setAnim("anim"); |
||||||
|
} |
||||||
|
} |
||||||
Loading…
Reference in new issue