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;

#include "utils/no_copy.hpp"
#include "utils/vec3.hpp"

class AbstractKart;
class KartProperties;
class RenderInfo;
class XMLNode;

struct SpeedWeightedObject
{
    struct Properties
    {
        Properties();

        float               m_strength_factor;

        float               m_speed_factor;

        core::vector2df     m_texture_speed;

        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;

    core::vector2df                     m_texture_cur_offset;

    Properties                          m_properties;
};
typedef std::vector<SpeedWeightedObject>    SpeedWeightedObjectList;

// ============================================================================
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;

public:

    HeadlightObject()
    {
        m_model    = NULL;
        m_node     = NULL;
    }   // HeadlightObject
    // ------------------------------------------------------------------------
    HeadlightObject(const std::string& filename, const core::matrix4& location,
                    const std::string& bone_name, const video::SColor& color)
    {
        m_filename = filename;
        m_location = location;
        m_model    = NULL;
        m_node     = NULL;
        m_bone_name = bone_name;
        m_headlight_color = color;
    }   // HeadlightObjects
    // ------------------------------------------------------------------------
    const std::string& getFilename() const { return m_filename; }
    // ------------------------------------------------------------------------
    void setModel(scene::IMesh *mesh) { m_model = mesh; }
    // ------------------------------------------------------------------------
    void setLight(scene::ISceneNode* parent, float energy, float radius);
    // ------------------------------------------------------------------------
    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; }
    // ------------------------------------------------------------------------
};   // 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_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_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;

    bool  m_play_non_loop;

    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);

    void  loadHeadlights(const XMLNode &node);

    void OnAnimationEnd(scene::IAnimatedMeshSceneNode *node);

    AbstractKart* m_kart;

    std::shared_ptr<RenderInfo> 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;

    // ------------------------------------------------------------------------
    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);
    }

public:
                  KartModel(bool is_master);
                 ~KartModel();
    KartModel*    makeCopy(std::shared_ptr<RenderInfo> 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<RenderInfo> 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; }

};   // KartModel
#endif