camera.h

Go to the documentation of this file.

#ifndef VART_CAMERA_H
#define VART_CAMERA_H

#include "vart/point4d.h"
#include <string>    //STL include

namespace VART {
    class Camera {
        friend std::ostream& operator<<(std::ostream& output, const Camera& cam);
        public:
            enum ProjectionType { ORTHOGRAPHIC, PERSPECTIVE };

            Camera();

            Camera(const Point4D& position, const Point4D& focus, const Point4D& upVec);

            Camera(const Camera& cam);

            Camera& operator=(const Camera& cam);

            const std::string& GetDescription() const { return description; }

            void SetDescription(const std::string& descriptionValue);

            ProjectionType GetProjectionType() const { return projectionType; }

            void SetProjectionType(ProjectionType newValue) { projectionType = newValue; }

            float GetAspectRatio() const { return aspectRatio; }

            void SetAspectRatio(float newAR) { aspectRatio = newAR; }

            float GetNearPlaneDistance() const { return nearPlaneDistance; }

            void SetNearPlaneDistance(float newValue) { nearPlaneDistance = newValue; }

            float GetFarPlaneDistance() const { return farPlaneDistance; }

            void SetFarPlaneDistance(float newValue) { farPlaneDistance = newValue; }

            float GetFovY() const;

            void SetFovY(float f);

            Point4D GetLocation() const;

            void SetLocation(const Point4D& locationValue);

            Point4D GetTarget() const;

            void SetTarget(const Point4D& targetValue);

            Point4D GetUp() const;

            void LeftVector(Point4D* resultPtr) const;

            void FrontVector(Point4D* resultPtr) const;

            void SetUp(const Point4D& upValue);

            void SetVisibleVolumeHLimits(double left, double right)
                                        { vvLeft = left; vvRight = right; }

            void SetVisibleVolumeVLimits(double top, double bottom)
                                        { vvTop = top; vvBottom = bottom; }

            const double GetVisibleVolumeLeftLimit()  const   { return vvLeft; }

            const double GetVisibleVolumeRightLimit()  const   { return vvRight; }

            const double GetVisibleVolumeTopLimit()  const   { return vvTop; }

            const double GetVisibleVolumeBottomLimit()  const   { return vvBottom; }

            void SetVisibleVolumeHeight(double newValue);

            void ScaleVisibleVolume(float horScale, float verScale);

            void YawAroundTarget(float radians);
            void Yaw(float radians);
            void Roll(float radians);
            void PitchAroundTarget(float radians);
            void MoveForward(double distance);
            void MoveSideways(double distance);
            void MoveUp(double distance);

            bool DrawOGL() const;

            void SetMatrices() const;

        protected:
            ProjectionType projectionType;
            float fovY;
            float aspectRatio;
            float nearPlaneDistance;
            float farPlaneDistance;

            double vvLeft;
            double vvRight;
            double vvTop;
            double vvBottom;

            Point4D location;
            Point4D target;
            //FixMe: Should be kept orthogonal to (target-location).
            Point4D up;
        private:
            std::string description;
    }; // end class declaration
} // end namespace
#endif  // VART_CAMERA_H