track_8hpp_source.html

 //  SuperTuxKart - a fun racing game with go-kart

 //

 //  Copyright (C) 2004-2015 Steve Baker <sjbaker1@airmail.net>

 //  Copyright (C) 2009-2015  Joerg Henrichs, Steve Baker

 //

 //  This program is free software; you can redistribute it and/or

 //  modify it under the terms of the GNU General Public License

 //  as published by the Free Software Foundation; either version 3

 //  of the License, or (at your option) any later version.

 //

 //  This program is distributed in the hope that it will be useful,

 //  but WITHOUT ANY WARRANTY; without even the implied warranty of

 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 //  GNU General Public License for more details.

 //

 //  You should have received a copy of the GNU General Public License

 //  along with this program; if not, write to the Free Software

 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.


 #ifndef HEADER_TRACK_HPP

 #define HEADER_TRACK_HPP


 #include <algorithm>

 #include <array>

 #include <atomic>

 #include <memory>

 #include <string>

 #include <vector>


 #include <irrString.h>

 #include <rect.h>

 #include <SColor.h>


 namespace irr

 {

     namespace scene

     {

         class IMesh; class ISceneNode;

     }

     namespace video

     {

         class IImage; class ITexture;

     }

 }


 using namespace irr;


 #include "LinearMath/btTransform.h"


 #include "utils/aligned_array.hpp"

 #include "utils/log.hpp"

 #include "utils/random_generator.hpp"

 #include "utils/vec3.hpp"

 #include "utils/stk_process.hpp"


 class AbstractKart;

 class AnimationManager;

 class BezierCurve;

 class CheckManager;

 class ItemManager;

 class ModelDefinitionLoader;

 class MovingTexture;

 class MusicInformation;

 class ParticleKind;

 class PhysicalObject;

 class RenderTarget;

 class TrackObject;

 class TrackObjectManager;

 class TriangleMesh;

 class XMLNode;


 const int HEIGHT_MAP_RESOLUTION = 256;


 // TODO: eventually remove this and fully replace with scripting

 struct OverworldChallenge

 {

 public:

     core::vector3df m_position;

     std::string m_challenge_id;


     OverworldChallenge(core::vector3df position, std::string challenge_id)

     {

         m_position = position;

         m_challenge_id = challenge_id;

     }

 };


 struct Subtitle

 {

     int m_from, m_to;

     core::stringw m_text;


     Subtitle(int from, int to, core::stringw text)

     {

         m_from = from;

         m_to = to;

         m_text = text;

     }

     int getFrom() const { return m_from; }

     int getTo()   const { return m_to;   }

     const core::stringw& getText() const { return m_text; }

 };


 class Track

 {

 private:


     static std::atomic<Track*> m_current_track[PT_COUNT];


 #ifdef DEBUG

     unsigned int             m_magic_number;

 #endif


     /* Gravity to be used for this track. */

     float                    m_gravity;


     float                    m_friction;


     std::string              m_ident;

     std::string              m_screenshot;

     bool                     m_is_day;

     std::vector<MusicInformation*> m_music;

     unsigned                       m_music_idx;


     std::vector<OverworldChallenge> m_challenges;


     std::vector<Subtitle> m_subtitles;


     AlignedArray<btTransform> m_start_transforms;


     std::string              m_item_style;

     std::string              m_description;

     core::stringw            m_designer;


     /* For running the startup script */

     bool m_startup_run;

     std::string              m_filename;


     std::string              m_root;

     std::vector<std::string> m_groups;


     std::vector<scene::ISceneNode*> m_all_nodes;


     std::vector<scene::ISceneNode*> m_static_physics_only_nodes;


     std::vector<scene::ISceneNode*> m_object_physics_only_nodes;


     std::vector<scene::IMesh*>      m_all_cached_meshes;


     std::vector<scene::IMesh*>      m_detached_cached_meshes;


     std::vector<video::ITexture*>   m_all_cached_textures;


     bool m_materials_loaded;


     bool m_cache_track;


 #ifdef DEBUG

     std::vector<video::ITexture*>   m_old_textures;


     std::vector<std::string> m_old_mesh_buffers;

 #endif


     scene::ISceneNode  *m_sun;

     TriangleMesh*            m_track_mesh;

     TriangleMesh*            m_height_map_mesh;

     TriangleMesh*            m_gfx_effect_mesh;

     Vec3                     m_aabb_min;

     Vec3                     m_aabb_max;

     btTransform              m_red_flag;

     btTransform              m_blue_flag;

     bool                     m_is_arena;

     bool                     m_is_ctf;

     unsigned int             m_max_arena_players;

     bool                     m_has_easter_eggs;

     bool                     m_has_navmesh;

     bool                     m_is_soccer;


     bool                     m_is_cutscene;


     int                      m_version;


     float                    m_camera_far;


     bool                     m_internal;


     bool                     m_reverse_available;


     bool                     m_enable_auto_rescue;


     bool                     m_enable_push_back;


     enum {SKY_NONE, SKY_BOX,

           SKY_COLOR}          m_sky_type;


     float m_sky_dx, m_sky_dy;


     std::vector<void*> m_sky_textures;


     std::vector<void*> m_spherical_harmonics_textures;


     irr::video::SColor m_sky_color;


     std::vector<MovingTexture*> m_animated_textures;


     TrackObjectManager *m_track_object_manager;


     int                      m_sky_hori_segments;


     int                      m_sky_vert_segments;


     float                    m_sky_sphere_percent;


     float                    m_sky_texture_percent;


     ParticleKind*            m_sky_particles;


     bool                     m_weather_lightning;

     std::string              m_weather_sound;


     class TrackMode

     {

     public:

         std::string m_name;

         std::string m_quad_name;

         std::string m_graph_name;

         std::string m_scene;

 #ifdef DEBUG

         unsigned int m_magic_number;

 #endif


         TrackMode() : m_name("default"),         m_quad_name("quads.xml"),

                       m_graph_name("graph.xml"), m_scene("scene.xml")

         {

 #ifdef DEBUG

             m_magic_number = 0x46825179;

 #endif

         }


         ~TrackMode()

         {

 #ifdef DEBUG

             assert(m_magic_number == 0x46825179);

             m_magic_number = 0xDEADBEEF;

 #endif

         }


     };   // TrackMode


     std::vector<TrackMode> m_all_modes;


     std::string         m_name;


     core::stringw       m_sort_name;


     bool                m_use_fog;


     bool                m_force_disable_fog;


     bool                m_smooth_normals;


     bool                m_is_addon;


     float               m_fog_max;

     float               m_fog_start;

     float               m_fog_end;

     float               m_fog_height_start;

     float               m_fog_height_end;

     core::vector3df     m_sun_position;

     video::SColor       m_ambient_color;

     video::SColor       m_default_ambient_color;

     video::SColor       m_sun_specular_color;

     video::SColor       m_sun_diffuse_color;

     video::SColor       m_fog_color;


     RenderTarget           *m_render_target;

     CheckManager*           m_check_manager;

     std::shared_ptr<ItemManager> m_item_manager;

     float                   m_minimap_x_scale;

     float                   m_minimap_y_scale;


     bool m_bloom;

     float m_bloom_threshold;


     bool m_godrays;

     core::vector3df m_godrays_position;

     float m_godrays_opacity;

     video::SColor m_godrays_color;


     bool m_shadows;


     float m_displacement_speed;

     int m_physical_object_uid;


     bool m_minimap_invert_x_z;


     core::vector3df m_color_inlevel;

     core::vector2df m_color_outlevel;


     std::vector<BezierCurve*> m_all_curves;


     std::vector<std::pair<TrackObject*, TrackObject*> > m_meta_library;


     int m_default_number_of_laps;


     int m_actual_number_of_laps;


     void loadTrackInfo();

     void loadDriveGraph(unsigned int mode_id, const bool reverse);

     void loadArenaGraph(const XMLNode &node);

     btQuaternion getArenaStartRotation(const Vec3& xyz, float heading);

     bool loadMainTrack(const XMLNode &node);

     void loadMinimap();

     void createWater(const XMLNode &node);

     void getMusicInformation(std::vector<std::string>&  filenames,

                              std::vector<MusicInformation*>& m_music   );

     void loadCurves(const XMLNode &node);

     void handleSky(const XMLNode &root, const std::string &filename);

     void freeCachedMeshVertexBuffer();

     void copyFromMainProcess();

     video::IImage* getSkyTexture(std::string path) const;

     scene::IMesh* getClonedMesh(const std::string& filename) const;

 public:


     static Track* getCurrentTrack()

     {

         ProcessType type = STKProcess::getType();

         return m_current_track[type];

     }

     // ------------------------------------------------------------------------

     Track* clone()

     {

         Track* child_track = new Track(*this);

         child_track->copyFromMainProcess();

         return child_track;

     }

     // ------------------------------------------------------------------------

     void initChildTrack();

     // ------------------------------------------------------------------------

     static void cleanChildTrack();

     // ------------------------------------------------------------------------

     void handleAnimatedTextures(scene::ISceneNode *node, const XMLNode &xml);


     static bool        m_dont_load_navmesh;


     static void uploadNodeVertexBuffer(scene::ISceneNode *node);


     static const float NOHIT;


                        Track             (const std::string &filename);

                       ~Track             ();

     void               cleanup           ();

     void               removeCachedData  ();

     void               startMusic        () const;


     void               createPhysicsModel(unsigned int main_track_count,

                                           bool for_height_map);

     void               updateGraphics(float dt);

     void               update(int ticks);

     void               reset();

     void               itemCommand(const XMLNode *node);

     Vec3               flagCommand(const XMLNode *node);

     //-----------------------------------------------------------------------------

     core::stringw      getName() const;

     //-----------------------------------------------------------------------------

     core::stringw      getSortName() const;

     bool               isInGroup(const std::string &group_name);

     const core::vector3df& getSunRotation();

     void               setAmbientColor(const video::SColor &color,

                                        unsigned int k);

     void               handleExplosion(const Vec3 &pos,

                                        const PhysicalObject *mp,

                                        bool secondary_hits=true) const;

     void               loadTrackModel  (bool reverse_track = false,

                                         unsigned int mode_id=0);

     bool findGround(AbstractKart *kart);


     std::vector< std::vector<float> > buildHeightMap();

     void               drawMiniMap(const core::rect<s32>& dest_rect) const;

     void               updateMiniMapScale();

     // ------------------------------------------------------------------------

     bool isArena() const { return m_is_arena; }

     // ------------------------------------------------------------------------

     bool isCTF() const { return m_is_ctf; }

     // ------------------------------------------------------------------------

     bool isRaceTrack() const

     {

         return !m_internal && !m_is_arena && !m_is_soccer;

     }   // isRaceTrack

     // ------------------------------------------------------------------------

     bool hasEasterEggs() const { return m_has_easter_eggs; }

     // ------------------------------------------------------------------------

     bool reverseAvailable() const { return m_reverse_available; }

     // ------------------------------------------------------------------------

     bool hasNavMesh() const { return m_has_navmesh; }

     // ------------------------------------------------------------------------

     void loadObjects(const XMLNode* root, const std::string& path,

         ModelDefinitionLoader& lod_loader, bool create_lod_definitions,

         scene::ISceneNode* parent, TrackObject* parent_library);

     // ------------------------------------------------------------------------

     bool               isSoccer             () const { return m_is_soccer; }

     // ------------------------------------------------------------------------

     void               addMusic          (MusicInformation* mi)

                                                   {m_music.push_back(mi);     }

     // ------------------------------------------------------------------------

     float              getGravity        () const {return m_gravity;          }

     // ------------------------------------------------------------------------

     int                getVersion        () const {return m_version;          }

     // ------------------------------------------------------------------------

     float              getTrackLength    () const;

     // ------------------------------------------------------------------------

     const std::string& getIdent          () const {return m_ident;            }

     // ------------------------------------------------------------------------

     const std::vector<std::string>&

                        getGroups         () const {return m_groups;           }

     // ------------------------------------------------------------------------

     const std::string& getFilename       () const {return m_filename;         }

     // ------------------------------------------------------------------------

     const core::stringw& getDesigner     () const {return m_designer;         }

     // ------------------------------------------------------------------------

     const std::string& getScreenshotFile () const {return m_screenshot;       }

     // ------------------------------------------------------------------------

     const bool getIsDuringDay () const {return m_is_day;               }

     // ------------------------------------------------------------------------

     const bool getMinimapInvert () const {return m_minimap_invert_x_z;               }

     // ------------------------------------------------------------------------

     const btTransform& getStartTransform (unsigned int index) const

     {

         if (index >= m_start_transforms.size())

             Log::fatal("Track", "No start position for kart %i.", index);

         return m_start_transforms[index];

     }

     // ------------------------------------------------------------------------

     void shuffleStartTransforms()

     {

        std::shuffle(m_start_transforms.begin(), m_start_transforms.end(),

                     RandomGenerator::getGenerator());

     }

     // ------------------------------------------------------------------------

     void               getAABB(const Vec3 **min, const Vec3 **max) const

                        { *min = &m_aabb_min; *max = &m_aabb_max; }

     // ------------------------------------------------------------------------

     float              getAngle(int n) const;

     // ------------------------------------------------------------------------

     void               mapPoint2MiniMap(const Vec3 &xyz, Vec3 *draw_at) const;

     // ------------------------------------------------------------------------

     std::string        getTrackFile(const std::string &s) const

                                 { return m_root+"/"+s; }

     // ------------------------------------------------------------------------

     unsigned int       getNumberOfModes() const { return (unsigned int) m_all_modes.size();  }

     // ------------------------------------------------------------------------

     unsigned int getNumOfCompletedChallenges();

     // ------------------------------------------------------------------------

     const std::string &getModeName(unsigned int i) const

                                               { return m_all_modes[i].m_name; }

     // ------------------------------------------------------------------------

     const video::SColor &getDefaultAmbientColor() const

                                             { return m_default_ambient_color; }

     // ------------------------------------------------------------------------

     float  getCameraFar() const { return m_camera_far; }

     // ------------------------------------------------------------------------

     const TriangleMesh *getPtrTriangleMesh() const { return m_track_mesh; }

     const TriangleMesh& getTriangleMesh() const {return *m_track_mesh; }

     // ------------------------------------------------------------------------

     const TriangleMesh& getGFXEffectMesh() const {return *m_gfx_effect_mesh;}

     // ------------------------------------------------------------------------

     unsigned int getMaxArenaPlayers() const

                                                 { return m_max_arena_players; }

     // ------------------------------------------------------------------------

     unsigned int getNumberOfStartPositions() const

                             { return (unsigned int)m_start_transforms.size(); }

     // ------------------------------------------------------------------------

     bool getWeatherLightning() {return m_weather_lightning;}

     // ------------------------------------------------------------------------

     const std::string& getWeatherSound() {return m_weather_sound;}

     // ------------------------------------------------------------------------

     ParticleKind* getSkyParticles         () { return m_sky_particles; }

     // ------------------------------------------------------------------------

     void forceFogDisabled(bool v) { m_force_disable_fog = v; }

     //-------------------------------------------------------------------------

     bool isFogEnabled() const

     {

         return !m_force_disable_fog && m_use_fog;

     }   // isFogEnabled


     // ------------------------------------------------------------------------

     float getFogStart()  const { return m_fog_start; }

     // ------------------------------------------------------------------------

     void setFogStart(float start) { m_fog_start = start; }

     // ------------------------------------------------------------------------

     float getFogEnd()    const { return m_fog_end; }

     // ------------------------------------------------------------------------

     void setFogEnd(float end) { m_fog_end = end; }

     // ------------------------------------------------------------------------

     float getFogStartHeight()  const { return m_fog_height_start; }

     // ------------------------------------------------------------------------

     float getFogEndHeight()    const { return m_fog_height_end; }

     // ------------------------------------------------------------------------

     float getFogMax()    const { return m_fog_max; }

     // ------------------------------------------------------------------------

     void setFogMax(float max) { m_fog_max = max; }

     // ------------------------------------------------------------------------

     video::SColor getFogColor() const { return m_fog_color; }

     // ------------------------------------------------------------------------

     void setFogColor(video::SColor& color) { m_fog_color = color; }

     // ------------------------------------------------------------------------

     video::SColor getSunColor() const { return m_sun_diffuse_color; }

     // ------------------------------------------------------------------------

     bool isInternal() const { return m_internal; }

     // ------------------------------------------------------------------------

     bool isAutoRescueEnabled() const { return m_enable_auto_rescue; }

     // ------------------------------------------------------------------------

     bool isPushBackEnabled() const { return m_enable_push_back; }

     // ------------------------------------------------------------------------

     bool smoothNormals() const { return m_smooth_normals; }

     // ------------------------------------------------------------------------

     TrackObjectManager* getTrackObjectManager() const

     {

         return m_track_object_manager;

     }   // getTrackObjectManager


     // ------------------------------------------------------------------------

     const std::vector<OverworldChallenge>& getChallengeList() const

         { return m_challenges; }


     // ------------------------------------------------------------------------

     const std::vector<Subtitle>& getSubtitles() const { return m_subtitles; }


     // ------------------------------------------------------------------------

     bool hasBloom() const { return m_bloom; }


     // ------------------------------------------------------------------------

     float getBloomThreshold() const { return m_bloom_threshold; }


     // ------------------------------------------------------------------------

     core::vector3df getColorLevelIn() const { return m_color_inlevel; }

     // ------------------------------------------------------------------------

     core::vector2df getColorLevelOut() const { return m_color_outlevel; }

     // ------------------------------------------------------------------------

     bool hasGodRays() const { return m_godrays; }

     // ------------------------------------------------------------------------

     core::vector3df getGodRaysPosition() const { return m_godrays_position; }

     // ------------------------------------------------------------------------

     float getGodRaysOpacity() const { return m_godrays_opacity; }

     // ------------------------------------------------------------------------

     video::SColor getGodRaysColor() const { return m_godrays_color; }

     // ------------------------------------------------------------------------

     bool hasShadows() const { return m_shadows; }

     // ------------------------------------------------------------------------

     void addNode(scene::ISceneNode* node) { m_all_nodes.push_back(node); }

     // ------------------------------------------------------------------------

     void addPhysicsOnlyNode(scene::ISceneNode* node)

     {

         m_object_physics_only_nodes.push_back(node);

     }

     // ------------------------------------------------------------------------

     float getDisplacementSpeed() const { return m_displacement_speed;    }

     // ------------------------------------------------------------------------

     int getPhysicalObjectUID()              { return m_physical_object_uid++; }

     // ------------------------------------------------------------------------

     const int getDefaultNumberOfLaps() const { return m_default_number_of_laps;}

     // ------------------------------------------------------------------------

     const int getActualNumberOfLap() const { return m_actual_number_of_laps; }

     // ------------------------------------------------------------------------

     void setActualNumberOfLaps(unsigned int laps)

                                          { m_actual_number_of_laps = laps; }

     // ------------------------------------------------------------------------

     bool operator<(const Track &other) const;

     // ------------------------------------------------------------------------

     void addCachedMesh(scene::IMesh* mesh) { m_all_cached_meshes.push_back(mesh); }

     // ------------------------------------------------------------------------

     void addMetaLibrary(TrackObject* parent, TrackObject* meta_library)

                          { m_meta_library.emplace_back(parent, meta_library); }

     // ------------------------------------------------------------------------

     const btTransform& getRedFlag() const                { return m_red_flag; }

     // ------------------------------------------------------------------------

     const btTransform& getBlueFlag() const              { return m_blue_flag; }

     // ------------------------------------------------------------------------

     bool isAddon() const                                 { return m_is_addon; }

     // ------------------------------------------------------------------------

     void convertTrackToBullet(scene::ISceneNode *node,

                       std::vector<std::array<btVector3, 3> >* occluder = NULL);

     // ------------------------------------------------------------------------

     CheckManager* getCheckManager() const           { return m_check_manager; }

     // ------------------------------------------------------------------------

     ItemManager* getItemManager() const        { return m_item_manager.get(); }

     // ------------------------------------------------------------------------

     bool isOnGround(const Vec3& xyz, const Vec3& down, Vec3* hit_point,

                     Vec3* normal, bool print_warning = true);

     // ------------------------------------------------------------------------

     MusicInformation* getTrackMusic() const

     {

         if (m_music_idx < m_music.size())

             return m_music[m_music_idx];

         return NULL;

     }

 };   // class Track


 #endif

