Merge remote-tracking branch 'origin/UberShader-Update'

Former-commit-id: c4996b587140ffc36079fec54bde3e1bbb4728de

NazaraModuleTemplate/src/Nazara/ModuleName/ModuleName.cpp

@@ -3,6 +3,7 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/ModuleName/ModuleName.hpp>
+#include <Nazara/Core/CallOnExit.hpp>
 #include <Nazara/Core/Core.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/Log.hpp>
@@ -11,8 +12,11 @@
 
 bool NzModuleName::Initialize()
 {
-	if (s_moduleReferenceCounter++ != 0)
+	if (s_moduleReferenceCounter > 0)
+	{
+		s_moduleReferenceCounter++;
 		return true; // Déjà initialisé
+	}
 
 	// Initialisation des dépendances
 	if (!NzCore::Initialize())
@@ -21,10 +25,14 @@ bool NzModuleName::Initialize()
 		return false;
 	}
 
+	s_moduleReferenceCounter++;
+
 	// Initialisation du module
+	NzCallOnExit onExit(NzModuleName::Uninitialize);
+
+	onExit.Reset();
 
 	NazaraNotice("Initialized: ModuleName module");
-
 	return true;
 }
 

include/Nazara/Audio.hpp

@@ -1,4 +1,4 @@
-// This file was automatically generated on 12 Jan 2014 at 20:08:11
+// This file was automatically generated on 21 Feb 2014 at 18:17:18
 
 /*
 	Nazara Engine - Audio module

include/Nazara/Audio/Debug.hpp

@@ -5,7 +5,4 @@
 #include <Nazara/Audio/Config.hpp>
 #if NAZARA_AUDIO_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG)
 	#include <Nazara/Core/Debug/MemoryLeakTracker.hpp>
-
-	#define delete NzMemoryManager::NextFree(__FILE__, __LINE__), delete
-	#define new new(__FILE__, __LINE__)
 #endif

include/Nazara/Core.hpp

@@ -1,4 +1,4 @@
-// This file was automatically generated on 12 Jan 2014 at 20:08:11
+// This file was automatically generated on 21 Feb 2014 at 18:17:18
 
 /*
 	Nazara Engine - Core module
@@ -31,6 +31,7 @@
 
 #include <Nazara/Core/AbstractHash.hpp>
 #include <Nazara/Core/ByteArray.hpp>
+#include <Nazara/Core/CallOnExit.hpp>
 #include <Nazara/Core/Clock.hpp>
 #include <Nazara/Core/Color.hpp>
 #include <Nazara/Core/ConditionVariable.hpp>
@@ -56,6 +57,7 @@
 #include <Nazara/Core/MemoryStream.hpp>
 #include <Nazara/Core/Mutex.hpp>
 #include <Nazara/Core/NonCopyable.hpp>
+#include <Nazara/Core/ParameterList.hpp>
 #include <Nazara/Core/PluginManager.hpp>
 #include <Nazara/Core/Primitive.hpp>
 #include <Nazara/Core/PrimitiveList.hpp>

include/Nazara/Core/CallOnExit.hpp

@@ -0,0 +1,28 @@
+// Copyright (C) 2014 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Core module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_CALLONEXIT_HPP
+#define NAZARA_CALLONEXIT_HPP
+
+#include <Nazara/Prerequesites.hpp>
+
+class NzCallOnExit
+{
+	using Func = void (*)();
+
+	public:
+		NzCallOnExit(Func func = nullptr);
+		~NzCallOnExit();
+
+		void Reset(Func func = nullptr);
+
+	private:
+		Func m_func;
+};
+
+#include <Nazara/Core/CallOnExit.inl>
+
+#endif // NAZARA_CALLONEXIT_HPP

include/Nazara/Core/CallOnExit.inl

@@ -0,0 +1,23 @@
+// Copyright (C) 2014 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Core module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Core/Debug.hpp>
+
+inline NzCallOnExit::NzCallOnExit(Func func) :
+m_func(func)
+{
+}
+
+inline NzCallOnExit::~NzCallOnExit()
+{
+	if (m_func)
+		m_func();
+}
+
+inline void NzCallOnExit::Reset(Func func)
+{
+	m_func = func;
+}
+
+#include <Nazara/Core/DebugOff.hpp>

include/Nazara/Core/Debug.hpp

@@ -5,7 +5,4 @@
 #include <Nazara/Core/Config.hpp>
 #if NAZARA_CORE_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG)
 	#include <Nazara/Core/Debug/MemoryLeakTracker.hpp>
-
-	#define delete NzMemoryManager::NextFree(__FILE__, __LINE__), delete
-	#define new new(__FILE__, __LINE__)
 #endif

include/Nazara/Core/Debug/MemoryLeakTracker.hpp

@@ -14,14 +14,14 @@
 class NAZARA_API NzMemoryManager
 {
 	public:
-		NzMemoryManager();
-		~NzMemoryManager();
-
 		static void* Allocate(std::size_t size, bool multi, const char* file = nullptr, unsigned int line = 0);
 		static void Free(void* pointer, bool multi);
 		static void NextFree(const char* file, unsigned int line);
 
 	private:
+		NzMemoryManager();
+		~NzMemoryManager();
+
 		static void Initialize();
 		static char* TimeInfo();
 		static void Uninitialize();
@@ -33,3 +33,8 @@ NAZARA_API void operator delete(void* ptr, const char* file, unsigned int line)
 NAZARA_API void operator delete[](void* ptr, const char* file, unsigned int line) throw();
 
 #endif // NAZARA_DEBUG_MEMORYLEAKTRACKER_HPP
+
+#ifndef NAZARA_DEBUG_MEMORYLEAKTRACKER_DISABLE_REDEFINITION
+	#define delete NzMemoryManager::NextFree(__FILE__, __LINE__), delete
+	#define new new(__FILE__, __LINE__)
+#endif

include/Nazara/Core/DynLib.hpp

@@ -31,7 +31,7 @@ using NzDynLibFunc =  int (*)(); // Type "générique" de pointeur sur fonction
 
 class NzDynLibImpl;
 
-class NzDynLib : NzNonCopyable
+class NAZARA_API NzDynLib : NzNonCopyable
 {
 	public:
 		NzDynLib();

include/Nazara/Core/Enums.hpp

@@ -60,6 +60,19 @@ enum nzHash
 	nzHash_Whirlpool
 };
 
+enum nzParameterType
+{
+	nzParameterType_Boolean,
+	nzParameterType_Float,
+	nzParameterType_Integer,
+	nzParameterType_None,
+	nzParameterType_Pointer,
+	nzParameterType_String,
+	nzParameterType_Userdata,
+
+	nzParameterType_Max = nzParameterType_Userdata
+};
+
 enum nzPlugin
 {
 	nzPlugin_Assimp,

include/Nazara/Core/ParameterList.hpp

@@ -0,0 +1,94 @@
+// Copyright (C) 2014 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Core module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_PARAMETERLIST_HPP
+#define NAZARA_PARAMETERLIST_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/String.hpp>
+#include <atomic>
+#include <unordered_map>
+
+class NAZARA_API NzParameterList
+{
+	public:
+		using Destructor = void (*)(void* value);
+
+		NzParameterList() = default;
+		NzParameterList(const NzParameterList& list);
+		NzParameterList(NzParameterList&& list);
+		~NzParameterList();
+
+		void Clear();
+
+		bool GetBooleanParameter(const NzString& name, bool* value) const;
+		bool GetFloatParameter(const NzString& name, float* value) const;
+		bool GetIntegerParameter(const NzString& name, int* value) const;
+		bool GetParameterType(const NzString& name, nzParameterType* type) const;
+		bool GetPointerParameter(const NzString& name, void** value) const;
+		bool GetStringParameter(const NzString& name, NzString* value) const;
+		bool GetUserdataParameter(const NzString& name, void** value) const;
+
+		bool HasParameter(const NzString& name) const;
+
+		void RemoveParameter(const NzString& name);
+
+		void SetParameter(const NzString& name);
+		void SetParameter(const NzString& name, const NzString& value);
+		void SetParameter(const NzString& name, const char* value);
+		void SetParameter(const NzString& name, void* value);
+		void SetParameter(const NzString& name, void* value, Destructor destructor);
+		void SetParameter(const NzString& name, bool value);
+		void SetParameter(const NzString& name, float value);
+		void SetParameter(const NzString& name, int value);
+
+		NzParameterList& operator=(const NzParameterList& list);
+		NzParameterList& operator=(NzParameterList&& list);
+
+	private:
+		struct Parameter
+		{
+			struct UserdataValue
+			{
+				UserdataValue(Destructor Destructor, void* value) :
+				counter(1),
+				destructor(Destructor),
+				ptr(value)
+				{
+				}
+
+				std::atomic_uint counter;
+				Destructor destructor;
+				void* ptr;
+			};
+
+			nzParameterType type;
+			union Value
+			{
+				// On définit un constructeur/destructeur vide, permettant de mettre des classes dans l'union
+				Value() {}
+				Value(const Value&) {} // Placeholder
+				~Value() {}
+
+				bool boolVal;
+				float floatVal;
+				int intVal;
+				void* ptrVal;
+				NzString stringVal;
+				UserdataValue* userdataVal;
+			};
+
+			Value value;
+		};
+
+		using ParameterMap = std::unordered_map<NzString, Parameter>;
+
+		void DestroyValue(Parameter& parameter);
+
+		ParameterMap m_parameters;
+};
+
+#endif // NAZARA_PARAMETERLIST_HPP

include/Nazara/Debug.hpp

@@ -2,7 +2,4 @@
 // This file is part of the "Nazara Engine"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Core/Debug/MemoryLeakTracker.hpp>
-
-#define delete NzMemoryManager::NextFree(__FILE__, __LINE__), delete
-#define new new(__FILE__, __LINE__)
+#include <Nazara/Core/Debug/MemoryLeakTracker.hpp>

include/Nazara/Graphics.hpp

@@ -1,4 +1,4 @@
-// This file was automatically generated on 12 Jan 2014 at 20:08:11
+// This file was automatically generated on 21 Feb 2014 at 18:17:18
 
 /*
 	Nazara Engine - Graphics module
@@ -54,6 +54,7 @@
 #include <Nazara/Graphics/Graphics.hpp>
 #include <Nazara/Graphics/Light.hpp>
 #include <Nazara/Graphics/LightManager.hpp>
+#include <Nazara/Graphics/Material.hpp>
 #include <Nazara/Graphics/Model.hpp>
 #include <Nazara/Graphics/RenderTechniques.hpp>
 #include <Nazara/Graphics/Scene.hpp>

include/Nazara/Graphics/Camera.hpp

@@ -50,7 +50,7 @@ class NAZARA_API NzCamera : public NzAbstractViewer, public NzNode, NzRenderTarg
 
 	private:
 		void ApplyView() const override;
-		void Invalidate() override;
+		void InvalidateNode() override;
 
 		void OnRenderTargetReleased(const NzRenderTarget* renderTarget, void* userdata) override;
 		bool OnRenderTargetSizeChange(const NzRenderTarget* renderTarget, void* userdata) override;

include/Nazara/Graphics/ColorBackground.hpp

@@ -10,7 +10,7 @@
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/Color.hpp>
 #include <Nazara/Graphics/AbstractBackground.hpp>
-#include <Nazara/Renderer/ShaderProgram.hpp>
+#include <Nazara/Renderer/UberShader.hpp>
 
 class NAZARA_API NzColorBackground : public NzAbstractBackground
 {
@@ -26,7 +26,10 @@ class NAZARA_API NzColorBackground : public NzAbstractBackground
 
 	private:
 		NzColor m_color;
-		NzShaderProgramConstRef m_program;
+		NzUberShaderConstRef m_uberShader;
+		const NzUberShaderInstance* m_uberShaderInstance;
+		int m_materialDiffuseUniform;
+		int m_vertexDepthUniform;
 };
 
 #endif // NAZARA_COLORBACKGROUND_HPP

include/Nazara/Graphics/Config.hpp

@@ -38,4 +38,7 @@
 // Active les tests de sécurité basés sur le code (Conseillé pour le développement)
 #define NAZARA_GRAPHICS_SAFE 1
 
+// Le nombre maximum de lumières qu'un shader standard supportera
+#define NAZARA_GRAPHICS_MAX_LIGHTPERPASS 3U // Unsigned
+
 #endif // NAZARA_CONFIG_GRAPHICS_HPP

include/Nazara/Graphics/Debug.hpp

@@ -5,7 +5,4 @@
 #include <Nazara/Graphics/Config.hpp>
 #if NAZARA_GRAPHICS_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG)
 	#include <Nazara/Core/Debug/MemoryLeakTracker.hpp>
-
-	#define delete NzMemoryManager::NextFree(__FILE__, __LINE__), delete
-	#define new new(__FILE__, __LINE__)
 #endif

include/Nazara/Graphics/DeferredBloomPass.hpp

@@ -11,7 +11,7 @@
 #include <Nazara/Graphics/DeferredRenderPass.hpp>
 #include <Nazara/Renderer/RenderStates.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
-#include <Nazara/Renderer/ShaderProgram.hpp>
+#include <Nazara/Renderer/Shader.hpp>
 #include <Nazara/Renderer/Texture.hpp>
 #include <Nazara/Renderer/TextureSampler.hpp>
 
@@ -38,16 +38,16 @@ class NAZARA_API NzDeferredBloomPass : public NzDeferredRenderPass
 	protected:
 		NzRenderStates m_bloomStates;
 		NzRenderTexture m_bloomRTT;
-		NzShaderProgramRef m_bloomBrightProgram;
-		NzShaderProgramRef m_bloomFinalProgram;
-		NzShaderProgramRef m_gaussianBlurProgram;
+		NzShaderRef m_bloomBrightShader;
+		NzShaderRef m_bloomFinalShader;
+		NzShaderRef m_gaussianBlurShader;
 		NzTextureRef m_bloomTextures[2];
 		NzTextureSampler m_bilinearSampler;
 		mutable bool m_uniformUpdated;
 		float m_brightLuminance;
 		float m_brightMiddleGrey;
 		float m_brightThreshold;
-		int m_gaussianBlurProgramFilterLocation;
+		int m_gaussianBlurShaderFilterLocation;
 		unsigned int m_blurPassCount;
 };
 

include/Nazara/Graphics/DeferredDOFPass.hpp

@@ -11,7 +11,7 @@
 #include <Nazara/Graphics/DeferredRenderPass.hpp>
 #include <Nazara/Renderer/RenderStates.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
-#include <Nazara/Renderer/ShaderProgram.hpp>
+#include <Nazara/Renderer/Shader.hpp>
 #include <Nazara/Renderer/Texture.hpp>
 #include <Nazara/Renderer/TextureSampler.hpp>
 
@@ -27,12 +27,12 @@ class NAZARA_API NzDeferredDOFPass : public NzDeferredRenderPass
 	protected:
 		NzRenderTexture m_dofRTT;
 		NzRenderStates m_states;
-		NzShaderProgramRef m_blurProgram;
-		NzShaderProgramRef m_dofProgram;
+		NzShaderConstRef m_dofShader;
+		NzShaderConstRef m_gaussianBlurShader;
 		NzTextureRef m_dofTextures[2];
 		NzTextureSampler m_bilinearSampler;
 		NzTextureSampler m_pointSampler;
-		int m_blurProgramFilterLocation;
+		int m_gaussianBlurShaderFilterLocation;
 };
 
 #endif // NAZARA_DEFERREDDOFPASS_HPP

include/Nazara/Graphics/DeferredFXAAPass.hpp

@@ -10,7 +10,7 @@
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Graphics/DeferredRenderPass.hpp>
 #include <Nazara/Renderer/RenderStates.hpp>
-#include <Nazara/Renderer/ShaderProgram.hpp>
+#include <Nazara/Renderer/Shader.hpp>
 #include <Nazara/Renderer/TextureSampler.hpp>
 
 class NAZARA_API NzDeferredFXAAPass : public NzDeferredRenderPass
@@ -23,7 +23,7 @@ class NAZARA_API NzDeferredFXAAPass : public NzDeferredRenderPass
 
 	protected:
 		NzRenderStates m_states;
-		NzShaderProgramRef m_fxaaProgram;
+		NzShaderRef m_fxaaShader;
 		NzTextureSampler m_pointSampler;
 };
 

include/Nazara/Graphics/DeferredFinalPass.hpp

@@ -10,8 +10,8 @@
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Graphics/DeferredRenderPass.hpp>
 #include <Nazara/Renderer/RenderStates.hpp>
-#include <Nazara/Renderer/ShaderProgram.hpp>
 #include <Nazara/Renderer/TextureSampler.hpp>
+#include <Nazara/Renderer/UberShader.hpp>
 
 class NAZARA_API NzDeferredFinalPass : public NzDeferredRenderPass
 {
@@ -23,8 +23,11 @@ class NAZARA_API NzDeferredFinalPass : public NzDeferredRenderPass
 
 	protected:
 		NzRenderStates m_states;
-		NzShaderProgramRef m_program;
 		NzTextureSampler m_pointSampler;
+		NzUberShaderConstRef m_uberShader;
+		const NzUberShaderInstance* m_uberShaderInstance;
+		int m_materialDiffuseUniform;
+		int m_materialDiffuseMapUniform;
 };
 
 #endif // NAZARA_DEFERREDFINALPASS_HPP

include/Nazara/Graphics/DeferredFogPass.hpp

@@ -10,7 +10,7 @@
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Graphics/DeferredRenderPass.hpp>
 #include <Nazara/Renderer/RenderStates.hpp>
-#include <Nazara/Renderer/ShaderProgram.hpp>
+#include <Nazara/Renderer/Shader.hpp>
 #include <Nazara/Renderer/TextureSampler.hpp>
 
 class NAZARA_API NzDeferredFogPass : public NzDeferredRenderPass
@@ -23,7 +23,7 @@ class NAZARA_API NzDeferredFogPass : public NzDeferredRenderPass
 
 	protected:
 		NzRenderStates m_states;
-		NzShaderProgramRef m_program;
+		NzShaderRef m_shader;
 		NzTextureSampler m_pointSampler;
 };
 

include/Nazara/Graphics/DeferredGeometryPass.hpp

@@ -10,7 +10,7 @@
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Graphics/DeferredRenderPass.hpp>
 #include <Nazara/Renderer/RenderStates.hpp>
-#include <Nazara/Renderer/ShaderProgram.hpp>
+#include <Nazara/Renderer/Shader.hpp>
 
 class NAZARA_API NzDeferredGeometryPass : public NzDeferredRenderPass
 {
@@ -23,7 +23,7 @@ class NAZARA_API NzDeferredGeometryPass : public NzDeferredRenderPass
 
 	protected:
 		NzRenderStates m_clearStates;
-		NzShaderProgramRef m_clearProgram;
+		NzShaderRef m_clearShader;
 };
 
 #endif // NAZARA_DEFERREDGEOMETRYPASS_HPP

include/Nazara/Graphics/DeferredPhongLightingPass.hpp

@@ -9,7 +9,8 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Graphics/DeferredRenderPass.hpp>
-#include <Nazara/Renderer/ShaderProgram.hpp>
+#include <Nazara/Graphics/Light.hpp>
+#include <Nazara/Renderer/Shader.hpp>
 #include <Nazara/Renderer/TextureSampler.hpp>
 #include <Nazara/Utility/Mesh.hpp>
 
@@ -28,16 +29,17 @@ class NAZARA_API NzDeferredPhongLightingPass : public NzDeferredRenderPass
 		bool Process(const NzScene* scene, unsigned int firstWorkTexture, unsigned secondWorkTexture) const;
 
 	protected:
+		NzLightUniforms m_directionalLightUniforms;
+		NzLightUniforms m_pointSpotLightUniforms;
 		NzMeshRef m_cone;
 		NzMeshRef m_sphere;
-		NzShaderProgramRef m_directionalLightProgram;
-		NzShaderProgramRef m_pointSpotLightProgram;
+		NzShaderRef m_directionalLightShader;
+		NzShaderRef m_pointSpotLightShader;
 		NzTextureSampler m_pointSampler;
 		NzStaticMesh* m_coneMesh;
 		NzStaticMesh* m_sphereMesh;
 		bool m_lightMeshesDrawing;
-		int m_pointSpotLightProgramDiscardLocation;
-		int m_pointSpotLightProgramSpotLightLocation;
+		int m_pointSpotLightShaderDiscardLocation;
 };
 
 #endif // NAZARA_DEFERREDPHONGLIGHTINGPASS_HPP

include/Nazara/Graphics/DeferredRenderTechnique.hpp

@@ -16,7 +16,6 @@
 #include <Nazara/Renderer/RenderBuffer.hpp>
 #include <Nazara/Renderer/RenderStates.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
-#include <Nazara/Renderer/ShaderProgram.hpp>
 #include <Nazara/Renderer/Texture.hpp>
 #include <Nazara/Renderer/TextureSampler.hpp>
 #include <Nazara/Utility/Mesh.hpp>
@@ -50,7 +49,9 @@ class NAZARA_API NzDeferredRenderTechnique : public NzAbstractRenderTechnique, p
 
 		void SetPass(nzRenderPassType relativeTo, int position, NzDeferredRenderPass* pass);
 
+		static bool Initialize();
 		static bool IsSupported();
+		static void Uninitialize();
 
 	private:
 		bool Resize(const NzVector2ui& dimensions) const;

include/Nazara/Graphics/Enums.hpp

@@ -26,6 +26,23 @@ enum nzLightType
 	nzLightType_Max = nzLightType_Spot
 };
 
+enum nzMaterialUniform
+{
+	nzMaterialUniform_AlphaMap,
+	nzMaterialUniform_AlphaThreshold,
+	nzMaterialUniform_Ambient,
+	nzMaterialUniform_Diffuse,
+	nzMaterialUniform_DiffuseMap,
+	nzMaterialUniform_EmissiveMap,
+	nzMaterialUniform_HeightMap,
+	nzMaterialUniform_NormalMap,
+	nzMaterialUniform_Shininess,
+	nzMaterialUniform_Specular,
+	nzMaterialUniform_SpecularMap,
+
+	nzMaterialUniform_Max = nzMaterialUniform_SpecularMap
+};
+
 enum nzRenderPassType
 {
 	nzRenderPassType_AA,
@@ -63,4 +80,15 @@ enum nzSceneNodeType
 	nzSceneNodeType_Max = nzSceneNodeType_User
 };
 
+// Ces paramètres sont indépendants du matériau: ils peuvent être demandés à tout moment
+enum nzShaderFlags
+{
+	nzShaderFlags_None = 0,
+
+	nzShaderFlags_Deferred   = 0x1,
+	nzShaderFlags_Instancing = 0x2,
+
+	nzShaderFlags_Max = nzShaderFlags_Instancing*2-1
+};
+
 #endif // NAZARA_ENUMS_GRAPHICS_HPP

include/Nazara/Graphics/ForwardRenderTechnique.hpp

@@ -8,13 +8,15 @@
 #define NAZARA_FORWARDRENDERTECHNIQUE_HPP
 
 #include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/ResourceListener.hpp>
 #include <Nazara/Graphics/AbstractRenderTechnique.hpp>
 #include <Nazara/Graphics/ForwardRenderQueue.hpp>
+#include <Nazara/Graphics/Light.hpp>
 #include <Nazara/Graphics/LightManager.hpp>
 #include <Nazara/Utility/IndexBuffer.hpp>
 #include <Nazara/Utility/VertexBuffer.hpp>
 
-class NAZARA_API NzForwardRenderTechnique : public NzAbstractRenderTechnique
+class NAZARA_API NzForwardRenderTechnique : public NzAbstractRenderTechnique, NzResourceListener
 {
 	public:
 		NzForwardRenderTechnique();
@@ -30,10 +32,23 @@ class NAZARA_API NzForwardRenderTechnique : public NzAbstractRenderTechnique
 		void SetMaxLightPassPerObject(unsigned int passCount);
 
 	private:
+		struct LightUniforms;
+
 		void DrawOpaqueModels(const NzScene* scene) const;
 		void DrawSprites(const NzScene* scene) const;
 		void DrawTransparentModels(const NzScene* scene) const;
+		const LightUniforms* GetLightUniforms(const NzShader* shader) const;
 
+		struct LightUniforms
+		{
+			NzLightUniforms uniforms;
+			bool exists;
+			int offset; // "Distance" entre Lights[0].type et Lights[1].type
+			/// Moins coûteux en mémoire que de stocker un NzLightUniforms par index de lumière,
+			/// à voir si ça fonctionne chez tout le monde
+		};
+
+		mutable std::unordered_map<const NzShader*, LightUniforms> m_lightUniforms;
 		mutable NzForwardRenderQueue m_renderQueue;
 		NzIndexBufferRef m_indexBuffer;
 		mutable NzLightManager m_directionalLights;

include/Nazara/Graphics/Light.hpp

@@ -12,7 +12,8 @@
 #include <Nazara/Graphics/Enums.hpp>
 #include <Nazara/Graphics/SceneNode.hpp>
 
-class NzShaderProgram;
+class NzShader;
+struct NzLightUniforms;
 
 class NAZARA_API NzLight : public NzSceneNode
 {
@@ -23,7 +24,7 @@ class NAZARA_API NzLight : public NzSceneNode
 
 		void AddToRenderQueue(NzAbstractRenderQueue* renderQueue) const override;
 
-		void Enable(const NzShaderProgram* program, unsigned int lightUnit) const;
+		void Enable(const NzShader* shader, const NzLightUniforms& uniforms, int offset = 0) const;
 
 		float GetAmbientFactor() const;
 		float GetAttenuation() const;
@@ -49,11 +50,11 @@ class NAZARA_API NzLight : public NzSceneNode
 
 		NzLight& operator=(const NzLight& light);
 
-		static void Disable(const NzShaderProgram* program, unsigned int lightUnit);
+		static void Disable(const NzShader* program, const NzLightUniforms& uniforms, int offset = 0);
 
 	private:
 		bool FrustumCull(const NzFrustumf& frustum) override;
-		void Invalidate() override;
+		void InvalidateNode() override;
 		void Register() override;
 		void Unregister() override;
 		void UpdateBoundingVolume() const;
@@ -70,4 +71,25 @@ class NAZARA_API NzLight : public NzSceneNode
 		float m_radius;
 };
 
+struct NzLightUniforms
+{
+	struct UniformLocations
+	{
+		int type;
+		int color;
+		int factors;
+		int parameters1;
+		int parameters2;
+		int parameters3;
+	};
+
+	bool ubo;
+
+	union
+	{
+		UniformLocations locations;
+		int blockLocation;
+	};
+};
+
 #endif // NAZARA_LIGHT_HPP

include/Nazara/Graphics/Material.hpp

@@ -1,5 +1,5 @@
 // Copyright (C) 2014 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Renderer module"
+// This file is part of the "Nazara Engine - Graphics module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #pragma once
@@ -13,11 +13,11 @@
 #include <Nazara/Core/ResourceLoader.hpp>
 #include <Nazara/Core/ResourceRef.hpp>
 #include <Nazara/Core/String.hpp>
-#include <Nazara/Renderer/Enums.hpp>
+#include <Nazara/Graphics/Enums.hpp>
 #include <Nazara/Renderer/RenderStates.hpp>
-#include <Nazara/Renderer/ShaderProgram.hpp>
 #include <Nazara/Renderer/Texture.hpp>
 #include <Nazara/Renderer/TextureSampler.hpp>
+#include <Nazara/Renderer/UberShader.hpp>
 
 struct NAZARA_API NzMaterialParams
 {
@@ -27,6 +27,7 @@ struct NAZARA_API NzMaterialParams
 	bool loadHeightMap = true;
 	bool loadNormalMap = true;
 	bool loadSpecularMap = true;
+	NzString shaderName = "Basic";
 
 	bool IsValid() const;
 };
@@ -48,11 +49,12 @@ class NAZARA_API NzMaterial : public NzResource
 		NzMaterial(NzMaterial&& material);
 		~NzMaterial();
 
-		void Apply(const NzShaderProgram* program) const;
+		const NzShader* Apply(nzUInt32 shaderFlags = 0, nzUInt8 textureUnit = 0, nzUInt8* lastUsedUnit = nullptr) const;
 
 		void Enable(nzRendererParameter renderParameter, bool enable);
 		void EnableAlphaTest(bool alphaTest);
 		void EnableLighting(bool lighting);
+		void EnableTransform(bool transform);
 
 		NzTexture* GetAlphaMap() const;
 		float GetAlphaThreshold() const;
@@ -69,7 +71,8 @@ class NAZARA_API NzMaterial : public NzResource
 		NzTexture* GetHeightMap() const;
 		NzTexture* GetNormalMap() const;
 		const NzRenderStates& GetRenderStates() const;
-		const NzShaderProgram* GetShaderProgram(nzShaderTarget target, nzUInt32 flags) const;
+		const NzUberShader* GetShader() const;
+		const NzUberShaderInstance* GetShaderInstance(nzUInt32 flags = nzShaderFlags_None) const;
 		float GetShininess() const;
 		NzColor GetSpecularColor() const;
 		NzTexture* GetSpecularMap() const;
@@ -78,7 +81,6 @@ class NAZARA_API NzMaterial : public NzResource
 		nzBlendFunc GetSrcBlend() const;
 
 		bool HasAlphaMap() const;
-		bool HasCustomShaderProgram(nzShaderTarget target, nzUInt32 flags) const;
 		bool HasDiffuseMap() const;
 		bool HasEmissiveMap() const;
 		bool HasHeightMap() const;
@@ -88,6 +90,7 @@ class NAZARA_API NzMaterial : public NzResource
 		bool IsAlphaTestEnabled() const;
 		bool IsEnabled(nzRendererParameter renderParameter) const;
 		bool IsLightingEnabled() const;
+		bool IsTransformEnabled() const;
 
 		bool LoadFromFile(const NzString& filePath, const NzMaterialParams& params = NzMaterialParams());
 		bool LoadFromMemory(const void* data, std::size_t size, const NzMaterialParams& params = NzMaterialParams());
@@ -114,7 +117,8 @@ class NAZARA_API NzMaterial : public NzResource
 		bool SetNormalMap(const NzString& texturePath);
 		void SetNormalMap(NzTexture* map);
 		void SetRenderStates(const NzRenderStates& states);
-		void SetShaderProgram(nzShaderTarget target, nzUInt32 flags, const NzShaderProgram* program);
+		void SetShader(const NzUberShader* uberShader);
+		bool SetShader(const NzString& uberShaderName);
 		void SetShininess(float shininess);
 		void SetSpecularColor(const NzColor& specular);
 		bool SetSpecularMap(const NzString& texturePath);
@@ -125,27 +129,26 @@ class NAZARA_API NzMaterial : public NzResource
 		NzMaterial& operator=(const NzMaterial& material);
 		NzMaterial& operator=(NzMaterial&& material);
 
+		static bool Initialize();
 		static NzMaterial* GetDefault();
+		static void Uninitialize();
 
 	private:
-		struct ProgramUnit
+		struct ShaderInstance
 		{
-			NzShaderProgramConstRef program;
-			bool custom = false;
+			const NzShader* shader;
+			NzUberShaderInstance* uberInstance;
+			int uniforms[nzMaterialUniform_Max+1];
 		};
 
 		void Copy(const NzMaterial& material);
-		void GenerateProgram(nzShaderTarget target, nzUInt32 flags) const;
-		void InvalidatePrograms(nzShaderTarget target);
-
-		static bool Initialize();
-		static void Uninitialize();
+		void GenerateShader(nzUInt32 flags) const;
+		void InvalidateShaders();
 
 		NzColor m_ambientColor;
 		NzColor m_diffuseColor;
 		NzColor m_specularColor;
 		NzRenderStates m_states;
-		mutable ProgramUnit m_programs[nzShaderTarget_Max+1][nzShaderFlags_Max+1];
 		NzTextureSampler m_diffuseSampler;
 		NzTextureSampler m_specularSampler;
 		NzTextureRef m_alphaMap;
@@ -154,8 +157,11 @@ class NAZARA_API NzMaterial : public NzResource
 		NzTextureRef m_heightMap;
 		NzTextureRef m_normalMap;
 		NzTextureRef m_specularMap;
+		NzUberShaderConstRef m_uberShader;
+		mutable ShaderInstance m_shaders[nzShaderFlags_Max+1];
 		bool m_alphaTestEnabled;
 		bool m_lightingEnabled;
+		bool m_transformEnabled;
 		float m_alphaThreshold;
 		float m_shininess;
 

include/Nazara/Graphics/Model.hpp

@@ -10,8 +10,8 @@
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Core/ResourceLoader.hpp>
 #include <Nazara/Core/Updatable.hpp>
+#include <Nazara/Graphics/Material.hpp>
 #include <Nazara/Graphics/SceneNode.hpp>
-#include <Nazara/Renderer/Material.hpp>
 #include <Nazara/Utility/Animation.hpp>
 #include <Nazara/Utility/Mesh.hpp>
 
@@ -22,6 +22,7 @@ struct NAZARA_API NzModelParameters
 	NzAnimationParams animation;
 	NzMaterialParams material;
 	NzMeshParams mesh;
+	NzString shaderName = "PhongLighting";
 
 	bool IsValid() const;
 };
@@ -89,7 +90,7 @@ class NAZARA_API NzModel : public NzSceneNode, public NzUpdatable
 
 	private:
 		bool FrustumCull(const NzFrustumf& frustum) override;
-		void Invalidate() override;
+		void InvalidateNode() override;
 		void Register() override;
 		void Unregister() override;
 		void Update() override;

include/Nazara/Graphics/SkyboxBackground.hpp

@@ -9,7 +9,7 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Graphics/AbstractBackground.hpp>
-#include <Nazara/Renderer/ShaderProgram.hpp>
+#include <Nazara/Renderer/Shader.hpp>
 #include <Nazara/Renderer/Texture.hpp>
 #include <Nazara/Renderer/TextureSampler.hpp>
 #include <Nazara/Utility/IndexBuffer.hpp>
@@ -35,7 +35,7 @@ class NAZARA_API NzSkyboxBackground : public NzAbstractBackground
 		NzTextureRef m_texture;
 		NzTextureSampler m_sampler;
 		NzIndexBufferRef m_indexBuffer;
-		NzShaderProgramRef m_program;
+		NzShaderRef m_shader;
 		NzVertexBufferRef m_vertexBuffer;
 };
 

include/Nazara/Graphics/Sprite.hpp

@@ -8,8 +8,8 @@
 #define NAZARA_SPRITE_HPP
 
 #include <Nazara/Prerequesites.hpp>
+#include <Nazara/Graphics/Material.hpp>
 #include <Nazara/Graphics/SceneNode.hpp>
-#include <Nazara/Renderer/Material.hpp>
 
 class NAZARA_API NzSprite : public NzSceneNode
 {
@@ -38,7 +38,7 @@ class NAZARA_API NzSprite : public NzSceneNode
 
 	private:
 		bool FrustumCull(const NzFrustumf& frustum) override;
-		void Invalidate() override;
+		void InvalidateNode() override;
 		void Register() override;
 		void Unregister() override;
 		void UpdateBoundingVolume() const;

include/Nazara/Graphics/TextureBackground.hpp

@@ -9,7 +9,7 @@
 
 #include <Nazara/Prerequesites.hpp>
 #include <Nazara/Graphics/AbstractBackground.hpp>
-#include <Nazara/Renderer/ShaderProgram.hpp>
+#include <Nazara/Renderer/UberShader.hpp>
 #include <Nazara/Renderer/Texture.hpp>
 
 class NAZARA_API NzTextureBackground : public NzAbstractBackground
@@ -26,8 +26,12 @@ class NAZARA_API NzTextureBackground : public NzAbstractBackground
 		void SetTexture(NzTexture* texture);
 
 	private:
-		NzShaderProgramConstRef m_program;
 		NzTextureRef m_texture;
+		NzUberShaderConstRef m_uberShader;
+		const NzUberShaderInstance* m_uberShaderInstance;
+		int m_materialDiffuseUniform;
+		int m_materialDiffuseMapUniform;
+		int m_vertexDepthUniform;
 };
 
 #endif // NAZARA_TEXTUREBACKGROUND_HPP

include/Nazara/Graphics/View.hpp

@@ -48,7 +48,7 @@ class NAZARA_API NzView : public NzAbstractViewer, public NzNode, NzRenderTarget
 
 	private:
 		void ApplyView() const override;
-		void Invalidate() override;
+		void InvalidateNode() override;
 
 		void OnRenderTargetReleased(const NzRenderTarget* renderTarget, void* userdata) override;
 		bool OnRenderTargetSizeChange(const NzRenderTarget* renderTarget, void* userdata) override;

include/Nazara/Lua.hpp

@@ -1,4 +1,4 @@
-// This file was automatically generated on 12 Jan 2014 at 20:08:11
+// This file was automatically generated on 21 Feb 2014 at 18:17:18
 
 /*
 	Nazara Engine - Lua scripting module

include/Nazara/Lua/Debug.hpp

@@ -5,7 +5,4 @@
 #include <Nazara/Lua/Config.hpp>
 #if NAZARA_LUA_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG)
 	#include <Nazara/Core/Debug/MemoryLeakTracker.hpp>
-
-	#define delete NzMemoryManager::NextFree(__FILE__, __LINE__), delete
-	#define new new(__FILE__, __LINE__)
 #endif

include/Nazara/Math.hpp

@@ -1,4 +1,4 @@
-// This file was automatically generated on 12 Jan 2014 at 20:08:11
+// This file was automatically generated on 21 Feb 2014 at 18:17:18
 
 /*
 	Nazara Engine - Mathematics module

include/Nazara/Math/Basic.inl

@@ -313,8 +313,6 @@ inline long long NzStringToNumber(NzString str, nzUInt8 radix, bool* ok)
 			total += c-symbols;
 		else
 		{
-			NazaraError("str is not a valid number");
-
 			if (ok)
 				*ok = false;
 

include/Nazara/Noise.hpp

@@ -1,4 +1,4 @@
-// This file was automatically generated on 12 Jan 2014 at 20:08:11
+// This file was automatically generated on 21 Feb 2014 at 18:17:18
 
 /*
 	Nazara Engine - Noise module

include/Nazara/Noise/Debug.hpp

@@ -5,7 +5,4 @@
 #include <Nazara/Noise/Config.hpp>
 #if NAZARA_NOISE_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG)
 	#include <Nazara/Core/Debug/MemoryLeakTracker.hpp>
-
-	#define delete NzMemoryManager::NextFree(__FILE__, __LINE__), delete
-	#define new new(__FILE__, __LINE__)
 #endif

include/Nazara/Physics.hpp

@@ -1,4 +1,4 @@
-// This file was automatically generated on 12 Jan 2014 at 20:08:11
+// This file was automatically generated on 21 Feb 2014 at 18:17:18
 
 /*
 	Nazara Engine - Physics module

include/Nazara/Physics/Debug.hpp

@@ -5,7 +5,4 @@
 #include <Nazara/Physics/Config.hpp>
 #if NAZARA_PHYSICS_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG)
 	#include <Nazara/Core/Debug/MemoryLeakTracker.hpp>
-
-	#define delete NzMemoryManager::NextFree(__FILE__, __LINE__), delete
-	#define new new(__FILE__, __LINE__)
 #endif

include/Nazara/Renderer.hpp

@@ -1,4 +1,4 @@
-// This file was automatically generated on 12 Jan 2014 at 20:08:11
+// This file was automatically generated on 21 Feb 2014 at 18:17:18
 
 /*
 	Nazara Engine - Renderer module
@@ -35,7 +35,6 @@
 #include <Nazara/Renderer/DebugDrawer.hpp>
 #include <Nazara/Renderer/Enums.hpp>
 #include <Nazara/Renderer/GpuQuery.hpp>
-#include <Nazara/Renderer/Material.hpp>
 #include <Nazara/Renderer/OpenGL.hpp>
 #include <Nazara/Renderer/RenderBuffer.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
@@ -44,10 +43,17 @@
 #include <Nazara/Renderer/RenderTargetParameters.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
 #include <Nazara/Renderer/RenderWindow.hpp>
-#include <Nazara/Renderer/ShaderProgram.hpp>
-#include <Nazara/Renderer/ShaderProgramManager.hpp>
-#include <Nazara/Renderer/ShaderProgramManagerParams.hpp>
+#include <Nazara/Renderer/Shader.hpp>
+#include <Nazara/Renderer/ShaderLibrary.hpp>
+#include <Nazara/Renderer/ShaderStage.hpp>
 #include <Nazara/Renderer/Texture.hpp>
 #include <Nazara/Renderer/TextureSampler.hpp>
+#include <Nazara/Renderer/UberShader.hpp>
+#include <Nazara/Renderer/UberShaderInstance.hpp>
+#include <Nazara/Renderer/UberShaderInstancePreprocessor.hpp>
+#include <Nazara/Renderer/UberShaderLibrary.hpp>
+#include <Nazara/Renderer/UberShaderPreprocessor.hpp>
+#include <Nazara/Renderer/UberShaderPUniform.hpp>
+#include <Nazara/Renderer/UberShaderPUSubroutine.hpp>
 
 #endif // NAZARA_GLOBAL_RENDERER_HPP

include/Nazara/Renderer/Config.hpp

@@ -41,7 +41,4 @@
 // Active les tests de sécurité basés sur le code (Conseillé pour le développement)
 #define NAZARA_RENDERER_SAFE 1
 
-// Le nombre maximum de lumières qu'un forward shader supportera
-#define NAZARA_RENDERER_SHADER_MAX_LIGHTCOUNT 8
-
 #endif // NAZARA_CONFIG_MODULENAME_HPP

include/Nazara/Renderer/Debug.hpp

@@ -5,7 +5,4 @@
 #include <Nazara/Renderer/Config.hpp>
 #if NAZARA_RENDERER_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG)
 	#include <Nazara/Core/Debug/MemoryLeakTracker.hpp>
-
-	#define delete NzMemoryManager::NextFree(__FILE__, __LINE__), delete
-	#define new new(__FILE__, __LINE__)
 #endif

include/Nazara/Renderer/Enums.hpp

@@ -185,27 +185,6 @@ enum nzSamplerWrap
 	nzSamplerWrap_Max = nzSamplerWrap_Repeat
 };
 
-enum nzShaderFlags
-{
-	nzShaderFlags_None = 0,
-
-	nzShaderFlags_Deferred   = 0x1,
-	nzShaderFlags_FlipUVs    = 0x2,
-	nzShaderFlags_Instancing = 0x4,
-
-	nzShaderFlags_Max = nzShaderFlags_Instancing*2-1
-};
-
-enum nzShaderLanguage
-{
-	nzShaderLanguage_Unknown = -1,
-
-	nzShaderLanguage_Cg,
-	nzShaderLanguage_GLSL,
-
-	nzShaderLanguage_Max = nzShaderLanguage_GLSL
-};
-
 enum nzShaderTarget
 {
 	nzShaderTarget_FullscreenQuad,
@@ -226,21 +205,9 @@ enum nzShaderUniform
 	nzShaderUniform_InvWorldMatrix,
 	nzShaderUniform_InvWorldViewMatrix,
 	nzShaderUniform_InvWorldViewProjMatrix,
-	nzShaderUniform_MaterialAlphaMap,
-	nzShaderUniform_MaterialAlphaThreshold,
-	nzShaderUniform_MaterialAmbient,
-	nzShaderUniform_MaterialDiffuse,
-	nzShaderUniform_MaterialDiffuseMap,
-	nzShaderUniform_MaterialEmissiveMap,
-	nzShaderUniform_MaterialHeightMap,
-	nzShaderUniform_MaterialNormalMap,
-	nzShaderUniform_MaterialShininess,
-	nzShaderUniform_MaterialSpecular,
-	nzShaderUniform_MaterialSpecularMap,
 	nzShaderUniform_ProjMatrix,
 	nzShaderUniform_SceneAmbient,
 	nzShaderUniform_TargetSize,
-	nzShaderUniform_VertexDepth,
 	nzShaderUniform_ViewMatrix,
 	nzShaderUniform_ViewProjMatrix,
 	nzShaderUniform_WorldMatrix,
@@ -250,13 +217,13 @@ enum nzShaderUniform
 	nzShaderUniform_Max = nzShaderUniform_WorldViewProjMatrix
 };
 
-enum nzShaderType
+enum nzShaderStage
 {
-	nzShaderType_Fragment,
-	nzShaderType_Geometry,
-	nzShaderType_Vertex,
+	nzShaderStage_Fragment,
+	nzShaderStage_Geometry,
+	nzShaderStage_Vertex,
 
-	nzShaderType_Max = nzShaderType_Vertex
+	nzShaderStage_Max = nzShaderStage_Vertex
 };
 
 enum nzStencilOperation

include/Nazara/Renderer/OpenGL.hpp

@@ -140,15 +140,15 @@ class NAZARA_API NzOpenGL
 		static GLenum RendererComparison[nzRendererComparison_Max+1];
 		static GLenum RendererParameter[nzRendererParameter_Max+1];
 		static GLenum SamplerWrapMode[nzSamplerWrap_Max+1];
-		static GLenum ShaderType[nzShaderType_Max+1];
+		static GLenum ShaderStage[nzShaderStage_Max+1];
 		static GLenum StencilOperation[nzStencilOperation_Max+1];
 		static GLenum TextureTarget[nzImageType_Max+1];
 		static GLenum TextureTargetBinding[nzImageType_Max+1];
 		static GLenum TextureTargetProxy[nzImageType_Max+1];
 
 	private:
-		static void OnContextDestruction(const NzContext* context);
 		static void OnContextChange(const NzContext* newContext);
+		static void OnContextDestruction(const NzContext* context);
 };
 
 NAZARA_API extern PFNGLACTIVETEXTUREPROC            glActiveTexture;
@@ -221,6 +221,7 @@ NAZARA_API extern PFNGLGENRENDERBUFFERSPROC         glGenRenderbuffers;
 NAZARA_API extern PFNGLGENSAMPLERSPROC              glGenSamplers;
 NAZARA_API extern PFNGLGENTEXTURESPROC              glGenTextures;
 NAZARA_API extern PFNGLGENVERTEXARRAYSPROC          glGenVertexArrays;
+NAZARA_API extern PFNGLGETACTIVEUNIFORMPROC         glGetActiveUniform;
 NAZARA_API extern PFNGLGETBOOLEANVPROC              glGetBooleanv;
 NAZARA_API extern PFNGLGETBUFFERPARAMETERIVPROC     glGetBufferParameteriv;
 NAZARA_API extern PFNGLGETDEBUGMESSAGELOGPROC       glGetDebugMessageLog;

include/Nazara/Renderer/Renderer.hpp

@@ -21,15 +21,13 @@
 class NzColor;
 class NzContext;
 class NzIndexBuffer;
-class NzMaterial;
 class NzRenderTarget;
-class NzShaderProgram;
+class NzShader;
 class NzTexture;
 class NzVertexBuffer;
 
 class NAZARA_API NzRenderer
 {
-	friend NzShaderProgram;
 	friend NzTexture;
 
 	public:
@@ -64,7 +62,7 @@ class NAZARA_API NzRenderer
 		static float GetPointSize();
 		static const NzRenderStates& GetRenderStates();
 		static NzRecti GetScissorRect();
-		static const NzShaderProgram* GetShaderProgram();
+		static const NzShader* GetShader();
 		static const NzRenderTarget* GetTarget();
 		static NzRecti GetViewport();
 
@@ -89,7 +87,7 @@ class NAZARA_API NzRenderer
 		static void SetPointSize(float size);
 		static void SetRenderStates(const NzRenderStates& states);
 		static void SetScissorRect(const NzRecti& rect);
-		static void SetShaderProgram(const NzShaderProgram* shader);
+		static void SetShader(const NzShader* shader);
 		static void SetStencilCompareFunction(nzRendererComparison compareFunc, nzFaceSide faceSide = nzFaceSide_FrontAndBack);
 		static void SetStencilFailOperation(nzStencilOperation failOperation, nzFaceSide faceSide = nzFaceSide_FrontAndBack);
 		static void SetStencilMask(nzUInt32 mask, nzFaceSide faceSide = nzFaceSide_FrontAndBack);
@@ -107,7 +105,7 @@ class NAZARA_API NzRenderer
 	private:
 		static void EnableInstancing(bool instancing);
 		static bool EnsureStateUpdate();
-		static void OnProgramReleased(const NzShaderProgram* program);
+		static void OnShaderReleased(const NzShader* shader);
 		static void OnTextureReleased(const NzTexture* texture);
 		static void UpdateMatrix(nzMatrixType type);
 

include/Nazara/Renderer/Shader.hpp

@@ -0,0 +1,110 @@
+// Copyright (C) 2014 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Renderer module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_SHADER_HPP
+#define NAZARA_SHADER_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/ByteArray.hpp>
+#include <Nazara/Core/Color.hpp>
+#include <Nazara/Core/NonCopyable.hpp>
+#include <Nazara/Core/Resource.hpp>
+#include <Nazara/Core/ResourceRef.hpp>
+#include <Nazara/Core/String.hpp>
+#include <Nazara/Math/Matrix4.hpp>
+#include <Nazara/Math/Vector2.hpp>
+#include <Nazara/Math/Vector3.hpp>
+#include <Nazara/Math/Vector4.hpp>
+#include <Nazara/Renderer/Enums.hpp>
+
+class NzShader;
+class NzShaderStage;
+
+using NzShaderConstRef = NzResourceRef<const NzShader>;
+using NzShaderRef = NzResourceRef<NzShader>;
+
+class NAZARA_API NzShader : public NzResource, NzNonCopyable
+{
+	friend class NzRenderer;
+
+	public:
+		NzShader();
+		NzShader(NzShader&& shader);
+		~NzShader();
+
+		void AttachStage(nzShaderStage stage, const NzShaderStage& shaderStage);
+		bool AttachStageFromFile(nzShaderStage stage, const NzString& filePath);
+		bool AttachStageFromSource(nzShaderStage stage, const char* source, unsigned int length);
+		bool AttachStageFromSource(nzShaderStage stage, const NzString& source);
+
+		void Bind() const;
+
+		bool Create();
+		void Destroy();
+
+		NzByteArray GetBinary() const;
+		NzString GetLog() const;
+		NzString GetSourceCode(nzShaderStage stage) const;
+		int GetUniformLocation(const NzString& name) const;
+		int GetUniformLocation(nzShaderUniform shaderUniform) const;
+
+		bool HasStage(nzShaderStage stage) const;
+
+		bool IsBinaryRetrievable() const;
+		bool IsLinked() const;
+		bool IsValid() const;
+
+		bool Link();
+
+		bool LoadFromBinary(const void* buffer, unsigned int size);
+		bool LoadFromBinary(const NzByteArray& byteArray);
+
+		void SendBoolean(int location, bool value) const;
+		void SendColor(int location, const NzColor& color) const;
+		void SendDouble(int location, double value) const;
+		void SendDoubleArray(int location, const double* values, unsigned int count) const;
+		void SendFloat(int location, float value) const;
+		void SendFloatArray(int location, const float* values, unsigned int count) const;
+		void SendInteger(int location, int value) const;
+		void SendIntegerArray(int location, const int* values, unsigned int count) const;
+		void SendMatrix(int location, const NzMatrix4d& matrix) const;
+		void SendMatrix(int location, const NzMatrix4f& matrix) const;
+		void SendVector(int location, const NzVector2d& vector) const;
+		void SendVector(int location, const NzVector2f& vector) const;
+		void SendVector(int location, const NzVector2i& vector) const;
+		void SendVector(int location, const NzVector3d& vector) const;
+		void SendVector(int location, const NzVector3f& vector) const;
+		void SendVector(int location, const NzVector3i& vector) const;
+		void SendVector(int location, const NzVector4d& vector) const;
+		void SendVector(int location, const NzVector4f& vector) const;
+		void SendVector(int location, const NzVector4i& vector) const;
+		void SendVectorArray(int location, const NzVector2d* vectors, unsigned int count) const;
+		void SendVectorArray(int location, const NzVector2f* vectors, unsigned int count) const;
+		void SendVectorArray(int location, const NzVector2i* vectors, unsigned int count) const;
+		void SendVectorArray(int location, const NzVector3d* vectors, unsigned int count) const;
+		void SendVectorArray(int location, const NzVector3f* vectors, unsigned int count) const;
+		void SendVectorArray(int location, const NzVector3i* vectors, unsigned int count) const;
+		void SendVectorArray(int location, const NzVector4d* vectors, unsigned int count) const;
+		void SendVectorArray(int location, const NzVector4f* vectors, unsigned int count) const;
+		void SendVectorArray(int location, const NzVector4i* vectors, unsigned int count) const;
+
+		// Fonctions OpenGL
+		unsigned int GetOpenGLID() const;
+
+		NzShader& operator=(NzShader&& shader);
+
+		static bool IsStageSupported(nzShaderStage stage);
+
+	private:
+		bool PostLinkage();
+
+		std::vector<unsigned int> m_attachedShaders[nzShaderStage_Max+1];
+		bool m_linked;
+		int m_uniformLocations[nzShaderUniform_Max+1];
+		unsigned int m_program;
+};
+
+#endif // NAZARA_SHADER_HPP

include/Nazara/Renderer/ShaderLibrary.hpp

@@ -0,0 +1,33 @@
+// Copyright (C) 2014 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Renderer module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_SHADERLIBRARY_HPP
+#define NAZARA_SHADERLIBRARY_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/String.hpp>
+#include <Nazara/Renderer/Shader.hpp>
+#include <unordered_map>
+
+class NAZARA_API NzShaderLibrary
+{
+	public:
+		NzShaderLibrary() = delete;
+		~NzShaderLibrary() = delete;
+
+		static NzShader* Get(const NzString& name);
+		static bool Has(const NzString& name);
+
+		static bool Initialize();
+		static void Register(const NzString& name, NzShader* shader);
+		static void Uninitialize();
+		static void Unregister(const NzString& name);
+
+	private:
+		static std::unordered_map<NzString, NzShaderRef> s_library;
+};
+
+#endif // NAZARA_SHADERLIBRARY_HPP

include/Nazara/Renderer/ShaderProgram.hpp

@@ -1,109 +0,0 @@
-// Copyright (C) 2014 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Renderer module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#pragma once
-
-#ifndef NAZARA_SHADERPROGRAM_HPP
-#define NAZARA_SHADERPROGRAM_HPP
-
-#include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/ByteArray.hpp>
-#include <Nazara/Core/Color.hpp>
-#include <Nazara/Core/NonCopyable.hpp>
-#include <Nazara/Core/Resource.hpp>
-#include <Nazara/Core/ResourceRef.hpp>
-#include <Nazara/Core/String.hpp>
-#include <Nazara/Math/Matrix4.hpp>
-#include <Nazara/Math/Vector2.hpp>
-#include <Nazara/Math/Vector3.hpp>
-#include <Nazara/Math/Vector4.hpp>
-#include <Nazara/Renderer/Enums.hpp>
-
-class NzShaderProgram;
-
-using NzShaderProgramConstRef = NzResourceRef<const NzShaderProgram>;
-using NzShaderProgramRef = NzResourceRef<NzShaderProgram>;
-
-class NzAbstractShaderProgram;
-class NzTexture;
-
-class NAZARA_API NzShaderProgram : public NzResource, NzNonCopyable
-{
-	friend class NzRenderer;
-
-	public:
-		NzShaderProgram();
-		NzShaderProgram(nzShaderLanguage language);
-		NzShaderProgram(NzShaderProgram&& shader);
-		~NzShaderProgram();
-
-		bool Create(nzShaderLanguage language);
-		bool Compile();
-
-		void Destroy();
-
-		NzByteArray GetBinary() const;
-		nzUInt32 GetFlags() const;
-		NzString GetLog() const;
-		nzShaderLanguage GetLanguage() const;
-		NzString GetSourceCode(nzShaderType type) const;
-		int GetUniformLocation(const NzString& name) const;
-		int GetUniformLocation(nzShaderUniform uniform) const;
-
-		bool HasUniform(const NzString& name) const;
-
-		bool IsBinaryRetrievable() const;
-		bool IsCompiled() const;
-		bool IsLoaded(nzShaderType type) const;
-		bool IsValid() const;
-
-		bool LoadFromBinary(const void* buffer, unsigned int size);
-		bool LoadFromBinary(const NzByteArray& byteArray);
-		bool LoadShader(nzShaderType type, const NzString& source);
-		bool LoadShaderFromFile(nzShaderType type, const NzString& filePath);
-
-		bool SendBoolean(int location, bool value) const;
-		bool SendColor(int location, const NzColor& color) const;
-		bool SendDouble(int location, double value) const;
-		bool SendDoubleArray(int location, const double* values, unsigned int count) const;
-		bool SendFloat(int location, float value) const;
-		bool SendFloatArray(int location, const float* values, unsigned int count) const;
-		bool SendInteger(int location, int value) const;
-		bool SendIntegerArray(int location, const int* values, unsigned int count) const;
-		bool SendMatrix(int location, const NzMatrix4d& matrix) const;
-		bool SendMatrix(int location, const NzMatrix4f& matrix) const;
-		bool SendTexture(int location, const NzTexture* texture, nzUInt8* textureUnit = nullptr) const;
-		bool SendVector(int location, const NzVector2d& vector) const;
-		bool SendVector(int location, const NzVector2f& vector) const;
-		bool SendVector(int location, const NzVector2i& vector) const;
-		bool SendVector(int location, const NzVector3d& vector) const;
-		bool SendVector(int location, const NzVector3f& vector) const;
-		bool SendVector(int location, const NzVector3i& vector) const;
-		bool SendVector(int location, const NzVector4d& vector) const;
-		bool SendVector(int location, const NzVector4f& vector) const;
-		bool SendVector(int location, const NzVector4i& vector) const;
-		bool SendVectorArray(int location, const NzVector2d* vectors, unsigned int count) const;
-		bool SendVectorArray(int location, const NzVector2f* vectors, unsigned int count) const;
-		bool SendVectorArray(int location, const NzVector2i* vectors, unsigned int count) const;
-		bool SendVectorArray(int location, const NzVector3d* vectors, unsigned int count) const;
-		bool SendVectorArray(int location, const NzVector3f* vectors, unsigned int count) const;
-		bool SendVectorArray(int location, const NzVector3i* vectors, unsigned int count) const;
-		bool SendVectorArray(int location, const NzVector4d* vectors, unsigned int count) const;
-		bool SendVectorArray(int location, const NzVector4f* vectors, unsigned int count) const;
-		bool SendVectorArray(int location, const NzVector4i* vectors, unsigned int count) const;
-
-		void SetFlags(nzUInt32 flags);
-
-		NzShaderProgram& operator=(NzShaderProgram&& shader);
-
-		static bool IsLanguageSupported(nzShaderLanguage language);
-		static bool IsShaderTypeSupported(nzShaderType type);
-
-	private:
-		nzUInt32 m_flags;
-		NzAbstractShaderProgram* m_impl;
-		bool m_compiled;
-};
-
-#endif // NAZARA_SHADERPROGRAM_HPP

include/Nazara/Renderer/ShaderProgramManager.hpp

@@ -1,33 +0,0 @@
-// Copyright (C) 2014 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Renderer module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#pragma once
-
-#ifndef NAZARA_SHADERPROGRAMMANAGER_HPP
-#define NAZARA_SHADERPROGRAMMANAGER_HPP
-
-#include <Nazara/Prerequesites.hpp>
-#include <Nazara/Renderer/ShaderProgram.hpp>
-#include <Nazara/Renderer/ShaderProgramManagerParams.hpp>
-
-class NAZARA_API NzShaderProgramManager
-{
-	friend class NzRenderer;
-
-	public:
-		NzShaderProgramManager() = delete;
-		~NzShaderProgramManager() = delete;
-
-		static const NzShaderProgram* Get(const NzShaderProgramManagerParams& params);
-
-	private:
-		static NzString BuildFragmentCode(const NzShaderProgramManagerParams& params);
-		static NzString BuildVertexCode(const NzShaderProgramManagerParams& params);
-		static NzShaderProgram* GenerateProgram(const NzShaderProgramManagerParams& params);
-
-		static bool Initialize();
-		static void Uninitialize();
-};
-
-#endif // NAZARA_SHADERPROGRAMMANAGER_HPP

include/Nazara/Renderer/ShaderProgramManagerParams.hpp

@@ -1,51 +0,0 @@
-// Copyright (C) 2014 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Renderer module"
-// For conditions of distribution and use, see copyright notice in Config.hpp
-
-#pragma once
-
-#ifndef NAZARA_SHADERPROGRAMMANAGERPARAMS_HPP
-#define NAZARA_SHADERPROGRAMMANAGERPARAMS_HPP
-
-#include <Nazara/Renderer/Enums.hpp>
-
-struct NzShaderProgramManagerParams
-{
-	struct FullscreenQuad
-	{
-		bool alphaMapping;
-		bool alphaTest;
-		bool diffuseMapping;
-	};
-
-	struct Model
-	{
-		bool alphaMapping;
-		bool alphaTest;
-		bool diffuseMapping;
-		bool emissiveMapping;
-		bool lighting;
-		bool normalMapping;
-		bool parallaxMapping;
-		bool specularMapping;
-	};
-
-	struct Sprite
-	{
-		bool alphaMapping;
-		bool alphaTest;
-		bool diffuseMapping;
-	};
-
-	nzShaderTarget target;
-	nzUInt32 flags;
-
-	union
-	{
-		FullscreenQuad fullscreenQuad;
-		Model model;
-		Sprite sprite;
-	};
-};
-
-#endif // NAZARA_SHADERPROGRAMMANAGERPARAMS_HPP

include/Nazara/Renderer/ShaderStage.hpp

@@ -0,0 +1,51 @@
+// Copyright (C) 2014 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Renderer module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_SHADERSTAGE_HPP
+#define NAZARA_SHADERSTAGE_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/NonCopyable.hpp>
+#include <Nazara/Core/String.hpp>
+#include <Nazara/Renderer/Enums.hpp>
+
+class NAZARA_API NzShaderStage : NzNonCopyable
+{
+	public:
+		NzShaderStage();
+		NzShaderStage(nzShaderStage stage);
+		NzShaderStage(NzShaderStage&& stage);
+		~NzShaderStage();
+
+		bool Compile();
+
+		bool Create(nzShaderStage stage);
+		void Destroy();
+
+		NzString GetLog() const;
+		NzString GetSource() const;
+
+		bool IsCompiled() const;
+		bool IsValid() const;
+
+		void SetSource(const char* source, unsigned int length);
+		void SetSource(const NzString& source);
+		bool SetSourceFromFile(const NzString& filePath);
+
+		NzShaderStage& operator=(NzShaderStage&& shader);
+
+		// Fonctions OpenGL
+		unsigned int GetOpenGLID() const;
+
+		static bool IsSupported(nzShaderStage stage);
+
+	private:
+		nzShaderStage m_stage;
+		bool m_compiled;
+		unsigned int m_id;
+};
+
+#endif // NAZARA_SHADERSTAGE_HPP

include/Nazara/Renderer/UberShader.hpp

@@ -0,0 +1,31 @@
+// Copyright (C) 2014 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Renderer module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_UBERSHADER_HPP
+#define NAZARA_UBERSHADER_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/ParameterList.hpp>
+#include <Nazara/Core/Resource.hpp>
+#include <Nazara/Core/ResourceRef.hpp>
+#include <Nazara/Renderer/UberShaderInstance.hpp>
+#include <unordered_map>
+
+class NzUberShader;
+
+using NzUberShaderConstRef = NzResourceRef<const NzUberShader>;
+using NzUberShaderRef = NzResourceRef<NzUberShader>;
+
+class NAZARA_API NzUberShader : public NzResource
+{
+	public:
+		NzUberShader() = default;
+		virtual ~NzUberShader();
+
+		virtual NzUberShaderInstance* Get(const NzParameterList& parameters) const = 0;
+};
+
+#endif // NAZARA_UBERSHADER_HPP

include/Nazara/Renderer/UberShaderInstance.hpp

@@ -0,0 +1,27 @@
+// Copyright (C) 2014 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Renderer module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_UBERSHADERINSTANCE_HPP
+#define NAZARA_UBERSHADERINSTANCE_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <Nazara/Renderer/Shader.hpp>
+
+class NAZARA_API NzUberShaderInstance
+{
+	public:
+		NzUberShaderInstance(const NzShader* shader);
+		virtual ~NzUberShaderInstance();
+
+		virtual bool Activate() const = 0;
+
+		const NzShader* GetShader() const;
+
+	protected:
+		NzShaderConstRef m_shader;
+};
+
+#endif // NAZARA_UBERSHADERINSTANCE_HPP

include/Nazara/Renderer/UberShaderInstancePreprocessor.hpp

@@ -0,0 +1,22 @@
+// Copyright (C) 2014 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Renderer module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_UBERSHADERINSTANCEPREPROCESSOR_HPP
+#define NAZARA_UBERSHADERINSTANCEPREPROCESSOR_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <Nazara/Renderer/UberShaderInstance.hpp>
+
+class NAZARA_API NzUberShaderInstancePreprocessor : public NzUberShaderInstance
+{
+	public:
+		NzUberShaderInstancePreprocessor(const NzShader* shader);
+		virtual ~NzUberShaderInstancePreprocessor();
+
+		bool Activate() const;
+};
+
+#endif // NAZARA_UBERSHADERINSTANCEPREPROCESSOR_HPP

include/Nazara/Renderer/UberShaderLibrary.hpp

@@ -0,0 +1,33 @@
+// Copyright (C) 2014 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Renderer module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_UBERSHADERLIBRARY_HPP
+#define NAZARA_UBERSHADERLIBRARY_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <Nazara/Core/String.hpp>
+#include <Nazara/Renderer/UberShader.hpp>
+#include <unordered_map>
+
+class NAZARA_API NzUberShaderLibrary
+{
+	public:
+		NzUberShaderLibrary() = delete;
+		~NzUberShaderLibrary() = delete;
+
+		static NzUberShader* Get(const NzString& name);
+		static bool Has(const NzString& name);
+
+		static bool Initialize();
+		static void Register(const NzString& name, NzUberShader* uberShader);
+		static void Uninitialize();
+		static void Unregister(const NzString& name);
+
+	private:
+		static std::unordered_map<NzString, NzUberShaderRef> s_library;
+};
+
+#endif // NAZARA_UBERSHADERLIBRARY_HPP

include/Nazara/Renderer/UberShaderPreprocessor.hpp

@@ -0,0 +1,45 @@
+// Copyright (C) 2014 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Renderer module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#pragma once
+
+#ifndef NAZARA_UBERSHADERPREPROCESSOR_HPP
+#define NAZARA_UBERSHADERPREPROCESSOR_HPP
+
+#include <Nazara/Prerequesites.hpp>
+#include <Nazara/Renderer/Enums.hpp>
+#include <Nazara/Renderer/Shader.hpp>
+#include <Nazara/Renderer/ShaderStage.hpp>
+#include <Nazara/Renderer/UberShader.hpp>
+#include <Nazara/Renderer/UberShaderInstancePreprocessor.hpp>
+#include <unordered_map>
+
+class NAZARA_API NzUberShaderPreprocessor : public NzUberShader
+{
+	public:
+		NzUberShaderPreprocessor() = default;
+		~NzUberShaderPreprocessor() = default;
+
+		NzUberShaderInstance* Get(const NzParameterList& parameters) const;
+
+		void SetShader(nzShaderStage stage, const NzString& source, const NzString& flags);
+		bool SetShaderFromFile(nzShaderStage stage, const NzString& filePath, const NzString& flags);
+
+		static bool IsSupported();
+
+	private:
+		struct Shader
+		{
+			mutable std::unordered_map<nzUInt32, NzShaderStage> cache;
+			std::unordered_map<NzString, nzUInt32> flags;
+			NzString source;
+			bool present = false;
+		};
+
+		mutable std::unordered_map<nzUInt32, NzUberShaderInstancePreprocessor> m_cache;
+		std::unordered_map<NzString, nzUInt32> m_flags;
+		Shader m_shaders[nzShaderStage_Max+1];
+};
+
+#endif // NAZARA_UBERSHADERPREPROCESSOR_HPP

include/Nazara/Utility.hpp

@@ -1,4 +1,4 @@
-// This file was automatically generated on 12 Jan 2014 at 20:08:11
+// This file was automatically generated on 21 Feb 2014 at 18:17:18
 
 /*
 	Nazara Engine - Window module

include/Nazara/Utility/Debug.hpp

@@ -5,7 +5,4 @@
 #include <Nazara/Utility/Config.hpp>
 #if NAZARA_UTILITY_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG)
 	#include <Nazara/Core/Debug/MemoryLeakTracker.hpp>
-
-	#define delete NzMemoryManager::NextFree(__FILE__, __LINE__), delete
-	#define new new(__FILE__, __LINE__)
 #endif

include/Nazara/Utility/Node.hpp

@@ -92,7 +92,7 @@ class NAZARA_API NzNode
 
 	protected:
 		void AddChild(NzNode* node) const;
-		virtual void Invalidate();
+		virtual void InvalidateNode();
 		virtual void OnParenting(const NzNode* parent);
 		void RemoveChild(NzNode* node) const;
 		void UpdateDerived() const;

src/Nazara/Audio/Audio.cpp

@@ -7,6 +7,7 @@
 #include <Nazara/Audio/Enums.hpp>
 #include <Nazara/Audio/OpenAL.hpp>
 #include <Nazara/Audio/Loaders/sndfile.hpp>
+#include <Nazara/Core/CallOnExit.hpp>
 #include <Nazara/Core/Core.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/Log.hpp>
@@ -84,24 +85,28 @@ float NzAudio::GetSpeedOfSound()
 
 bool NzAudio::Initialize()
 {
-	if (s_moduleReferenceCounter++ != 0)
+	if (s_moduleReferenceCounter > 0)
+	{
+		s_moduleReferenceCounter++;
 		return true; // Déjà initialisé
+	}
 
 	// Initialisation des dépendances
 	if (!NzCore::Initialize())
 	{
 		NazaraError("Failed to initialize core module");
-		Uninitialize();
-
 		return false;
 	}
 
+	s_moduleReferenceCounter++;
+
+	// Initialisation du module
+	NzCallOnExit onExit(NzAudio::Uninitialize);
+
 	// Initialisation d'OpenGL
 	if (!NzOpenAL::Initialize())
 	{
 		NazaraError("Failed to initialize OpenAL");
-		Uninitialize();
-
 		return false;
 	}
 
@@ -111,8 +116,9 @@ bool NzAudio::Initialize()
 	// Loaders
 	NzLoaders_sndfile_Register();
 
-	NazaraNotice("Initialized: Audio module");
+	onExit.Reset();
 
+	NazaraNotice("Initialized: Audio module");
 	return true;
 }
 

src/Nazara/Audio/Debug/Leaks.cpp

@@ -4,6 +4,9 @@
 
 #include <Nazara/Audio/Config.hpp>
 #if NAZARA_AUDIO_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG)
+
+#define NAZARA_DEBUG_MEMORYLEAKTRACKER_DISABLE_REDEFINITION
+
 #include <Nazara/Core/Debug/MemoryLeakTracker.hpp>
 #include <new>
 
@@ -26,4 +29,5 @@ void operator delete[](void* pointer) noexcept
 {
 	NzMemoryManager::Free(pointer, true);
 }
+
 #endif

src/Nazara/Core/Core.cpp

@@ -12,11 +12,15 @@
 
 bool NzCore::Initialize()
 {
-	if (s_moduleReferenceCounter++ != 0)
+	if (s_moduleReferenceCounter > 0)
+	{
+		s_moduleReferenceCounter++;
 		return true; // Déjà initialisé
+	}
+
+	s_moduleReferenceCounter++;
 
 	NazaraNotice("Initialized: Core");
-
 	return true;
 }
 

src/Nazara/Core/Debug/Leaks.cpp

@@ -4,6 +4,9 @@
 
 #include <Nazara/Core/Config.hpp>
 #if NAZARA_CORE_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG)
+
+#define NAZARA_DEBUG_MEMORYLEAKTRACKER_DISABLE_REDEFINITION
+
 #include <Nazara/Core/Debug/MemoryLeakTracker.hpp>
 #include <new>
 

src/Nazara/Core/Debug/MemoryLeakTracker.cpp

@@ -2,6 +2,8 @@
 // This file is part of the "Nazara Engine - Core module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
+#define NAZARA_DEBUG_MEMORYLEAKTRACKER_DISABLE_REDEFINITION
+
 #include <Nazara/Core/Debug/MemoryLeakTracker.hpp>
 #include <cstdio>
 #include <cstdlib>

src/Nazara/Core/ParameterList.cpp

@@ -0,0 +1,458 @@
+// Copyright (C) 2014 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Core module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+// Notre utilisation du placement new n'est pas (encore ?) compatible avec les définitions du MLT
+#define NAZARA_DEBUG_MEMORYLEAKTRACKER_DISABLE_REDEFINITION
+
+#include <Nazara/Core/ParameterList.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <cstring>
+#include <limits>
+#include <new>
+#include <Nazara/Core/Debug.hpp>
+
+NzParameterList::NzParameterList(const NzParameterList& list)
+{
+	operator=(list);
+}
+
+NzParameterList::NzParameterList(NzParameterList&& list) :
+m_parameters(std::move(list.m_parameters))
+{
+}
+
+NzParameterList::~NzParameterList()
+{
+	Clear();
+}
+
+void NzParameterList::Clear()
+{
+	for (auto it = m_parameters.begin(); it != m_parameters.end(); ++it)
+		DestroyValue(it->second);
+
+	m_parameters.clear();
+}
+
+bool NzParameterList::GetBooleanParameter(const NzString& name, bool* value) const
+{
+	auto it = m_parameters.find(name);
+	if (it == m_parameters.end())
+	{
+		NazaraError("Parameter \"" + name + "\" is not present");
+		return false;
+	}
+
+	switch (it->second.type)
+	{
+		case nzParameterType_Boolean:
+			*value = it->second.value.boolVal;
+			return true;
+
+		case nzParameterType_Integer:
+			*value = (it->second.value.intVal != 0);
+			return true;
+
+		case nzParameterType_String:
+		{
+			bool converted;
+			if (it->second.value.stringVal.ToBool(&converted, NzString::CaseInsensitive))
+			{
+				*value = converted;
+				return true;
+			}
+
+			break;
+		}
+
+		case nzParameterType_Float:
+		case nzParameterType_None:
+		case nzParameterType_Pointer:
+		case nzParameterType_Userdata:
+			break;
+	}
+
+	NazaraError("Parameter value is not representable as a boolean");
+	return false;
+}
+
+bool NzParameterList::GetFloatParameter(const NzString& name, float* value) const
+{
+	auto it = m_parameters.find(name);
+	if (it == m_parameters.end())
+	{
+		NazaraError("Parameter \"" + name + "\" is not present");
+		return false;
+	}
+
+	switch (it->second.type)
+	{
+		case nzParameterType_Float:
+			*value = it->second.value.floatVal;
+			return true;
+
+		case nzParameterType_Integer:
+			*value = it->second.value.intVal;
+			return true;
+
+		case nzParameterType_String:
+		{
+			double converted;
+			if (it->second.value.stringVal.ToDouble(&converted))
+			{
+				*value = converted;
+				return true;
+			}
+
+			break;
+		}
+
+		case nzParameterType_Boolean:
+		case nzParameterType_None:
+		case nzParameterType_Pointer:
+		case nzParameterType_Userdata:
+			break;
+	}
+
+	NazaraError("Parameter value is not representable as a float");
+	return false;
+}
+
+bool NzParameterList::GetIntegerParameter(const NzString& name, int* value) const
+{
+	auto it = m_parameters.find(name);
+	if (it == m_parameters.end())
+	{
+		NazaraError("Parameter \"" + name + "\" is not present");
+		return false;
+	}
+
+	switch (it->second.type)
+	{
+		case nzParameterType_Boolean:
+			*value = (it->second.value.boolVal) ? 1 : 0;
+			return true;
+
+		case nzParameterType_Float:
+			*value = it->second.value.floatVal;
+			return true;
+
+		case nzParameterType_Integer:
+			*value = it->second.value.intVal;
+			return false;
+
+		case nzParameterType_String:
+		{
+			long long converted;
+			if (it->second.value.stringVal.ToInteger(&converted))
+			{
+				if (converted <= std::numeric_limits<int>::max() && converted >= std::numeric_limits<int>::min())
+				{
+					*value = converted;
+					return true;
+				}
+			}
+			break;
+		}
+
+		case nzParameterType_None:
+		case nzParameterType_Pointer:
+		case nzParameterType_Userdata:
+			break;
+	}
+
+	NazaraError("Parameter value is not representable as a integer");
+	return false;
+}
+
+bool NzParameterList::GetParameterType(const NzString& name, nzParameterType* type) const
+{
+	auto it = m_parameters.find(name);
+	if (it == m_parameters.end())
+		return false;
+
+	*type = it->second.type;
+
+	return true;
+}
+
+bool NzParameterList::GetPointerParameter(const NzString& name, void** value) const
+{
+	auto it = m_parameters.find(name);
+	if (it == m_parameters.end())
+	{
+		NazaraError("Parameter \"" + name + "\" is not present");
+		return false;
+	}
+
+	switch (it->second.type)
+	{
+		case nzParameterType_Pointer:
+			*value = it->second.value.ptrVal;
+			return true;
+
+		case nzParameterType_Userdata:
+			*value = it->second.value.userdataVal->ptr;
+			return true;
+
+		case nzParameterType_Boolean:
+		case nzParameterType_Float:
+		case nzParameterType_Integer:
+		case nzParameterType_None:
+		case nzParameterType_String:
+			break;
+	}
+
+	NazaraError("Parameter value is not a pointer");
+	return false;
+}
+
+bool NzParameterList::GetStringParameter(const NzString& name, NzString* value) const
+{
+	auto it = m_parameters.find(name);
+	if (it == m_parameters.end())
+	{
+		NazaraError("Parameter \"" + name + "\" is not present");
+		return false;
+	}
+
+	switch (it->second.type)
+	{
+		case nzParameterType_Boolean:
+			*value = NzString::Boolean(it->second.value.boolVal);
+			return true;
+
+		case nzParameterType_Float:
+			*value = NzString::Number(it->second.value.floatVal);
+			return true;
+
+		case nzParameterType_Integer:
+			*value = NzString::Number(it->second.value.intVal);
+			return true;
+
+		case nzParameterType_String:
+			*value = it->second.value.stringVal;
+			return true;
+
+		case nzParameterType_Pointer:
+			*value = NzString::Pointer(it->second.value.ptrVal);
+			return true;
+
+		case nzParameterType_Userdata:
+			*value = NzString::Pointer(it->second.value.userdataVal->ptr);
+			return true;
+
+		case nzParameterType_None:
+			*value = NzString();
+			return true;
+	}
+
+	NazaraInternalError("Parameter value is not valid");
+	return false;
+}
+
+bool NzParameterList::GetUserdataParameter(const NzString& name, void** value) const
+{
+	auto it = m_parameters.find(name);
+	if (it == m_parameters.end())
+	{
+		NazaraError("Parameter \"" + name + "\" is not present");
+		return false;
+	}
+
+	if (it->second.type == nzParameterType_Userdata)
+	{
+		*value = it->second.value.userdataVal->ptr;
+		return true;
+	}
+	else
+	{
+		NazaraError("Parameter value is not an userdata");
+		return nullptr;
+	}
+}
+
+bool NzParameterList::HasParameter(const NzString& name) const
+{
+	return m_parameters.find(name) != m_parameters.end();
+}
+
+void NzParameterList::RemoveParameter(const NzString& name)
+{
+	auto it = m_parameters.find(name);
+	if (it != m_parameters.end())
+	{
+		DestroyValue(it->second);
+		m_parameters.erase(it);
+	}
+}
+
+void NzParameterList::SetParameter(const NzString& name)
+{
+	std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter()));
+	Parameter& parameter = pair.first->second;
+
+	if (!pair.second)
+		DestroyValue(parameter);
+
+	parameter.type = nzParameterType_None;
+}
+
+void NzParameterList::SetParameter(const NzString& name, const NzString& value)
+{
+	std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter()));
+	Parameter& parameter = pair.first->second;
+
+	if (!pair.second)
+		DestroyValue(parameter);
+
+	parameter.type = nzParameterType_String;
+
+	new (&parameter.value.stringVal) NzString(value);
+}
+
+void NzParameterList::SetParameter(const NzString& name, const char* value)
+{
+	std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter()));
+	Parameter& parameter = pair.first->second;
+
+	if (!pair.second)
+		DestroyValue(parameter);
+
+	parameter.type = nzParameterType_String;
+
+	new (&parameter.value.stringVal) NzString(value);
+}
+
+void NzParameterList::SetParameter(const NzString& name, void* value)
+{
+	std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter()));
+	Parameter& parameter = pair.first->second;
+
+	if (!pair.second)
+		DestroyValue(parameter);
+
+	parameter.type = nzParameterType_Pointer;
+	parameter.value.ptrVal = value;
+}
+
+void NzParameterList::SetParameter(const NzString& name, void* value, Destructor destructor)
+{
+	std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter()));
+	Parameter& parameter = pair.first->second;
+
+	if (!pair.second)
+		DestroyValue(parameter);
+
+	parameter.type = nzParameterType_Userdata;
+	parameter.value.userdataVal = new Parameter::UserdataValue(destructor, value);
+}
+
+void NzParameterList::SetParameter(const NzString& name, bool value)
+{
+	std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter()));
+	Parameter& parameter = pair.first->second;
+
+	if (!pair.second)
+		DestroyValue(parameter);
+
+	parameter.type = nzParameterType_Boolean;
+	parameter.value.boolVal = value;
+}
+
+void NzParameterList::SetParameter(const NzString& name, float value)
+{
+	std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter()));
+	Parameter& parameter = pair.first->second;
+
+	if (!pair.second)
+		DestroyValue(parameter);
+
+	parameter.type = nzParameterType_Float;
+	parameter.value.floatVal = value;
+}
+
+void NzParameterList::SetParameter(const NzString& name, int value)
+{
+	std::pair<ParameterMap::iterator, bool> pair = m_parameters.insert(std::make_pair(name, Parameter()));
+	Parameter& parameter = pair.first->second;
+
+	if (!pair.second)
+		DestroyValue(parameter);
+
+	parameter.type = nzParameterType_Integer;
+	parameter.value.intVal = value;
+}
+
+NzParameterList& NzParameterList::operator=(const NzParameterList& list)
+{
+	Clear();
+
+	for (auto it = list.m_parameters.begin(); it != list.m_parameters.end(); ++it)
+	{
+		Parameter& parameter = m_parameters[it->first];
+
+		switch (it->second.type)
+		{
+			case nzParameterType_Boolean:
+			case nzParameterType_Float:
+			case nzParameterType_Integer:
+			case nzParameterType_Pointer:
+				std::memcpy(&parameter, &it->second, sizeof(Parameter));
+				break;
+
+			case nzParameterType_String:
+				parameter.type = nzParameterType_String;
+
+				new (&parameter.value.stringVal) NzString(it->second.value.stringVal);
+				break;
+
+			case nzParameterType_Userdata:
+				parameter.type = nzParameterType_Userdata;
+				parameter.value.userdataVal = it->second.value.userdataVal;
+				++(parameter.value.userdataVal->counter);
+				break;
+
+			case nzParameterType_None:
+				parameter.type = nzParameterType_None;
+				break;
+		}
+	}
+
+	return *this;
+}
+
+NzParameterList& NzParameterList::operator=(NzParameterList&& list)
+{
+	m_parameters = std::move(list.m_parameters);
+	return *this;
+}
+
+void NzParameterList::DestroyValue(Parameter& parameter)
+{
+	switch (parameter.type)
+	{
+		case nzParameterType_String:
+			parameter.value.stringVal.~NzString();
+			break;
+
+		case nzParameterType_Userdata:
+		{
+			Parameter::UserdataValue* userdata = parameter.value.userdataVal;
+			if (--userdata->counter == 0)
+			{
+				userdata->destructor(userdata->ptr);
+				delete userdata;
+			}
+			break;
+		}
+
+		case nzParameterType_Boolean:
+		case nzParameterType_Float:
+		case nzParameterType_Integer:
+		case nzParameterType_None:
+		case nzParameterType_Pointer:
+			break;
+	}
+}

src/Nazara/Graphics/Camera.cpp

@@ -222,9 +222,9 @@ void NzCamera::ApplyView() const
 	NzRenderer::SetViewport(m_viewport);
 }
 
-void NzCamera::Invalidate()
+void NzCamera::InvalidateNode()
 {
-	NzNode::Invalidate();
+	NzNode::InvalidateNode();
 
 	// Le frustum et la view matrix dépendent des paramètres du node, invalidons-les
 	m_frustumUpdated = false;

src/Nazara/Graphics/ColorBackground.cpp

@@ -4,7 +4,7 @@
 
 #include <Nazara/Graphics/ColorBackGround.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
-#include <Nazara/Renderer/ShaderProgramManager.hpp>
+#include <Nazara/Renderer/UberShaderLibrary.hpp>
 #include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
@@ -26,14 +26,15 @@ namespace
 NzColorBackground::NzColorBackground(const NzColor& color) :
 m_color(color)
 {
-	NzShaderProgramManagerParams params;
-	params.target = nzShaderTarget_FullscreenQuad;
-	params.flags = 0;
-	params.fullscreenQuad.alphaMapping = false;
-	params.fullscreenQuad.alphaTest = false;
-	params.fullscreenQuad.diffuseMapping = false;
+	m_uberShader = NzUberShaderLibrary::Get("Basic");
 
-	m_program = NzShaderProgramManager::Get(params);
+	NzParameterList list;
+	list.SetParameter("UNIFORM_VERTEX_DEPTH", true);
+	m_uberShaderInstance = m_uberShader->Get(list);
+
+	const NzShader* shader = m_uberShaderInstance->GetShader();
+	m_materialDiffuseUniform = shader->GetUniformLocation("MaterialDiffuse");
+	m_vertexDepthUniform = shader->GetUniformLocation("VertexDepth");
 }
 
 void NzColorBackground::Draw(const NzScene* scene) const
@@ -43,10 +44,12 @@ void NzColorBackground::Draw(const NzScene* scene) const
 	static NzRenderStates states(BuildRenderStates());
 
 	NzRenderer::SetRenderStates(states);
-	NzRenderer::SetShaderProgram(m_program);
 
-	m_program->SendColor(m_program->GetUniformLocation(nzShaderUniform_MaterialDiffuse), m_color);
-	m_program->SendFloat(m_program->GetUniformLocation(nzShaderUniform_VertexDepth), 1.f);
+	m_uberShaderInstance->Activate();
+
+	const NzShader* shader = m_uberShaderInstance->GetShader();
+	shader->SendColor(m_materialDiffuseUniform, m_color);
+	shader->SendFloat(m_vertexDepthUniform, 1.f);
 
 	NzRenderer::DrawFullscreenQuad();
 }
@@ -64,6 +67,5 @@ NzColor NzColorBackground::GetColor() const
 void NzColorBackground::SetColor(const NzColor& color)
 {
 	m_color = color;
-	m_program->SendColor(m_program->GetUniformLocation(nzShaderUniform_MaterialDiffuse), m_color);
 }
 

src/Nazara/Graphics/Debug/Leaks.cpp

@@ -4,6 +4,9 @@
 
 #include <Nazara/Graphics/Config.hpp>
 #if NAZARA_GRAPHICS_MEMORYLEAKTRACKER || defined(NAZARA_DEBUG)
+
+#define NAZARA_DEBUG_MEMORYLEAKTRACKER_DISABLE_REDEFINITION
+
 #include <Nazara/Core/Debug/MemoryLeakTracker.hpp>
 #include <new>
 
@@ -26,4 +29,5 @@ void operator delete[](void* pointer) noexcept
 {
 	NzMemoryManager::Free(pointer, true);
 }
+
 #endif

src/Nazara/Graphics/DeferredBloomPass.cpp

@@ -4,142 +4,10 @@
 
 #include <Nazara/Graphics/DeferredBloomPass.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
+#include <Nazara/Renderer/ShaderLibrary.hpp>
 #include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
-namespace
-{
-	NzShaderProgram* BuildBloomBrightProgram()
-	{
-		const nzUInt8 fragmentSource[] = {
-			#include <Nazara/Graphics/Resources/DeferredShading/Shaders/BloomBright.frag.h>
-		};
-
-		const char* vertexSource =
-		"#version 140\n"
-
-		"in vec3 VertexPosition;\n"
-
-		"void main()\n"
-		"{\n"
-		"\t" "gl_Position = vec4(VertexPosition, 1.0);" "\n"
-		"}\n";
-
-		///TODO: Remplacer ça par des ShaderNode
-		std::unique_ptr<NzShaderProgram> program(new NzShaderProgram(nzShaderLanguage_GLSL));
-		program->SetPersistent(false);
-
-		if (!program->LoadShader(nzShaderType_Fragment, NzString(reinterpret_cast<const char*>(fragmentSource), sizeof(fragmentSource))))
-		{
-			NazaraError("Failed to load fragment shader");
-			return nullptr;
-		}
-
-		if (!program->LoadShader(nzShaderType_Vertex, vertexSource))
-		{
-			NazaraError("Failed to load vertex shader");
-			return nullptr;
-		}
-
-		if (!program->Compile())
-		{
-			NazaraError("Failed to compile program");
-			return nullptr;
-		}
-
-		program->SendInteger(program->GetUniformLocation("ColorTexture"), 0);
-
-		return program.release();
-	}
-
-	NzShaderProgram* BuildBloomFinalProgram()
-	{
-		const nzUInt8 fragmentSource[] = {
-			#include <Nazara/Graphics/Resources/DeferredShading/Shaders/BloomFinal.frag.h>
-		};
-
-		const char* vertexSource =
-		"#version 140\n"
-
-		"in vec3 VertexPosition;\n"
-
-		"void main()\n"
-		"{\n"
-		"\t" "gl_Position = vec4(VertexPosition, 1.0);" "\n"
-		"}\n";
-
-		///TODO: Remplacer ça par des ShaderNode
-		std::unique_ptr<NzShaderProgram> program(new NzShaderProgram(nzShaderLanguage_GLSL));
-		program->SetPersistent(false);
-
-		if (!program->LoadShader(nzShaderType_Fragment, NzString(reinterpret_cast<const char*>(fragmentSource), sizeof(fragmentSource))))
-		{
-			NazaraError("Failed to load fragment shader");
-			return nullptr;
-		}
-
-		if (!program->LoadShader(nzShaderType_Vertex, vertexSource))
-		{
-			NazaraError("Failed to load vertex shader");
-			return nullptr;
-		}
-
-		if (!program->Compile())
-		{
-			NazaraError("Failed to compile program");
-			return nullptr;
-		}
-
-		program->SendInteger(program->GetUniformLocation("ColorTexture"), 0);
-		program->SendInteger(program->GetUniformLocation("BloomTexture"), 1);
-
-		return program.release();
-	}
-
-	NzShaderProgram* BuildGaussianBlurProgram()
-	{
-		const nzUInt8 fragmentSource[] = {
-			#include <Nazara/Graphics/Resources/DeferredShading/Shaders/GaussianBlur.frag.h>
-		};
-
-		const char* vertexSource =
-		"#version 140\n"
-
-		"in vec3 VertexPosition;\n"
-
-		"void main()\n"
-		"{\n"
-		"\t" "gl_Position = vec4(VertexPosition, 1.0);" "\n"
-		"}\n";
-
-		///TODO: Remplacer ça par des ShaderNode
-		std::unique_ptr<NzShaderProgram> program(new NzShaderProgram(nzShaderLanguage_GLSL));
-		program->SetPersistent(false);
-
-		if (!program->LoadShader(nzShaderType_Fragment, NzString(reinterpret_cast<const char*>(fragmentSource), sizeof(fragmentSource))))
-		{
-			NazaraError("Failed to load fragment shader");
-			return nullptr;
-		}
-
-		if (!program->LoadShader(nzShaderType_Vertex, vertexSource))
-		{
-			NazaraError("Failed to load vertex shader");
-			return nullptr;
-		}
-
-		if (!program->Compile())
-		{
-			NazaraError("Failed to compile program");
-			return nullptr;
-		}
-
-		program->SendInteger(program->GetUniformLocation("ColorTexture"), 0);
-
-		return program.release();
-	}
-}
-
 NzDeferredBloomPass::NzDeferredBloomPass() :
 m_uniformUpdated(false),
 m_brightLuminance(0.8),
@@ -151,23 +19,17 @@ m_blurPassCount(5)
 	m_bilinearSampler.SetFilterMode(nzSamplerFilter_Bilinear);
 	m_bilinearSampler.SetWrapMode(nzSamplerWrap_Clamp);
 
-	m_bloomBrightProgram = BuildBloomBrightProgram();
-	m_bloomBrightProgram->SendInteger(m_bloomBrightProgram->GetUniformLocation("ColorTexture"), 0);
-
-	m_bloomFinalProgram = BuildBloomFinalProgram();
-	m_bloomFinalProgram->SendInteger(m_bloomFinalProgram->GetUniformLocation("BloomTexture"), 1);
-	m_bloomFinalProgram->SendInteger(m_bloomFinalProgram->GetUniformLocation("ColorTexture"), 0);
-
+	m_bloomBrightShader = NzShaderLibrary::Get("DeferredBloomBright");
+	m_bloomFinalShader = NzShaderLibrary::Get("DeferredBloomFinal");
 	m_bloomStates.parameters[nzRendererParameter_DepthBuffer] = false;
+	m_gaussianBlurShader = NzShaderLibrary::Get("DeferredGaussianBlur");
+	m_gaussianBlurShaderFilterLocation = m_gaussianBlurShader->GetUniformLocation("Filter");
 
 	for (unsigned int i = 0; i < 2; ++i)
 	{
 		m_bloomTextures[i] = new NzTexture;
 		m_bloomTextures[i]->SetPersistent(false);
 	}
-
-	m_gaussianBlurProgram = BuildGaussianBlurProgram();
-	m_gaussianBlurProgramFilterLocation = m_gaussianBlurProgram->GetUniformLocation("Filter");
 }
 
 NzDeferredBloomPass::~NzDeferredBloomPass() = default;
@@ -217,12 +79,12 @@ bool NzDeferredBloomPass::Process(const NzScene* scene, unsigned int firstWorkTe
 	NzRenderer::SetTarget(m_workRTT);
 	NzRenderer::SetViewport(NzRecti(0, 0, m_dimensions.x, m_dimensions.y));
 
-	NzRenderer::SetShaderProgram(m_bloomBrightProgram);
+	NzRenderer::SetShader(m_bloomBrightShader);
 	if (!m_uniformUpdated)
 	{
-		m_bloomBrightProgram->SendFloat(m_bloomBrightProgram->GetUniformLocation("BrightLuminance"), m_brightLuminance);
-		m_bloomBrightProgram->SendFloat(m_bloomBrightProgram->GetUniformLocation("BrightMiddleGrey"), m_brightMiddleGrey);
-		m_bloomBrightProgram->SendFloat(m_bloomBrightProgram->GetUniformLocation("BrightThreshold"), m_brightThreshold);
+		m_bloomBrightShader->SendFloat(m_bloomBrightShader->GetUniformLocation("BrightLuminance"), m_brightLuminance);
+		m_bloomBrightShader->SendFloat(m_bloomBrightShader->GetUniformLocation("BrightMiddleGrey"), m_brightMiddleGrey);
+		m_bloomBrightShader->SendFloat(m_bloomBrightShader->GetUniformLocation("BrightThreshold"), m_brightThreshold);
 
 		m_uniformUpdated = true;
 	}
@@ -233,20 +95,20 @@ bool NzDeferredBloomPass::Process(const NzScene* scene, unsigned int firstWorkTe
 	NzRenderer::SetTarget(&m_bloomRTT);
 	NzRenderer::SetViewport(NzRecti(0, 0, m_dimensions.x/8, m_dimensions.y/8));
 
-	NzRenderer::SetShaderProgram(m_gaussianBlurProgram);
+	NzRenderer::SetShader(m_gaussianBlurShader);
 
 	for (unsigned int i = 0; i < m_blurPassCount; ++i)
 	{
 		m_bloomRTT.SetColorTarget(0); // bloomTextureA
 
-		m_gaussianBlurProgram->SendVector(m_gaussianBlurProgramFilterLocation, NzVector2f(1.f, 0.f));
+		m_gaussianBlurShader->SendVector(m_gaussianBlurShaderFilterLocation, NzVector2f(1.f, 0.f));
 
 		NzRenderer::SetTexture(0, (i == 0) ? m_workTextures[firstWorkTexture] : static_cast<const NzTexture*>(m_bloomTextures[1]));
 		NzRenderer::DrawFullscreenQuad();
 
 		m_bloomRTT.SetColorTarget(1); // bloomTextureB
 
-		m_gaussianBlurProgram->SendVector(m_gaussianBlurProgramFilterLocation, NzVector2f(0.f, 1.f));
+		m_gaussianBlurShader->SendVector(m_gaussianBlurShaderFilterLocation, NzVector2f(0.f, 1.f));
 
 		NzRenderer::SetTexture(0, m_bloomTextures[0]);
 		NzRenderer::DrawFullscreenQuad();
@@ -256,7 +118,7 @@ bool NzDeferredBloomPass::Process(const NzScene* scene, unsigned int firstWorkTe
 	NzRenderer::SetTarget(m_workRTT);
 	NzRenderer::SetViewport(NzRecti(0, 0, m_dimensions.x, m_dimensions.y));
 
-	NzRenderer::SetShaderProgram(m_bloomFinalProgram);
+	NzRenderer::SetShader(m_bloomFinalShader);
 	NzRenderer::SetTexture(0, m_bloomTextures[1]);
 	NzRenderer::SetTexture(1, m_workTextures[secondWorkTexture]);
 	NzRenderer::DrawFullscreenQuad();

src/Nazara/Graphics/DeferredDOFPass.cpp

@@ -7,13 +7,14 @@
 #include <Nazara/Graphics/Scene.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
+#include <Nazara/Renderer/ShaderLibrary.hpp>
 #include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
 namespace
 {
 	// http://digitalerr0r.wordpress.com/2009/05/16/xna-shader-programming-tutorial-20-depth-of-field/
-	NzShaderProgram* BuildDepthOfFieldProgram()
+	NzShader* BuildDepthOfFieldShader()
 	{
 		const char* fragmentSource =
 		"#version 140\n"
@@ -62,84 +63,46 @@ namespace
 		"}\n";
 
 		///TODO: Remplacer ça par des ShaderNode
-		std::unique_ptr<NzShaderProgram> program(new NzShaderProgram(nzShaderLanguage_GLSL));
-		program->SetPersistent(false);
+		std::unique_ptr<NzShader> shader(new NzShader);
+		shader->SetPersistent(false);
 
-		if (!program->LoadShader(nzShaderType_Fragment, fragmentSource))
+		if (!shader->Create())
+		{
+				NazaraError("Failed to load create shader");
+				return nullptr;
+		}
+
+		if (!shader->AttachStageFromSource(nzShaderStage_Fragment, fragmentSource))
 		{
 				NazaraError("Failed to load fragment shader");
 				return nullptr;
 		}
 
-		if (!program->LoadShader(nzShaderType_Vertex, vertexSource))
+		if (!shader->AttachStageFromSource(nzShaderStage_Vertex, vertexSource))
 		{
 				NazaraError("Failed to load vertex shader");
 				return nullptr;
 		}
 
-		if (!program->Compile())
+		if (!shader->Link())
 		{
-				NazaraError("Failed to compile program");
+				NazaraError("Failed to link shader");
 				return nullptr;
 		}
 
-		return program.release();
-	}
-
-
-	NzShaderProgram* BuildGaussianBlurProgram()
-	{
-		const nzUInt8 fragmentSource[] = {
-			#include <Nazara/Graphics/Resources/DeferredShading/Shaders/GaussianBlur.frag.h>
-		};
-
-		const char* vertexSource =
-		"#version 140\n"
-
-		"in vec3 VertexPosition;\n"
-
-		"void main()\n"
-		"{\n"
-		"\t" "gl_Position = vec4(VertexPosition, 1.0);" "\n"
-		"}\n";
-
-		///TODO: Remplacer ça par des ShaderNode
-		std::unique_ptr<NzShaderProgram> program(new NzShaderProgram(nzShaderLanguage_GLSL));
-		program->SetPersistent(false);
-
-		if (!program->LoadShader(nzShaderType_Fragment, NzString(reinterpret_cast<const char*>(fragmentSource), sizeof(fragmentSource))))
-		{
-			NazaraError("Failed to load fragment shader");
-			return nullptr;
-		}
-
-		if (!program->LoadShader(nzShaderType_Vertex, vertexSource))
-		{
-			NazaraError("Failed to load vertex shader");
-			return nullptr;
-		}
-
-		if (!program->Compile())
-		{
-			NazaraError("Failed to compile program");
-			return nullptr;
-		}
-
-		return program.release();
+		return shader.release();
 	}
 }
 
 NzDeferredDOFPass::NzDeferredDOFPass()
 {
-	m_blurProgram = BuildGaussianBlurProgram();
-	m_blurProgram->SendInteger(m_blurProgram->GetUniformLocation("ColorTexture"), 0);
+	m_dofShader = BuildDepthOfFieldShader();
+	m_dofShader->SendInteger(m_dofShader->GetUniformLocation("ColorTexture"), 0);
+	m_dofShader->SendInteger(m_dofShader->GetUniformLocation("BlurTexture"), 1);
+	m_dofShader->SendInteger(m_dofShader->GetUniformLocation("GBuffer1"), 2);
 
-	m_blurProgramFilterLocation = m_blurProgram->GetUniformLocation("Filer");
-
-	m_dofProgram = BuildDepthOfFieldProgram();
-	m_dofProgram->SendInteger(m_dofProgram->GetUniformLocation("ColorTexture"), 0);
-	m_dofProgram->SendInteger(m_dofProgram->GetUniformLocation("BlurTexture"), 1);
-	m_dofProgram->SendInteger(m_dofProgram->GetUniformLocation("GBuffer1"), 2);
+	m_gaussianBlurShader = NzShaderLibrary::Get("DeferredGaussianBlur");
+	m_gaussianBlurShaderFilterLocation = m_gaussianBlurShader->GetUniformLocation("Filter");
 
 	for (unsigned int i = 0; i < 2; ++i)
 	{
@@ -169,21 +132,21 @@ bool NzDeferredDOFPass::Process(const NzScene* scene, unsigned int firstWorkText
 	NzRenderer::SetTarget(&m_dofRTT);
 	NzRenderer::SetViewport(NzRecti(0, 0, m_dimensions.x/4, m_dimensions.y/4));
 
-	NzRenderer::SetShaderProgram(m_blurProgram);
+	NzRenderer::SetShader(m_gaussianBlurShader);
 
 	const unsigned int dofBlurPass = 2;
 	for (unsigned int i = 0; i < dofBlurPass; ++i)
 	{
 		m_dofRTT.SetColorTarget(0); // dofTextureA
 
-		m_blurProgram->SendVector(m_blurProgramFilterLocation, NzVector2f(1.f, 0.f));
+		m_gaussianBlurShader->SendVector(m_gaussianBlurShaderFilterLocation, NzVector2f(1.f, 0.f));
 
 		NzRenderer::SetTexture(0, (i == 0) ? m_workTextures[secondWorkTexture] : static_cast<const NzTexture*>(m_dofTextures[1]));
 		NzRenderer::DrawFullscreenQuad();
 
 		m_dofRTT.SetColorTarget(1); // dofTextureB
 
-		m_blurProgram->SendVector(m_blurProgramFilterLocation, NzVector2f(0.f, 1.f));
+		m_gaussianBlurShader->SendVector(m_gaussianBlurShaderFilterLocation, NzVector2f(0.f, 1.f));
 
 		NzRenderer::SetTexture(0, m_dofTextures[0]);
 		NzRenderer::DrawFullscreenQuad();
@@ -193,7 +156,7 @@ bool NzDeferredDOFPass::Process(const NzScene* scene, unsigned int firstWorkText
 	NzRenderer::SetTarget(m_workRTT);
 	NzRenderer::SetViewport(NzRecti(0, 0, m_dimensions.x, m_dimensions.y));
 
-	NzRenderer::SetShaderProgram(m_dofProgram);
+	NzRenderer::SetShader(m_dofShader);
 	NzRenderer::SetTexture(0, m_workTextures[secondWorkTexture]);
 	NzRenderer::SetTexture(1, m_dofTextures[1]);
 	NzRenderer::SetTexture(2, m_GBuffer[1]);

src/Nazara/Graphics/DeferredFXAAPass.cpp

@@ -5,57 +5,13 @@
 #include <Nazara/Graphics/DeferredFXAAPass.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
+#include <Nazara/Renderer/ShaderLibrary.hpp>
 #include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
-namespace
-{
-	NzShaderProgram* BuildFXAAProgram()
-	{
-		const nzUInt8 fragmentSource[] = {
-				#include <Nazara/Graphics/Resources/DeferredShading/Shaders/FXAA.frag.h>
-		};
-
-		const char* vertexSource =
-		"#version 140\n"
-
-		"in vec3 VertexPosition;\n"
-
-		"void main()\n"
-		"{\n"
-		"\t" "gl_Position = vec4(VertexPosition, 1.0);" "\n"
-		"}\n";
-
-		///TODO: Remplacer ça par des ShaderNode
-		std::unique_ptr<NzShaderProgram> program(new NzShaderProgram(nzShaderLanguage_GLSL));
-		program->SetPersistent(false);
-
-		if (!program->LoadShader(nzShaderType_Fragment, NzString(reinterpret_cast<const char*>(fragmentSource), sizeof(fragmentSource))))
-		{
-				NazaraError("Failed to load fragment shader");
-				return nullptr;
-		}
-
-		if (!program->LoadShader(nzShaderType_Vertex, vertexSource))
-		{
-				NazaraError("Failed to load vertex shader");
-				return nullptr;
-		}
-
-		if (!program->Compile())
-		{
-				NazaraError("Failed to compile program");
-				return nullptr;
-		}
-
-		return program.release();
-	}
-}
-
 NzDeferredFXAAPass::NzDeferredFXAAPass()
 {
-	m_fxaaProgram = BuildFXAAProgram();
-	m_fxaaProgram->SendInteger(m_fxaaProgram->GetUniformLocation("ColorTexture"), 0);
+	m_fxaaShader = NzShaderLibrary::Get("DeferredFXAA");
 
 	m_pointSampler.SetAnisotropyLevel(1);
 	m_pointSampler.SetFilterMode(nzSamplerFilter_Nearest);
@@ -75,7 +31,7 @@ bool NzDeferredFXAAPass::Process(const NzScene* scene, unsigned int firstWorkTex
 	NzRenderer::SetViewport(NzRecti(0, 0, m_dimensions.x, m_dimensions.y));
 
 	NzRenderer::SetRenderStates(m_states);
-	NzRenderer::SetShaderProgram(m_fxaaProgram);
+	NzRenderer::SetShader(m_fxaaShader);
 	NzRenderer::SetTexture(0, m_workTextures[secondWorkTexture]);
 	NzRenderer::SetTextureSampler(0, m_pointSampler);
 	NzRenderer::DrawFullscreenQuad();

src/Nazara/Graphics/DeferredFinalPass.cpp

@@ -6,64 +6,30 @@
 #include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Graphics/Scene.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
-#include <Nazara/Renderer/RenderTexture.hpp>
+#include <Nazara/Renderer/UberShaderLibrary.hpp>
 #include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
-namespace
-{
-	NzShaderProgram* BuildBlitProgram()
-	{
-		const nzUInt8 fragmentSource[] = {
-			#include <Nazara/Graphics/Resources/DeferredShading/Shaders/Blit.frag.h>
-		};
-
-		const char* vertexSource =
-		"#version 140\n"
-
-		"in vec3 VertexPosition;\n"
-
-		"void main()\n"
-		"{\n"
-		"\t" "gl_Position = vec4(VertexPosition, 1.0);" "\n"
-		"}\n";
-
-		///TODO: Remplacer ça par des ShaderNode
-		std::unique_ptr<NzShaderProgram> program(new NzShaderProgram(nzShaderLanguage_GLSL));
-		program->SetPersistent(false);
-
-		if (!program->LoadShader(nzShaderType_Fragment, NzString(reinterpret_cast<const char*>(fragmentSource), sizeof(fragmentSource))))
-		{
-			NazaraError("Failed to load fragment shader");
-			return nullptr;
-		}
-
-		if (!program->LoadShader(nzShaderType_Vertex, vertexSource))
-		{
-			NazaraError("Failed to load vertex shader");
-			return nullptr;
-		}
-
-		if (!program->Compile())
-		{
-			NazaraError("Failed to compile program");
-			return nullptr;
-		}
-
-		return program.release();
-	}
-}
-
 NzDeferredFinalPass::NzDeferredFinalPass()
 {
-	m_program = BuildBlitProgram();
-	m_program->SendInteger(m_program->GetUniformLocation("ColorTexture"), 0);
-
 	m_pointSampler.SetAnisotropyLevel(1);
 	m_pointSampler.SetFilterMode(nzSamplerFilter_Nearest);
 	m_pointSampler.SetWrapMode(nzSamplerWrap_Clamp);
 
 	m_states.parameters[nzRendererParameter_DepthBuffer] = false;
+
+	m_uberShader = NzUberShaderLibrary::Get("Basic");
+
+	NzParameterList list;
+	list.SetParameter("AUTO_TEXCOORDS", true);
+	list.SetParameter("DIFFUSE_MAPPING", true);
+	list.SetParameter("TEXTURE_MAPPING", false);
+
+	m_uberShaderInstance = m_uberShader->Get(list);
+
+	const NzShader* shader = m_uberShaderInstance->GetShader();
+	m_materialDiffuseUniform = shader->GetUniformLocation("MaterialDiffuse");
+	m_materialDiffuseMapUniform = shader->GetUniformLocation("MaterialDiffuseMap");
 }
 
 NzDeferredFinalPass::~NzDeferredFinalPass() = default;
@@ -75,10 +41,15 @@ bool NzDeferredFinalPass::Process(const NzScene* scene, unsigned int firstWorkTe
 	scene->GetViewer()->ApplyView();
 
 	NzRenderer::SetRenderStates(m_states);
-	NzRenderer::SetShaderProgram(m_program);
 	NzRenderer::SetTexture(0, m_workTextures[secondWorkTexture]);
 	NzRenderer::SetTextureSampler(0, m_pointSampler);
 
+	m_uberShaderInstance->Activate();
+
+	const NzShader* shader = m_uberShaderInstance->GetShader();
+	shader->SendColor(m_materialDiffuseUniform, NzColor::White);
+	shader->SendInteger(m_materialDiffuseMapUniform, 0);
+
 	NzRenderer::DrawFullscreenQuad();
 
 	return false;

src/Nazara/Graphics/DeferredFogPass.cpp

@@ -12,7 +12,7 @@
 
 namespace
 {
-	NzShaderProgram* BuildFogProgram()
+	NzShader* BuildFogShader()
 	{
 		/*const nzUInt8 fragmentSource[] = {
 				#include <Nazara/Graphics/Resources/DeferredShading/Shaders/FXAA.frag.h>
@@ -84,41 +84,48 @@ namespace
 		"}\n";
 
 		///TODO: Remplacer ça par des ShaderNode
-		std::unique_ptr<NzShaderProgram> program(new NzShaderProgram(nzShaderLanguage_GLSL));
-		program->SetPersistent(false);
+		std::unique_ptr<NzShader> shader(new NzShader);
+		shader->SetPersistent(false);
 
-		if (!program->LoadShader(nzShaderType_Fragment, fragmentSource/*NzString(reinterpret_cast<const char*>(fragmentSource), sizeof(fragmentSource))*/))
+		if (!shader->Create())
+		{
+				NazaraError("Failed to load create shader");
+				return nullptr;
+		}
+
+		if (!shader->AttachStageFromSource(nzShaderStage_Fragment, fragmentSource/*NzString(reinterpret_cast<const char*>(fragmentSource), sizeof(fragmentSource))*/))
 		{
 				NazaraError("Failed to load fragment shader");
 				return nullptr;
 		}
 
