Dogcows Code - chaz/yoink/blob - src/Moof/Camera.cc

   1
   2 /*]  Copyright (c) 2009-2010, Charles McGarvey  [**************************
   3 **]  All rights reserved.
   4 *
   5 * vi:ts=4 sw=4 tw=75
   6 *
   7 * Distributable under the terms and conditions of the 2-clause BSD license;
   8 * see the file COPYING for a complete text of the license.
   9 *
  10 **************************************************************************/
  11
  12 #include "Camera.hh"
  13 #include "OpenGL.hh"
  14
  15
  16 namespace Mf {
  17
  18
  19 void Camera::setPosition(const Vector3& position)
  20 {
  21         mState.position = position;
  22 }
  23
  24 void Camera::setRotation(const Quaternion& rotation)
  25 {
  26         mState.orientation = rotation;
  27 }
  28
  29 void Camera::lookAt(const Vector3& point)
  30 {
  31         // FIXME this doesn't work as expected
  32         cml::quaternion_rotation_aim_at(mState.orientation,
  33                                                                         mState.position, point,
  34                                                                         Vector3(0.0, 1.0, 0.0));
  35 }
  36
  37
  38 void Camera::setProjection(const Matrix4& projection)
  39 {
  40         mProjection = projection;
  41 }
  42
  43 void Camera::setProjection(Scalar fovy, Scalar aspect, Scalar abutting,
  44                                                    Scalar distant)
  45 {
  46         cml::matrix_perspective_yfov_RH(mProjection, fovy, aspect, abutting,
  47                                                                         distant, cml::z_clip_neg_one);
  48 }
  49
  50
  51 void Camera::uploadToGL(Scalar alpha) const
  52 {
  53         calculate(alpha);
  54
  55         glMatrixMode(GL_PROJECTION);
  56         glMultMatrix(mProjection.data());
  57
  58         glMatrixMode(GL_MODELVIEW);
  59         glMultMatrix(mModelview.data());
  60 }
  61
  62 void Camera::calculate(Scalar alpha) const
  63 {
  64         State3 state = getState(alpha);
  65
  66         cml::matrix_rotation_quaternion(mModelview, state.orientation);
  67
  68         Matrix4 translate;
  69         cml::matrix_translation(translate, state.position);
  70
  71         mModelview *= translate;
  72
  73         mFrustum.init(mModelview, mProjection);
  74 }
  75
  76
  77 void Camera::update(Scalar t, Scalar dt)
  78 {
  79         RigidBody3::update(t, dt);
  80 }
  81
  82 void Camera::draw(Scalar alpha) const
  83 {
  84         mSphere.draw(alpha);
  85 }
  86
  87
  88 void Camera::handleEvent(const Event& event)
  89 {
  90         const Scalar ds = 50.0;
  91
  92         switch (event.type)
  93         {
  94                 case SDL_KEYDOWN:
  95                         if (event.key.keysym.sym == SDLK_RIGHT)
  96                         {
  97                                 mState.position[0] -= ds;
  98                         }
  99                         else if (event.key.keysym.sym == SDLK_LEFT)
 100                         {
 101                                 mState.position[0] += ds;
 102                         }
 103                         else if (event.key.keysym.sym == SDLK_UP)
 104                         {
 105                                 mState.position[1] -= ds;
 106                         }
 107                         else if (event.key.keysym.sym == SDLK_DOWN)
 108                         {
 109                                 mState.position[1] += ds;
 110                         }
 111                         else if (event.key.keysym.sym == SDLK_PAGEUP)
 112                         {
 113                                 mState.position[2] += ds;
 114                         }
 115                         else if (event.key.keysym.sym == SDLK_PAGEDOWN)
 116                         {
 117                                 mState.position[2] -= ds;
 118                         }
 119                         break;
 120
 121                 case SDL_MOUSEMOTION:
 122                         {
 123                                 Scalar xrel = cml::rad(Scalar(event.motion.xrel) / 6.0);
 124                                 Scalar yrel = cml::rad(Scalar(event.motion.yrel) / 6.0);
 125
 126                                 Quaternion rotation = mState.orientation;
 127
 128                                 cml::quaternion_rotate_about_world_x(rotation, yrel);
 129                                 //mRotation.normalize();
 130                                 cml::quaternion_rotate_about_world_y(rotation, xrel);
 131
 132                                 rotation.normalize();
 133                                 mState.orientation = rotation;
 134                         }
 135                         break;
 136
 137                 case SDL_MOUSEBUTTONDOWN:
 138                         if (event.button.button == SDL_BUTTON_WHEELUP)
 139                         {
 140                                 mState.position[2] -= ds;
 141                         }
 142                         else if (event.button.button == SDL_BUTTON_WHEELDOWN)
 143                         {
 144                                 mState.position[2] -= ds;
 145                         }
 146                         break;
 147         }
 148 }
 149
 150
 151 } // namespace Mf
 152