AbstractKart
An abstract interface for the actual karts.
Definition: abstract_kart.hpp:62

BezierCurve
A class to manage bezier curves and interpolation.
Definition: bezier_curve.hpp:34

CheckManager
Controls all checks structures of a track.
Definition: check_manager.hpp:40

ItemManager
Definition: item_manager.hpp:47

ModelDefinitionLoader
Utility class to load level-of-detail nodes and library nodes.
Definition: model_definition_loader.hpp:81

MovingTexture
Handles animated textures (textures that move)
Definition: moving_texture.hpp:34

MusicInformation
Wrapper around an instance of the Music interface Adds information like composer, song title,...
Definition: music_information.hpp:43

ParticleKind
type of particles
Definition: particle_kind.hpp:42

PhysicalObject
Definition: physical_object.hpp:40

RandomGenerator::getGenerator
static std::mt19937 & getGenerator()
Return a reference to the thread-local generator.
Definition: random_generator.cpp:25

RenderTarget
Definition: render_target.hpp:42

TrackObjectManager
Definition: track_object_manager.hpp:39

TrackObject
This is a base object for any separate object on the track, which might also have a skeletal animatio...
Definition: track_object.hpp:56

Track::TrackMode
A simple class to keep information about a track mode.
Definition: track.hpp:311