-		if (!program->LoadShader(nzShaderType_Vertex, vertexSource))
+		if (!shader->AttachStageFromSource(nzShaderStage_Vertex, vertexSource))
 		{
 				NazaraError("Failed to load vertex shader");
 				return nullptr;
 		}
 
-		if (!program->Compile())
+		if (!shader->Link())
 		{
-				NazaraError("Failed to compile program");
+				NazaraError("Failed to link shader");
 				return nullptr;
 		}
 
-		return program.release();
+		shader->SendInteger(shader->GetUniformLocation("ColorTexture"), 0);
+		shader->SendInteger(shader->GetUniformLocation("GBuffer2"), 1);
+
+		return shader.release();
 	}
 }
 
 NzDeferredFogPass::NzDeferredFogPass()
 {
-	m_program = BuildFogProgram();
-	m_program->SendInteger(m_program->GetUniformLocation("ColorTexture"), 0);
-	m_program->SendInteger(m_program->GetUniformLocation("GBuffer2"), 1);
-
 	m_pointSampler.SetAnisotropyLevel(1);
 	m_pointSampler.SetFilterMode(nzSamplerFilter_Nearest);
 	m_pointSampler.SetWrapMode(nzSamplerWrap_Clamp);
 
+	m_shader = BuildFogShader();
+
 	m_states.parameters[nzRendererParameter_DepthBuffer] = false;
 }
 
