DebugPass and UiPass are now operational

src/libRender/RadiumNBR/NodeBasedRenderer.cpp

@@ -128,8 +128,11 @@ void NodeBasedRenderer::initializeInternal() {
     // TODO, do we really need to setup an index for the two following passes
     // build the Ui pass
     // todo find a way to replace the "31" by another id
-    m_uiPass = std::make_unique<UIPass>( &m_uiRenderObjects, 31 );
+    m_uiPass = std::make_unique<UIPass>( &m_uiRenderObjects );
     m_uiPass->setResourcesDir( resourcesPath );
+    m_uiPass->setInputs( *( sharedTextures().find( "Depth (RadiumNBR)" ) ) );
+    m_uiPass->setOutput( m_fancyTexture.get() );
+    m_uiPass->initializePass( m_width, m_height, m_shaderProgramManager );
     // configure the pass
     m_uiPass->deactivate();
 

src/libRender/RadiumNBR/Passes/DebugPass.cpp

@@ -24,7 +24,7 @@ DebugPass::~DebugPass() = default;
 
 bool DebugPass::buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
                                       Ra::Engine::Rendering::RenderTechnique& rt ) const {
-    // This method is never called for DebugObject.
+    // This method is never called for DebugObjects.
     // Rendering use the Default Radium pass
     return true;
 }
