camera.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2004-2015 Steve Baker <sjbaker1@airmail.net>
//  Copyright (C) 2006-2015 SuperTuxKart-Team, 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_CAMERA_HPP
#define HEADER_CAMERA_HPP
 
#include "io/xml_node.hpp"
#include "utils/no_copy.hpp"
#include "utils/aligned_array.hpp"
#include "utils/leak_check.hpp"
#include "utils/log.hpp"
#include "utils/vec3.hpp"
 
#include "matrix4.h"
#include "rect.h"
#include "SColor.h"
#include "vector2d.h"
 
#include <vector>
 
#include "ICameraSceneNode.h"
 
class AbstractKart;
 
class Camera : public NoCopy
{
public:
    enum CameraType
    {
        CM_TYPE_NORMAL,
        CM_TYPE_DEBUG,         
        CM_TYPE_FPS,           
        CM_TYPE_END            
    };   // CameraType
 
    /* Only used for the normal camera. */
    enum Mode
    {
        CM_NORMAL,            
        CM_CLOSEUP,           
        CM_REVERSE,           
        CM_LEADER_MODE,       
        CM_SPECTATOR_SOCCER,   
        CM_SPECTATOR_TOP_VIEW, 
        CM_SIMPLE_REPLAY,
        CM_FALLING
    };   // Mode
 
 
private:
    static Camera* s_active_camera;
 
    core::matrix4 m_previous_pv_matrix;
 
    Mode            m_mode;
    Mode            m_previous_mode;
 
    CameraType      m_type;
 
    static CameraType m_default_type;
 
    unsigned int    m_index;
 
    video::SColor   m_ambient_light;
 
    AbstractKart   *m_original_kart;
 
    core::recti     m_viewport;
 
    core::vector2df m_scaling;
 
    float           m_fov;
 
    float           m_aspect;
 
 
    static std::vector<Camera*> m_all_cameras;
 
protected:
    scene::ICameraSceneNode *m_camera;
 
    AbstractKart   *m_kart;
 
    static Camera* createCamera(unsigned int index, CameraType type,
                                AbstractKart* kart);
 
             Camera(CameraType type, int camera_index, AbstractKart* kart);
    virtual ~Camera();
    virtual void reset();
public:
    LEAK_CHECK()
 
    // ========================================================================
    // Static functions
    static Camera* createCamera(AbstractKart* kart, const int index);
    static void resetAllCameras();
    static void changeCamera(unsigned int camera_index, CameraType type);
 
    // ------------------------------------------------------------------------
    static void setDefaultCameraType(CameraType type) { m_default_type = type;}
    // ------------------------------------------------------------------------
    static CameraType getDefaultCameraType() { return m_default_type;}
    // ------------------------------------------------------------------------
    static unsigned int getNumCameras()
    {
        return (unsigned int)m_all_cameras.size(); 
    }   // getNumCameras
    // ------------------------------------------------------------------------
    static Camera *getCamera(unsigned int n) { return m_all_cameras[n]; }
    // ------------------------------------------------------------------------
    static Camera* getActiveCamera() { return s_active_camera; }
    // ------------------------------------------------------------------------
    static void removeAllCameras()
    {
        for(unsigned int i=0; i<m_all_cameras.size(); i++)
            delete m_all_cameras[i];
        m_all_cameras.clear();
    }   // removeAllCameras
 
    // ========================================================================
 
    void setMode(Mode mode);    
    Mode getMode();
    Mode getPreviousMode();
    bool isSpectatorMode();
    void setNextSpectatorMode();
    void setKart(AbstractKart *new_kart);
    virtual void setInitialTransform();
    virtual void activate(bool alsoActivateInIrrlicht=true);
    virtual void update(float dt);
    // ------------------------------------------------------------------------
    CameraType getType() { return m_type; }
    // ------------------------------------------------------------------------
    void setFoV() { m_camera->setFOV(m_fov); }
    // ------------------------------------------------------------------------
    int  getIndex() const  {return m_index;}
    // ------------------------------------------------------------------------
    core::matrix4 getPreviousPVMatrix() const { return m_previous_pv_matrix; }
 
    // ------------------------------------------------------------------------
    void setPreviousPVMatrix(core::matrix4 mat) { m_previous_pv_matrix = mat; }
 
    // ------------------------------------------------------------------------
    const AbstractKart* getKart() const { return m_kart; }
 
    // ------------------------------------------------------------------------
    AbstractKart* getKart() { return m_kart; }
 
    // ------------------------------------------------------------------------
    void setAmbientLight(const video::SColor &color) { m_ambient_light=color; }
 
    // ------------------------------------------------------------------------
    const video::SColor &getAmbientLight() const {return m_ambient_light; }
 
    // ------------------------------------------------------------------------
    const core::recti& getViewport() const {return m_viewport; }
 
    // ------------------------------------------------------------------------
    const core::vector2df& getScaling() const {return m_scaling; }
 
    // ------------------------------------------------------------------------
    scene::ICameraSceneNode *getCameraSceneNode() { return m_camera; }
    // ------------------------------------------------------------------------
    Vec3 getXYZ() { return Vec3(m_camera->getPosition()); }
    // ------------------------------------------------------------------------
    void setupCamera();
};   // class Camera
 
#endif
 
/* EOF */