Update some memory management and plugin unload timing

- Change to unique_ptr for BasePlugin creator
- PostProcessRegion creates unique_ptr, not raw pointer
- rpcore::Globals has unload function and is unloaded before removing showbase
- Fix #18

Author: bluekyu

render_pipeline/rpcore/globals.hpp

@@ -44,6 +44,7 @@ class RENDER_PIPELINE_DECL Globals
 {
 public:
     static void load(rppanda::ShowBase* showbase);
+    static void unload();
 
     static rppanda::ShowBase* base;
     static NodePath render;

render_pipeline/rpcore/pluginbase/base_plugin.hpp

@@ -30,9 +30,9 @@
 #include <render_pipeline/rpcore/pluginbase/day_setting_types.hpp>
 
 #define RENDER_PIPELINE_PLUGIN_CREATOR(PLUGIN_TYPE) \
-    static std::shared_ptr<::rpcore::BasePlugin> rpcpp_plugin_creator__(::rpcore::RenderPipeline& pipeline) \
+    static std::unique_ptr<::rpcore::BasePlugin> rpcpp_plugin_creator__(::rpcore::RenderPipeline& pipeline) \
     { \
-        return std::make_shared<PLUGIN_TYPE>(pipeline); \
+        return std::make_unique<PLUGIN_TYPE>(pipeline); \
     } \
     BOOST_DLL_ALIAS(::rpcpp_plugin_creator__, create_plugin)
 

render_pipeline/rpcore/pluginbase/manager.hpp

@@ -50,7 +50,7 @@ class RENDER_PIPELINE_DECL PluginManager : public RPObject
     using SettingsDataType = std::map<std::string, std::shared_ptr<BaseType>>;
     using DaySettingsDataType = std::map<std::string, std::shared_ptr<DayBaseType>>;
 
-    typedef std::shared_ptr<BasePlugin> (PluginCreatorType)(RenderPipeline&);
+    typedef std::unique_ptr<BasePlugin> (PluginCreatorType)(RenderPipeline&);
 
 public:
     /**

render_pipeline/rpcore/util/post_process_region.hpp

@@ -23,22 +23,22 @@
 #pragma once
 
 #include <nodePath.h>
-#include <graphicsOutput.h>
 
 #include <unordered_map>
 #include <functional>
 
 #include <render_pipeline/rpcore/rpobject.hpp>
 
+class GraphicsOutput;
 class CallbackObject;
 
 namespace rpcore {
 
 class RENDER_PIPELINE_DECL PostProcessRegion
 {
 public:
-    static PostProcessRegion* make(GraphicsOutput* internal_buffer);
-    static PostProcessRegion* make(GraphicsOutput* internal_buffer, const LVecBase4f& dimensions);
+    static std::unique_ptr<PostProcessRegion> make(GraphicsOutput* internal_buffer);
+    static std::unique_ptr<PostProcessRegion> make(GraphicsOutput* internal_buffer, const LVecBase4f& dimensions);
 
 public:
     PostProcessRegion(GraphicsOutput* internal_buffer);
@@ -67,16 +67,15 @@ class RENDER_PIPELINE_DECL PostProcessRegion
     std::function<void(const RenderAttrib*,int)> set_attrib;
     ///@}
 
-    DisplayRegion* get_region() { return region; }
-    NodePath get_node() const { return node; }
+    DisplayRegion* get_region() const;
+    NodePath get_node() const;
 
 private:
     void init_function_pointers();
     void make_fullscreen_tri();
     void make_fullscreen_cam();
 
-    PT(GraphicsOutput) _buffer;
-    PT(DisplayRegion) region;
+    PT(DisplayRegion) region_;
     NodePath node;
     NodePath tri;
     NodePath camera;
@@ -90,4 +89,14 @@ inline void PostProcessRegion::set_shader_input(const ShaderInput& inp, bool ove
         tri.set_shader_input(inp);
 }
 
+inline DisplayRegion* PostProcessRegion::get_region() const
+{
+    return region_;
+}
+
+inline NodePath PostProcessRegion::get_node() const
+{
+    return node;
+}
+
 }

src/rpcore/globals.cpp

@@ -43,4 +43,12 @@ void Globals::load(rppanda::ShowBase* showbase)
     Globals::resolution = LVecBase2i(0, 0);
 }
 
+void Globals::unload()
+{
+    Globals::base = nullptr;
+    Globals::render.clear();
+    Globals::clock = nullptr;
+    Globals::font = nullptr;
+}
+
 }

src/rpcore/pluginbase/base_plugin.cpp

@@ -50,10 +50,13 @@ BasePlugin::BasePlugin(RenderPipeline& pipeline, const std::string& plugin_id):
     RPObject(std::string("plugin:") + plugin_id), pipeline_(pipeline), plugin_id_(plugin_id),
     impl_(std::make_unique<Impl>())
 {
+    trace(fmt::format("Constructing '{}' plugin", plugin_id_));
 }
 
 BasePlugin::~BasePlugin()
 {
+    trace(fmt::format("Destructing '{}' plugin", plugin_id_));
+
     auto manager = pipeline_.get_stage_mgr();
     if (!manager)
         return;

src/rpcore/pluginbase/manager.cpp

@@ -72,7 +72,7 @@ class PluginManager::Impl
     void unload();
 
     /** Internal method to load a plugin. */
-    std::shared_ptr<BasePlugin> load_plugin(const std::string& plugin_id);
+    std::unique_ptr<BasePlugin> load_plugin(const std::string& plugin_id);
 
     void load_plugin_settings(const std::string& plugin_id, const Filename& plugin_pth);
 
@@ -137,11 +137,10 @@ void PluginManager::Impl::unload()
     day_settings_.clear();
     enabled_plugins_.clear();
 
-    // unload DLL of plugins.
-    plugin_creators_.clear();
+    // NOTE: DLLs are not unloaded, yet.
 }
 
