X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Fengineer%2Fengineer.cpp;h=ef5b54d8c7110bef454e1f76b1966622bcae70df;hb=eb8b919a1a224c0d6f206d1d29a9b4b8c3a0cac8;hp=777758700a4a857bf81df07c42d4a8cb7975ae50;hpb=a448b6ac73e0eb19980e69b095136eabe95d2534;p=r2c2.git

diff --git a/source/engineer/engineer.cpp b/source/engineer/engineer.cpp
index 7777587..ef5b54d 100644
--- a/source/engineer/engineer.cpp
+++ b/source/engineer/engineer.cpp
@@ -1,497 +1,408 @@
-/* $Id$
-
-This file is part of the MSP Märklin suite
-Copyright © 2006-2009 Mikkosoft Productions, Mikko Rasa
-Distributed under the GPL
-*/
-
+#include <algorithm>
 #include <cmath>
+#include <cstdlib>
 #include <limits>
-#include <GL/gl.h>
-#include <msp/core/except.h>
-#include <msp/core/getopt.h>
+#include <signal.h>
 #include <msp/fs/stat.h>
-#include <msp/gbase/display.h>
-#include <msp/gbase/window.h>
-#include <msp/gl/immediate.h>
+#include <msp/fs/utils.h>
+#include <msp/graphics/display.h>
+#include <msp/graphics/window.h>
+#include <msp/gl/blend.h>
+#include <msp/gl/framebuffer.h>
 #include <msp/gl/matrix.h>
-#include <msp/gl/projection.h>
-#include <msp/gl/transform.h>
-#include <msp/strings/formatter.h>
-#include <msp/strings/lexicalcast.h>
-#include <msp/strings/regex.h>
+#include <msp/gl/misc.h>
+#include <msp/gl/tests.h>
+#include <msp/gltk/floatingarrangement.h>
+#include <msp/io/print.h>
+#include <msp/strings/format.h>
 #include <msp/time/units.h>
-#include "libmarklin/except.h"
-#include "libmarklin/tracktype.h"
+#include <msp/time/utils.h>
+#include "libr2c2/driver.h"
+#include "libr2c2/trackcircuit.h"
+#include "libr2c2/tracktype.h"
+#include "3d/allocation.h"
+#include "3d/path.h"
+#include "3d/track.h"
+#include "3d/trackcircuit.h"
+#include "3d/vehicle.h"
+#include "dynamicdialog.h"
 #include "engineer.h"
-#include "mainpanel.h"
-#include "trainpanel.h"
-#include "trainproperties.h"
+#include "mainwindow.h"
+#include "newtraindialog.h"
+#include "traindialog.h"
 
 using namespace std;
-using namespace Marklin;
+using namespace R2C2;
 using namespace Msp;
 
 Engineer::Engineer(int argc, char **argv):
-	screen_w(1280),
-	screen_h(960),
-	fullscreen(false),
-	layout(catalogue),
+	options(argc, argv),
+	window(options.screen_w, options.screen_h, options.fullscreen),
+	keyboard(window),
+	mouse(window),
+	ui_res("data/r2c2.res"),
+	import_active(false),
+	layout(catalogue, (options.driver.empty() ? 0 : Driver::create(options.driver))),
 	layout_3d(layout),
 	server(0),
