Rendertarget interfaces

data/gloperate/qml/Viewer.qml

@@ -436,8 +436,6 @@ ApplicationWindow
             // Load settings
             settings.load();
         }
-
-        gloperate.components.scanPlugins();
 
         // Scan for plugins
         gloperate.components.scanPlugins();

source/examples/demo-stages-plugins/AntialiasableTriangleStage.cpp

@@ -29,7 +29,7 @@ CPPEXPOSE_COMPONENT(AntialiasableTriangleStage, gloperate::Stage)
 
 AntialiasableTriangleStage::AntialiasableTriangleStage(gloperate::Environment * environment, const std::string & name)
 : Stage(environment, name)
-, renderInterface(this)
+, canvasInterface(this)
 , subpixelOffsets("subpixelOffset", this, nullptr)
 {
 }
@@ -40,6 +40,7 @@ AntialiasableTriangleStage::~AntialiasableTriangleStage()
 
 void AntialiasableTriangleStage::onContextInit(gloperate::AbstractGLContext *)
 {
+    canvasInterface.onContextInit();
     setupGeometry();
     setupProgram();
 }
@@ -54,12 +55,14 @@ void AntialiasableTriangleStage::onContextDeinit(gloperate::AbstractGLContext *)
     // deinitialize geometry
     m_vertexBuffer.reset();
     m_vao.reset();
+
+    canvasInterface.onContextDeinit();
 }
 
 void AntialiasableTriangleStage::onProcess()
 {
     // Get viewport
-    glm::vec4 viewport = *renderInterface.deviceViewport;
+    const glm::vec4 & viewport = *canvasInterface.viewport;
 
     // Update viewport
     gl::glViewport(
@@ -70,11 +73,11 @@ void AntialiasableTriangleStage::onProcess()
     );
 
     // Bind FBO
-    globjects::Framebuffer * fbo = *renderInterface.targetFBO;
+    globjects::Framebuffer * fbo = canvasInterface.obtainFBO();
     fbo->bind(gl::GL_FRAMEBUFFER);
 
     // Clear background
-    auto & color = *renderInterface.backgroundColor;
+    auto & color = *canvasInterface.backgroundColor;
     gl::glClearColor(color.redf(), color.greenf(), color.bluef(), 1.0f);
     gl::glScissor(viewport.x, viewport.y, viewport.z, viewport.w);
     gl::glEnable(gl::GL_SCISSOR_TEST);
@@ -83,7 +86,7 @@ void AntialiasableTriangleStage::onProcess()
 
     // Set uniforms
     m_program->setUniform("offset", *subpixelOffsets
-                                    ? (*subpixelOffsets)->at((*renderInterface.frameCounter) % (*subpixelOffsets)->size())
+                                    ? (*subpixelOffsets)->at((*canvasInterface.frameCounter) % (*subpixelOffsets)->size())
                                     : glm::vec2(0.0f));
 
     // Draw geometry
@@ -95,12 +98,7 @@ void AntialiasableTriangleStage::onProcess()
     globjects::Framebuffer::unbind(gl::GL_FRAMEBUFFER);
 
     // Signal that output is valid
-    renderInterface.rendered.setValue(true);
-}
-
-void AntialiasableTriangleStage::onInputValueChanged(gloperate::AbstractSlot * /*slot*/)
-{
-    renderInterface.rendered.invalidate();
+    canvasInterface.updateRenderTargetOutputs();
 }
 
 void AntialiasableTriangleStage::setupGeometry()

source/examples/demo-stages-plugins/AntialiasableTriangleStage.h

@@ -12,7 +12,7 @@
 
 #include <gloperate/gloperate-version.h>
 #include <gloperate/pipeline/Stage.h>
-#include <gloperate/stages/interfaces/RenderInterface.h>
+#include <gloperate/stages/interfaces/CanvasInterface.h>
 #include <gloperate/rendering/Camera.h>
 
 
@@ -36,7 +36,7 @@ class AntialiasableTriangleStage : public gloperate::Stage
 
 public:
     // Interfaces
-    gloperate::RenderInterface renderInterface;      ///< Interface for rendering into a viewer
+    gloperate::CanvasInterface canvasInterface;      ///< Interface for rendering into a viewer
 
     // Inputs
     Input<std::vector<glm::vec2> *> subpixelOffsets; ///< Subpixel offsets for multiframe antialiasing
