]> git.mxchange.org Git - flightgear.git/blob - src/Scenery/tilemgr.hxx
Multiplayer client/server system -- Message base class, "hello" message, and message...
[flightgear.git] / src / Scenery / tilemgr.hxx
1 // tilemgr.hxx -- routines to handle dynamic management of scenery tiles
2 //
3 // Written by Curtis Olson, started January 1998.
4 //
5 // Copyright (C) 1997  Curtis L. Olson  - curt@infoplane.com
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 _TILEMGR_HXX
25 #define _TILEMGR_HXX
26
27
28 #ifndef __cplusplus                                                          
29 # error This library requires C++
30 #endif                                   
31
32 #include <simgear/compiler.h>
33 #include <simgear/math/point3d.hxx>
34 #include <simgear/scene/model/location.hxx>
35
36 #include <queue>
37
38 #include <plib/ssg.h>
39
40 #include <simgear/bucket/newbucket.hxx>
41 #ifdef ENABLE_THREADS
42 #  include <simgear/threads/SGQueue.hxx>
43 #endif // ENABLE_THREADS
44
45 #include "FGTileLoader.hxx"
46 #include "hitlist.hxx"
47 #include "newcache.hxx"
48
49 #if defined(USE_MEM) || defined(WIN32)
50 #  define FG_MEM_COPY(to,from,n)        memcpy(to, from, n)
51 #else
52 #  define FG_MEM_COPY(to,from,n)        bcopy(from, to, n)
53 #endif
54
55 SG_USING_STD( queue );
56
57
58 // forward declaration
59 class FGTileEntry;
60 class FGDeferredModel;
61
62
63 class FGTileMgr {
64
65 private:
66
67     // Tile loading state
68     enum load_state {
69         Start = 0,
70         Inited = 1,
71         Running = 2
72     };
73
74     load_state state;
75
76     // initialize the cache
77     void initialize_queue();
78
79     // schedule a tile for loading
80     void sched_tile( const SGBucket& b );
81
82     // schedule a needed buckets for loading
83     void schedule_needed(double visibility_meters, SGBucket curr_bucket);
84
85     // see comment at prep_ssg_nodes()
86     void prep_ssg_node( int idx );
87         
88     FGHitList hit_list;
89
90     SGBucket previous_bucket;
91     SGBucket current_bucket;
92     SGBucket pending;
93         
94     FGTileEntry *current_tile;
95         
96     // x and y distance of tiles to load/draw
97     float vis;
98     int xrange, yrange;
99         
100     // current longitude latitude
101     double longitude;
102     double latitude;
103     double last_longitude;
104     double last_latitude;
105
106     /**
107      * tile cache
108      */
109     FGNewCache tile_cache;
110
111     /**
112      * Queue tiles for loading.
113      */
114     FGTileLoader loader;
115     int counter_hack;
116
117     /**
118      * Work queues.
119      *
120      * attach_queue is the tiles that have been loaded [by the pager]
121      * that can be attached to the scene graph by the render thread.
122      *
123      * model_queue is the set of models that need to be loaded by the
124      * primary render thread.
125      */
126 #ifdef ENABLE_THREADS
127     static SGLockedQueue<FGTileEntry *> attach_queue;
128     static SGLockedQueue<FGDeferredModel *> model_queue;
129 #else
130     static queue<FGTileEntry *> attach_queue;
131     static queue<FGDeferredModel *> model_queue;
132 #endif // ENABLE_THREADS
133     static queue<FGTileEntry *> delete_queue;
134
135 public:
136
137     /**
138      * Add a loaded tile to the 'attach to the scene graph' queue.
139      */
140     static void ready_to_attach( FGTileEntry *t ) { attach_queue.push( t ); }
141
142     /**
143      * Add a pending model to the 'deferred model load' queue
144      */
145     static void model_ready( FGDeferredModel *dm ) { model_queue.push( dm ); }
146
147 public:
148
149     // Constructor
150     FGTileMgr();
151
152     // Destructor
153     ~FGTileMgr();
154
155     // Initialize the Tile Manager subsystem
156     int init();
157
158     // Update the various queues maintained by the tilemagr (private
159     // internal function, do not call directly.)
160     void update_queues();
161
162     // given the current lon/lat (in degrees), fill in the array of
163     // local chunks.  If the chunk isn't already in the cache, then
164     // read it from disk.
165     int update( double visibility_meters );
166     int update( SGLocation *location, double visibility_meters,
167                 sgdVec3 abs_pos_vector );
168
169     int updateCurrentElevAtPos(sgdVec3 abs_pos_vector, Point3D center );
170
171     // Determine scenery altitude.  Normally this just happens when we
172     // render the scene, but we'd also like to be able to do this
173     // explicitely.  lat & lon are in radians.  abs_view_pos in
174     // meters.  Returns result in meters.
175     void my_ssg_los( string s, ssgBranch *branch, sgdMat4 m, 
176                      const sgdVec3 p, const sgdVec3 dir, sgdVec3 normal );
177         
178     void my_ssg_los( ssgBranch *branch, sgdMat4 m, 
179                      const sgdVec3 p, const sgdVec3 dir,
180                      FGHitList *list );
181
182     // Prepare the ssg nodes corresponding to each tile.  For each
183     // tile, set the ssg transform and update it's range selector
184     // based on current visibilty void prep_ssg_nodes( float
185     // visibility_meters );
186     void prep_ssg_nodes( SGLocation *location, float visibility_meters );
187
188     // Set flag with event manager so that non-moving view refreshes
189     // tiles...
190     void refresh_view_timestamps();
191
192     inline SGBucket get_current_bucket () { return current_bucket; }
193     inline SGBucket get_previous_bucket () { return previous_bucket; }
194 };
195
196
197 #endif // _TILEMGR_HXX