source/3d/layout.cpp

   1 #include <algorithm>
   2 #include <fstream>
   3 #include <msp/gl/rendermode.h>
   4 #include <msp/gl/select.h>
   5 #include <msp/gl/texture.h>
   6 #include <msp/datafile/parser.h>
   7 #include "layout.h"
   8
   9 using namespace std;
  10 using namespace Msp;
  11
  12 namespace Marklin {
  13
  14 Layout3D::Layout3D(Layout &l):
  15         layout(l),
  16         quality(4)
  17 {
  18         layout.signal_track_added.connect(sigc::mem_fun(this, &Layout3D::track_added));
  19         layout.signal_track_removed.connect(sigc::mem_fun(this, &Layout3D::track_removed));
  20 }
  21
  22 Layout3D::~Layout3D()
  23 {
  24         for(list<Track3D *>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
  25                 delete *i;
  26 }
  27
  28 void Layout3D::set_quality(unsigned q)
  29 {
  30         quality=q;
  31         for(list<Track3D *>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
  32                 (*i)->set_quality(quality);
  33 }
  34
  35 void Layout3D::render(bool endpoints) const
  36 {
  37         GL::Texture::unbind();
  38         glEnable(GL_DEPTH_TEST);
  39
  40         for(list<Track3D *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
  41                 (*i)->render();
  42
  43         if(endpoints)
  44         {
  45                 glDepthMask(false);
  46                 for(list<Track3D *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
  47                         (*i)->render_endpoints();
  48                 glDepthMask(true);
  49         }
  50 }
  51
  52 Track3D &Layout3D::get_track(const Track &t) const
  53 {
  54         for(list<Track3D *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
  55                 if(&(*i)->get_track()==&t)
  56                         return **i;
  57
  58         throw KeyError("Unknown track");
  59 }
  60
  61 Track3D *Layout3D::pick_track(float x, float y, float size) const
  62 {
  63         vector<GL::SelectRecord> select_buf;
  64         GL::select_buffer(select_buf);
  65         GL::render_mode(GL::SELECT);
  66
  67         glPushMatrix();
  68         glLoadIdentity();
  69
  70         double clip[4];
  71         clip[0]=1;
  72         clip[1]=0;
  73         clip[2]=x-size;
  74         clip[3]=0;
  75         glClipPlane(GL_CLIP_PLANE0, clip);
  76         glEnable(GL_CLIP_PLANE0);
  77
  78         clip[0]=-1;
  79         clip[2]=-(x+size);
  80         glClipPlane(GL_CLIP_PLANE1, clip);
  81         glEnable(GL_CLIP_PLANE1);
  82
  83         clip[0]=0;
  84         clip[1]=1;
  85         clip[2]=y-size;
  86         glClipPlane(GL_CLIP_PLANE2, clip);
  87         glEnable(GL_CLIP_PLANE2);
  88
  89         clip[1]=-1;
  90         clip[2]=-(y+size);
  91         glClipPlane(GL_CLIP_PLANE3, clip);
  92         glEnable(GL_CLIP_PLANE3);
  93
  94         glPopMatrix();
  95
  96         render();
  97
  98         glDisable(GL_CLIP_PLANE0);
  99         glDisable(GL_CLIP_PLANE1);
 100         glDisable(GL_CLIP_PLANE2);
 101         glDisable(GL_CLIP_PLANE3);
 102
 103         GL::render_mode(GL::RENDER);
 104         Track3D *track=0;
 105         unsigned track_depth=numeric_limits<unsigned>::max();
 106         for(vector<GL::SelectRecord>::iterator i=select_buf.begin(); i!=select_buf.end(); ++i)
 107                 if(i->min_depth<track_depth)
 108                 {
 109                         track=reinterpret_cast<Track3D *>(i->names.back());
 110                         track_depth=i->min_depth;
 111                 }
 112
 113         return track;
 114 }
 115
 116 void Layout3D::track_added(Track &t)
 117 {
 118         tracks.push_back(new Track3D(t, quality));
 119 }
 120
 121 void Layout3D::track_removed(Track &t)
 122 {
 123         for(list<Track3D *>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 124                 if(&(*i)->get_track()==&t)
 125                 {
 126                         delete *i;
 127                         tracks.erase(i);
 128                         return;
 129                 }
 130 }
 131
 132 } // namespace Marklin