camera_end.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_END_HPP
#define HEADER_CAMERA_END_HPP
 
#include "graphics/camera_normal.hpp"
 
#include "utils/cpp2011.hpp"
 
class CameraEnd : public CameraNormal
{
private:
    class EndCameraInformation
    {
    public:
        typedef enum {EC_STATIC_FOLLOW_KART,
                      EC_AHEAD_OF_KART} EndCameraType;
        EndCameraType m_type;
 
        Vec3    m_position;
 
        float   m_distance2;
 
        bool    readXML(const XMLNode &node)
        {
            std::string s;
            node.get("type", &s);
            if(s=="static_follow_kart")
                m_type = EC_STATIC_FOLLOW_KART;
            else if(s=="ahead_of_kart")
                m_type = EC_AHEAD_OF_KART;
            else
            {
                Log::warn("Camera", "Invalid camera type '%s' - camera is ignored.",
                          s.c_str());
                return false;
            }
            node.get("xyz", &m_position);
            node.get("distance", &m_distance2);
            // Store the squared value
            m_distance2 *= m_distance2;
            return true;
        }   // readXML
        // --------------------------------------------------------------------
        bool    isReached(const Vec3 &xyz)
                { return (xyz-m_position).length2() < m_distance2; }
    };   // EndCameraInformation
    // ------------------------------------------------------------------------
 
    static AlignedArray<EndCameraInformation> m_end_cameras;
 
    unsigned int m_current_end_camera;
 
    unsigned int  m_next_end_camera;
 
    void handleEndCamera(float dt);
 
    friend class Camera;   // Give Camera access to constructor
             CameraEnd(int camera_index, AbstractKart* kart);
    virtual ~CameraEnd() {}
public:
 
    static void readEndCamera(const XMLNode &root);
    static void clearEndCameras();
    virtual void update(float dt) OVERRIDE;
};   // class CameraEnd
 
#endif
 
/* EOF */