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