Renderer.hpp

#pragma once
 
#include <Engine/RaEngine.hpp>
 
#include <array>
#include <chrono>
#include <memory>
#include <mutex>
#include <vector>
 
#include <Core/Types.hpp>
#include <Core/Utils/Color.hpp>
#include <Core/Utils/Timer.hpp>
#include <Engine/Data/DisplayableObject.hpp>
 
namespace globjects {
class Framebuffer;
}
 
namespace Ra {
namespace Engine {
 
namespace Data {
class Texture;
struct ViewingParameters;
class ShaderProgram;
class ShaderProgramManager;
class TextureManager;
} // namespace Data
 
namespace Scene {
class Light;
class LightManager;
} // namespace Scene
 
namespace Rendering {
class RenderObject;
class RenderObjectManager;
 
class RA_ENGINE_API Renderer
{
  protected:
    using RenderObjectPtr = std::shared_ptr<RenderObject>;
 
  public:
    struct TimerData {
        Core::Utils::TimePoint renderStart;
        Core::Utils::TimePoint updateEnd;
        Core::Utils::TimePoint feedRenderQueuesEnd;
        Core::Utils::TimePoint mainRenderEnd;
        Core::Utils::TimePoint postProcessEnd;
        Core::Utils::TimePoint renderEnd;
    };
 
    enum PickingMode {
        RO = 0,     
        VERTEX,     
        EDGE,       
        TRIANGLE,   
        C_VERTEX,   
        C_EDGE,     
        C_TRIANGLE, 
        NONE,       
    };
 
    enum PickingPurpose { SELECTION = 0, MANIPULATION };
 
    struct PickingQuery {
        Core::Vector2 m_screenCoords;
        PickingPurpose m_purpose;
        PickingMode m_mode;
    };
 
    class PickingResult
    {
      public:
        inline const std::vector<std::tuple<int, int, int>>& getIndices() const;
 
        inline void addIndex( const std::tuple<int, int, int>& idx );
 
        inline void reserve( size_t s );
 
        inline void removeDuplicatedIndices() const;
 
        inline void clear();
 
        inline void setRoIdx( Core::Utils::Index idx );
        inline Core::Utils::Index getRoIdx() const;
        inline void setMode( PickingMode mode );
        inline PickingMode getMode() const;
        //
 
        inline Scalar getDepth() const;
        inline void setDepth( Scalar depth );
 
      private:
        PickingMode m_mode { Engine::Rendering::Renderer::RO };
        Core::Utils::Index m_roIdx { Core::Utils::Index::Invalid() };
 
        mutable std::vector<std::tuple<int, int, int>> m_indices;
        Scalar m_depth;
    };
 
  public:
    Renderer();
 
    virtual ~Renderer();
 
    // -=-=-=-=-=-=-=-=- FINAL -=-=-=-=-=-=-=-=- //
 
    inline const TimerData& getTimerData() const;
 
    inline Data::Texture* getDisplayTexture() const;
 
    // Lock the renderer (for MT access)
    inline void lockRendering();
 
    inline void unlockRendering();
 
    inline void toggleWireframe();
 
    inline void enableWireframe( bool enabled );
 
    inline void toggleDrawDebug();
 
    inline void enableDebugDraw( bool enabled );
 
    inline void enablePostProcess( bool enabled );
 
    void render( const Data::ViewingParameters& renderData );
 
    void initialize( uint width, uint height );
 
    void resize( uint width, uint height );
 
    inline void addPickingRequest( const PickingQuery& query );
 
    inline const std::vector<PickingResult>& getPickingResults() const;
 
    inline const std::vector<PickingQuery>& getPickingQueries() const;
 
    inline void setMousePosition( const Core::Vector2& pos );
 
    inline void setBrushRadius( Scalar brushRadius );
 
    bool hasLight() const;
 
    inline void setBackgroundColor( const Core::Utils::Color& color );
 
    inline const Core::Utils::Color& getBackgroundColor() const;
 
    // -=-=-=-=-=-=-=-=- VIRTUAL -=-=-=-=-=-=-=-=- //
    virtual void addLight( const Scene::Light* light );
 
    virtual void reloadShaders();
 