@@ -130,8 +137,8 @@ bool NzDeferredFogPass::Process(const NzScene* scene, unsigned int firstWorkText
 	NzRenderer::SetTarget(m_workRTT);
 	NzRenderer::SetViewport(NzRecti(0, 0, m_dimensions.x, m_dimensions.y));
 
-	NzRenderer::SetShaderProgram(m_program);
-	m_program->SendVector(m_program->GetUniformLocation(nzShaderUniform_EyePosition), scene->GetViewer()->GetEyePosition());
+	NzRenderer::SetShader(m_shader);
+	m_shader->SendVector(m_shader->GetUniformLocation(nzShaderUniform_EyePosition), scene->GetViewer()->GetEyePosition());
 
 	NzRenderer::SetRenderStates(m_states);
 	NzRenderer::SetTexture(0, m_workTextures[secondWorkTexture]);

src/Nazara/Graphics/DeferredGeometryPass.cpp

@@ -6,63 +6,20 @@
 #include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Graphics/DeferredRenderTechnique.hpp>
+#include <Nazara/Graphics/Material.hpp>
 #include <Nazara/Graphics/Scene.hpp>
-#include <Nazara/Renderer/Material.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
+#include <Nazara/Renderer/ShaderLibrary.hpp>
 #include <Nazara/Utility/BufferMapper.hpp>
 #include <Nazara/Utility/StaticMesh.hpp>
 #include <Nazara/Utility/VertexStruct.hpp>
 #include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
-namespace
-{
-	NzShaderProgram* BuildClearProgram()
-	{
-		const nzUInt8 fragmentSource[] = {
-			#include <Nazara/Graphics/Resources/DeferredShading/Shaders/ClearGBuffer.frag.h>
-		};
-
-		const char* vertexSource =
-		"#version 140\n"
-
-		"in vec2 VertexPosition;\n"
-
-		"void main()\n"
-		"{\n"
-		"\t" "gl_Position = vec4(VertexPosition, 0.0, 1.0);" "\n"
-		"}\n";
-
-		///TODO: Remplacer ça par des ShaderNode
-		std::unique_ptr<NzShaderProgram> program(new NzShaderProgram(nzShaderLanguage_GLSL));
-		program->SetPersistent(false);
-
-		if (!program->LoadShader(nzShaderType_Fragment, NzString(reinterpret_cast<const char*>(fragmentSource), sizeof(fragmentSource))))
-		{
-			NazaraError("Failed to load fragment shader");
-			return nullptr;
-		}
-
-		if (!program->LoadShader(nzShaderType_Vertex, vertexSource))
-		{
-			NazaraError("Failed to load vertex shader");
-			return nullptr;
-		}
-
-		if (!program->Compile())
-		{
-			NazaraError("Failed to compile program");
-			return nullptr;
-		}
-
-		return program.release();
-	}
-}
-
 NzDeferredGeometryPass::NzDeferredGeometryPass()
 {
-	m_clearProgram = BuildClearProgram();
+	m_clearShader = NzShaderLibrary::Get("DeferredGBufferClear");
 	m_clearStates.parameters[nzRendererParameter_DepthBuffer] = true;
 	m_clearStates.parameters[nzRendererParameter_FaceCulling] = true;
 	m_clearStates.parameters[nzRendererParameter_StencilTest] = true;
@@ -86,14 +43,14 @@ bool NzDeferredGeometryPass::Process(const NzScene* scene, unsigned int firstWor
 	NzRenderer::SetViewport(NzRecti(0, 0, m_dimensions.x, m_dimensions.y));
 
 	NzRenderer::SetRenderStates(m_clearStates);
-	NzRenderer::SetShaderProgram(m_clearProgram);
+	NzRenderer::SetShader(m_clearShader);
 	NzRenderer::DrawFullscreenQuad();
 
 
 	NzRenderer::SetMatrix(nzMatrixType_Projection, viewer->GetProjectionMatrix());
 	NzRenderer::SetMatrix(nzMatrixType_View, viewer->GetViewMatrix());
 
-	const NzShaderProgram* lastProgram = nullptr;
+	const NzShader* lastShader = nullptr;
 
 	for (auto& matIt : m_renderQueue->opaqueModels)
 	{
@@ -118,23 +75,19 @@ bool NzDeferredGeometryPass::Process(const NzScene* scene, unsigned int firstWor
 				if (useInstancing)
 					flags |= nzShaderFlags_Instancing;
 
-				const NzShaderProgram* program = material->GetShaderProgram(nzShaderTarget_Model, flags);
+				const NzShader* shader = material->Apply(flags);
 
 				// Les uniformes sont conservées au sein d'un programme, inutile de les renvoyer tant qu'il ne change pas
-				if (program != lastProgram)
+				if (shader != lastShader)
 				{
-					NzRenderer::SetShaderProgram(program);
-
 					// Couleur ambiante de la scène
-					program->SendColor(program->GetUniformLocation(nzShaderUniform_SceneAmbient), scene->GetAmbientColor());
+					shader->SendColor(shader->GetUniformLocation(nzShaderUniform_SceneAmbient), scene->GetAmbientColor());
 					// Position de la caméra
-					program->SendVector(program->GetUniformLocation(nzShaderUniform_EyePosition), viewer->GetEyePosition());
+					shader->SendVector(shader->GetUniformLocation(nzShaderUniform_EyePosition), viewer->GetEyePosition());
 
-					lastProgram = program;
+					lastShader = shader;
 				}
 
-				material->Apply(program);
-
 				// Meshs squelettiques
 				/*if (!skeletalContainer.empty())
 				{

src/Nazara/Graphics/DeferredPhongLightingPass.cpp

@@ -5,119 +5,37 @@
 #include <Nazara/Graphics/DeferredPhongLightingPass.hpp>
 #include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Graphics/DeferredRenderQueue.hpp>
-#include <Nazara/Graphics/Light.hpp>
 #include <Nazara/Graphics/Scene.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/RenderTexture.hpp>
-#include <Nazara/Renderer/ShaderProgramManager.hpp>
+#include <Nazara/Renderer/ShaderLibrary.hpp>
 #include <Nazara/Utility/StaticMesh.hpp>
 #include <memory>
-#include <Nazara/Renderer/OpenGL.hpp> // Supprimer
 #include <Nazara/Graphics/Debug.hpp>
 
-namespace
-{
-	NzShaderProgram* BuildDirectionalLightProgram()
-	{
-		const nzUInt8 fragmentSource[] = {
-			#include <Nazara/Graphics/Resources/DeferredShading/Shaders/DirectionalLight.frag.h>
-		};
-
-		const char* vertexSource =
-		"#version 140\n"
-
-		"in vec2 VertexPosition;\n"
-
-		"void main()\n"
-		"{\n"
-		"\t" "gl_Position = vec4(VertexPosition, 0.0, 1.0);" "\n"
-		"}\n";
-
-		///TODO: Remplacer ça par des ShaderNode
-		std::unique_ptr<NzShaderProgram> program(new NzShaderProgram(nzShaderLanguage_GLSL));
-		program->SetPersistent(false);
-
-		if (!program->LoadShader(nzShaderType_Fragment, NzString(reinterpret_cast<const char*>(fragmentSource), sizeof(fragmentSource))))
-		{
-			NazaraError("Failed to load fragment shader");
-			return nullptr;
-		}
-
-		if (!program->LoadShader(nzShaderType_Vertex, vertexSource))
-		{
-			NazaraError("Failed to load vertex shader");
-			return nullptr;
-		}
-
-		if (!program->Compile())
-		{
-			NazaraError("Failed to compile program");
-			return nullptr;
-		}
-
-		program->SendInteger(program->GetUniformLocation("GBuffer0"), 0);
-		program->SendInteger(program->GetUniformLocation("GBuffer1"), 1);
-		program->SendInteger(program->GetUniformLocation("GBuffer2"), 2);
-
-		return program.release();
-	}
-
-	NzShaderProgram* BuildPointSpotLightProgram()
-	{
-		const nzUInt8 fragmentSource[] = {
-			#include <Nazara/Graphics/Resources/DeferredShading/Shaders/PointSpotLight.frag.h>
-		};
-
-		const char* vertexSource =
-		"#version 140\n"
-
-		"in vec3 VertexPosition;\n"
-
-		"uniform mat4 WorldViewProjMatrix;\n"
-
-		"void main()\n"
-		"{\n"
-		"\t" "gl_Position = WorldViewProjMatrix * vec4(VertexPosition, 1.0);" "\n"
-		"}\n";
-
-		///TODO: Remplacer ça par des ShaderNode
-		std::unique_ptr<NzShaderProgram> program(new NzShaderProgram(nzShaderLanguage_GLSL));
-		program->SetPersistent(false);
-
-		if (!program->LoadShader(nzShaderType_Fragment, NzString(reinterpret_cast<const char*>(fragmentSource), sizeof(fragmentSource))))
-		{
-			NazaraError("Failed to load fragment shader");
-			return nullptr;
-		}
-
-		if (!program->LoadShader(nzShaderType_Vertex, vertexSource))
-		{
-			NazaraError("Failed to load vertex shader");
-			return nullptr;
-		}
-
-		if (!program->Compile())
-		{
-			NazaraError("Failed to compile program");
-			return nullptr;
-		}
-
-		program->SendInteger(program->GetUniformLocation("GBuffer0"), 0);
-		program->SendInteger(program->GetUniformLocation("GBuffer1"), 1);
-		program->SendInteger(program->GetUniformLocation("GBuffer2"), 2);
-
-		return program.release();
-	}
-}
-
 NzDeferredPhongLightingPass::NzDeferredPhongLightingPass() :
 m_lightMeshesDrawing(false)
 {
-	m_directionalLightProgram = BuildDirectionalLightProgram();
-	m_pointSpotLightProgram = BuildPointSpotLightProgram();
+	m_directionalLightShader = NzShaderLibrary::Get("DeferredDirectionnalLight");
 
-	m_pointSpotLightProgramDiscardLocation = m_pointSpotLightProgram->GetUniformLocation("Discard");
-	m_pointSpotLightProgramSpotLightLocation = m_pointSpotLightProgram->GetUniformLocation("SpotLight");
+	m_directionalLightUniforms.ubo = false;
+	m_directionalLightUniforms.locations.type = -1; // Type déjà connu
+	m_directionalLightUniforms.locations.color = m_directionalLightShader->GetUniformLocation("LightColor");
+	m_directionalLightUniforms.locations.factors = m_directionalLightShader->GetUniformLocation("LightFactors");
+	m_directionalLightUniforms.locations.parameters1 = m_directionalLightShader->GetUniformLocation("LightDirection");
+	m_directionalLightUniforms.locations.parameters2 = -1;
+	m_directionalLightUniforms.locations.parameters3 = -1;
+
+	m_pointSpotLightShader = NzShaderLibrary::Get("DeferredPointSpotLight");
+	m_pointSpotLightShaderDiscardLocation = m_pointSpotLightShader->GetUniformLocation("Discard");
+
+	m_pointSpotLightUniforms.ubo = false;
+	m_pointSpotLightUniforms.locations.type = m_pointSpotLightShader->GetUniformLocation("LightType");
+	m_pointSpotLightUniforms.locations.color = m_pointSpotLightShader->GetUniformLocation("LightColor");
+	m_pointSpotLightUniforms.locations.factors = m_pointSpotLightShader->GetUniformLocation("LightFactors");
+	m_pointSpotLightUniforms.locations.parameters1 = m_pointSpotLightShader->GetUniformLocation("LightParameters1");
+	m_pointSpotLightUniforms.locations.parameters2 = m_pointSpotLightShader->GetUniformLocation("LightParameters2");
+	m_pointSpotLightUniforms.locations.parameters3 = m_pointSpotLightShader->GetUniformLocation("LightParameters3");
 
 	m_pointSampler.SetAnisotropyLevel(1);
 	m_pointSampler.SetFilterMode(nzSamplerFilter_Nearest);
@@ -177,13 +95,13 @@ bool NzDeferredPhongLightingPass::Process(const NzScene* scene, unsigned int fir
 	if (!m_renderQueue->directionalLights.empty())
 	{
 		NzRenderer::SetRenderStates(lightStates);
-		NzRenderer::SetShaderProgram(m_directionalLightProgram);
-		m_directionalLightProgram->SendColor(m_directionalLightProgram->GetUniformLocation(nzShaderUniform_SceneAmbient), scene->GetAmbientColor());
-		m_directionalLightProgram->SendVector(m_directionalLightProgram->GetUniformLocation(nzShaderUniform_EyePosition), scene->GetViewer()->GetEyePosition());
+		NzRenderer::SetShader(m_directionalLightShader);
+		m_directionalLightShader->SendColor(m_directionalLightShader->GetUniformLocation(nzShaderUniform_SceneAmbient), scene->GetAmbientColor());
+		m_directionalLightShader->SendVector(m_directionalLightShader->GetUniformLocation(nzShaderUniform_EyePosition), scene->GetViewer()->GetEyePosition());
 
 		for (const NzLight* light : m_renderQueue->directionalLights)
 		{
-			light->Enable(m_directionalLightProgram, 0);
+			light->Enable(m_directionalLightShader, m_directionalLightUniforms);
 			NzRenderer::DrawFullscreenQuad();
 		}
 	}
@@ -207,23 +125,21 @@ bool NzDeferredPhongLightingPass::Process(const NzScene* scene, unsigned int fir
 
 		NzRenderer::SetRenderStates(lightStates);
 
-		NzRenderer::SetShaderProgram(m_pointSpotLightProgram);
-		m_pointSpotLightProgram->SendColor(m_pointSpotLightProgram->GetUniformLocation(nzShaderUniform_SceneAmbient), scene->GetAmbientColor());
-		m_pointSpotLightProgram->SendVector(m_pointSpotLightProgram->GetUniformLocation(nzShaderUniform_EyePosition), scene->GetViewer()->GetEyePosition());
+		NzRenderer::SetShader(m_pointSpotLightShader);
+		m_pointSpotLightShader->SendColor(m_pointSpotLightShader->GetUniformLocation(nzShaderUniform_SceneAmbient), scene->GetAmbientColor());
+		m_pointSpotLightShader->SendVector(m_pointSpotLightShader->GetUniformLocation(nzShaderUniform_EyePosition), scene->GetViewer()->GetEyePosition());
 
 		NzMatrix4f lightMatrix;
 		lightMatrix.MakeIdentity();
 		if (!m_renderQueue->pointLights.empty())
 		{
-			m_pointSpotLightProgram->SendBoolean(m_pointSpotLightProgramSpotLightLocation, false);
-
 			const NzIndexBuffer* indexBuffer = m_sphereMesh->GetIndexBuffer();
 			NzRenderer::SetIndexBuffer(indexBuffer);
 			NzRenderer::SetVertexBuffer(m_sphereMesh->GetVertexBuffer());
 
 			for (const NzLight* light : m_renderQueue->pointLights)
 			{
-				light->Enable(m_pointSpotLightProgram, 0);
+				light->Enable(m_pointSpotLightShader, m_pointSpotLightUniforms);
 				lightMatrix.SetScale(NzVector3f(light->GetRadius()*1.1f)); // Pour corriger les imperfections liées à la sphère
 				lightMatrix.SetTranslation(light->GetPosition());
 
@@ -235,7 +151,7 @@ bool NzDeferredPhongLightingPass::Process(const NzScene* scene, unsigned int fir
 				NzRenderer::Enable(nzRendererParameter_FaceCulling, false);
 				NzRenderer::SetStencilCompareFunction(nzRendererComparison_Always);
 
-				m_pointSpotLightProgram->SendBoolean(m_pointSpotLightProgramDiscardLocation, true);
+				m_pointSpotLightShader->SendBoolean(m_pointSpotLightShaderDiscardLocation, true);
 
 				NzRenderer::DrawIndexedPrimitives(nzPrimitiveMode_TriangleList, 0, indexBuffer->GetIndexCount());
 
@@ -246,7 +162,7 @@ bool NzDeferredPhongLightingPass::Process(const NzScene* scene, unsigned int fir
 				NzRenderer::SetStencilCompareFunction(nzRendererComparison_NotEqual, nzFaceSide_Back);
 				NzRenderer::SetStencilPassOperation(nzStencilOperation_Zero, nzFaceSide_Back);
 
-				m_pointSpotLightProgram->SendBoolean(m_pointSpotLightProgramDiscardLocation, false);
+				m_pointSpotLightShader->SendBoolean(m_pointSpotLightShaderDiscardLocation, false);
 
 				NzRenderer::DrawIndexedPrimitives(nzPrimitiveMode_TriangleList, 0, indexBuffer->GetIndexCount());
 			}
@@ -259,20 +175,8 @@ bool NzDeferredPhongLightingPass::Process(const NzScene* scene, unsigned int fir
 				NzRenderer::Enable(nzRendererParameter_StencilTest, false);
 				NzRenderer::SetFaceFilling(nzFaceFilling_Line);
 
-				NzShaderProgramManagerParams params;
-				params.flags = nzShaderFlags_None;
-				params.target = nzShaderTarget_Model;
-				params.model.alphaMapping = false;
-				params.model.alphaTest = false;
-				params.model.diffuseMapping = false;
-				params.model.emissiveMapping = false;
-				params.model.lighting = false;
-				params.model.normalMapping = false;
-				params.model.parallaxMapping = false;
-				params.model.specularMapping = false;
-
-				const NzShaderProgram* program = NzShaderProgramManager::Get(params);
-				NzRenderer::SetShaderProgram(program);
+				const NzShader* shader = NzShaderLibrary::Get("DebugSimple");
+				NzRenderer::SetShader(shader);
 				for (const NzLight* light : m_renderQueue->pointLights)
 				{
 					lightMatrix.SetScale(NzVector3f(light->GetRadius()*1.1f)); // Pour corriger les imperfections liées à la sphère
@@ -280,7 +184,7 @@ bool NzDeferredPhongLightingPass::Process(const NzScene* scene, unsigned int fir
 
 					NzRenderer::SetMatrix(nzMatrixType_World, lightMatrix);
 
-					program->SendColor(program->GetUniformLocation(nzShaderUniform_MaterialDiffuse), light->GetColor());
+					shader->SendColor(0, light->GetColor());
 
 					NzRenderer::DrawIndexedPrimitives(nzPrimitiveMode_TriangleList, 0, indexBuffer->GetIndexCount());
 				}
@@ -295,15 +199,13 @@ bool NzDeferredPhongLightingPass::Process(const NzScene* scene, unsigned int fir
 
 		if (!m_renderQueue->spotLights.empty())
 		{
-			m_pointSpotLightProgram->SendBoolean(m_pointSpotLightProgramSpotLightLocation, true);
-
 			const NzIndexBuffer* indexBuffer = m_coneMesh->GetIndexBuffer();
 			NzRenderer::SetIndexBuffer(indexBuffer);
 			NzRenderer::SetVertexBuffer(m_coneMesh->GetVertexBuffer());
 
 			for (const NzLight* light : m_renderQueue->spotLights)
 			{
-				light->Enable(m_pointSpotLightProgram, 0);
+				light->Enable(m_pointSpotLightShader, m_pointSpotLightUniforms);
 				float radius = light->GetRadius()*std::tan(NzDegreeToRadian(light->GetOuterAngle()))*1.1f;
 				lightMatrix.MakeTransform(light->GetPosition(), light->GetRotation(), NzVector3f(radius, radius, light->GetRadius()));
 
@@ -315,7 +217,7 @@ bool NzDeferredPhongLightingPass::Process(const NzScene* scene, unsigned int fir
 				NzRenderer::Enable(nzRendererParameter_FaceCulling, false);
 				NzRenderer::SetStencilCompareFunction(nzRendererComparison_Always);
 
-				m_pointSpotLightProgram->SendBoolean(m_pointSpotLightProgramDiscardLocation, true);
+				m_pointSpotLightShader->SendBoolean(m_pointSpotLightShaderDiscardLocation, true);
 
 				NzRenderer::DrawIndexedPrimitives(nzPrimitiveMode_TriangleList, 0, indexBuffer->GetIndexCount());
 
@@ -327,7 +229,7 @@ bool NzDeferredPhongLightingPass::Process(const NzScene* scene, unsigned int fir
 				NzRenderer::SetStencilCompareFunction(nzRendererComparison_NotEqual, nzFaceSide_Back);
 				NzRenderer::SetStencilPassOperation(nzStencilOperation_Zero, nzFaceSide_Back);
 
-				m_pointSpotLightProgram->SendBoolean(m_pointSpotLightProgramDiscardLocation, false);
+				m_pointSpotLightShader->SendBoolean(m_pointSpotLightShaderDiscardLocation, false);
 
 				NzRenderer::DrawIndexedPrimitives(nzPrimitiveMode_TriangleList, 0, indexBuffer->GetIndexCount());
 			}
@@ -340,20 +242,8 @@ bool NzDeferredPhongLightingPass::Process(const NzScene* scene, unsigned int fir
 				NzRenderer::Enable(nzRendererParameter_StencilTest, false);
 				NzRenderer::SetFaceFilling(nzFaceFilling_Line);
 
-				NzShaderProgramManagerParams params;
-				params.flags = nzShaderFlags_None;
-				params.target = nzShaderTarget_Model;
-				params.model.alphaMapping = false;
-				params.model.alphaTest = false;
-				params.model.diffuseMapping = false;
-				params.model.emissiveMapping = false;
-				params.model.lighting = false;
-				params.model.normalMapping = false;
-				params.model.parallaxMapping = false;
-				params.model.specularMapping = false;
-
-				const NzShaderProgram* program = NzShaderProgramManager::Get(params);
-				NzRenderer::SetShaderProgram(program);
+				const NzShader* shader = NzShaderLibrary::Get("DebugSimple");
+				NzRenderer::SetShader(shader);
 				for (const NzLight* light : m_renderQueue->spotLights)
 				{
 					float baseRadius = light->GetRadius()*std::tan(NzDegreeToRadian(light->GetOuterAngle()))*1.1f;
@@ -361,7 +251,7 @@ bool NzDeferredPhongLightingPass::Process(const NzScene* scene, unsigned int fir
 
 					NzRenderer::SetMatrix(nzMatrixType_World, lightMatrix);
 
-					program->SendColor(program->GetUniformLocation(nzShaderUniform_MaterialDiffuse), light->GetColor());
+					shader->SendColor(0, light->GetColor());
 
 					NzRenderer::DrawIndexedPrimitives(nzPrimitiveMode_TriangleList, 0, indexBuffer->GetIndexCount());
 				}

src/Nazara/Graphics/DeferredRenderQueue.cpp

@@ -6,9 +6,9 @@
 #include <Nazara/Graphics/Camera.hpp>
 #include <Nazara/Graphics/ForwardRenderQueue.hpp>
 #include <Nazara/Graphics/Light.hpp>
+#include <Nazara/Graphics/Material.hpp>
 #include <Nazara/Graphics/Model.hpp>
 #include <Nazara/Graphics/Sprite.hpp>
-#include <Nazara/Renderer/Material.hpp>
 #include <Nazara/Utility/SkeletalMesh.hpp>
 #include <Nazara/Utility/StaticMesh.hpp>
 #include <Nazara/Graphics/Debug.hpp>
@@ -252,19 +252,16 @@ void NzDeferredRenderQueue::OnResourceReleased(const NzResource* resource, int i
 
 bool NzDeferredRenderQueue::BatchedModelMaterialComparator::operator()(const NzMaterial* mat1, const NzMaterial* mat2)
 {
-	nzUInt32 possibleFlags[] = {
-		nzShaderFlags_Deferred,
-		nzShaderFlags_Deferred | nzShaderFlags_Instancing
-	};
+	const NzUberShader* uberShader1 = mat1->GetShader();
+	const NzUberShader* uberShader2 = mat2->GetShader();
+	if (uberShader1 != uberShader2)
+		return uberShader1 < uberShader2;
 
-	for (nzUInt32 flag : possibleFlags)
-	{
-		const NzShaderProgram* program1 = mat1->GetShaderProgram(nzShaderTarget_Model, flag);
-		const NzShaderProgram* program2 = mat2->GetShaderProgram(nzShaderTarget_Model, flag);
+	const NzShader* shader1 = mat1->GetShaderInstance(nzShaderFlags_Deferred)->GetShader();
+	const NzShader* shader2 = mat2->GetShaderInstance(nzShaderFlags_Deferred)->GetShader();
 
-		if (program1 != program2)
-			return program1 < program2;
-	}
+	if (shader1 != shader2)
+		return shader1 < shader2;
 
 	const NzTexture* diffuseMap1 = mat1->GetDiffuseMap();
 	const NzTexture* diffuseMap2 = mat2->GetDiffuseMap();
@@ -276,18 +273,16 @@ bool NzDeferredRenderQueue::BatchedModelMaterialComparator::operator()(const NzM
 
 bool NzDeferredRenderQueue::BatchedSpriteMaterialComparator::operator()(const NzMaterial* mat1, const NzMaterial* mat2)
 {
-	nzUInt32 possibleFlags[] = {
-		nzShaderFlags_Deferred
-	};
+	const NzUberShader* uberShader1 = mat1->GetShader();
+	const NzUberShader* uberShader2 = mat2->GetShader();
+	if (uberShader1 != uberShader2)
+		return uberShader1 < uberShader2;
 
-	for (nzUInt32 flag : possibleFlags)
-	{
-		const NzShaderProgram* program1 = mat1->GetShaderProgram(nzShaderTarget_Model, flag);
-		const NzShaderProgram* program2 = mat2->GetShaderProgram(nzShaderTarget_Model, flag);
+	const NzShader* shader1 = mat1->GetShaderInstance(nzShaderFlags_Deferred)->GetShader();
+	const NzShader* shader2 = mat2->GetShaderInstance(nzShaderFlags_Deferred)->GetShader();
 
-		if (program1 != program2)
-			return program1 < program2;
-	}
+	if (shader1 != shader2)
+		return shader1 < shader2;
 
 	const NzTexture* diffuseMap1 = mat1->GetDiffuseMap();
 	const NzTexture* diffuseMap2 = mat2->GetDiffuseMap();

src/Nazara/Graphics/DeferredRenderTechnique.cpp

@@ -2,6 +2,10 @@
 // This file is part of the "Nazara Engine - Graphics module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
+#ifndef NAZARA_RENDERER_OPENGL
+#define NAZARA_RENDERER_OPENGL // Nécessaire pour inclure les headers OpenGL
+#endif
+
 #include <Nazara/Graphics/DeferredRenderTechnique.hpp>
 #include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Graphics/AbstractBackground.hpp>
@@ -16,12 +20,14 @@
 #include <Nazara/Graphics/DeferredPhongLightingPass.hpp>
 #include <Nazara/Graphics/Drawable.hpp>
 #include <Nazara/Graphics/Light.hpp>
+#include <Nazara/Graphics/Material.hpp>
 #include <Nazara/Graphics/Sprite.hpp>
 #include <Nazara/Renderer/Config.hpp>
-#include <Nazara/Renderer/Material.hpp>
 #include <Nazara/Renderer/OpenGL.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
-#include <Nazara/Renderer/ShaderProgramManager.hpp>
+#include <Nazara/Renderer/Shader.hpp>
+#include <Nazara/Renderer/ShaderLibrary.hpp>
+#include <Nazara/Renderer/ShaderStage.hpp>
 #include <limits>
 #include <memory>
 #include <random>
@@ -43,6 +49,37 @@ namespace
 	};
 
 	static_assert(sizeof(RenderPassPriority)/sizeof(unsigned int) == nzRenderPassType_Max+1, "Render pass priority array is incomplete");
+
+	inline NzShader* RegisterDeferredShader(const NzString& name, const nzUInt8* fragmentSource, unsigned int fragmentSourceLength, const NzShaderStage& vertexStage, NzString* err)
+	{
+		NzErrorFlags errFlags(nzErrorFlag_ThrowExceptionDisabled);
+
+		std::unique_ptr<NzShader> shader(new NzShader);
+		shader->SetPersistent(false);
+
+		if (!shader->Create())
+		{
+			err->Set("Failed to create shader");
+			return nullptr;
+		}
+
+		if (!shader->AttachStageFromSource(nzShaderStage_Fragment, reinterpret_cast<const char*>(fragmentSource), fragmentSourceLength))
+		{
+			err->Set("Failed to attach fragment stage");
+			return nullptr;
+		}
+
+		shader->AttachStage(nzShaderStage_Vertex, vertexStage);
+
+		if (!shader->Link())
+		{
+			err->Set("Failed to link shader");
+			return nullptr;
+		}
+
+		NzShaderLibrary::Register(name, shader.get());
+		return shader.release();
+	}
 }
 
 NzDeferredRenderTechnique::NzDeferredRenderTechnique() :
@@ -67,7 +104,6 @@ m_GBufferSize(0U)
 	try
 	{
 		NzErrorFlags errFlags(nzErrorFlag_ThrowException);
-		std::unique_ptr<NzDeferredRenderPass> smartPtr; // Nous évite un leak en cas d'exception
 
 		ResetPass(nzRenderPassType_Final, 0);
 		ResetPass(nzRenderPassType_Geometry, 0);
@@ -343,14 +379,186 @@ void NzDeferredRenderTechnique::SetPass(nzRenderPassType relativeTo, int positio
 		m_passes[relativeTo].erase(position);
 }
 
+bool NzDeferredRenderTechnique::Initialize()
+{
+	const nzUInt8 fragmentSource_BloomBright[] = {
+		#include <Nazara/Graphics/Resources/DeferredShading/Shaders/BloomBright.frag.h>
+	};
+
+	const nzUInt8 fragmentSource_BloomFinal[] = {
+		#include <Nazara/Graphics/Resources/DeferredShading/Shaders/BloomFinal.frag.h>
+	};
+
+	const nzUInt8 fragmentSource_DirectionalLight[] = {
+		#include <Nazara/Graphics/Resources/DeferredShading/Shaders/DirectionalLight.frag.h>
+	};
+
+	const nzUInt8 fragmentSource_FXAA[] = {
+		#include <Nazara/Graphics/Resources/DeferredShading/Shaders/FXAA.frag.h>
+	};
+
+	const nzUInt8 fragmentSource_GBufferClear[] = {
+		#include <Nazara/Graphics/Resources/DeferredShading/Shaders/GBufferClear.frag.h>
+	};
+
+	const nzUInt8 fragmentSource_GaussianBlur[] = {
+		#include <Nazara/Graphics/Resources/DeferredShading/Shaders/GaussianBlur.frag.h>
+	};
+
+	const nzUInt8 fragmentSource_PointSpotLight[] = {
+		#include <Nazara/Graphics/Resources/DeferredShading/Shaders/PointSpotLight.frag.h>
+	};
+
+	const char vertexSource_Basic[] =
+	"#version 140\n"
+
+	"in vec3 VertexPosition;\n"
+	"uniform mat4 WorldViewProjMatrix;\n"
+
+	"void main()\n"
+	"{\n"
+		"gl_Position = WorldViewProjMatrix * vec4(VertexPosition, 1.0);\n"
+	"}\n";
+
+	const char vertexSource_PostProcess[] =
+	"#version 140\n"
+
+	"in vec3 VertexPosition;\n"
+
+	"void main()\n"
+	"{\n"
+		"gl_Position = vec4(VertexPosition, 1.0);"
+	"}\n";
+
+	NzShaderStage basicVertexStage(nzShaderStage_Vertex);
+	if (!basicVertexStage.IsValid())
+	{
+		NazaraError("Failed to create basic vertex shader");
+		return false;
+	}
+
+	basicVertexStage.SetSource(vertexSource_Basic, sizeof(vertexSource_Basic));
+
+	if (!basicVertexStage.Compile())
+	{
+		NazaraError("Failed to compile basic vertex shader");
+		return false;
+	}
+
+
+	NzShaderStage ppVertexStage(nzShaderStage_Vertex);
+	if (!ppVertexStage.IsValid())
+	{
+		NazaraError("Failed to create vertex shader");
+		return false;
+	}
+
+	ppVertexStage.SetSource(vertexSource_PostProcess, sizeof(vertexSource_PostProcess));
+
+	if (!ppVertexStage.Compile())
+	{
+		NazaraError("Failed to compile vertex shader");
+		return false;
+	}
+
+
+	NzString error;
+	NzShader* shader;
+
+	// Shaders critiques (Nécessaires pour le Deferred Shading minimal)
+	shader = RegisterDeferredShader("DeferredGBufferClear", fragmentSource_GBufferClear, sizeof(fragmentSource_GBufferClear), ppVertexStage, &error);
+	if (!shader)
+	{
+		NazaraError("Failed to register critical shader: " + error);
+		return false;
+	}
+
+
+	shader = RegisterDeferredShader("DeferredDirectionnalLight", fragmentSource_DirectionalLight, sizeof(fragmentSource_DirectionalLight), ppVertexStage, &error);
+	if (!shader)
+	{
+		NazaraError("Failed to register critical shader: " + error);
+		return false;
+	}
+
+	shader->SendInteger(shader->GetUniformLocation("GBuffer0"), 0);
+	shader->SendInteger(shader->GetUniformLocation("GBuffer1"), 1);
+	shader->SendInteger(shader->GetUniformLocation("GBuffer2"), 2);
+
+
+	shader = RegisterDeferredShader("DeferredPointSpotLight", fragmentSource_PointSpotLight, sizeof(fragmentSource_PointSpotLight), basicVertexStage, &error);
+	if (!shader)
+	{
+		NazaraError("Failed to register critical shader: " + error);
+		return false;
+	}
+
+	shader->SendInteger(shader->GetUniformLocation("GBuffer0"), 0);
+	shader->SendInteger(shader->GetUniformLocation("GBuffer1"), 1);
+	shader->SendInteger(shader->GetUniformLocation("GBuffer2"), 2);
+
+
+	// Shaders optionnels (S'ils ne sont pas présents, le rendu minimal sera quand même assuré)
+	shader = RegisterDeferredShader("DeferredBloomBright", fragmentSource_BloomBright, sizeof(fragmentSource_BloomBright), ppVertexStage, &error);
+	if (shader)
+		shader->SendInteger(shader->GetUniformLocation("ColorTexture"), 0);
+	else
+	{
+		NazaraWarning("Failed to register bloom (bright pass) shader, certain features will not work: " + error);
+	}
+
+
+	shader = RegisterDeferredShader("DeferredBloomFinal", fragmentSource_BloomFinal, sizeof(fragmentSource_BloomFinal), ppVertexStage, &error);
+	if (shader)
+	{
+		shader->SendInteger(shader->GetUniformLocation("ColorTexture"), 0);
+		shader->SendInteger(shader->GetUniformLocation("BloomTexture"), 1);
+	}
+	else
+	{
+		NazaraWarning("Failed to register bloom (final pass) shader, certain features will not work: " + error);
+	}
+
+
+	shader = RegisterDeferredShader("DeferredFXAA", fragmentSource_FXAA, sizeof(fragmentSource_FXAA), ppVertexStage, &error);
+	if (shader)
+		shader->SendInteger(shader->GetUniformLocation("ColorTexture"), 0);
+	else
+	{
+		NazaraWarning("Failed to register FXAA shader, certain features will not work: " + error);
+	}
+
+
+	shader = RegisterDeferredShader("DeferredGaussianBlur", fragmentSource_GaussianBlur, sizeof(fragmentSource_GaussianBlur), ppVertexStage, &error);
+	if (shader)
+		shader->SendInteger(shader->GetUniformLocation("ColorTexture"), 0);
+	else
+	{
+		NazaraWarning("Failed to register gaussian blur shader, certain features will not work: " + error);
+	}
+
+	return true;
+}
+
 bool NzDeferredRenderTechnique::IsSupported()
 {
 	// On ne va pas s'embêter à écrire un Deferred Renderer qui ne passe pas par le MRT, ce serait lent et inutile (OpenGL 2 garanti cette fonctionnalité en plus)
-	return NzRenderer::HasCapability(nzRendererCap_RenderTexture) &&
+	return NzOpenGL::GetGLSLVersion() >= 140 && // On ne va pas s'embêter non plus avec le mode de compatibilité
+	       NzRenderer::HasCapability(nzRendererCap_RenderTexture) &&
 	       NzRenderer::HasCapability(nzRendererCap_MultipleRenderTargets) &&
 	       NzRenderer::GetMaxColorAttachments() >= 4 &&
-	       NzRenderer::GetMaxRenderTargets() >= 4 &&
-	       NzTexture::IsFormatSupported(nzPixelFormat_RGBA32F);
+	       NzRenderer::GetMaxRenderTargets() >= 4;
+}
+
+void NzDeferredRenderTechnique::Uninitialize()
+{
+	NzShaderLibrary::Unregister("DeferredGBufferClear");
+	NzShaderLibrary::Unregister("DeferredDirectionnalLight");
+	NzShaderLibrary::Unregister("DeferredPointSpotLight");
+	NzShaderLibrary::Unregister("DeferredBloomBright");
+	NzShaderLibrary::Unregister("DeferredBloomFinal");
+	NzShaderLibrary::Unregister("DeferredFXAA");
+	NzShaderLibrary::Unregister("DeferredGaussianBlur");
 }
 
 bool NzDeferredRenderTechnique::Resize(const NzVector2ui& dimensions) const

src/Nazara/Graphics/ForwardRenderQueue.cpp

@@ -5,9 +5,9 @@
 #include <Nazara/Graphics/ForwardRenderQueue.hpp>
 #include <Nazara/Graphics/AbstractViewer.hpp>
 #include <Nazara/Graphics/Light.hpp>
+#include <Nazara/Graphics/Material.hpp>
 #include <Nazara/Graphics/Model.hpp>
 #include <Nazara/Graphics/Sprite.hpp>
-#include <Nazara/Renderer/Material.hpp>
 #include <Nazara/Utility/SkeletalMesh.hpp>
 #include <Nazara/Utility/StaticMesh.hpp>
 #include <Nazara/Graphics/Debug.hpp>
@@ -186,8 +186,7 @@ void NzForwardRenderQueue::AddSubMesh(const NzMaterial* material, const NzSubMes
 				unsigned int instanceCount = staticDataContainer.size() + 1;
 
 				// Avons-nous suffisamment d'instances pour que le coût d'utilisation de l'instancing soit payé ?
-				unsigned int tumasoublie = NAZARA_GRAPHICS_INSTANCING_MIN_INSTANCES_COUNT;
-				if (instanceCount >= 10)
+				if (instanceCount >= NAZARA_GRAPHICS_INSTANCING_MIN_INSTANCES_COUNT)
 					enableInstancing = true; // Apparemment oui, activons l'instancing avec ce matériau
 
 				staticDataContainer.resize(instanceCount);
@@ -350,19 +349,16 @@ void NzForwardRenderQueue::OnResourceReleased(const NzResource* resource, int in
 
 bool NzForwardRenderQueue::BatchedModelMaterialComparator::operator()(const NzMaterial* mat1, const NzMaterial* mat2)
 {
-	nzUInt32 possibleFlags[] = {
-		nzShaderFlags_None,
-		nzShaderFlags_Instancing
-	};
+	const NzUberShader* uberShader1 = mat1->GetShader();
+	const NzUberShader* uberShader2 = mat2->GetShader();
+	if (uberShader1 != uberShader2)
+		return uberShader1 < uberShader2;
 
-	for (nzUInt32 flag : possibleFlags)
-	{
-		const NzShaderProgram* program1 = mat1->GetShaderProgram(nzShaderTarget_Model, flag);
-		const NzShaderProgram* program2 = mat2->GetShaderProgram(nzShaderTarget_Model, flag);
+	const NzShader* shader1 = mat1->GetShaderInstance()->GetShader();
+	const NzShader* shader2 = mat2->GetShaderInstance()->GetShader();
 
-		if (program1 != program2)
-			return program1 < program2;
-	}
+	if (shader1 != shader2)
+		return shader1 < shader2;
 
 	const NzTexture* diffuseMap1 = mat1->GetDiffuseMap();
 	const NzTexture* diffuseMap2 = mat2->GetDiffuseMap();
@@ -374,18 +370,16 @@ bool NzForwardRenderQueue::BatchedModelMaterialComparator::operator()(const NzMa
 
 bool NzForwardRenderQueue::BatchedSpriteMaterialComparator::operator()(const NzMaterial* mat1, const NzMaterial* mat2)
 {
-	nzUInt32 possibleFlags[] = {
-		nzShaderFlags_None
-	};
+	const NzUberShader* uberShader1 = mat1->GetShader();
+	const NzUberShader* uberShader2 = mat2->GetShader();
+	if (uberShader1 != uberShader2)
+		return uberShader1 < uberShader2;
 
-	for (nzUInt32 flag : possibleFlags)
-	{
-		const NzShaderProgram* program1 = mat1->GetShaderProgram(nzShaderTarget_Model, flag);
-		const NzShaderProgram* program2 = mat2->GetShaderProgram(nzShaderTarget_Model, flag);
+	const NzShader* shader1 = mat1->GetShaderInstance(nzShaderFlags_Deferred)->GetShader();
+	const NzShader* shader2 = mat2->GetShaderInstance(nzShaderFlags_Deferred)->GetShader();
 
-		if (program1 != program2)
-			return program1 < program2;
-	}
+	if (shader1 != shader2)
+		return shader1 < shader2;
 
 	const NzTexture* diffuseMap1 = mat1->GetDiffuseMap();
 	const NzTexture* diffuseMap2 = mat2->GetDiffuseMap();

src/Nazara/Graphics/ForwardRenderTechnique.cpp

@@ -7,9 +7,9 @@
 #include <Nazara/Graphics/Camera.hpp>
 #include <Nazara/Graphics/Drawable.hpp>
 #include <Nazara/Graphics/Light.hpp>
+#include <Nazara/Graphics/Material.hpp>
 #include <Nazara/Graphics/Sprite.hpp>
 #include <Nazara/Renderer/Config.hpp>
-#include <Nazara/Renderer/Material.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Utility/BufferMapper.hpp>
 #include <Nazara/Utility/StaticMesh.hpp>
@@ -18,10 +18,11 @@
 #include <memory>
 #include <Nazara/Graphics/Debug.hpp>
 
+///TODO: Surveiller les shaders et supprimer les données uniformes en cas de changement (recompilation/destruction)
+
 namespace
 {
 	static NzIndexBuffer* s_indexBuffer = nullptr;
-	unsigned int s_maxLightPerPass = 3; ///TODO: Constante sur le nombre maximum de lumières
 	unsigned int s_maxSprites = 8192;
 
 	NzIndexBuffer* BuildIndexBuffer()
@@ -164,7 +165,8 @@ void NzForwardRenderTechnique::SetMaxLightPassPerObject(unsigned int passCount)
 void NzForwardRenderTechnique::DrawOpaqueModels(const NzScene* scene) const
 {
 	NzAbstractViewer* viewer = scene->GetViewer();
-	const NzShaderProgram* lastProgram = nullptr;
+	const LightUniforms* lightUniforms = nullptr;
+	const NzShader* lastShader = nullptr;
 
 	for (auto& matIt : m_renderQueue.opaqueModels)
 	{
@@ -184,23 +186,23 @@ void NzForwardRenderTechnique::DrawOpaqueModels(const NzScene* scene) const
 				// (Le deferred shading n'a pas ce problème)
 				bool instancing = m_instancingEnabled && (!material->IsLightingEnabled() || m_lights.IsEmpty()) && renderQueueInstancing;
 
-				// On commence par récupérer le programme du matériau
-				const NzShaderProgram* program = material->GetShaderProgram(nzShaderTarget_Model, (instancing) ? nzShaderFlags_Instancing : 0);
+				// On commence par appliquer du matériau (et récupérer le shader ainsi activé)
+				const NzShader* shader = material->Apply((instancing) ? nzShaderFlags_Instancing : 0);
 
 				// Les uniformes sont conservées au sein d'un programme, inutile de les renvoyer tant qu'il ne change pas
-				if (program != lastProgram)
+				if (shader != lastShader)
 				{
-					NzRenderer::SetShaderProgram(program);
-
 					// Couleur ambiante de la scène
-					program->SendColor(program->GetUniformLocation(nzShaderUniform_SceneAmbient), scene->GetAmbientColor());
+					shader->SendColor(shader->GetUniformLocation(nzShaderUniform_SceneAmbient), scene->GetAmbientColor());
 					// Position de la caméra
-					program->SendVector(program->GetUniformLocation(nzShaderUniform_EyePosition), viewer->GetEyePosition());
+					shader->SendVector(shader->GetUniformLocation(nzShaderUniform_EyePosition), viewer->GetEyePosition());
 
-					lastProgram = program;
+					// Index des uniformes d'éclairage dans le shader
+					lightUniforms = GetLightUniforms(shader);
+
+					lastShader = shader;
 				}
 
-				material->Apply(program);
 
 				// Meshs squelettiques
 				/*if (!skeletalContainer.empty())
@@ -260,10 +262,10 @@ void NzForwardRenderTechnique::DrawOpaqueModels(const NzScene* scene) const
 							unsigned int lightIndex = 0;
 							nzRendererComparison oldDepthFunc = NzRenderer::GetDepthFunc();
 
-							unsigned int passCount = (lightCount == 0) ? 1 : (lightCount-1)/s_maxLightPerPass + 1;
+							unsigned int passCount = (lightCount == 0) ? 1 : (lightCount-1)/NAZARA_GRAPHICS_MAX_LIGHTPERPASS + 1;
 							for (unsigned int pass = 0; pass < passCount; ++pass)
 							{
-								unsigned int renderedLightCount = std::min(lightCount, s_maxLightPerPass);
+								unsigned int renderedLightCount = std::min(lightCount, NAZARA_GRAPHICS_MAX_LIGHTPERPASS);
 								lightCount -= renderedLightCount;
 
 								if (pass == 1)
@@ -278,10 +280,10 @@ void NzForwardRenderTechnique::DrawOpaqueModels(const NzScene* scene) const
 								}
 
 								for (unsigned int i = 0; i < renderedLightCount; ++i)
-									m_directionalLights.GetLight(lightIndex++)->Enable(program, i);
+									m_directionalLights.GetLight(lightIndex++)->Enable(shader, lightUniforms->uniforms, lightUniforms->offset*i);
 
-								for (unsigned int i = renderedLightCount; i < s_maxLightPerPass; ++i)
-									NzLight::Disable(program, i);
+								for (unsigned int i = renderedLightCount; i < NAZARA_GRAPHICS_MAX_LIGHTPERPASS; ++i)
+									NzLight::Disable(shader, lightUniforms->uniforms, lightUniforms->offset*i);
 
 								const NzForwardRenderQueue::StaticData* data = &staticData[0];
 								unsigned int instanceCount = staticData.size();
@@ -317,7 +319,7 @@ void NzForwardRenderTechnique::DrawOpaqueModels(const NzScene* scene) const
 							for (const NzForwardRenderQueue::StaticData& data : staticData)
 							{
 								unsigned int directionalLightCount = m_directionalLights.GetLightCount();
-								unsigned int otherLightCount = m_lights.ComputeClosestLights(data.transformMatrix.GetTranslation() + boundingSphere.GetPosition(), boundingSphere.radius, m_maxLightPassPerObject*s_maxLightPerPass - directionalLightCount);
+								unsigned int otherLightCount = m_lights.ComputeClosestLights(data.transformMatrix.GetTranslation() + boundingSphere.GetPosition(), boundingSphere.radius, m_maxLightPassPerObject*NAZARA_GRAPHICS_MAX_LIGHTPERPASS - directionalLightCount);
                                 unsigned int lightCount = directionalLightCount + otherLightCount;
 
  								NzRenderer::SetMatrix(nzMatrixType_World, data.transformMatrix);
@@ -325,10 +327,10 @@ void NzForwardRenderTechnique::DrawOpaqueModels(const NzScene* scene) const
  								unsigned int otherLightIndex = 0;
  								nzRendererComparison oldDepthFunc = NzRenderer::GetDepthFunc();
 
-								unsigned int passCount = (lightCount == 0) ? 1 : (lightCount-1)/s_maxLightPerPass + 1;
+								unsigned int passCount = (lightCount == 0) ? 1 : (lightCount-1)/NAZARA_GRAPHICS_MAX_LIGHTPERPASS + 1;
 								for (unsigned int pass = 0; pass < passCount; ++pass)
 								{
-									unsigned int renderedLightCount = std::min(lightCount, s_maxLightPerPass);
+									unsigned int renderedLightCount = std::min(lightCount, NAZARA_GRAPHICS_MAX_LIGHTPERPASS);
 									lightCount -= renderedLightCount;
 
 									if (pass == 1)
@@ -345,13 +347,13 @@ void NzForwardRenderTechnique::DrawOpaqueModels(const NzScene* scene) const
 									for (unsigned int i = 0; i < renderedLightCount; ++i)
 									{
 										if (directionalLightIndex >= directionalLightCount)
-											m_lights.GetResult(otherLightIndex++)->Enable(program, i);
+											m_lights.GetResult(otherLightIndex++)->Enable(shader, lightUniforms->uniforms, lightUniforms->offset*i);
 										else
-											m_directionalLights.GetLight(directionalLightIndex++)->Enable(program, i);
+											m_directionalLights.GetLight(directionalLightIndex++)->Enable(shader, lightUniforms->uniforms, lightUniforms->offset*i);
 									}
 
-									for (unsigned int i = renderedLightCount; i < s_maxLightPerPass; ++i)
-										NzLight::Disable(program, i);
+									for (unsigned int i = renderedLightCount; i < NAZARA_GRAPHICS_MAX_LIGHTPERPASS; ++i)
+										NzLight::Disable(shader, lightUniforms->uniforms, lightUniforms->offset*i);
 
 									DrawFunc(primitiveMode, 0, indexCount);
 								}
@@ -375,7 +377,7 @@ void NzForwardRenderTechnique::DrawOpaqueModels(const NzScene* scene) const
 void NzForwardRenderTechnique::DrawSprites(const NzScene* scene) const
 {
 	NzAbstractViewer* viewer = scene->GetViewer();
-	const NzShaderProgram* lastProgram = nullptr;
+	const NzShader* lastShader = nullptr;
 
 	NzRenderer::SetIndexBuffer(m_indexBuffer);
 	NzRenderer::SetMatrix(nzMatrixType_World, NzMatrix4f::Identity());
@@ -389,24 +391,20 @@ void NzForwardRenderTechnique::DrawSprites(const NzScene* scene) const
 		unsigned int spriteCount = spriteVector.size();
 		if (spriteCount > 0)
 		{
-			// On commence par récupérer le programme du matériau
-			const NzShaderProgram* program = material->GetShaderProgram(nzShaderTarget_Sprite, 0);
+			// On commence par appliquer du matériau (et récupérer le shader ainsi activé)
+			const NzShader* shader = material->Apply();
 
-			// Les uniformes sont conservées au sein du shader, inutile de les renvoyer tant que le shader reste le même
-			if (program != lastProgram)
+			// Les uniformes sont conservées au sein d'un programme, inutile de les renvoyer tant qu'il ne change pas
+			if (shader != lastShader)
 			{
-				NzRenderer::SetShaderProgram(program);
-
 				// Couleur ambiante de la scène
-				program->SendColor(program->GetUniformLocation(nzShaderUniform_SceneAmbient), scene->GetAmbientColor());
+				shader->SendColor(shader->GetUniformLocation(nzShaderUniform_SceneAmbient), scene->GetAmbientColor());
 				// Position de la caméra
-				program->SendVector(program->GetUniformLocation(nzShaderUniform_EyePosition), viewer->GetEyePosition());
+				shader->SendVector(shader->GetUniformLocation(nzShaderUniform_EyePosition), viewer->GetEyePosition());
 
-				lastProgram = program;
+				lastShader = shader;
 			}
 
-			material->Apply(program);
-
 			const NzSprite** spritePtr = &spriteVector[0];
 			do
 			{
@@ -455,7 +453,8 @@ void NzForwardRenderTechnique::DrawSprites(const NzScene* scene) const
 void NzForwardRenderTechnique::DrawTransparentModels(const NzScene* scene) const
 {
 	NzAbstractViewer* viewer = scene->GetViewer();
-	const NzShaderProgram* lastProgram = nullptr;
+	const LightUniforms* lightUniforms = nullptr;
+	const NzShader* lastShader = nullptr;
 	unsigned int lightCount = 0;
 
 	for (const std::pair<unsigned int, bool>& pair : m_renderQueue.transparentsModels)
@@ -465,29 +464,28 @@ void NzForwardRenderTechnique::DrawTransparentModels(const NzScene* scene) const
 		                              m_renderQueue.transparentStaticModels[pair.first].material :
 		                              m_renderQueue.transparentSkeletalModels[pair.first].material;
 
-		// On commence par récupérer le shader du matériau
-		const NzShaderProgram* program = material->GetShaderProgram(nzShaderTarget_Model, 0);
+		// On commence par appliquer du matériau (et récupérer le shader ainsi activé)
+		const NzShader* shader = material->Apply();
 
-		// Les uniformes sont conservées au sein du shader, inutile de les renvoyer tant que le shader reste le même
-		if (program != lastProgram)
+		// Les uniformes sont conservées au sein d'un programme, inutile de les renvoyer tant qu'il ne change pas
+		if (shader != lastShader)
 		{
-			NzRenderer::SetShaderProgram(program);
-
 			// Couleur ambiante de la scène
-			program->SendColor(program->GetUniformLocation(nzShaderUniform_SceneAmbient), scene->GetAmbientColor());
+			shader->SendColor(shader->GetUniformLocation(nzShaderUniform_SceneAmbient), scene->GetAmbientColor());
 			// Position de la caméra
-			program->SendVector(program->GetUniformLocation(nzShaderUniform_EyePosition), viewer->GetEyePosition());
+			shader->SendVector(shader->GetUniformLocation(nzShaderUniform_EyePosition), viewer->GetEyePosition());
+
+			// Index des uniformes d'éclairage dans le shader
+			lightUniforms = GetLightUniforms(shader);
 
 			// On envoie les lumières directionnelles s'il y a (Les mêmes pour tous)
-			lightCount = std::min(m_directionalLights.GetLightCount(), 3U);
+			lightCount = std::min(m_directionalLights.GetLightCount(), NAZARA_GRAPHICS_MAX_LIGHTPERPASS);
 			for (unsigned int i = 0; i < lightCount; ++i)
-				m_directionalLights.GetLight(i)->Enable(program, i);
+				m_directionalLights.GetLight(i)->Enable(shader, lightUniforms->uniforms, lightUniforms->offset*i);
 
-			lastProgram = program;
+			lastShader = shader;
 		}
 
-		material->Apply(program);
-
 		// Mesh
 		if (pair.second)
 		{
@@ -518,15 +516,15 @@ void NzForwardRenderTechnique::DrawTransparentModels(const NzScene* scene) const
 			NzRenderer::SetVertexBuffer(vertexBuffer);
 
 			// Calcul des lumières les plus proches
-			if (lightCount < s_maxLightPerPass && !m_lights.IsEmpty())
+			if (lightCount < NAZARA_GRAPHICS_MAX_LIGHTPERPASS && !m_lights.IsEmpty())
 			{
-				unsigned int count = std::min(s_maxLightPerPass - lightCount, m_lights.ComputeClosestLights(matrix.GetTranslation() + staticModel.boundingSphere.GetPosition(), staticModel.boundingSphere.radius, s_maxLightPerPass));
+				unsigned int count = std::min(NAZARA_GRAPHICS_MAX_LIGHTPERPASS - lightCount, m_lights.ComputeClosestLights(matrix.GetTranslation() + staticModel.boundingSphere.GetPosition(), staticModel.boundingSphere.radius, NAZARA_GRAPHICS_MAX_LIGHTPERPASS));
 				for (unsigned int i = 0; i < count; ++i)
-					m_lights.GetResult(i)->Enable(program, lightCount++);
+					m_lights.GetResult(i)->Enable(shader, lightUniforms->uniforms, lightUniforms->offset*(lightCount++));
 			}
 
-			for (unsigned int i = lightCount; i < s_maxLightPerPass; ++i)
-				NzLight::Disable(program, i);
+			for (unsigned int i = lightCount; i < NAZARA_GRAPHICS_MAX_LIGHTPERPASS; ++i)
+				NzLight::Disable(shader, lightUniforms->uniforms, lightUniforms->offset*i);
 
 			NzRenderer::SetMatrix(nzMatrixType_World, matrix);
 			DrawFunc(mesh->GetPrimitiveMode(), 0, indexCount);
@@ -537,3 +535,35 @@ void NzForwardRenderTechnique::DrawTransparentModels(const NzScene* scene) const
 		}
 	}
 }
+
+const NzForwardRenderTechnique::LightUniforms* NzForwardRenderTechnique::GetLightUniforms(const NzShader* shader) const
+{
+	auto it = m_lightUniforms.find(shader);
+	if (it != m_lightUniforms.end())
+		return &(it->second);
+	else
+	{
+		int type0Location = shader->GetUniformLocation("Lights[0].type");
+		int type1Location = shader->GetUniformLocation("Lights[1].type");
+
+		LightUniforms lightUniforms;
+
+		if (type0Location > 0 && type1Location > 0)
+		{
+			lightUniforms.exists = true;
+			lightUniforms.offset = type1Location - type0Location;
+			lightUniforms.uniforms.ubo = false;
+			lightUniforms.uniforms.locations.type = type0Location;
+			lightUniforms.uniforms.locations.color = shader->GetUniformLocation("Lights[0].color");
+			lightUniforms.uniforms.locations.factors = shader->GetUniformLocation("Lights[0].factors");
+			lightUniforms.uniforms.locations.parameters1 = shader->GetUniformLocation("Lights[0].parameters1");
+			lightUniforms.uniforms.locations.parameters2 = shader->GetUniformLocation("Lights[0].parameters2");
+			lightUniforms.uniforms.locations.parameters3 = shader->GetUniformLocation("Lights[0].parameters3");
+		}
+		else
+			lightUniforms.exists = false;
+
+		auto pair = m_lightUniforms.emplace(shader, lightUniforms);
+		return &(pair.first->second);
+	}
+}

src/Nazara/Graphics/Graphics.cpp

@@ -3,47 +3,65 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Graphics/Graphics.hpp>
+#include <Nazara/Core/CallOnExit.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Core/Log.hpp>
 #include <Nazara/Graphics/Config.hpp>
 #include <Nazara/Graphics/DeferredRenderTechnique.hpp>
 #include <Nazara/Graphics/ForwardRenderTechnique.hpp>
+#include <Nazara/Graphics/Material.hpp>
 #include <Nazara/Graphics/RenderTechniques.hpp>
 #include <Nazara/Graphics/Loaders/Mesh.hpp>
 #include <Nazara/Graphics/Loaders/OBJ.hpp>
+#include <Nazara/Graphics/Loaders/Texture.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Graphics/Debug.hpp>
 
 bool NzGraphics::Initialize()
 {
-	if (s_moduleReferenceCounter++ != 0)
+	if (s_moduleReferenceCounter > 0)
+	{
+		s_moduleReferenceCounter++;
 		return true; // Déjà initialisé
+	}
 
 	// Initialisation des dépendances
 	if (!NzRenderer::Initialize())
 	{
 		NazaraError("Failed to initialize Renderer module");
-		Uninitialize();
-
 		return false;
 	}
 
+	s_moduleReferenceCounter++;
+
 	// Initialisation du module
+	NzCallOnExit onExit(NzGraphics::Uninitialize);
+
+	if (!NzMaterial::Initialize())
+	{
+		NazaraError("Failed to create material");
+		return false;
+	}
 
 	// Loaders
 	NzLoaders_OBJ_Register();
 
-	// Loader générique
+	// Loaders génériques
 	NzLoaders_Mesh_Register();
+	NzLoaders_Texture_Register();
 
 	// RenderTechniques
 	NzRenderTechniques::Register(NzRenderTechniques::ToString(nzRenderTechniqueType_BasicForward), 0, []() -> NzAbstractRenderTechnique* { return new NzForwardRenderTechnique; });
 
 	if (NzDeferredRenderTechnique::IsSupported())
+	{
+		NzDeferredRenderTechnique::Initialize();
 		NzRenderTechniques::Register(NzRenderTechniques::ToString(nzRenderTechniqueType_DeferredShading), 20, []() -> NzAbstractRenderTechnique* { return new NzDeferredRenderTechnique; });
+	}
+
+	onExit.Reset();
 
 	NazaraNotice("Initialized: Graphics module");
-
 	return true;
 }
 
@@ -69,6 +87,11 @@ void NzGraphics::Uninitialize()
 	// Loaders
 	NzLoaders_Mesh_Unregister();
 	NzLoaders_OBJ_Unregister();
+	NzLoaders_Texture_Unregister();
+
+	NzMaterial::Uninitialize();
+
+	NzDeferredRenderTechnique::Uninitialize();
 
 	NazaraNotice("Uninitialized: Graphics module");
 

src/Nazara/Graphics/Light.cpp

@@ -9,7 +9,7 @@
 #include <Nazara/Math/Basic.hpp>
 #include <Nazara/Math/Sphere.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
-#include <Nazara/Renderer/ShaderProgram.hpp>
+#include <Nazara/Renderer/Shader.hpp>
 #include <cstring>
 #include <Nazara/Graphics/Debug.hpp>
 
@@ -41,6 +41,7 @@ m_innerAngle(light.m_innerAngle),
 m_outerAngle(light.m_outerAngle),
 m_radius(light.m_radius)
 {
+	SetParent(light);
 }
 
 void NzLight::AddToRenderQueue(NzAbstractRenderQueue* renderQueue) const
@@ -48,7 +49,7 @@ void NzLight::AddToRenderQueue(NzAbstractRenderQueue* renderQueue) const
 	renderQueue->AddLight(this);
 }
 
-void NzLight::Enable(const NzShaderProgram* program, unsigned int lightUnit) const
+void NzLight::Enable(const NzShader* shader, const NzLightUniforms& uniforms, int offset) const
 {
 	/*
 	struct Light
@@ -75,31 +76,9 @@ void NzLight::Enable(const NzShaderProgram* program, unsigned int lightUnit) con
 	-P3: float cosInnerAngle + float cosOuterAngle
 	*/
 
-	///TODO: Optimiser
-	int typeLocation = program->GetUniformLocation("Lights[0].type");
-	int colorLocation = program->GetUniformLocation("Lights[0].color");
-	int factorsLocation = program->GetUniformLocation("Lights[0].factors");
-	int parameters1Location = program->GetUniformLocation("Lights[0].parameters1");
-	int parameters2Location = program->GetUniformLocation("Lights[0].parameters2");
-	int parameters3Location = program->GetUniformLocation("Lights[0].parameters3");
-
-	if (lightUnit > 0)
-	{
-		int type2Location = program->GetUniformLocation("Lights[1].type");
-		int offset = lightUnit * (type2Location - typeLocation); // type2Location - typeLocation donne la taille de la structure
-
-		// On applique cet offset
-		typeLocation += offset;
-		colorLocation += offset;
-		factorsLocation += offset;
-		parameters1Location += offset;
-		parameters2Location += offset;
-		parameters3Location += offset;
-	}
-
-	program->SendInteger(typeLocation, m_type);
-	program->SendColor(colorLocation, m_color);
-	program->SendVector(factorsLocation, NzVector2f(m_ambientFactor, m_diffuseFactor));
+	shader->SendInteger(uniforms.locations.type + offset, m_type);
+	shader->SendColor(uniforms.locations.color + offset, m_color);
+	shader->SendVector(uniforms.locations.factors + offset, NzVector2f(m_ambientFactor, m_diffuseFactor));
 
 	if (!m_derivedUpdated)
 		UpdateDerived();
@@ -107,18 +86,18 @@ void NzLight::Enable(const NzShaderProgram* program, unsigned int lightUnit) con
 	switch (m_type)
 	{
 		case nzLightType_Directional:
-			program->SendVector(parameters1Location, NzVector4f(m_derivedRotation * NzVector3f::Forward()));
+			shader->SendVector(uniforms.locations.parameters1 + offset, NzVector4f(m_derivedRotation * NzVector3f::Forward()));
 			break;
 
 		case nzLightType_Point:
-			program->SendVector(parameters1Location, NzVector4f(m_derivedPosition, m_attenuation));
-			program->SendVector(parameters2Location, NzVector4f(0.f, 0.f, 0.f, 1.f/m_radius));
+			shader->SendVector(uniforms.locations.parameters1 + offset, NzVector4f(m_derivedPosition, m_attenuation));
+			shader->SendVector(uniforms.locations.parameters2 + offset, NzVector4f(0.f, 0.f, 0.f, 1.f/m_radius));
 			break;
 
 		case nzLightType_Spot:
-			program->SendVector(parameters1Location, NzVector4f(m_derivedPosition, m_attenuation));
-			program->SendVector(parameters2Location, NzVector4f(m_derivedRotation * NzVector3f::Forward(), 1.f/m_radius));
-			program->SendVector(parameters3Location, NzVector2f(std::cos(NzDegreeToRadian(m_innerAngle)), std::cos(NzDegreeToRadian(m_outerAngle))));
+			shader->SendVector(uniforms.locations.parameters1 + offset, NzVector4f(m_derivedPosition, m_attenuation));
+			shader->SendVector(uniforms.locations.parameters2 + offset, NzVector4f(m_derivedRotation * NzVector3f::Forward(), 1.f/m_radius));
+			shader->SendVector(uniforms.locations.parameters3 + offset, NzVector2f(std::cos(NzDegreeToRadian(m_innerAngle)), std::cos(NzDegreeToRadian(m_outerAngle))));
 			break;
 	}
 }
@@ -245,10 +224,9 @@ NzLight& NzLight::operator=(const NzLight& light)
 	return *this;
 }
 
-void NzLight::Disable(const NzShaderProgram* program, unsigned int lightUnit)
+void NzLight::Disable(const NzShader* shader, const NzLightUniforms& uniforms, int offset)
 {
-	///TODO: Optimiser
-	program->SendInteger(program->GetUniformLocation("Lights[" + NzString::Number(lightUnit) + "].type"), -1);
+	shader->SendInteger(uniforms.locations.type + offset, -1);
 }
 
 bool NzLight::FrustumCull(const NzFrustumf& frustum)
@@ -276,9 +254,9 @@ bool NzLight::FrustumCull(const NzFrustumf& frustum)
 	return false;
 }
 
-void NzLight::Invalidate()
+void NzLight::InvalidateNode()
 {
-	NzSceneNode::Invalidate();
+	NzSceneNode::InvalidateNode();
 
 	m_boundingVolumeUpdated = false;
 }

src/Nazara/Graphics/Loaders/Mesh/Loader.cpp

@@ -3,8 +3,8 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Graphics/Loaders/Mesh.hpp>
+#include <Nazara/Graphics/Material.hpp>
 #include <Nazara/Graphics/Model.hpp>
-#include <Nazara/Renderer/Material.hpp>
 #include <Nazara/Utility/Mesh.hpp>
 #include <memory>
 #include <Nazara/Graphics/Debug.hpp>
@@ -63,8 +63,11 @@ namespace
 				{
 					std::unique_ptr<NzMaterial> material(new NzMaterial);
 					material->SetPersistent(false);
+
 					if (material->LoadFromFile(mat, parameters.material))
 					{
+						material->SetShader(parameters.shaderName);
+
 						model->SetMaterial(i, material.get());
 						material.release();
 					}

src/Nazara/Graphics/Loaders/OBJ/Loader.cpp

@@ -3,10 +3,10 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Graphics/Loaders/OBJ.hpp>
+#include <Nazara/Graphics/Material.hpp>
+#include <Nazara/Graphics/Model.hpp>
 #include <Nazara/Graphics/Loaders/OBJ/MTLParser.hpp>
 #include <Nazara/Graphics/Loaders/OBJ/OBJParser.hpp>
-#include <Nazara/Graphics/Model.hpp>
-#include <Nazara/Renderer/Material.hpp>
 #include <Nazara/Utility/BufferMapper.hpp>
 #include <Nazara/Utility/IndexMapper.hpp>
 #include <Nazara/Utility/Mesh.hpp>
@@ -212,6 +212,8 @@ namespace
 								std::unique_ptr<NzMaterial> material(new NzMaterial);
 								material->SetPersistent(false);
 
+								material->SetShader(parameters.shaderName);
+
 								nzUInt8 alphaValue = static_cast<nzUInt8>(mtlMat->alpha*255.f);
 
 								NzColor ambientColor(mtlMat->ambient);

src/Nazara/Graphics/Loaders/Texture.hpp

@@ -1,5 +1,5 @@
 // Copyright (C) 2014 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Renderer module"
+// This file is part of the "Nazara Engine - Graphics module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #pragma once

src/Nazara/Graphics/Loaders/Texture/Loader.cpp

@@ -1,12 +1,12 @@
 // Copyright (C) 2014 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Renderer module"
+// This file is part of the "Nazara Engine - Graphics module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Renderer/Loaders/Texture.hpp>
-#include <Nazara/Renderer/Material.hpp>
+#include <Nazara/Graphics/Loaders/Texture.hpp>
+#include <Nazara/Graphics/Material.hpp>
 #include <Nazara/Renderer/Texture.hpp>
 #include <memory>
-#include <Nazara/Renderer/Debug.hpp>
+#include <Nazara/Graphics/Debug.hpp>
 
 namespace
 {

src/Nazara/Graphics/Material.cpp

@@ -1,17 +1,25 @@
 // Copyright (C) 2014 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Renderer module"
+// This file is part of the "Nazara Engine - Graphics module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Renderer/Material.hpp>
+#ifndef NAZARA_RENDERER_OPENGL
+#define NAZARA_RENDERER_OPENGL // Nécessaire pour inclure les headers OpenGL
+#endif
+
+#include <Nazara/Graphics/Material.hpp>
+#include <Nazara/Renderer/OpenGL.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
-#include <Nazara/Renderer/ShaderProgram.hpp>
-#include <Nazara/Renderer/ShaderProgramManager.hpp>
+#include <Nazara/Renderer/UberShaderLibrary.hpp>
+#include <Nazara/Renderer/UberShaderPreprocessor.hpp>
 #include <cstring>
 #include <memory>
-#include <Nazara/Renderer/Debug.hpp>
+#include <Nazara/Graphics/Debug.hpp>
 
 bool NzMaterialParams::IsValid() const
 {
+	if (!NzUberShaderLibrary::Has(shaderName))
+		return false;
+
 	return true;
 }
 
@@ -37,10 +45,7 @@ NzMaterial::NzMaterial(NzMaterial&& material)
 	material.m_heightMap.Reset();
 	material.m_normalMap.Reset();
 	material.m_specularMap.Reset();
-
-	for (unsigned int i = 0; i <= nzShaderTarget_Max; ++i)
-		for (ProgramUnit& unit : material.m_programs[i])
-			unit.program.Reset();
+	material.m_uberShader.Reset();
 }
 
 NzMaterial::~NzMaterial()
@@ -48,108 +53,83 @@ NzMaterial::~NzMaterial()
 	NotifyDestroy();
 }
 
-void NzMaterial::Apply(const NzShaderProgram* program) const
+const NzShader* NzMaterial::Apply(nzUInt32 shaderFlags, nzUInt8 textureUnit, nzUInt8* lastUsedUnit) const
 {
-	int alphaThresholdLocation = program->GetUniformLocation(nzShaderUniform_MaterialAlphaThreshold);
-	int ambientColorLocation = program->GetUniformLocation(nzShaderUniform_MaterialAmbient);
-	int diffuseColorLocation = program->GetUniformLocation(nzShaderUniform_MaterialDiffuse);
-	int shininessLocation = program->GetUniformLocation(nzShaderUniform_MaterialShininess);
-	int specularColorLocation = program->GetUniformLocation(nzShaderUniform_MaterialSpecular);
+	const ShaderInstance& instance = m_shaders[shaderFlags];
+	if (!instance.uberInstance)
+		GenerateShader(shaderFlags);
 
-	if (m_alphaMap)
+	instance.uberInstance->Activate();
+
+	if (instance.uniforms[nzMaterialUniform_AlphaThreshold] != -1)
+		instance.shader->SendFloat(instance.uniforms[nzMaterialUniform_AlphaThreshold], m_alphaThreshold);
+
+	if (instance.uniforms[nzMaterialUniform_Ambient] != -1)
+		instance.shader->SendColor(instance.uniforms[nzMaterialUniform_Ambient], m_ambientColor);
+
+	if (instance.uniforms[nzMaterialUniform_Diffuse] != -1)
+		instance.shader->SendColor(instance.uniforms[nzMaterialUniform_Diffuse], m_diffuseColor);
+
+	if (instance.uniforms[nzMaterialUniform_Shininess] != -1)
+		instance.shader->SendFloat(instance.uniforms[nzMaterialUniform_Shininess], m_shininess);
+
+	if (instance.uniforms[nzMaterialUniform_Specular] != -1)
+		instance.shader->SendColor(instance.uniforms[nzMaterialUniform_Specular], m_specularColor);
+
+	if (m_alphaMap && instance.uniforms[nzMaterialUniform_AlphaMap] != -1)
 	{
-		int alphaMapLocation = program->GetUniformLocation(nzShaderUniform_MaterialAlphaMap);
-		if (alphaMapLocation != -1)
-		{
-			nzUInt8 textureUnit;
-			if (program->SendTexture(alphaMapLocation, m_alphaMap, &textureUnit))
-				NzRenderer::SetTextureSampler(textureUnit, m_diffuseSampler);
-			else
-				NazaraWarning("Failed to send diffuse map");
-		}
+		NzRenderer::SetTexture(textureUnit, m_alphaMap);
+		NzRenderer::SetTextureSampler(textureUnit, m_diffuseSampler);
+		instance.shader->SendInteger(instance.uniforms[nzMaterialUniform_AlphaMap], textureUnit);
+		textureUnit++;
 	}
 
-	if (alphaThresholdLocation != -1)
-		program->SendFloat(alphaThresholdLocation, m_alphaThreshold);
-
-	if (ambientColorLocation != -1)
-		program->SendColor(ambientColorLocation, m_ambientColor);
-
-	if (diffuseColorLocation != -1)
-		program->SendColor(diffuseColorLocation, m_diffuseColor);
-
-	if (m_diffuseMap)
+	if (m_diffuseMap && instance.uniforms[nzMaterialUniform_DiffuseMap] != -1)
 	{
-		int diffuseMapLocation = program->GetUniformLocation(nzShaderUniform_MaterialDiffuseMap);
-		if (diffuseMapLocation != -1)
-		{
-			nzUInt8 textureUnit;
-			if (program->SendTexture(diffuseMapLocation, m_diffuseMap, &textureUnit))
-				NzRenderer::SetTextureSampler(textureUnit, m_diffuseSampler);
-			else
-				NazaraWarning("Failed to send diffuse map");
-		}
+		NzRenderer::SetTexture(textureUnit, m_diffuseMap);
+		NzRenderer::SetTextureSampler(textureUnit, m_diffuseSampler);
+		instance.shader->SendInteger(instance.uniforms[nzMaterialUniform_DiffuseMap], textureUnit);
+		textureUnit++;
 	}
 
-	if (m_emissiveMap)
+	if (m_emissiveMap && instance.uniforms[nzMaterialUniform_EmissiveMap] != -1)
 	{
-		int emissiveMapLocation = program->GetUniformLocation(nzShaderUniform_MaterialEmissiveMap);
-		if (emissiveMapLocation != -1)
-		{
-			nzUInt8 textureUnit;
-			if (program->SendTexture(emissiveMapLocation, m_emissiveMap, &textureUnit))
-				NzRenderer::SetTextureSampler(textureUnit, m_diffuseSampler);
-			else
-				NazaraWarning("Failed to send emissive map");
-		}
+		NzRenderer::SetTexture(textureUnit, m_emissiveMap);
+		NzRenderer::SetTextureSampler(textureUnit, m_diffuseSampler);
+		instance.shader->SendInteger(instance.uniforms[nzMaterialUniform_EmissiveMap], textureUnit);
+		textureUnit++;
 	}
 
-	if (m_heightMap)
+	if (m_heightMap && instance.uniforms[nzMaterialUniform_HeightMap] != -1)
 	{
-		int heightMapLocation = program->GetUniformLocation(nzShaderUniform_MaterialHeightMap);
-		if (heightMapLocation != -1)
-		{
-			nzUInt8 textureUnit;
-			if (program->SendTexture(heightMapLocation, m_heightMap, &textureUnit))
-				NzRenderer::SetTextureSampler(textureUnit, m_diffuseSampler);
-			else
-				NazaraWarning("Failed to send height map");
-		}
+		NzRenderer::SetTexture(textureUnit, m_heightMap);
+		NzRenderer::SetTextureSampler(textureUnit, m_diffuseSampler);
+		instance.shader->SendInteger(instance.uniforms[nzMaterialUniform_HeightMap], textureUnit);
+		textureUnit++;
 	}
 
-	if (m_normalMap)
+	if (m_normalMap && instance.uniforms[nzMaterialUniform_NormalMap] != -1)
 	{
-		int normalMapLocation = program->GetUniformLocation(nzShaderUniform_MaterialNormalMap);
-		if (normalMapLocation != -1)
-		{
-			nzUInt8 textureUnit;
-			if (program->SendTexture(normalMapLocation, m_normalMap, &textureUnit))
-				NzRenderer::SetTextureSampler(textureUnit, m_diffuseSampler);
-			else
-				NazaraWarning("Failed to send normal map");
-		}
+		NzRenderer::SetTexture(textureUnit, m_normalMap);
+		NzRenderer::SetTextureSampler(textureUnit, m_diffuseSampler);
+		instance.shader->SendInteger(instance.uniforms[nzMaterialUniform_NormalMap], textureUnit);
+		textureUnit++;
 	}
 
-	if (shininessLocation != -1)
-		program->SendFloat(shininessLocation, m_shininess);
-
-	if (specularColorLocation != -1)
-		program->SendColor(specularColorLocation, m_specularColor);
-
-	if (m_specularMap)
+	if (m_specularMap && instance.uniforms[nzMaterialUniform_SpecularMap] != -1)
 	{
-		int specularMapLocation = program->GetUniformLocation(nzShaderUniform_MaterialSpecularMap);
-		if (specularMapLocation != -1)
-		{
-			nzUInt8 textureUnit;
-			if (program->SendTexture(specularMapLocation, m_specularMap, &textureUnit))
-				NzRenderer::SetTextureSampler(textureUnit, m_specularSampler);
-			else
-				NazaraWarning("Failed to send specular map");
-		}
+		NzRenderer::SetTexture(textureUnit, m_specularMap);
+		NzRenderer::SetTextureSampler(textureUnit, m_specularSampler);
+		instance.shader->SendInteger(instance.uniforms[nzMaterialUniform_SpecularMap], textureUnit);
+		textureUnit++;
 	}
 
 	NzRenderer::SetRenderStates(m_states);
+
+	if (lastUsedUnit)
+		*lastUsedUnit = textureUnit;
+
+	return instance.shader;
 }
 
 void NzMaterial::Enable(nzRendererParameter renderParameter, bool enable)
@@ -169,16 +149,21 @@ void NzMaterial::EnableAlphaTest(bool alphaTest)
 {
 	m_alphaTestEnabled = alphaTest;
 
-	InvalidatePrograms(nzShaderTarget_FullscreenQuad);
-	InvalidatePrograms(nzShaderTarget_Model);
-	InvalidatePrograms(nzShaderTarget_Sprite);
+	InvalidateShaders();
 }
 
 void NzMaterial::EnableLighting(bool lighting)
 {
 	m_lightingEnabled = lighting;
 
-	InvalidatePrograms(nzShaderTarget_Model);
+	InvalidateShaders();
+}
+
+void NzMaterial::EnableTransform(bool transform)
+{
+	m_transformEnabled = transform;
+
+	InvalidateShaders();
 }
 
 NzTexture* NzMaterial::GetAlphaMap() const
@@ -256,13 +241,17 @@ const NzRenderStates& NzMaterial::GetRenderStates() const
 	return m_states;
 }
 
-const NzShaderProgram* NzMaterial::GetShaderProgram(nzShaderTarget target, nzUInt32 flags) const
+const NzUberShader* NzMaterial::GetShader() const
 {
-	const ProgramUnit& unit = m_programs[target][flags];
-	if (!unit.program.IsValid())
-		GenerateProgram(target, flags);
+	return m_uberShader;
+}
 
-	return unit.program;
+const NzUberShaderInstance* NzMaterial::GetShaderInstance(nzUInt32 flags) const
+{
+	if (!m_shaders[flags].uberInstance)
+		GenerateShader(flags);
+
+    return m_shaders[flags].uberInstance;
 }
 
 float NzMaterial::GetShininess() const
@@ -300,11 +289,6 @@ bool NzMaterial::HasAlphaMap() const
 	return m_alphaMap.IsValid();
 }
 
