/**
|
* JMOCAP
|
*
|
* Developed by Michael Kipp, 2008-2011, DFKI Saarbrücken, Germany
|
* E-Mail: mich.kipp@googlemail.com
|
*
|
* This software has been released under the
|
* GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007
|
*/
|
|
package mocap;
|
|
import java.awt.Color;
|
import java.awt.Dimension;
|
import java.awt.Font;
|
import java.awt.GraphicsConfiguration;
|
import java.awt.event.MouseEvent;
|
import java.awt.event.MouseListener;
|
import java.awt.event.MouseMotionListener;
|
import java.awt.event.MouseWheelEvent;
|
import java.awt.event.MouseWheelListener;
|
import java.io.File;
|
import java.io.IOException;
|
import java.util.Map;
|
|
import javax.media.j3d.AmbientLight;
|
import javax.media.j3d.Appearance;
|
import javax.media.j3d.BoundingSphere;
|
import javax.media.j3d.BranchGroup;
|
import javax.media.j3d.Canvas3D;
|
import javax.media.j3d.DirectionalLight;
|
import javax.media.j3d.J3DGraphics2D;
|
import javax.media.j3d.Material;
|
import javax.media.j3d.Switch;
|
import javax.media.j3d.Transform3D;
|
import javax.vecmath.Color3f;
|
import javax.vecmath.Point3d;
|
import javax.vecmath.Vector3d;
|
import javax.vecmath.Vector3f;
|
|
import com.sun.j3d.utils.behaviors.vp.OrbitBehavior;
|
import com.sun.j3d.utils.geometry.Sphere;
|
import com.sun.j3d.utils.universe.SimpleUniverse;
|
|
import mocap.figure.AnimData;
|
import mocap.figure.Bone;
|
import mocap.figure.Figure;
|
import mocap.figure.FigureManager;
|
import mocap.figure.MotionTrailPoint;
|
import mocap.gui.CameraChangeListener;
|
import mocap.reader.AMCReader;
|
import mocap.reader.BVHReader;
|
import mocap.scene.CoordCross;
|
import mocap.scene.Floor;
|
import java.util.List;
|
|
/**
|
* Provides a Java3D world for viewing mocap files (ASF/AMC and BVH).
|
*
|
* FLICKER PROBLEM: One solution appears to be switching off "Use unified back/depth buffer" for
|
* NVIDIA cards
|
*
|
* @author Michael Kipp
|
*/
|
public class JMocap
|
implements
|
MouseMotionListener,
|
MouseListener,
|
MouseWheelListener
|
{
|
|
private static final String VERSION = "1.0";
|
private static final boolean HAS_ORBIT_CONTROL = false;
|
private static final int VIEW_ACTIVATION_RADIUS = 250;
|
private static final double BACK_CLIP_DISTANCE = 500;
|
private static final float LIGHT_REACH = 500;
|
private Figure _figure;
|
private FigureManager _figureManager = new FigureManager();
|
private static final int W = 1100;
|
private static final int H = 800;
|
protected BranchGroup _root;
|
protected SimpleUniverse _su;
|
protected JMocapCanvas3D _canvas;
|
private Switch _coordCrossSwitch;
|
private Switch _floorSwitch;
|
private boolean _dirty = false;
|
private BranchGroup _bgMotionTrails;
|
private boolean _bMouseButtonPressed;
|
private int _nBeginMouseCoord_Y;
|
private int _nLastMouseCoord_Y;
|
private int _nLastMouseCoord_X;
|
private int _nBeginMouseCoord_X;
|
private Point3d _p3dCameraPosition = new Point3d(1, 3, 15);
|
public static final int _nCAMERA_YAW_MAX = 180;
|
public static final int _nCAMERA_YAW_MIN = -180;
|
private int _nCameraYaw = 0;
|
private int _nCameraPitch = 0;
|
public static final int _nCAMERA_PITCH_MAX = 90;
|
public static final int _nCAMERA_PITCH_MIN = -90;
|
private int _nCameraRoll;
|
private Point3d _p3dCameraTarget;
|
private boolean _bLookAtPosition = false;
|
private Point3d _p3dCameraPositionInit;
|
private float _fGainer_Y = 0.08f;
|
private float _fGainer_X = 0.08f;
|
private float _fGainer_Z = 0.2f;
|
private double _dScale = 1.0;
|
private int nReverseX = 1;
|
private int nReverseY = 1;
|
private boolean _bClearTrails;
|
private List<MotionTrailPoint> _motionTrailPoints = null;
|
private CameraChangeListener _cameraChangeListener = null;
|
// private Time _timeMotionTrailEnd;
|
// private Time _timeMotionTrailStart;
|
private boolean _bShowMotionTrailVelocity = false;
|
|
public JMocap()
|
{
|
super();
|
_root = createScenegraph();
|
_root.compile();
|
_canvas = new JMocapCanvas3D(SimpleUniverse.getPreferredConfiguration())
|
{
|
|
@Override
|
public void postSwap()
|
{
|
super.postSwap();
|
synchronized (this) {
|
_dirty = false;
|
}
|
}
|
};
|
// _canvas = new Canvas3D(SimpleUniverse.getPreferredConfiguration());
|
// _canvas = new
|
// Canvas3D(GraphicsEnvironment.getLocalGraphicsEnvironment().
|
// getDefaultScreenDevice().getDefaultConfiguration());
|
_canvas.setPreferredSize(new Dimension(W, H));
|
_canvas.setSize(new Dimension(W, H));
|
_su = new SimpleUniverse(_canvas);
|
// _su.getViewingPlatform().getViewPlatform().setCapability(ViewPlatform.ALLOW_BOUNDS_WRITE);
|
|
_su.getViewer().getView().setBackClipDistance(BACK_CLIP_DISTANCE);
|
_su.getViewingPlatform().getViewPlatform().setActivationRadius(
|
VIEW_ACTIVATION_RADIUS);
|
if (HAS_ORBIT_CONTROL) {
|
OrbitBehavior orbit = new OrbitBehavior(_canvas,
|
OrbitBehavior.REVERSE_ALL);
|
orbit.setSchedulingBounds(new BoundingSphere());
|
_su.getViewingPlatform().setViewPlatformBehavior(orbit);
|
} else {
|
// _su.getViewingPlatform().getViewPlatform().setBounds(new BoundingSphere(new Point3d(0.0,0.0,0.0), 100.0));
|
}
|
// _su.getViewer().getView().addCanvas3D();
|
_su.addBranchGraph(_root);
|
|
// printInfo();
|
_canvas.addMouseListener(this);
|
_canvas.addMouseMotionListener(this);
|
_canvas.addMouseWheelListener(this);
|
}
|
|
public void initCanvasComponents()
|
{
|
_canvas.initComponents();
|
}
|
|
public synchronized void setDirty()
|
{
|
_dirty = true;
|
}
|
|
public synchronized boolean isDirty()
|
{
|
return _dirty;
|
}
|
|
/**
|
* @return String with infos on current Java and J3D versions, used
|
* pipeline and renderer.
|
*/
|
public String getInfo()
|
{
|
StringBuilder sb = new StringBuilder();
|
Map props = SimpleUniverse.getProperties();
|
sb.append("JMocap version: " + VERSION);
|
sb.append("\nJava version: "
|
+ System.getProperty("java.version"));
|
sb.append("\nJ3D Version: " + props.get("j3d.version"));
|
sb.append("\nJ3D Specification: "
|
+ props.get("j3d.specification.version"));
|
sb.append("\nPipeline: " + props.get("j3d.pipeline"));
|
sb.append("\nRenderer: " + props.get("j3d.renderer"));
|
return sb.toString();
|
}
|
|
private void createFloor(BranchGroup bg)
|
{
|
_floorSwitch = new Switch();
|
_floorSwitch.setCapability(Switch.ALLOW_SWITCH_WRITE);
|
_floorSwitch.addChild(new Floor().getBG()); // add the floor
|
bg.addChild(_floorSwitch);
|
_floorSwitch.setWhichChild(0);
|
}
|
|
public FigureManager getFigureManager()
|
{
|
return _figureManager;
|
}
|
|
/**
|
* Removes all figures.
|
*/
|
public void clearAll()
|
{
|
for (Figure f : _figureManager.getFigures()) {
|
_root.removeChild(f.getBG());
|
}
|
_figureManager.getFigures().clear();
|
if (_bgMotionTrails != null) {
|
_bgMotionTrails.removeAllChildren();
|
_bgMotionTrails = null;
|
}
|
|
}
|
|
public void dispose()
|
{
|
_canvas.dispose();
|
}
|
|
/**
|
* @return 3D viewing component.
|
*/
|
public Canvas3D getViewComponent()
|
{
|
return _canvas;
|
}
|
|
public void setCameraView(Point3d pos, Point3d target)
|
{
|
_p3dCameraPosition = pos;
|
_p3dCameraPositionInit = new Point3d(pos);
|
_p3dCameraTarget = target;
|
Transform3D t3d = new Transform3D();
|
t3d.setTranslation(new Vector3d(_p3dCameraPosition));
|
// _su.getViewingPlatform().getViewPlatformTransform().getTransform(t3d);
|
// t3d.lookAt(pos, target, new Vector3d(0, 1, 0));
|
// t3d.invert();
|
_su.getViewingPlatform().getViewPlatformTransform().setTransform(t3d);
|
t3d = null;
|
}
|
|
public void resetCamera()
|
{
|
_p3dCameraPosition = new Point3d(_p3dCameraPositionInit);
|
moveCamera(_p3dCameraPosition.x, _p3dCameraPosition.y,
|
_p3dCameraPosition.z, -_nCameraYaw, _nCameraPitch, 0, false);
|
|
}
|
|
public SimpleUniverse getUniverse()
|
{
|
return _su;
|
}
|
|
public BranchGroup getRootBG()
|
{
|
return _root;
|
}
|
|
/**
|
* @return Most recently loaded figure.
|
*/
|
public Figure getFigure()
|
{
|
return _figure;
|
}
|
|
public void initFigure(Bone skel, String name)
|
{
|
initFigure(skel, name, new Point3d());
|
}
|
|
public void initFigure(Bone skel, String name, Point3d offset)
|
{
|
_figure = _figureManager.addFigure(name, skel, offset);
|
_root.addChild(_figure.getBG());
|
}
|
|
public void initAnim(AnimData data, String name)
|
{
|
_figure.setAnimation(data);
|
_figure.getPlayer().reset();
|
}
|
|
public void loadAMC(File file) throws IOException
|
{
|
AMCReader r = new AMCReader();
|
AnimData d = r.readAMC(file, _figure.getSkeleton());
|
initAnim(d, file.getName());
|
}
|
|
public void loadBVH(File f, float targetHeight, Point3d offset)
|
throws IOException
|
{
|
_figureManager.pauseAll();
|
BVHReader rd = new BVHReader(targetHeight);
|
BVHReader.BVHResult bvh = rd.readFile(f);
|
initFigure(bvh.skeleton, f.getName(), offset);
|
initAnim(bvh.animation, f.getName());
|
|
_dScale = rd.getScale();
|
}
|
|
protected Sphere createSphere(Color c, float radius)
|
{
|
Sphere s = new Sphere(radius);
|
Color3f c3 = new Color3f(c);
|
Appearance app = new Appearance();
|
app.setMaterial(new Material(c3, c3, new Color3f(Color.WHITE), c3,
|
.3f));
|
s.setAppearance(app);
|
return s;
|
}
|
|
protected Switch createCoordCross(BranchGroup r, float diameter, float thick)
|
{
|
Switch s = new Switch();
|
s.setCapability(Switch.ALLOW_SWITCH_WRITE);
|
CoordCross cc = new CoordCross(1.2f);
|
s.addChild(cc.getRoot());
|
s.setWhichChild(Switch.CHILD_ALL);
|
return s;
|
}
|
|
/**
|
* One ambient light. 2 directional lights: 1) from up-right-front 2) from up-left-back
|
*/
|
protected void lightScene(BranchGroup bg)
|
{
|
BoundingSphere bounds = new BoundingSphere(new Point3d(), LIGHT_REACH);
|
Color3f white = new Color3f(Color.YELLOW);
|
AmbientLight ambientLightNode = new AmbientLight(white);
|
ambientLightNode.setInfluencingBounds(bounds);
|
bg.addChild(ambientLightNode);
|
|
// Directional lights:
|
// comes from up-right-front
|
Vector3f light1Direction = new Vector3f(-5f, -5f, -5f); // left, down,
|
// backwards
|
// comes from up-left-back
|
Vector3f light2Direction = new Vector3f(5f, -5f, 5f); // right, down,
|
// forwards
|
|
DirectionalLight light1 = new DirectionalLight(white, light1Direction);
|
light1.setInfluencingBounds(bounds);
|
bg.addChild(light1);
|
|
DirectionalLight light2 = new DirectionalLight(white, light2Direction);
|
light2.setInfluencingBounds(bounds);
|
bg.addChild(light2);
|
}
|
|
public void showCoordCross(boolean val)
|
{
|
_coordCrossSwitch.setWhichChild(val
|
? Switch.CHILD_ALL
|
: Switch.CHILD_NONE);
|
}
|
|
public void showFloor(boolean val)
|
{
|
_floorSwitch.setWhichChild(val ? Switch.CHILD_ALL : Switch.CHILD_NONE);
|
}
|
|
public BranchGroup createScenegraph()
|
{
|
BranchGroup r = new BranchGroup();
|
r.setCapability(BranchGroup.ALLOW_CHILDREN_EXTEND);
|
lightScene(r);
|
r.setCapability(BranchGroup.ALLOW_CHILDREN_WRITE);
|
_coordCrossSwitch = createCoordCross(r, 15f, .01f);
|
r.addChild(_coordCrossSwitch);
|
r.setBounds(new BoundingSphere(new Point3d(0, 0, 0), 10d));
|
createFloor(r);
|
return r;
|
}
|
|
/**
|
* Shows the path of the special joint.
|
*
|
* @param startFrame
|
* @param endFrame
|
* @param color
|
* @param jointName
|
*/
|
public void addMotionTrail(List<MotionTrailPoint> motionTrailPoints)
|
{
|
_bClearTrails = true;
|
_motionTrailPoints = motionTrailPoints;
|
_canvas.addPositionsToMotionTrail();
|
_canvas.repaint();
|
}
|
|
/**
|
* Add the path of the special joint to the scene
|
*
|
* @param startFrame
|
* @param endFrame
|
* @param color
|
* @param jointName
|
*/
|
private void addPositionsToMotionTrailPoints(
|
List<MotionTrailPoint> motionTrailPoints)
|
{
|
|
if (_figure.getPlayer() != null) {
|
int nCurrentFrame = _figure.getPlayer().getCurrentFrame();
|
for (MotionTrailPoint motionTrailPoint : motionTrailPoints) {
|
Bone bone = _figure.getSkeleton().findBone(
|
motionTrailPoint.getBone());
|
|
if (bone != null) {
|
_figure.getPlayer().gotoTime(
|
motionTrailPoint.getTimePointInSeconds());
|
motionTrailPoint.setScale(_dScale);
|
Point3d p3dPositionInWorld = new Point3d();
|
bone.getWorldPosition(p3dPositionInWorld);
|
|
// NEW: position is relative to root joint
|
// bone.getRelativePosition(_figure.getSkeleton(), p3dPositionInWorld);
|
|
motionTrailPoint.setPosition(p3dPositionInWorld);
|
p3dPositionInWorld = null;
|
|
} else {
|
System.err.println("Bone " + motionTrailPoint.getBone()
|
+ " not found");
|
|
}
|
bone = null;
|
}
|
// go to old position
|
_figure.getPlayer().gotoTime(
|
nCurrentFrame / _figure.getPlayer().getPlaybackFps());
|
} else {
|
System.err.println("No player Mocap-Player found");
|
|
}
|
|
}
|
|
/**
|
* Add the given MotionTrailPoints to scene
|
*
|
* @param motionTrailPoints
|
* Vector of MotionTrailPoints
|
*/
|
private void addMotionTrailsToScene(
|
List<MotionTrailPoint> motionTrailPoints)
|
{
|
// Point3d p = new Point3d();
|
// _figure.getSkeleton().getWorldPosition(p);
|
// System.out.println("Figure position in World: " + p);
|
|
if (_bgMotionTrails == null) {
|
_bgMotionTrails = new BranchGroup();
|
_bgMotionTrails.setCapability(BranchGroup.ALLOW_CHILDREN_EXTEND);
|
_bgMotionTrails.setCapability(BranchGroup.ALLOW_CHILDREN_WRITE);
|
_bgMotionTrails.setCapability(BranchGroup.ALLOW_DETACH);
|
_root.addChild(_bgMotionTrails);
|
} else if (_bClearTrails) {
|
removeMotionTrails();
|
}
|
|
for (int i = 0; i + 1 < motionTrailPoints.size() - 1; i++) {
|
motionTrailPoints.get(i).showMotionTrailVelocity(
|
_bShowMotionTrailVelocity);
|
_bgMotionTrails.addChild(motionTrailPoints.get(i).getObject());
|
|
Vector3d v3dNextPositionInWorld = new Vector3d();
|
motionTrailPoints.get(i + 1).getPosition(v3dNextPositionInWorld);
|
motionTrailPoints.get(i).angleVelocityVisualisation(
|
new Point3d(v3dNextPositionInWorld));
|
if (i + 1 == motionTrailPoints.size() - 1) {
|
_bgMotionTrails.addChild(motionTrailPoints.get(i + 1).getObject());
|
}
|
|
}
|
|
// write the positions into a file
|
// PathsFileWriter checkpointPoseReader = new PathsFileWriter();
|
// checkpointPoseReader.writeDocument("checkpoints", motionTrailPoints);
|
// System.out.println("Figure Scale: " + _figure.getScale());
|
|
}
|
|
public void showMotionTrailVelocity(boolean showMotionTrailVelocity)
|
{
|
if (showMotionTrailVelocity != _bShowMotionTrailVelocity
|
&& _motionTrailPoints != null) {
|
for (MotionTrailPoint mtPoint : _motionTrailPoints) {
|
mtPoint.showMotionTrailVelocity(showMotionTrailVelocity);
|
}
|
}
|
_bShowMotionTrailVelocity = showMotionTrailVelocity;
|
}
|
|
public void removeMotionTrails()
|
{
|
if (_bgMotionTrails != null) {
|
_bgMotionTrails.removeAllChildren();
|
}
|
}
|
|
public void initCameraToSkeleton(Point3d cameraTarget)
|
{
|
|
// _p3dCameraTarget = cameraTarget;
|
double dSkeletonSize = 1.5d * _figure.getSkeleton().getMaxDistance();
|
// System.out.println("Max Distance: " + dSkeletonSize);
|
|
// get the field of view
|
|
double dFieldOfView = _su.getViewer().getView().getFieldOfView();
|
double dCameraZPos = Math.atan(dFieldOfView / 2d) / dSkeletonSize;
|
// System.out.println("Max Distance:dCameraZPos: " + dCameraZPos);
|
// double dFieldOfViewInRadians = Math
|
// .atan((dSkeletonSize / (2 * _cameraConfiguration.getFocal())))
|
// * factor;
|
// // System.out.println("\n\n\n\nCameraController::" + this +
|
// // "getObjectInFieldOfView::_dFieldOfViewInRadians::" +
|
// // dFieldOfViewInRadians + "\n\n\n\n");
|
// _cameraConfiguration.setFieldOfView(dFieldOfViewInRadians);
|
// return dFieldOfViewInRadians;
|
// update();
|
_p3dCameraPosition.z = dCameraZPos;
|
_p3dCameraPosition.x = cameraTarget.x;
|
_p3dCameraPosition.y = cameraTarget.y;
|
moveCamera(_p3dCameraPosition.x, _p3dCameraPosition.y,
|
_p3dCameraPosition.z, -_nCameraYaw, _nCameraPitch, 0, false);
|
onCameraChanged("z_coord", _p3dCameraPosition.z);
|
onCameraChanged("x_coord", _p3dCameraPosition.x);
|
onCameraChanged("y_coord", _p3dCameraPosition.y);
|
// System.out.println("Max Distance:_p3dCameraPosition: " + _p3dCameraPosition);
|
// System.out.println("Max Distance:_p3dCameraTarget: " + _p3dCameraTarget);
|
// System.out.println("Max Distance:getCameraYaw(): " + getCameraYaw());
|
// System.out.println("Max Distance:getCameraPitch: " + getCameraPitch());
|
|
|
}
|
|
private Transform3D moveCamera(double x, double y, double z, double yaw,
|
double pitch, double roll, boolean holdLookAt)
|
{
|
Transform3D ret = new Transform3D();// return transform
|
Transform3D xrot = new Transform3D();
|
Transform3D yrot = new Transform3D();
|
Transform3D zrot = new Transform3D();
|
Transform3D pos = new Transform3D();
|
|
// roll pitch yaw rotations by Degrees
|
yrot.rotY(yaw / 360 * (2 * Math.PI));
|
xrot.rotX(pitch / 360 * (2 * Math.PI));
|
zrot.rotZ(roll / 360 * (2 * Math.PI));
|
// multiply return values by rotation
|
// (order of multiplication is important dependent on coordinate system
|
// being used)
|
ret.mul(zrot);
|
ret.mul(yrot);
|
ret.mul(xrot);
|
|
// multiply return values by translation
|
pos.setTranslation(new Vector3d(x, y, z));
|
ret.mul(pos);
|
|
if (holdLookAt) {
|
Vector3d v3dPos = new Vector3d();
|
ret.get(v3dPos);
|
Transform3D t3d = new Transform3D();
|
t3d.lookAt(new Point3d(v3dPos), _p3dCameraTarget, new Vector3d(0,
|
1, 0));
|
t3d.invert();
|
|
_su.getViewingPlatform().getViewPlatformTransform().setTransform(
|
t3d);
|
} else {
|
_su.getViewingPlatform().getViewPlatformTransform().setTransform(
|
ret);
|
}
|
return ret;
|
}
|
|
/**
|
* Zooming by changing the field of view
|
*
|
* @param fieldOfView
|
*/
|
private void zoomCamera(double fieldOfView)
|
{
|
double dFieldOfView = _su.getViewingPlatform().getViewers()[0].getView().getFieldOfView();
|
|
_su.getViewingPlatform().getViewers()[0].getView().setFieldOfView(
|
dFieldOfView + fieldOfView * 0.05);
|
}
|
|
@Override
|
public void mouseDragged(MouseEvent e)
|
{
|
// camera rotating
|
if (e.getButton() == MouseEvent.BUTTON1) {
|
|
if (!_bMouseButtonPressed) {
|
|
_nCameraYaw = _nCameraYaw + e.getX() - _nLastMouseCoord_X;
|
|
} else {
|
_nCameraYaw = _nCameraYaw + e.getX() - _nBeginMouseCoord_X;
|
|
}
|
if (_nCameraYaw >= _nCAMERA_YAW_MAX) {
|
_nCameraYaw = _nCAMERA_YAW_MAX;
|
} else if (_nCameraYaw <= _nCAMERA_YAW_MIN) {
|
_nCameraYaw = _nCAMERA_YAW_MIN;
|
}
|
// negate _fYaw to get an intuitive behavior. Move mouse to right,
|
moveCamera(_p3dCameraPosition.x, _p3dCameraPosition.y,
|
_p3dCameraPosition.z, -_nCameraYaw, _nCameraPitch, 0,
|
_bLookAtPosition);
|
onCameraChanged("yaw", _nCameraYaw);
|
_bMouseButtonPressed = false;
|
|
} else if (e.getButton() == MouseEvent.BUTTON3) // camera moving
|
{
|
if (!_bMouseButtonPressed) {
|
|
_p3dCameraPosition.x = _p3dCameraPosition.x
|
+ (nReverseX * ((e.getX() - _nLastMouseCoord_X))
|
* _fGainer_X * _dScale);
|
_p3dCameraPosition.y = _p3dCameraPosition.y
|
+ (nReverseY * ((e.getY() - _nLastMouseCoord_Y))
|
* _fGainer_Y * _dScale);
|
|
} else {
|
_p3dCameraPosition.x = _p3dCameraPosition.x
|
+ (nReverseX * ((e.getX() - _nBeginMouseCoord_X))
|
* _fGainer_X * _dScale);
|
_p3dCameraPosition.y = _p3dCameraPosition.y
|
+ (nReverseY * ((e.getY() - _nBeginMouseCoord_Y))
|
* _fGainer_Y * _dScale);
|
}
|
|
moveCamera(_p3dCameraPosition.x, _p3dCameraPosition.y,
|
_p3dCameraPosition.z, -_nCameraYaw, _nCameraPitch, 0, false);
|
onCameraChanged("x_coord", _p3dCameraPosition.x);
|
onCameraChanged("y_coord", _p3dCameraPosition.y);
|
_bMouseButtonPressed = false;
|
|
} else if (e.getButton() == MouseEvent.BUTTON2) // camera moving
|
{
|
if (!_bMouseButtonPressed) {
|
|
_nCameraPitch = _nCameraPitch + e.getY() - _nLastMouseCoord_Y;
|
|
} else {
|
|
_nCameraPitch = _nCameraPitch + e.getY() - _nBeginMouseCoord_Y;
|
}
|
if (_nCameraPitch >= _nCAMERA_PITCH_MAX) {
|
_nCameraPitch = _nCAMERA_PITCH_MAX;
|
} else if (_nCameraPitch <= _nCAMERA_PITCH_MIN) {
|
_nCameraPitch = _nCAMERA_PITCH_MIN;
|
}
|
// negate _fYaw to get an intuitive behavior. Move mouse to
|
// right,
|
moveCamera(_p3dCameraPosition.x, _p3dCameraPosition.y,
|
_p3dCameraPosition.z, -_nCameraYaw, _nCameraPitch, 0,
|
_bLookAtPosition);
|
onCameraChanged("pitch", _nCameraPitch);
|
_bMouseButtonPressed = false;
|
|
}
|
_nLastMouseCoord_X = e.getX();
|
_nLastMouseCoord_Y = e.getY();
|
}
|
|
private void onCameraChanged(String command, double value)
|
{
|
if (_cameraChangeListener != null) {
|
_cameraChangeListener.onCameraChanged(command, value);// TODO Auto-generated method stub
|
}
|
}
|
|
public Point3d getCameraPosition()
|
{
|
return _p3dCameraPosition;
|
}
|
|
public int getCameraPitch()
|
{
|
return _nCameraPitch;
|
}
|
|
public int getCameraYaw()
|
{
|
return _nCameraYaw;
|
}
|
|
public void reverseXAxis(boolean reverse)
|
{
|
if (reverse) {
|
nReverseX = -1;
|
} else {
|
nReverseX = 1;
|
}
|
}
|
|
public void reverseYAxis(boolean reverse)
|
{
|
if (reverse) {
|
nReverseY = -1;
|
} else {
|
nReverseY = 1;
|
}
|
}
|
|
@Override
|
public void mouseMoved(MouseEvent e)
|
{
|
// TODO Auto-generated method stub
|
}
|
|
@Override
|
public void mouseClicked(MouseEvent e)
|
{
|
// TODO Auto-generated method stub
|
}
|
|
@Override
|
public void mouseEntered(MouseEvent e)
|
{
|
// TODO Auto-generated method stub
|
}
|
|
@Override
|
public void mouseExited(MouseEvent e)
|
{
|
// TODO Auto-generated method stub
|
}
|
|
@Override
|
public void mousePressed(MouseEvent e)
|
{
|
_nBeginMouseCoord_X = e.getX();
|
_nLastMouseCoord_X = e.getX();
|
_nBeginMouseCoord_Y = e.getY();
|
_nLastMouseCoord_Y = e.getY();
|
_bMouseButtonPressed = true;
|
|
}
|
|
@Override
|
public void mouseReleased(MouseEvent e)
|
{
|
// TODO Auto-generated method stub
|
}
|
|
@Override
|
public void mouseWheelMoved(MouseWheelEvent e)
|
{
|
int notches = e.getWheelRotation();
|
_p3dCameraPosition.z = _p3dCameraPosition.z + notches * _fGainer_Z;
|
moveCamera(_p3dCameraPosition.x, _p3dCameraPosition.y,
|
_p3dCameraPosition.z, -_nCameraYaw, _nCameraPitch, 0, false);
|
onCameraChanged("z_coord", _p3dCameraPosition.z);
|
// zoomCamera(notches);
|
|
}
|
|
public void setCameraChangeListener(
|
CameraChangeListener cameraChangeListener)
|
{
|
_cameraChangeListener = cameraChangeListener;
|
|
}
|
|
public void setCamera(double x, double y, double z, int yaw, int pitch,
|
int roll, boolean lookAtPos)
|
{
|
_p3dCameraPosition.x = x;
|
_p3dCameraPosition.y = y;
|
_p3dCameraPosition.z = z;
|
_nCameraYaw = yaw;
|
_nCameraPitch = pitch;
|
_nCameraRoll = roll;
|
_bLookAtPosition = lookAtPos;
|
// System.out.println("Set Camera values (" + x + ", " + y + ", " + z
|
// + ", " + yaw + ", " + pitch + ")");
|
moveCamera(_p3dCameraPosition.x, _p3dCameraPosition.y,
|
_p3dCameraPosition.z, -_nCameraYaw, _nCameraPitch,
|
_nCameraRoll, _bLookAtPosition);
|
|
}
|
|
class JMocapCanvas3D extends Canvas3D
|
{
|
|
private boolean bAddMotionTrail;
|
// private double pathStartTime;
|
// private double pathEndTime;
|
// private float fps;
|
// private Color pathColor;
|
// private String jointName1;
|
// private String jointName2;
|
private J3DGraphics2D graphics2D;
|
|
public JMocapCanvas3D(GraphicsConfiguration gconfig,
|
boolean offscreenflag)
|
{
|
super(gconfig, offscreenflag);
|
initComponents();
|
}
|
|
public JMocapCanvas3D(GraphicsConfiguration preferredConfiguration)
|
{
|
super(preferredConfiguration);
|
initComponents();
|
|
}
|
|
public void initComponents()
|
{
|
graphics2D = this.getGraphics2D();
|
graphics2D.setColor(Color.LIGHT_GRAY);
|
graphics2D.setFont(new Font("Serif", Font.BOLD, 15));
|
}
|
|
@Override
|
public void preRender()
|
{
|
super.preRender();
|
if (bAddMotionTrail) {
|
addPositionsToMotionTrailPoints(_motionTrailPoints);
|
addMotionTrailsToScene(_motionTrailPoints);
|
bAddMotionTrail = false;
|
}
|
}
|
|
@Override
|
public void postRender()
|
{
|
super.postRender();
|
|
showFrameInformation();
|
|
graphics2D.flush(true);
|
}
|
|
public void dispose()
|
{
|
graphics2D.dispose();
|
}
|
|
// public void showPath(double startTime, double endTime, Color color,
|
// String name1, String name2, float fps)
|
// {
|
// bAddMotionTrail = true;
|
// pathStartTime = startTime;
|
// pathEndTime = endTime;
|
// pathColor = color;
|
// jointName1 = name1;
|
// jointName2 = name2;
|
// this.fps = fps;
|
//
|
// }
|
|
public void addPositionsToMotionTrail()
|
{
|
bAddMotionTrail = true;
|
}
|
|
public void showFrameInformation()
|
{
|
if (_figure != null) {
|
graphics2D.drawString("frame: "
|
+ _figure.getPlayer().getCurrentFrame(),
|
getSize().width / 2, getSize().height - 20);
|
}
|
|
}
|
}
|
}
|
