MockObjects.h

// This file is a part of the OpenSurgSim project.
// Copyright 2012-2016, 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_UNITTESTS_MOCKOBJECTS_H
#define SURGSIM_GRAPHICS_UNITTESTS_MOCKOBJECTS_H

#include "SurgSim/Graphics/Camera.h"
#include "SurgSim/Graphics/Group.h"
#include "SurgSim/Graphics/Manager.h"
#include "SurgSim/Graphics/Material.h"
#include "SurgSim/Graphics/Program.h"
#include "SurgSim/Graphics/RenderTarget.h"
#include "SurgSim/Graphics/Representation.h"
#include "SurgSim/Graphics/Texture.h"
#include "SurgSim/Graphics/UniformBase.h"
#include "SurgSim/Graphics/View.h"
#include "SurgSim/Graphics/ViewElement.h"
#include "SurgSim/Math/Vector.h"

#include <array>

class MockGroup : public SurgSim::Graphics::Group
{
public:
    explicit MockGroup(const std::string& name) : SurgSim::Graphics::Group(name), m_isVisible(false)
    {
    }

    virtual void setVisible(bool visible)
    {
        m_isVisible = visible;
    }

    virtual bool isVisible() const
    {
        return m_isVisible;
    }

private:
    bool m_isVisible;
};

class MockManager : public SurgSim::Graphics::Manager
{
public:

    friend class GraphicsManagerTest;

    MockManager() : SurgSim::Graphics::Manager(),
        m_numUpdates(0),
        m_sumDt(0.0)
    {
    }

    int getNumUpdates() const
    {
        return m_numUpdates;
    }
    double getSumDt() const
    {
        return m_sumDt;
    }

    void dumpDebugInfo() const
    {
        return;
    }

    int getType() const override
    {
        return SurgSim::Framework::MANAGER_TYPE_NONE;
    }

    virtual std::shared_ptr<SurgSim::Graphics::Group> getOrCreateGroup(const std::string& name)
    {
        if (getGroups().find(name) == std::end(getGroups()))
        {
            addGroup(std::make_shared<MockGroup>(name));
        }
        return getGroups().at(name);
    }

private:
    virtual bool doUpdate(double dt)
    {
        if (Manager::doUpdate(dt))
        {
            ++m_numUpdates;
            m_sumDt += dt;
            return true;
        }
        else
        {
            return false;
        }
    }

    int m_numUpdates;
    double m_sumDt;
};

class MockRepresentation : public SurgSim::Graphics::Representation
{
public:
    explicit MockRepresentation(const std::string& name) : SurgSim::Graphics::Representation(name),
        m_numUpdates(0),
        m_sumDt(0.0),
        m_isInitialized(false),
        m_isAwoken(false),
        m_drawAsWireFrame(false)
    {
        m_transform.setIdentity();
    }

    int getNumUpdates() const
    {
        return m_numUpdates;
    }
    double getSumDt() const
    {
        return m_sumDt;
    }

    virtual void update(double dt)
    {
        if (isActive())
        {
            ++m_numUpdates;
            m_sumDt += dt;
        }
    }

    bool isInitialized() const
    {
        return m_isInitialized;
    }
    bool isAwoken() const
    {
        return m_isAwoken;
    }

    virtual bool setMaterial(std::shared_ptr<SurgSim::Framework::Component> material)
    {
        return false;
    }

    virtual std::shared_ptr<SurgSim::Graphics::Material> getMaterial() const
    {
        return nullptr;
    }

    virtual void clearMaterial()
    {
    }

    virtual void setDrawAsWireFrame(bool val)
    {
        m_drawAsWireFrame = val;
    }

    virtual bool getDrawAsWireFrame() const
    {
        return m_drawAsWireFrame;
    }


    void setGenerateTangents(bool value)
    {

    }

    bool isGeneratingTangents() const
    {
        return false;
    }