-	placing_train(0),
-	placing_block(0),
-	placing_entry(0),
-	no_lighting(false),
-	simulate(false)
+	main_view(layout_3d, window.get_width(), window.get_height()),
+	emergency_blink_state(0)
 {
-	string res;
-	bool debug = false;
-	string device = "/dev/ttyS0";
-	unsigned quality = 4;
-	bool network = false;
-
-	GetOpt getopt;
-	getopt.add_option('r', "resolution",  res,         GetOpt::REQUIRED_ARG);
-	getopt.add_option('f', "fullscreen",  fullscreen,  GetOpt::NO_ARG);
-	getopt.add_option('g', "debug",       debug,       GetOpt::NO_ARG);
-	getopt.add_option('d', "device",      device,      GetOpt::REQUIRED_ARG);
-	getopt.add_option('q', "quality",     quality,     GetOpt::REQUIRED_ARG);
-	getopt.add_option('s', "simulate",    simulate,    GetOpt::NO_ARG);
-	getopt.add_option('n', "network",     network,     GetOpt::NO_ARG);
-	getopt.add_option(     "no-lighting", no_lighting, GetOpt::NO_ARG);
-	getopt(argc, argv);
-
-	if(!res.empty())
-	{
-		if(RegMatch m=Regex("([1-9][0-9]*)x([1-9][0-9]*)").match(res))
-		{
-			screen_w = lexical_cast<unsigned>(m[1].str);
-			screen_h = lexical_cast<unsigned>(m[2].str);
-		}
-		else
-			throw UsageError("Invalid resolution");
-	}
-
-	if(device!="none")
-		control.open(device);
+	// Setup GUI
+	window.set_title("Railroad Engineer");
+	window.signal_close.connect(sigc::bind(sigc::mem_fun(this, &Engineer::exit), 0));
+
+	root = new GLtk::Root(ui_res, &window, &keyboard, &mouse);
+	GLtk::Layout *root_layout = new GLtk::Layout;
+	root->set_layout(root_layout);
+	root_layout->set_margin(GLtk::Sides());
+	root_arrangement = new GLtk::FloatingArrangement(*root_layout);
+	mouse.signal_button_press.connect(sigc::bind_return(sigc::mem_fun(this, &Engineer::button_press), false));
+	mouse.signal_axis_motion.connect(sigc::bind_return(sigc::mem_fun(this, &Engineer::axis_motion), false));
+	root->set_visible(true);
 
-	control.set_debug(debug);
+	main_wnd = new MainWindow(*this);
+	root->add(*main_wnd);
+	main_wnd->autosize();
+	main_wnd->set_position(0, window.get_height()-main_wnd->get_geometry().h);
 
-	layout_3d.set_quality(quality);
+	overlay = new Overlay3D(ui_res.get_default_font());
 
-	DataFile::load(catalogue, "tracks.dat");
-	DataFile::load(catalogue, "locos.dat");
+	// Setup railroad control
+	catalogue.add_source("data/Märklin/H0");
+	DataFile::load(layout, options.layout_fn);
 
-	const vector<string> &args = getopt.get_args();
-	if(args.empty())
-		throw UsageError("No layout given");
-	DataFile::load(layout, args.front());
+	if(layout.has_driver())
+	{
+		Driver &driver = layout.get_driver();
+		driver.signal_locomotive_detected.connect(sigc::mem_fun(this, &Engineer::locomotive_detected));
+		driver.signal_halt.connect(sigc::mem_fun(this, &Engineer::halt_event));
+	}
+	layout.signal_train_added.connect(sigc::mem_fun(this, &Engineer::train_added));
+	layout.signal_emergency.connect(sigc::mem_fun(this, &Engineer::emergency));
+	const set<Block *> &blocks = layout.get_all<Block>();
+	for(set<Block *>::const_iterator i=blocks.begin(); i!=blocks.end(); ++i)
+		if(TrackCircuit *tc = (*i)->get_sensor())
+			new TrackCircuit3D(layout_3d, *tc);
+
+	const set<Track *> &tracks = layout.get_all<Track>();
+	for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
+		if((*i)->get_type().is_turnout())
+			new Path3D(layout_3d.get_3d(**i));
 
-	trfc_mgr = new TrafficManager(control, layout);
-	if(FS::exists("engineer.state"))
-		DataFile::load(*trfc_mgr, "engineer.state");
-	trfc_mgr->signal_train_added.connect(sigc::mem_fun(this, &Engineer::train_added));
-	trfc_mgr->signal_block_reserved.connect(sigc::mem_fun(this, &Engineer::block_reserved));
+	if(FS::exists(options.state_fn))
+		DataFile::load(layout, options.state_fn);
 
-	if(network)
+	if(options.network)
 	{
-		server = new Server(*trfc_mgr);
+		server = new Server(layout);
 		server->use_event_dispatcher(event_disp);
 	}
 
-	const map<unsigned, Sensor *> &sensors = control.get_sensors();
-	for(map<unsigned, Sensor *>::const_iterator i=sensors.begin(); i!=sensors.end(); ++i)
-		i->second->signal_state_changed.connect(sigc::bind(sigc::mem_fun(this, &Engineer::sensor_event), i->second));
+	// Setup 3D view
+	GL::Pipeline &pipeline = main_view.get_pipeline();
+
+	GL::Pipeline::Pass *pass = &pipeline.add_pass("unlit");
+	pass->set_depth_test(&GL::DepthTest::lequal());
+	pipeline.add_renderable_for_pass(layout_3d.get_path_scene(), "unlit");
+
+	pass = &pipeline.add_pass("overlay");
+	pass->set_blend(&GL::Blend::alpha());
+	pipeline.add_renderable_for_pass(*overlay, "overlay");
 
 	view_all();
+
+	// Catch various signals so we can stop the trains in case we get terminated
+	catch_signal(SIGINT);
+	catch_signal(SIGTERM);
+	catch_signal(SIGSEGV);
+	catch_signal(SIGILL);
+	catch_signal(SIGFPE);
+	catch_signal(SIGABRT);
 }
 
 Engineer::~Engineer()
 {
-	if(!simulate)
-		trfc_mgr->save("engineer.state");
-	delete trfc_mgr;
+	if(!options.simulate)
+	{
+		layout.save_dynamic(options.state_fn+".tmp");
+		FS::rename(options.state_fn+".tmp", options.state_fn);
+	}
+
+	layout.get_driver().halt(true);
+	layout.get_driver().flush();
+
+	delete overlay;
+	delete root_arrangement;
+	delete root;
+
 	delete server;
 }
 
