package mocap.player;
|
|
import java.util.ArrayList;
|
import java.util.List;
|
|
import javax.vecmath.Point3d;
|
|
import mocap.figure.AnimData;
|
import mocap.figure.Bone;
|
|
/**
|
* Plays a mocap animation, the "motor" that drives every skeleton.
|
* Needs the skeleton and the animation data (usually mocap data).
|
* The method update(fps) must be called periodically to make animation run.
|
*
|
* @author Michael Kipp
|
*/
|
public class MocapPlayer extends AnimPlayer
|
{
|
|
private static final float DEFAULT_FPS = 90;
|
private boolean _isPlaying = false;
|
private Bone _root;
|
private Bone[] _bones; // skeleton
|
private double _time = 0;
|
private float _fps; // playback fps
|
private int _frame = -1; // current frame
|
private AnimData _animData;
|
private Point3d _offset;
|
private boolean _pinAtRoot = false;
|
|
public MocapPlayer(Bone skeleton, AnimData dat, Point3d offset)
|
{
|
_fps = DEFAULT_FPS;
|
_animData = dat;
|
_offset = offset;
|
_root = skeleton;
|
initSkeleton(skeleton);
|
}
|
|
private void initSkeleton(Bone skeleton)
|
{
|
List<Bone> ls = new ArrayList<Bone>();
|
skeleton.collectBones(ls);
|
_bones = new Bone[ls.size()];
|
_bones = (Bone[]) ls.toArray(_bones);
|
}
|
|
private int mapTimeToFrame(double time)
|
{
|
return (int) Math.max(time * _fps, 0);
|
}
|
|
public Bone[] getBones()
|
{
|
return _bones;
|
}
|
|
/**
|
* When set, figure's root will not move at all, the figure is "pinned"
|
* at its root joint (usually the hip).
|
*
|
* @param val whether to pin or not
|
*/
|
public void setPinAtRoot(boolean val) {
|
_pinAtRoot = val;
|
}
|
|
public void gotoTime(double sec)
|
{
|
int f = mapTimeToFrame(sec);
|
gotoFrame(f < _animData.getNumFrames() ? f : _animData.getNumFrames() - 1);
|
}
|
|
private void gotoFrame(int frame)
|
{
|
if (_animData != null) {
|
for (int i = 0; i < _bones.length; i++) {
|
Bone bone = _bones[i];
|
|
if (bone != _root || !_pinAtRoot) {
|
bone.setPose(frame, _animData.getBoneData(bone.getIndex()), _offset);
|
}
|
}
|
_frame = frame;
|
for (PlayerFrameListener li : _listeners) {
|
li.frameUpdate(frame);
|
}
|
}
|
}
|
|
public int getNumFrames()
|
{
|
return _animData.getNumFrames();
|
}
|
|
public int getCurrentFrame()
|
{
|
return _frame;
|
}
|
|
/**
|
* Intended playback speed of the motion capture fragment.
|
* @param fps
|
*/
|
public void setPlaybackFps(float fps)
|
{
|
_fps = fps;
|
_time = _frame / _fps;
|
}
|
|
public float getPlaybackFps()
|
{
|
return _fps;
|
}
|
|
public void setIsPlaying(boolean val)
|
{
|
if (val && _animData != null) {
|
_isPlaying = true;
|
} else {
|
_isPlaying = false;
|
}
|
}
|
|
public boolean isPlaying()
|
{
|
return _isPlaying;
|
}
|
|
public void reset()
|
{
|
_isPlaying = false;
|
_time = 0;
|
_frame = -1;
|
gotoFrame(0);
|
}
|
|
public void frameForward()
|
{
|
_frame++;
|
if (_frame >= _animData.getNumFrames()) {
|
_frame = 0;
|
}
|
_time = _frame / _fps;
|
gotoFrame(_frame);
|
}
|
|
public void frameBackward()
|
{
|
_frame--;
|
if (_frame < 0) {
|
_frame = _animData.getNumFrames() - 1;
|
}
|
_time = _frame / _fps;
|
gotoFrame(_frame);
|
}
|
|
/**
|
* Converts the system's fps to the intended playback fps und changes
|
* animation frames accordingly. Usually system speed is higher (and
|
* is also an upper limit to the playback speed).
|
*
|
* @param fps The fps speed of the system
|
*/
|
@Override
|
public void update(float fps)
|
{
|
if (_isPlaying) {
|
_time += 1 / fps; // time in seconds since setIsPlaying
|
int frame = (int) (_time * _fps); // frame in animation
|
if (frame >= _animData.getNumFrames()) {
|
_time = 0;
|
_frame = -1;
|
} else if (frame > _frame) {
|
gotoFrame(frame);
|
_frame = frame;
|
}
|
}
|
// return _frame;
|
}
|
}
|
