fwRenderVTK/include/fwRenderVTK/SRender.hpp

/* ***** BEGIN LICENSE BLOCK *****
 * FW4SPL - Copyright (C) IRCAD, 2009-2018.
 * Distributed under the terms of the GNU Lesser General Public License (LGPL) as
 * published by the Free Software Foundation.
 * ****** END LICENSE BLOCK ****** */

#pragma once

#include "fwRenderVTK/config.hpp"

#include <fwCom/helper/SigSlotConnection.hpp>

#include <fwRender/IRender.hpp>

#include <fwRuntime/ConfigurationElement.hpp>

#include <fwServices/helper/Config.hpp>

#include <map>

class vtkRenderWindow;
class vtkRenderer;
class vtkAbstractPropPicker;
class vtkObject;
class vtkTransform;

// Forward declarations
namespace fwData
{
class TransformationMatrix3D;
}

namespace fwThread
{
class Timer;
}

namespace fwRenderVTK
{

class IAdaptor;
class IVtkRenderWindowInteractorManager;

class FWRENDERVTK_CLASS_API SRender : public ::fwRender::IRender
{
public:
    fwCoreServiceClassDefinitionsMacro( (SRender)(::fwRender::IRender) );

    typedef std::string RendererIdType;
    typedef std::string PickerIdType;
    typedef std::string ObjectIdType;
    typedef std::string AdaptorIdType;
    typedef std::string VtkObjectIdType;
    typedef std::map< std::string, ::fwData::Object::csptr > ConstObjectMapType;

    FWRENDERVTK_API static const ::fwCom::Slots::SlotKeyType s_RENDER_SLOT;
    FWRENDERVTK_API static const ::fwCom::Slots::SlotKeyType s_REQUEST_RENDER_SLOT;
    FWRENDERVTK_API static const ::fwCom::Slots::SlotKeyType s_TOGGLE_AUTO_RENDER_SLOT;

    FWRENDERVTK_API static const ::fwCom::Signals::SignalKeyType s_DROPPED_SIG;
    typedef ::fwCom::Signal< void (std::string)> DroppedSignalType;

    FWRENDERVTK_API SRender() noexcept;

    FWRENDERVTK_API virtual ~SRender() noexcept;

    FWRENDERVTK_API vtkRenderer* getRenderer(RendererIdType rendererId);

    bool isShownOnScreen();

    FWRENDERVTK_API vtkAbstractPropPicker* getPicker(PickerIdType pickerId);

    FWRENDERVTK_API vtkObject* getVtkObject(const VtkObjectIdType& objectId) const;

    FWRENDERVTK_API vtkTransform* getOrAddVtkTransform( const VtkObjectIdType& _id );

    bool getPendingRenderRequest() const;

    void setPendingRenderRequest(bool b);

    enum class RenderMode
    {
        NONE,
        AUTO,
        TIMER,
        SYNC
    };

    RenderMode getRenderMode() const;

    FWRENDERVTK_API bool isOffScreen() const;

    FWRENDERVTK_API void setOffScreenRenderSize(unsigned int _width, unsigned int _height);

protected:

    FWRENDERVTK_API void render();

    FWRENDERVTK_API virtual void starting() override;

    FWRENDERVTK_API virtual void stopping() override;

    FWRENDERVTK_API virtual void configuring() override;

    FWRENDERVTK_API virtual void updating() override;

    FWRENDERVTK_API void addVtkObject( const VtkObjectIdType& _id, vtkObject* _vtkObj );

private:

    void requestRender();

    void toggleAutoRender();

    void startContext();

    void stopContext();

    void configurePicker   (const ConfigType& pickerConf );

    void configureRenderer (const ConfigType& rendererConf );

    void configureVtkObject(const ConfigType& vtkObjectConf );

    vtkTransform* createVtkTransform(const ConfigType& vtkObjectConf );

    SPTR( ::fwRenderVTK::IVtkRenderWindowInteractorManager ) m_interactorManager;

    typedef std::map< RendererIdType, vtkRenderer* > RenderersMapType;

    typedef std::map< PickerIdType, vtkAbstractPropPicker* > PickersMapType;

    typedef std::map< VtkObjectIdType, vtkObject* > VtkObjectMapType;

    RenderersMapType m_renderers;
    PickersMapType m_pickers;
    VtkObjectMapType m_vtkObjects;

    bool m_pendingRenderRequest;

    RenderMode m_renderMode;

    unsigned int m_width; 
    unsigned int m_height; 
    bool m_offScreen; 
    bool m_flip; 

    SPTR( ::fwThread::Timer ) m_timer;

    ConfigType m_sceneConf;
};

//-----------------------------------------------------------------------------

inline bool SRender::getPendingRenderRequest() const
{
    return m_pendingRenderRequest;
}

//------------------------------------------------------------------------------

inline void SRender::setPendingRenderRequest(bool b)
{
    m_pendingRenderRequest = b;
}

//-----------------------------------------------------------------------------

inline SRender::RenderMode SRender::getRenderMode() const
{
    return m_renderMode;
}

}