Revert "RT CPU: flush scene objects pending deletion when rendering is paused"

This reverts commit 6104bed.

Author: howetuft

include/slg/engines/rtpathcpu/rtpathcpu.h

@@ -58,7 +58,7 @@ class RTPathCPUSampler;
 class RTPathCPURenderEngine : public PathCPURenderEngine {
 public:
 	RTPathCPURenderEngine(RenderConfigRef cfg);
-	virtual ~RTPathCPURenderEngine() = default;
+	~RTPathCPURenderEngine();
 
 	virtual RenderEngineType GetType() const { return GetObjectType(); }
 	virtual std::string GetTag() const { return GetObjectTag(); }
@@ -80,11 +80,15 @@ class RTPathCPURenderEngine : public PathCPURenderEngine {
 	friend class RTPathCPURenderThread;
 	friend class RTPathCPUSampler;
 
+    struct completion_t {
+        void operator()() noexcept { }
+    };
+
 protected:
 	static luxrays::PropertiesUPtr GetDefaultProps();
 
 	virtual bool IsRTMode() const { return true; }
-
+	
 	CPURenderThreadUPtr NewRenderThread(const u_int index,
 			luxrays::IntersectionDevice *device) {
 		return std::make_unique<RTPathCPURenderThread>(this, index, device);
@@ -109,12 +113,10 @@ class RTPathCPURenderEngine : public PathCPURenderEngine {
 
 	std::mutex firstFrameMutex;
     std::condition_variable firstFrameCondition;
-	std::atomic<u_int> firstFrameThreadDoneCount;
+	u_int firstFrameThreadDoneCount;
 	bool firstFrameDone;
 
-	using CompletionFunction = std::function<void()>;
-	std::unique_ptr<std::barrier<CompletionFunction>> threadsSyncBarrier;  // General sync
-	std::unique_ptr<std::barrier<CompletionFunction>> threadsPauseBarrier;  // Dedicated to pause event
+	std::barrier<completion_t> *threadsSyncBarrier;
 	std::atomic<bool> threadsPauseMode;
 };
 

include/slg/scene/scene.h

@@ -262,7 +262,7 @@ class Scene {
 	void SetEnableParsePrint(bool status) { enableParsePrint = status; }
 
 	void moveToTrash(luxrays::NamedObjectUPtr&&);
-	void EmptyTrash();
+	void emptyTrash();
 
 	// Serialization
 	static SceneUPtr LoadSerialized(const std::string &fileName);

src/slg/engines/rtpathcpu/rtpathcpu.cpp

@@ -19,8 +19,6 @@
 #include "slg/slg.h"
 #include "slg/samplers/rtpathcpusampler.h"
 #include <memory>
-#include <barrier>
-#include <csignal>
 #include "slg/engines/rtpathcpu/rtpathcpu.h"
 
 using namespace std;
@@ -31,25 +29,14 @@ using namespace slg;
 // RTPathCPURenderEngine
 //------------------------------------------------------------------------------
 
-
 RTPathCPURenderEngine::RTPathCPURenderEngine(RenderConfigRef rcfg) :
 		PathCPURenderEngine(rcfg) {
-
-	auto nullHandler = [&]() noexcept {
-	};
-
-	auto onPause = [&]() noexcept {
-		renderConfig.GetScene().EmptyTrash();
-	};
-
-	threadsSyncBarrier = std::make_unique<std::barrier<CompletionFunction>>(
-		renderThreads.size() + 1, nullHandler
-	);
-	threadsPauseBarrier = std::make_unique<std::barrier<CompletionFunction>>(
-		renderThreads.size() + 1, onPause
-	);
+	threadsSyncBarrier = new std::barrier(renderThreads.size() + 1, completion_t());
 }
 
+RTPathCPURenderEngine::~RTPathCPURenderEngine() {
+	delete threadsSyncBarrier;
+}
 
 void RTPathCPURenderEngine::StartLockLess() {
 	auto& cfg = renderConfig.GetConfig();
@@ -83,7 +70,7 @@ void RTPathCPURenderEngine::PauseThreads() {
 	threadsPauseMode = true;
 
 	// Wait for the threads
-	threadsPauseBarrier->arrive_and_wait();
+	threadsSyncBarrier->arrive_and_wait();
 }
 
 void RTPathCPURenderEngine::ResumeThreads() {

src/slg/engines/rtpathcpu/rtpathcputhread.cpp

@@ -36,7 +36,8 @@ RTPathCPURenderThread::RTPathCPURenderThread(RTPathCPURenderEngine *engine, cons
 	PathCPURenderThread(engine, index, device) {
 }
 
-RTPathCPURenderThread::~RTPathCPURenderThread() = default;
+RTPathCPURenderThread::~RTPathCPURenderThread() {
+}
 
 void RTPathCPURenderThread::StartRenderThread() {
 	// Avoid to allocate the film thread because I'm going to use the global one
@@ -82,7 +83,7 @@ void RTPathCPURenderThread::RTRenderFunc(std::stop_token stop_token) {
 		// Check if we are in pause or edit mode
 		if (engine->threadsPauseMode) {
 			// Synchronize all threads -> This waits for RTPathCPURenderEngine::PauseThreads()
-			engine->threadsPauseBarrier->arrive_and_wait();
+			engine->threadsSyncBarrier->arrive_and_wait();
 
 			while (!stop_token.stop_requested() && engine->threadsPauseMode)
 				std::this_thread::sleep_for(100ms);

src/slg/scene/scene.cpp

@@ -462,7 +462,7 @@ void Scene::moveToTrash(NamedObjectUPtr&& oldObj) {
 }
 
 
-void Scene::EmptyTrash() {
+void Scene::emptyTrash() {
 	std::lock_guard lk(trashMtx);
 	trashBin.clear();
 }