From ce88350abfda47e52bf0d0d2747fcc03d54e7dda Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Re=CC=81my=20Bouquet?= Date: Mon, 1 Jan 2018 18:00:43 +0100 Subject: [PATCH] Better blending structure --- .../main/java/com/jme3/anim/AnimComposer.java | 40 +++--- .../com/jme3/anim/tween/AnimClipTween.java | 87 ------------ .../com/jme3/anim/tween/ContainsTweens.java | 6 + .../main/java/com/jme3/anim/tween/Tweens.java | 30 +++- .../com/jme3/anim/tween/action/Action.java | 39 ++--- .../jme3/anim/tween/action/BaseAction.java | 40 ++++++ .../jme3/anim/tween/action/BlendAction.java | 133 ++++++++++++------ .../anim/tween/action/BlendableAction.java | 83 +++++++++++ .../jme3/anim/tween/action/ClipAction.java | 64 +++++++++ .../anim/tween/action/LinearBlendSpace.java | 14 +- .../anim/tween/action/SequenceAction.java | 75 ---------- .../model/anim/TestAnimMigration.java | 10 +- 12 files changed, 346 insertions(+), 275 deletions(-) delete mode 100644 jme3-core/src/main/java/com/jme3/anim/tween/AnimClipTween.java create mode 100644 jme3-core/src/main/java/com/jme3/anim/tween/ContainsTweens.java create mode 100644 jme3-core/src/main/java/com/jme3/anim/tween/action/BaseAction.java create mode 100644 jme3-core/src/main/java/com/jme3/anim/tween/action/BlendableAction.java create mode 100644 jme3-core/src/main/java/com/jme3/anim/tween/action/ClipAction.java delete mode 100644 jme3-core/src/main/java/com/jme3/anim/tween/action/SequenceAction.java diff --git a/jme3-core/src/main/java/com/jme3/anim/AnimComposer.java b/jme3-core/src/main/java/com/jme3/anim/AnimComposer.java index 1bdb41176..1814faf72 100644 --- a/jme3-core/src/main/java/com/jme3/anim/AnimComposer.java +++ b/jme3-core/src/main/java/com/jme3/anim/AnimComposer.java @@ -1,11 +1,8 @@ package com.jme3.anim; -import com.jme3.anim.tween.AnimClipTween; import com.jme3.anim.tween.Tween; -import com.jme3.anim.tween.action.Action; -import com.jme3.anim.tween.action.BlendAction; -import com.jme3.anim.tween.action.BlendSpace; -import com.jme3.anim.tween.action.SequenceAction; +import com.jme3.anim.tween.Tweens; +import com.jme3.anim.tween.action.*; import com.jme3.export.*; import com.jme3.renderer.RenderManager; import com.jme3.renderer.ViewPort; @@ -62,40 +59,37 @@ public class AnimComposer extends AbstractControl { } public void setCurrentAction(String name) { - Action action = action(name); - if (currentAction != null) { - currentAction.reset(); - } - currentAction = action; + currentAction = action(name); time = 0; } public Action action(String name) { Action action = actions.get(name); if (action == null) { - AnimClipTween tween = tweenFromClip(name); - action = new SequenceAction(tween); + AnimClip clip = animClipMap.get(name); + if (clip == null) { + throw new IllegalArgumentException("Cannot find clip named " + name); + } + action = new ClipAction(clip); actions.put(name, action); } return action; } - public AnimClipTween tweenFromClip(String clipName) { - AnimClip clip = animClipMap.get(clipName); - if (clip == null) { - throw new IllegalArgumentException("Cannot find clip named " + clipName); - } - return new AnimClipTween(clip); - } - public SequenceAction actionSequence(String name, Tween... tweens) { - SequenceAction action = new SequenceAction(tweens); + public BaseAction actionSequence(String name, Tween... tweens) { + BaseAction action = new BaseAction(Tweens.sequence(tweens)); actions.put(name, action); return action; } - public BlendAction actionBlended(String name, BlendSpace blendSpace, Tween... tweens) { - BlendAction action = new BlendAction(blendSpace, tweens); + public BlendAction actionBlended(String name, BlendSpace blendSpace, String... clips) { + BlendableAction[] acts = new BlendableAction[clips.length]; + for (int i = 0; i < acts.length; i++) { + BlendableAction ba = (BlendableAction) action(clips[i]); + acts[i] = ba; + } + BlendAction action = new BlendAction(blendSpace, acts); actions.put(name, action); return action; } diff --git a/jme3-core/src/main/java/com/jme3/anim/tween/AnimClipTween.java b/jme3-core/src/main/java/com/jme3/anim/tween/AnimClipTween.java deleted file mode 100644 index a36936244..000000000 --- a/jme3-core/src/main/java/com/jme3/anim/tween/AnimClipTween.java +++ /dev/null @@ -1,87 +0,0 @@ -package com.jme3.anim.tween; - -import com.jme3.anim.AnimClip; -import com.jme3.anim.TransformTrack; -import com.jme3.anim.tween.action.Action; -import com.jme3.anim.util.HasLocalTransform; -import com.jme3.anim.util.Weighted; -import com.jme3.export.InputCapsule; -import com.jme3.export.JmeExporter; -import com.jme3.export.JmeImporter; -import com.jme3.export.OutputCapsule; -import com.jme3.math.Transform; -import com.jme3.util.clone.Cloner; -import com.jme3.util.clone.JmeCloneable; - -import java.io.IOException; - -public class AnimClipTween implements Tween, Weighted, JmeCloneable { - - private AnimClip clip; - private Transform transform = new Transform(); - private float weight = 1f; - private Action parentAction; - - public AnimClipTween() { - } - - public AnimClipTween(AnimClip clip) { - this.clip = clip; - } - - @Override - public double getLength() { - return clip.getLength(); - } - - @Override - public boolean interpolate(double t) { - // Sanity check the inputs - if (t < 0) { - return true; - } - if (parentAction != null) { - weight = parentAction.getWeightForTween(this); - } - if (weight == 0) { - //weight is 0 let's not interpolate - return t < clip.getLength(); - } - TransformTrack[] tracks = clip.getTracks(); - for (TransformTrack track : tracks) { - HasLocalTransform target = track.getTarget(); - transform.set(target.getLocalTransform()); - track.getTransformAtTime(t, transform); - - if (weight == 1f) { - target.setLocalTransform(transform); - } else { - Transform tr = target.getLocalTransform(); - tr.interpolateTransforms(tr, transform, weight); - target.setLocalTransform(tr); - } - } - return t < clip.getLength(); - } - - - @Override - public Object jmeClone() { - try { - AnimClipTween clone = (AnimClipTween) super.clone(); - return clone; - } catch (CloneNotSupportedException ex) { - throw new AssertionError(); - } - } - - @Override - public void cloneFields(Cloner cloner, Object original) { - clip = cloner.clone(clip); - } - - @Override - public void setParentAction(Action action) { - this.parentAction = action; - } -} diff --git a/jme3-core/src/main/java/com/jme3/anim/tween/ContainsTweens.java b/jme3-core/src/main/java/com/jme3/anim/tween/ContainsTweens.java new file mode 100644 index 000000000..b7fe69bfc --- /dev/null +++ b/jme3-core/src/main/java/com/jme3/anim/tween/ContainsTweens.java @@ -0,0 +1,6 @@ +package com.jme3.anim.tween; + +public interface ContainsTweens { + + public Tween[] getTweens(); +} diff --git a/jme3-core/src/main/java/com/jme3/anim/tween/Tweens.java b/jme3-core/src/main/java/com/jme3/anim/tween/Tweens.java index b369cadce..54ff3986b 100644 --- a/jme3-core/src/main/java/com/jme3/anim/tween/Tweens.java +++ b/jme3-core/src/main/java/com/jme3/anim/tween/Tweens.java @@ -221,7 +221,7 @@ public class Tweens { } } - private static class Sequence implements Tween { + private static class Sequence implements Tween, ContainsTweens { private final Tween[] delegates; private int current = 0; private double baseTime; @@ -279,9 +279,14 @@ public class Tweens { public String toString() { return getClass().getSimpleName() + "[delegates=" + Arrays.asList(delegates) + "]"; } + + @Override + public Tween[] getTweens() { + return delegates; + } } - private static class Parallel implements Tween { + private static class Parallel implements Tween, ContainsTweens { private final Tween[] delegates; private final boolean[] done; private double length; @@ -343,6 +348,11 @@ public class Tweens { public String toString() { return getClass().getSimpleName() + "[delegates=" + Arrays.asList(delegates) + "]"; } + + @Override + public Tween[] getTweens() { + return delegates; + } } private static class Delay extends AbstractTween { @@ -356,14 +366,15 @@ public class Tweens { } } - private static class Stretch implements Tween { + private static class Stretch implements Tween, ContainsTweens { - private final Tween delegate; + private final Tween[] delegate = new Tween[1]; private final double length; private final double scale; public Stretch(Tween delegate, double length) { - this.delegate = delegate; + this.delegate[0] = delegate; + this.length = length; // Caller desires delegate to be 'length' instead of @@ -382,6 +393,11 @@ public class Tweens { return length; } + @Override + public Tween[] getTweens() { + return delegate; + } + @Override public boolean interpolate(double t) { if (t < 0) { @@ -392,12 +408,12 @@ public class Tweens { } else { t = length; } - return delegate.interpolate(t); + return delegate[0].interpolate(t); } @Override public String toString() { - return getClass().getSimpleName() + "[delegate=" + delegate + ", length=" + length + "]"; + return getClass().getSimpleName() + "[delegate=" + delegate[0] + ", length=" + length + "]"; } } diff --git a/jme3-core/src/main/java/com/jme3/anim/tween/action/Action.java b/jme3-core/src/main/java/com/jme3/anim/tween/action/Action.java index ea283f8ec..d445abf09 100644 --- a/jme3-core/src/main/java/com/jme3/anim/tween/action/Action.java +++ b/jme3-core/src/main/java/com/jme3/anim/tween/action/Action.java @@ -1,23 +1,21 @@ package com.jme3.anim.tween.action; import com.jme3.anim.tween.Tween; -import com.jme3.anim.util.Weighted; -import com.jme3.export.*; -import java.io.IOException; +public abstract class Action implements Tween { -public abstract class Action implements Tween, Weighted { - - protected Tween[] tweens; + protected Action[] actions; protected float weight = 1; protected double length; - protected Action parentAction; protected Action(Tween... tweens) { - this.tweens = tweens; - for (Tween tween : tweens) { - if (tween instanceof Weighted) { - ((Weighted) tween).setParentAction(this); + this.actions = new Action[tweens.length]; + for (int i = 0; i < tweens.length; i++) { + Tween tween = tweens[i]; + if (tween instanceof Action) { + this.actions[i] = (Action) tween; + } else { + this.actions[i] = new BaseAction(tween); } } } @@ -27,23 +25,8 @@ public abstract class Action implements Tween, Weighted { return length; } - @Override - public boolean interpolate(double t) { - if (parentAction != null) { - weight = parentAction.getWeightForTween(this); - } - - return doInterpolate(t); + public void setWeight(float weight) { + this.weight = weight; } - public abstract float getWeightForTween(Tween tween); - - public abstract boolean doInterpolate(double t); - - public abstract void reset(); - - @Override - public void setParentAction(Action parentAction) { - this.parentAction = parentAction; - } } diff --git a/jme3-core/src/main/java/com/jme3/anim/tween/action/BaseAction.java b/jme3-core/src/main/java/com/jme3/anim/tween/action/BaseAction.java new file mode 100644 index 000000000..6e59ce091 --- /dev/null +++ b/jme3-core/src/main/java/com/jme3/anim/tween/action/BaseAction.java @@ -0,0 +1,40 @@ +package com.jme3.anim.tween.action; + +import com.jme3.anim.tween.ContainsTweens; +import com.jme3.anim.tween.Tween; +import com.jme3.util.SafeArrayList; + +public class BaseAction extends Action { + + private Tween tween; + private SafeArrayList subActions = new SafeArrayList<>(Action.class); + + public BaseAction(Tween tween) { + this.tween = tween; + length = tween.getLength(); + gatherActions(tween); + } + + private void gatherActions(Tween tween) { + if (tween instanceof Action) { + subActions.add((Action) tween); + } else if (tween instanceof ContainsTweens) { + Tween[] tweens = ((ContainsTweens) tween).getTweens(); + for (Tween t : tweens) { + gatherActions(t); + } + } + } + + @Override + public void setWeight(float weight) { + for (Action action : subActions.getArray()) { + action.setWeight(weight); + } + } + + @Override + public boolean interpolate(double t) { + return tween.interpolate(t); + } +} diff --git a/jme3-core/src/main/java/com/jme3/anim/tween/action/BlendAction.java b/jme3-core/src/main/java/com/jme3/anim/tween/action/BlendAction.java index eb6afe01f..97188a11f 100644 --- a/jme3-core/src/main/java/com/jme3/anim/tween/action/BlendAction.java +++ b/jme3-core/src/main/java/com/jme3/anim/tween/action/BlendAction.java @@ -1,80 +1,129 @@ package com.jme3.anim.tween.action; -import com.jme3.anim.tween.Tween; -import com.jme3.anim.tween.Tweens; +import com.jme3.anim.util.HasLocalTransform; +import com.jme3.math.Transform; -public class BlendAction extends Action { +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; +public class BlendAction extends BlendableAction { - private Tween firstActiveTween; - private Tween secondActiveTween; + private int firstActiveIndex; + private int secondActiveIndex; private BlendSpace blendSpace; private float blendWeight; + private double[] timeFactor; + private Map targetMap = new HashMap<>(); - public BlendAction(BlendSpace blendSpace, Tween... tweens) { - super(tweens); + public BlendAction(BlendSpace blendSpace, BlendableAction... actions) { + super(actions); + timeFactor = new double[actions.length]; this.blendSpace = blendSpace; blendSpace.setBlendAction(this); - for (Tween tween : tweens) { - if (tween.getLength() > length) { - length = tween.getLength(); + for (BlendableAction action : actions) { + if (action.getLength() > length) { + length = action.getLength(); + } + Collection targets = action.getTargets(); + for (HasLocalTransform target : targets) { + Transform t = targetMap.get(target); + if (t == null) { + t = new Transform(); + targetMap.put(target, t); + } } } //Blending effect maybe unexpected when blended animation don't have the same length - //Stretching any tween that doesn't have the same length. - for (int i = 0; i < tweens.length; i++) { - if (tweens[i].getLength() != length) { - tweens[i] = Tweens.stretch(length, tweens[i]); + //Stretching any action that doesn't have the same length. + for (int i = 0; i < this.actions.length; i++) { + this.timeFactor[i] = 1; + if (this.actions[i].getLength() != length) { + double actionLength = this.actions[i].getLength(); + if (actionLength > 0 && length > 0) { + this.timeFactor[i] = this.actions[i].getLength() / length; + } } } - } - @Override - public float getWeightForTween(Tween tween) { + public void doInterpolate(double t) { blendWeight = blendSpace.getWeight(); - if (tween == firstActiveTween) { - return 1f; + BlendableAction firstActiveAction = (BlendableAction) actions[firstActiveIndex]; + BlendableAction secondActiveAction = (BlendableAction) actions[secondActiveIndex]; + firstActiveAction.setCollectTransformDelegate(this); + secondActiveAction.setCollectTransformDelegate(this); + + //only interpolate the first action if the weight if below 1. + if (blendWeight < 1f) { + firstActiveAction.setWeight(1f); + firstActiveAction.interpolate(t * timeFactor[firstActiveIndex]); + if (blendWeight == 0) { + for (HasLocalTransform target : targetMap.keySet()) { + collect(target, targetMap.get(target)); + } + } } - return weight * blendWeight; - } - @Override - public boolean doInterpolate(double t) { - if (firstActiveTween == null) { - blendSpace.getWeight(); - } + //Second action should be interpolated + secondActiveAction.setWeight(blendWeight); + secondActiveAction.interpolate(t * timeFactor[secondActiveIndex]); - boolean running = this.firstActiveTween.interpolate(t); - this.secondActiveTween.interpolate(t); + firstActiveAction.setCollectTransformDelegate(null); + secondActiveAction.setCollectTransformDelegate(null); - if (!running) { - return false; - } + } - return true; + protected Action[] getActions() { + return actions; } - @Override - public void reset() { + public BlendSpace getBlendSpace() { + return blendSpace; + } + protected void setFirstActiveIndex(int index) { + this.firstActiveIndex = index; } - protected Tween[] getTweens() { - return tweens; + protected void setSecondActiveIndex(int index) { + this.secondActiveIndex = index; } - public BlendSpace getBlendSpace() { - return blendSpace; + @Override + public Collection getTargets() { + return targetMap.keySet(); } - protected void setFirstActiveTween(Tween firstActiveTween) { - this.firstActiveTween = firstActiveTween; + @Override + public void collectTransform(HasLocalTransform target, Transform t, float weight, BlendableAction source) { + + Transform tr = targetMap.get(target); + if (weight == 1) { + tr.set(t); + } else if (weight > 0) { + tr.interpolateTransforms(tr, t, weight); + } + + if (source == actions[secondActiveIndex]) { + collect(target, tr); + } } - protected void setSecondActiveTween(Tween secondActiveTween) { - this.secondActiveTween = secondActiveTween; + private void collect(HasLocalTransform target, Transform tr) { + if (collectTransformDelegate != null) { + collectTransformDelegate.collectTransform(target, tr, this.weight, this); + } else { + if (getTransitionWeight() == 1) { + target.setLocalTransform(tr); + } else { + Transform trans = target.getLocalTransform(); + trans.interpolateTransforms(trans, tr, getTransitionWeight()); + target.setLocalTransform(trans); + } + } } + } diff --git a/jme3-core/src/main/java/com/jme3/anim/tween/action/BlendableAction.java b/jme3-core/src/main/java/com/jme3/anim/tween/action/BlendableAction.java new file mode 100644 index 000000000..6ad68edc2 --- /dev/null +++ b/jme3-core/src/main/java/com/jme3/anim/tween/action/BlendableAction.java @@ -0,0 +1,83 @@ +package com.jme3.anim.tween.action; + +import com.jme3.anim.tween.AbstractTween; +import com.jme3.anim.tween.Tween; +import com.jme3.anim.util.HasLocalTransform; +import com.jme3.math.Transform; + +import java.util.Collection; + +public abstract class BlendableAction extends Action { + + protected BlendableAction collectTransformDelegate; + private float transitionWeight = 1.0f; + private double transitionLength = 0.4f; + private TransitionTween transition = new TransitionTween(transitionLength); + + public BlendableAction(Tween... tweens) { + super(tweens); + } + + + public void setCollectTransformDelegate(BlendableAction delegate) { + this.collectTransformDelegate = delegate; + } + + @Override + public boolean interpolate(double t) { + // Sanity check the inputs + if (t < 0) { + return true; + } + + if (collectTransformDelegate == null) { + if (transition.getLength() > getLength()) { + transition.setLength(getLength()); + } + transition.interpolate(t); + } else { + transitionWeight = 1f; + } + + if (weight == 0) { + //weight is 0 let's not interpolate + return t < getLength(); + } + + doInterpolate(t); + + return t < getLength(); + } + + protected abstract void doInterpolate(double t); + + public abstract Collection getTargets(); + + public abstract void collectTransform(HasLocalTransform target, Transform t, float weight, BlendableAction source); + + public double getTransitionLength() { + return transitionLength; + } + + public void setTransitionLength(double transitionLength) { + this.transitionLength = transitionLength; + } + + protected float getTransitionWeight() { + return transitionWeight; + } + + private class TransitionTween extends AbstractTween { + + + public TransitionTween(double length) { + super(length); + } + + @Override + protected void doInterpolate(double t) { + transitionWeight = (float) t; + } + } + +} diff --git a/jme3-core/src/main/java/com/jme3/anim/tween/action/ClipAction.java b/jme3-core/src/main/java/com/jme3/anim/tween/action/ClipAction.java new file mode 100644 index 000000000..2eb9aefc7 --- /dev/null +++ b/jme3-core/src/main/java/com/jme3/anim/tween/action/ClipAction.java @@ -0,0 +1,64 @@ +package com.jme3.anim.tween.action; + +import com.jme3.anim.AnimClip; +import com.jme3.anim.TransformTrack; +import com.jme3.anim.tween.AbstractTween; +import com.jme3.anim.util.HasLocalTransform; +import com.jme3.math.Transform; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +public class ClipAction extends BlendableAction { + + private AnimClip clip; + private Transform transform = new Transform(); + + public ClipAction(AnimClip clip) { + this.clip = clip; + length = clip.getLength(); + } + + @Override + public void doInterpolate(double t) { + TransformTrack[] tracks = clip.getTracks(); + for (TransformTrack track : tracks) { + HasLocalTransform target = track.getTarget(); + transform.set(target.getLocalTransform()); + track.getTransformAtTime(t, transform); + + if (collectTransformDelegate != null) { + collectTransformDelegate.collectTransform(target, transform, weight, this); + } else { + this.collectTransform(target, transform, getTransitionWeight(), this); + } + } + } + + public void reset() { + + } + + @Override + public Collection getTargets() { + List targets = new ArrayList<>(clip.getTracks().length); + for (TransformTrack track : clip.getTracks()) { + targets.add(track.getTarget()); + } + return targets; + } + + @Override + public void collectTransform(HasLocalTransform target, Transform t, float weight, BlendableAction source) { + if (weight == 1f) { + target.setLocalTransform(t); + } else { + Transform tr = target.getLocalTransform(); + tr.interpolateTransforms(tr, t, weight); + target.setLocalTransform(tr); + } + } + + +} diff --git a/jme3-core/src/main/java/com/jme3/anim/tween/action/LinearBlendSpace.java b/jme3-core/src/main/java/com/jme3/anim/tween/action/LinearBlendSpace.java index 0c086d1e8..f9773f8a0 100644 --- a/jme3-core/src/main/java/com/jme3/anim/tween/action/LinearBlendSpace.java +++ b/jme3-core/src/main/java/com/jme3/anim/tween/action/LinearBlendSpace.java @@ -1,7 +1,5 @@ package com.jme3.anim.tween.action; -import com.jme3.anim.tween.Tween; - public class LinearBlendSpace implements BlendSpace { private BlendAction action; @@ -17,24 +15,24 @@ public class LinearBlendSpace implements BlendSpace { @Override public void setBlendAction(BlendAction action) { this.action = action; - Tween[] tweens = action.getTweens(); - step = maxValue / (float) (tweens.length - 1); + Action[] actions = action.getActions(); + step = maxValue / (float) (actions.length - 1); } @Override public float getWeight() { - Tween[] tweens = action.getTweens(); + Action[] actions = action.getActions(); float lowStep = 0, highStep = 0; int lowIndex = 0, highIndex = 0; - for (int i = 0; i < tweens.length && highStep < value; i++) { + for (int i = 0; i < actions.length && highStep < value; i++) { lowStep = highStep; lowIndex = i; highStep += step; } highIndex = lowIndex + 1; - action.setFirstActiveTween(tweens[lowIndex]); - action.setSecondActiveTween(tweens[highIndex]); + action.setFirstActiveIndex(lowIndex); + action.setSecondActiveIndex(highIndex); if (highStep == lowStep) { return 0; diff --git a/jme3-core/src/main/java/com/jme3/anim/tween/action/SequenceAction.java b/jme3-core/src/main/java/com/jme3/anim/tween/action/SequenceAction.java deleted file mode 100644 index 08c59085a..000000000 --- a/jme3-core/src/main/java/com/jme3/anim/tween/action/SequenceAction.java +++ /dev/null @@ -1,75 +0,0 @@ -package com.jme3.anim.tween.action; - -import com.jme3.anim.tween.AbstractTween; -import com.jme3.anim.tween.Tween; - -public class SequenceAction extends Action { - - private int currentIndex = 0; - private double accumTime; - private double transitionTime = 0; - private float mainWeight = 1.0f; - private double transitionLength = 0.4f; - private TransitionTween transition = new TransitionTween(transitionLength); - - - public SequenceAction(Tween... tweens) { - super(tweens); - for (Tween tween : tweens) { - length += tween.getLength(); - } - } - - @Override - public float getWeightForTween(Tween tween) { - return weight * mainWeight; - } - - @Override - public boolean doInterpolate(double t) { - Tween currentTween = tweens[currentIndex]; - if (transition.getLength() > currentTween.getLength()) { - transition.setLength(currentTween.getLength()); - } - - transition.interpolate(t - transitionTime); - - boolean running = currentTween.interpolate(t - accumTime); - if (!running) { - accumTime += currentTween.getLength(); - currentIndex++; - transitionTime = accumTime; - transition.setLength(transitionLength); - } - - if (t >= length) { - reset(); - return false; - } - return true; - } - - public void reset() { - currentIndex = 0; - accumTime = 0; - transitionTime = 0; - mainWeight = 1; - } - - public void setTransitionLength(double transitionLength) { - this.transitionLength = transitionLength; - } - - private class TransitionTween extends AbstractTween { - - - public TransitionTween(double length) { - super(length); - } - - @Override - protected void doInterpolate(double t) { - mainWeight = (float) t; - } - } -} diff --git a/jme3-examples/src/main/java/jme3test/model/anim/TestAnimMigration.java b/jme3-examples/src/main/java/jme3test/model/anim/TestAnimMigration.java index a2c40dd60..d3eea6de5 100644 --- a/jme3-examples/src/main/java/jme3test/model/anim/TestAnimMigration.java +++ b/jme3-examples/src/main/java/jme3test/model/anim/TestAnimMigration.java @@ -3,6 +3,7 @@ package jme3test.model.anim; import com.jme3.anim.AnimComposer; import com.jme3.anim.SkinningControl; import com.jme3.anim.tween.action.BlendAction; +import com.jme3.anim.tween.action.BlendableAction; import com.jme3.anim.tween.action.LinearBlendSpace; import com.jme3.anim.util.AnimMigrationUtils; import com.jme3.app.ChaseCameraAppState; @@ -159,13 +160,12 @@ public class TestAnimMigration extends SimpleApplication { anims.add(name); } composer.actionSequence("Sequence", - composer.tweenFromClip("Walk"), - composer.tweenFromClip("Run"), - composer.tweenFromClip("Jumping")); + composer.action("Walk"), + composer.action("Run"), + composer.action("Jumping")); action = composer.actionBlended("Blend", new LinearBlendSpace(4), - composer.tweenFromClip("Walk"), - composer.tweenFromClip("Jumping")); + "Walk", "Punches", "Jumping", "Taunt"); action.getBlendSpace().setValue(2);