]> git.mxchange.org Git - flightgear.git/blob - src/Scenery/tileentry.hxx
Add multiplayer support from Duncan McCreanor and Diarmuid Tyson
[flightgear.git] / src / Scenery / tileentry.hxx
1 // tileentry.hxx -- routines to handle an individual scenery tile
2 //
3 // Written by Curtis Olson, started May 1998.
4 //
5 // Copyright (C) 1998 - 2001  Curtis L. Olson  - curt@flightgear.org
6 //
7 // This program is free software; you can redistribute it and/or
8 // modify it under the terms of the GNU General Public License as
9 // published by the Free Software Foundation; either version 2 of the
10 // License, or (at your option) any later version.
11 //
12 // This program is distributed in the hope that it will be useful, but
13 // WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 // General Public License for more details.
16 //
17 // You should have received a copy of the GNU General Public License
18 // along with this program; if not, write to the Free Software
19 // Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 //
21 // $Id$
22
23
24 #ifndef _TILEENTRY_HXX
25 #define _TILEENTRY_HXX
26
27
28 #ifndef __cplusplus                                                          
29 # error This library requires C++
30 #endif                                   
31
32 #ifdef HAVE_CONFIG_H
33 #  include <config.h>
34 #endif
35
36 #include <simgear/compiler.h>
37
38 #include <vector>
39 #include STL_STRING
40
41 #include <plib/ssg.h>           // plib includes
42
43 #include <simgear/bucket/newbucket.hxx>
44 #include <simgear/math/point3d.hxx>
45 #include <simgear/misc/sg_path.hxx>
46
47 #if defined( sgi )
48 #include <strings.h>
49 #endif
50
51 SG_USING_STD(string);
52 SG_USING_STD(vector);
53
54
55 typedef vector < Point3D > point_list;
56 typedef point_list::iterator point_list_iterator;
57 typedef point_list::const_iterator const_point_list_iterator;
58
59 class FGTileEntry;
60
61
62 /**
63  * A class to hold deferred model loading info
64  */
65 class FGDeferredModel {
66
67 private:
68
69     string model_path;
70     string texture_path;
71     FGTileEntry *tile;
72     ssgTransform *obj_trans;
73
74 public:
75
76     inline FGDeferredModel() { }
77     inline FGDeferredModel( const string mp, const string tp,
78                      FGTileEntry *t, ssgTransform *ot )
79     {
80         model_path = mp;
81         texture_path = tp;
82         tile = t;
83         obj_trans = ot;
84     }
85     inline ~FGDeferredModel() { }
86     inline string get_model_path() const { return model_path; }
87     inline string get_texture_path() const { return texture_path; }
88     inline FGTileEntry *get_tile() const { return tile; }
89     inline ssgTransform *get_obj_trans() const { return obj_trans; }
90 };
91
92
93 /**
94  * A class to encapsulate everything we need to know about a scenery tile.
95  */
96 class FGTileEntry {
97
98 public:
99
100     /* CLO123 FROM HERE TO THE CORRESPONDING MARKER ARE THINGS THAT
101        CAN BE DELETED AFTER WE DROP THE ASCII SCENERY FORMAT */
102     typedef vector < sgVec3 * > free_vec3_list;
103     typedef vector < sgVec2 * > free_vec2_list;
104     typedef vector < unsigned short * > free_index_list;
105
106     // node list
107     point_list nodes;
108     int ncount;
109     /* CLO123 MARKER */
110
111     // global tile culling data
112     Point3D center;
113     double bounding_radius;
114     Point3D offset;
115
116     // this tile's official location in the world
117     SGBucket tile_bucket;
118
119     // list of pointers to memory chunks that need to be freed when
120     // tile entry goes away
121     free_vec3_list vec3_ptrs;
122     free_vec2_list vec2_ptrs;
123     free_index_list index_ptrs;
124
125 private:
126
127     // ssg tree structure for this tile is as follows:
128     // ssgRoot(scene)
129     //     - ssgBranch(terrain)
130     //        - ssgTransform(tile)
131     //           - ssgRangeSelector(tile)
132     //              - ssgEntity(tile)
133     //                 - kid1(fan)
134     //                 - kid2(fan)
135     //                   ...
136     //                 - kidn(fan)
137
138     // pointer to ssg transform for this tile
139     ssgTransform *terra_transform;
140     ssgTransform *rwy_lights_transform;
141     ssgTransform *taxi_lights_transform;
142     ssgTransform *gnd_lights_transform;
143
144     // pointer to ssg range selector for this tile
145     ssgRangeSelector *terra_range;
146     ssgRangeSelector *gnd_lights_range;
147
148     // we create several preset brightness and can choose which one we
149     // want based on lighting conditions.
150     ssgSelector *gnd_lights_brightness;
151
152     // ADA --->
153     // Runway centre coords.
154     Point3D rway_center; // Reqd. for switching as function of distance from runway center
155     //pointers for Runway lights    
156     ssgTransform *lightmaps_transform; // branch for runway lights
157     ssgRangeSelector *lightmaps_range; // tried to maintain same structure as Curt's ground
158     ssgSelector *lightmaps_brightness; // selector node for points/ lightmaps
159
160     ssgSimpleState *lightmap_state; // OpenGL state of the polygons that make up runway lights
161     ssgVertexArray *light_points; // array of runway light coords.
162     // <--- ADA
163
164     /**
165      * Indicates this tile has been loaded from a file and connected
166      * into the scene graph.  Note that this may be set asynchronously
167      * by another thread.
168      */
169     volatile bool loaded;
170
171     /**
172      * Count of pending models to load for this tile.  This tile
173      * cannot be removed until this number reaches zero (i.e. no
174      * pending models to load for this tile.)
175      */
176     volatile int pending_models;
177
178     bool obj_load( const std::string& path,
179                          ssgBranch* geometry,
180                          ssgBranch* rwy_lights,
181                          ssgBranch* taxi_lights,
182                          ssgVertexArray* gound_lights,
183                          bool is_base );
184
185     ssgLeaf* gen_lights( ssgVertexArray *lights, int inc, float bright );
186
187     double timestamp;
188
189
190     // this variable tracks the status of the incremental memory freeing.
191     enum {
192         NODES = 0x01,
193         VEC_PTRS = 0x02,
194         TERRA_NODE = 0x04,
195         GROUND_LIGHTS = 0x08,
196         RWY_LIGHTS = 0x10,
197         TAXI_LIGHTS = 0x20,
198         LIGHTMAPS = 0x40
199     };
200     int free_tracker;
201
202 public:
203
204     // ADA --->
205     ssgTransform *ols_transform; // transform node for flols simulation
206     ssgSelector *lightmaps_sequence; // selector node for points/ lightmaps
207     ssgBranch* gen_runway_lights(ssgVertexArray *points,ssgVertexArray *normal, ssgVertexArray *dir, int *type);
208     // <--- ADA
209
210     // Constructor
211     FGTileEntry( const SGBucket& b );
212
213     // Destructor
214     ~FGTileEntry();
215
216     // Clean up the memory used by this tile and delete the arrays
217     // used by ssg as well as the whole ssg branch.  This does a
218     // partial clean up and exits so we can spread the load across
219     // multiple frames.  Returns false if work remaining to be done,
220     // true if dynamically allocated memory used by this tile is
221     // completely freed.
222     bool free_tile();
223
224     // Calculate this tile's offset
225     void SetOffset( const Point3D& p)
226     {
227         offset = center - p;
228     }
229
230     // Return this tile's offset
231     inline Point3D get_offset() const { return offset; }
232
233     // Update the ssg transform node for this tile so it can be
234     // properly drawn relative to our (0,0,0) point
235     void prep_ssg_node( const Point3D& p, sgVec3 up, float vis);
236
237     /**
238      * Load tile data from a file.
239      * @param base name of directory containing tile data file.
240      * @param is_base is this a base terrain object for which we should generate
241      *        random ground light points */
242     void load( const SGPath& base, bool is_base );
243
244     /**
245      * Return true if the tile entry is loaded, otherwise return false
246      * indicating that the loading thread is still working on this.
247      */
248     inline bool is_loaded() const { return loaded; }
249
250     /**
251      * decrement the pending models count
252      */
253     inline void dec_pending_models() { pending_models--; }
254
255     /**
256      * return the number of remaining pending models for this tile
257      */
258     inline int get_pending_models() const { return pending_models; }
259
260     /**
261      * Return the "bucket" for this tile
262      */
263     inline SGBucket get_tile_bucket() const { return tile_bucket; }
264
265     /**
266      * Add terrain mesh and ground lighting to scene graph.
267      */
268     void add_ssg_nodes( ssgBranch* terrain_branch,
269                         ssgBranch* gnd_lights_branch,
270                         ssgBranch* rwy_lights_branch,
271                         ssgBranch* taxi_lights_branch );
272
273     /**
274      * disconnect terrain mesh and ground lighting nodes from scene
275      * graph for this tile.
276      */
277     void disconnect_ssg_nodes();
278
279         
280     /**
281      * return the SSG Transform node for the terrain
282      */
283     inline ssgTransform *get_terra_transform() { return terra_transform; }
284
285     void set_timestamp(double time_ms) { timestamp = time_ms; }
286
287     inline double get_timestamp() const { return timestamp; }
288
289 };
290
291
292 #endif // _TILEENTRY_HXX