kart_model.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2008-2015 Joerg Henrichs
//
//  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_KART_MODEL_HPP
#define HEADER_KART_MODEL_HPP
 
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include <IAnimatedMeshSceneNode.h>
namespace irr
{
    namespace scene { class IAnimatedMesh; class IMesh;
                      class ISceneNode; class IMeshSceneNode; }
}
using namespace irr;
namespace GE { class GERenderInfo; class GESPM; }
namespace SP { class SPMesh; }
 
#include "utils/constants.hpp"
#include "utils/no_copy.hpp"
#include "utils/vec3.hpp"
 
class AbstractKart;
class KartProperties;
class MovingTexture;
class XMLNode;
 
struct SpeedWeightedObject
{
    struct Properties
    {
        Properties();
 
        ~Properties();
 
        Properties& operator=(const Properties& other);
 
        float               m_strength_factor;
 
        float               m_speed_factor;
 
        MovingTexture*      m_moving_texture;
 
        void    loadFromXMLNode(const XMLNode* xml_node);
 
    };
 
    SpeedWeightedObject() : m_model(NULL), m_node(NULL), m_name() {}
    scene::IAnimatedMesh *              m_model;
 
    scene::IAnimatedMeshSceneNode *     m_node;
 
    core::matrix4                       m_location;
 
    std::string                         m_name;
 
    std::string                         m_bone_name;
 
    Properties                          m_properties;
};
typedef std::vector<SpeedWeightedObject>    SpeedWeightedObjectList;
 
 
// ============================================================================
enum HeadlightType : int
{
    HLT_UNKNOWN = -1,
    HLT_POINT = 0,
    HLT_SPOT,
    HLT_MESH,
    HLT_COUNT,
};
// ============================================================================
class HeadlightObject
{
private:
    std::string m_filename;
 
    core::matrix4 m_location;
 
    scene::IMesh* m_model;
 
    scene::ISceneNode* m_node;
 
    video::SColor m_headlight_color;
 
    std::string m_bone_name;
 
    HeadlightType m_headlight_type;
 
    float m_radius;
 
    float m_energy;
 
    float m_inner_cone;
 
    float m_outer_cone;
public:
    // ------------------------------------------------------------------------
    static HeadlightType getHeadlightTypeFromString(const std::string& s)
    {
        if (s == "point")
            return HLT_POINT;
        if (s == "spot")
            return HLT_SPOT;
        if (s == "mesh")
            return HLT_MESH;
        return HLT_UNKNOWN;
    }
    // ------------------------------------------------------------------------
    HeadlightObject()
    {
        m_model    = NULL;
        m_node     = NULL;
        m_headlight_type = HLT_POINT;
        m_radius = 0.0f;
        m_energy = 0.0f;
        m_inner_cone = 0.0f;
        m_outer_cone = 0.0f;
    }   // HeadlightObject
    // ------------------------------------------------------------------------
    HeadlightObject(const std::string& filename, const core::matrix4& location,
                    const std::string& bone_name, const video::SColor& color,
                    HeadlightType headlight_type, float radius, float energy,
                    float inner_cone, float outer_cone)
    {
        m_filename = filename;
        m_location = location;
        m_model    = NULL;
        m_node     = NULL;
        m_bone_name = bone_name;
        m_headlight_color = color;
        m_headlight_type = headlight_type;
        m_radius = radius;
        m_energy = energy;
        m_inner_cone = inner_cone;
        m_outer_cone = outer_cone;
    }   // HeadlightObjects
    // ------------------------------------------------------------------------
    const std::string& getFilename() const { return m_filename; }
    // ------------------------------------------------------------------------
    void setModel(scene::IMesh *mesh) { m_model = mesh; }
    // ------------------------------------------------------------------------
    void setLight(scene::ISceneNode* parent);
    // ------------------------------------------------------------------------
    void setLightNode(scene::ISceneNode* node) { m_node = node; }
    // ------------------------------------------------------------------------
    const scene::ISceneNode *getLightNode() const { return m_node;  }
    // ------------------------------------------------------------------------
    scene::ISceneNode *getLightNode() { return m_node; }
    // ------------------------------------------------------------------------
    const scene::IMesh *getModel() const { return m_model;  }
    // ------------------------------------------------------------------------
    scene::IMesh *getModel() { return m_model; }
    // ------------------------------------------------------------------------
    const core::matrix4& getLocation() const { return m_location; }
    // ------------------------------------------------------------------------
    const std::string& getBoneName() const { return m_bone_name; }
    // ------------------------------------------------------------------------
    HeadlightType getHeadlightType() const { return m_headlight_type; }
    // ------------------------------------------------------------------------
    void setRadius(float radius) { m_radius = radius; }
    // ------------------------------------------------------------------------
    void setEnergy(float energy) { m_energy = energy; }
    // ------------------------------------------------------------------------
    void setDefaultConeValues(unsigned light_count)
    {
        float outer_cone_angle = (light_count == 1 ? 45.0f : 50.0f);
        m_outer_cone = outer_cone_angle / 180.0f * M_PI;
        m_inner_cone = m_outer_cone / 1.5f;
    }
    // ------------------------------------------------------------------------
    bool useDefaultSettings() const
    {
        return m_radius == 0.0f && m_energy == 0.0f && m_inner_cone == 0.0f &&
            m_outer_cone == 0.0f;
    }
};   // class HeadlightObject
 