-bool NzMaterial::HasCustomShaderProgram(nzShaderTarget target, nzUInt32 flags) const
-{
-	return m_programs[target][flags].custom;
-}
-
 bool NzMaterial::HasDiffuseMap() const
 {
 	return m_diffuseMap.IsValid();
@@ -353,6 +337,11 @@ bool NzMaterial::IsLightingEnabled() const
 	return m_lightingEnabled;
 }
 
+bool NzMaterial::IsTransformEnabled() const
+{
+	return m_transformEnabled;
+}
+
 bool NzMaterial::LoadFromFile(const NzString& filePath, const NzMaterialParams& params)
 {
 	return NzMaterialLoader::LoadFromFile(this, filePath, params);
@@ -378,15 +367,10 @@ void NzMaterial::Reset()
 	m_heightMap.Reset();
 	m_normalMap.Reset();
 	m_specularMap.Reset();
+	m_uberShader.Reset();
 
-	for (unsigned int i = 0; i <= nzShaderTarget_Max; ++i)
-	{
-		for (ProgramUnit& unit : m_programs[i])
-		{
-			unit.custom = false;
-			unit.program.Reset();
-		}
-	}
+	for (ShaderInstance& instance : m_shaders)
+		instance.uberInstance = nullptr;
 
 	m_alphaThreshold = 0.2f;
 	m_alphaTestEnabled = false;
@@ -400,6 +384,9 @@ void NzMaterial::Reset()
 	m_states = NzRenderStates();
 	m_states.parameters[nzRendererParameter_DepthBuffer] = true;
 	m_states.parameters[nzRendererParameter_FaceCulling] = true;
+	m_transformEnabled = true;
+
+	SetShader("Basic");
 }
 
 bool NzMaterial::SetAlphaMap(const NzString& texturePath)
