Extract AO and VoxelGenerator from SphereRenderer

.gitignore

@@ -41,3 +41,4 @@ __pycache__/
 # Individual developer settings for local machines
 mmprjs/**/*
 *.orig
+/out/install/x64-Debug

plugins/compositing_gl/CMakeLists.txt

@@ -9,7 +9,8 @@ megamol_plugin(compositing_gl
     opengl
   DEPENDS_PLUGINS
     mmstd
-    mmstd_gl)
+    mmstd_gl
+    geometry_calls)
 
 if (compositing_gl_PLUGIN_ENABLED)
   # Additional sources

plugins/compositing_gl/src/AO.h

@@ -0,0 +1,153 @@
+#pragma once
+
+#include "geometry_calls/VolumetricDataCall.h"
+#include "glowl/glowl.h"
+#include "mmcore/Call.h"
+#include "mmcore/CalleeSlot.h"
+#include "mmcore/CallerSlot.h"
+#include "mmcore/param/BoolParam.h"
+#include "mmcore/param/FloatParam.h"
+#include "mmcore/param/ParamSlot.h"
+#include "mmcore_gl/utility/ShaderFactory.h"
+#include "mmstd_gl/renderer/Renderer3DModuleGL.h"
+
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+#include <vector>
+
+namespace megamol::compositing_gl {
+
+class AO : public megamol::mmstd_gl::Renderer3DModuleGL {
+
+public:
+    /**
+     * Answer the name of this module.
+     *
+     * @return The name of this module.
+     */
+    static const char* ClassName(void) {
+        return "AO";
+    }
+
+    /**
+     * Answer a human readable description of this module.
+     *
+     * @return A human readable description of this module.
+     */
+    static const char* Description(void) {
+        return "AO";
+    }
+
+    /**
+     * Answers whether this module is available on the current system.
+     *
+     * @return 'true' if the module is available, 'false' otherwise.
+     */
+    static inline bool IsAvailable(void) {
+        return true;
+    }
+
+    /**
+     * Initialises a new instance.
+     */
+    AO(void);
+
+    /**
+     * Finalises an instance.
+     */
+    ~AO(void);
+
+protected:
+    /**
+     * Implementation of 'Create'.
+     *
+     * @return 'true' on success, 'false' otherwise.
+     */
+    bool create(void);
+
+
+    bool GetExtents(mmstd_gl::CallRender3DGL& call) override;
+
+    /**
+     * Implementation of 'Release'.
+     */
+    void release(void);
+
+    bool Render(mmstd_gl::CallRender3DGL& call) override;
+
+private:
+
+    core::CalleeSlot output_tex_slot_; // Ambient occlusion texture (left slot)
+
+    core::CallerSlot voxels_tex_slot_; // VolumetricDataCall (right slot)
+
+    core::CallerSlot get_lights_slot_;
+
+    /** Slot for querying normals render target texture, i.e. a rhs connection */
+    core::CallerSlot normals_tex_slot_;
+
+    /** Slot for querying depth render target texture, i.e. a rhs connection */
+    core::CallerSlot depth_tex_slot_;
+
+    /** Slot for querying color render target texture, i.e. a rhs connection */
+    core::CallerSlot color_tex_slot_;
+
+    /** Slot for querying camera, i.e. a rhs connection */
+    core::CallerSlot camera_slot_;
+
+
+    GLuint texture_handle_;
+    GLuint voxel_handle_;
+    GLuint vertex_array_;
+    GLuint vbo_;
+
+    std::shared_ptr<glowl::Texture2D> color_tex_;
+    std::shared_ptr<glowl::Texture2D> depth_tex_;
+    std::shared_ptr<glowl::Texture2D> normal_tex_;
+
+    glm::mat4 cur_mvp_inv_;
+    glm::vec3 cur_cam_pos_;
+    glm::vec4 cur_light_dir_;
+
+    vislib::math::Cuboid<float> cur_clip_box_;
+
+    int cur_vp_width_;
+    int cur_vp_height_;
+
+    std::unique_ptr<msf::ShaderFactoryOptionsOpenGL> shader_options_flags_;
+
+    std::shared_ptr<glowl::GLSLProgram> lighting_prgm_;
+
+    std::unique_ptr<glowl::BufferObject> ao_dir_ubo_;
+
+    core::param::ParamSlot vol_size_slot_;
+    core::param::ParamSlot ao_cone_apex_slot_;
+    core::param::ParamSlot enable_lighting_slot_;
+    core::param::ParamSlot ao_offset_slot_;
+    core::param::ParamSlot ao_strength_slot_;
+    core::param::ParamSlot ao_cone_length_slot_;
+
+    /**
+    * render deferreded pass with volume, depth, normal and color texture
+    */
+    void renderAmbientOcclusion();
+
+    /**
+    * generate cone directions to be used in AO shader
+    */
+    void generate3ConeDirections(std::vector<glm::vec4>& directions, float apex);
+
+    /**
+    * get volume data from volumetric data call
+    */
+    bool updateVolumeData(const unsigned int frameID);
+
+    /**
+    * recreate resources like shaders and buffers
+    */
+    bool recreateResources(void);
+};
+
+} // namespace megamol::compositing_gl