@@ -66,7 +66,6 @@ class AntialiasableTriangleStage : public gloperate::Stage
     virtual void onContextInit(gloperate::AbstractGLContext * context) override;
     virtual void onContextDeinit(gloperate::AbstractGLContext * context) override;
     virtual void onProcess() override;
-    virtual void onInputValueChanged(gloperate::AbstractSlot * slot) override;
 
     // Helper functions
     void setupGeometry();

source/examples/demo-stages-plugins/AntialiasingRenderingPipeline.cpp

@@ -14,7 +14,7 @@ CPPEXPOSE_COMPONENT(AntialiasingRenderingPipeline, gloperate::Stage)
 
 AntialiasingRenderingPipeline::AntialiasingRenderingPipeline(gloperate::Environment * environment, const std::string & name)
 : Pipeline(environment, name)
-, renderInterface(this)
+, canvasInterface(this)
 , multiFrameCount("multiFrameCount", this, 1)
 , m_subpixelStage(cppassist::make_unique<gloperate_glkernel::DiscDistributionKernelStage>(environment))
 , m_triangleStage(cppassist::make_unique<AntialiasableTriangleStage>(environment))
@@ -24,15 +24,14 @@ AntialiasingRenderingPipeline::AntialiasingRenderingPipeline(gloperate::Environm
     m_subpixelStage->radius.setValue(0.001f); // guessing inverse height of viewport
 
     addStage(m_triangleStage.get());
-    m_triangleStage->renderInterface.backgroundColor << renderInterface.backgroundColor;
-    m_triangleStage->renderInterface.deviceViewport << renderInterface.deviceViewport;
-    m_triangleStage->renderInterface.frameCounter << renderInterface.frameCounter;
-    m_triangleStage->renderInterface.targetFBO << renderInterface.targetFBO;
-    m_triangleStage->renderInterface.timeDelta << renderInterface.timeDelta;
-    m_triangleStage->renderInterface.virtualViewport << renderInterface.virtualViewport;
+    m_triangleStage->canvasInterface.backgroundColor << canvasInterface.backgroundColor;
+    m_triangleStage->canvasInterface.viewport << canvasInterface.viewport;
+    m_triangleStage->canvasInterface.frameCounter << canvasInterface.frameCounter;
+    m_triangleStage->canvasInterface.timeDelta << canvasInterface.timeDelta;
     m_triangleStage->subpixelOffsets << m_subpixelStage->kernel;
 
-    renderInterface.rendered << m_triangleStage->renderInterface.rendered;
+    m_triangleStage->createInput("Color") << *createInput<gloperate::ColorRenderTarget *>("Color");
+    *createOutput<gloperate::ColorRenderTarget *>("Color") << *m_triangleStage->createOutput<gloperate::ColorRenderTarget *>("Color");
 }
 
 AntialiasingRenderingPipeline::~AntialiasingRenderingPipeline()

source/examples/demo-stages-plugins/AntialiasingRenderingPipeline.h

@@ -6,7 +6,7 @@
 
 #include <gloperate/gloperate-version.h>
 #include <gloperate/pipeline/Pipeline.h>
-#include <gloperate/stages/interfaces/RenderInterface.h>
+#include <gloperate/stages/interfaces/CanvasInterface.h>
 
 
 namespace gloperate_glkernel
@@ -43,7 +43,7 @@ class AntialiasingRenderingPipeline : public gloperate::Pipeline
 
 public:
     // Interfaces
-    gloperate::RenderInterface renderInterface; ///< Interface for rendering into a viewer
+    gloperate::CanvasInterface canvasInterface; ///< Interface for rendering into a viewer
 
     // Inputs
     Input<int> multiFrameCount;                 ///< Total number of frames to aggregate

source/examples/demo-stages-plugins/CMakeLists.txt

