camera.cc

Go to the documentation of this file.

/*
 *  camera.cc
 *  Stage
 *
 *  Created by Alex Couture-Beil on 06/06/08.
 *
 */

#include "stage.hh"
#include "worldfile.hh"
using namespace Stg;

#include <iostream>

// Perspective Camera
PerspectiveCamera::PerspectiveCamera(void)
    : Camera(), _z_near(0.2), _z_far(40.0), _vert_fov(70), _horiz_fov(70), _aspect(1.0)
{
  setPitch(70.0);
}

void PerspectiveCamera::move(double x, double y, double z)
{
  (void)z; // avoid warning about unused var

  // scale relative to zoom level
  x *= _z / 100.0;
  y *= _z / 100.0;

  // adjust for yaw angle
  _x += cos(dtor(_yaw)) * x;
  _x += -sin(dtor(_yaw)) * y;

  _y += sin(dtor(_yaw)) * x;
  _y += cos(dtor(_yaw)) * y;
}

void PerspectiveCamera::Draw(void) const
{
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();

  glRotatef(-_pitch, 1.0, 0.0, 0.0);
  glRotatef(-_yaw, 0.0, 0.0, 1.0);

  glTranslatef(-_x, -_y, -_z);
  // zooming needs to happen in the Projection code (don't use glScale for zoom)
}

void PerspectiveCamera::SetProjection(void) const
{
  //    SetProjection( pixels_width/pixels_height );

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  double top = tan(dtor(_vert_fov) / 2.0) * _z_near;
  double bottom = -top;
  double right = tan(dtor(_horiz_fov) / 2.0) * _z_near;
  double left = -right;

  right *= _aspect;
  left *= _aspect;

  glFrustum(left, right, bottom, top, _z_near, _z_far);

  glMatrixMode(GL_MODELVIEW);
}

void PerspectiveCamera::update(void)
{
}

void PerspectiveCamera::strafe(double amount)
{
  _x += cos(dtor(_yaw)) * amount;
  _y += sin(dtor(_yaw)) * amount;
}

void PerspectiveCamera::forward(double amount)
{
  _x += -sin(dtor(_yaw)) * amount;
  _y += cos(dtor(_yaw)) * amount;
}

void PerspectiveCamera::Load(Worldfile *wf, int sec)
{
  wf->ReadTuple(sec, "pcam_loc", 0, 3, "lll", &_x, &_y, &_z);
  wf->ReadTuple(sec, "pcam_angle", 0, 2, "aa", &_pitch, &_yaw);
}

void PerspectiveCamera::Save(Worldfile *wf, int sec)
{
  wf->WriteTuple(sec, "pcam_loc", 0, 3, "lll", _x, _y, _z);
  wf->WriteTuple(sec, "pcam_angle", 0, 2, "aa", _pitch, _yaw);
}

// Ortho camera
void OrthoCamera::Draw(void) const
{
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();

  glRotatef(-_pitch, 1.0, 0.0, 0.0);
  glRotatef(-_yaw, 0.0, 0.0, 1.0);

  glTranslatef(-_x, -_y, 0.0);
  // zooming needs to happen in the Projection code (don't use glScale for zoom)
}

void OrthoCamera::SetProjection(void) const
{
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();

  glOrtho(-_pixels_width / 2.0 / _scale, _pixels_width / 2.0 / _scale,
          -_pixels_height / 2.0 / _scale, _pixels_height / 2.0 / _scale, _y_min * _scale * 2,
          _y_max * _scale * 2);

  glMatrixMode(GL_MODELVIEW);
}

void OrthoCamera::SetProjection(double pixels_width, double pixels_height, double y_min,
                                double y_max)
{
  _pixels_width = pixels_width;
  _pixels_height = pixels_height;
  _y_min = y_min;
  _y_max = y_max;
  SetProjection();
}

void OrthoCamera::move(double x, double y)
{
  // convert screen points into world points
  x = x / (_scale);
  y = y / (_scale);

  // adjust for pitch angle
  y = y / cos(dtor(_pitch));

  // don't allow huge values
  if (y > 100)
    y = 100;
  else if (y < -100)
    y = -100;

  // adjust for yaw angle
  double yaw = -dtor(_yaw);
  _x += cos(yaw) * x;
  _y += -sin(yaw) * x;

  _x += sin(yaw) * y;
  _y += cos(yaw) * y;
}

// TODO re-evaluate the way the camera is shifted when the mouse zooms - it
// might be possible to simplify
void OrthoCamera::scale(double scale, double shift_x, double w, double shift_y, double h)
{
  double to_scale = -scale;
  const double old_scale = _scale;

  // TODO setting up the factor can use some work
  double factor = 1.0 + fabs(to_scale) / 25;
  if (factor < 1.1)
    factor = 1.1; // this must be greater than 1.
  else if (factor > 2.5)
    factor = 2.5;

  // convert the shift distance to the range [-0.5, 0.5]
  shift_x = shift_x / w - 0.5;
  shift_y = shift_y / h - 0.5;

  // adjust the shift values based on the factor (this represents how much the
  // positions grows/shrinks)
  shift_x *= factor - 1.0;
  shift_y *= factor - 1.0;

  if (to_scale > 0) {
    // zoom in
    _scale *= factor;
    move(shift_x * w, -shift_y * h);
  } else {
    // zoom out
    _scale /= factor;
    if (_scale < 1) {
      _scale = 1;
    } else {
      // shift camera to follow where mouse zoomed out
      move(-shift_x * w / old_scale * _scale, shift_y * h / old_scale * _scale);
    }
  }
}

void OrthoCamera::Load(Worldfile *wf, int sec)
{
  wf->ReadTuple(sec, "center", 0, 2, "ff", &_x, &_y);
  wf->ReadTuple(sec, "rotate", 0, 2, "ff", &_pitch, &_yaw);
  setScale(wf->ReadFloat(sec, "scale", scale()));
}

void OrthoCamera::Save(Worldfile *wf, int sec)
{
  wf->WriteTuple(sec, "center", 0, 2, "ff", _x, _y);
  wf->WriteTuple(sec, "rotate", 0, 2, "ff", _pitch, _yaw);

  // wf->WriteTupleFloat( sec, "center", 0, x() );
  // wf->WriteTupleFloat( sec, "center", 1, y() );
  // wf->WriteTupleFloat( sec, "rotate", 0, pitch() );
  // wf->WriteTupleFloat( sec, "rotate", 1, yaw() );

  wf->WriteFloat(sec, "scale", scale());
}