    // TODO:    For now the drawn texture takes the whole viewport,
    //          maybe it could be great if we had a way to switch between
    //          the current "fullscreen" debug mode, and some kind of
    //          "windowed" mode (that would show the debugged texture in
    //          its own viewport, without hiding the final texture.)
    virtual void displayTexture( const std::string& texName );
 
    virtual std::vector<std::string> getAvailableTextures() const;
 
    virtual std::string getRendererName() const = 0;
 
    virtual bool buildRenderTechnique( RenderObject* ro ) const = 0;
 
    int buildAllRenderTechniques() const;
 
    virtual std::unique_ptr<uchar[]> grabFrame( size_t& w, size_t& h ) const;
 
    PickingResult doPickingNow( const PickingQuery& query,
                                const Data::ViewingParameters& renderData );
 
  protected:
    virtual void initializeInternal() = 0;
 
    virtual void resizeInternal() = 0;
 
    virtual void updateStepInternal( const Data::ViewingParameters& renderData ) = 0;
 
    virtual void renderInternal( const Data::ViewingParameters& renderData ) = 0;
 
    virtual void postProcessInternal( const Data::ViewingParameters& renderData ) = 0;
 
    virtual void
    debugInternal( const Data::ViewingParameters& renderData ) = 0; // is viewingParameters useful ?
 
    virtual void uiInternal( const Data::ViewingParameters& renderData ) = 0; // idem ?
 
  private:
    // 0.
    void saveExternalFBOInternal();
    void restoreExternalFBOInternal();
 
    // 1.
    void feedRenderQueuesInternal( const Data::ViewingParameters& renderData );
 
    // 2.0
    void updateRenderObjectsInternal( const Data::ViewingParameters& renderData );
 
    // 3.
    void splitRenderQueuesForPicking( const Data::ViewingParameters& renderData );
    void splitRQ( const std::vector<RenderObjectPtr>& renderQueue,
                  std::array<std::vector<RenderObjectPtr>, 4>& renderQueuePicking );
    void renderForPicking( const Data::ViewingParameters& renderData,
                           const std::array<const Data::ShaderProgram*, 4>& pickingShaders,
                           const std::array<std::vector<RenderObjectPtr>, 4>& renderQueuePicking );
 
    void doPicking( const Data::ViewingParameters& renderData );
 
    // 6.
    void drawScreenInternal();
 
    // 7.
    void notifyRenderObjectsRenderingInternal();
 
  protected:
    uint m_width { 0 };
    uint m_height { 0 };
 
    Data::ShaderProgramManager* m_shaderProgramManager { nullptr };
 
    RenderObjectManager* m_renderObjectManager { nullptr };
 
    //                It would make more sense if we are able to show the
    //                debugged texture in its own viewport.
    Data::Texture* m_displayedTexture { nullptr };
 
    std::vector<Ra::Engine::Scene::LightManager*> m_lightmanagers;
 
    bool m_renderQueuesUpToDate { false };
 
    std::vector<RenderObjectPtr> m_fancyRenderObjects;
    std::vector<RenderObjectPtr> m_debugRenderObjects;
    std::vector<RenderObjectPtr> m_xrayRenderObjects;
    std::vector<RenderObjectPtr> m_uiRenderObjects;
 
    // Simple quad mesh, used to render the final image
    std::unique_ptr<Data::Displayable> m_quadMesh;
 
    bool m_drawDebug { true };          // Should we render debug stuff ?
    bool m_wireframe { false };         // Are we rendering in "real" wireframe mode
    bool m_postProcessEnabled { true }; // Should we do post processing ?
 
    // derived class could use the already created textures
    std::unique_ptr<Data::Texture> m_depthTexture;
    std::unique_ptr<Data::Texture> m_fancyTexture;
    std::map<std::string, Data::Texture*> m_secondaryTextures;
 
  private:
    // Renderer timings data
    TimerData m_timerData;
 
    std::mutex m_renderMutex;
 
    // PICKING STUFF
    Ra::Core::Vector2 m_mousePosition;
    float m_brushRadius { 0 };
    std::unique_ptr<globjects::Framebuffer> m_pickingFbo;
    std::unique_ptr<Data::Texture> m_pickingTexture;
 