    void addUniform(const std::string& type, const std::string& name, const boost::any& value)
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    void addUniform(std::shared_ptr<SurgSim::Graphics::UniformBase> uniform)
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    void setUniforms(const std::vector<std::shared_ptr<SurgSim::Graphics::UniformBase>>& uniforms)
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    std::vector<std::shared_ptr<SurgSim::Graphics::UniformBase>> getUniforms() const
    {
        throw std::logic_error("The method or operation is not implemented.");
    }



private:
    virtual bool doInitialize()
    {
        m_isInitialized = true;
        return true;
    }
    virtual bool doWakeUp()
    {
        m_isAwoken = true;
        return true;
    }


    int m_numUpdates;
    double m_sumDt;

    bool m_isInitialized;
    bool m_isAwoken;

    bool m_drawAsWireFrame;

    SurgSim::Math::RigidTransform3d m_transform;
};

class MockCamera : public SurgSim::Graphics::Camera
{
public:
    explicit MockCamera(const std::string& name) :
        SurgSim::Graphics::Representation(name),
        SurgSim::Graphics::Camera(name),
        m_numUpdates(0),
        m_sumDt(0.0)
    {
        m_pose.setIdentity();
        m_viewMatrix.setIdentity();
        m_projectionMatrix.setIdentity();
    }

    int getNumUpdates() const
    {
        return m_numUpdates;
    }
    double getSumDt() const
    {
        return m_sumDt;
    }

    virtual void setPose(const SurgSim::Math::RigidTransform3d& transform)
    {
        m_pose = transform;
    }

    virtual SurgSim::Math::RigidTransform3d getPose() const
    {
        return m_pose;
    }

    virtual void setViewMatrix(const SurgSim::Math::Matrix44d& matrix)
    {
        m_viewMatrix = matrix;
    }

    virtual SurgSim::Math::Matrix44d getViewMatrix() const
    {
        return m_viewMatrix;
    }

    virtual void setProjectionMatrix(const SurgSim::Math::Matrix44d& matrix)
    {
        m_projectionMatrix = matrix;
    }

    virtual const SurgSim::Math::Matrix44d& getProjectionMatrix() const
    {
        return m_projectionMatrix;
    }

    virtual SurgSim::Math::Matrix44d getInverseProjectionMatrix() const
    {
        return m_projectionMatrix.inverse();
    }

    virtual void update(double dt)
    {
        ++m_numUpdates;
        m_sumDt += dt;
    }

    virtual bool setMaterial(std::shared_ptr<SurgSim::Framework::Component> material)
    {
        return false;
    }

    virtual std::shared_ptr<SurgSim::Graphics::Material> getMaterial() const
    {
        return nullptr;
    }

    virtual void clearMaterial()
    {
    }

    virtual void setDrawAsWireFrame(bool val)
    {
    }

    virtual bool getDrawAsWireFrame() const
    {
        return false;
    }

    virtual bool setColorRenderTexture(std::shared_ptr<SurgSim::Graphics::Texture> texture)
    {
        return true;
    }

    virtual std::shared_ptr<SurgSim::Graphics::Texture> getColorRenderTexture() const
    {
        return nullptr;
    }

    virtual bool setRenderTarget(std::shared_ptr<SurgSim::Graphics::RenderTarget> renderTarget)
    {
        return true;
    }

    virtual std::shared_ptr<SurgSim::Graphics::RenderTarget> getRenderTarget() const
    {
        return nullptr;
    }

    void setRenderOrder(RenderOrder bin, int value) override
    {
    }

    void setMainCamera(bool val) override
    {
    }

    bool isMainCamera() override
    {
        return false;
    }