// ============================================================================
 
class KartModel : public scene::IAnimationEndCallBack, public NoCopy
{
public:
    enum   AnimationFrameType
           {AF_BEGIN,              // First animation frame
            AF_DEFAULT = AF_BEGIN, // Default, i.e. steering animation
            AF_LEFT,               // Steering to the left
            AF_STRAIGHT,           // Going straight
            AF_RIGHT,              // Steering to the right
            AF_LOSE_START,         // Begin losing animation
            AF_LOSE_LOOP_START,    // Begin of the losing loop
            AF_LOSE_END,           // End losing animation
            AF_LOSE_END_STRAIGHT,  // End losing animation to straight frame
            AF_BEGIN_EXPLOSION,    // Begin explosion animation
            AF_END_EXPLOSION,      // End explosion animation
            AF_JUMP_START,         // Begin of jump
            AF_JUMP_LOOP,          // Begin of jump loop
            AF_JUMP_END,           // End of jump
            AF_WIN_START,          // Begin of win animation
            AF_WIN_LOOP_START,     // Begin of win loop animation
            AF_WIN_END,            // End of win animation
            AF_WIN_END_STRAIGHT,   // End of win animation to straight frame
            AF_SELECTION_START,    // Start frame in kart selection screen
            AF_SELECTION_END,      // End frame in kart selection screen
            AF_BACK_LEFT,          // Going back left
            AF_BACK_STRAIGHT,      // Going back straight
            AF_BACK_RIGHT,         // Going back right
            AF_END=AF_BACK_RIGHT,  // Last animation frame
            AF_COUNT};             // Number of entries here
 
private:
    int m_animation_frame[AF_COUNT];
 
    float m_animation_speed;
 
    scene::IAnimatedMesh *m_mesh;
 
    scene::IAnimatedMeshSceneNode *m_animated_node;
 
    core::matrix4* m_hat_location;
 
    std::string m_hat_bone;
 
    std::string m_hat_name;
 
    static float UNDEFINED;
 
    std::string   m_model_filename;
 
    scene::IMesh *m_wheel_model[4];
 
    scene::ISceneNode *m_wheel_node[4];
 
    std::string   m_wheel_filename[4];
 
    Vec3          m_wheel_graphics_position[4];
 
    float         m_wheel_graphics_radius[4];
    
    Vec3          m_nitro_emitter_position[2];
 
    bool          m_has_nitro_emitter;
 
    SpeedWeightedObjectList     m_speed_weighted_objects;
    
    std::vector<HeadlightObject> m_headlight_objects;
 
    float m_default_physics_suspension[4];
 
    float         m_min_suspension[4];
 
    float         m_max_suspension[4];
 
    float         m_dampen_suspension_amplitude[4];
 
    AnimationFrameType m_current_animation;
 
    float m_kart_width;
 
    float m_kart_length;
 
    float m_kart_height;
 
    float m_kart_highest_point;
 
    float m_kart_lowest_point;
 
    bool  m_is_master;
 
    void  loadWheelInfo(const XMLNode &node,
                        const std::string &wheel_name, int index);
    
    void  loadNitroEmitterInfo(const XMLNode &node,
                        const std::string &emitter_name, int index);
 
    void  loadSpeedWeightedInfo(const XMLNode* speed_weighted_node, int index);
 
    void  loadHeadlights(const XMLNode &node, const std::string& kart_dir);
 
    void OnAnimationEnd(scene::IAnimatedMeshSceneNode *node);
 
    AbstractKart* m_kart;
 
    std::shared_ptr<GE::GERenderInfo> m_render_info;
 
    bool m_support_colorization;
 
    std::unordered_map<std::string, core::matrix4> m_inverse_bone_matrices;
 
    unsigned m_version;
 
    std::string m_exhaust_xml;
 