@@ -423,9 +410,7 @@ void NzMaterial::SetAlphaMap(NzTexture* map)
 {
 	m_alphaMap = map;
 
-	InvalidatePrograms(nzShaderTarget_FullscreenQuad);
-	InvalidatePrograms(nzShaderTarget_Model);
-	InvalidatePrograms(nzShaderTarget_Sprite);
+	InvalidateShaders();
 }
 
 void NzMaterial::SetAlphaThreshold(float alphaThreshold)
@@ -469,9 +454,7 @@ void NzMaterial::SetDiffuseMap(NzTexture* map)
 {
 	m_diffuseMap = map;
 
-	InvalidatePrograms(nzShaderTarget_FullscreenQuad);
-	InvalidatePrograms(nzShaderTarget_Model);
-	InvalidatePrograms(nzShaderTarget_Sprite);
+	InvalidateShaders();
 }
 
 void NzMaterial::SetDiffuseSampler(const NzTextureSampler& sampler)
@@ -505,7 +488,7 @@ void NzMaterial::SetEmissiveMap(NzTexture* map)
 {
 	m_emissiveMap = map;
 
-	InvalidatePrograms(nzShaderTarget_Model);
+	InvalidateShaders();
 }
 
 void NzMaterial::SetFaceCulling(nzFaceSide faceSide)