-std::shared_ptr<BasePlugin> PluginManager::Impl::load_plugin(const std::string& plugin_id)
+std::unique_ptr<BasePlugin> PluginManager::Impl::load_plugin(const std::string& plugin_id)
 {
     boost::filesystem::path plugin_path = get_canonical_path(plugin_dir_ / plugin_id);
 
@@ -381,6 +380,8 @@ PluginManager::~PluginManager()
     trace("Destructing PluginManager");
 
     unload();
+
+    // unload DLL of plugins.
 }
 
 void PluginManager::load()
@@ -401,10 +402,10 @@ void PluginManager::load()
             continue;
         }
 
-        std::shared_ptr<BasePlugin> handle = impl_->load_plugin(plugin_id);
+        auto handle = impl_->load_plugin(plugin_id);
 
         if (handle)
-            impl_->instances_[plugin_id] = handle;
+            impl_->instances_[plugin_id] = std::move(handle);
         else
             disable_plugin(plugin_id);
     }

src/rpcore/render_pipeline.cpp

@@ -251,14 +251,9 @@ class RenderPipeline::Impl
     std::unique_ptr<LoadingScreen> loading_screen_;
     std::unique_ptr<CommonResources> common_resources_;
 
-    std::unique_ptr<AmbientStage> ambient_stage_;
-    std::unique_ptr<GBufferStage> gbuffer_stage_;
-    std::unique_ptr<FinalStage> final_stage_;
-    std::unique_ptr<DownscaleZStage> downscale_stage_;
-    std::unique_ptr<CombineVelocityStage> combine_velocity_stage_;
-    std::unique_ptr<UpscaleStage> upscale_stage_;
-
-    PT(rppanda::ShowBase) showbase_ = nullptr;
+    std::vector<std::unique_ptr<RenderStage>> internal_stages_;
+
+    PT(rppanda::ShowBase) showbase_;
     std::unique_ptr<TaskScheduler> task_scheduler_;
     std::unique_ptr<TagStateManager> tag_mgr_;
     std::unique_ptr<PluginManager> plugin_mgr_;
@@ -289,6 +284,12 @@ RenderPipeline::Impl::~Impl()
     debugger_.reset();
     loading_screen_.reset();
 
+    plugin_mgr_->unload();
+
+    internal_stages_.clear();
+
+    Globals::unload();
+
     showbase_.clear();
 
     // should delete at last to delete resources in DLL module.