    static const int NoPickingRenderMode = Data::Displayable::PickingRenderMode::NO_PICKING;
    std::array<std::vector<RenderObjectPtr>, NoPickingRenderMode> m_fancyRenderObjectsPicking;
    std::array<std::vector<RenderObjectPtr>, NoPickingRenderMode> m_debugRenderObjectsPicking;
    std::array<std::vector<RenderObjectPtr>, NoPickingRenderMode> m_xrayRenderObjectsPicking;
    std::array<std::vector<RenderObjectPtr>, NoPickingRenderMode> m_uiRenderObjectsPicking;
    std::array<const Data::ShaderProgram*, NoPickingRenderMode> m_pickingShaders;
 
    std::vector<PickingQuery> m_pickingQueries;
    std::vector<PickingQuery> m_lastFramePickingQueries;
    std::vector<PickingResult> m_pickingResults;
 
    Core::Utils::Color m_backgroundColor { Core::Utils::Color::Grey( 0.0392_ra, 0_ra ) };
    void preparePicking( const Data::ViewingParameters& renderData );
 
    bool m_initialized { false };
};
 
inline const std::vector<std::tuple<int, int, int>>& Renderer::PickingResult::getIndices() const {
    return m_indices;
}
 
inline void Renderer::PickingResult::addIndex( const std::tuple<int, int, int>& idx ) {
    m_indices.push_back( idx );
}
 
inline void Renderer::PickingResult::reserve( size_t s ) {
    m_indices.reserve( s );
}
 
inline void Renderer::PickingResult::removeDuplicatedIndices() const {
    std::sort( m_indices.begin(), m_indices.end() );
    m_indices.erase( std::unique( m_indices.begin(), m_indices.end() ), m_indices.end() );
}
 
inline void Renderer::PickingResult::clear() {
    m_mode  = Engine::Rendering::Renderer::RO;
    m_roIdx = Core::Utils::Index::Invalid();
    m_indices.clear();
}
 
inline void Renderer::PickingResult::setRoIdx( Core::Utils::Index idx ) {
    m_roIdx = idx;
}
 
inline Core::Utils::Index Renderer::PickingResult::getRoIdx() const {
    return m_roIdx;
}
 
inline void Renderer::PickingResult::setMode( Renderer::PickingMode mode ) {
    m_mode = mode;
}
 
inline Renderer::PickingMode Renderer::PickingResult::getMode() const {
    return m_mode;
}
 
inline Scalar Renderer::PickingResult::getDepth() const {
    return m_depth;
}
 
inline void Renderer::PickingResult::setDepth( Scalar depth ) {
    m_depth = depth;
}
 
inline const Renderer::TimerData& Renderer::getTimerData() const {
    return m_timerData;
}
 
inline Data::Texture* Renderer::getDisplayTexture() const {
    return m_displayedTexture;
}
 
inline void Renderer::lockRendering() {
    m_renderMutex.lock();
}
 
inline void Renderer::unlockRendering() {
    m_renderMutex.unlock();
}
 
inline void Renderer::toggleWireframe() {
    m_wireframe = !m_wireframe;
}
 
inline void Renderer::enableWireframe( bool enabled ) {
    m_wireframe = enabled;
}
 
inline void Renderer::toggleDrawDebug() {
    m_drawDebug = !m_drawDebug;
}
 
inline void Renderer::enableDebugDraw( bool enabled ) {
    m_drawDebug = enabled;
}
 
inline void Renderer::enablePostProcess( bool enabled ) {
    m_postProcessEnabled = enabled;
}
 
inline void Renderer::addPickingRequest( const PickingQuery& query ) {
    m_pickingQueries.push_back( query );
}
 
inline const std::vector<Renderer::PickingResult>& Renderer::getPickingResults() const {
    return m_pickingResults;
}
 
inline const std::vector<Renderer::PickingQuery>& Renderer::getPickingQueries() const {
    return m_lastFramePickingQueries;
}
 
inline void Renderer::setMousePosition( const Core::Vector2& pos ) {
    m_mousePosition[0] = pos[0];
    m_mousePosition[1] = m_height - pos[1];
}
 
inline void Renderer::setBrushRadius( Scalar brushRadius ) {
    m_brushRadius = brushRadius;
}
 
inline void Renderer::setBackgroundColor( const Core::Utils::Color& color ) {
    m_backgroundColor = color;
}
 
inline const Core::Utils::Color& Renderer::getBackgroundColor() const {
    return m_backgroundColor;
}
 
} // namespace Rendering
} // namespace Engine
} // namespace Ra