X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=source%2Flibr2c2%2Fvehicletype.cpp;h=59787455e3cf1a6c7e81da4bd076b09b4de7377b;hb=399b48a7a80dafde49e7530ff8dfd2820232a73f;hp=9d929b328cbf6359d880715721cce898f16b0180;hpb=bc9e941447da48905295192289bc09483a678180;p=r2c2.git diff --git a/source/libr2c2/vehicletype.cpp b/source/libr2c2/vehicletype.cpp index 9d929b3..5978745 100644 --- a/source/libr2c2/vehicletype.cpp +++ b/source/libr2c2/vehicletype.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include "vehicletype.h" @@ -9,14 +10,15 @@ using namespace Msp; namespace R2C2 { -VehicleType::VehicleType(const ArticleNumber &an): - ObjectType(an), +VehicleType::VehicleType(): locomotive(false), swap_direction(false), + gauge(1.524), length(0), width(0), height(0), - rotate_object(false) + rotate_object(false), + max_speed(0) { } unsigned VehicleType::get_max_function() const @@ -95,11 +97,6 @@ VehicleType::Bogie::Bogie(): VehicleType::Rod::Rod(): - pivot(BODY), - pivot_index(0), - pivot_index2(0), - limit(ROTATE), - connect_index(-1), mirror_object(false) { } @@ -110,9 +107,12 @@ VehicleType::Loader::Loader(VehicleType &vt): add("axle", &Loader::axle); add("bogie", &Loader::bogie); add("function", &Loader::function); + add("gauge", &Loader::gauge); add("height", &Loader::height); add("length", &Loader::length); add("locomotive", &VehicleType::locomotive); + add("maximum_speed", &VehicleType::max_speed); + add("mirror_rods", &Loader::mirror_rods); add("object", &VehicleType::object); add("rod", &Loader::rod); add("rotate_object", &VehicleType::rotate_object); @@ -140,6 +140,10 @@ void VehicleType::Loader::finish() obj.fixed_axles.push_back(&obj.axles[i]); } + for(TagMap::const_iterator i=rod_tags.begin(); i!=rod_tags.end(); ++i) + if(i->second>=0x10000) + throw runtime_error(format("unresolved reference to %s\n", i->first)); + obj.shape = new Geometry::TransformedShape( Geometry::Box(obj.length, obj.width, obj.height), Transform::translation(Vector(0, 0, obj.height/2))); @@ -165,6 +169,11 @@ void VehicleType::Loader::function(unsigned i, const string &f) obj.functions[i] = f; } +void VehicleType::Loader::gauge(float g) +{ + obj.gauge = g/1000; +} + void VehicleType::Loader::height(float h) { obj.height = h/1000; @@ -175,15 +184,63 @@ void VehicleType::Loader::length(float l) obj.length = l/1000; } -void VehicleType::Loader::rod() +void VehicleType::Loader::mirror_rods() +{ + MirrorParametersLoader params; + load_sub_with(params); + Regex r_filter(params.filter); + + vector mirror_indices(obj.rods.size(), 0); + for(TagMap::const_iterator i=rod_tags.begin(); i!=rod_tags.end(); ++i) + if(i->second<0x10000 && r_filter.match(i->first)) + mirror_indices[i->second] = 1; + + for(unsigned i=0, j=obj.rods.size(); i::iterator j=mr.constraints.begin(); j!=mr.constraints.end(); ++j) + { + j->target_position.y = -j->target_position.y; + j->local_position.y = -j->local_position.y; + j->axis.y = -j->axis.y; + if(j->target==RodConstraint::ROD && mirror_indices[j->target_index]) + j->target_index = mirror_indices[j->target_index]; + else if(j->target==RodConstraint::AXLE) + j->target_position = axle_trans.transform(j->target_position); + } + + obj.rods.push_back(mr); + } +} + +void VehicleType::Loader::rod(const string &t) { Rod rd; Rod::Loader ldr(rd, rod_tags); load_sub_with(ldr); + + unsigned n = obj.rods.size(); + if(rod_tags.count(t)) + { + unsigned p = rod_tags[t]; + for(vector::iterator i=obj.rods.begin(); i!=obj.rods.end(); ++i) + for(vector::iterator j=i->constraints.begin(); j!=i->constraints.end(); ++j) + if(j->target_index==p) + j->target_index = n; + } + rod_tags[t] = n; obj.rods.push_back(rd); - if(!ldr.get_tag().empty()) - rod_tags[ldr.get_tag()] = obj.rods.size()-1; - rod_tags["previous"] = obj.rods.size()-1; } void VehicleType::Loader::width(float w) @@ -240,75 +297,102 @@ void VehicleType::Bogie::Loader::position(float p) } -VehicleType::Rod::Loader::Loader(Rod &r, const map &t): - DataFile::ObjectLoader(r), +VehicleType::RodConstraint::RodConstraint(): + type(MOVE), + target(BODY), + target_index(0) +{ } + + +VehicleType::RodConstraint::Loader::Loader(RodConstraint &c, TagMap &t): + DataFile::ObjectLoader(c), tags(t) { - add("connect", &Loader::connect); - add("limit", &Rod::limit); - add("mirror_object", &Rod::mirror_object); - add("object", &Rod::object); - add("pivot_body", &Loader::pivot_body); - add("pivot_axle", &Loader::pivot_axle); - add("pivot_axle", &Loader::pivot_bogie_axle); - add("pivot_rod", &Loader::pivot_rod); - add("position", &Loader::position); - add("tag", &Loader::set_tag); + add("axis", &Loader::axis); + add("local_position", &Loader::local_position); + add("target_axle", &Loader::target_axle); + add("target_position", &Loader::target_position); + add("target_rod", &Loader::target_rod); +} + +void VehicleType::RodConstraint::Loader::axis(float x, float y, float z) +{ + obj.axis = Vector(x, y, z); + obj.axis.normalize(); +} + +void VehicleType::RodConstraint::Loader::local_position(float x, float y, float z) +{ + obj.local_position = Vector(x/1000, y/1000, z/1000); } -void VehicleType::Rod::Loader::connect(const string &t, float px, float pz, float ox, float oz) +void VehicleType::RodConstraint::Loader::target_axle(unsigned i) { - obj.connect_index = get_item(tags, t); - obj.connect_point = Vector(px/1000, 0, pz/1000); - obj.connect_offset = Vector(ox/1000, 0, oz/1000); + obj.target = AXLE; + obj.target_index = i; + // TODO check range } -void VehicleType::Rod::Loader::pivot_body() +void VehicleType::RodConstraint::Loader::target_position(float x, float y, float z) { - obj.pivot = BODY; + obj.target_position = Vector(x/1000, y/1000, z/1000); } -void VehicleType::Rod::Loader::pivot_axle(unsigned i) +void VehicleType::RodConstraint::Loader::target_rod(const string &n) { - obj.pivot = AXLE; - obj.pivot_index = i; + obj.target = ROD; + TagMap::iterator i = tags.find(n); + if(i!=tags.end()) + obj.target_index = i->second; + else + { + obj.target_index = 0x10000+tags.size(); + tags[n] = obj.target_index; + } } -void VehicleType::Rod::Loader::pivot_bogie_axle(unsigned i, unsigned j) + +VehicleType::Rod::Loader::Loader(Rod &r, TagMap &t): + DataFile::ObjectLoader(r), + tags(t) { - obj.pivot = BOGIE_AXLE; - obj.pivot_index = i; - obj.pivot_index2 = j; + add("initial_position", &Loader::initial_position); + add("mirror_object", &Rod::mirror_object); + add("move", &Loader::constraint); + add("object", &Rod::object); + add("rotate", &Loader::constraint); + add("slide", &Loader::constraint); } -void VehicleType::Rod::Loader::pivot_rod(const string &t) +template +void VehicleType::Rod::Loader::constraint() { - obj.pivot_index = get_item(tags, t); - obj.pivot = ROD; + RodConstraint cns; + cns.type = t; + load_sub(cns, tags); + obj.constraints.push_back(cns); } -void VehicleType::Rod::Loader::position(float x, float y, float z) +void VehicleType::Rod::Loader::initial_position(float x, float y, float z) { - obj.pivot_point = Vector(x/1000, y/1000, z/1000); + obj.initial_position = Vector(x/1000, y/1000, z/1000); } -void VehicleType::Rod::Loader::set_tag(const string &t) + +VehicleType::MirrorParametersLoader::MirrorParametersLoader() { - tag = t; + add("filter", &MirrorParametersLoader::filt); + add("phase_offset", &MirrorParametersLoader::phase_offs); } +void VehicleType::MirrorParametersLoader::filt(const string &f) +{ + filter = f; +} -void operator>>(const LexicalConverter &c, VehicleType::Rod::Limit &l) +void VehicleType::MirrorParametersLoader::phase_offs(float o) { - const string &s = c.get(); - if(s=="FIXED") - l = VehicleType::Rod::FIXED; - else if(s=="ROTATE") - l = VehicleType::Rod::ROTATE; - else if(s=="SLIDE_X") - l = VehicleType::Rod::SLIDE_X; - else - throw lexical_error(format("conversion of '%s' to Rod::Limit", s)); + phase_offset = Angle::from_degrees(o); } } // namespace R2C2