source/designer/designer.cpp

   1 #include <signal.h>
   2 #include <algorithm>
   3 #include <cmath>
   4 #include <msp/fs/utils.h>
   5 #include <msp/gl/blend.h>
   6 #include <msp/gl/framebuffer.h>
   7 #include <msp/gl/matrix.h>
   8 #include <msp/gl/misc.h>
   9 #include <msp/gl/tests.h>
  10 #include <msp/gl/texture2d.h>
  11 #include <msp/input/keys.h>
  12 #include <msp/io/print.h>
  13 #include <msp/stringcodec/codec.h>
  14 #include <msp/stringcodec/utf8.h>
  15 #include <msp/strings/lexicalcast.h>
  16 #include <msp/strings/utils.h>
  17 #include <msp/time/units.h>
  18 #include <msp/time/utils.h>
  19 #include "libr2c2/route.h"
  20 #include "libr2c2/terrain.h"
  21 #include "libr2c2/tracktype.h"
  22 #include "libr2c2/zone.h"
  23 #include "3d/path.h"
  24 #include "designer.h"
  25 #include "elevatetool.h"
  26 #include "extendtool.h"
  27 #include "input.h"
  28 #include "layoutbar.h"
  29 #include "manipulator.h"
  30 #include "measure.h"
  31 #include "movetool.h"
  32 #include "objectproperties.h"
  33 #include "objectselecttool.h"
  34 #include "rotatetool.h"
  35 #include "routebar.h"
  36 #include "selection.h"
  37 #include "slopetool.h"
  38 #include "svgexporter.h"
  39 #include "terraintool.h"
  40 #include "trackbar.h"
  41 #include "zonebar.h"
  42 #include "zoneproperties.h"
  43
  44 using namespace std;
  45 using namespace R2C2;
  46 using namespace Msp;
  47
  48 Designer::Designer(int argc, char **argv):
  49         window(1280, 960),
  50         keyboard(window),
  51         mouse(window),
  52         ui_res("r2c2.res"),
  53         root(ui_res, &window, &keyboard, &mouse),
  54         base_object(0),
  55         cur_route(0),
  56         cur_zone(0),
  57         mode(TOOL),
  58         sel_wrap(selection),
  59         cur_tool(0),
  60         keep_status(0)
  61 {
  62         window.set_title("Railway Designer");
  63         window.signal_close.connect(sigc::bind(sigc::mem_fun(this, &Designer::exit), 0));
  64
  65         // Setup catalogue and layout
  66         DataFile::load(catalogue, "tracks.dat");
  67         DataFile::load(catalogue, "terrain.dat");
  68
  69         cat_layout_3d = new Layout3D(catalogue.get_layout());
  70
  71         layout = new Layout(catalogue);
  72         layout_3d = new Layout3D(*layout);
  73
  74         if(argc>1)
  75         {
  76                 filename = argv[1];
  77                 DataFile::load(*layout, argv[1]);
  78
  79                 if(!layout->get_base().empty())
  80                 {
  81                         base_object = new GL::Object;
  82                         DataFile::load(*base_object, layout->get_base());
  83                 }
  84         }
  85
  86         // Setup OpenGL
  87         cat_view = new View3D(*cat_layout_3d, window.get_width(), window.get_height());
  88
  89         main_view = new View3D(*layout_3d, window.get_width(), window.get_height());
  90         GL::Pipeline *pipeline = &main_view->get_pipeline();
  91
  92         GL::Pipeline::Pass *pass = &pipeline->add_pass("unlit");
  93         pass->set_depth_test(&GL::DepthTest::lequal());
  94         pass->set_blend(&GL::Blend::alpha());
  95
  96         pass = &pipeline->add_pass("blended");
  97         pass->set_lighting(&layout_3d->get_lighting());
  98         pass->set_depth_test(&GL::DepthTest::lequal());
  99         pass->set_blend(&GL::Blend::alpha());
 100
 101         pass = &pipeline->add_pass("overlay");
 102         pass->set_blend(&GL::Blend::alpha());
 103
 104         if(base_object)
 105                 pipeline->add_renderable(*base_object);
 106         pipeline->add_renderable_for_pass(layout_3d->get_path_scene(), "unlit");
 107         pipeline->add_renderable_for_pass(layout_3d->get_endpoint_scene(), "unlit");
 108
 109         // Setup UI
 110         keyboard.signal_button_press.connect(sigc::bind_return(sigc::mem_fun(this, &Designer::key_press), false));
 111         mouse.signal_button_press.connect(sigc::bind_return(sigc::mem_fun(this, &Designer::button_press), false));
 112         root.signal_tooltip.connect(sigc::mem_fun(this, &Designer::tooltip));
 113         root_layout = new GLtk::Layout;
 114         root_layout->set_margin(0);
 115         root.set_layout(root_layout);
 116
 117         toolbars.push_back(new Layoutbar(*this));
 118         toolbars.push_back(new Trackbar(*this));
 119         toolbars.push_back(new Routebar(*this));
 120         toolbars.push_back(new Zonebar(*this));
 121         Toolbar *prev = 0;
 122         for(vector<Toolbar *>::iterator i=toolbars.begin(); i!=toolbars.end(); ++i)
 123         {
 124                 root.add(**i);
 125                 if(i!=toolbars.begin())
 126                         (*i)->expand(false);
 127                 (*i)->signal_expanded.connect(sigc::hide(sigc::mem_fun(root_layout, &GLtk::Layout::update)));
 128                 if(prev)
 129                 {
 130                         root_layout->add_constraint(**i, GLtk::Layout::RIGHT_OF, *prev, 0);
 131                         root_layout->add_constraint(**i, GLtk::Layout::COPY_HEIGHT, *prev);
 132                 }
 133                 prev = *i;
 134         }
 135
 136         GLtk::Panel *statusbar = new GLtk::Panel;
 137         root.add(*statusbar);
 138         statusbar->set_focusable(false);
 139         root_layout->set_gravity(*statusbar, -1, -1);
 140         root_layout->set_expand(*statusbar, true, false);
 141
 142         lbl_status = new GLtk::Label;
 143         statusbar->add(*lbl_status);
 144         lbl_status->set_geometry(GLtk::Geometry(20, 2, 300, 16));
 145
 146         pipeline->add_renderable_for_pass(sel_wrap, "unlit");
 147         overlay = new Overlay3D(ui_res.get_default_font());
 148         pipeline->add_renderable_for_pass(*overlay, "overlay");
 149
 150         camera_ctl = new CameraController(*main_view, keyboard, mouse);
 151         cat_view->get_camera().set_look_direction(GL::Vector3(0, 0.13053, -0.99144));
 152         cat_view->view_all(true);
 153         main_view->view_all();
 154
 155         const set<Object *> &objects = layout->get_all<Object>();
 156         for(set<Object *>::const_iterator i=objects.begin(); i!=objects.end(); ++i)
 157                 update_object_icon(**i);
 158 }
 159
 160 Designer::~Designer()
 161 {
 162         for(vector<Toolbar *>::iterator i=toolbars.begin(); i!=toolbars.end(); ++i)
 163                 delete *i;
 164         delete camera_ctl;
 165         delete overlay;
 166         delete main_view;
 167         delete base_object;
 168         delete layout_3d;
 169         delete layout;
 170         delete cat_view;
 171         delete cat_layout_3d;
 172 }
 173
 174 int Designer::main()
 175 {
 176         window.show();
 177
 178         use_select_tool();
 179
 180         return Application::main();
 181 }
 182
 183 void Designer::save()
 184 {
 185         InputDialog *input = new InputDialog(*this, "Save layout", filename);
 186         input->signal_accept.connect(sigc::mem_fun(layout, &Layout::save));
 187         root.add(*input);
 188         root_layout->set_gravity(*input, 0, 0);
 189 }
 190
 191 void Designer::quit()
 192 {
 193         exit(0);
 194 }
 195
 196 void Designer::new_object()
 197 {
 198         use_select_tool();
 199
 200         mode = CATALOGUE;
 201         lbl_status->set_text("Select new object or press Esc to cancel");
 202 }
 203
 204 void Designer::erase_objects()
 205 {
 206         use_select_tool();
 207
 208         set<Object *> objects = selection.get_objects();
 209         selection.clear();
 210         for(set<Object *>::iterator i=objects.begin(); i!=objects.end(); ++i)
 211         {
 212                 overlay->clear(layout_3d->get_3d(**i));
 213                 delete *i;
 214         }
 215 }
 216
 217 void Designer::object_properties()
 218 {
 219         use_select_tool();
 220         if(selection.empty())
 221                 return;
 222
 223         ObjectProperties *dlg = new ObjectProperties(selection);
 224         root.add(*dlg);
 225         root_layout->set_gravity(*dlg, 0, 0);
 226
 227         dlg->signal_response.connect(sigc::mem_fun(this, &Designer::object_properties_response));
 228 }
 229
 230 void Designer::extend_track()
 231 {
 232         use_tool_with_selected_objects<ExtendTool>();
 233 }
 234
 235 void Designer::connect_tracks()
 236 {
 237         use_tool_with_selected_objects<ExtendTool>()->connect();
 238 }
 239
 240 void Designer::flatten_tracks()
 241 {
 242         use_tool_with_selected_objects<SlopeTool>()->flatten();
 243 }
 244
 245 void Designer::svg_export()
 246 {
 247         InputDialog *input = new InputDialog(*this, "SVG export", FS::basepart(filename)+".svg");
 248         input->signal_accept.connect(sigc::mem_fun(this, &Designer::svg_export_accept));
 249         root.add(*input);
 250         root_layout->set_gravity(*input, 0, 0);
 251 }
 252
 253 void Designer::edit_route(Route *r)
 254 {
 255         cur_route = r;
 256         cur_zone = 0;
 257         if(cur_route)
 258                 show_route(*cur_route);
 259         else
 260                 clear_paths();
 261 }
 262
 263 void Designer::rename_route()
 264 {
 265         use_select_tool();
 266         if(!cur_route)
 267                 return;
 268
 269         InputDialog *input = new InputDialog(*this, "Route name", cur_route->get_name());
 270         input->signal_accept.connect(sigc::mem_fun(this, &Designer::route_name_accept));
 271         root.add(*input);
 272         root_layout->set_gravity(*input, 0, 0);
 273 }
 274
 275 void Designer::add_selection_to_route()
 276 {
 277         if(!cur_route)
 278                 return;
 279
 280         try
 281         {
 282                 cur_route->add_tracks(selection.get_objects<Track>());
 283         }
 284         catch(const exception &e)
 285         {
 286                 lbl_status->set_text(e.what());
 287         }
 288
 289         show_route(*cur_route);
 290 }
 291
 292 void Designer::edit_zone(Zone *z)
 293 {
 294         cur_zone = z;
 295         cur_route = 0;
 296         if(cur_zone)
 297                 show_zone(*cur_zone);
 298         else
 299                 clear_paths();
 300 }
 301
 302 void Designer::zone_properties()
 303 {
 304         if(!cur_zone)
 305                 return;
 306
 307         ZoneProperties *zone_prop = new ZoneProperties(*cur_zone);
 308         root.add(*zone_prop);
 309         const GLtk::Geometry &root_geom = root.get_geometry();
 310         const GLtk::Geometry &dlg_geom = zone_prop->get_geometry();
 311         zone_prop->set_position((root_geom.w-dlg_geom.w)/2, (root_geom.h-dlg_geom.h)/2);
 312 }
 313
 314 void Designer::add_selection_to_zone()
 315 {
 316         if(!cur_zone)
 317                 return;
 318
 319         try
 320         {
 321                 cur_zone->add_tracks(selection.get_objects<Track>());
 322         }
 323         catch(const exception &e)
 324         {
 325                 lbl_status->set_text(e.what());
 326         }
 327
 328         show_zone(*cur_zone);
 329 }
 330
 331 Vector Designer::map_pointer_to_ground(const Vector &p)
 332 {
 333         GL::Vector4 vec = main_view->get_camera().unproject(GL::Vector4(p.x, p.y, 0, 0));
 334         const GL::Vector3 &pos = main_view->get_camera().get_position();
 335
 336         return pos-GL::Vector3(vec.x, vec.y, vec.z)*(pos.z/vec.z);
 337 }
 338
 339 void Designer::tick()
 340 {
 341         const Msp::Time::TimeStamp t = Msp::Time::now();
 342         float dt = (t-last_tick)/Msp::Time::sec;
 343         last_tick = t;
 344
 345         if(cur_tool && cur_tool->is_done())
 346         {
 347                 cur_tool->update_selection(selection);
 348                 use_select_tool();
 349         }
 350         keep_status = 0;
 351
 352         window.tick();
 353         root.tick();
 354         camera_ctl->tick(dt);
 355
 356         render();
 357
 358         window.swap_buffers();
 359 }
 360
 361 void Designer::key_press(unsigned key)
 362 {
 363         bool shift = keyboard.get_button_state(Input::KEY_SHIFT_L) || keyboard.get_button_state(Input::KEY_SHIFT_R);
 364
 365         if(key==Msp::Input::KEY_N && shift)
 366                 use_tool_with_selected_objects<ExtendTool>();
 367         else if(key==Msp::Input::KEY_N)
 368                 new_object();
 369         else if(key==Msp::Input::KEY_G)
 370                 use_tool_with_selected_objects<MoveTool>();
 371         else if(key==Msp::Input::KEY_R)
 372                 use_tool_with_selected_objects<RotateTool>();
 373         else if(key==Msp::Input::KEY_D)
 374         {
 375                 const set<Object *> &sel_objs = selection.get_objects();
 376                 list<Object *> new_objs;
 377                 for(set<Object *>::iterator i=sel_objs.begin(); i!=sel_objs.end(); ++i)
 378                 {
 379                         Object *obj = (*i)->clone(layout);
 380                         for(list<Object *>::iterator j=new_objs.begin(); j!=new_objs.end(); ++j)
 381                                 obj->link_to(**j);
 382                         new_objs.push_back(obj);
 383                 }
 384
 385                 selection.replace(new_objs.begin(), new_objs.end());
 386
 387                 use_tool_with_selected_objects<MoveTool>();
 388         }
 389         else if(key==Msp::Input::KEY_W)
 390                 save();
 391         else if(key==Msp::Input::KEY_M)
 392                 use_tool<Measure>();
 393         else if(key==Msp::Input::KEY_Z)
 394                 use_tool_with_selected_objects<ElevateTool>();
 395         else if(key==Msp::Input::KEY_ESC)
 396         {
 397                 if(mode==CATALOGUE)
 398                         use_select_tool();
 399         }
 400         else if(key==Msp::Input::KEY_X)
 401                 erase_objects();
 402         else if(key==Msp::Input::KEY_F && shift)
 403         {
 404                 const set<Track *> &tracks = selection.get_objects<Track>();
 405                 const set<Track *> &ltracks = layout->get_all<Track>();
 406                 for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
 407                 {
 408                         (*i)->set_flex(!(*i)->get_flex());
 409                         (*i)->break_links();
 410                         for(set<Track *>::const_iterator j=ltracks.begin(); j!=ltracks.end(); ++j)
 411                                 if(*j!=*i)
 412                                         (*i)->snap_to(**j, true);
 413
 414                         update_object_icon(**i);
 415                 }
 416         }
 417         else if(key==Msp::Input::KEY_F)
 418                 use_tool_with_selected_objects<SlopeTool>()->flatten();
 419         else if(key==Msp::Input::KEY_E && shift)
 420                 use_tool_with_selected_objects<SlopeTool>()->even_slope(true);
 421         else if(key==Msp::Input::KEY_E)
 422                 use_tool_with_selected_objects<SlopeTool>()->even_slope();
 423         else if(key==Msp::Input::KEY_A)
 424         {
 425                 if(cur_route)
 426                         add_selection_to_route();
 427                 else if(cur_zone)
 428                         add_selection_to_zone();
 429         }
 430         else if(key==Msp::Input::KEY_C)
 431                 use_tool_with_selected_objects<ExtendTool>()->connect();
 432         else if(key==Msp::Input::KEY_V)
 433                 svg_export();
 434         else if(key==Msp::Input::KEY_P)
 435                 object_properties();
 436         else if(key==Msp::Input::KEY_TAB)
 437         {
 438                 Object *obj = selection.get_object();
 439                 if(Terrain *terrain = dynamic_cast<Terrain *>(obj))
 440                         use_tool(new TerrainTool(*this, keyboard, mouse, *terrain));
 441         }
 442 }
 443
 444 template<typename T>
 445 T *Designer::use_tool_with_selected_objects()
 446 {
 447         T *tool = new T(*this, keyboard, mouse, selection.get_objects());
 448         use_tool(tool);
 449         return tool;
 450 }
 451
 452 template<typename T>
 453 T *Designer::use_tool()
 454 {
 455         T *tool = new T(*this, keyboard, mouse);
 456         use_tool(tool);
 457         return tool;
 458 }
 459
 460 void Designer::use_tool(Tool *tool)
 461 {
 462         if(cur_tool)
 463         {
 464                 delete cur_tool;
 465                 cur_tool = 0;
 466         }
 467
 468         cur_tool = tool;
 469         cur_tool->signal_status.connect(sigc::mem_fun(this, &Designer::tool_status));
 470         if(keep_status<2)
 471                 tool_status(tool->get_status());
 472         mode = TOOL;
 473         keep_status = 1;
 474 }
 475
 476 void Designer::use_select_tool()
 477 {
 478         use_tool(new ObjectSelectTool(*this, keyboard, mouse, selection));
 479 }
 480
 481 void Designer::button_press(unsigned btn)
 482 {
 483         Vector pointer(mouse.get_axis_value(0), mouse.get_axis_value(1), 0);
 484         Vector ground = map_pointer_to_ground(pointer);
 485
 486         if(mode==CATALOGUE)
 487         {
 488                 Object *obj = 0;
 489                 if(btn==1)
 490                         obj = pick_object(pointer);
 491
 492                 if(obj)
 493                 {
 494                         obj = obj->clone(layout);
 495                         obj->set_position(ground);
 496
 497                         selection.clear();
 498                         selection.add_object(obj);
 499                 }
 500
 501                 if(obj || btn==3)
 502                         use_select_tool();
 503         }
 504 }
 505
 506 void Designer::render()
 507 {
 508         GL::Framebuffer::system().clear(GL::COLOR_BUFFER_BIT|GL::DEPTH_BUFFER_BIT);
 509
 510         View3D *view = (mode==CATALOGUE ? cat_view : main_view);
 511         view->render();
 512
 513         root.render();
 514 }
 515
 516 Object *Designer::pick_object(const Vector &pointer)
 517 {
 518         View3D &view = *(mode==CATALOGUE ? cat_view : main_view);
 519         const GL::Vector3 &cpos = view.get_camera().get_position();
 520         GL::Vector4 cray = view.get_camera().unproject(GL::Vector4(pointer.x, pointer.y, 0, 0));
 521
 522         return view.get_layout().get_layout().pick<Object>(Ray(cpos, Vector(cray)));
 523 }
 524
 525 void Designer::update_object_icon(Object &obj)
 526 {
 527         Object3D &obj3d = layout_3d->get_3d(obj);
 528         overlay->clear(obj3d);
 529
 530         if(Track *track = dynamic_cast<Track *>(&obj))
 531         {
 532                 if(track->get_flex())
 533                         overlay->add_graphic(obj3d, "flex");
 534
 535                 if(unsigned saddr = track->get_sensor_address())
 536                 {
 537                         overlay->add_graphic(obj3d, "trackcircuit");
 538                         overlay->set_label(obj3d, lexical_cast<string>(saddr));
 539                 }
 540                 else if(track->get_type().is_turnout())
 541                 {
 542                         unsigned taddr = track->get_turnout_address();
 543                         if(taddr<0x800)
 544                         {
 545                                 overlay->add_graphic(obj3d, "turnout");
 546                                 overlay->set_label(obj3d, lexical_cast<string>(taddr));
 547                         }
 548                 }
 549         }
 550         else if(Signal *signal = dynamic_cast<Signal *>(&obj))
 551         {
 552                 overlay->add_graphic(obj3d, "signal");
 553                 overlay->set_label(obj3d, lexical_cast<string>(signal->get_address()));
 554         }
 555         else if(BeamGate *gate = dynamic_cast<BeamGate *>(&obj))
 556         {
 557                 overlay->add_graphic(obj3d, "beamgate");
 558                 overlay->set_label(obj3d, lexical_cast<string>(gate->get_address()));
 559         }
 560 }
 561
 562 void Designer::tool_status(const string &status)
 563 {
 564         lbl_status->set_text(status);
 565         if(keep_status==1)
 566                 keep_status = 2;
 567 }
 568
 569 void Designer::object_properties_response(int)
 570 {
 571         const set<Object *> &objects = selection.get_objects();
 572         for(set<Object *>::const_iterator i=objects.begin(); i!=objects.end(); ++i)
 573                 update_object_icon(**i);
 574 }
 575
 576 void Designer::route_name_accept(const string &text)
 577 {
 578         if(cur_route)
 579                 cur_route->set_name(text);
 580 }
 581
 582 void Designer::svg_export_accept(const string &text)
 583 {
 584         SvgExporter svg_exp(*layout);
 585         svg_exp.save(text);
 586 }
 587
 588 string Designer::tooltip(int x, int y)
 589 {
 590         const GLtk::Geometry &rgeom = root.get_geometry();
 591         if(Object *obj = pick_object(Vector(x*2.0f/rgeom.w-1.0f, y*2.0f/rgeom.h-1.0f, 0)))
 592         {
 593                 const ObjectType &otype = obj->get_type();
 594                 string info = format("%d %s", otype.get_article_number(), otype.get_name());
 595                 if(Track *track = dynamic_cast<Track *>(obj))
 596                 {
 597                         if(mode!=CATALOGUE && abs(track->get_tilt()).radians()>1e-4)
 598                                 info += format(" (slope %.1f%%)", abs(tan(track->get_tilt())*100));
 599                         if(track->get_type().is_turnout())
 600                                 info += format(" (turnout %d)", track->get_turnout_address());
 601                         else if(track->get_sensor_address())
 602                                 info += format(" (sensor %d)", track->get_sensor_address());
 603                 }
 604                 if(mode==CATALOGUE)
 605                 {
 606                         const string &descr = otype.get_description();
 607                         if(!descr.empty())
 608                         {
 609                                 info += '\n';
 610                                 info += otype.get_description();
 611                         }
 612                 }
 613                 return info;
 614         }
 615
 616         return string();
 617 }
 618
 619 void Designer::clear_paths()
 620 {
 621         for(list<Path3D *>::iterator i=highlight_paths.begin(); i!=highlight_paths.end(); ++i)
 622                 delete *i;
 623         highlight_paths.clear();
 624 }
 625
 626 void Designer::show_route(const Route &route)
 627 {
 628         clear_paths();
 629
 630         const set<Track *> &rtracks = route.get_tracks();
 631         for(set<Track *>::iterator i=rtracks.begin(); i!=rtracks.end(); ++i)
 632         {
 633                 Track3D &t3d = layout_3d->get_3d(**i);
 634                 Path3D *path = new Path3D(t3d);
 635                 path->set_color(GL::Color(0.5, 0.8, 1.0));
 636                 if((*i)->get_type().is_turnout())
 637                         path->set_path(route.get_turnout((*i)->get_turnout_address()));
 638                 highlight_paths.push_back(path);
 639         }
 640 }
 641
 642 void Designer::show_zone(const Zone &zone)
 643 {
 644         clear_paths();
 645
 646         const Zone::TrackSet &ztracks = zone.get_tracks();
 647         for(Zone::TrackSet::const_iterator i=ztracks.begin(); i!=ztracks.end(); ++i)
 648         {
 649                 Track3D &t3d = layout_3d->get_3d(**i);
 650                 Path3D *path = new Path3D(t3d);
 651                 path->set_color(GL::Color(0.8, 1.0, 0.5));
 652                 highlight_paths.push_back(path);
 653         }
 654 }