plugins/compositing_gl/src/SimpleRenderTarget.cpp

@@ -53,7 +53,8 @@ bool megamol::compositing_gl::SimpleRenderTarget::create() {
 
     m_GBuffer = std::make_shared<glowl::FramebufferObject>(1, 1);
     m_GBuffer->createColorAttachment(GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT); // surface albedo
-    m_GBuffer->createColorAttachment(GL_RGB16F, GL_RGB, GL_HALF_FLOAT);   // normals
+    m_GBuffer->createColorAttachment(GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT); // normals
+    //m_GBuffer->createColorAttachment(GL_RGB16F, GL_RGB, GL_HALF_FLOAT);   // normals
 
     return true;
 }

plugins/compositing_gl/src/compositing_gl.cpp

@@ -7,6 +7,7 @@
 #include "mmcore/factories/AbstractPluginInstance.h"
 #include "mmcore/factories/PluginRegister.h"
 
+#include "AO.h"
 #include "AntiAliasing.h"
 #include "DepthDarkening.h"
 #include "DrawToScreen.h"
@@ -45,6 +46,7 @@ class CompositingPluginInstance : public megamol::core::factories::AbstractPlugi
         this->module_descriptions.RegisterAutoDescription<megamol::compositing_gl::TextureDepthCompositing>();
         this->module_descriptions.RegisterAutoDescription<megamol::compositing_gl::NormalFromDepth>();
         this->module_descriptions.RegisterAutoDescription<megamol::compositing_gl::SSAO>();
+        this->module_descriptions.RegisterAutoDescription<megamol::compositing_gl::AO>();
         this->module_descriptions.RegisterAutoDescription<megamol::compositing_gl::AntiAliasing>();
         this->module_descriptions.RegisterAutoDescription<megamol::compositing_gl::PNGDataSource>();
         this->module_descriptions.RegisterAutoDescription<megamol::compositing_gl::TexInspectModule>();

plugins/moldyn_gl/shaders/moldyn_gl/sphere_renderer/inc/mdao_deferred_fragment_main.inc.glsl

@@ -8,8 +8,6 @@ uniform sampler2D inColorTex;
 uniform sampler2D inNormalsTex;
 uniform sampler2D inDepthTex;
 
-uniform bool inUseHighPrecision;
-
 uniform vec3 inObjLightDir;
 uniform vec3 inObjCamPos;
 
@@ -51,9 +49,6 @@ void main()
     vec3 color = texelFetch(inColorTex, texelCoord, 0).xyz;
     vec4 normal = texelFetch(inNormalsTex, texelCoord, 0);
 
-    if (!inUseHighPrecision)
-        normal = normal * 2.0 - 1.0;
-
     vec3 ray = normalize(objPos.xyz - inObjCamPos.xyz);
     vec3 lightCol = LocalLighting(ray, normal.xyz, inObjLightDir, color);
 

plugins/moldyn_gl/src/moldyn_gl.cpp

@@ -11,6 +11,8 @@
 #include "rendering/GlyphRenderer.h"
 #include "rendering/GrimRenderer.h"
 #include "rendering/SphereRenderer.h"
+#include "rendering/VoxelGenerator.h"
+//#include "rendering/AO.h"
 
 namespace megamol::moldyn_gl {
 class MoldynGLPluginInstance : public megamol::core::factories::AbstractPluginInstance {
@@ -31,6 +33,8 @@ class MoldynGLPluginInstance : public megamol::core::factories::AbstractPluginIn
         this->module_descriptions.RegisterAutoDescription<megamol::moldyn_gl::rendering::ArrowRenderer>();
         this->module_descriptions.RegisterAutoDescription<megamol::moldyn_gl::rendering::SphereRenderer>();
         this->module_descriptions.RegisterAutoDescription<megamol::moldyn_gl::rendering::GlyphRenderer>();
+        this->module_descriptions.RegisterAutoDescription<megamol::moldyn_gl::rendering::VoxelGenerator>();
+        //this->module_descriptions.RegisterAutoDescription<megamol::moldyn_gl::rendering::AO>();
     }
 };
 } // namespace megamol::moldyn_gl