track.hpp

//  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 <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/vec3.hpp"
#include "utils/stk_process.hpp"
 
class AbstractKart;
class AnimationManager;
class BezierCurve;
class CheckManager;
class ItemManager;
class ModelDefinitionLoader;
class MovingTexture;
class MusicInformation;
class ParticleEmitter;
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;
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::random_shuffle(m_start_transforms.begin(), m_start_transforms.end());
    }
    // ------------------------------------------------------------------------
    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);
    // ------------------------------------------------------------------------
    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