Track::TrackMode::m_quad_name
std::string m_quad_name
Name of the quad file to use.
Definition: track.hpp:314

Track::TrackMode::m_graph_name
std::string m_graph_name
Name of the graph file to use.
Definition: track.hpp:315

Track::TrackMode::TrackMode
TrackMode()
Default constructor, sets default names for all fields.
Definition: track.hpp:323

Track::TrackMode::m_scene
std::string m_scene
Name of the scene file to use.
Definition: track.hpp:316

Track::TrackMode::m_name
std::string m_name
Name / description of this mode.
Definition: track.hpp:313

Track
Definition: track.hpp:115

Track::getVersion
int getVersion() const
Returns the version of the .track file.
Definition: track.hpp:528

Track::m_all_cached_meshes
std::vector< scene::IMesh * > m_all_cached_meshes
The list of all meshes that are loaded from disk, which means that those meshes are being cached by i...
Definition: track.hpp:174

Track::m_all_curves
std::vector< BezierCurve * > m_all_curves
List of all bezier curves in the track - for e.g.
Definition: track.hpp:403

Track::m_sky_color
irr::video::SColor m_sky_color
Used if m_sky_type is SKY_COLOR only.
Definition: track.hpp:280

Track::getDesigner
const core::stringw & getDesigner() const
Returns the name of the designer.
Definition: track.hpp:544