@@ -539,7 +522,7 @@ void NzMaterial::SetHeightMap(NzTexture* map)
 {
 	m_heightMap = map;
 
-	InvalidatePrograms(nzShaderTarget_Model);
+	InvalidateShaders();
 }
 
 bool NzMaterial::SetNormalMap(const NzString& texturePath)
@@ -563,7 +546,7 @@ void NzMaterial::SetNormalMap(NzTexture* map)
 {
 	m_normalMap = map;
 
-	InvalidatePrograms(nzShaderTarget_Model);
+	InvalidateShaders();
 }
 
 void NzMaterial::SetRenderStates(const NzRenderStates& states)
@@ -571,12 +554,20 @@ void NzMaterial::SetRenderStates(const NzRenderStates& states)
 	m_states = states;
 }
 
-void NzMaterial::SetShaderProgram(nzShaderTarget target, nzUInt32 flags, const NzShaderProgram* program)
+void NzMaterial::SetShader(const NzUberShader* uberShader)
 {
-	ProgramUnit& unit = m_programs[target][flags];
+	m_uberShader = uberShader;
+	InvalidateShaders();
+}
 
-	unit.custom = (program != nullptr);
-	unit.program = program;
+bool NzMaterial::SetShader(const NzString& uberShaderName)
+{
+	NzUberShader* uberShader = NzUberShaderLibrary::Get(uberShaderName);
+	if (!uberShader)
+		return false;
+
+	SetShader(uberShader);
+	return true;
 }
 
 void NzMaterial::SetShininess(float shininess)
