tools/viewer.cpp

   1 #include <cmath>
   2 #include <msp/core/application.h>
   3 #include <msp/core/getopt.h>
   4 #include <msp/datafile/directorysource.h>
   5 #include <msp/datafile/packsource.h>
   6 #include <msp/fs/stat.h>
   7 #include <msp/fs/utils.h>
   8 #include <msp/graphics/display.h>
   9 #include <msp/graphics/window.h>
  10 #include <msp/gl/animatedobject.h>
  11 #include <msp/gl/animation.h>
  12 #include <msp/gl/animationplayer.h>
  13 #include <msp/gl/blend.h>
  14 #include <msp/gl/camera.h>
  15 #include <msp/gl/device.h>
  16 #include <msp/gl/directionallight.h>
  17 #include <msp/gl/framebuffer.h>
  18 #include <msp/gl/lighting.h>
  19 #include <msp/gl/mesh.h>
  20 #include <msp/gl/object.h>
  21 #include <msp/gl/sequence.h>
  22 #include <msp/gl/sequencebuilder.h>
  23 #include <msp/gl/sequencetemplate.h>
  24 #include <msp/gl/renderer.h>
  25 #include <msp/gl/resources.h>
  26 #include <msp/gl/simplescene.h>
  27 #include <msp/gl/technique.h>
  28 #include <msp/gl/windowview.h>
  29 #include <msp/input/mouse.h>
  30 #include <msp/io/print.h>
  31 #include <msp/strings/regex.h>
  32 #include <msp/time/timestamp.h>
  33 #include <msp/time/utils.h>
  34
  35 using namespace std;
  36 using namespace Msp;
  37
  38 class Viewer: public RegisteredApplication<Viewer>
  39 {
  40 private:
  41         struct Options
  42         {
  43                 list<string> resource_locations;
  44                 string animation_name;
  45                 string renderable_name;
  46                 Graphics::WindowOptions wnd_opts;
  47                 Graphics::GLOptions gl_opts;
  48
  49                 Options(int, char **);
  50         };
  51
  52         class Resources: public GL::Resources
  53         {
  54         private:
  55                 DataFile::DirectorySource dir_source;
  56                 DataFile::PackSource pack_source;
  57
  58         public:
  59                 Resources();
  60
  61                 void add_directory(const string &);
  62                 void add_pack(const string &);
  63         };
  64
  65         Options opts;
  66         Graphics::Display display;
  67         Graphics::Window window;
  68         GL::Device gl_device;
  69         Input::Mouse mouse;
  70         Resources resources;
  71         GL::WindowView view;
  72         GL::Sequence *sequence;
  73         GL::Renderable *renderable;
  74         GL::AnimatedObject *anim_object;
  75         GL::AnimationPlayer *anim_player;
  76         GL::DirectionalLight light;
  77         GL::Lighting lighting;
  78         GL::Camera camera;
  79         float yaw;
  80         float pitch;
  81         float distance;
  82         float light_yaw;
  83         float light_pitch;
  84         unsigned dragging;
  85         Time::TimeStamp last_tick;
  86
  87 public:
  88         Viewer(int, char **);
  89 private:
  90         template<typename T>
  91         T *load(const string &);
  92 public:
  93         ~Viewer();
  94
  95         virtual int main();
  96 private:
  97         virtual void tick();
  98
  99         void button_press(unsigned);
 100         void button_release(unsigned);
 101         void axis_motion(unsigned, float, float);
 102
 103         void update_camera();
 104         void update_light();
 105 };
 106
 107
 108 Viewer::Options::Options(int argc, char **argv)
 109 {
 110         string window_size;
 111
 112         GetOpt getopt;
 113         getopt.add_option('r', "resources", resource_locations, GetOpt::REQUIRED_ARG);
 114         getopt.add_option('a', "animation", animation_name, GetOpt::REQUIRED_ARG);
 115         getopt.add_option('w', "window-size", window_size, GetOpt::REQUIRED_ARG);
 116         getopt.add_argument("renderable", renderable_name);
 117         getopt(argc, argv);
 118
 119         wnd_opts.width = 1024;
 120         wnd_opts.height = 768;
 121         if (!window_size.empty())
 122         {
 123                 RegMatch m = Regex("^([1-9][0-9]*)x([1-9][0-9]*)$").match(window_size);
 124                 if(!m)
 125                         throw usage_error("Invalid window size");
 126
 127                 wnd_opts.width = lexical_cast<unsigned>(m[1].str);
 128                 wnd_opts.height = lexical_cast<unsigned>(m[2].str);
 129         }
 130         gl_opts.gl_version_major = Graphics::GLOptions::LATEST_VERSION;
 131         gl_opts.core_profile = true;
 132 }
 133
 134 Viewer::Viewer(int argc, char **argv):
 135         opts(argc, argv),
 136         window(display, opts.wnd_opts),
 137         gl_device(window, opts.gl_opts),
 138         mouse(window),
 139         view(window),
 140         sequence(0),
 141         renderable(0),
 142         anim_object(0),
 143         anim_player(0),
 144         yaw(0),
 145         pitch(0),
 146         distance(10),
 147         light_yaw(0),
 148         light_pitch(0),
 149         dragging(0)
 150 {
 151         for(list<string>::const_iterator i=opts.resource_locations.begin(); i!=opts.resource_locations.end(); ++i)
 152         {
 153                 if(FS::is_dir(*i))
 154                         resources.add_directory(*i);
 155                 else
 156                 {
 157                         string ext = FS::extpart(*i);
 158                         if(ext==".mdp")
 159                                 resources.add_pack(*i);
 160                         else
 161                                 DataFile::load(resources, *i);
 162                 }
 163         }
 164
 165         GL::Object *object = 0;
 166
 167         string ext = FS::extpart(opts.renderable_name);
 168         if(ext==".mesh")
 169         {
 170                 GL::Mesh *mesh = 0;
 171                 if(FS::exists(opts.renderable_name))
 172                 {
 173                         mesh = new GL::Mesh;
 174                         DataFile::load(*mesh, opts.renderable_name);
 175                         resources.add("__"+opts.renderable_name, mesh);
 176                 }
 177                 else
 178                         mesh = &resources.get<GL::Mesh>(opts.renderable_name);
 179
 180                 object = new GL::Object;
 181                 GL::Technique *tech = new GL::Technique;
 182                 tech->add_method(0);
 183                 object->set_mesh(mesh);
 184                 object->set_technique(tech);
 185                 renderable = object;
 186
 187                 resources.add("__.tech", tech);
 188                 resources.add("__.object", object);
 189         }
 190         else if(ext==".object")
 191                 renderable = load<GL::Object>(opts.renderable_name);
 192         else if(ext==".scene")
 193         {
 194                 if(FS::exists(opts.renderable_name))
 195                 {
 196                         GL::Scene::GenericLoader ldr(resources);
 197                         IO::BufferedFile in(opts.renderable_name);
 198                         DataFile::Parser parser(in, opts.renderable_name);
 199                         ldr.load(parser);
 200                         renderable = ldr.get_object();
 201                 }
 202                 else
 203                         renderable = &resources.get<GL::Scene>(opts.renderable_name);
 204         }
 205         else if(ext==".seq")
 206         {
 207                 GL::SequenceTemplate *tmpl = load<GL::SequenceTemplate>(opts.renderable_name);
 208                 GL::SequenceBuilder bld(*tmpl);
 209                 bld.set_debug_name(FS::basename(opts.renderable_name));
 210                 sequence = bld.build(view);
 211         }
 212         else
 213                 throw usage_error("Unknown renderable type");
 214
 215         if(!opts.animation_name.empty())
 216         {
 217                 if(!object)
 218                         throw usage_error("Must have an object to animate");
 219
 220                 GL::Animation *anim = load<GL::Animation>(opts.animation_name);
 221                 anim_player = new GL::AnimationPlayer;
 222                 anim_object = new GL::AnimatedObject(*object);
 223                 anim_player->play(*anim_object, *anim);
 224                 renderable = anim_object;
 225         }
 226
 227         window.signal_close.connect(sigc::bind(sigc::mem_fun(this, &Viewer::exit), 0));
 228         mouse.signal_button_press.connect(sigc::bind_return(sigc::mem_fun(this, &Viewer::button_press), false));
 229         mouse.signal_button_release.connect(sigc::bind_return(sigc::mem_fun(this, &Viewer::button_release), false));
 230         mouse.signal_axis_motion.connect(sigc::bind_return(sigc::mem_fun(this, &Viewer::axis_motion), false));
 231
 232         light.set_direction(GL::Vector3(0, 0, -1));
 233         lighting.attach(light);
 234
 235         camera.set_debug_name("Camera");
 236         camera.set_up_direction(GL::Vector3(0, 0, 1));
 237         update_camera();
 238
 239         if(!sequence)
 240         {
 241                 sequence = new GL::Sequence();
 242                 sequence->set_debug_name("Sequence");
 243                 GL::Sequence::Step &step = sequence->add_step(0, *renderable);
 244                 step.set_lighting(&lighting);
 245                 step.set_depth_test(GL::LEQUAL);
 246         }
 247
 248         view.set_content(sequence);
 249         view.set_camera(&camera);
 250 }
 251
 252 template<typename T>
 253 T *Viewer::load(const string &name)
 254 {
 255         if(FS::exists(name))
 256         {
 257                 T *thing = new T;
 258                 DataFile::load(*thing, name, resources);
 259                 resources.add("__"+name, thing);
 260                 return thing;
 261         }
 262         else
 263                 return &resources.get<T>(name);
 264 }
 265
 266 Viewer::~Viewer()
 267 {
 268         delete anim_player;
 269         delete anim_object;
 270         delete sequence;
 271 }
 272
 273 int Viewer::main()
 274 {
 275         window.show();
 276         return Application::main();
 277 }
 278
 279 void Viewer::tick()
 280 {
 281         if(anim_player)
 282         {
 283                 Time::TimeStamp t = Time::now();
 284                 Time::TimeDelta dt;
 285                 if(last_tick)
 286                         dt = t-last_tick;
 287                 last_tick = t;
 288
 289                 anim_player->tick(dt);
 290         }
 291
 292         display.tick();
 293         view.render();
 294 }
 295
 296 void Viewer::button_press(unsigned btn)
 297 {
 298         if(btn==1)
 299         {
 300                 dragging = 1;
 301         }
 302         else if(btn==3)
 303         {
 304                 dragging = 3;
 305                 axis_motion(0, 0, 0);
 306         }
 307         else if(btn==4)
 308         {
 309                 distance *= 0.9;
 310                 update_camera();
 311         }
 312         else if(btn==5)
 313         {
 314                 distance *= 1.1;
 315                 update_camera();
 316         }
 317 }
 318
 319 void Viewer::button_release(unsigned btn)
 320 {
 321         if(btn==dragging)
 322                 dragging = 0;
 323 }
 324
 325 void Viewer::axis_motion(unsigned axis, float, float delta)
 326 {
 327         if(dragging==1)
 328         {
 329                 float dx = (axis==0 ? delta : 0);
 330                 float dy = (axis==1 ? delta : 0);
 331
 332                 yaw -= dx*M_PI*2;
 333                 while(yaw>M_PI)
 334                         yaw -= M_PI*2;
 335                 while(yaw<-M_PI)
 336                         yaw += M_PI*2;
 337
 338                 pitch += dy*M_PI;
 339                 if(pitch>M_PI*0.49)
 340                         pitch = M_PI*0.49;
 341                 if(pitch<-M_PI*0.49)
 342                         pitch = -M_PI*0.49;
 343
 344                 update_camera();
 345         }
 346         else if(dragging==3)
 347         {
 348                 float x = mouse.get_axis_value(0);
 349                 float y = mouse.get_axis_value(1);
 350
 351                 light_yaw = yaw+x*M_PI;
 352                 light_pitch = pitch-y*M_PI;
 353
 354                 update_light();
 355         }
 356 }
 357
 358 void Viewer::update_camera()
 359 {
 360         float cy = cos(yaw);
 361         float sy = sin(yaw);
 362         float cp = cos(pitch);
 363         float sp = sin(pitch);
 364         camera.set_position(GL::Vector3(-cy*cp*distance, -sy*cp*distance, -sp*distance));
 365         camera.set_depth_clip(distance*0.02, distance*50);
 366         camera.look_at(GL::Vector3(0, 0, 0));
 367 }
 368
 369 void Viewer::update_light()
 370 {
 371         float cy = cos(light_yaw);
 372         float sy = sin(light_yaw);
 373         float cp = cos(light_pitch);
 374         float sp = sin(light_pitch);
 375         light.set_direction(GL::Vector3(cy*cp, sy*cp, sp));
 376 }
 377
 378
 379 Viewer::Resources::Resources()
 380 {
 381         add_source(dir_source);
 382         add_source(pack_source);
 383 }
 384
 385 void Viewer::Resources::add_directory(const string &dir)
 386 {
 387         dir_source.add_directory(dir);
 388 }
 389
 390 void Viewer::Resources::add_pack(const string &pack)
 391 {
 392         pack_source.add_pack_file(pack);
 393 }