1 /*******************************************************************************
\r
2 * Copyright (c) 2007 VTT Technical Research Centre of Finland and others.
\r
3 * All rights reserved. This program and the accompanying materials
\r
4 * are made available under the terms of the Eclipse Public License v1.0
\r
5 * which accompanies this distribution, and is available at
\r
6 * http://www.eclipse.org/legal/epl-v10.html
\r
9 * VTT Technical Research Centre of Finland - initial API and implementation
\r
10 *******************************************************************************/
\r
11 package org.simantics.proconf.g3d.common;
\r
13 import javax.vecmath.AxisAngle4d;
\r
14 import javax.vecmath.Matrix3d;
\r
15 import javax.vecmath.Vector3d;
\r
17 import org.simantics.proconf.g3d.base.VecmathJmeTools;
\r
19 import com.jme.renderer.Camera;
\r
25 * Modified version of fi.vtt.proconf.webmon.graphics3d.utils.OrbitalCamera<br>
\r
26 * Using floats instead of double<br>
\r
30 * @author Marko Luukkainen
\r
33 public class OrbitalCamera {
\r
35 private Vector3d up = new Vector3d(0.0,1.0,0.0);
\r
36 private static Vector3d up2 = new Vector3d(0.0,0.0,-1.0);
\r
37 private static double minDistance = 0.5;
\r
38 private Vector3d target = new Vector3d();
\r
39 private Vector3d cameraPos = new Vector3d(10.0,0.0,0.0);
\r
42 public void translate(Vector3d v) {
\r
47 public void rotateAroundTarget(Vector3d axis, double angle) {
\r
48 Vector3d temp = new Vector3d(cameraPos);
\r
50 Matrix3d rotation = new Matrix3d();
\r
51 rotation.set(new AxisAngle4d(axis,angle));
\r
52 rotation.transform(temp);
\r
54 cameraPos.set(temp);
\r
57 public Vector3d getUnNormalizedHeading() {
\r
58 Vector3d heading = new Vector3d(target);
\r
59 heading.sub(cameraPos);
\r
63 public Vector3d getUnNormalizedRight() {
\r
64 Vector3d heading = getUnNormalizedHeading();
\r
65 Vector3d right = new Vector3d();
\r
66 right.cross(heading,up);
\r
67 if (right.lengthSquared() < 0.01)
\r
68 right.cross(heading,up2);
\r
72 public double getDistanceToTarget() {
\r
73 Vector3d t = new Vector3d(target);
\r
78 public void moveToTarget(double distance) {
\r
79 Vector3d heading = getUnNormalizedHeading();
\r
80 double length = heading.length();
\r
81 if (length + distance < minDistance) {
\r
82 // cannot move closer
\r
85 heading.scale(distance / length); //normalizing and scaling by distance
\r
86 cameraPos.add(heading);
\r
89 public void moveScaledToTarget(double s) {
\r
90 Vector3d heading = getUnNormalizedHeading();
\r
91 double currentLength = heading.length();
\r
92 double length = currentLength * (1.0 - s);// heading.length();
\r
93 if (length < minDistance) {
\r
94 s = -minDistance / currentLength + 1.0;
\r
97 //normalizing and scaling by distance
\r
98 cameraPos.add(heading);
\r
101 public void rotateUp(double angle) {
\r
102 Vector3d right = getUnNormalizedRight();
\r
103 double length = right.length();
\r
104 // TODO : better handling of singular cases
\r
106 right.scale(1.0/length);
\r
108 right.set(-1.0,0.0,0.0);
\r
109 rotateAroundTarget(right,angle);
\r
112 public void rotateRight(double angle) {
\r
113 rotateAroundTarget(up,angle);
\r
116 public void moveRight(double length) {
\r
117 Vector3d right = getUnNormalizedRight();
\r
119 right.scale(length);
\r
123 public void moveUp(double length) {
\r
124 Vector3d u = new Vector3d(up);
\r
129 public void moveFront(double length) {
\r
130 Vector3d right = getUnNormalizedRight();
\r
131 Vector3d front = new Vector3d();
\r
132 front.cross(up,right);
\r
134 front.scale(length);
\r
138 public void updateCamera() {
\r
139 Vector3d t = new Vector3d(cameraPos);
\r
142 cam.setLocation(VecmathJmeTools.get(cameraPos));
\r
144 if (Math.abs(t.dot(up)) > 0.99) {
\r
145 cam.lookAt(VecmathJmeTools.get(target), VecmathJmeTools.get(up2));
\r
147 cam.lookAt(VecmathJmeTools.get(target), VecmathJmeTools.get(up));
\r
155 * @return Returns the cameraPos.
\r
157 public Vector3d getCameraPos() {
\r
162 * @param cameraPos The cameraPos to set.
\r
164 public void setCameraPos(Vector3d cameraPos) {
\r
165 this.cameraPos = cameraPos;
\r
169 * @return Returns the target.
\r
171 public Vector3d getTarget() {
\r
176 * @param target The target to set.
\r
178 public void setTarget(Vector3d target) {
\r
179 this.target = target;
\r
182 public void setCameraPosRelativeToTarget(Vector3d targetToCam) {
\r
183 targetToCam.add(target);
\r
184 setCameraPos(targetToCam);
\r
187 public void setUp(Vector3d v) {
\r
191 public Vector3d getUp() {
\r
195 public void setDefaultUp() {
\r
196 up.set(0.0,1.0,0.0);
\r
199 private Camera cam;
\r
201 public void setCamera(Camera cam) {
\r