-void Engineer::place_train(Train &train)
+void Engineer::set_status(const string &text)
 {
-	placing_train = &train;
-	placing_block = 0;
-	main_panel->set_status_text("Select location");
+	main_wnd->set_status_text(text);
+	status_timeout = Time::now()+10*Time::sec;
 }
 
-int Engineer::main()
+void Engineer::add_dynamic_dialog(DynamicDialog &tv)
 {
-	dpy = new Graphics::Display;
-
-	Graphics::WindowOptions wopt;
-	wopt.width = screen_w;
-	wopt.height = screen_h;
-	wopt.fullscreen = fullscreen;
-	wnd = new Graphics::Window(*dpy, wopt);
-
-	Graphics::GLOptions glopt;
-	//glopt.multisample = 4;
-	glc = new Graphics::GLContext(*wnd, glopt);
-
-	wnd->signal_close.connect(sigc::bind(sigc::mem_fun(this, &Engineer::exit), 0));
-	wnd->signal_button_press.connect(sigc::mem_fun(this, &Engineer::button_press));
-	wnd->signal_button_release.connect(sigc::mem_fun(this, &Engineer::button_release));
-	wnd->signal_pointer_motion.connect(sigc::mem_fun(this, &Engineer::pointer_motion));
-
-	glEnableClientState(GL_VERTEX_ARRAY);
-	glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
-	glEnable(GL_COLOR_MATERIAL);
-	glDepthFunc(GL_LEQUAL);
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-
-	DataFile::load(ui_res, "marklin.res");
-	root = new GLtk::Root(ui_res, *wnd);
-	root->set_visible(true);
-
-	list<GL::Texture *> texs = ui_res.get_list<GL::Texture>();
-	for(list<GL::Texture *>::iterator i=texs.begin(); i!=texs.end(); ++i)
-	{
-		(*i)->set_min_filter(GL::NEAREST);
-		(*i)->set_mag_filter(GL::NEAREST);
-	}
-
-	main_panel = new MainPanel(*this, ui_res);
-	root->add(*main_panel);
-	main_panel->set_position(0, screen_h-main_panel->get_geometry().h);
-	main_panel->set_visible(true);
-
-	const list<Train *> &trains = trfc_mgr->get_trains();
-	int y = main_panel->get_geometry().y;
-	for(list<Train *>::const_iterator i=trains.begin(); i!=trains.end(); ++i)
-	{
-		TrainPanel *tpanel = new TrainPanel(*this, ui_res, **i);
-		root->add(*tpanel);
-		tpanel->set_position(0, y-tpanel->get_geometry().h);
-		train_panels.push_back(tpanel);
-		tpanel->set_visible(true);
-		y -= tpanel->get_geometry().h;
-	}
-
-	wnd->show();
+	dyn_dialogs.push_back(&tv);
+}
 
