Subversion Repositories gelsvn

Rev

Rev 87 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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