@@ -610,7 +601,7 @@ void NzMaterial::SetSpecularMap(NzTexture* map)
 {
 	m_specularMap = map;
 
-	InvalidatePrograms(nzShaderTarget_Model);
+	InvalidateShaders();
 }
 
 void NzMaterial::SetSpecularSampler(const NzTextureSampler& sampler)
@@ -641,19 +632,115 @@ NzMaterial& NzMaterial::operator=(NzMaterial&& material)
 	material.m_heightMap.Reset();
 	material.m_normalMap.Reset();
 	material.m_specularMap.Reset();
-
-	for (unsigned int i = 0; i <= nzShaderTarget_Max; ++i)
-		for (ProgramUnit& unit : material.m_programs[i])
-			unit.program.Reset();
+	material.m_uberShader.Reset();
 
 	return *this;
 }
 
+bool NzMaterial::Initialize()
+{
+	bool glsl140 = (NzOpenGL::GetGLSLVersion() >= 140);
+
+	// Basic shader
+	{
+		std::unique_ptr<NzUberShaderPreprocessor> uberShader(new NzUberShaderPreprocessor);
+
+		NzString fragmentShader;
+		NzString vertexShader;
+		if (glsl140)
+		{
+			const nzUInt8 coreFragmentShader[] = {
+				#include <Nazara/Graphics/Resources/Shaders/Basic/core.frag.h>
+			};
+
+			const nzUInt8 coreVertexShader[] = {
+				#include <Nazara/Graphics/Resources/Shaders/Basic/core.vert.h>
+			};
+
+			fragmentShader.Set(reinterpret_cast<const char*>(coreFragmentShader), sizeof(coreFragmentShader));
+			vertexShader.Set(reinterpret_cast<const char*>(coreVertexShader), sizeof(coreVertexShader));
+		}
+		else
+		{
+			const nzUInt8 compatibilityFragmentShader[] = {
+				#include <Nazara/Graphics/Resources/Shaders/Basic/compatibility.frag.h>
+			};
+
+			const nzUInt8 compatibilityVertexShader[] = {
+				#include <Nazara/Graphics/Resources/Shaders/Basic/compatibility.vert.h>
+			};
+
+			fragmentShader.Set(reinterpret_cast<const char*>(compatibilityFragmentShader), sizeof(compatibilityFragmentShader));
+			vertexShader.Set(reinterpret_cast<const char*>(compatibilityVertexShader), sizeof(compatibilityVertexShader));
+		}
+
+		uberShader->SetShader(nzShaderStage_Fragment, fragmentShader, "ALPHA_MAPPING ALPHA_TEST AUTO_TEXCOORDS DIFFUSE_MAPPING");
+		uberShader->SetShader(nzShaderStage_Vertex, vertexShader, "FLAG_INSTANCING TEXTURE_MAPPING TRANSFORM UNIFORM_VERTEX_DEPTH");
+
+		NzUberShaderLibrary::Register("Basic", uberShader.get());
+		uberShader.release();
+	}
+
+	// PhongLighting shader
+	{
+		std::unique_ptr<NzUberShaderPreprocessor> uberShader(new NzUberShaderPreprocessor);
+
+		NzString fragmentShader;
+		NzString vertexShader;
+		if (glsl140)
+		{
+			const nzUInt8 coreFragmentShader[] = {
+				#include <Nazara/Graphics/Resources/Shaders/PhongLighting/core.frag.h>
+			};
+
+			const nzUInt8 coreVertexShader[] = {
+				#include <Nazara/Graphics/Resources/Shaders/PhongLighting/core.vert.h>
+			};
+
+			fragmentShader.Set(reinterpret_cast<const char*>(coreFragmentShader), sizeof(coreFragmentShader));
+			vertexShader.Set(reinterpret_cast<const char*>(coreVertexShader), sizeof(coreVertexShader));
+		}
+		else
+		{
+			const nzUInt8 compatibilityFragmentShader[] = {
+				#include <Nazara/Graphics/Resources/Shaders/PhongLighting/compatibility.frag.h>
+			};
+
+			const nzUInt8 compatibilityVertexShader[] = {
+				#include <Nazara/Graphics/Resources/Shaders/PhongLighting/compatibility.vert.h>
+			};
+
+			fragmentShader.Set(reinterpret_cast<const char*>(compatibilityFragmentShader), sizeof(compatibilityFragmentShader));
+			vertexShader.Set(reinterpret_cast<const char*>(compatibilityVertexShader), sizeof(compatibilityVertexShader));
+		}
+
+		uberShader->SetShader(nzShaderStage_Fragment, fragmentShader, "FLAG_DEFERRED ALPHA_MAPPING ALPHA_TEST DIFFUSE_MAPPING EMISSIVE_MAPPING LIGHTING NORMAL_MAPPING PARALLAX_MAPPING SPECULAR_MAPPING");
+		uberShader->SetShader(nzShaderStage_Vertex, vertexShader, "FLAG_DEFERRED FLAG_INSTANCING COMPUTE_TBNMATRIX LIGHTING PARALLAX_MAPPING TEXTURE_MAPPING TRANSFORM UNIFORM_VERTEX_DEPTH");
+
+		NzUberShaderLibrary::Register("PhongLighting", uberShader.get());
+		uberShader.release();
+	}
+
+	s_defaultMaterial = new NzMaterial;
+	s_defaultMaterial->SetPersistent(true);
+
+	return true;
+}
+
 NzMaterial* NzMaterial::GetDefault()
 {
 	return s_defaultMaterial;
 }
 