-	Application::main();
+void Engineer::remove_dynamic_dialog(DynamicDialog &tv)
+{
+	dyn_dialogs.erase(remove(dyn_dialogs.begin(), dyn_dialogs.end(), &tv), dyn_dialogs.end());
+}
 
-	delete root;
-	delete glc;
-	delete wnd;
-	delete dpy;
+int Engineer::main()
+{
+	window.show();
 
-	return exit_code;
+	return Application::main();
 }
 
 void Engineer::tick()
 {
-	dpy->tick();
+	window.get_display().tick();
 
-	control.tick();
-	trfc_mgr->tick();
-	event_disp.tick(Time::zero);
-
-	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
-
-	project_3d();
-	glLoadIdentity();
-	glRotatef(-cam_rot*180/M_PI, 0, 0, 1);
-	glTranslatef(-cam_pos.x, -cam_pos.y, -cam_pos.z);
-
-	if(!no_lighting)
-	{
-		glEnable(GL_LIGHTING);
-		glEnable(GL_LIGHT0);
-		float params[4];
-		params[0] = 0;
-		params[1] = -0.2;
-		params[2] = 1;
-		params[3] = 0;
-		glLightfv(GL_LIGHT0, GL_POSITION, params);
-	}
+	for(list<Train *>::iterator i=new_trains.begin(); i!=new_trains.end(); ++i)
+		process_new_train(**i);
+	new_trains.clear();
 
-	//glEnable(GL_DEPTH_TEST);
-	glEnable(GL_MULTISAMPLE);
-
-	layout_3d.render();
+	layout.tick(options.sim_speed);
+	layout_3d.tick();
+	event_disp.tick(Time::zero);
 
-	glDisable(GL_LIGHTING);
-	glColor4f(1, 1, 1, 1);
-	const list<Track3D *> &ltracks = layout_3d.get_tracks();
-	for(list<Track3D *>::const_iterator i=ltracks.begin(); i!=ltracks.end(); ++i)
-	{
-		Track &track = (*i)->get_track();
-		if(track.get_turnout_id())
-		{
-			Turnout &trnt = control.get_turnout(track.get_turnout_id());
-			(*i)->render_path(trnt.get_path());
-		}
-		else
-			(*i)->render_path(-1);
-	}
+	for(list<DynamicDialog *>::iterator i=dyn_dialogs.begin(); i!=dyn_dialogs.end(); ++i)
+		(*i)->update();
 
-	if(placing_train && placing_block)
+	Time::TimeStamp t = Time::now();
+	if(status_timeout && t>status_timeout)
 	{
-		GL::push_matrix();
-
-		const Marklin::Block::Endpoint &bep = placing_block->get_endpoints()[placing_entry];
-		float rot = bep.track->get_endpoint_direction(bep.track_ep);
-		Point pos = bep.track->get_endpoint_position(bep.track_ep);
-
-		GL::translate(pos.x, pos.y, pos.z+0.03);
-		GL::rotate(rot*180/M_PI+180, 0, 0, 1);
-		GL::Texture::unbind();
-
-		GL::Immediate imm((GL::COLOR4_UBYTE, GL::VERTEX2));
-		imm.color(1.0f, 1.0f, 1.0f);
-		imm.begin(GL::TRIANGLE_FAN);
-		imm.vertex(0.08,  0);
-		imm.vertex(0.05,  0.03);
-		imm.vertex(0.05,  0.01);
-		imm.vertex(0,     0.01);
-		imm.vertex(0,    -0.01);
-		imm.vertex(0.05, -0.01);
-		imm.vertex(0.05, -0.03);
-		imm.end();
-
-		GL::pop_matrix();
+		main_wnd->set_status_text(string());
+		status_timeout = Time::TimeStamp();
 	}
-
-	const list<Train *> &trains = trfc_mgr->get_trains();
-	for(list<Train *>::const_iterator i=trains.begin(); i!=trains.end(); ++i)
+	if(!emergencies.empty() && t>emergency_blink_timeout)
 	{
-		GL::PushMatrix _push;
-
-		const Point &tp = (*i)->get_position();
-		GL::translate(tp.x, tp.y, tp.z+0.02);
-		GL::Immediate imm((GL::COLOR4_UBYTE, GL::VERTEX2));
-		imm.color(0.8f, 0.8f, 1.0f);
-		imm.begin(GL::TRIANGLE_FAN);
-		imm.vertex(0, 0);
-		for(unsigned j=0; j<=12; ++j)
-			imm.vertex(0.02*cos(j*M_PI/6), 0.02*sin(j*M_PI/6));
-		imm.end();
-
-		GL::rotate(cam_rot*180/M_PI, 0, 0, 1);
-		GL::translate(0.03, -0.02, 0);
-		GL::scale_uniform(0.04);
-		ui_res.get_default_font().draw_string((*i)->get_name());
-		GL::Texture::unbind();
+		emergency_blink_state = (emergency_blink_state+1)%2;
+		GL::Color color(1.0f/(1+emergency_blink_state), 0.0f, 0.0f);
+		for(list<TrackChain3D *>::iterator i=emergencies.begin(); i!=emergencies.end(); ++i)
+			(*i)->set_color(color);
+		emergency_blink_timeout = t+0.5*Time::sec;
 	}
 
-	GL::matrix_mode(GL::PROJECTION);
-	GL::load_identity();
-	GL::ortho_bottomleft(screen_w, screen_h);
-	GL::matrix_mode(GL::MODELVIEW);
-	GL::load_identity();
+	GL::Framebuffer::system().clear(GL::COLOR_BUFFER_BIT|GL::DEPTH_BUFFER_BIT);
 
-	glDisable(GL_DEPTH_TEST);
-	glDisable(GL_LIGHTING);
-	glDisable(GL_MULTISAMPLE);
+	main_view.render();
 
 	root->render();
 
-	glc->swap_buffers();
+	window.swap_buffers();
 }
 