    virtual SurgSim::Math::Matrix44d getInverseViewMatrix() const
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    void setAmbientColor(const SurgSim::Math::Vector4d& color)
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    SurgSim::Math::Vector4d getAmbientColor()
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    void setGenerateTangents(bool value)
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    bool isGeneratingTangents() const
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    void setPerspectiveProjection(double fovy, double aspect, double near, double far)
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    void setOrthogonalProjection(double left, double right, double bottom, double top, double near, double far)
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    void setViewport(int x, int y, int width, int height)
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    std::array<int, 4> getViewport() const
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    void getViewport(int* x, int* y, int* width, int* height) const
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    void setViewportSize(std::array<double, 2> dimensions)
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    std::array<double, 2> getViewportSize() const
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    void addUniform(const std::string& type, const std::string& name, const boost::any& value)
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    void addUniform(std::shared_ptr<SurgSim::Graphics::UniformBase> uniform)
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    void setUniforms(const std::vector<std::shared_ptr<SurgSim::Graphics::UniformBase>>& uniforms)
    {
        throw std::logic_error("The method or operation is not implemented.");
    }

    std::vector<std::shared_ptr<SurgSim::Graphics::UniformBase>> getUniforms() const
    {
        throw std::logic_error("The method or operation is not implemented.");

    }

private:
    int m_numUpdates;
    double m_sumDt;

    SurgSim::Math::RigidTransform3d m_pose;

    SurgSim::Math::Matrix44d m_viewMatrix;

    SurgSim::Math::Matrix44d m_projectionMatrix;

};

class MockView : public SurgSim::Graphics::View
{
public:
    explicit MockView(const std::string& name) : SurgSim::Graphics::View(name),
        m_x(0),
        m_y(0),
        m_width(800),
        m_height(600),
        m_isWindowBorderEnabled(true),
        m_numUpdates(0),
        m_sumDt(0.0),
        m_isInitialized(false),
        m_isAwoken(false)
    {
    }

    void setPosition(const std::array<int, 2>& position) override
    {
        m_x = position[0];
        m_y = position[1];
    }

    std::array<int, 2> getPosition() const override
    {
        std::array<int, 2> result = {m_x, m_y};
        return result;
    }

    void setDimensions(const std::array<int, 2>& dimensions) override
    {
        m_width = dimensions[0];
        m_height = dimensions[1];
    }

    std::array<int, 2> getDimensions() const override
    {
        std::array<int, 2> result = {m_width, m_height};
        return result;
    }

    void setDimensionsDouble(const std::array<double, 2>& dimensions)
    {
        m_width = static_cast<int>(dimensions[0]);
        m_height = static_cast<int>(dimensions[1]);
    }

    std::array<double, 2> getDimensionsDouble() const
    {
        std::array<double, 2> result = {static_cast<double>(m_width), static_cast<double>(m_height)};
        return std::move(result);
    }

    void setWindowBorderEnabled(bool enabled) override
    {
        m_isWindowBorderEnabled = enabled;
    }
    bool isWindowBorderEnabled() const override
    {
        return m_isWindowBorderEnabled;
    }

    int getNumUpdates() const
    {
        return m_numUpdates;
    }
    double getSumDt() const
    {
        return m_sumDt;
    }

    virtual void update(double dt)
    {
        ++m_numUpdates;
        m_sumDt += dt;
    }

    bool isInitialized() const
    {
        return m_isInitialized;
    }
    bool isAwoken() const
    {
        return m_isAwoken;
    }

private:
    virtual bool doInitialize()
    {
        m_isInitialized = true;
        return true;
    }
    virtual bool doWakeUp()
    {
        m_isAwoken = true;
        return true;
    }

    int doSetTargetScreen(int val)
    {
        return 0;
    }

    int m_x, m_y;
    int m_width, m_height;
    bool m_isWindowBorderEnabled;

    int m_numUpdates;
    double m_sumDt;

    bool m_isInitialized;
    bool m_isAwoken;

};

class NonGraphicsRepresentation : public SurgSim::Framework::Representation
{
public:
    explicit NonGraphicsRepresentation(const std::string& name) : SurgSim::Framework::Representation(name)
    {
    }
};

#endif  // SURGSIM_GRAPHICS_UNITTESTS_MOCKOBJECTS_H