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 moof {
  17
  18
  19 void camera::position(const vector3& position)
  20 {
  21         state_.position = position;
  22 }
  23
  24 void camera::rotation(const quaternion& rotation)
  25 {
  26         state_.orientation = rotation;
  27 }
  28
  29 void camera::look_at(const vector3& point)
  30 {
  31         // FIXME: this doesn't work as expected
  32         quaternion_rotation_aim_at(state_.orientation,
  33                                                                         state_.position, point,
  34                                                                         vector3(0.0, 1.0, 0.0));
  35 }
  36
  37
  38 void camera::projection(const matrix4& projection)
  39 {
  40         projection_ = projection;
  41 }
  42
  43 void camera::projection(scalar fovy, scalar aspect, scalar abutting,
  44                                                    scalar distant)
  45 {
  46         matrix_perspective_yfov_RH(projection_, fovy, aspect, abutting,
  47                                                                         distant, z_clip_neg_one);
  48 }
  49
  50
  51 void camera::upload_to_gl(scalar alpha) const
  52 {
  53         calculate(alpha);
  54
  55         glMatrixMode(GL_PROJECTION);
  56         glMultMatrix(projection_.data());
  57
  58         glMatrixMode(GL_MODELVIEW);
  59         glMultMatrix(modelview_.data());
  60 }
  61
  62 void camera::calculate(scalar alpha) const
  63 {
  64         state3 state = rigid_body3::state(alpha);
  65
  66         matrix_rotation_quaternion(modelview_, state.orientation);
  67
  68         matrix4 translate;
  69         matrix_translation(translate, state.position);
  70
  71         modelview_ *= translate;
  72
  73         frustum_.init(modelview_, projection_);
  74 }
  75
  76
  77 void camera::update(scalar t, scalar dt)
  78 {
  79         rigid_body3::update(t, dt);
  80 }
  81
  82 void camera::draw(scalar alpha) const
  83 {
  84         sphere_.draw(alpha);
  85 }
  86
  87
  88 void camera::handle_event(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                                 state_.position[0] -= ds;
  98                         }
  99                         else if (event.key.keysym.sym == SDLK_LEFT)
 100                         {
 101                                 state_.position[0] += ds;
 102                         }
 103                         else if (event.key.keysym.sym == SDLK_UP)
 104                         {
 105                                 state_.position[1] -= ds;
 106                         }
 107                         else if (event.key.keysym.sym == SDLK_DOWN)
 108                         {
 109                                 state_.position[1] += ds;
 110                         }
 111                         else if (event.key.keysym.sym == SDLK_PAGEUP)
 112                         {
 113                                 state_.position[2] += ds;
 114                         }
 115                         else if (event.key.keysym.sym == SDLK_PAGEDOWN)
 116                         {
 117                                 state_.position[2] -= ds;
 118                         }
 119                         break;
 120
 121                 case SDL_MOUSEMOTION:
 122                         {
 123                                 scalar xrel = rad(scalar(event.motion.xrel) / 6.0);
 124                                 scalar yrel = rad(scalar(event.motion.yrel) / 6.0);
 125
 126                                 quaternion rotation = state_.orientation;
 127
 128                                 quaternion_rotate_about_world_x(rotation, yrel);
 129                                 //mRotation.normalize();
 130                                 quaternion_rotate_about_world_y(rotation, xrel);
 131
 132                                 rotation.normalize();
 133                                 state_.orientation = rotation;
 134                         }
 135                         break;
 136
 137                 case SDL_MOUSEBUTTONDOWN:
 138                         if (event.button.button == SDL_BUTTON_WHEELUP)
 139                         {
 140                                 state_.position[2] -= ds;
 141                         }
 142                         else if (event.button.button == SDL_BUTTON_WHEELDOWN)
 143                         {
 144                                 state_.position[2] -= ds;
 145                         }
 146                         break;
 147         }
 148 }
 149
 150
 151 } // namespace moof
 152