-void Engineer::button_press(int x, int y, unsigned btn, unsigned)
+void Engineer::button_press(unsigned btn)
 {
-	if(placing_train)
-	{
-		if(btn==1 && placing_block && !placing_block->get_train())
-		{
-			set_block_color(*placing_block, GL::Color(1, 1, 1));
-
-			placing_train->place(placing_block, placing_entry);
-			placing_train = 0;
-			main_panel->set_status_text(string());
-		}
-		else if(btn==3)
-		{
-			const vector<Block::Endpoint> &endpoints = placing_block->get_endpoints();
-			placing_entry = (placing_entry+1)%endpoints.size();
-		}
-	}
-	else
+	if(btn==1)
 	{
-		Track3D *track = pick_track(x, screen_h-y-1);
-		if(track)
+		Object *obj = pick_object(pointer);
+		if(Track *track = dynamic_cast<Track *>(obj))
 		{
-			if(unsigned tid=track->get_track().get_turnout_id())
+			if(track->get_type().is_turnout())
 			{
-				Turnout &turnout = control.get_turnout(tid);
-				try
-				{
-					turnout.set_path((turnout.get_path()+1)%track->get_track().get_type().get_n_paths());
-					main_panel->set_status_text(format("Turnout %d switched", turnout.get_address()));
-				}
-				catch(const TurnoutBusy &e)
+				Block &block = track->get_block();
+				if(block.get_train() && block.get_train()->is_block_critical(block))
+					set_status("Turnout is busy");
+				else
 				{
-					main_panel->set_status_text(e.what());
+					unsigned paths = track->get_type().get_paths();
+					unsigned i = track->get_active_path()+1;
+					while(!(paths&(1<<i)))
+					{
+						if(!(paths>>i))
+							i = 0;
+						else
+							++i;
+					}
+					track->set_active_path(i);
+					set_status(format("Turnout %d", track->get_turnout_address()));
 				}
 			}
-			else if(simulate)
+			if(unsigned saddr = track->get_sensor_address())
 			{
-				if(unsigned sid=track->get_track().get_sensor_id())
-				{
-					Sensor &sensor = control.get_sensor(sid);
-					control.signal_sensor_event.emit(sid, !sensor.get_state());
-				}
+				if(options.simulate)
+					layout.get_driver().set_sensor(saddr, !layout.get_driver().get_sensor(saddr));
+				set_status(format("Sensor %d", saddr));
 			}
 		}
+		else if(Vehicle *veh = dynamic_cast<Vehicle *>(obj))
+		{
+			TrainDialog *dlg = new TrainDialog(*this, *veh->get_train());
+			root->add(*dlg);
+			dlg->autosize();
+		}
 	}
 }
 
