source/engineer/engineer.cpp

   1 #include <algorithm>
   2 #include <cmath>
   3 #include <cstdlib>
   4 #include <limits>
   5 #include <signal.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/blend.h>
  11 #include <msp/gl/framebuffer.h>
  12 #include <msp/gl/matrix.h>
  13 #include <msp/gl/misc.h>
  14 #include <msp/gl/tests.h>
  15 #include <msp/gltk/floatingarrangement.h>
  16 #include <msp/io/print.h>
  17 #include <msp/strings/format.h>
  18 #include <msp/time/units.h>
  19 #include <msp/time/utils.h>
  20 #include "libr2c2/driver.h"
  21 #include "libr2c2/trackcircuit.h"
  22 #include "libr2c2/tracktype.h"
  23 #include "3d/allocation.h"
  24 #include "3d/path.h"
  25 #include "3d/track.h"
  26 #include "3d/trackcircuit.h"
  27 #include "3d/vehicle.h"
  28 #include "dynamicdialog.h"
  29 #include "engineer.h"
  30 #include "mainwindow.h"
  31 #include "newtraindialog.h"
  32 #include "traindialog.h"
  33
  34 using namespace std;
  35 using namespace R2C2;
  36 using namespace Msp;
  37
  38 Engineer::Engineer(int argc, char **argv):
  39         options(argc, argv),
  40         window(options.screen_w, options.screen_h, options.fullscreen),
  41         keyboard(window),
  42         mouse(window),
  43         ui_res("data/r2c2.res"),
  44         import_active(false),
  45         layout(catalogue, (options.driver.empty() ? 0 : Driver::create(options.driver))),
  46         layout_3d(layout),
  47         server(0),
  48         main_view(layout_3d, window.get_width(), window.get_height()),
  49         emergency_blink_state(0)
  50 {
  51         // Setup GUI
  52         window.set_title("Railroad Engineer");
  53         window.signal_close.connect(sigc::bind(sigc::mem_fun(this, &Engineer::exit), 0));
  54
  55         root = new GLtk::Root(ui_res, &window, &keyboard, &mouse);
  56         GLtk::Layout *root_layout = new GLtk::Layout;
  57         root->set_layout(root_layout);
  58         root_layout->set_margin(GLtk::Sides());
  59         root_arrangement = new GLtk::FloatingArrangement(*root_layout);
  60         mouse.signal_button_press.connect(sigc::bind_return(sigc::mem_fun(this, &Engineer::button_press), false));
  61         mouse.signal_axis_motion.connect(sigc::bind_return(sigc::mem_fun(this, &Engineer::axis_motion), false));
  62         root->set_visible(true);
  63
  64         main_wnd = new MainWindow(*this);
  65         root->add(*main_wnd);
  66         main_wnd->autosize();
  67         main_wnd->set_position(0, window.get_height()-main_wnd->get_geometry().h);
  68
  69         overlay = new Overlay3D(ui_res.get_default_font());
  70
  71         // Setup railroad control
  72         catalogue.add_source("data/Märklin/H0");
  73         DataFile::load(layout, options.layout_fn);
  74
  75         if(layout.has_driver())
  76         {
  77                 Driver &driver = layout.get_driver();
  78                 driver.signal_locomotive_detected.connect(sigc::mem_fun(this, &Engineer::locomotive_detected));
  79                 driver.signal_halt.connect(sigc::mem_fun(this, &Engineer::halt_event));
  80         }
  81         layout.signal_train_added.connect(sigc::mem_fun(this, &Engineer::train_added));
  82         layout.signal_emergency.connect(sigc::mem_fun(this, &Engineer::emergency));
  83         const set<Block *> &blocks = layout.get_all<Block>();
  84         for(set<Block *>::const_iterator i=blocks.begin(); i!=blocks.end(); ++i)
  85                 if(TrackCircuit *tc = (*i)->get_sensor())
  86                         new TrackCircuit3D(layout_3d, *tc);
  87
  88         const set<Track *> &tracks = layout.get_all<Track>();
  89         for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
  90                 if((*i)->get_type().is_turnout())
  91                         new Path3D(layout_3d.get_3d(**i));
  92
  93         if(FS::exists(options.state_fn))
  94                 DataFile::load(layout, options.state_fn);
  95
  96         if(options.network)
  97         {
  98                 server = new Server(layout);
  99                 server->use_event_dispatcher(event_disp);
 100         }
 101
 102         // Setup 3D view
 103         GL::Pipeline &pipeline = main_view.get_pipeline();
 104
 105         GL::Pipeline::Pass *pass = &pipeline.add_pass("unlit");
 106         pass->set_depth_test(&GL::DepthTest::lequal());
 107         pipeline.add_renderable_for_pass(layout_3d.get_path_scene(), "unlit");
 108
 109         pass = &pipeline.add_pass("overlay");
 110         pass->set_blend(&GL::Blend::alpha());
 111         pipeline.add_renderable_for_pass(*overlay, "overlay");
 112
 113         view_all();
 114
 115         // Catch various signals so we can stop the trains in case we get terminated
 116         catch_signal(SIGINT);
 117         catch_signal(SIGTERM);
 118         catch_signal(SIGSEGV);
 119         catch_signal(SIGILL);
 120         catch_signal(SIGFPE);
 121         catch_signal(SIGABRT);
 122 }
 123
 124 Engineer::~Engineer()
 125 {
 126         if(!options.simulate)
 127         {
 128                 layout.save_dynamic(options.state_fn+".tmp");
 129                 FS::rename(options.state_fn+".tmp", options.state_fn);
 130         }
 131
 132         layout.get_driver().halt(true);
 133         layout.get_driver().flush();
 134
 135         delete overlay;
 136         delete root_arrangement;
 137         delete root;
 138
 139         delete server;
 140 }
 141
 142 void Engineer::set_status(const string &text)
 143 {
 144         main_wnd->set_status_text(text);
 145         status_timeout = Time::now()+10*Time::sec;
 146 }
 147
 148 void Engineer::add_dynamic_dialog(DynamicDialog &tv)
 149 {
 150         dyn_dialogs.push_back(&tv);
 151 }
 152
 153 void Engineer::remove_dynamic_dialog(DynamicDialog &tv)
 154 {
 155         dyn_dialogs.erase(remove(dyn_dialogs.begin(), dyn_dialogs.end(), &tv), dyn_dialogs.end());
 156 }
 157
 158 int Engineer::main()
 159 {
 160         window.show();
 161
 162         return Application::main();
 163 }
 164
 165 void Engineer::tick()
 166 {
 167         window.get_display().tick();
 168
 169         for(list<Train *>::iterator i=new_trains.begin(); i!=new_trains.end(); ++i)
 170                 process_new_train(**i);
 171         new_trains.clear();
 172
 173         layout.tick(options.sim_speed);
 174         layout_3d.tick();
 175         event_disp.tick(Time::zero);
 176
 177         for(list<DynamicDialog *>::iterator i=dyn_dialogs.begin(); i!=dyn_dialogs.end(); ++i)
 178                 (*i)->update();
 179
 180         Time::TimeStamp t = Time::now();
 181         if(status_timeout && t>status_timeout)
 182         {
 183                 main_wnd->set_status_text(string());
 184                 status_timeout = Time::TimeStamp();
 185         }
 186         if(!emergencies.empty() && t>emergency_blink_timeout)
 187         {
 188                 emergency_blink_state = (emergency_blink_state+1)%2;
 189                 GL::Color color(1.0f/(1+emergency_blink_state), 0.0f, 0.0f);
 190                 for(list<TrackChain3D *>::iterator i=emergencies.begin(); i!=emergencies.end(); ++i)
 191                         (*i)->set_color(color);
 192                 emergency_blink_timeout = t+0.5*Time::sec;
 193         }
 194
 195         GL::Framebuffer::system().clear(GL::COLOR_BUFFER_BIT|GL::DEPTH_BUFFER_BIT);
 196
 197         main_view.render();
 198
 199         root->render();
 200
 201         window.swap_buffers();
 202 }
 203
 204 void Engineer::button_press(unsigned btn)
 205 {
 206         if(btn==1)
 207         {
 208                 Object *obj = pick_object(pointer);
 209                 if(Track *track = dynamic_cast<Track *>(obj))
 210                 {
 211                         if(track->get_type().is_turnout())
 212                         {
 213                                 Block &block = track->get_block();
 214                                 if(block.get_train() && block.get_train()->is_block_critical(block))
 215                                         set_status("Turnout is busy");
 216                                 else
 217                                 {
 218                                         unsigned paths = track->get_type().get_paths();
 219                                         unsigned i = track->get_active_path()+1;
 220                                         while(!(paths&(1<<i)))
 221                                         {
 222                                                 if(!(paths>>i))
 223                                                         i = 0;
 224                                                 else
 225                                                         ++i;
 226                                         }
 227                                         track->set_active_path(i);
 228                                         set_status(format("Turnout %d", track->get_turnout_address()));
 229                                 }
 230                         }
 231                         if(unsigned saddr = track->get_sensor_address())
 232                         {
 233                                 if(options.simulate)
 234                                         layout.get_driver().set_sensor(saddr, !layout.get_driver().get_sensor(saddr));
 235                                 set_status(format("Sensor %d", saddr));
 236                         }
 237                 }
 238                 else if(Vehicle *veh = dynamic_cast<Vehicle *>(obj))
 239                 {
 240                         TrainDialog *dlg = new TrainDialog(*this, *veh->get_train());
 241                         root->add(*dlg);
 242                         dlg->autosize();
 243                 }
 244         }
 245 }
 246
 247 void Engineer::axis_motion(unsigned axis, float value, float)
 248 {
 249         if(axis==0)
 250                 pointer.x = value;
 251         if(axis==1)
 252                 pointer.y = value;
 253 }
 254
 255 void Engineer::view_all()
 256 {
 257         const Layout3D::ObjectMap &objects = layout_3d.get_all();
 258
 259         float view_aspect = float(window.get_width())/window.get_height();
 260         float view_height = tan(main_view.get_camera().get_field_of_view()/2.0f)*2.0f;
 261         float best_score = 0;
 262         GL::Vector3 pos;
 263         GL::Vector3 up;
 264         for(Angle angle; angle<Angle::half_turn(); angle+=Angle::from_radians(0.01))
 265         {
 266                 Transform trans = Transform::rotation(-angle, Vector(0, 0, 1));
 267                 BoundingBox bbox;
 268                 for(Layout3D::ObjectMap::const_iterator i=objects.begin(); i!=objects.end(); ++i)
 269                         bbox = bbox|trans.transform(i->second->get_object().get_bounding_box());
 270
 271                 const Vector &minp = bbox.get_minimum_point();
 272                 const Vector &maxp = bbox.get_maximum_point();
 273
 274                 float width = maxp.x-minp.x;
 275                 float height = maxp.y-minp.y;
 276                 float aspect = width/height;
 277                 float score = min(aspect/view_aspect, view_aspect/aspect);
 278
 279                 if(score>best_score)
 280                 {
 281                         best_score = score;
 282
 283                         float size = max(width/view_aspect, height);
 284                         float c = cos(angle);
 285                         float s = sin(angle);
 286                         float x = (minp.x+maxp.x)/2;
 287                         float y = (minp.y+maxp.y)/2;
 288                         float z = max(size*1.05/view_height, 0.15);
 289
 290                         pos = GL::Vector3(c*x-s*y, s*x+c*y, z);
 291                         up = GL::Vector3(-s, c, 0);
 292                 }
 293         }
 294
 295         GL::Camera &camera = main_view.get_camera();
 296         camera.set_position(pos);
 297         camera.set_up_direction(up);
 298         camera.set_look_direction(GL::Vector3(0, 0, -1));
 299         camera.set_aspect(float(window.get_width())/window.get_height());
 300         camera.set_depth_clip(pos.z*0.5, pos.z*1.5);
 301 }
 302
 303 Object *Engineer::pick_object(const Vector &p)
 304 {
 305         const GL::Vector3 &start = main_view.get_camera().get_position();
 306         GL::Vector4 ray = main_view.get_camera().unproject(GL::Vector4(p.x, p.y, 0, 0));
 307
 308         // XXX Do this better; make this function a template?
 309         if(Vehicle *veh = layout.pick<Vehicle>(Ray(start, ray.slice<3>(0))))
 310                 return veh;
 311         return layout.pick<Track>(Ray(start, ray.slice<3>(0)));
 312 }
 313
 314 void Engineer::emergency(Block *block, const string &msg)
 315 {
 316         set_status(msg);
 317         if(block)
 318         {
 319                 TrackChain3D *tch3d = new TrackChain3D(layout_3d, *block);
 320                 tch3d->set_color(GL::Color(1.0f, 0.0f, 0.0f));
 321                 tch3d->set_layer(2);
 322                 emergencies.push_back(tch3d);
 323         }
 324 }
 325
 326 void Engineer::halt_event(bool h)
 327 {
 328         if(!h)
 329         {
 330                 for(list<TrackChain3D *>::iterator i=emergencies.begin(); i!=emergencies.end(); ++i)
 331                         delete *i;
 332                 emergencies.clear();
 333         }
 334 }
 335
 336 void Engineer::locomotive_detected(const Driver::DetectedLocomotive &loco)
 337 {
 338         if(!import_active)
 339         {
 340                 NewTrainDialog *dlg = new NewTrainDialog(*this);
 341                 dlg->prefill(loco);
 342                 dlg->signal_response.connect(sigc::mem_fun(this, &Engineer::import_finished));
 343                 root->add(*dlg);
 344                 import_active = true;
 345         }
 346 }
 347
 348 void Engineer::import_finished(int)
 349 {
 350         import_active = false;
 351 }
 352
 353 void Engineer::process_new_train(Train &train)
 354 {
 355         Vehicle3D &loco3d = layout_3d.get_3d(train.get_vehicle(0));
 356         overlay->set_label(loco3d, train.get_name());
 357         train.signal_name_changed.connect(sigc::bind<0>(sigc::mem_fun(overlay, &Overlay3D::set_label), sigc::ref(loco3d)));
 358 }
 359
 360 void Engineer::train_added(Train &train)
 361 {
 362         new_trains.push_back(&train);
 363
 364         GL::Color best_color;
 365         float best_d_sq = 0;
 366         for(unsigned i=0; i<10; ++i)
 367         {
 368                 GL::Color color;
 369                 unsigned h = rand()%3;
 370                 color.r = (h==0 ? 0.0 : rand()*1.0/RAND_MAX);
 371                 color.g = (h==1 ? 0.0 : rand()*1.0/RAND_MAX);
 372                 color.b = (h==2 ? 0.0 : rand()*1.0/RAND_MAX);
 373                 color = color*(1/max(max(color.r, color.g), color.b));
 374                 float min_d_sq = 3;
 375                 for(map<Train *, GL::Color>::const_iterator j=train_colors.begin(); j!=train_colors.end(); ++j)
 376                 {
 377                         float dr = color.r-j->second.r;
 378                         float dg = color.g-j->second.g;
 379                         float db = color.b-j->second.b;
 380                         float d_sq = dr*dr+dg*dg+db*db;
 381                         if(d_sq<min_d_sq)
 382                                 min_d_sq = d_sq;
 383                 }
 384                 if(min_d_sq>best_d_sq)
 385                 {
 386                         best_color = color;
 387                         best_d_sq = min_d_sq;
 388                 }
 389         }
 390         train_colors[&train] = best_color;
 391
 392         Allocation3D *alloc = new Allocation3D(layout_3d, train);
 393         alloc->set_color(best_color);
 394 }
 395
 396 void Engineer::sighandler(int sig)
 397 {
 398         if(sig==SIGSEGV || sig==SIGILL || sig==SIGFPE || sig==SIGABRT)
 399         {
 400                 signal(sig, SIG_DFL);
 401                 IO::print(IO::cerr, "Fatal signal received, terminating\n");
 402                 layout.get_driver().halt(true);
 403                 layout.get_driver().flush();
 404                 raise(sig);
 405         }
 406         else if(sig==SIGTERM || sig==SIGINT)
 407                 exit(0);
 408 }