| 87 |
jab |
1 |
#include <iostream>
|
|
|
2 |
#include "CGLA/CGLA.h"
|
|
|
3 |
#include "QuatTrackBall.h"
|
|
|
4 |
|
|
|
5 |
#ifdef WIN32
|
|
|
6 |
#include <windows.h>
|
|
|
7 |
#endif
|
|
|
8 |
|
|
|
9 |
#include <GL/glu.h>
|
|
|
10 |
|
|
|
11 |
using namespace std;
|
|
|
12 |
using namespace CGLA;
|
|
|
13 |
|
|
|
14 |
namespace Graphics
|
|
|
15 |
{
|
|
|
16 |
|
|
|
17 |
QuatTrackBall::QuatTrackBall(const Vec3f& _centre,
|
|
|
18 |
float _eye_dist,
|
|
|
19 |
unsigned _width,
|
|
|
20 |
unsigned _height):
|
|
|
21 |
centre(_centre), eye_dist(_eye_dist), scale(0.5*_eye_dist),
|
|
|
22 |
width(_width), height(_height)
|
|
|
23 |
{
|
|
|
24 |
// This size should really be based on the distance from the center of
|
|
|
25 |
// rotation to the point on the object underneath the mouse. That
|
|
|
26 |
// point would then track the mouse as closely as possible. This is a
|
|
|
27 |
// simple example, though, so that is left as an exercise.
|
|
|
28 |
ballsize = 2.0f;
|
|
|
29 |
screen_centre = Vec2i(width/2, height/2);
|
|
|
30 |
qrot = Quaternion(0.0, 0.0, 0.0, 1.0);
|
|
|
31 |
qinc = Quaternion(0.0, 0.0, 0.0, 1.0);
|
|
|
32 |
trans = Vec2f(0.0, 0.0);
|
|
|
33 |
}
|
|
|
34 |
|
|
|
35 |
void QuatTrackBall::grab_ball(TrackBallAction act, const Vec2i& v)
|
|
|
36 |
{
|
|
|
37 |
set_position(scalePoint(v));
|
|
|
38 |
current_action = act;
|
|
|
39 |
}
|
|
|
40 |
|
|
|
41 |
void QuatTrackBall::roll_ball(const Vec2i& v)
|
|
|
42 |
{
|
|
|
43 |
Vec2f w = scalePoint(v);
|
|
|
44 |
|
|
|
45 |
switch (current_action)
|
|
|
46 |
{
|
|
|
47 |
case ROTATE_ACTION:
|
|
|
48 |
rotate(w);
|
|
|
49 |
break;
|
|
|
50 |
|
|
|
51 |
case PAN_ACTION:
|
|
|
52 |
pan(w);
|
|
|
53 |
break;
|
|
|
54 |
|
|
|
55 |
case ZOOM_ACTION:
|
|
|
56 |
zoom(w);
|
|
|
57 |
break;
|
|
|
58 |
}
|
|
|
59 |
last_pos = w;
|
|
|
60 |
}
|
|
|
61 |
|
|
|
62 |
// Call this when the user does a mouse down.
|
|
|
63 |
// Stop the trackball glide, then remember the mouse
|
|
|
64 |
// down point (for a future rotate, pan or zoom).
|
|
|
65 |
void QuatTrackBall::set_position(const Vec2f& _last_pos)
|
|
|
66 |
{
|
|
|
67 |
stop_spin();
|
|
|
68 |
last_pos = _last_pos;
|
|
|
69 |
}
|
|
|
70 |
|
|
|
71 |
// Rotationaly spin the trackball by the current increment.
|
|
|
72 |
// Use this to implement rotational glide.
|
|
|
73 |
void QuatTrackBall::do_spin()
|
|
|
74 |
{
|
|
|
75 |
qrot = qrot*qinc;
|
|
|
76 |
}
|
|
|
77 |
|
|
|
78 |
// Cease any rotational glide by zeroing the increment.
|
|
|
79 |
void QuatTrackBall::stop_spin()
|
|
|
80 |
{
|
|
|
81 |
qinc.set(0.0, 0.0, 0.0, 1.0);
|
|
|
82 |
}
|
|
|
83 |
|
|
|
84 |
void QuatTrackBall::rotate(const Vec2f& new_v)
|
|
|
85 |
{
|
|
|
86 |
calcRotation(new_v);
|
|
|
87 |
do_spin();
|
|
|
88 |
}
|
|
|
89 |
|
|
|
90 |
void QuatTrackBall::pan(const Vec2f& new_v)
|
|
|
91 |
{
|
|
|
92 |
trans += (new_v - last_pos) * Vec2f(scale[0], scale[1]);
|
|
|
93 |
}
|
|
|
94 |
|
|
|
95 |
void QuatTrackBall::zoom(const Vec2f& new_v)
|
|
|
96 |
{
|
|
|
97 |
eye_dist += (new_v[1] - last_pos[1]) * scale[2];
|
|
|
98 |
eye_dist = max(eye_dist, 0.01f);
|
|
|
99 |
}
|
|
|
100 |
|
|
|
101 |
void QuatTrackBall::calcRotation(const Vec2f& new_pos)
|
|
|
102 |
{
|
|
|
103 |
// Check for zero rotation
|
|
|
104 |
if (new_pos == last_pos)
|
|
|
105 |
qinc = Quaternion();
|
|
|
106 |
else
|
|
|
107 |
{
|
|
|
108 |
// Form two vectors based on input points, find rotation axis
|
|
|
109 |
Vec3f p1 = Vec3f(new_pos[0], new_pos[1], projectToSphere(new_pos));
|
|
|
110 |
Vec3f p2 = Vec3f(last_pos[0], last_pos[1], projectToSphere(last_pos));
|
|
|
111 |
|
|
|
112 |
Vec3f q = cross(p1, p2); /* axis of rotation from p1 and p2 */
|
|
|
113 |
float L = sqrt(1.0f-dot(q,q) / (dot(p1,p1) * dot(p2,p2)));
|
|
|
114 |
|
|
|
115 |
q.normalize(); /* q' = axis of rotation */
|
|
|
116 |
q *= sqrt((1 - L)/2); /* q' = q' * sin(phi) */
|
|
|
117 |
|
|
|
118 |
qinc.set(q[0],q[1],q[2],sqrt((1 + L)/2));
|
|
|
119 |
}
|
|
|
120 |
}
|
|
|
121 |
|
|
|
122 |
// Project an x,y pair onto a sphere of radius r OR a hyperbolic sheet
|
|
|
123 |
// if we are away from the center of the sphere.
|
|
|
124 |
float QuatTrackBall::projectToSphere(const Vec2f& v)
|
|
|
125 |
{
|
|
|
126 |
float d, t, z;
|
|
|
127 |
|
|
|
128 |
d = v.length();
|
|
|
129 |
|
|
|
130 |
// Inside sphere
|
|
|
131 |
if (d < ballsize * 0.70710678118654752440) {
|
|
|
132 |
z = sqrt(ballsize*ballsize - d*d);
|
|
|
133 |
}
|
|
|
134 |
// On hyperbola
|
|
|
135 |
else {
|
|
|
136 |
t = ballsize / 1.41421356237309504880;
|
|
|
137 |
z = t*t / d;
|
|
|
138 |
}
|
|
|
139 |
|
|
|
140 |
return z;
|
|
|
141 |
}
|
|
|
142 |
|
|
|
143 |
// Scales integer point to the range [-1, 1]
|
|
|
144 |
Vec2f QuatTrackBall::scalePoint(const Vec2i& v) const
|
|
|
145 |
{
|
|
|
146 |
Vec2f w(v[0],height - v[1]);
|
|
|
147 |
w -= Vec2f(screen_centre);
|
|
|
148 |
w /= Vec2f(width,height);
|
|
|
149 |
w = CGLA::v_min(Vec2f(1.0f), CGLA::v_max(Vec2f(-1), 2*w));
|
|
|
150 |
return w;
|
|
|
151 |
}
|
|
|
152 |
|
|
|
153 |
void QuatTrackBall::get_view_param(Vec3f& eye, Vec3f& _centre, Vec3f& up) const
|
|
|
154 |
{
|
|
|
155 |
up = qrot.apply(Vec3f(0,1,0));
|
|
|
156 |
Vec3f right = qrot.apply(Vec3f(1,0,0));
|
|
|
157 |
_centre = centre - up * trans[1] - right * trans[0];
|
|
|
158 |
eye = qrot.apply(Vec3f(0,0,1)*eye_dist) + _centre;
|
|
|
159 |
}
|
|
|
160 |
|
|
|
161 |
|
|
|
162 |
// Modify the current gl matrix by the trackball rotation and translation.
|
|
|
163 |
void QuatTrackBall::set_gl_modelview() const
|
|
|
164 |
{
|
|
|
165 |
glMatrixMode(GL_MODELVIEW);
|
|
|
166 |
glLoadIdentity();
|
|
|
167 |
Vec3f eye;
|
|
|
168 |
Vec3f _centre;
|
|
|
169 |
Vec3f up;
|
|
|
170 |
get_view_param(eye, _centre, up);
|
|
|
171 |
gluLookAt(eye[0], eye[1], eye[2],
|
|
|
172 |
_centre[0], _centre[1], _centre[2],
|
|
|
173 |
up[0],up[1],up[2]);
|
|
|
174 |
}
|
|
|
175 |
|
|
|
176 |
bool QuatTrackBall::is_spinning() const
|
|
|
177 |
{
|
|
|
178 |
static const Quaternion null_quat(0,0,0,1);
|
|
|
179 |
if(!(qinc == null_quat))
|
|
|
180 |
return true;
|
|
|
181 |
return false;
|
|
|
182 |
}
|
|
|
183 |
}
|