CCamera.h

Go to the documentation of this file.

//    Copyright (C) 2004-2013 Dylan Blair
//
//    email: dblair@alumni.cs.utexas.edu
//
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    This library 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
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with this library; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#ifndef CCAMERA_H
#define CCAMERA_H

#include "IObject.h"

#include "../Math_LIB/MInterpolator.h"

#include <queue>

namespace OpenSkyNet {
    namespace Core {
        enum CAMERA_EFFECT { NO_CAMERA_EFFECT, ZOOM, TILT, PAN, ROLL, FADE, MAX_STATIC_CAMERA_EFFECT, MOVE, ORBIT, PATH, SHAKE, MAX_MOVING_CAMERA_EFFECT };
        enum DIRECTOR_CAM { NONE, USER_1, USER_2, USER_3, USER_MAX, PREV, CURR, TEMP, POV_3RD, POV_1ST };

        class Director;

        class CORE_DLL Cinematographer : public ABCObject {
        public:
            struct CameraEffectData {
                CAMERA_EFFECT _type;
                CameraEffectData() : _type(NO_CAMERA_EFFECT) {}
                CameraEffectData(CAMERA_EFFECT type_) : _type(type_) {}
            };

            struct StaticCameraEffectData : public CameraEffectData {
                float _begin, _end, _speed;

                StaticCameraEffectData(CAMERA_EFFECT type_, float begin_, 
                    float end_, float speed_) : CameraEffectData(type_), 
                    _begin(begin_), _end(end_), _speed(speed_) {
                    assert(type_ > NO_CAMERA_EFFECT && type_ < MAX_STATIC_CAMERA_EFFECT);
                }
            };

            struct MovingCameraEffectData : public CameraEffectData {
                Math::Matrix3x3 _endRot;

                Math::Point<> _endPos;

                Math::Point<> _endForward;

                Math::Point<> _axis;

                Math::Point<> _centerOfRot;

                float _radians;

                float _speed;

                bool _useForward, _useRot, _useAxisAngle;

                MovingCameraEffectData(const Math::Point<>& endPos_, float speed_) : 
                    CameraEffectData(MOVE), _endPos(endPos_), _speed(speed_),
                    _useForward(false), _useRot(false), _useAxisAngle(false) {}

                MovingCameraEffectData(const Math::Point<>& centerOfRot_, 
                    const Math::Point<>& endForward_, float speed_) : 
                    CameraEffectData(ORBIT), _endForward(endForward_),
                    _centerOfRot(centerOfRot_), _speed(speed_),
                    _useForward(true), _useRot(false), _useAxisAngle(false) {}

                MovingCameraEffectData(const Math::Point<>& centerOfRot_, 
                    const Math::Matrix3x3& endRot_, float speed_) : 
                    CameraEffectData(ORBIT), _endRot(endRot_),
                    _centerOfRot(centerOfRot_), _speed(speed_),
                    _useForward(false), _useRot(true), _useAxisAngle(false) {}

                MovingCameraEffectData(const Math::Point<>& centerOfRot_, 
                    const Math::Point<>& axis_, float radians_, float speed_) : 
                    CameraEffectData(ORBIT), _axis(axis_), _centerOfRot(centerOfRot_),
                    _radians(radians_), _speed(speed_),
                    _useForward(false), _useRot(false), _useAxisAngle(true) {}
            };

            friend class Core::Director;
        private:
            std::queue<CameraEffectData*> _q;
            CameraEffectData* _currEffect;
            Math::LerpOverTime3 _fade;
            bool _isBusy;
            Math::Point<> _angVel;
        public:
            Cinematographer() : _currEffect(0), _isBusy(false) {}

            virtual Cinematographer& operator=(const Cinematographer& rhs_);

            virtual ~Cinematographer() {
                if (_currEffect) delete _currEffect;
                while (!_q.empty()) {
                    delete _q.front();
                    _q.pop();
                }
            }

            virtual Math::Point<> getAngVel() const { return _angVel; }
            virtual void getAngVel(Math::Point<>& angVel_) const { angVel_ = _angVel; }
            virtual void setAngVel(const Math::Point<> &angVel_) {
                _angVel = angVel_;
                setHasAngVelChanged(true);
            }

            virtual void lookAt(const Math::Point<>& p_) = 0;

            virtual float getAspectRatio() const = 0;

            virtual void getFOVRads(OpenSkyNet::Math::Point<float, 2>& fOV_) const = 0;

            virtual void getCameraToViewportRay(const OpenSkyNet::Math::Point<float, 2>& screenSpaceOrigin_, 
                OpenSkyNet::Math::Point<>& origin_, OpenSkyNet::Math::Point<>& dir_) const = 0;

            inline void setFadeColor(const Math::Point<>& fadeColor_) { _fade._end = fadeColor_; }

            inline bool isBusy() const { return _isBusy; }
        };
    }
}

#endif //CCAMERA_H