path: root/src/render/camera.cc

/* 
   render/camera.cc
   This file is part of the Osirion project and is distributed under 
   the terms and conditions of the GNU General Public License version 2 
*/

#include "core/core.h"
#include "math/mathlib.h"
#include "math/matrix4f.h"
#include "render/camera.h"
#include "render/gl.h"
#include "sys/sys.h"

using math::degrees360f;
using math::degrees180f;

namespace render
{

const float 		MIN_DELTA = 10e-10;

const float 		pitch_track = -15.0f;
const float 		pitch_overview = -75.0f;

float 			Camera::camera_aspect = 1.0f;
float			Camera::camera_frustum_size = 0.5f;
float			Camera::camera_frustum_front = 1.0f;
math::Vector3f 		Camera::camera_eye;
math::Vector3f 		Camera::camera_target;
math::Axis 		Camera::camera_axis;
Camera::Mode 		Camera::camera_mode;

// current and target yaw angle in XZ plane, positive is looking left
float Camera::direction_current;
float Camera::direction_target;
float Camera::target_direction;

// current and target pitch angle in XY, positive is looking up
float Camera::pitch_current;
float Camera::pitch_target;
float Camera::target_pitch;

float Camera::distance;

void Camera::init()
{
	camera_aspect = 1.0f;
	
	camera_frustum_size = 0.5f;
	camera_frustum_front = 1.0f;

	direction_current = 0;
	direction_target = 0; 

	pitch_current = pitch_track * 2; 
	pitch_target = pitch_track; 

	target_pitch = 0.0f;
	target_direction = 0.0f;

	distance = 0.4f;

	set_mode(Track);

	camera_axis.clear();
	camera_eye.clear();
	camera_target.clear();
	
}

void Camera::shutdown()
{
}

void Camera::set_aspect(int width, int height)
{
	camera_aspect = (float) width / (float) height;
}

void Camera::set_mode(Mode newmode) {
	
	direction_target = 0;
	direction_current = direction_target;
	pitch_target = pitch_track;
	pitch_current = pitch_target;

	target_direction = 0.0f;
	target_pitch = 0.0f;
	distance = 0.4f;

	camera_frustum_size = 0.5f;
	camera_frustum_front = 1.0f;

	camera_axis.clear();

	switch(newmode) {
	case Track:
		// switch camera to Track mode
		camera_mode = Track;
		if (core::localcontrol()) {
			if (core::localcontrol()->state())
				camera_axis.assign(core::localcontrol()->state()->axis());
			else
				camera_axis.assign(core::localcontrol()->axis());
		}
		break;

	case Free:
		// switch camera to Free mode
		camera_mode = Free;
		pitch_target = 2.0 * pitch_track;
		pitch_current = pitch_target;
		break;

	case Cockpit:
		camera_mode = Cockpit;
		break;

	case Overview:
		// switch camera to Overview mode
		camera_mode = Overview;

	default:
		break;
	}

}

void Camera::view_next()
{
	
 	if (!core::localcontrol()) {
		set_mode(Overview);
		return;
	}

	switch(camera_mode) {
	case Free:
		// switch camera to Track mode
		set_mode(Track);
		core::application()->notify_message(std::string("view: track"));
		break;

	case Track:
		// switch camera to Cockpit mode
		set_mode(Cockpit);
		core::application()->notify_message(std::string("view: cockpit"));
		break;
	
	case Cockpit:
		// switch camera to Free mode
		set_mode(Free);
		core::application()->notify_message(std::string("view: free"));
		break;
	
	default:
		break;
	}
}

void Camera::view_previous()
{
	
 	if (!core::localcontrol()) {
		set_mode(Overview);
		return;
	}

	switch(camera_mode) {
	case Cockpit:
		// switch camera to Track mode
		set_mode(Track);
		core::application()->notify_message(std::string("view: track"));
		break;

	case Free:
		// switch camera to Cockpit mode
		set_mode(Cockpit);
		core::application()->notify_message(std::string("view: cockpit"));
		break;
	
	case Track:
		// switch camera to Free mode
		set_mode(Free);
		core::application()->notify_message(std::string("view: free"));
		break;
	
	default:
		break;
	}
}
void Camera::frame(float seconds) 
{	
	math::Axis target_axis;
	float d = 0;

	if (!core::localcontrol()) {

		if (camera_mode != Overview) {
			set_mode(Overview);
		}
		
		camera_eye.clear();
		camera_target.clear();
		camera_axis.clear();
		pitch_current = pitch_overview;
		camera_axis.change_pitch(pitch_current);

		distance = 20.0f;

	} else {
		if (mode() == Overview)
			set_mode(Track);

		camera_target.assign(core::localcontrol()->state()->location());
		target_axis.assign(core::localcontrol()->state()->axis());
		distance = core::localcontrol()->radius();

		if (mode() == Track) {

			float cosangle;		// cosine of an angle
			float angle;		// angle in radians	
			math::Vector3f n;	// normal of a plane

			n.assign(math::crossproduct(camera_axis.forward(), target_axis.forward()));
			if (!(n.length() < MIN_DELTA)) {
				n.normalize();
				cosangle = math::dotproduct(camera_axis.forward(), target_axis.forward());
				angle = acos(cosangle) * seconds; // * 180.0f / M_PI;
				if (angle > MIN_DELTA)
					camera_axis.rotate(n, -angle);
			}

			n.assign(math::crossproduct(camera_axis.left(), target_axis.left()));
			if (!(n.length() < MIN_DELTA)) {
				n.normalize();
				cosangle = math::dotproduct(camera_axis.left(), target_axis.left());
				angle = acos(cosangle) * seconds; // * 180.0f / M_PI;
				if (angle > MIN_DELTA)
					camera_axis.rotate(n, -angle);
			}

			n.assign(math::crossproduct(camera_axis.up(), target_axis.up()));
			if (!(n.length() < MIN_DELTA)) {
				n.normalize();
				cosangle = math::dotproduct(camera_axis.up(), target_axis.up());
				angle = acos(cosangle) * seconds; // * 180.0f / M_PI;
				if (angle > MIN_DELTA)
					camera_axis.rotate(n, -angle);
			} 

			if (core::localcontrol()->model()) {
 				camera_target -= (core::localcontrol()->model()->maxbbox().x + core::localcontrol()->model()->radius() + 0.1f) * 0.5f * camera_axis.forward();
				camera_target += (core::localcontrol()->model()->maxbbox().z + core::localcontrol()->model()->radius() + 0.1f) * 0.5f * camera_axis.up();
			}

		} else if (mode() == Free) {
			camera_axis.assign(target_axis);

			direction_target =  direction_current - 90 * target_direction;
			pitch_target = pitch_current - 90 * target_pitch;

			// adjust direction
			d = degrees180f(direction_current - direction_target);
			direction_current = degrees360f( direction_current -  d * seconds);
			camera_axis.change_direction(direction_current);

			// adjust pitch 
			d = degrees180f(pitch_current - pitch_target);
			pitch_current = degrees360f(pitch_current -  d * seconds);
			camera_axis.change_pitch(pitch_current);

			distance = 1.5f * core::localcontrol()->radius();
		
		} else if (mode() == Cockpit) {

			camera_axis.assign(target_axis);

			if (core::localcontrol()->state()) {
				if (core::localcontrol()->model()) {
					camera_target += (core::localcontrol()->model()->maxbbox().x+0.05) *
						core::localcontrol()->state()->axis().forward();
				} else  {
					camera_target += (core::localcontrol()->radius() + 0.05) *
						core::localcontrol()->state()->axis().forward();
				}
			}
			distance = 0.0f;
		}
	}

	distance += camera_frustum_front;

	// calculate eye position
	camera_eye = camera_target - (distance * camera_axis.forward());
}

void Camera::draw()
{
	// Change to the projection matrix and set our viewing volume large enough for the skysphere
	gl::matrixmode(GL_PROJECTION);
	gl::loadidentity();

	gl::frustum(-camera_frustum_size, camera_frustum_size, -camera_frustum_size/Camera::aspect(), camera_frustum_size/Camera::aspect(), camera_frustum_front, 1023.0f);
	gl::matrixmode(GL_MODELVIEW);
	gl::loadidentity();

	// map world coordinates to opengl coordinates
	gl::rotate(90.0f, 0.0f, 1.0f, 0.0f);
	gl::rotate(-90.0f, 1.0f , 0.0f, 0.0f);

	// apply the transpose of the axis transformation (the axis is orhtonormal)
	math::Matrix4f matrix;
	matrix.assign(camera_axis);
	gl::multmatrix(matrix.transpose());

	gl::translate(-1.0f * camera_eye);
}

void Camera::set_direction(float direction)
{
	target_direction = direction;
	math::clamp(target_direction, -1.0f, 1.0f);
}

void Camera::set_pitch(float pitch)
{
	target_pitch = pitch;
	math::clamp(target_pitch, -1.0f, 1.0f);
}

void Camera::reset()
{
	set_mode(camera_mode);
}

float Camera::frustum_front()
{
	return camera_frustum_front;
}

float Camera::frustum_size()
{
	return camera_frustum_size;
}

}