Subversion Repositories gelsvn

/* ----------------------------------------------------------------------- *

 * This file is part of GEL, http://www.imm.dtu.dk/GEL

 * Copyright (C) the authors and DTU Informatics

 * For license and list of authors, see ../../doc/intro.pdf

 * ----------------------------------------------------------------------- */

#include <iostream>

#include "../CGLA/CGLA.h"

#include "QuatTrackBall.h"

#include "gel_glu.h"

#include "GLViewController.h"

using namespace std;

using namespace CGLA;

namespace GLGraphics

{

    QuatTrackBall::QuatTrackBall(const Vec3f& _centre, 

			 float _eye_dist,

			 unsigned _width, 

			 unsigned _height):

	centre(_centre), width(_width), height(_height), 

	eye_dist(_eye_dist)

	{

	// This size should really be based on the distance from the center of

	// rotation to the point on the object underneath the mouse.  That

	// point would then track the mouse as closely as possible.  This is a

	// simple example, though, so that is left as an exercise.

	ballsize = 2.0f;

	screen_centre = Vec2i(width/2, height/2);

	qrot = Quatf(0.0, 0.0, 0.0, 1.0);

	qinc = Quatf(0.0, 0.0, 0.0, 1.0);

	trans = Vec2f(0.0, 0.0);

    }

    void QuatTrackBall::grab_ball(TrackBallAction act, const Vec2i& v)

    {

    if(v[0] < 0 || v[0] >= static_cast<int>(width)

       || v[1] < 0 || v[1] >= static_cast<int>(height))

      return;      

	set_position(scalePoint(v));

	current_action = act;

    }

    void QuatTrackBall::roll_ball(const Vec2i& v)

    {

    if(v[0] < 0 || v[0] >= static_cast<int>(width)

       || v[1] < 0 || v[1] >= static_cast<int>(height))

      return;      

	Vec2f w = scalePoint(v); 

	switch (current_action) 

	{

			case ROTATE_ACTION:

	    rotate(w);

	    break;

			case PAN_ACTION:

	    pan(w);

	    break;

			case ZOOM_ACTION:

	    zoom(w);

	    break;

	}

	last_pos = w;	

    }

    // Call this when the user does a mouse down.  

    // Stop the trackball glide, then remember the mouse

    // down point (for a future rotate, pan or zoom).

    void QuatTrackBall::set_position(const Vec2f& _last_pos) 

    {

	stop_spin();

	last_pos = _last_pos;

    }

    // Rotationaly spin the trackball by the current increment.

    // Use this to implement rotational glide.

    void QuatTrackBall::do_spin() 

    {

	qrot = qrot*qinc;

    }

    // Cease any rotational glide by zeroing the increment.

    void QuatTrackBall::stop_spin() 

    {

	qinc.set(0.0, 0.0, 0.0, 1.0);

    }

    void QuatTrackBall::rotate(const Vec2f& new_v) 

    {

	calcRotation(new_v);

	do_spin();	

    }

    void QuatTrackBall::pan(const Vec2f& new_v) 

    {

	trans += (new_v - last_pos) * Vec2f(eye_dist);

    }

    void QuatTrackBall::zoom(const Vec2f& new_v) 

    {

	eye_dist += (new_v[1] - last_pos[1]) * eye_dist;

	eye_dist = max(eye_dist, 0.01f);

    }

    void QuatTrackBall::calcRotation(const Vec2f& new_pos) 

    {

	// Check for zero rotation

	if (new_pos == last_pos) 

	    qinc = Quatf(0.0f, 0.0f, 0.0f, 1.0f);

	else

	{

		// Form two vectors based on input points, find rotation axis

		Vec3f p1 = Vec3f(new_pos[0], new_pos[1], projectToSphere(new_pos));

		Vec3f p2 = Vec3f(last_pos[0], last_pos[1], projectToSphere(last_pos));

        qinc.make_rot(normalize(p1), normalize(p2));

/*

		Vec3f q = cross(p1, p2);		// axis of rotation from p1 and p2 

		float L = sqrt(1.0f-dot(q,q) / (dot(p1,p1) * dot(p2,p2)));

		q.normalize();				// q' = axis of rotation 

		q *= sqrt((1 - L)/2);	// q' = q' * sin(phi)

		qinc.set(q[0],q[1],q[2],sqrt((1 + L)/2));

*/

	}

    }

    // Project an x,y pair onto a sphere of radius r OR a hyperbolic sheet

    // if we are away from the center of the sphere.

    float QuatTrackBall::projectToSphere(const Vec2f& v) 

    {

#ifndef M_SQRT_2

	  const double M_SQRT_2 = 0.707106781187;

#endif

      float d = v.length();

      float t = ballsize*M_SQRT_2;

      float z;

      // Inside sphere 

      if(d < ballsize) 

        z = sqrt(ballsize*ballsize - d*d);

      else if(d < t)

        z = 0.0;

      // On hyperbola 

      else 

        z = t*t/d;

      return z;

    }

    // Scales integer point to the range [-1, 1]

    Vec2f QuatTrackBall::scalePoint(const Vec2i& v) const

    {

	Vec2f w(v[0],height - v[1]);

	w -= Vec2f(screen_centre);

	w /= Vec2f(width,height);

	w = CGLA::v_min(Vec2f(1.0f), CGLA::v_max(Vec2f(-1), 2*w));

	return w; 

    }

    void QuatTrackBall::get_view_param(Vec3f& eye, Vec3f& _centre, Vec3f& up) const

    {

	up  = qrot.apply_unit(Vec3f(0,1,0));

	Vec3f right = qrot.apply(Vec3f(1,0,0));

	_centre = centre - up * trans[1] - right * trans[0]; 

	eye = qrot.apply_unit(Vec3f(0,0,1)*eye_dist) + _centre;

    }

    // Modify the current gl matrix by the trackball rotation and translation.

    void QuatTrackBall::set_gl_modelview() const

    {

	glMatrixMode(GL_MODELVIEW);

	glLoadIdentity();

	Vec3f eye;

	Vec3f _centre;

	Vec3f up;

	get_view_param(eye, _centre, up);

	gluLookAt(eye[0], eye[1], eye[2],

		  _centre[0], _centre[1], _centre[2], 

		  up[0],up[1],up[2]);

    }

    bool QuatTrackBall::is_spinning() const

    {

	static const Quatf null_quat(0,0,0,1);

	if(!(qinc == null_quat))

	    return true;

	return false;

    }

}