-void Engineer::button_release(int, int, unsigned, unsigned)
+void Engineer::axis_motion(unsigned axis, float value, float)
 {
+	if(axis==0)
+		pointer.x = value;
+	if(axis==1)
+		pointer.y = value;
 }
 
-void Engineer::pointer_motion(int x, int y)
+void Engineer::view_all()
 {
-	if(placing_train)
+	const Layout3D::ObjectMap &objects = layout_3d.get_all();
+
+	float view_aspect = float(window.get_width())/window.get_height();
+	float view_height = tan(main_view.get_camera().get_field_of_view()/2.0f)*2.0f;
+	float best_score = 0;
+	GL::Vector3 pos;
+	GL::Vector3 up;
+	for(Angle angle; angle<Angle::half_turn(); angle+=Angle::from_radians(0.01))
 	{
-		Track3D *track = pick_track(x, screen_h-y-1);
-		if(track && placing_train)
-		{
-			Block &block = trfc_mgr->get_block_by_track(track->get_track());
-			if(&block!=placing_block)
-			{
-				if(placing_block)
-					reset_block_color(*placing_block);
-				placing_block = &block;
-				placing_entry = 0;
-				set_block_color(*placing_block, GL::Color(0.5, 1, 0.7));
-			}
-		}
-		else if(track && track->get_track().get_turnout_id())
-			main_panel->set_status_text(format("Turnout %d", track->get_track().get_turnout_id()));
-		else if(!placing_train)
-			main_panel->set_status_text(string());
-	}
-}
+		Transform trans = Transform::rotation(-angle, Vector(0, 0, 1));
+		BoundingBox bbox;
+		for(Layout3D::ObjectMap::const_iterator i=objects.begin(); i!=objects.end(); ++i)
+			bbox = bbox|trans.transform(i->second->get_object().get_bounding_box());
 