    const KartProperties* m_kart_properties;
    // ------------------------------------------------------------------------
    void initInverseBoneMatrices();
    // ------------------------------------------------------------------------
    void configNode(scene::ISceneNode* node, const core::matrix4& global_mat,
                    const core::matrix4& inv_mat)
    {
        const core::matrix4 mat = inv_mat * global_mat;
        const core::vector3df position = mat.getTranslation();
        const core::vector3df rotation = mat.getRotationDegrees();
        const core::vector3df scale = mat.getScale();
        node->setPosition(position);
        node->setRotation(rotation);
        node->setScale(scale);
    }
    // ------------------------------------------------------------------------
    bool handleSpotlight(GE::GESPM* spm);
    // ------------------------------------------------------------------------
    bool handleSPSpotlight(SP::SPMesh* spm);
 
public:
                  KartModel(bool is_master);
                 ~KartModel();
    KartModel*    makeCopy(std::shared_ptr<GE::GERenderInfo> ri);
    void          reset();
    void          loadInfo(const XMLNode &node);
    bool          loadModels(const KartProperties &kart_properties);
    void          setDefaultSuspension();
    void          update(float dt, float distance, float steer, float speed,
                         float current_lean_angle,
                         int gt_replay_index = -1);
    void          finishedRace();
    void          resetVisualWheelPosition();
    scene::ISceneNode*
                  attachModel(bool animatedModels, bool human_player);
    // ------------------------------------------------------------------------
    scene::IAnimatedMesh*
                  getModel() const { return m_mesh; }
 
    // ------------------------------------------------------------------------
    scene::IMesh* getWheelModel(const int i) const
                             { assert(i>=0 && i<4); return m_wheel_model[i]; }
    // ------------------------------------------------------------------------
    int  getBaseFrame() const   { return m_animation_frame[AF_STRAIGHT];  }
    // ------------------------------------------------------------------------
    int  getFrame(AnimationFrameType f) const  { return m_animation_frame[f]; }
    // ------------------------------------------------------------------------
    float  getAnimationSpeed() const              { return m_animation_speed; }
    // ------------------------------------------------------------------------
    const Vec3& getWheelGraphicsPosition(unsigned int i) const
                {assert(i<4); return m_wheel_graphics_position[i];}
    // ------------------------------------------------------------------------
    const Vec3* getWheelsGraphicsPosition() const
                {return m_wheel_graphics_position;}
    // ------------------------------------------------------------------------
    float       getWheelGraphicsRadius(unsigned int i) const
                {assert(i<4); return m_wheel_graphics_radius[i]; }
    // ------------------------------------------------------------------------
    const Vec3& getNitroEmittersPositon(unsigned int i) const
                { assert(i<2);  return m_nitro_emitter_position[i]; }
    // ------------------------------------------------------------------------
    const bool hasNitroEmitters() const
                {return m_has_nitro_emitter;}
    // ------------------------------------------------------------------------
    size_t      getSpeedWeightedObjectsCount() const
                {return m_speed_weighted_objects.size();}
    // ------------------------------------------------------------------------
    const SpeedWeightedObject& getSpeedWeightedObject(int i) const
                {return m_speed_weighted_objects[i];}
    // ------------------------------------------------------------------------
    float getLength                 () const {return m_kart_length;      }
    // ------------------------------------------------------------------------
    float getWidth                  () const {return m_kart_width;       }
    // ------------------------------------------------------------------------
    float getHeight                 () const {return m_kart_height;      }
    // ------------------------------------------------------------------------
    float getHighestPoint           () const { return m_kart_highest_point;  }
    // ------------------------------------------------------------------------
    float getLowestPoint           () const { return m_kart_lowest_point;  }
    // ------------------------------------------------------------------------
    AnimationFrameType getAnimation() { return m_current_animation; }
    // ------------------------------------------------------------------------
    void  setAnimation(AnimationFrameType type, bool play_non_loop = false);
    // ------------------------------------------------------------------------
    void  setKart(AbstractKart* k) { m_kart = k; }
    // ------------------------------------------------------------------------
    void setHatMeshName(const std::string &name) {m_hat_name = name; }
    // ------------------------------------------------------------------------
    scene::ISceneNode** getWheelNodes() { return m_wheel_node; }
    // ------------------------------------------------------------------------
    scene::IAnimatedMeshSceneNode* getAnimatedNode(){ return m_animated_node; }
    // ------------------------------------------------------------------------
    std::shared_ptr<GE::GERenderInfo> getRenderInfo();
    // ------------------------------------------------------------------------
    bool supportColorization() const         { return m_support_colorization; }
    // ------------------------------------------------------------------------
    void toggleHeadlights(bool on);
    // ------------------------------------------------------------------------
    const core::matrix4&
                      getInverseBoneMatrix(const std::string& bone_name) const;
    // ------------------------------------------------------------------------
    const std::string& getExhaustXML() const          { return m_exhaust_xml; }
    // ------------------------------------------------------------------------
    bool hasWheel() const              { return !m_wheel_filename[0].empty(); }
    // ------------------------------------------------------------------------
    const KartProperties* getKartProperties() const
                                                  { return m_kart_properties; }
};   // KartModel
#endif