X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;f=src%2FScenery%2Ftileentry.hxx;h=e315d515071cb97c50b0bb5b029ffddce5fe3827;hb=048da049f87fe3f543795f3b1b511d774caa2787;hp=8a5ec4c0a1df60a6d238cac29b559f487c64e285;hpb=e5a87cf9fa9374f0ae86b9ae38020e976d1830e1;p=flightgear.git diff --git a/src/Scenery/tileentry.hxx b/src/Scenery/tileentry.hxx index 8a5ec4c0a..e315d5150 100644 --- a/src/Scenery/tileentry.hxx +++ b/src/Scenery/tileentry.hxx @@ -2,7 +2,7 @@ // // Written by Curtis Olson, started May 1998. // -// Copyright (C) 1998, 1999 Curtis L. Olson - curt@flightgear.org +// Copyright (C) 1998 - 2001 Curtis L. Olson - curt@flightgear.org // // This program is free software; you can redistribute it and/or // modify it under the terms of the GNU General Public License as @@ -38,83 +38,102 @@ #endif #include -#include +#include -#include +#include #include #include STL_STRING -#include // plib includes +#include // plib includes -#include -#include -#include -#include +#include +#include +#include -#ifdef FG_HAVE_NATIVE_SGI_COMPILERS +#if defined( sgi ) #include #endif -FG_USING_STD(string); -FG_USING_STD(vector); +SG_USING_STD(string); +SG_USING_STD(vector); typedef vector < Point3D > point_list; typedef point_list::iterator point_list_iterator; typedef point_list::const_iterator const_point_list_iterator; +class FGTileEntry; -// Scenery tile class -class FGTileEntry { + +/** + * A class to hold deferred model loading info + */ +class FGDeferredModel { private: - // Tile state - enum tile_state { - Unused = 0, - Scheduled_for_use = 1, - Scheduled_for_cache = 2, - Loaded = 3, - Cached = 4 - }; + string model_path; + string texture_path; + FGTileEntry *tile; + ssgTransform *obj_trans; public: - typedef vector < fgFRAGMENT > container; - typedef container::iterator FragmentIterator; - typedef container::const_iterator FragmentConstIterator; + inline FGDeferredModel() { } + inline FGDeferredModel( const string mp, const string tp, + FGTileEntry *t, ssgTransform *ot ) + { + model_path = mp; + texture_path = tp; + tile = t; + obj_trans = ot; + } + inline ~FGDeferredModel() { } + inline string get_model_path() const { return model_path; } + inline string get_texture_path() const { return texture_path; } + inline FGTileEntry *get_tile() const { return tile; } + inline ssgTransform *get_obj_trans() const { return obj_trans; } +}; + + +/** + * A class to encapsulate everything we need to know about a scenery tile. + */ +class FGTileEntry { public: - // node list (the per fragment face lists reference this node list) + + /* CLO123 FROM HERE TO THE CORRESPONDING MARKER ARE THINGS THAT + CAN BE DELETED AFTER WE DROP THE ASCII SCENERY FORMAT */ + typedef vector < sgVec3 * > free_vec3_list; + typedef vector < sgVec2 * > free_vec2_list; + typedef vector < unsigned short * > free_index_list; + + // node list point_list nodes; int ncount; + /* CLO123 MARKER */ // global tile culling data Point3D center; double bounding_radius; Point3D offset; - // model view matrix for this tile - GLfloat model_view[16]; - // this tile's official location in the world - FGBucket tile_bucket; - - // the tile cache will keep track here if the tile is being used - tile_state state; + SGBucket tile_bucket; - container fragment_list; + // list of pointers to memory chunks that need to be freed when + // tile entry goes away + free_vec3_list vec3_ptrs; + free_vec2_list vec2_ptrs; + free_index_list index_ptrs; - // ssg related structures - sgVec3 *vtlist; - sgVec3 *vnlist; - sgVec2 *tclist; +private: // ssg tree structure for this tile is as follows: // ssgRoot(scene) // - ssgBranch(terrain) - // - ssgSelector(tile) // - ssgTransform(tile) // - ssgRangeSelector(tile) // - ssgEntity(tile) @@ -123,102 +142,144 @@ public: // ... // - kidn(fan) - // selector (turn tile on/off) - ssgSelector *select_ptr; - // pointer to ssg transform for this tile - ssgTransform *transform_ptr; + ssgTransform *terra_transform; + ssgTransform *rwy_lights_transform; + ssgTransform *gnd_lights_transform; // pointer to ssg range selector for this tile - ssgRangeSelector *range_ptr; + ssgRangeSelector *terra_range; + ssgRangeSelector *rwy_lights_range; + ssgRangeSelector *gnd_lights_range; + + // we create several preset brightness and can choose which one we + // want based on lighting conditions. + ssgSelector *gnd_lights_brightness; + + // ADA ---> + // Runway centre coords. + Point3D rway_center; // Reqd. for switching as function of distance from runway center + //pointers for Runway lights + ssgTransform *lightmaps_transform; // branch for runway lights + ssgRangeSelector *lightmaps_range; // tried to maintain same structure as Curt's ground + ssgSelector *lightmaps_brightness; // selector node for points/ lightmaps + + ssgSimpleState *lightmap_state; // OpenGL state of the polygons that make up runway lights + ssgVertexArray *light_points; // array of runway light coords. + // <--- ADA + + /** + * Indicates this tile has been loaded from a file and connected + * into the scene graph. Note that this may be set asynchronously + * by another thread. + */ + volatile bool loaded; + + /** + * Count of pending models to load for this tile. This tile + * cannot be removed until this number reaches zero (i.e. no + * pending models to load for this tile.) + */ + volatile int pending_models; + + bool obj_load( const std::string& path, + ssgBranch* geometry, + ssgBranch* rwy_lights, + ssgVertexArray* gound_lights, + bool is_base ); + + ssgLeaf* gen_lights( ssgVertexArray *lights, int inc, float bright ); + + double timestamp; public: + // ADA ---> + ssgTransform *ols_transform; // transform node for flols simulation + ssgSelector *lightmaps_sequence; // selector node for points/ lightmaps + ssgBranch* gen_runway_lights(ssgVertexArray *points,ssgVertexArray *normal, ssgVertexArray *dir, int *type); + // <--- ADA + // Constructor - FGTileEntry ( void ); + FGTileEntry( const SGBucket& b ); // Destructor - ~FGTileEntry ( void ); + ~FGTileEntry(); - FragmentIterator begin() { return fragment_list.begin(); } - FragmentConstIterator begin() const { return fragment_list.begin(); } - - FragmentIterator end() { return fragment_list.end(); } - FragmentConstIterator end() const { return fragment_list.end(); } - - void add_fragment( fgFRAGMENT& frag ) { - frag.tile_ptr = this; - fragment_list.push_back( frag ); - } - - size_t num_fragments() const { - return fragment_list.size(); - } +#ifdef WISH_PLIB_WAS_THREADED // but it isn't + // Schedule tile to be freed/removed + void sched_removal(); +#endif - // Step through the fragment list, deleting the display list, then - // the fragment, until the list is empty. Also delete the arrays + // Clean up the memory used by this tile and delete the arrays // used by ssg as well as the whole ssg branch void free_tile(); // Calculate this tile's offset - void SetOffset( const Point3D& off) + void SetOffset( const Point3D& p) { - offset = center - off; + offset = center - p; } // Return this tile's offset - inline Point3D get_offset( void ) const { return offset; } - - // Calculate the model_view transformation matrix for this tile - inline void update_view_matrix(GLfloat *MODEL_VIEW) - { + inline Point3D get_offset() const { return offset; } + + // Update the ssg transform node for this tile so it can be + // properly drawn relative to our (0,0,0) point + void prep_ssg_node( const Point3D& p, sgVec3 up, float vis); + + /** + * Load tile data from a file. + * @param base name of directory containing tile data file. + * @param is_base is this a base terrain object for which we should generate + * random ground light points */ + void load( const SGPath& base, bool is_base ); + + /** + * Return true if the tile entry is loaded, otherwise return false + * indicating that the loading thread is still working on this. + */ + inline bool is_loaded() const { return loaded; } + + /** + * decrement the pending models count + */ + inline void dec_pending_models() { pending_models--; } + + /** + * return the number of remaining pending models for this tile + */ + inline int get_pending_models() const { return pending_models; } + + /** + * Return the "bucket" for this tile + */ + inline SGBucket get_tile_bucket() const { return tile_bucket; } + + /** + * Add terrain mesh and ground lighting to scene graph. + */ + void add_ssg_nodes( ssgBranch* terrain_branch, + ssgBranch* gnd_lights_branch, + ssgBranch* rwy_lights_branch ); + + /** + * disconnect terrain mesh and ground lighting nodes from scene + * graph for this tile. + */ + void disconnect_ssg_nodes(); -#if defined( USE_MEM ) || defined( WIN32 ) - memcpy( model_view, MODEL_VIEW, 16*sizeof(GLfloat) ); -#else - bcopy( MODEL_VIEW, model_view, 16*sizeof(GLfloat) ); -#endif - // This is equivalent to doing a glTranslatef(x, y, z); - model_view[12] += (model_view[0]*offset.x() + - model_view[4]*offset.y() + - model_view[8]*offset.z()); - model_view[13] += (model_view[1]*offset.x() + - model_view[5]*offset.y() + - model_view[9]*offset.z()); - model_view[14] += (model_view[2]*offset.x() + - model_view[6]*offset.y() + - model_view[10]*offset.z() ); - // m[15] += (m[3]*x + m[7]*y + m[11]*z); - // m[3] m7[] m[11] are 0.0 see LookAt() in views.cxx - // so m[15] is unchanged - } + /** + * return the SSG Transform node for the terrain + */ + inline ssgTransform *get_terra_transform() { return terra_transform; } - inline bool is_unused() const { return state == Unused; } - inline bool is_scheduled_for_use() const { - return state == Scheduled_for_use; - } - inline bool is_scheduled_for_cache() const { - return state == Scheduled_for_cache; - } - inline bool is_loaded() const { return state == Loaded; } + void set_timestamp(double time_ms) { timestamp = time_ms; } - inline void mark_unused() { state = Unused; } - inline void mark_scheduled_for_use() { state = Scheduled_for_use; } - inline void mark_scheduled_for_cache() { state = Scheduled_for_use; } - inline void mark_loaded() { state = Loaded; } + inline double get_timestamp() const { return timestamp; } - - // when a tile is still in the cache, but not in the immediate - // draw l ist, it can still remain in the scene graph, but we use - // a range selector to disable it from ever being drawn. - void ssg_disable(); }; -typedef vector < FGTileEntry > tile_list; -typedef tile_list::iterator tile_list_iterator; -typedef tile_list::const_iterator const_tile_list_iterator; - - #endif // _TILEENTRY_HXX