Track::setAmbientColor
void setAmbientColor(const video::SColor &color, unsigned int k)
Sets the current ambient color for a kart with index k.

Track::m_render_target
RenderTarget * m_render_target
The render target for the mini map, which is displayed in the race gui.
Definition: track.hpp:375

Track::m_gfx_effect_mesh
TriangleMesh * m_gfx_effect_mesh
Used to collect the triangles which do not have a physical representation, but are needed for some ra...
Definition: track.hpp:220

Track::getAABB
void getAABB(const Vec3 **min, const Vec3 **max) const
Sets pointer to the aabb of this track.
Definition: track.hpp:573

Track::shuffleStartTransforms
void shuffleStartTransforms()
Shuffles the start transformations.
Definition: track.hpp:566

Track::m_track_object_manager
TrackObjectManager * m_track_object_manager
Manager for all track objects.
Definition: track.hpp:286

Track::m_actual_number_of_laps
int m_actual_number_of_laps
The number of laps that is predefined in a track info dialog.
Definition: track.hpp:412

Track::m_max_arena_players
unsigned int m_max_arena_players
Max players supported by an arena.
Definition: track.hpp:231

Track::getCurrentTrack
static Track * getCurrentTrack()
Static function to get the current track.
Definition: track.hpp:433

Track::getPtrTriangleMesh
const TriangleMesh * getPtrTriangleMesh() const
Returns the triangle mesh for this track.
Definition: track.hpp:614

