Allow custom objects for tracks

[r2c2.git] / source / 3d / tracktype.cpp

diff --git a/source/3d/tracktype.cpp b/source/3d/tracktype.cpp
index 1196b32ce18b7eb161f87e4c64487fcf45207378..755f0080807771f7e1bd4ddf76d34a86c0affaf5 100644 (file)
--- a/source/3d/tracktype.cpp
+++ b/source/3d/tracktype.cpp
@@ -73,7 +73,8 @@ namespace R2C2 {
 
 TrackType3D::TrackType3D(Catalogue3D &cat3d, const TrackType &tt):
        catalogue(cat3d),
-       mesh((GL::NORMAL3, GL::TEXCOORD2, GL::VERTEX3))
+       mesh(0),
+       object(0)
 {
        const Catalogue &cat = cat3d.get_catalogue();
        const vector<TrackPart> &parts = tt.get_parts();
@@ -90,24 +91,34 @@ TrackType3D::TrackType3D(Catalogue3D &cat3d, const TrackType &tt):
 
        float gauge = cat.get_gauge();
 
+       string obj_name = tt.get_object();
+       if(!obj_name.empty())
        {
+               object = catalogue.get<GL::Object>(obj_name);
+               // XXX border
+       }
+       else
+       {
+               mesh = new GL::Mesh((GL::NORMAL3, GL::TEXCOORD2, GL::VERTEX3));
+               mesh->set_winding(&GL::WindingTest::counterclockwise());
+               GL::MeshBuilder bld(*mesh);
+
                unsigned index = 0;
-               GL::MeshBuilder bld(mesh);
                bld.texcoord(0.25, 0.5);
                for(vector<TrackPart>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
-                       build_part(*i, ballast_profile, Point(0, -ballast_min.y), bld, index);
+                       build_part(*i, ballast_profile, Point(0, -ballast_min.y), false, bld, index);
 
                bld.texcoord(0.75, 0.5);
                float y = ballast_h-rail_min.y;
                for(vector<TrackPart>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
-                       build_part(*i, rail_profile, Point(-gauge/2-rail_max.x, y), bld, index);
+                       build_part(*i, rail_profile, Point(-gauge/2, y), true, bld, index);
                for(vector<TrackPart>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
-                       build_part(*i, rail_profile, Point(gauge/2-rail_min.x, y), bld, index);
-       }
+                       build_part(*i, rail_profile, Point(gauge/2, y), false, bld, index);
 
-       mesh.set_winding(&GL::WindingTest::counterclockwise());
-       object.set_mesh(&mesh);
-       object.set_technique(catalogue.get<GL::Technique>(cat.get_track_technique()));
+               object = new GL::Object;
+               object->set_mesh(mesh);
+               object->set_technique(catalogue.get<GL::Technique>(cat.get_track_technique()));
+       }
  
        unsigned paths = tt.get_paths();
        for(unsigned i=0; paths; ++i, paths>>=1)
@@ -120,7 +131,7 @@ TrackType3D::TrackType3D(Catalogue3D &cat3d, const TrackType &tt):
                        unsigned index = 0;
                        for(vector<TrackPart>::const_iterator j=parts.begin(); j!=parts.end(); ++j)
                                if(j->get_path()==i)
-                                       build_part(*j, cat.get_path_profile(), Point(0, ballast_h+1.5*rail_h), bld, index);
+                                       build_part(*j, cat.get_path_profile(), Point(0, ballast_h+1.5*rail_h), false, bld, index);
                }
                path_meshes.push_back(m);
        }
@@ -168,54 +179,56 @@ const GL::Mesh &TrackType3D::get_path_mesh(unsigned p) const
        return *path_meshes[p];
 }
 
-void TrackType3D::build_part(const TrackPart &part, const Profile &profile, const Point &offset, GL::MeshBuilder &bld, unsigned &base_index)
+void TrackType3D::build_part(const TrackPart &part, const Profile &profile, const Point &offset, bool mirror, GL::MeshBuilder &bld, unsigned &base_index)
 {
        float plen = part.get_length();
        unsigned nsegs = (part.is_curved() ? static_cast<unsigned>(plen*32)+1 : 1);
 
-       unsigned n_points = profile.get_n_points();
+       unsigned n_vertices = profile.get_n_vertices();
        for(unsigned i=0; i<=nsegs; ++i)
        {
                TrackPoint basep = part.get_point(i*plen/nsegs);
                float c = cos(basep.dir);
                float s = sin(basep.dir);
 
-               Point p;
-               for(unsigned j=0; j<n_points; ++j)
+               for(unsigned j=0; j<n_vertices; ++j)
                {
-                       // TODO: smoothing - only duplicate vertex if the angle is large enough
-
-                       p = profile.get_point(j);
+                       const Profile::Vertex &v = profile.get_vertex(mirror ? n_vertices-1-j : j);
+                       Point p = v.pos;
+                       if(mirror)
+                               p.x = -p.x;
                        p.z = basep.pos.z+p.y+offset.y;
                        p.y = basep.pos.y-c*(p.x+offset.x);
                        p.x = basep.pos.x+s*(p.x+offset.x);
-                       if(j>0)
-                               bld.vertex(p.x, p.y, p.z);
 
-                       if(j+1<n_points)
-                       {
-                               Point n = profile.get_edge_normal(j);
-                               bld.normal(s*n.x, -c*n.x, n.y);
-                               bld.vertex(p.x, p.y, p.z);
-                       }
+                       Point n = v.normal;
+                       if(mirror)
+                               n.x = -n.x;
+
+                       bld.normal(s*n.x, -c*n.x, n.y);
+                       bld.vertex(p.x, p.y, p.z);
 
                        border.push_back(p);
                }
        }
 
-       for(unsigned i=0; i+1<n_points; ++i)
+       for(unsigned i=0; i+1<n_vertices; )
        {
                bld.begin(GL::TRIANGLE_STRIP);
                for(unsigned j=0; j<=nsegs; ++j)
                {
-                       unsigned k = (j*(n_points-1)+i)*2;
+                       unsigned k = j*n_vertices+i;
                        bld.element(base_index+k+1);
                        bld.element(base_index+k);
                }
                bld.end();
+
+               ++i;
+               if(!profile.get_vertex(i).smooth)
+                       ++i;
        }
 
-       base_index += (nsegs+1)*(n_points-1)*2;
+       base_index += (nsegs+1)*n_vertices;
 }
 
 } // namespace R2C2