@@ -761,26 +762,32 @@ void RenderPipeline::Impl::init_common_stages()
 {
     self_.trace("Initailizing common stages ...");
 
-    ambient_stage_ = std::make_unique<AmbientStage>(self_);
-    stage_mgr_->add_stage(ambient_stage_.get());
+    auto ambient_stage = std::make_unique<AmbientStage>(self_);
+    stage_mgr_->add_stage(ambient_stage.get());
+    internal_stages_.push_back(std::move(ambient_stage));
 
-    gbuffer_stage_ = std::make_unique<GBufferStage>(self_);
-    stage_mgr_->add_stage(gbuffer_stage_.get());
+    auto gbuffer_stage = std::make_unique<GBufferStage>(self_);
+    stage_mgr_->add_stage(gbuffer_stage.get());
+    internal_stages_.push_back(std::move(gbuffer_stage));
 
-    final_stage_ = std::make_unique<FinalStage>(self_);
-    stage_mgr_->add_stage(final_stage_.get());
+    auto final_stage = std::make_unique<FinalStage>(self_);
+    stage_mgr_->add_stage(final_stage.get());
+    internal_stages_.push_back(std::move(final_stage));
 
-    downscale_stage_ = std::make_unique<DownscaleZStage>(self_);
-    stage_mgr_->add_stage(downscale_stage_.get());
+    auto downscale_stage = std::make_unique<DownscaleZStage>(self_);
+    stage_mgr_->add_stage(downscale_stage.get());
+    internal_stages_.push_back(std::move(downscale_stage));
 
-    combine_velocity_stage_ = std::make_unique<CombineVelocityStage>(self_);
-    stage_mgr_->add_stage(combine_velocity_stage_.get());
+    auto combine_velocity_stage = std::make_unique<CombineVelocityStage>(self_);
+    stage_mgr_->add_stage(combine_velocity_stage.get());
+    internal_stages_.push_back(std::move(combine_velocity_stage));
 
     // Add an upscale/downscale stage in case we render at a different resolution
     if (Globals::resolution != Globals::native_resolution)
     {
-        upscale_stage_ = std::make_unique<UpscaleStage>(self_);
-        stage_mgr_->add_stage(upscale_stage_.get());
+        auto upscale_stage = std::make_unique<UpscaleStage>(self_);
+        stage_mgr_->add_stage(upscale_stage.get());
+        internal_stages_.push_back(std::move(upscale_stage));
     }
 }
 

src/rpcore/render_target.cpp

@@ -67,11 +67,11 @@ class RenderTarget::Impl
 public:
     RenderTarget& self_;
 
-    PT(GraphicsBuffer) internal_buffer_ = nullptr;
+    GraphicsBuffer* internal_buffer_ = nullptr;
     GraphicsWindow* source_window_ = nullptr;
 
     PT(DisplayRegion) source_display_region_ = nullptr;
-    PostProcessRegion* source_postprocess_region_ = nullptr;
+    std::unique_ptr<PostProcessRegion> source_postprocess_region_;
 
     GraphicsEngine* engine_ = nullptr;
 
@@ -120,11 +120,7 @@ void RenderTarget::Impl::prepare_render(const NodePath& camera_np)
     create_default_region_ = false;
     create_buffer();
     source_display_region_ = internal_buffer_->get_display_region(0);
-    if (source_postprocess_region_)
-    {
-        delete source_postprocess_region_;
-        source_postprocess_region_ = nullptr;
-    }
+    source_postprocess_region_.reset();
 
     if (!camera_np.is_empty())
     {
@@ -176,14 +172,11 @@ void RenderTarget::Impl::remove()
         engine_->remove_window(internal_buffer_);
 
         RenderTarget::REGISTERED_TARGETS.erase(std::find(RenderTarget::REGISTERED_TARGETS.begin(), RenderTarget::REGISTERED_TARGETS.end(), &self_));
-        internal_buffer_.clear();
-    }
-    else
-    {
-        delete source_postprocess_region_;
-        source_postprocess_region_ = nullptr;
+        internal_buffer_ = nullptr;
     }
 
+    source_postprocess_region_.reset();
+
     active_ = false;
     for (const auto& target: targets_)
         target.second->release_all();
@@ -558,7 +551,7 @@ DisplayRegion* RenderTarget::get_display_region() const
 
 PostProcessRegion* RenderTarget::get_postprocess_region() const
 {
-    return impl_->source_postprocess_region_;
+    return impl_->source_postprocess_region_.get();
 }
 
 void RenderTarget::consider_resize()

src/rpcore/stages/gbuffer_stage.cpp