Track::m_sky_sphere_percent
float m_sky_sphere_percent
If a sky dome is used, percentage of the sphere to be used.
Definition: track.hpp:297

Track::reverseAvailable
bool reverseAvailable() const
Returns true if this race can be driven in reverse.
Definition: track.hpp:511

Track::m_dont_load_navmesh
static bool m_dont_load_navmesh
Flag to avoid loading navmeshes (useful to speedup debugging: e.g.
Definition: track.hpp:455

Track::m_static_physics_only_nodes
std::vector< scene::ISceneNode * > m_static_physics_only_nodes
The list of all nodes that are to be converted into physics, but not to be drawn (e....
Definition: track.hpp:165

Track::getTrackFile
std::string getTrackFile(const std::string &s) const
Returns the full path of a given file inside this track directory.
Definition: track.hpp:593

Track::addMetaLibrary
void addMetaLibrary(TrackObject *parent, TrackObject *meta_library)
Adds the parent of the meta library for correction later.
Definition: track.hpp:740

Track::m_force_disable_fog
bool m_force_disable_fog
Can be set to force fog off (e.g.
Definition: track.hpp:354

Track::getNumberOfStartPositions
unsigned int getNumberOfStartPositions() const
Get the number of start positions defined in the scene file.
Definition: track.hpp:625

Track::getNumberOfModes
unsigned int getNumberOfModes() const
Returns the number of modes available for this track.
Definition: track.hpp:597

Track::m_smooth_normals
bool m_smooth_normals
True if this track supports using smoothed normals.
Definition: track.hpp:357

Track::isPushBackEnabled
bool isPushBackEnabled() const
True if push back of karts towards the track should be enabled.
Definition: track.hpp:675

Track::m_color_inlevel
core::vector3df m_color_inlevel
The levels for color correction m_color_inlevel(black, gamma, white) m_color_outlevel(black,...
Definition: track.hpp:399

Track::forceFogDisabled
void forceFogDisabled(bool v)
Override track fog value to force disabled.
Definition: track.hpp:635

Track::m_animated_textures
std::vector< MovingTexture * > m_animated_textures
The list of all animated textures.
Definition: track.hpp:283

Track::smoothNormals
bool smoothNormals() const
Returns true if the normals of this track can be smoothed.
Definition: track.hpp:678

Track::m_cache_track
bool m_cache_track
True if this track (textures and track data) should be cached.
Definition: track.hpp:192

Track::m_aabb_min
Vec3 m_aabb_min
Minimum coordinates of this track.
Definition: track.hpp:222

Track::isInternal
bool isInternal() const
Whether this is an "internal" track.
Definition: track.hpp:669

Track::m_sky_vert_segments
int m_sky_vert_segments
If a sky dome is used, the number of vertical segments the sphere should be divided in.
Definition: track.hpp:294

Track::m_enable_push_back
bool m_enable_push_back
If true any collision of a kart with the track will push the kart towards the nearest driveline.
Definition: track.hpp:264

Track::getDefaultAmbientColor
const video::SColor & getDefaultAmbientColor() const
Returns the default ambient color.
Definition: track.hpp:607

Track::m_all_modes
std::vector< TrackMode > m_all_modes
List of all modes for a track.
Definition: track.hpp:342

Track::getIsDuringDay
const bool getIsDuringDay() const
Returns if the track is during day time.
Definition: track.hpp:550

Track::m_object_physics_only_nodes
std::vector< scene::ISceneNode * > m_object_physics_only_nodes
Same concept but for track objects.
Definition: track.hpp:170

Track::m_start_transforms
AlignedArray< btTransform > m_start_transforms
Start transforms of karts (either the default, or the ones taken from the scene file).
Definition: track.hpp:145

Track::getGFXEffectMesh
const TriangleMesh & getGFXEffectMesh() const
Returns the graphical effect mesh for this track.
Definition: track.hpp:618

Track::m_track_mesh
TriangleMesh * m_track_mesh
Used to collect the triangles for the bullet mesh.
Definition: track.hpp:211

Track::m_sky_textures
std::vector< void * > m_sky_textures
A list of the textures for the sky to use.
Definition: track.hpp:275

Track::m_reverse_available
bool m_reverse_available
Whether this track should be available in reverse version.
Definition: track.hpp:254

Track::m_sky_dx
float m_sky_dx
sky rotation speed
Definition: track.hpp:271

Track::m_enable_auto_rescue
bool m_enable_auto_rescue
If true a player kart will automatically be rescued if it is e.g.
Definition: track.hpp:258

Track::m_has_easter_eggs
bool m_has_easter_eggs
True if this track has easter eggs.
Definition: track.hpp:233

Track::m_sort_name
core::stringw m_sort_name
The name used in sorting the track.
Definition: track.hpp:348

Track::getModeName
const std::string & getModeName(unsigned int i) const
Returns the name of the i-th.
Definition: track.hpp:603

Track::getScreenshotFile
const std::string & getScreenshotFile() const
Returns an absolute path to the screenshot file of this track.
Definition: track.hpp:547

Track::getStartTransform
const btTransform & getStartTransform(unsigned int index) const
Returns the start coordinates for a kart with a given index.
Definition: track.hpp:557

Track::isRaceTrack
bool isRaceTrack() const
Returns true if this track is a racing track.
Definition: track.hpp:502

Track::m_materials_loaded
bool m_materials_loaded
True if the materials.xml file is already loaded.
Definition: track.hpp:188

Track::m_sky_particles
ParticleKind * m_sky_particles
Particles emitted from the sky (wheather)
Definition: track.hpp:303

Track::m_use_fog
bool m_use_fog
True if the track uses fog.
Definition: track.hpp:351

Track::m_internal
bool m_internal
Whether this is an "internal" track.
Definition: track.hpp:251

Track::m_all_cached_textures
std::vector< video::ITexture * > m_all_cached_textures
A list of all textures loaded by the track, so that they can be removed from the cache at cleanup tim...
Definition: track.hpp:184

Track::m_all_nodes
std::vector< scene::ISceneNode * > m_all_nodes
The list of all nodes.
Definition: track.hpp:161

Track::getIdent
const std::string & getIdent() const
Returns a unique identifier for this track (the directory name).
Definition: track.hpp:534

Track::m_default_number_of_laps
int m_default_number_of_laps
The number of laps the track will be raced in a random GP.
Definition: track.hpp:409

Track::isArena
bool isArena() const
Returns true if this track has an arena mode.
Definition: track.hpp:496

Track::isFogEnabled
bool isFogEnabled() const
Returns if fog is currently enabled.
Definition: track.hpp:639

Track::getGroups
const std::vector< std::string > & getGroups() const
Returns all groups this track belongs to.
Definition: track.hpp:538

Track::m_weather_lightning
bool m_weather_lightning
Use a special built-in wheather.
Definition: track.hpp:306

Track::getMinimapInvert
const bool getMinimapInvert() const
Returns if invert minimap.
Definition: track.hpp:553

Track::m_is_soccer
bool m_is_soccer
True if this track is a soccer arena.
Definition: track.hpp:237

Track::m_name
std::string m_name
Name of the track to display.
Definition: track.hpp:345

Track::getChallengeList
const std::vector< OverworldChallenge > & getChallengeList() const
Get list of challenges placed on that world.
Definition: track.hpp:688

Track::m_sky_texture_percent
float m_sky_texture_percent
If a sky dome is used, percentage of the texture to be used.
Definition: track.hpp:300

Track::getColorLevelIn
core::vector3df getColorLevelIn() const
Return the color levels for color correction shader.
Definition: track.hpp:702

Track::getMaxArenaPlayers
unsigned int getMaxArenaPlayers() const
Get the max players supported for this track, for arena only.
Definition: track.hpp:621

Track::isAutoRescueEnabled
bool isAutoRescueEnabled() const
Returns true if auto rescue is enabled.
Definition: track.hpp:672

Track::getCameraFar
float getCameraFar() const
Returns the far value for cameras.
Definition: track.hpp:611

Track::m_friction
float m_friction
Friction to be used for the track.
Definition: track.hpp:130

Track::m_sky_hori_segments
int m_sky_hori_segments
If a sky dome is used, the number of horizontal segments the sphere should be divided in.
Definition: track.hpp:290

Track::m_challenges
std::vector< OverworldChallenge > m_challenges
Will only be used on overworld.
Definition: track.hpp:139

Track::addCachedMesh
void addCachedMesh(scene::IMesh *mesh)
Adds mesh to cleanup list.
Definition: track.hpp:737

Track::m_camera_far
float m_camera_far
Far value for cameras for this track.
Definition: track.hpp:246

Track::m_root
std::string m_root
The base dir of all files of this track.
Definition: track.hpp:157

Track::m_height_map_mesh
TriangleMesh * m_height_map_mesh
Used to collect the triangles for the height map mesh used for particle rendering.
Definition: track.hpp:214

Track::hasNavMesh
bool hasNavMesh() const
Returns true if this track navmesh.
Definition: track.hpp:514

Track::m_is_arena
bool m_is_arena
True if this track is an arena.
Definition: track.hpp:228

Track::getTrackObjectManager
TrackObjectManager * getTrackObjectManager() const
Returns the track object manager.
Definition: track.hpp:681

Track::m_version
int m_version
The version of this track.
Definition: track.hpp:243

Track::m_has_navmesh
bool m_has_navmesh
True if this track has navmesh.
Definition: track.hpp:235

Track::getFilename
const std::string & getFilename() const
Returns the filename of this track.
Definition: track.hpp:541

Track::m_aabb_max
Vec3 m_aabb_max
Maximum coordinates of this track.
Definition: track.hpp:224

Track::m_ambient_color
video::SColor m_ambient_color
The current ambient color for each kart.
Definition: track.hpp:368

Track::m_detached_cached_meshes
std::vector< scene::IMesh * > m_detached_cached_meshes
m_all_cached_meshes assumes meshes are attached to a scene node.
Definition: track.hpp:180

Track::hasEasterEggs
bool hasEasterEggs() const
Returns true if this track has easter eggs.
Definition: track.hpp:508

Track::m_filename
std::string m_filename
The full filename of the config (xml) file.
Definition: track.hpp:154

TriangleMesh
A special class to store a triangle mesh with a separate material per triangle.
Definition: triangle_mesh.hpp:35

Vec3
A wrapper around bullets btVector3 to include conventient conversion functions (e....
Definition: vec3.hpp:35

XMLNode
utility class used to parse XML files
Definition: xml_node.hpp:48

OverworldChallenge
Definition: track.hpp:82

Subtitle
Definition: track.hpp:96