@@ -69,8 +69,6 @@ set(headers
 )
 
 set(sources
-    ${source_path}/plugin.cpp
-
     ${source_path}/AntialiasableTriangleStage.cpp
     ${source_path}/AntialiasingRenderingPipeline.cpp
     ${source_path}/AssimpMeshLoader.cpp

source/examples/demo-stages-plugins/ColorGradientDemo.cpp

@@ -26,7 +26,7 @@ using namespace gloperate;
 
 ColorGradientDemo::ColorGradientDemo(Environment * environment, const std::string & name)
 : Pipeline(environment, "ColorGradientDemo", name)
-, renderInterface(this)
+, canvasInterface(this)
 , colors("colors", this, dataPath() + "/gloperate/gradients/colorbrewer.json")
 , gradient("gradient", this)
 , value("value", this, 0.5f)
@@ -56,7 +56,7 @@ ColorGradientDemo::ColorGradientDemo(Environment * environment, const std::strin
 
     // Trackball stage
     addStage(m_trackball.get());
-    m_trackball->viewport << renderInterface.deviceViewport;
+    m_trackball->viewport << canvasInterface.viewport;
 
     // Shape stage
     addStage(m_shape.get());
@@ -108,19 +108,20 @@ ColorGradientDemo::ColorGradientDemo(Environment * environment, const std::strin
 
     // Clear stage
     addStage(m_clear.get());
-    m_clear->renderInterface.targetFBO << renderInterface.targetFBO;
-    m_clear->renderInterface.deviceViewport << renderInterface.deviceViewport;
-    m_clear->renderInterface.backgroundColor = Color(0.0f, 0.0f, 0.0f, 1.0f);
-    m_clear->createInput("renderPass") << m_shapeRenderPass->renderPass;
+    m_clear->createInput("ColorAttachment") << *createInput<gloperate::ColorRenderTarget *>("Color");
+    m_clear->createInput("DepthAttachment") << *createInput<gloperate::DepthRenderTarget *>("Depth");
+    m_clear->createInput("ColorValue") << canvasInterface.backgroundColor;
+    m_clear->createInput("DepthValue") = 1.0f;
 
     // Rasterization stage for shape
     addStage(m_shapeRasterization.get());
-    m_shapeRasterization->renderInterface.targetFBO << m_clear->fboOut;
-    m_shapeRasterization->renderInterface.deviceViewport << renderInterface.deviceViewport;
+    m_shapeRasterization->createInput("Color") << *m_clear->createOutput<gloperate::ColorRenderTarget *>("ColorOut");
+    m_shapeRasterization->createInput("Depth") << *m_clear->createOutput<gloperate::DepthRenderTarget *>("DepthOut");
+    m_shapeRasterization->renderInterface.viewport << canvasInterface.viewport;
     m_shapeRasterization->drawable << m_shapeRenderPass->renderPass;
 
     // Outputs
-    renderInterface.rendered << m_shapeRasterization->renderInterface.rendered;
+    *createOutput<gloperate::ColorRenderTarget *>("ColorOut") << *m_shapeRasterization->createOutput<gloperate::ColorRenderTarget *>("ColorOut");
 }
 
 ColorGradientDemo::~ColorGradientDemo()

source/examples/demo-stages-plugins/ColorGradientDemo.h

@@ -8,7 +8,7 @@
 #include <gloperate/base/ExtendedProperties.h>
 #include <gloperate/pipeline/Pipeline.h>
 #include <gloperate/pipeline/Input.h>
-#include <gloperate/stages/interfaces/RenderInterface.h>
+#include <gloperate/stages/interfaces/CanvasInterface.h>
 
 
 namespace gloperate
@@ -46,7 +46,7 @@ class ColorGradientDemo : public gloperate::Pipeline
 
 public:
     // Interfaces
-    gloperate::RenderInterface renderInterface; ///< Interface for rendering into a viewer
+    gloperate::CanvasInterface canvasInterface; ///< Interface for rendering into a viewer
 
     // Inputs
     Input<cppassist::FilePath> colors;   ///< Color gradients filename

source/examples/demo-stages-plugins/DOFCubeStage.cpp

@@ -48,7 +48,7 @@ CPPEXPOSE_COMPONENT(DOFCubeStage, gloperate::Stage)
 
 DOFCubeStage::DOFCubeStage(gloperate::Environment * environment, const std::string & name)
 : Stage(environment, name)
-, renderInterface(this)
+, canvasInterface(this)
 , dofShifts("dofShift", this, nullptr)
 {
 }
@@ -59,6 +59,7 @@ DOFCubeStage::~DOFCubeStage()
 
 void DOFCubeStage::onContextInit(gloperate::AbstractGLContext *)
 {
+    canvasInterface.onContextInit();
     setupGeometry();
     setupProgram();
 }
@@ -69,6 +70,7 @@ void DOFCubeStage::onContextDeinit(gloperate::AbstractGLContext *)
     m_program.reset();
     m_fragmentShader.reset();
     m_vertexShader.reset();
+    canvasInterface.onContextDeinit();
 
     // deinitialize geometry
     m_vertexBuffer.reset();
@@ -78,7 +80,7 @@ void DOFCubeStage::onContextDeinit(gloperate::AbstractGLContext *)
 void DOFCubeStage::onProcess()
 {
     // Get viewport
-    glm::vec4 viewport = *renderInterface.deviceViewport;
+    const glm::vec4 & viewport = *canvasInterface.viewport;
 
     // Update viewport
     gl::glViewport(
@@ -89,11 +91,11 @@ void DOFCubeStage::onProcess()
     );
 
     // Bind FBO
-    globjects::Framebuffer * fbo = *renderInterface.targetFBO;
+    globjects::Framebuffer * fbo = canvasInterface.obtainFBO();
     fbo->bind(gl::GL_FRAMEBUFFER);
 
     // Clear background
-    auto & color = *renderInterface.backgroundColor;
+    auto & color = *canvasInterface.backgroundColor;
     gl::glClearColor(color.redf(), color.greenf(), color.bluef(), 1.0f);
     gl::glScissor(viewport.x, viewport.y, viewport.z, viewport.w);
     gl::glEnable(gl::GL_SCISSOR_TEST);
@@ -102,7 +104,7 @@ void DOFCubeStage::onProcess()
 
     // Set uniforms
     m_program->setUniform("dofShift", *dofShifts
-                                      ? (*dofShifts)->at((*renderInterface.frameCounter) % (*dofShifts)->size())
+                                      ? (*dofShifts)->at((*canvasInterface.frameCounter) % (*dofShifts)->size())
                                       : glm::vec2(0.0f));
 
     auto viewMatrix = glm::lookAt(glm::vec3(1.02f, -1.02f, 1.1f), glm::vec3(0.5f, -1.0f, -1.0f), glm::vec3(0.0f, 1.0f, 0.0f));
@@ -119,7 +121,7 @@ void DOFCubeStage::onProcess()
     globjects::Framebuffer::unbind(gl::GL_FRAMEBUFFER);
 
     // Signal that output is valid
-    renderInterface.rendered.setValue(true);
+    canvasInterface.updateRenderTargetOutputs();
 }
 
 void DOFCubeStage::setupGeometry()

source/examples/demo-stages-plugins/DOFCubeStage.h

@@ -13,7 +13,7 @@
 
 #include <gloperate/gloperate-version.h>
 #include <gloperate/pipeline/Stage.h>
-#include <gloperate/stages/interfaces/RenderInterface.h>
+#include <gloperate/stages/interfaces/CanvasInterface.h>
 #include <gloperate/rendering/Camera.h>
 
 
@@ -37,7 +37,7 @@ class DOFCubeStage : public gloperate::Stage
 
 public:
     // Interfaces
-    gloperate::RenderInterface renderInterface; ///< Interface for rendering into a viewer
+    gloperate::CanvasInterface canvasInterface; ///< Interface for rendering into a viewer
 
     // Inputs
     Input<std::vector<glm::vec2> *> dofShifts;  ///< DOF shift for multiframe rendering

source/examples/demo-stages-plugins/DOFRenderingPipeline.cpp

@@ -14,7 +14,7 @@ CPPEXPOSE_COMPONENT(DOFRenderingPipeline, gloperate::Stage)
 
 DOFRenderingPipeline::DOFRenderingPipeline(gloperate::Environment * environment, const std::string & name)
 : Pipeline(environment, name)
-, renderInterface(this)
+, canvasInterface(this)
 , multiFrameCount("multiFrameCount", this, 1)
 , m_dofShiftStage(cppassist::make_unique<gloperate_glkernel::DiscDistributionKernelStage>(environment))
 , m_cubeStage(cppassist::make_unique<DOFCubeStage>(environment))
@@ -24,15 +24,14 @@ DOFRenderingPipeline::DOFRenderingPipeline(gloperate::Environment * environment,
     m_dofShiftStage->radius.setValue(0.03f);
 
     addStage(m_cubeStage.get());
-    m_cubeStage->renderInterface.backgroundColor << renderInterface.backgroundColor;
-    m_cubeStage->renderInterface.deviceViewport << renderInterface.deviceViewport;
-    m_cubeStage->renderInterface.frameCounter << renderInterface.frameCounter;
-    m_cubeStage->renderInterface.targetFBO << renderInterface.targetFBO;
-    m_cubeStage->renderInterface.timeDelta << renderInterface.timeDelta;
-    m_cubeStage->renderInterface.virtualViewport << renderInterface.virtualViewport;
+    m_cubeStage->canvasInterface.backgroundColor << canvasInterface.backgroundColor;
+    m_cubeStage->canvasInterface.viewport << canvasInterface.viewport;
+    m_cubeStage->canvasInterface.frameCounter << canvasInterface.frameCounter;
+    m_cubeStage->canvasInterface.timeDelta << canvasInterface.timeDelta;
     m_cubeStage->dofShifts << m_dofShiftStage->kernel;
+    m_cubeStage->createInput("Color") << *createInput<gloperate::ColorRenderTarget *>("Color");
 
-    renderInterface.rendered << m_cubeStage->renderInterface.rendered;
+    *createOutput<gloperate::ColorRenderTarget *>("ColorOut") << *m_cubeStage->createOutput<gloperate::ColorRenderTarget *>("ColorOut");
 }
 
 DOFRenderingPipeline::~DOFRenderingPipeline()

source/examples/demo-stages-plugins/DOFRenderingPipeline.h

@@ -6,7 +6,7 @@
 
 #include <gloperate/gloperate-version.h>
 #include <gloperate/pipeline/Pipeline.h>
-#include <gloperate/stages/interfaces/RenderInterface.h>
+#include <gloperate/stages/interfaces/CanvasInterface.h>
 
 
 namespace gloperate_glkernel
@@ -42,7 +42,7 @@ class DOFRenderingPipeline : public gloperate::Pipeline
 
 public:
     // Interfaces
-    gloperate::RenderInterface renderInterface; ///< Interface for rendering into a viewer
+    gloperate::CanvasInterface canvasInterface; ///< Interface for rendering into a viewer
 
     // Inputs
     Input<int> multiFrameCount;                 ///< Total number of multiframes to render

source/examples/demo-stages-plugins/DemoAntialiasingAggregationPipeline.cpp

@@ -11,27 +11,27 @@ CPPEXPOSE_COMPONENT(DemoAntialiasingAggregationPipeline, gloperate::Stage)
 
 DemoAntialiasingAggregationPipeline::DemoAntialiasingAggregationPipeline(gloperate::Environment * environment, const std::string & name)
 : Pipeline(environment, name)
-, renderInterface(this)
+, canvasInterface(this)
 , multiFrameCount("multiFrameCount", this, 64)
 , m_multiFramePipeline(cppassist::make_unique<gloperate_glkernel::MultiFrameAggregationPipeline>(environment))
 , m_antialiasingPipeline(cppassist::make_unique<AntialiasingRenderingPipeline>(environment))
 {
     addStage(m_multiFramePipeline.get());
 
-    m_multiFramePipeline->setFrameRenderer(m_antialiasingPipeline->renderInterface);
+    m_multiFramePipeline->addStage(m_antialiasingPipeline.get());
     m_antialiasingPipeline->multiFrameCount << multiFrameCount;
 
     // Inputs
-    m_multiFramePipeline->renderInterface.deviceViewport << renderInterface.deviceViewport;
-    m_multiFramePipeline->renderInterface.virtualViewport << renderInterface.virtualViewport;
-    m_multiFramePipeline->renderInterface.backgroundColor << renderInterface.backgroundColor;
-    m_multiFramePipeline->renderInterface.frameCounter << renderInterface.frameCounter;
-    m_multiFramePipeline->renderInterface.timeDelta << renderInterface.timeDelta;
-    m_multiFramePipeline->renderInterface.targetFBO << renderInterface.targetFBO;
+    *m_multiFramePipeline->canvasInterface.colorRenderTargetInput(0) << *createInput<gloperate::ColorRenderTarget *>("Color");
+
+    m_multiFramePipeline->canvasInterface.viewport << canvasInterface.viewport;
+    m_multiFramePipeline->canvasInterface.backgroundColor << canvasInterface.backgroundColor;
+    m_multiFramePipeline->canvasInterface.frameCounter << canvasInterface.frameCounter;
+    m_multiFramePipeline->canvasInterface.timeDelta << canvasInterface.timeDelta;
     m_multiFramePipeline->multiFrameCount << multiFrameCount;
 
     // Outputs
-    renderInterface.rendered << m_multiFramePipeline->renderInterface.rendered;
+    *createOutput<gloperate::ColorRenderTarget *>("ColorOut") << *m_multiFramePipeline->canvasInterface.colorRenderTargetOutput(0);
 }
 
 DemoAntialiasingAggregationPipeline::~DemoAntialiasingAggregationPipeline()