source/designer/cameracontroller.cpp

   1 /* $Id$
   2
   3 This file is part of the MSP Märklin suite
   4 Copyright © 2010 Mikkosoft Productions, Mikko Rasa
   5 Distributed under the GPL
   6 */
   7
   8 #include <cmath>
   9 #include <msp/input/keys.h>
  10 #include "cameracontroller.h"
  11 #include "designer.h"
  12
  13 using namespace std;
  14 using namespace Msp;
  15 using namespace Marklin;
  16
  17 CameraController::CameraController(Designer &d, Graphics::EventSource &es, GL::Camera &c):
  18         designer(d),
  19         event_source(es),
  20         camera(c),
  21         move_x(0),
  22         move_y(0),
  23         drag_mode(NONE)
  24 {
  25         event_source.signal_button_press.connect(sigc::mem_fun(this, &CameraController::button_press));
  26         event_source.signal_button_release.connect(sigc::mem_fun(this, &CameraController::button_release));
  27         event_source.signal_pointer_motion.connect(sigc::mem_fun(this, &CameraController::pointer_motion));
  28         event_source.signal_key_press.connect(sigc::mem_fun(this, &CameraController::key_press));
  29         event_source.signal_key_release.connect(sigc::mem_fun(this, &CameraController::key_release));
  30 }
  31
  32 void CameraController::top_down()
  33 {
  34         const GL::Vector3 &look = camera.get_look_direction();
  35         float xy_len = sqrt(look.x*look.x+look.y*look.y);
  36         set_look_direction(GL::Vector3(look.x*0.01/xy_len, look.y*0.01/xy_len, -0.99995));
  37 }
  38
  39 void CameraController::set_look_direction(const GL::Vector3 &look)
  40 {
  41         GL::Vector3 focus = get_focus();
  42         float dist = get_distance();
  43         camera.set_look_direction(look);
  44         camera.set_position(GL::Vector3(focus.x-look.x*dist, focus.y-look.y*dist, focus.z-look.z*dist));
  45 }
  46
  47 void CameraController::view_all()
  48 {
  49         Point minp;
  50         Point maxp;
  51
  52         const Layout3D::TrackMap &tracks = designer.get_layout_3d().get_tracks();
  53         for(Layout3D::TrackMap::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
  54         {
  55                 Point tmin;
  56                 Point tmax;
  57                 i->second->get_bounds(0, tmin, tmax);
  58                 minp.x = min(minp.x, tmin.x);
  59                 minp.y = min(minp.y, tmin.y);
  60                 maxp.x = max(maxp.x, tmax.x);
  61                 maxp.y = max(maxp.y, tmax.y);
  62         }
  63
  64         float t = tan(camera.get_field_of_view()/2)*2;
  65         float size = max((maxp.y-minp.y+0.1), (maxp.x-minp.x+0.1)/camera.get_aspect());
  66         float dist = size/t+size*0.25;
  67         GL::Vector3 center((minp.x+maxp.x)/2, (minp.y+maxp.y)/2, 0);
  68         const GL::Vector3 &look = camera.get_look_direction();
  69         camera.set_position(GL::Vector3(center.x-look.x*dist, center.y-look.y*dist, center.z-look.z*dist));
  70 }
  71
  72 void CameraController::move(float x, float y)
  73 {
  74         const GL::Vector3 &pos = camera.get_position();
  75         const GL::Vector3 &look = camera.get_look_direction();
  76         float xy_len = sqrt(look.x*look.x+look.y*look.y);
  77         float dx = (look.x*y+look.y*x)/xy_len;
  78         float dy = (look.y*y-look.x*x)/xy_len;
  79         camera.set_position(GL::Vector3(pos.x+dx, pos.y+dy, pos.z));
  80 }
  81
  82 void CameraController::adjust_distance(float delta)
  83 {
  84         const GL::Vector3 &pos = camera.get_position();
  85         const GL::Vector3 &look = camera.get_look_direction();
  86         camera.set_position(GL::Vector3(pos.x-look.x*delta, pos.y-look.y*delta, pos.z-look.z*delta));
  87 }
  88
  89 void CameraController::rotate(float angle)
  90 {
  91         GL::Vector3 look = camera.get_look_direction();
  92         float c = cos(angle);
  93         float s = sin(angle);
  94         set_look_direction(GL::Vector3(look.x*c-look.y*s, look.x*s+look.y*c, look.z));
  95 }
  96
  97 void CameraController::pitch(float angle)
  98 {
  99         GL::Vector3 look = camera.get_look_direction();
 100         float xy_len = sqrt(look.x*look.x+look.y*look.y);
 101         float c = cos(angle);
 102         float s = sin(angle);
 103         if(xy_len*c-look.z*s<0.01)
 104                 top_down();
 105         else if(xy_len*s+look.z*c>-0.01)
 106                 set_look_direction(GL::Vector3(look.x*0.99995/xy_len, look.y*0.99995/xy_len, -0.01));
 107         else
 108         {
 109                 float xy_scale = (xy_len*c-look.z*s)/xy_len;
 110                 set_look_direction(GL::Vector3(look.x*xy_scale, look.y*xy_scale, xy_len*s+look.z*c));
 111         }
 112 }
 113
 114 void CameraController::tick(float dt)
 115 {
 116         if(move_x || move_y)
 117         {
 118                 float scale = get_view_scale()*dt;
 119                 move(move_x*scale, move_y*scale);
 120         }
 121 }
 122
 123 void CameraController::button_press(int x, int y, unsigned btn, unsigned mod)
 124 {
 125         mod = Input::mod_from_sys(mod);
 126         if(btn==2 || btn==3)
 127         {
 128                 if(mod&Input::MOD_CONTROL)
 129                         drag_mode = DISTANCE;
 130                 else
 131                         drag_mode = ((btn==2)==((mod&Input::MOD_SHIFT)!=0) ? ROTATE : PAN);
 132
 133                 pointer_x = x;
 134                 pointer_y = y;
 135         }
 136         else if(btn==4)
 137         {
 138                 adjust_distance(-get_distance()*0.1);
 139         }
 140         else if(btn==5)
 141         {
 142                 adjust_distance(get_distance()*0.1);
 143         }
 144 }
 145
 146 void CameraController::button_release(int, int, unsigned btn, unsigned)
 147 {
 148         if(btn==2 || btn==3)
 149                 drag_mode = NONE;
 150 }
 151
 152 void CameraController::pointer_motion(int x, int y)
 153 {
 154         if(drag_mode!=NONE)
 155         {
 156                 int dx = x-pointer_x;
 157                 int dy = y-pointer_y;
 158
 159                 if(drag_mode==PAN)
 160                 {
 161                         float scale = get_view_scale()/event_source.get_height();
 162                         move(-dx*scale, dy*scale);
 163                 }
 164                 else if(drag_mode==ROTATE)
 165                 {
 166                         rotate(-dx*M_PI*2/event_source.get_width());
 167                         pitch(-dy*M_PI/event_source.get_height());
 168                 }
 169                 else if(drag_mode==DISTANCE)
 170                         adjust_distance(dy*3*get_distance()/event_source.get_height());
 171
 172                 pointer_x = x;
 173                 pointer_y = y;
 174         }
 175 }
 176
 177 void CameraController::key_press(unsigned code, unsigned, wchar_t)
 178 {
 179         unsigned key = Msp::Input::key_from_sys(code);
 180
 181         if(key==Msp::Input::KEY_RIGHT)
 182                 move_x = 1;
 183         else if(key==Msp::Input::KEY_LEFT)
 184                 move_x = -1;
 185         else if(key==Msp::Input::KEY_UP)
 186                 move_y = 1;
 187         else if(key==Msp::Input::KEY_DOWN)
 188                 move_y = -1;
 189         else if(key==Msp::Input::KEY_HOME)
 190                 view_all();
 191         else if(key==Msp::Input::KEY_INSERT)
 192                 top_down();
 193 }
 194
 195 void CameraController::key_release(unsigned code, unsigned)
 196 {
 197         unsigned key = Msp::Input::key_from_sys(code);
 198
 199         if(key==Msp::Input::KEY_RIGHT || key==Msp::Input::KEY_LEFT)
 200                 move_x = 0;
 201         else if(key==Msp::Input::KEY_UP || key==Msp::Input::KEY_DOWN)
 202                 move_y = 0;
 203 }
 204
 205 GL::Vector3 CameraController::get_focus() const
 206 {
 207         const GL::Vector3 &pos = camera.get_position();
 208         const GL::Vector3 &look = camera.get_look_direction();
 209         float dist = get_distance();
 210         return GL::Vector3(pos.x+look.x*dist, pos.y+look.y*dist, pos.z+look.z*dist);
 211 }
 212
 213 float CameraController::get_distance() const
 214 {
 215         return -camera.get_position().z/camera.get_look_direction().z;
 216 }
 217
 218 float CameraController::get_view_scale() const
 219 {
 220         float t = tan(camera.get_field_of_view()/2)*2;
 221         return get_distance()*t;
 222 }