Translate model over time like actor? - animation

Question

I recently picked up learning LibGDX and loved the simplicity of the Actor system when it came to moving/fading/rotating stuff. So simple! But, moving into 3d, I wondered if there was a similar style of implementation.
I've seen people saying "instance.transform(x,y,z)", but that's immediately applied and shown on the next render. I was wondering if I could interpolate that transformation using some of the built-in frameworks ala "model.addAction(moveTo(x,y,z), duration(0.4f));" I know that Model doesn't inherit from Actor in the way that most elements in scene2d do. When it comes to skeletal animation and imported animations for said model, I understand the current animation framework in place, but I'm looking more for a solution to move my model around my gameworld without having to do a ton of dependent logic in the render.
Instead of cluttering up my render loop with a custom interpolation implementation, is there a way to use the Action framework on a Model? Just stuff like translate, rotate, etc. (If not, I may go down the path of implementing the action, pool, etc. on the Model object.)
Thanks!

Answer 1

A quick and dirty trick is to use scene2d's actions system on the side. Create a Stage with no actors in it. You can send your actions directly to the stage and call stage.update(delta); once per frame to handle all your actions. You don't need to draw the stage to do this. (Down the road, you will likely want a stage for your 2D UI stuff anyway though.)
You will need to create your own Actions. Since a stage is not meant for 3D, there's no reason to try to use Actors. Your Actions can be applied directly to the stage for processing, and designed not to target any Actor.
Here's an example (untested). Since you are mainly concerned with blending stuff over time, you probably will be extending most of your Actions from TemporalAction.
public class MoveVector3ToAction extends TemporalAction {
private Vector3 target;
private float startX, startY, startZ, endX, endY, endZ;
protected void begin(){
startX = target.x;
startY = target.y;
startZ = target.z;
}
protected void update (float percent) {
target.set(startX + (endX - startX) * percent, startY + (endY - startY) * percent, startZ + (endZ - startZ) * percent);
}
public void reset(){
super.reset();
target = null; //must clear reference for pooling purposes
}
public void setTarget(Vector3 target){
this.target = target;
}
public void setPosition(float x, float y, float z){
endX = x;
endY = y;
endZ = z;
}
}
You can create a convenience class analogous to the Actions class to make it easy to set up generating your actions with automatic pooling:
public class MyActions {
public static MoveVector3ToAction moveVector3To (Vector3 target, float x, float y, float z, float duration){
return moveVector3To(target, x, y, z, duration, null);
}
public static MoveVector3ToAction moveVector3To (Vector3 target, float x, float y, float z, float duration, Interpolation interpolation){
MoveVector3ToAction action = Actions.action(MoveVector3ToAction.class);
action.setTarget(target);
action.setPosition(x, y, z);
action.setDuration(duration);
action.setInterpolation(interpolation);
return action;
}
}
Sample usage. ModelInstances are a bit tricky to move around, because you have to do it with their Matrix4 transform, but you can't safely back the position or rotation or scale out of the transform. So you need to keep a separate Vector3 position and Quaternion rotation, and apply them on each frame to update the instance's transform.
//Static import MyActions to avoid needing to type "MyActions" over and over.
import static com.mydomain.mygame.MyActions.*;
//To move some ModelInstance
stage.addAction(moveVector3To(myInstancePosition, 10, 10, 10, 1f, Interpolation.pow2));
//In render():
stage.update(delta);
myInstance.transform.set(myInstancePosition, myInstanceRotation);