-void Engineer::view_all()
-{
-	const list<Track3D *> &tracks = layout_3d.get_tracks();
+		const Vector &minp = bbox.get_minimum_point();
+		const Vector &maxp = bbox.get_maximum_point();
 
-	cam_rot = 0;
-	float best_height = -1;
-	float mid_x = 0;
-	float mid_y = 0;
-	for(float angle=0; angle<M_PI; angle+=0.01)
-	{
-		float min_x = 0;
-		float max_x = 0;
-		float min_y = 0;
-		float max_y = 0;
-		for(list<Track3D *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
+		float width = maxp.x-minp.x;
+		float height = maxp.y-minp.y;
+		float aspect = width/height;
+		float score = min(aspect/view_aspect, view_aspect/aspect);
+
+		if(score>best_score)
 		{
-			Point minp, maxp;
-			(*i)->get_bounds(angle, minp, maxp);
-			min_x = min(min_x, minp.x);
-			max_x = max(max_x, maxp.x);
-			min_y = min(min_y, minp.y);
-			max_y = max(max_y, maxp.y);
-		}
+			best_score = score;
 
-		float width = max_x-min_x;
-		float height = max_y-min_y;
-		height = max(height, width);
+			float size = max(width/view_aspect, height);
+			float c = cos(angle);
+			float s = sin(angle);
+			float x = (minp.x+maxp.x)/2;
+			float y = (minp.y+maxp.y)/2;
+			float z = max(size*1.05/view_height, 0.15);
 
-		if(height<best_height || best_height<0)
-		{
-			cam_rot = angle;
-			best_height = height;
-			mid_x = (min_x+max_x)/2;
-			mid_y = (min_y+max_y)/2;
+			pos = GL::Vector3(c*x-s*y, s*x+c*y, z);
+			up = GL::Vector3(-s, c, 0);
 		}
 	}
 
-	float c = cos(cam_rot);
-	float s = sin(cam_rot);
-	cam_pos.x = c*mid_x-s*mid_y;
-	cam_pos.y = s*mid_x+c*mid_y;
-	cam_pos.z = max(best_height*1.05/0.82843, 0.15);
+	GL::Camera &camera = main_view.get_camera();
+	camera.set_position(pos);
+	camera.set_up_direction(up);
+	camera.set_look_direction(GL::Vector3(0, 0, -1));
+	camera.set_aspect(float(window.get_width())/window.get_height());
+	camera.set_depth_clip(pos.z*0.5, pos.z*1.5);
 }
 
-void Engineer::set_block_color(const Block &block, const GL::Color &color)
+Object *Engineer::pick_object(const Vector &p)
 {
-	const set<Track *> &tracks = block.get_tracks();
-	for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
-		layout_3d.get_track(**i).set_color(color);
+	const GL::Vector3 &start = main_view.get_camera().get_position();
+	GL::Vector4 ray = main_view.get_camera().unproject(GL::Vector4(p.x, p.y, 0, 0));
+
+	// XXX Do this better; make this function a template?
+	if(Vehicle *veh = layout.pick<Vehicle>(Ray(start, ray.slice<3>(0))))
+		return veh;
+	return layout.pick<Track>(Ray(start, ray.slice<3>(0)));
 }
 
-void Engineer::reset_block_color(const Block &block)
+void Engineer::emergency(Block *block, const string &msg)
 {
-	if(unsigned sid=block.get_sensor_id())
+	set_status(msg);
+	if(block)
 	{
-		Sensor &sensor = control.get_sensor(sid);
-		if(sensor.get_state())
-		{
-			set_block_color(block, GL::Color(1, 0.5, 0.3));
-			return;
-		}
+		TrackChain3D *tch3d = new TrackChain3D(layout_3d, *block);
+		tch3d->set_color(GL::Color(1.0f, 0.0f, 0.0f));
+		tch3d->set_layer(2);
+		emergencies.push_back(tch3d);
 	}
+}
 
-	if(block.get_train())
-		set_block_color(block, GL::Color(1, 1, 0.3));
-	else
-		set_block_color(block, GL::Color(1, 1, 1));
+void Engineer::halt_event(bool h)
+{
+	if(!h)
+	{
+		for(list<TrackChain3D *>::iterator i=emergencies.begin(); i!=emergencies.end(); ++i)
+			delete *i;
+		emergencies.clear();
+	}
 }
 
-void Engineer::sensor_event(bool, Sensor *sensor)
+void Engineer::locomotive_detected(const Driver::DetectedLocomotive &loco)
 {
-	const list<Block *> &blocks = trfc_mgr->get_blocks();
-	for(list<Block *>::const_iterator i=blocks.begin(); i!=blocks.end(); ++i)
-		if((*i)->get_sensor_id()==sensor->get_address())
-			reset_block_color(**i);
+	if(!import_active)
+	{
+		NewTrainDialog *dlg = new NewTrainDialog(*this);
+		dlg->prefill(loco);
+		dlg->signal_response.connect(sigc::mem_fun(this, &Engineer::import_finished));
+		root->add(*dlg);
+		import_active = true;
+	}
 }
 
-void Engineer::block_reserved(const Block &block, const Train *)
+void Engineer::import_finished(int)
 {
-	reset_block_color(block);
+	import_active = false;
 }
 
-void Engineer::project_3d()
+void Engineer::process_new_train(Train &train)
 {
-	glMatrixMode(GL_PROJECTION);
-	glLoadIdentity();
-	float offset = 200.0/screen_w*0.055228;
-	glFrustum(-0.055228-offset, 0.055228-offset, -0.041421, 0.041421, 0.1, 10);
-	glMatrixMode(GL_MODELVIEW);
+	Vehicle3D &loco3d = layout_3d.get_3d(train.get_vehicle(0));
+	overlay->set_label(loco3d, train.get_name());
+	train.signal_name_changed.connect(sigc::bind<0>(sigc::mem_fun(overlay, &Overlay3D::set_label), sigc::ref(loco3d)));
 }
 
-Track3D *Engineer::pick_track(int x, int y)
+void Engineer::train_added(Train &train)
 {
-	float xx = (static_cast<float>(x-static_cast<int>(screen_w)/2-100)/screen_h)*0.82843;
-	float yy = (static_cast<float>(y)/screen_h-0.5)*0.82843;
-	float size = 4.0/screen_h*0.82843;
+	new_trains.push_back(&train);
 
-	project_3d();
-	glLoadIdentity();
-	glRotatef(-cam_rot*180/M_PI, 0, 0, 1);
-	glTranslatef(-cam_pos.x, -cam_pos.y, -cam_pos.z);
+	GL::Color best_color;
+	float best_d_sq = 0;
+	for(unsigned i=0; i<10; ++i)
+	{
+		GL::Color color;
+		unsigned h = rand()%3;
+		color.r = (h==0 ? 0.0 : rand()*1.0/RAND_MAX);
+		color.g = (h==1 ? 0.0 : rand()*1.0/RAND_MAX);
+		color.b = (h==2 ? 0.0 : rand()*1.0/RAND_MAX);
+		color = color*(1/max(max(color.r, color.g), color.b));
+		float min_d_sq = 3;
+		for(map<Train *, GL::Color>::const_iterator j=train_colors.begin(); j!=train_colors.end(); ++j)
+		{
+			float dr = color.r-j->second.r;
+			float dg = color.g-j->second.g;
+			float db = color.b-j->second.b;
+			float d_sq = dr*dr+dg*dg+db*db;
+			if(d_sq<min_d_sq)
+				min_d_sq = d_sq;
+		}
+		if(min_d_sq>best_d_sq)
+		{
+			best_color = color;
+			best_d_sq = min_d_sq;
+		}
+	}
+	train_colors[&train] = best_color;
 
-	return layout_3d.pick_track(xx, yy, size);
+	Allocation3D *alloc = new Allocation3D(layout_3d, train);
+	alloc->set_color(best_color);
 }
 
-void Engineer::train_added(Train &train)
+void Engineer::sighandler(int sig)
 {
-	TrainPanel *tpanel = new TrainPanel(*this, ui_res, train);
-	root->add(*tpanel);
-	int y = main_panel->get_geometry().y;
-	for(list<TrainPanel *>::iterator i=train_panels.begin(); i!=train_panels.end(); ++i)
-		y -= (*i)->get_geometry().h;
-	tpanel->set_position(0, y-tpanel->get_geometry().h);
-	train_panels.push_back(tpanel);
-	tpanel->set_visible(true);
-
-	place_train(train);
+	if(sig==SIGSEGV || sig==SIGILL || sig==SIGFPE || sig==SIGABRT)
+	{
+		signal(sig, SIG_DFL);
+		IO::print(IO::cerr, "Fatal signal received, terminating\n");
+		layout.get_driver().halt(true);
+		layout.get_driver().flush();
+		raise(sig);
+	}
+	else if(sig==SIGTERM || sig==SIGINT)
+		exit(0);
 }
-
-Application::RegApp<Engineer> Engineer::reg;