glPopMatrix();
}
-void Track3D::render_route(int route) const
+void Track3D::render_path(int path) const
{
prepare_render(true);
varray.apply();
- if(route>=0 && static_cast<unsigned>(route)<route_seq.size())
- glDrawElements(GL_QUADS, route_seq[route].size(), GL_UNSIGNED_INT, &route_seq[route][0]);
+ if(path>=0 && static_cast<unsigned>(path)<path_seq.size())
+ glDrawElements(GL_QUADS, path_seq[path].size(), GL_UNSIGNED_INT, &path_seq[path][0]);
else
{
- for(unsigned i=0; i<route_seq.size(); ++i)
- glDrawElements(GL_QUADS, route_seq[i].size(), GL_UNSIGNED_INT, &route_seq[i][0]);
+ for(unsigned i=0; i<path_seq.size(); ++i)
+ glDrawElements(GL_QUADS, path_seq[i].size(), GL_UNSIGNED_INT, &path_seq[i][0]);
}
glPopMatrix();
base_seq.clear();
rail_seq.clear();
- route_seq.clear();
- route_seq.resize(track.get_type().get_n_routes());
+ path_seq.clear();
+ path_seq.resize(track.get_type().get_n_paths());
const vector<TrackPart> &parts = track.get_type().get_parts();
unsigned index = 0;
rail_seq.push_back(base_index+(i+1)*psize+1+j*2);
rail_seq.push_back(base_index+i*psize+1+j*2);
}
- route_seq[part.route].push_back(base_index+i*psize+18);
- route_seq[part.route].push_back(base_index+(i+1)*psize+18);
- route_seq[part.route].push_back(base_index+(i+1)*psize+19);
- route_seq[part.route].push_back(base_index+i*psize+19);
+ path_seq[part.path].push_back(base_index+i*psize+18);
+ path_seq[part.path].push_back(base_index+(i+1)*psize+18);
+ path_seq[part.path].push_back(base_index+(i+1)*psize+19);
+ path_seq[part.path].push_back(base_index+i*psize+19);
}
base_index += (nsegs+1)*psize;
Msp::GL::VertexArray varray;
std::vector<unsigned> base_seq;
std::vector<unsigned> rail_seq;
- std::vector<std::vector<unsigned> > route_seq;
+ std::vector<std::vector<unsigned> > path_seq;
unsigned quality;
public:
void get_bounds(float, Point &, Point &) const;
void render() const;
void render_endpoints() const;
- void render_route(int) const;
+ void render_path(int) const;
private:
void prepare_render(bool) const;
void build_object();
else if(key==Msp::Input::KEY_T)
{
Track *track = selection->get_track();
- if(selection->size()==1 && track->get_type().get_n_routes()>1)
+ if(selection->size()==1 && track->get_type().get_n_paths()>1)
{
ostringstream ss;
ss<<track->get_turnout_id();
int id = -1;
for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
{
- if((*i)->get_type().get_n_routes()==1)
+ if((*i)->get_type().get_n_paths()==1)
ok = true;
if(static_cast<int>((*i)->get_sensor_id())!=id)
{
const map<unsigned, int> &turnouts = cur_route->get_turnouts();
for(set<const Track *>::const_iterator i=rtracks.begin(); i!=rtracks.end(); ++i)
{
- unsigned route = 0;
+ unsigned path = 0;
if(unsigned tid=(*i)->get_turnout_id())
{
map<unsigned, int>::const_iterator j = turnouts.find(tid);
if(j!=turnouts.end())
- route = j->second;
+ path = j->second;
}
- layout_3d->get_track(**i).render_route(route);
+ layout_3d->get_track(**i).render_path(path);
}
}
manipulator->render();
if(track.get_turnout_id())
{
Turnout &trnt = control.get_turnout(track.get_turnout_id());
- (*i)->render_route(trnt.get_route());
+ (*i)->render_path(trnt.get_path());
}
else
- (*i)->render_route(-1);
+ (*i)->render_path(-1);
}
if(placing_train && placing_block)
Turnout &turnout = control.get_turnout(tid);
try
{
- turnout.set_route((turnout.get_route()+1)%track->get_track().get_type().get_n_routes());
+ 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)
for(unsigned i=0; i<endpoints.size(); ++i)
{
- unsigned route = 1<<i;
- endpoints[i].routes |= route;
+ unsigned path = 1<<i;
+ endpoints[i].paths |= path;
set<Track *> visited;
- find_routes(*endpoints[i].track, endpoints[i].track_ep, route, visited);
+ find_paths(*endpoints[i].track, endpoints[i].track_ep, path, visited);
}
}
while(1)
{
- unsigned cur_route = 0;
+ unsigned cur_path = 0;
unsigned tid = track->get_turnout_id();
if(tid)
{
Turnout &turnout = trfc_mgr.get_control().get_turnout(tid);
- cur_route = turnout.get_route();
+ cur_path = turnout.get_path();
}
if(len)
- *len += track->get_type().get_route_length(cur_route);
+ *len += track->get_type().get_path_length(cur_path);
- int other_ep = track->traverse(track_ep, cur_route);
+ int other_ep = track->traverse(track_ep, cur_path);
if(other_ep<0)
return -1;
cout<<i->link->id;
else
cout<<"none";
- cout<<", routes="<<i->routes<<'\n';
+ cout<<", paths="<<i->paths<<'\n';
}
}
-void Block::find_routes(Track &track, unsigned track_ep, unsigned route, set<Track *> &visited)
+void Block::find_paths(Track &track, unsigned track_ep, unsigned path, set<Track *> &visited)
{
visited.insert(&track);
Track *link = track.get_link(i);
if(!link) continue;
if(visited.count(link)) continue;
- if(!(eps[i].routes&eps[track_ep].routes)) continue;
+ if(!(eps[i].paths&eps[track_ep].paths)) continue;
if(tracks.count(link))
- find_routes(*link, link->get_endpoint_by_link(track), route, visited);
+ find_paths(*link, link->get_endpoint_by_link(track), path, visited);
else
{
for(vector<Endpoint>::iterator j=endpoints.begin(); j!=endpoints.end(); ++j)
if(j->track==&track && j->track_ep==i)
- j->routes |= route;
+ j->paths |= path;
}
}
}
track(t),
track_ep(e),
link(0),
- routes(0)
+ paths(0)
{ }
} // namespace Marklin
Track *track;
unsigned track_ep;
Block *link;
- unsigned routes;
+ unsigned paths;
Endpoint(Track *, unsigned);
};
const Train *get_train() const { return train; }
void print_debug();
private:
- void find_routes(Track &, unsigned, unsigned, std::set<Track *> &);
+ void find_paths(Track &, unsigned, unsigned, std::set<Track *> &);
static unsigned next_id;
};
{
Point pos;
float dir; // Direction outwards from the endpoint
- unsigned routes;
+ unsigned paths;
- Endpoint(): dir(0), routes(0) { }
- Endpoint(float x, float y, float d, unsigned r): pos(x, y), dir(d), routes(r) { }
+ Endpoint(): dir(0), paths(0) { }
+ Endpoint(float x, float y, float d, unsigned p): pos(x, y), dir(d), paths(p) { }
};
} // namespace Marklin
const map<unsigned, int> turnouts = (*i)->get_turnouts();
Track *track = 0;
- unsigned trk_route = 0;
+ unsigned trk_path = 0;
for(set<Track *>::const_iterator j=tracks.begin(); j!=tracks.end(); ++j)
{
map<unsigned, int>::const_iterator k = turnouts.find((*j)->get_turnout_id());
if(k!=turnouts.end())
{
track = *j;
- trk_route = k->second;
+ trk_path = k->second;
break;
}
}
const vector<Endpoint> &eps = track->get_type().get_endpoints();
unsigned ep = 0;
for(unsigned j=0; j<eps.size(); ++i)
- if(eps[j].routes&(1<<trk_route))
+ if(eps[j].paths&(1<<trk_path))
{
ep = j;
break;
Track *start = track;
while(1)
{
- int out_ep = track->traverse(ep, trk_route);
+ int out_ep = track->traverse(ep, trk_path);
if(out_ep<0)
break;
Track *next = track->get_links()[out_ep];
if(!next || next == start)
break;
ep = next->get_endpoint_by_link(*track);
- if(next->get_type().get_n_routes()>1)
+ if(next->get_type().get_n_paths()>1)
{
map<unsigned, int>::const_iterator j = turnouts.find(next->get_turnout_id());
if(j==turnouts.end())
break;
- trk_route = j->second;
+ trk_path = j->second;
}
else
- trk_route = 0;
+ trk_path = 0;
(*i)->add_track(*next);
track = next;
}
if(unsigned tid2=links[j]->get_turnout_id())
{
const Endpoint &ep = links[j]->get_type().get_endpoints()[links[j]->get_endpoint_by_link(**i)];
- int r = get_turnout(tid2);
- if(r>=0 && !(ep.routes&(1<<r)))
+ int p = get_turnout(tid2);
+ if(p>=0 && !(ep.paths&(1<<p)))
{
- mask &= ~endpoints[j].routes;
+ mask &= ~endpoints[j].paths;
continue;
}
}
- mask &= endpoints[j].routes;
+ mask &= endpoints[j].paths;
}
if(!(mask&(mask-1)))
{
- unsigned route = 0;
- for(; (mask && !(mask&1)); mask>>=1, ++route) ;
- turnouts[tid] = route;
+ unsigned path = 0;
+ for(; (mask && !(mask&1)); mask>>=1, ++path) ;
+ turnouts[tid] = path;
}
else
turnouts[tid] = -1;
int r = get_turnout(tid);
if(r>=0)
{
- if(endpoints[epi].routes&(1<<r))
+ if(endpoints[epi].paths&(1<<r))
result |= 2;
}
else
if(count<=1)
{
result |= 2;
- if(epj>=0 && !(endpoints[epi].routes&endpoints[epj].routes))
+ if(epj>=0 && !(endpoints[epi].paths&endpoints[epj].paths))
result &= 3;
}
}
add("turnout", &Loader::turnout);
}
-void Route::Loader::turnout(unsigned id, unsigned route)
+void Route::Loader::turnout(unsigned id, unsigned path)
{
- obj.turnouts[id] = route;
+ obj.turnouts[id] = path;
}
} // namespace Marklin
return links[i];
}
-int Track::traverse(unsigned i, unsigned route) const
+int Track::traverse(unsigned i, unsigned path) const
{
const vector<Endpoint> &eps = type.get_endpoints();
if(i>=eps.size())
const Endpoint &ep = eps[i];
- if(ep.routes&(1<<route))
+ if(ep.paths&(1<<path))
{
- // Find the other endpoint for this route
+ // Find the other endpoint for this path
for(unsigned j=0; j<eps.size(); ++j)
- if((eps[j].routes&(1<<route)) && j!=i)
+ if((eps[j].paths&(1<<path)) && j!=i)
return j;
}
else
{
- // Find an endpoint that's connected to this one and has the requested route
+ // Find an endpoint that's connected to this one and has the requested path
for(unsigned j=0; j<eps.size(); ++j)
- if((eps[j].routes&(1<<route)) && (eps[j].routes&ep.routes))
+ if((eps[j].paths&(1<<path)) && (eps[j].paths&ep.paths))
return j;
}
return -1;
}
-Point Track::get_point(unsigned epi, unsigned route, float d) const
+Point Track::get_point(unsigned epi, unsigned path, float d) const
{
const vector<Endpoint> &eps = type.get_endpoints();
if(epi>=eps.size())
{
for(vector<TrackPart>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
{
- if((eps[epi].routes&(1<<route)) && i->route!=route)
+ if((eps[epi].paths&(1<<path)) && i->path!=path)
continue;
if(&*i==last_part)
continue;
dir(0),
length(0),
radius(0),
- route(0),
+ path(0),
dead_end(false)
{ }
void TrackPart::collect_endpoints(vector<Endpoint> &eps) const
{
- eps.push_back(Endpoint(pos.x, pos.y, dir+M_PI, 1<<route));
+ eps.push_back(Endpoint(pos.x, pos.y, dir+M_PI, 1<<path));
if(dead_end)
;
{
float a = ((radius<0) ? -length : length);
Point p = get_point(length*abs(radius));
- eps.push_back(Endpoint(p.x, p.y, dir+a, 1<<route));
+ eps.push_back(Endpoint(p.x, p.y, dir+a, 1<<path));
}
else
- eps.push_back(Endpoint(pos.x+cos(dir)*length, pos.y+sin(dir)*length, dir, 1<<route));
+ eps.push_back(Endpoint(pos.x+cos(dir)*length, pos.y+sin(dir)*length, dir, 1<<path));
}
Point TrackPart::get_point(float d) const
add("start", &Loader::start);
add("length", &TrackPart::length);
add("radius", &TrackPart::radius);
- add("route", &TrackPart::route);
+ add("path", &TrackPart::path);
add("dead_end", &TrackPart::dead_end);
}
float dir;
float length;
float radius;
- unsigned route;
+ unsigned path;
bool dead_end;
TrackPart();
float TrackType::get_total_length() const
{
- return get_route_length(-1);
+ return get_path_length(-1);
}
-float TrackType::get_route_length(int r) const
+float TrackType::get_path_length(int p) const
{
float len = 0;
for(vector<TrackPart>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
- if(r<0 || i->route==static_cast<unsigned>(r))
+ if(p<0 || i->path==static_cast<unsigned>(p))
{
float l = i->length;
if(i->radius)
return len;
}
-unsigned TrackType::get_n_routes() const
+unsigned TrackType::get_n_paths() const
{
unsigned n = 1;
for(vector<TrackPart>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
- if(i->route>=n)
- n = i->route+1;
+ if(i->path>=n)
+ n = i->path+1;
return n;
}
da -= M_PI*2;
if(da<-3.1 || da>3.1)
rm = true;
- i->routes |= j->routes;
+ i->paths |= j->paths;
j = endpoints.erase(j);
}
else
unsigned get_article_number() const { return art_nr; }
const std::string &get_description() const { return description; }
float get_total_length() const;
- float get_route_length(int) const;
- unsigned get_n_routes() const;
+ float get_path_length(int) const;
+ unsigned get_n_paths() const;
const std::vector<TrackPart> &get_parts() const { return parts; }
const std::vector<Endpoint> &get_endpoints() const { return endpoints; }
for(set<Track *>::const_iterator i=tracks.begin(); i!=tracks.end(); ++i)
{
if(unsigned tid=(*i)->get_turnout_id())
- new Turnout(control, tid, (*i)->get_type().get_n_routes()>=3);
+ new Turnout(control, tid, (*i)->get_type().get_n_paths()>=3);
if(unsigned sid=(*i)->get_sensor_id())
if(!control.get_sensors().count(sid))
new Sensor(control, sid);
}
}
-void TrafficManager::turnout_route_changed(unsigned, Turnout *)
+void TrafficManager::turnout_path_changed(unsigned, Turnout *)
{
}
void tick();
void save(const std::string &) const;
private:
- void turnout_route_changed(unsigned, Turnout *);
+ void turnout_path_changed(unsigned, Turnout *);
};
} // namespace Marklin
const map<unsigned, Turnout *> &turnouts = trfc_mgr.get_control().get_turnouts();
for(map<unsigned, Turnout *>::const_iterator i=turnouts.begin(); i!=turnouts.end(); ++i)
{
- i->second->signal_route_changing.connect(sigc::bind(sigc::mem_fun(this, &Train::turnout_route_changing), i->second));
- i->second->signal_route_changed.connect(sigc::bind(sigc::mem_fun(this, &Train::turnout_route_changed), i->second));
+ i->second->signal_path_changing.connect(sigc::bind(sigc::mem_fun(this, &Train::turnout_path_changing), i->second));
+ i->second->signal_path_changed.connect(sigc::bind(sigc::mem_fun(this, &Train::turnout_path_changed), i->second));
}
}
if(cur_track)
{
- unsigned route = 0;
+ unsigned path = 0;
if(cur_track->get_turnout_id())
- route = trfc_mgr.get_control().get_turnout(cur_track->get_turnout_id()).get_route();
+ path = trfc_mgr.get_control().get_turnout(cur_track->get_turnout_id()).get_path();
offset += get_real_speed(loco.get_speed())*(dt/Time::sec);
- if(offset>cur_track->get_type().get_route_length(route))
+ if(offset>cur_track->get_type().get_path_length(path))
{
- int out = cur_track->traverse(cur_track_ep, route);
+ int out = cur_track->traverse(cur_track_ep, path);
if(out>=0)
{
Track *next = cur_track->get_link(out);
}
if(cur_track)
- pos = cur_track->get_point(cur_track_ep, route, offset);
+ pos = cur_track->get_point(cur_track_ep, path, offset);
}
}
if(cur_track)
{
- unsigned route = 0;
+ unsigned path = 0;
if(unsigned turnout = cur_track->get_turnout_id())
- route = trfc_mgr.get_control().get_turnout(turnout).get_route();
- cur_track_ep = cur_track->traverse(cur_track_ep, route);
- offset = cur_track->get_type().get_route_length(route)-offset;
+ path = trfc_mgr.get_control().get_turnout(turnout).get_path();
+ cur_track_ep = cur_track->traverse(cur_track_ep, path);
+ offset = cur_track->get_type().get_path_length(path)-offset;
}
}
}
}
-void Train::turnout_route_changing(unsigned, Turnout *turnout)
+void Train::turnout_path_changing(unsigned, Turnout *turnout)
{
unsigned tid = turnout->get_address();
for(list<BlockRef>::const_iterator i=cur_blocks.begin(); i!=cur_blocks.end(); ++i)
}
}
-void Train::turnout_route_changed(unsigned, Turnout *turnout)
+void Train::turnout_path_changed(unsigned, Turnout *turnout)
{
unsigned tid = turnout->get_address();
for(list<BlockRef>::iterator i=rsv_blocks.begin(); i!=rsv_blocks.end(); ++i)
private:
void locomotive_reverse_changed(bool);
void sensor_event(bool, Sensor *);
- void turnout_route_changing(unsigned, Turnout *);
- void turnout_route_changed(unsigned, Turnout *);
+ void turnout_path_changing(unsigned, Turnout *);
+ void turnout_path_changed(unsigned, Turnout *);
unsigned reserve_more();
void update_speed();
float get_real_speed(unsigned) const;
Turnout::Turnout(Control &c, unsigned a, bool d):
control(c),
addr(a),
- route(0),
+ path(0),
dual(d)
{
control.add_turnout(*this);
}
}
-void Turnout::set_route(unsigned r)
+void Turnout::set_path(unsigned p)
{
- signal_route_changing.emit(r);
+ signal_path_changing.emit(p);
- route = r;
+ path = p;
command(true);
control.set_timer(200*Time::msec).signal_timeout.connect(sigc::mem_fun(this, &Turnout::switch_timeout));
- signal_route_changed.emit(route);
+ signal_path_changed.emit(path);
}
void Turnout::command(bool on)
{
unsigned char data[2];
data[0] = addr&0xFF;
- data[1] = ((addr>>8)&0x7) | (on ? 0x40 : 0) | (route&1 ? 0 : 0x80);
+ data[1] = ((addr>>8)&0x7) | (on ? 0x40 : 0) | (path&1 ? 0 : 0x80);
control.command(CMD_TURNOUT, data, 2);
if(dual)
{
data[0] = (addr+1)&0xFF;
- data[1] = (((addr+1)>>8)&0x7) | (on ? 0x40 : 0) | (route&2 ? 0 : 0x80);
+ data[1] = (((addr+1)>>8)&0x7) | (on ? 0x40 : 0) | (path&2 ? 0 : 0x80);
control.command(CMD_TURNOUT, data, 2);
}
}
{
bool v = !(reply.get_data()[0]&0x04);
unsigned b = (high?2:1);
- route = (route&~b)|(v?b:0);
- signal_route_changed.emit(route);
+ path = (path&~b)|(v?b:0);
+ signal_path_changed.emit(path);
}
}
return false;
}
-void Turnout::turnout_event(unsigned a, bool r)
+void Turnout::turnout_event(unsigned a, bool p)
{
- if(a==addr && r!=(route&1))
+ if(a==addr && p!=(path&1))
{
- route = (route&2)|(r?1:0);
- signal_route_changed.emit(route);
+ path = (path&2)|(p?1:0);
+ signal_path_changed.emit(path);
}
- else if(dual && a==addr+1 && r!=((route>>1)&1))
+ else if(dual && a==addr+1 && p!=((path>>1)&1))
{
- route = (route&1)|(r?2:0);
- signal_route_changed.emit(route);
+ path = (path&1)|(p?2:0);
+ signal_path_changed.emit(path);
}
}
class Turnout
{
public:
- sigc::signal<void, unsigned> signal_route_changing;
- sigc::signal<void, unsigned> signal_route_changed;
+ sigc::signal<void, unsigned> signal_path_changing;
+ sigc::signal<void, unsigned> signal_path_changed;
private:
Control &control;
unsigned addr;
- unsigned route;
+ unsigned path;
bool dual;
public:
Turnout(Control &, unsigned, bool =false);
- void set_route(unsigned);
+ void set_path(unsigned);
unsigned get_address() const { return addr; }
- unsigned get_route() const { return route; }
+ unsigned get_path() const { return path; }
private:
void command(bool);
void status_reply(const Reply &, bool);
part
{
length 77.5;
- route 0;
+ path 0;
};
part
{
start 77.5 0 0;
length 30;
radius 360;
- route 0;
+ path 0;
};
part
{
length 30;
radius 360;
- route 1;
+ path 1;
};
};
part
{
length 77.5;
- route 0;
+ path 0;
};
part
{
start 77.5 0 0;
length 30;
radius -360;
- route 0;
+ path 0;
};
part
{
length 30;
radius -360;
- route 1;
+ path 1;
};
};
part
{
length 188.3;
- route 0;
+ path 0;
};
part
{
length 24.3;
radius 437.5;
- route 1;
+ path 1;
};
};
part
{
length 188.3;
- route 0;
+ path 0;
};
part
{
length 24.3;
radius -437.5;
- route 1;
+ path 1;
};
};
part
{
length 188.3;
- route 0;
+ path 0;
};
part
{
length 24.3;
radius 437.5;
- route 1;
+ path 1;
};
part
{
length 24.3;
radius -437.5;
- route 2;
+ path 2;
};
};
part
{
length 236.1;
- route 0;
+ path 0;
};
part
{
length 12.1;
radius 1114.6;
- route 1;
+ path 1;
};
};
part
{
length 236.1;
- route 0;
+ path 0;
};
part
{
length 12.1;
radius -1114.6;
- route 1;
+ path 1;
};
};