]> git.tdb.fi Git - r2c2.git/blob - libr2c2/terrain.cpp
Don't crash if a train has no router
[r2c2.git] / libr2c2 / terrain.cpp
1 #include <msp/geometry/box.h>
2 #include <msp/geometry/transformedshape.h>
3 #include "layout.h"
4 #include "terrain.h"
5 #include "terraintype.h"
6
7 using namespace std;
8 using namespace Msp;
9
10 namespace R2C2 {
11
12 Terrain::Terrain(Layout &l, const TerrainType &t):
13         Object(l),
14         type(t),
15         width(0),
16         height(0)
17 {
18         set_size(1, 1);
19
20         layout.add(*this);
21 }
22
23 Terrain::~Terrain()
24 {
25         layout.remove(*this);
26 }
27
28 Terrain *Terrain::clone(Layout *to_layout) const
29 {
30         Terrain *terrain = new Terrain((to_layout ? *to_layout : layout), type);
31         terrain->set_size(width, height);
32         for(unsigned i=0; i<tiles.size(); ++i)
33                 terrain->tiles[i] = tiles[i];
34         return terrain;
35 }
36
37 void Terrain::set_position(const Vector &p)
38 {
39         position = p;
40         signal_moved.emit();
41 }
42
43 void Terrain::set_rotation(const Angle &r)
44 {
45         rotation = r;
46         signal_moved.emit();
47 }
48
49 void Terrain::set_size(unsigned w, unsigned h)
50 {
51         if(!w || !h)
52                 throw invalid_argument("Terrain::set_size");
53
54         vector<Tile> new_tiles(w*h);
55         for(unsigned y=0; (y<h && y<height); ++y)
56                 for(unsigned x=0; (x<w && x<width); ++x)
57                         new_tiles[x+y*w] = tiles[x+y*width];
58
59         width = w;
60         height = h;
61         swap(tiles, new_tiles);
62
63         delete shape;
64         float ts = type.get_tile_size();
65         Vector dim(width*ts, height*ts, ts);
66         shape = new Geometry::TransformedShape<float, 3>(
67                 Geometry::Box<float>(dim),
68                 Transform::translation(dim/2.0f));
69
70         signal_size_changed.emit(width, height);
71 }
72
73 const Terrain::Tile &Terrain::get_tile(unsigned x, unsigned y) const
74 {
75         if(x>=width || y>=height)
76                 throw out_of_range("Terrain::get_tile");
77         return tiles[x+y*width];
78 }
79
80 void Terrain::set_node_elevation(const NodeCoordinates &c, float elev, bool joined)
81 {
82         if(c.x>=width || c.y>=height || c.i>=4)
83                 throw out_of_range("Terrain::set_node_elevation");
84
85         float eg = type.get_elevation_granularity();
86         elev = int(elev/eg+0.5)*eg;
87
88         if(joined)
89         {
90                 float ref = tiles[c.x+c.y*width].nodes[c.i].elevation;
91                 for(unsigned i=0; i<4; ++i)
92                 {
93                         unsigned x = c.x+c.i%2-i%2;
94                         unsigned y = c.y+c.i/2-i/2;
95                         if(x<width && y<height)
96                         {
97                                 Tile &tile = tiles[x+y*width];
98                                 if(tile.nodes[i].elevation==ref)
99                                 {
100                                         tile.set_node_elevation(i, elev);
101                                         signal_tile_changed.emit(x, y);
102                                 }
103                         }
104                 }
105         }
106         else
107         {
108                 tiles[c.x+c.y*width].set_node_elevation(c.i, elev);
109                 signal_tile_changed.emit(c.x, c.y);
110         }
111 }
112
113 float Terrain::get_node_elevation(const NodeCoordinates &c) const
114 {
115         if(c.x>=width || c.y>=height || c.i>=4)
116                 throw out_of_range("Terrain::get_node_elevation");
117
118         return tiles[c.x+c.y*width].nodes[c.i].elevation;
119 }
120
121 Vector Terrain::get_node_position(const NodeCoordinates &c) const
122 {
123         if(c.x>=width || c.y>=height || c.i>=4)
124                 throw out_of_range("Terrain::get_node_position");
125
126         const Tile &tile = tiles[c.x+c.y*width];
127         float tile_size = type.get_tile_size();
128         Transform trans = Transform::translation(position)*
129                 Transform::rotation(rotation, Vector(0, 0, 1));
130         return trans.transform(Vector((c.x+c.i%2)*tile_size, (c.y+c.i/2)*tile_size, tile.nodes[c.i].elevation));
131 }
132
133 Terrain::NodeCoordinates Terrain::get_closest_node(const Ray &ray) const
134 {
135         Transform reverse_trans = Transform::rotation(rotation, Vector(0, 0, -1))*
136                 Transform::translation(-position);
137         Ray local_ray = reverse_trans.transform(ray);
138
139         float ts = type.get_tile_size();
140         NodeCoordinates coords;
141         float closest_dist = -1;
142         for(unsigned y=0; y<height; ++y)
143                 for(unsigned x=0; x<width; ++x)
144                         for(unsigned i=0; i<4; ++i)
145                         {
146                                 NodeCoordinates c(x, y, i);
147                                 Vector node_pos((x+0.25+(i%2)*0.5)*ts, (y+0.25+(i/2)*0.5)*ts, get_node_elevation(c));
148                                 Vector v = node_pos-local_ray.get_start();
149                                 float dist = (v-local_ray.get_direction()*dot(local_ray.get_direction(), v)).norm();
150                                 if(closest_dist<0 || dist<closest_dist)
151                                 {
152                                         coords = c;
153                                         closest_dist = dist;
154                                 }
155                         }
156
157         return coords;
158 }
159
160 void Terrain::save(list<DataFile::Statement> &st) const
161 {
162         st.push_back((DataFile::Statement("size"), width, height));
163         for(vector<Tile>::const_iterator i=tiles.begin(); i!=tiles.end(); ++i)
164         {
165                 DataFile::Statement ss("tile");
166                 i->save(ss.sub);
167                 st.push_back(ss);
168         }
169 }
170
171
172 Terrain::Node::Node():
173         elevation(0),
174         ground(0),
175         wall(0)
176 { }
177
178 void Terrain::Node::save(list<DataFile::Statement> &st) const
179 {
180         st.push_back((DataFile::Statement("elevation"), elevation));
181         st.push_back((DataFile::Statement("ground"), ground));
182 }
183
184
185 Terrain::Tile::Tile():
186         secondary_axis(false)
187 { }
188
189 void Terrain::Tile::set_node_elevation(unsigned i, float e)
190 {
191         nodes[i].elevation = e;
192         secondary_axis = ((nodes[1].elevation+nodes[2].elevation) < (nodes[0].elevation+nodes[3].elevation));
193 }
194
195 void Terrain::Tile::save(list<DataFile::Statement> &st) const
196 {
197         bool flat = true;
198         for(unsigned i=1; (flat && i<4); ++i)
199                 flat = (nodes[i].elevation==nodes[0].elevation && nodes[i].ground==nodes[0].ground && nodes[i].wall==nodes[0].wall);
200         if(flat)
201         {
202                 st.push_back((DataFile::Statement("elevation"), nodes[0].elevation));
203                 st.push_back((DataFile::Statement("ground"), nodes[0].ground));
204         }
205         else
206         {
207                 for(unsigned i=0; i<4; ++i)
208                 {
209                         DataFile::Statement ss("node");
210                         ss.append(i);
211                         nodes[i].save(ss.sub);
212                         st.push_back(ss);
213                 }
214         }
215 }
216
217
218 Terrain::NodeCoordinates::NodeCoordinates():
219         x(0),
220         y(0),
221         i(0)
222 { }
223
224 Terrain::NodeCoordinates::NodeCoordinates(unsigned x_, unsigned y_, unsigned i_):
225         x(x_),
226         y(y_),
227         i(i_)
228 { }
229
230
231 Terrain::Loader::Loader(Terrain &t):
232         DataFile::ObjectLoader<Terrain>(t),
233         next_tile(0)
234 {
235         add("position", &Loader::position);
236         add("rotation", &Loader::rotation);
237         add("size", &Loader::size);
238         add("tile", &Loader::tile);
239         add("tile", &Loader::tile_coords);
240 }
241
242 void Terrain::Loader::position(float x, float y, float z)
243 {
244         obj.set_position(Vector(x, y, z));
245 }
246
247 void Terrain::Loader::rotation(float a)
248 {
249         obj.set_rotation(Angle::from_radians(a));
250 }
251
252 void Terrain::Loader::size(unsigned w, unsigned h)
253 {
254         obj.set_size(w, h);
255 }
256
257 void Terrain::Loader::tile()
258 {
259         if(next_tile>=obj.tiles.size())
260                 throw runtime_error("Terrain::Loader::tile");
261
262         Tile &t = obj.tiles[next_tile];
263         Tile::Loader ldr(obj, t);
264         load_sub_with(ldr);
265         unsigned x = next_tile%obj.width;
266         unsigned y = next_tile/obj.width;
267         ++next_tile;
268         obj.signal_tile_changed.emit(x, y);
269 }
270
271 void Terrain::Loader::tile_coords(unsigned x, unsigned y)
272 {
273         if(x>=obj.width || y>=obj.height)
274                 throw out_of_range("Terrain::Loader::tile");
275         next_tile = x+y*obj.width;
276         tile();
277 }
278
279
280 Terrain::Node::Loader::Loader(Terrain &t, Node &n):
281         DataFile::ObjectLoader<Node>(n),
282         terrain(t)
283 {
284         add("ground", &Loader::ground);
285         add("elevation", &Node::elevation);
286 }
287
288 void Terrain::Node::Loader::ground(unsigned g)
289 {
290         if(g>=terrain.type.get_n_surface_types())
291                 throw out_of_range("Tile::Loader::surface");
292         obj.ground = g;
293 }
294
295
296 Terrain::Tile::Loader::Loader(Terrain &t, Tile &l):
297         DataFile::ObjectLoader<Tile>(l),
298         terrain(t)
299 {
300         add("ground", &Loader::ground);
301         add("elevation", &Loader::elevation);
302         add("node", &Loader::node);
303 }
304
305 void Terrain::Tile::Loader::ground(unsigned g)
306 {
307         if(g>=terrain.type.get_n_surface_types())
308                 throw out_of_range("Tile::Loader::surface");
309         for(unsigned i=0; i<4; ++i)
310                 obj.nodes[i].ground = g;
311 }
312
313 void Terrain::Tile::Loader::elevation(float h)
314 {
315         for(unsigned i=0; i<4; ++i)
316                 obj.nodes[i].elevation = h;
317 }
318
319 void Terrain::Tile::Loader::node(unsigned i)
320 {
321         if(i>=4)
322                 throw out_of_range("Tile::Loader::node");
323         Node::Loader ldr(terrain, obj.nodes[i]);
324         load_sub_with(ldr);
325 }
326
327 } // namespace R2C2