Replace ModuleObservers implementation in OpenGLShader with signals.

include/irender.h

@@ -402,7 +402,6 @@ class OpenGLRenderable
 
 class Matrix4;
 class Texture;
-class ModuleObserver;
 
 #include "math/Vector3.h"
 
@@ -463,8 +462,13 @@ class Shader
 
     virtual void incrementUsed() = 0;
     virtual void decrementUsed() = 0;
-    virtual void attach(ModuleObserver& observer) = 0;
-    virtual void detach(ModuleObserver& observer) = 0;
+
+	virtual sigc::signal<void>& signal_Realised() = 0;
+	virtual sigc::signal<void>& signal_Unrealised() = 0;
+
+	virtual bool isRealised() = 0;
+    //virtual void attach(ModuleObserver& observer) = 0;
+    //virtual void detach(ModuleObserver& observer) = 0;
 
 	/**
      * \brief Retrieve the Material that was used to construct this shader (if

libs/SurfaceShader.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <string>
+#include <sigc++/connection.h>
 #include "debugging/debugging.h"
 #include "moduleobservers.h"
 #include "util/Noncopyable.h"
@@ -14,7 +15,6 @@
  * shadersystem reference available.
  */
 class SurfaceShader :
-    public ModuleObserver,
     public util::Noncopyable
 {
 public:
@@ -44,6 +44,9 @@ class SurfaceShader :
     typedef std::set<Observer*> Observers;
     Observers _observers;
 
+	sigc::connection _shaderRealised;
+	sigc::connection _shaderUnrealised;
+
 public:
     // Constructor. The renderSystem reference will be kept internally as reference
     // The SurfaceShader will try to de-reference it when capturing shaders.
@@ -171,16 +174,17 @@ class SurfaceShader :
         _observers.erase(&observer);
     }
 
-    // ModuleObserver methods
-    void realise() override
+	// Called when the GL shader is realised
+    void realise()
     {
         assert(!_realised);
         _realised = true;
 
         for (auto i : _observers) i->realiseShader();
     }
 
-    void unrealise() override
+	// Called when the GL shader is unrealised
+    void unrealise()
     {
         assert(_realised);
 
@@ -193,38 +197,47 @@ class SurfaceShader :
     // Shader capture and release
     void captureShader()
     {
+		// Release previous resources in any case
+		releaseShader();
+
         // Check if we have a rendersystem - can we capture already?
         if (_renderSystem)
         {
-            releaseShader();
-
             _glShader = _renderSystem->capture(_materialName);
             assert(_glShader);
 
-            _glShader->attach(*this);
+			_shaderRealised = _glShader->signal_Realised().connect(
+				sigc::mem_fun(*this, &SurfaceShader::realise)
+			);
+			_shaderUnrealised = _glShader->signal_Unrealised().connect(
+				sigc::mem_fun(*this, &SurfaceShader::unrealise)
+			);
+
+			// Realise right now if the GLShader is already in that state
+			if (_glShader->isRealised())
+			{
+				realise();
+			}
 
             if (_inUse)
             {
                 _glShader->incrementUsed();
             }
         }
-        else
-        {
-            releaseShader();
-        }
     }
 
     void releaseShader()
     {
+		_shaderRealised.disconnect();
+		_shaderUnrealised.disconnect();
+
         if (_glShader)
         {
             if (_inUse)
             {
                 _glShader->decrementUsed();
             }
 
-            _glShader->detach(*this);
-
             _glShader.reset();
         }
     }

radiant/render/OpenGLRenderSystem.cpp

@@ -6,6 +6,7 @@
 #include "math/Matrix4.h"
 #include "modulesystem/StaticModule.h"
 #include "backend/GLProgramFactory.h"
+#include "debugging/debugging.h"
 
 #include <functional>
 

radiant/render/backend/OpenGLShader.cpp

@@ -148,27 +148,19 @@ void OpenGLShader::decrementUsed()
     }
 }
 
-bool OpenGLShader::realised() const
+sigc::signal<void>& OpenGLShader::signal_Realised()
 {
-    return _material != 0;
+	return _sigRealised;
 }
 
-void OpenGLShader::attach(ModuleObserver& observer)
+sigc::signal<void>& OpenGLShader::signal_Unrealised()
 {
-    if (realised())
-    {
-        observer.realise();
-    }
-    m_observers.attach(observer);
+	return _sigUnrealised;
 }
 
-void OpenGLShader::detach(ModuleObserver& observer)
+bool OpenGLShader::isRealised()
 {
-    if (realised())
-    {
-        observer.unrealise();
-    }
-    m_observers.detach(observer);
+    return _material != 0;
 }
 
 void OpenGLShader::realise(const std::string& name)
@@ -189,7 +181,7 @@ void OpenGLShader::realise(const std::string& name)
 
     insertPasses();
 
-    m_observers.realise();
+	signal_Realised().emit();
 }
 
 void OpenGLShader::insertPasses()
@@ -218,7 +210,7 @@ void OpenGLShader::removePasses()
 
 void OpenGLShader::unrealise()
 {
-    m_observers.unrealise();
+	signal_Unrealised().emit();
 
     removePasses();
 

radiant/render/backend/OpenGLShader.h

@@ -4,7 +4,6 @@
 
 #include "irender.h"
 #include "ishaders.h"
-#include "moduleobservers.h"
 #include "string/string.h"
 
 #include <list>
@@ -17,8 +16,8 @@ class OpenGLRenderSystem;
 /**
  * Implementation of the Shader class.
  */
-class OpenGLShader
-: public Shader
+class OpenGLShader : 
+	public Shader
 {
     // The state manager we will be inserting/removing OpenGL states from
     OpenGLRenderSystem& _renderSystem;
@@ -34,7 +33,9 @@ class OpenGLShader
     bool _isVisible;
 
 	std::size_t _useCount;
-	ModuleObservers m_observers;
+
+	sigc::signal<void> _sigRealised;
+	sigc::signal<void> _sigUnrealised;
 
 private:
 
@@ -69,8 +70,6 @@ class OpenGLShader
     void insertPasses();
     void removePasses();
 
-    bool realised() const;
-
 public:
     /// Construct and initialise
     OpenGLShader(OpenGLRenderSystem& renderSystem);
@@ -93,8 +92,10 @@ class OpenGLShader
     void incrementUsed() override;
     void decrementUsed() override;
 
-    void attach(ModuleObserver& observer) override;
-    void detach(ModuleObserver& observer) override;
+	sigc::signal<void>& signal_Realised() override;
+	sigc::signal<void>& signal_Unrealised() override;
+
+	bool isRealised() override;
 
 	/**
 	 * Realise this shader, setting the name in the process.