Camera.h

// This file is a part of the OpenSurgSim project.
// Copyright 2013, SimQuest Solutions Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef SURGSIM_GRAPHICS_CAMERA_H
#define SURGSIM_GRAPHICS_CAMERA_H

#include "SurgSim/Graphics/Representation.h"

#include "SurgSim/Math/Matrix.h"
#include "SurgSim/Math/Vector.h"

#include <array>

namespace SurgSim
{

namespace Graphics
{

class Group;
class Texture;
class RenderTarget;

class Camera : public virtual Representation
{
public:

    enum RenderOrder
    {
        RENDER_ORDER_PRE_RENDER = 0,
        RENDER_ORDER_IN_ORDER,
        RENDER_ORDER_POST_RENDER,
        RENDER_ORDER_COUNT
    };

    explicit Camera(const std::string& name);

    void setRenderGroupReference(const std::string& name);

    void setRenderGroupReferences(const std::vector<std::string>& names);

    std::vector<std::string> getRenderGroupReferences() const;

    void addRenderGroupReference(const std::string& name);

    virtual bool setRenderGroup(std::shared_ptr<Group> group);

    virtual bool setRenderGroups(const std::vector<std::shared_ptr<Group>>& groups);

    virtual bool addRenderGroup(std::shared_ptr<Group> group);

    std::vector<std::shared_ptr<Group>> getRenderGroups() const;

    virtual SurgSim::Math::Matrix44d getViewMatrix() const = 0;

    virtual SurgSim::Math::Matrix44d getInverseViewMatrix() const = 0;

    virtual void setProjectionMatrix(const SurgSim::Math::Matrix44d& matrix) = 0;

    virtual void setViewport(int x, int y, int width, int height) = 0;

    virtual void getViewport(int* x, int* y, int* width, int* height) const  = 0;

    virtual void setViewportSize(std::array<double, 2> dimensions) = 0;

    virtual std::array<double, 2> getViewportSize() const = 0;

    virtual void setPerspectiveProjection(double fovy, double aspect, double near, double far) = 0;

    virtual void setOrthogonalProjection(
        double left, double right,
        double bottom, double top,
        double near, double far) = 0;

    virtual const SurgSim::Math::Matrix44d& getProjectionMatrix() const = 0;

    virtual SurgSim::Math::Matrix44d getInverseProjectionMatrix() const = 0;

    virtual bool setRenderTarget(std::shared_ptr<RenderTarget> renderTarget) = 0;

    virtual std::shared_ptr<RenderTarget> getRenderTarget() const = 0;

    virtual void setRenderOrder(RenderOrder order, int value) = 0;

    bool addGroupReference(const std::string& name) override;

    virtual void setAmbientColor(const SurgSim::Math::Vector4d& color) = 0;

    virtual SurgSim::Math::Vector4d getAmbientColor() = 0;

    virtual void setMainCamera(bool val) = 0;

    virtual bool isMainCamera() = 0;

private:

    void setPerspectiveProjection(const std::array<double, 4>& val);

    void setOrthogonalProjection(const std::array<double, 6>& val);

    void setViewport(std::array<int, 4> val);

    std::array<int, 4> getViewport() const;


    bool doInitialize() override;

    std::vector<std::shared_ptr<Group>> m_renderGroups;

    std::vector<std::string> m_renderGroupReferences;
};

};  // namespace Graphics

};  // namespace SurgSim

#endif  // SURGSIM_GRAPHICS_CAMERA_H