+void NzMaterial::Uninitialize()
+{
+	NzUberShaderLibrary::Unregister("PhongLighting");
+	NzUberShaderLibrary::Unregister("Basic");
+
+	s_defaultMaterial->SetPersistent(false, true);
+	s_defaultMaterial = nullptr;
+}
+
 void NzMaterial::Copy(const NzMaterial& material)
 {
 	m_alphaMap.Reset();
@@ -662,10 +749,7 @@ void NzMaterial::Copy(const NzMaterial& material)
 	m_heightMap.Reset();
 	m_normalMap.Reset();
 	m_specularMap.Reset();
-
-	for (unsigned int i = 0; i <= nzShaderTarget_Max; ++i)
-		for (ProgramUnit& unit : m_programs[i])
-			unit.program.Reset();
+	m_uberShader.Reset();
 
 	std::memcpy(this, &material, sizeof(NzMaterial)); // Autorisé dans notre cas, et bien plus rapide
 
@@ -676,6 +760,7 @@ void NzMaterial::Copy(const NzMaterial& material)
 	m_heightMap.Release();
 	m_normalMap.Release();
 	m_specularMap.Release();
+	m_uberShader.Release();
 
 	m_alphaMap = material.m_alphaMap;
 	m_diffuseMap = material.m_diffuseMap;
@@ -683,77 +768,53 @@ void NzMaterial::Copy(const NzMaterial& material)
 	m_heightMap = material.m_heightMap;
 	m_normalMap = material.m_normalMap;
 	m_specularMap = material.m_specularMap;
-
-	for (unsigned int i = 0; i <= nzShaderTarget_Max; ++i)
-	{
-		for (unsigned int j = 0; j <= nzShaderFlags_Max; ++j)
-		{
-			NzShaderProgramConstRef& program = m_programs[i][j].program;
-
-			program.Release();
-			program = material.m_programs[i][j].program;
-		}
-	}
+	m_uberShader = material.m_uberShader;
 }
 
-void NzMaterial::GenerateProgram(nzShaderTarget target, nzUInt32 flags) const
+void NzMaterial::GenerateShader(nzUInt32 flags) const
 {
-	NzShaderProgramManagerParams params;
-	params.target = target;
-	params.flags = flags;
+	NzParameterList list;
+	list.SetParameter("ALPHA_MAPPING", m_alphaMap.IsValid());
+	list.SetParameter("ALPHA_TEST", m_alphaTestEnabled);
+	list.SetParameter("COMPUTE_TBNMATRIX", m_normalMap.IsValid() || m_heightMap.IsValid());
+	list.SetParameter("DIFFUSE_MAPPING", m_diffuseMap.IsValid());
+	list.SetParameter("EMISSIVE_MAPPING", m_emissiveMap.IsValid());
+	list.SetParameter("LIGHTING", m_lightingEnabled);
+	list.SetParameter("NORMAL_MAPPING", m_normalMap.IsValid());
+	list.SetParameter("PARALLAX_MAPPING", m_heightMap.IsValid());
+	list.SetParameter("SPECULAR_MAPPING", m_specularMap.IsValid());
+	list.SetParameter("TEXTURE_MAPPING", m_alphaMap.IsValid() || m_diffuseMap.IsValid() || m_emissiveMap.IsValid() ||
+	                                     m_normalMap.IsValid() || m_heightMap.IsValid() || m_specularMap.IsValid());
+	list.SetParameter("TRANSFORM", m_transformEnabled);
 
-	switch (target)
-	{
-		case nzShaderTarget_FullscreenQuad:
-			params.fullscreenQuad.alphaMapping = m_alphaMap.IsValid();
-			params.fullscreenQuad.alphaTest = m_alphaTestEnabled;
-			params.fullscreenQuad.diffuseMapping = m_diffuseMap.IsValid();
-			break;
+	list.SetParameter("FLAG_DEFERRED", static_cast<bool>(flags & nzShaderFlags_Deferred));
+	list.SetParameter("FLAG_INSTANCING", static_cast<bool>(flags & nzShaderFlags_Instancing));
 
-		case nzShaderTarget_Model:
-			params.model.alphaMapping = m_alphaMap.IsValid();
-			params.model.alphaTest = m_alphaTestEnabled;
-			params.model.diffuseMapping = m_diffuseMap.IsValid();
-			params.model.emissiveMapping = m_emissiveMap.IsValid();
-			params.model.lighting = m_lightingEnabled;
-			params.model.normalMapping = m_normalMap.IsValid();
-			params.model.parallaxMapping = m_heightMap.IsValid();
-			params.model.specularMapping = m_specularMap.IsValid();
-			break;
+	ShaderInstance& instance = m_shaders[flags];
+	instance.uberInstance = m_uberShader->Get(list);
+	instance.shader = instance.uberInstance->GetShader();
 
-		case nzShaderTarget_None:
-			break;
+	#define CacheUniform(name) instance.uniforms[nzMaterialUniform_##name] = instance.shader->GetUniformLocation("Material" #name)
 
-		case nzShaderTarget_Sprite:
-			params.sprite.alphaMapping = m_alphaMap.IsValid();
-			params.sprite.alphaTest = m_alphaTestEnabled;
-			params.sprite.diffuseMapping = m_diffuseMap.IsValid();
-			break;
-	}
+	CacheUniform(AlphaMap);
+	CacheUniform(AlphaThreshold);
+	CacheUniform(Ambient);
+	CacheUniform(Diffuse);
+	CacheUniform(DiffuseMap);
+	CacheUniform(EmissiveMap);
+	CacheUniform(HeightMap);
+	CacheUniform(NormalMap);
+	CacheUniform(Shininess);
+	CacheUniform(Specular);
+	CacheUniform(SpecularMap);
 
-	m_programs[target][flags].program = NzShaderProgramManager::Get(params);
+	#undef CacheUniform
 }
 
-void NzMaterial::InvalidatePrograms(nzShaderTarget target)
+void NzMaterial::InvalidateShaders()
 {
-	for (ProgramUnit& unit : m_programs[target])
-	{
-		if (!unit.custom)
-			unit.program.Reset();
-	}
-}
-
-bool NzMaterial::Initialize()
-{
-	s_defaultMaterial = new NzMaterial;
-
-	return true;
-}
-
-void NzMaterial::Uninitialize()
-{
-	delete s_defaultMaterial;
-	s_defaultMaterial = nullptr;
+	for (ShaderInstance& instance : m_shaders)
+		instance.uberInstance = nullptr;
 }
 
 NzMaterial* NzMaterial::s_defaultMaterial = nullptr;

src/Nazara/Graphics/Model.cpp

@@ -6,6 +6,7 @@
 #include <Nazara/Graphics/AbstractRenderQueue.hpp>
 #include <Nazara/Graphics/Camera.hpp>
 #include <Nazara/Graphics/Config.hpp>
+#include <Nazara/Renderer/UberShaderLibrary.hpp>
 #include <Nazara/Utility/SkeletalMesh.hpp>
 #include <Nazara/Utility/StaticMesh.hpp>
 #include <memory>
@@ -19,6 +20,9 @@ bool NzModelParameters::IsValid() const
 	if (loadMaterials && !material.IsValid())
 		return false;
 
+	if (!NzUberShaderLibrary::Has(shaderName))
+		return false;
+
 	return mesh.IsValid();
 }
 
@@ -56,6 +60,8 @@ m_skinCount(model.m_skinCount)
 		if (m_mesh->GetAnimationType() == nzAnimationType_Skeletal)
 			m_skeleton = model.m_skeleton;
 	}
+
+	SetParent(model);
 }
 
 NzModel::~NzModel()
@@ -633,9 +639,9 @@ bool NzModel::FrustumCull(const NzFrustumf& frustum)
 	return frustum.Contains(m_boundingVolume);
 }
 
-void NzModel::Invalidate()
+void NzModel::InvalidateNode()
 {
-	NzSceneNode::Invalidate();
+	NzSceneNode::InvalidateNode();
 
 	m_boundingVolumeUpdated = false;
 }

src/Nazara/Graphics/Resources/DeferredShading/Shaders/Blit.frag

@@ -1,12 +0,0 @@
-#version 140
-
-out vec4 RenderTarget0;
-
-uniform sampler2D ColorTexture;
-uniform vec2 InvTargetSize;
-
-void main()
-{
-	vec2 texCoord = gl_FragCoord.xy * InvTargetSize;
-	RenderTarget0 = textureLod(ColorTexture, texCoord, 0.0);
-}

src/Nazara/Graphics/Resources/DeferredShading/Shaders/Blit.frag.h

@@ -1 +0,0 @@
-35,118,101,114,115,105,111,110,32,49,52,48,13,10,13,10,111,117,116,32,118,101,99,52,32,82,101,110,100,101,114,84,97,114,103,101,116,48,59,13,10,13,10,117,110,105,102,111,114,109,32,115,97,109,112,108,101,114,50,68,32,67,111,108,111,114,84,101,120,116,117,114,101,59,13,10,117,110,105,102,111,114,109,32,118,101,99,50,32,73,110,118,84,97,114,103,101,116,83,105,122,101,59,13,10,13,10,118,111,105,100,32,109,97,105,110,40,41,13,10,123,13,10,9,118,101,99,50,32,116,101,120,67,111,111,114,100,32,61,32,103,108,95,70,114,97,103,67,111,111,114,100,46,120,121,32,42,32,73,110,118,84,97,114,103,101,116,83,105,122,101,59,13,10,9,82,101,110,100,101,114,84,97,114,103,101,116,48,32,61,32,116,101,120,116,117,114,101,76,111,100,40,67,111,108,111,114,84,101,120,116,117,114,101,44,32,116,101,120,67,111,111,114,100,44,32,48,46,48,41,59,13,10,125,13,10,

src/Nazara/Graphics/Resources/DeferredShading/Shaders/DirectionalLight.frag

@@ -2,20 +2,11 @@
 
 out vec4 RenderTarget0;
 
-struct Light
-{
-	int type;
-	vec4 ambient;
-	vec4 color;
-	vec2 factors;
-
-	vec4 parameters1;
-	vec4 parameters2;
-	vec2 parameters3;
-};
-
 uniform vec3 EyePosition;
-uniform Light Lights[1];
+
+uniform vec4 LightColor;
+uniform vec2 LightFactors;
+uniform vec4 LightDirection;
 
 uniform sampler2D GBuffer0;
 uniform sampler2D GBuffer1;
@@ -56,15 +47,15 @@ void main()
 	float depth = ColorToFloat(gVec2.xyz);
 	float shininess = (gVec2.w == 0.0) ? 0.0 : exp2(gVec2.w*10.5);
 
-	vec3 lightDir = -Lights[0].parameters1.xyz;
+	vec3 lightDir = -LightDirection.xyz;
 
 	// Ambient
-	vec3 lightAmbient = Lights[0].color.rgb * Lights[0].factors.x * (vec3(1.0) + SceneAmbient.rgb);
+	vec3 lightAmbient = LightColor.rgb * LightFactors.x * (vec3(1.0) + SceneAmbient.rgb);
 
 	// Diffuse
 	float lambert = max(dot(normal, lightDir), 0.0);
 
-	vec3 lightDiffuse = lambert * Lights[0].color.rgb * Lights[0].factors.y;
+	vec3 lightDiffuse = lambert * LightColor.rgb * LightFactors.y;
 
 	// Specular
 	vec3 lightSpecular;
@@ -81,7 +72,7 @@ void main()
 		float specularFactor = max(dot(reflection, eyeVec), 0.0);
 		specularFactor = pow(specularFactor, shininess);
 
-		lightSpecular = specularFactor * Lights[0].color.rgb * specularMultiplier;
+		lightSpecular = specularFactor * LightColor.rgb * specularMultiplier;
 	}
 	else
 		lightSpecular = vec3(0.0);

src/Nazara/Graphics/Resources/DeferredShading/Shaders/PointSpotLight.frag

@@ -1,21 +1,20 @@
 #version 140
 
+#define LIGHT_DIRECTIONAL 0
+#define LIGHT_POINT 1
+#define LIGHT_SPOT 2
+
 out vec4 RenderTarget0;
 
-struct Light
-{
-	int type;
-	vec4 ambient;
-	vec4 color;
-	vec2 factors;
-
-	vec4 parameters1;
-	vec4 parameters2;
-	vec2 parameters3;
-};
-
 uniform vec3 EyePosition;
-uniform Light Lights[1];
+
+uniform int LightType;
+uniform vec4 LightColor;
+uniform vec2 LightFactors;
+uniform vec4 LightDirection;
+uniform vec4 LightParameters1;
+uniform vec4 LightParameters2;
+uniform vec2 LightParameters3;
 
 uniform sampler2D GBuffer0;
 uniform sampler2D GBuffer1;
@@ -26,7 +25,6 @@ uniform vec2 InvTargetSize;
 uniform vec4 SceneAmbient;
 
 uniform bool Discard = false;
-uniform bool SpotLight;
 
 float ColorToFloat(vec3 color)
 { 	
@@ -67,28 +65,28 @@ void main()
 	vec4 worldPos = InvViewProjMatrix * vec4(viewSpace, 1.0);
 	worldPos.xyz /= worldPos.w;
 
-	vec3 lightDir = Lights[0].parameters1.xyz - worldPos.xyz;
+	vec3 lightDir = LightParameters1.xyz - worldPos.xyz;
 	float lightDirLength = length(lightDir);
 	lightDir /= lightDirLength;
 
-	float att = max(Lights[0].parameters1.w - Lights[0].parameters2.w*lightDirLength, 0.0);
+	float att = max(LightParameters1.w - LightParameters2.w*lightDirLength, 0.0);
 
 	// Ambient
-	vec3 lightAmbient = att * Lights[0].color.rgb * Lights[0].factors.x * (vec3(1.0) + SceneAmbient.rgb);
+	vec3 lightAmbient = att * LightColor.rgb * LightFactors.x * (vec3(1.0) + SceneAmbient.rgb);
 
-	if (SpotLight)
+	if (LightType == LIGHT_SPOT)
 	{
 		// Modification de l'atténuation pour gérer le spot
-		float curAngle = dot(Lights[0].parameters2.xyz, -lightDir);
-		float outerAngle = Lights[0].parameters3.y;
-		float innerMinusOuterAngle = Lights[0].parameters3.x - outerAngle;
+		float curAngle = dot(LightParameters2.xyz, -lightDir);
+		float outerAngle = LightParameters3.y;
+		float innerMinusOuterAngle = LightParameters3.x - outerAngle;
 		att *= max((curAngle - outerAngle) / innerMinusOuterAngle, 0.0);
 	}
 	
 	// Diffuse
 	float lambert = max(dot(normal, lightDir), 0.0);
 
-	vec3 lightDiffuse = att * lambert * Lights[0].color.rgb * Lights[0].factors.y;
+	vec3 lightDiffuse = att * lambert * LightColor.rgb * LightFactors.y;
 
 	// Specular
 	vec3 lightSpecular;
@@ -99,7 +97,7 @@ void main()
 		float specularFactor = max(dot(reflection, eyeVec), 0.0);
 		specularFactor = pow(specularFactor, shininess);
 
-		lightSpecular = att * specularFactor * Lights[0].color.rgb * specularMultiplier;
+		lightSpecular = att * specularFactor * LightColor.rgb * specularMultiplier;
 	}
 	else
 		lightSpecular = vec3(0.0);

src/Nazara/Graphics/Resources/DeferredShading/Shaders/SSAO.frag

@@ -1,82 +0,0 @@
-#version 140
-
-out vec4 RenderTarget0;
-
-uniform float SSAOBias = 0.0;
-uniform float SSAOIntensity = 3.0;
-uniform float SSAOSampleScale = 0.1;
-uniform float SSAOScale = 1.0;
-uniform int NoiseTextureSize;
-uniform mat4 InvViewProjMatrix;
-uniform sampler2D GBuffer1;
-uniform sampler2D NoiseTexture;
-uniform vec2 TargetSize;
-uniform vec2 InvTargetSize;
-
-vec3 extractPosition(in float depth, in vec2 texCoord)
-{
-	depth = depth*2.0 - 1.0;
-
-	vec3 viewSpace = vec3(texCoord*2.0 - 1.0, depth);
-
-	vec4 worldPos = InvViewProjMatrix * vec4(viewSpace, 1.0);
-	worldPos.xyz /= worldPos.w;
-
-	return worldPos.xyz;
-}
-
-float doAmbientOcclusion(in vec2 texCoord, in vec3 original, in vec3 normal)
-{
-	vec3 newp = extractPosition(textureLod(GBuffer1, texCoord, 0.0).w, texCoord);
-	vec3 diff = newp - original;
-	float d = length(diff);
-	vec3 v = diff * 1.0/d;
-	d *= SSAOScale;
-
-	return max(0.0, dot(normal, v) - SSAOBias) * (SSAOIntensity / (1.0 + d));
-}
-
-void main(void)
-{
-	const vec2 Kernel[16] = vec2[](
-		vec2(0.53812504, 0.18565957),
-		vec2(0.13790712, 0.24864247),
-		vec2(0.33715037, 0.56794053),
-		vec2(-0.6999805, -0.04511441),
-		vec2(0.06896307, -0.15983082),
-		vec2(0.056099437, 0.006954967),
-		vec2(-0.014653638, 0.14027752),
-		vec2(0.010019933, -0.1924225),
-		vec2(-0.35775623, -0.5301969),
-		vec2(-0.3169221, 0.106360726),
-		vec2(0.010350345, -0.58698344),
-		vec2(-0.08972908, -0.49408212),
-		vec2(0.7119986, -0.0154690035),
-		vec2(-0.053382345, 0.059675813),
-		vec2(0.035267662, -0.063188605),
-		vec2(-0.47761092, 0.2847911));
-
-	vec2 texCoord = gl_FragCoord.xy * InvTargetSize;
-	vec4 gVec1 = textureLod(GBuffer1, texCoord, 0.0);
-	
-	if (gVec1.w == 1.0)
-	{
-		RenderTarget0 = vec4(1.0, 0.0, 0.0, 0.0);
-		return;
-	}
-	
-	vec3 normal = gVec1.xyz*2.0 - 1.0;
-
-	vec3 viewPos = extractPosition(gVec1.w, texCoord);
-	vec2 randVec = normalize(textureLod(NoiseTexture, texCoord * (TargetSize/NoiseTextureSize), 0.0).xy * 2.0 - 1.0);
-
-	float ao = 0.0;
-	const int ITERATIONS = 16;
-	for (int i = 0; i < ITERATIONS; ++i)
-	{
-		vec2 coord = reflect(Kernel[i], randVec) * SSAOSampleScale;
-		ao += doAmbientOcclusion(texCoord + coord, viewPos, normal);
-	}
-
-	RenderTarget0 = vec4(1.0 - ao/ITERATIONS, 0.0, 0.0, 0.0);
-}