@@ -43,7 +43,7 @@ GBufferStage::ProduceType GBufferStage::get_produced_pipes() const
 
 std::shared_ptr<SimpleInputBlock> GBufferStage::make_gbuffer_ubo() const
 {
-    std::shared_ptr<SimpleInputBlock> ubo(new SimpleInputBlock("GBuffer"));
+    std::shared_ptr<SimpleInputBlock> ubo = std::make_shared<SimpleInputBlock>("GBuffer");
     ubo->add_input("Depth", target_->get_depth_tex());
     ubo->add_input("Data0", target_->get_color_tex());
     ubo->add_input("Data1", target_->get_aux_tex(0));

src/rpcore/util/post_process_region.cpp

@@ -26,23 +26,23 @@
 #include <geomTriangles.h>
 #include <omniBoundingVolume.h>
 #include <orthographicLens.h>
+#include <graphicsOutput.h>
 
 namespace rpcore {
 
-PostProcessRegion* PostProcessRegion::make(GraphicsOutput* internal_buffer)
+std::unique_ptr<PostProcessRegion> PostProcessRegion::make(GraphicsOutput* internal_buffer)
 {
-    return new PostProcessRegion(internal_buffer);
+    return std::make_unique<PostProcessRegion>(internal_buffer);
 }
 
-PostProcessRegion* PostProcessRegion::make(GraphicsOutput* internal_buffer, const LVecBase4f& dimensions)
+std::unique_ptr<PostProcessRegion> PostProcessRegion::make(GraphicsOutput* internal_buffer, const LVecBase4f& dimensions)
 {
-    return new PostProcessRegion(internal_buffer, dimensions);
+    return std::make_unique<PostProcessRegion>(internal_buffer, dimensions);
 }
 
 PostProcessRegion::PostProcessRegion(GraphicsOutput* internal_buffer)
 {
-    _buffer = internal_buffer;
-    region = _buffer->make_display_region();
+    region_ = internal_buffer->make_display_region();
     node = NodePath("RTRoot");
 
     make_fullscreen_tri();
@@ -52,8 +52,7 @@ PostProcessRegion::PostProcessRegion(GraphicsOutput* internal_buffer)
 
 PostProcessRegion::PostProcessRegion(GraphicsOutput* internal_buffer, const LVecBase4f& dimensions)
 {
-    _buffer = internal_buffer;
-    region = _buffer->make_display_region(dimensions);
+    region_ = internal_buffer->make_display_region(dimensions);
     node = NodePath("RTRoot");
 
     make_fullscreen_tri();
@@ -65,15 +64,15 @@ void PostProcessRegion::init_function_pointers()
 {
     using namespace std::placeholders;
 
-    set_sort = std::bind(&DisplayRegion::set_sort, region, _1);
-    disable_clears = std::bind(&DisplayRegion::disable_clears, region);
-    set_active = std::bind(&DisplayRegion::set_active, region, _1);
-    set_clear_depth_active = std::bind(&DisplayRegion::set_clear_depth_active, region, _1);
-    set_clear_depth = std::bind(&DisplayRegion::set_clear_depth, region, _1);
-    set_camera = std::bind(&DisplayRegion::set_camera, region, _1);
-    set_clear_color_active = std::bind(&DisplayRegion::set_clear_color_active, region, _1);
-    set_clear_color = std::bind(&DisplayRegion::set_clear_color, region, _1);
-    set_draw_callback = std::bind(&DisplayRegion::set_draw_callback, region, _1);
+    set_sort = std::bind(&DisplayRegion::set_sort, region_, _1);
+    disable_clears = std::bind(&DisplayRegion::disable_clears, region_);
+    set_active = std::bind(&DisplayRegion::set_active, region_, _1);
+    set_clear_depth_active = std::bind(&DisplayRegion::set_clear_depth_active, region_, _1);
+    set_clear_depth = std::bind(&DisplayRegion::set_clear_depth, region_, _1);
+    set_camera = std::bind(&DisplayRegion::set_camera, region_, _1);
+    set_clear_color_active = std::bind(&DisplayRegion::set_clear_color_active, region_, _1);
+    set_clear_color = std::bind(&DisplayRegion::set_clear_color, region_, _1);
+    set_draw_callback = std::bind(&DisplayRegion::set_draw_callback, region_, _1);
 
     set_instance_count = std::bind(&NodePath::set_instance_count, tri, _1);
     set_shader = std::bind(&NodePath::set_shader, tri, _1, _2);
@@ -119,7 +118,7 @@ void PostProcessRegion::make_fullscreen_cam()
     PT(OmniBoundingVolume) obv = new OmniBoundingVolume();
     buffer_cam->set_cull_bounds(obv);
     camera = node.attach_new_node(buffer_cam);
-    region->set_camera(camera);
+    region_->set_camera(camera);
 }
 
 }

src/rpcore/util/shader_input_blocks.cpp

@@ -22,6 +22,8 @@
 
 #include "render_pipeline/rpcore/util/shader_input_blocks.hpp"
 
+#include <graphicsOutput.h>
+
 #include <regex>
 
 #include <boost/format.hpp>