@@ -42,17 +42,6 @@ bool DebugPass::update() {
 }
 
 void DebugPass::resize( size_t width, size_t height ) {
-    // Only resize the owned textures. Imported one are resized by their owner
-    for ( auto& t : m_localTextures )
-    {
-        t.second->resize( width, height );
-    }
-
-    for ( auto& t : m_sharedTextures )
-    {
-        t.second->resize( width, height );
-    }
-
     m_fbo->bind();
     m_fbo->attachTexture( GL_DEPTH_ATTACHMENT, m_importedTextures["Debug::Depth"]->texture() );
     // no need to resize the output texture, it belongs to the Ra::Engine::Rendering::Renderer and
@@ -69,13 +58,12 @@ void DebugPass::resize( size_t width, size_t height ) {
 void DebugPass::execute( const Ra::Engine::Data::ViewingParameters& viewParams ) const {
 
     m_fbo->bind();
+    glDrawBuffers( 1, buffers );
     GL_ASSERT( glDisable( GL_BLEND ) );
     GL_ASSERT( glEnable( GL_DEPTH_TEST ) );
     GL_ASSERT( glDepthMask( GL_FALSE ) );
     GL_ASSERT( glDepthFunc( GL_LESS ) );
 
-    glDrawBuffers( 1, buffers );
-
     for ( const auto& ro : *m_objectsToRender )
     {
         ro->render( {}, viewParams );

src/libRender/RadiumNBR/Passes/UiPass.cpp

@@ -5,50 +5,116 @@
 using namespace Ra::Core::Utils; // log
 //#endif
 
+#include <Engine/Data/DisplayableObject.hpp>
 #include <Engine/Data/Material.hpp>
 #include <Engine/Data/ShaderConfigFactory.hpp>
 #include <Engine/Data/ShaderProgramManager.hpp>
 #include <Engine/Data/Texture.hpp>
+#include <Engine/Data/ViewingParameters.hpp>
 #include <Engine/Rendering/RenderObject.hpp>
 
 #include <globjects/Framebuffer.h>
 
 namespace RadiumNBR {
 using namespace gl;
-
-UIPass::UIPass( const std::vector<RenderObjectPtr>* objectsToRender,
-                const Ra::Core::Utils::Index& idx ) :
-    RenderPass( "User Interface pass", idx, objectsToRender ) {}
+static const GLenum buffers[] = {GL_COLOR_ATTACHMENT0};
+#define UI_PASS_ID 31
+UIPass::UIPass( const std::vector<RenderObjectPtr>* objectsToRender) :
+    RenderPass( "User Interface pass", UI_PASS_ID, objectsToRender ) {}
 
 UIPass::~UIPass() = default;
 
 bool UIPass::buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
                                    Ra::Engine::Rendering::RenderTechnique& rt ) const {
-    return false;
+    // This method is never called for UiObjects.
+    // Rendering use the Default Radium pass
+    return true;
 }
 
 bool UIPass::initializePass( size_t width,
                              size_t height,
                              Ra::Engine::Data::ShaderProgramManager* shaderMngr ) {
-    return false;
+    m_shaderMngr = shaderMngr;
+    m_fbo        = std::make_unique<globjects::Framebuffer>();
+    return true;
 }
 
 bool UIPass::update() {
     return false;
 }
 
-void UIPass::resize( size_t width, size_t height ) {}
+void UIPass::resize( size_t width, size_t height ) {
+    m_fbo->bind();
+    m_fbo->attachTexture( GL_DEPTH_ATTACHMENT, m_importedTextures["Ui::Depth"]->texture() );
+    // no need to resize the output texture, it belongs to the Ra::Engine::Rendering::Renderer and
+    // is already resized
+    m_fbo->attachTexture( GL_COLOR_ATTACHMENT0, m_outputTexture->texture() );
+#ifdef PASSES_LOG
+    if ( m_fbo->checkStatus() != GL_FRAMEBUFFER_COMPLETE )
+    { LOG( logERROR ) << "FBO Error (EmissivityPass::resize): " << m_fbo->checkStatus(); }
+#endif
+    // finished with fbo, undbind to bind default
+    globjects::Framebuffer::unbind();
+}
 
 void UIPass::execute( const Ra::Engine::Data::ViewingParameters& viewParams ) const {
+    /*
     LOG( Ra::Core::Utils::logINFO )
         << " requested to render " << m_objectsToRender->size() << " UI objects";
+    */
+    m_fbo->bind();
+    glDrawBuffers( 1, buffers );
+    GL_ASSERT( glDepthMask( GL_TRUE ) );
+    GL_ASSERT( glEnable( GL_DEPTH_TEST ) );
+    GL_ASSERT( glDepthFunc( GL_LESS ) );
+    GL_ASSERT( glClear( GL_DEPTH_BUFFER_BIT ) );
+
+    for ( const auto& ro : *m_objectsToRender )
+    {
+        if ( ro->isVisible() )
+        {
+            auto shader = ro->getRenderTechnique()->getShader();
+
+            // bind data
+            shader->bind();
+
+            Ra::Core::Matrix4 M  = ro->getTransformAsMatrix();
+            Ra::Core::Matrix4 MV = viewParams.viewMatrix * M;
+            Ra::Core::Vector3 V  = MV.block<3, 1>( 0, 3 );
+            Scalar d         = V.norm();
+
+            Ra::Core::Matrix4 S    = Ra::Core::Matrix4::Identity();
+            S.coeffRef( 0, 0 ) = S.coeffRef( 1, 1 ) = S.coeffRef( 2, 2 ) = d;
+
+            M = M * S;
+
+            shader->setUniform( "transform.proj", viewParams.projMatrix );
+            shader->setUniform( "transform.view", viewParams.viewMatrix );
+            shader->setUniform( "transform.model", M );
+
+            auto shaderParameter = ro->getRenderTechnique()->getParametersProvider();
+            if ( shaderParameter != nullptr ) shaderParameter->getParameters().bind( shader );
+
+            // render
+            ro->getMesh()->render( shader );
+        }
+    }
+
+    //   DebugRender::getInstance()->render( renderData.viewMatrix, renderData.projMatrix );
+
+    m_fbo->unbind();
+
 }
 
 /// Add the output colorBuffer
-void UIPass::setOutput( const SharedTextures& colorBuffer ) {}
+void UIPass::setOutput( const Ra::Engine::Data::Texture* colorBuffer ) {
+    m_outputTexture = colorBuffer;
+}
 
 /// These inputs must be computed before executing this pass
 /// depth buffer ? // TODO verify we need this
-void UIPass::setInputs( const SharedTextures& depthBuffer ) {}
+void UIPass::setInputs( const SharedTextures& depthBuffer ) {
+    addImportedTextures( {"Ui::Depth", depthBuffer.second} );
+}
 
 } // namespace RadiumNBR

src/libRender/RadiumNBR/Passes/UiPass.hpp

@@ -16,8 +16,7 @@ namespace RadiumNBR {
 class UIPass : public RenderPass
 {
   public:
-    UIPass( const std::vector<RenderObjectPtr>* objectsToRender,
-            const Ra::Core::Utils::Index& idx );
+    UIPass( const std::vector<RenderObjectPtr>* objectsToRender);
     ~UIPass() override;
 
     bool buildRenderTechnique( const Ra::Engine::Rendering::RenderObject* ro,
@@ -30,7 +29,7 @@ class UIPass : public RenderPass
     void execute( const Ra::Engine::Data::ViewingParameters& viewParams ) const override;
 
     /// Add the output colorBuffer
-    void setOutput( const SharedTextures& colorBuffer );
+    void setOutput( const Ra::Engine::Data::Texture* colorBuffer );
 
     /// These inputs must be computed before executing this pass
     /// depth buffer ? // TODO verify we need this
@@ -44,6 +43,6 @@ class UIPass : public RenderPass
     Ra::Engine::Data::ShaderProgramManager* m_shaderMngr{nullptr};
 
     /// The color texture for output.Stored here for easy access.
-    SharedTextures m_outputTexture;
+    const Ra::Engine::Data::Texture* m_outputTexture;
 };
 } // namespace RadiumNBR