Made Initialize/Uninitialize static methods from non-submodules private

Former-commit-id: 78dac32c8650dc9eb4fd2c7f0bece030012497cf

include/Nazara/Graphics/DeferredRenderTechnique.hpp

@@ -24,6 +24,8 @@
 
 class NAZARA_API NzDeferredRenderTechnique : public NzAbstractRenderTechnique, public NzRenderTarget::Listener
 {
+	friend class NzGraphics;
+
 	public:
 		NzDeferredRenderTechnique();
 		~NzDeferredRenderTechnique();
@@ -49,13 +51,14 @@ 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;
 
+		static bool Initialize();
+		static void Uninitialize();
+
 		struct RenderPassComparator
 		{
 			bool operator()(nzRenderPassType pass1, nzRenderPassType pass2);

include/Nazara/Graphics/Material.hpp

@@ -41,7 +41,7 @@ using NzMaterialRef = NzResourceRef<NzMaterial>;
 class NAZARA_API NzMaterial : public NzResource
 {
 	friend NzMaterialLoader;
-	friend class NzRenderer;
+	friend class NzGraphics;
 
 	public:
 		NzMaterial();
@@ -129,9 +129,7 @@ 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 ShaderInstance
@@ -145,6 +143,9 @@ class NAZARA_API NzMaterial : public NzResource
 		void GenerateShader(nzUInt32 flags) const;
 		void InvalidateShaders();
 
+		static bool Initialize();
+		static void Uninitialize();
+
 		NzColor m_ambientColor;
 		NzColor m_diffuseColor;
 		NzColor m_specularColor;

include/Nazara/Renderer/Context.hpp

@@ -22,6 +22,7 @@ class NzContextImpl;
 class NAZARA_API NzContext : public NzResource
 {
 	friend NzContextImpl;
+	friend class NzOpenGL;
 
 	public:
 		NzContext() = default;
@@ -39,10 +40,11 @@ class NAZARA_API NzContext : public NzResource
 		static const NzContext* GetCurrent();
 		static const NzContext* GetReference();
 		static const NzContext* GetThreadContext();
+
+	private:
 		static bool Initialize();
 		static void Uninitialize();
 
-	private:
 		NzContextParameters m_parameters;
 		NzContextImpl* m_impl = nullptr;
 

include/Nazara/Renderer/ShaderLibrary.hpp

@@ -14,6 +14,8 @@
 
 class NAZARA_API NzShaderLibrary
 {
+	friend class NzRenderer;
+
 	public:
 		NzShaderLibrary() = delete;
 		~NzShaderLibrary() = delete;
@@ -21,12 +23,13 @@ class NAZARA_API NzShaderLibrary
 		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 bool Initialize();
+		static void Uninitialize();
+
 		static std::unordered_map<NzString, NzShaderRef> s_library;
 };
 

include/Nazara/Renderer/UberShaderLibrary.hpp

@@ -14,6 +14,8 @@
 
 class NAZARA_API NzUberShaderLibrary
 {
+	friend class NzRenderer;
+
 	public:
 		NzUberShaderLibrary() = delete;
 		~NzUberShaderLibrary() = delete;
@@ -21,12 +23,13 @@ class NAZARA_API NzUberShaderLibrary
 		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 bool Initialize();
+		static void Uninitialize();
+
 		static std::unordered_map<NzString, NzUberShaderRef> s_library;
 };
 

src/Nazara/Graphics/DeferredRenderTechnique.cpp

@@ -379,6 +379,37 @@ void NzDeferredRenderTechnique::SetPass(nzRenderPassType relativeTo, int positio
 		m_passes[relativeTo].erase(position);
 }
 
+bool NzDeferredRenderTechnique::IsSupported()
+{
+	// On ne va pas s'embêter à écrire un Deferred Renderer qui ne passe pas par le MRT, ce serait trop lent pour servir...
+	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;
+}
+
+bool NzDeferredRenderTechnique::Resize(const NzVector2ui& dimensions) const
+{
+	try
+	{
+		NzErrorFlags errFlags(nzErrorFlag_ThrowException);
+
+		for (auto& passIt : m_passes)
+			for (auto& passIt2 : passIt.second)
+				passIt2.second->Resize(dimensions);
+
+		m_GBufferSize = dimensions;
+
+		return true;
+	}
+	catch (const std::exception& e)
+	{
+		NazaraError("Failed to create work RTT/G-Buffer");
+		return false;
+	}
+}
+
 bool NzDeferredRenderTechnique::Initialize()
 {
 	const nzUInt8 fragmentSource_BloomBright[] = {
@@ -540,16 +571,6 @@ bool NzDeferredRenderTechnique::Initialize()
 	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 trop lent pour servir...
-	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;
-}
-
 void NzDeferredRenderTechnique::Uninitialize()
 {
 	NzShaderLibrary::Unregister("DeferredGBufferClear");
@@ -561,27 +582,6 @@ void NzDeferredRenderTechnique::Uninitialize()
 	NzShaderLibrary::Unregister("DeferredGaussianBlur");
 }
 
-bool NzDeferredRenderTechnique::Resize(const NzVector2ui& dimensions) const
-{
-	try
-	{
-		NzErrorFlags errFlags(nzErrorFlag_ThrowException);
-
-		for (auto& passIt : m_passes)
-			for (auto& passIt2 : passIt.second)
-				passIt2.second->Resize(dimensions);
-
-		m_GBufferSize = dimensions;
-
-		return true;
-	}
-	catch (const std::exception& e)
-	{
-		NazaraError("Failed to create work RTT/G-Buffer");
-		return false;
-	}
-}
-
 bool NzDeferredRenderTechnique::RenderPassComparator::operator()(nzRenderPassType pass1, nzRenderPassType pass2)
 {
 	return RenderPassPriority[pass1] < RenderPassPriority[pass2];

src/Nazara/Graphics/Material.cpp

@@ -638,6 +638,88 @@ NzMaterial& NzMaterial::operator=(NzMaterial&& material)
 	return *this;
 }
 
+NzMaterial* NzMaterial::GetDefault()
+{
+	return s_defaultMaterial;
+}
+
+void NzMaterial::Copy(const NzMaterial& material)
+{
+	// On relache les références proprement
+	m_alphaMap.Reset();
+	m_diffuseMap.Reset();
+	m_emissiveMap.Reset();
+	m_heightMap.Reset();
+	m_normalMap.Reset();
+	m_specularMap.Reset();
+	m_uberShader.Reset();
+
+	std::memcpy(this, &material, sizeof(NzMaterial)); // Autorisé dans notre cas, et bien plus rapide
+
+	// Ensuite une petite astuce pour récupérer correctement les références
+	m_alphaMap.Release();
+	m_diffuseMap.Release();
+	m_emissiveMap.Release();
+	m_heightMap.Release();
+	m_normalMap.Release();
+	m_specularMap.Release();
+	m_uberShader.Release();
+
+	m_alphaMap = material.m_alphaMap;
+	m_diffuseMap = material.m_diffuseMap;
+	m_emissiveMap = material.m_emissiveMap;
+	m_heightMap = material.m_heightMap;
+	m_normalMap = material.m_normalMap;
+	m_specularMap = material.m_specularMap;
+	m_uberShader = material.m_uberShader;
+}
+
+void NzMaterial::GenerateShader(nzUInt32 flags) const
+{
+	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);
+
+	list.SetParameter("FLAG_DEFERRED", static_cast<bool>(flags & nzShaderFlags_Deferred));
+	list.SetParameter("FLAG_INSTANCING", static_cast<bool>(flags & nzShaderFlags_Instancing));
+
+	ShaderInstance& instance = m_shaders[flags];
+	instance.uberInstance = m_uberShader->Get(list);
+	instance.shader = instance.uberInstance->GetShader();
+
+	#define CacheUniform(name) instance.uniforms[nzMaterialUniform_##name] = instance.shader->GetUniformLocation("Material" #name)
+
+	CacheUniform(AlphaMap);
+	CacheUniform(AlphaThreshold);
+	CacheUniform(Ambient);
+	CacheUniform(Diffuse);
+	CacheUniform(DiffuseMap);
+	CacheUniform(EmissiveMap);
+	CacheUniform(HeightMap);
+	CacheUniform(NormalMap);
+	CacheUniform(Shininess);
+	CacheUniform(Specular);
+	CacheUniform(SpecularMap);
+
+	#undef CacheUniform
+}
+
+void NzMaterial::InvalidateShaders()
+{
+	for (ShaderInstance& instance : m_shaders)
+		instance.uberInstance = nullptr;
+}
+
 bool NzMaterial::Initialize()
 {
 	bool glsl140 = (NzOpenGL::GetGLSLVersion() >= 140);
@@ -733,11 +815,6 @@ bool NzMaterial::Initialize()
 	return true;
 }
 
-NzMaterial* NzMaterial::GetDefault()
-{
-	return s_defaultMaterial;
-}
-
 void NzMaterial::Uninitialize()
 {
 	NzUberShaderLibrary::Unregister("PhongLighting");
@@ -747,82 +824,5 @@ void NzMaterial::Uninitialize()
 	s_defaultMaterial = nullptr;
 }
 
-void NzMaterial::Copy(const NzMaterial& material)
-{
-	// On relache les références proprement
-	m_alphaMap.Reset();
-	m_diffuseMap.Reset();
-	m_emissiveMap.Reset();
-	m_heightMap.Reset();
-	m_normalMap.Reset();
-	m_specularMap.Reset();
-	m_uberShader.Reset();
-
-	std::memcpy(this, &material, sizeof(NzMaterial)); // Autorisé dans notre cas, et bien plus rapide
-
-	// Ensuite une petite astuce pour récupérer correctement les références
-	m_alphaMap.Release();
-	m_diffuseMap.Release();
-	m_emissiveMap.Release();
-	m_heightMap.Release();
-	m_normalMap.Release();
-	m_specularMap.Release();
-	m_uberShader.Release();
-
-	m_alphaMap = material.m_alphaMap;
-	m_diffuseMap = material.m_diffuseMap;
-	m_emissiveMap = material.m_emissiveMap;
-	m_heightMap = material.m_heightMap;
-	m_normalMap = material.m_normalMap;
-	m_specularMap = material.m_specularMap;
-	m_uberShader = material.m_uberShader;
-}
-
-void NzMaterial::GenerateShader(nzUInt32 flags) const
-{
-	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);
-
-	list.SetParameter("FLAG_DEFERRED", static_cast<bool>(flags & nzShaderFlags_Deferred));
-	list.SetParameter("FLAG_INSTANCING", static_cast<bool>(flags & nzShaderFlags_Instancing));
-
-	ShaderInstance& instance = m_shaders[flags];
-	instance.uberInstance = m_uberShader->Get(list);
-	instance.shader = instance.uberInstance->GetShader();
-
-	#define CacheUniform(name) instance.uniforms[nzMaterialUniform_##name] = instance.shader->GetUniformLocation("Material" #name)
-
-	CacheUniform(AlphaMap);
-	CacheUniform(AlphaThreshold);
-	CacheUniform(Ambient);
-	CacheUniform(Diffuse);
-	CacheUniform(DiffuseMap);
-	CacheUniform(EmissiveMap);
-	CacheUniform(HeightMap);
-	CacheUniform(NormalMap);
-	CacheUniform(Shininess);
-	CacheUniform(Specular);
-	CacheUniform(SpecularMap);
-
-	#undef CacheUniform
-}
-
-void NzMaterial::InvalidateShaders()
-{
-	for (ShaderInstance& instance : m_shaders)
-		instance.uberInstance = nullptr;
-}
-
 NzMaterial* NzMaterial::s_defaultMaterial = nullptr;
 NzMaterialLoader::LoaderList NzMaterial::s_loaders;

src/Nazara/Renderer/ShaderLibrary.cpp

@@ -23,17 +23,23 @@ bool NzShaderLibrary::Has(const NzString& name)
 	return s_library.find(name) != s_library.end();
 }
 
-bool NzShaderLibrary::Initialize()
-{
-	return true; // Que faire
-}
-
 void NzShaderLibrary::Register(const NzString& name, NzShader* shader)
 {
 	s_library.emplace(name, shader);
 	NazaraDebug("Shader \"" + name + "\" registred");
 }
 
+void NzShaderLibrary::Unregister(const NzString& name)
+{
+	s_library.erase(name);
+	NazaraDebug("Shader \"" + name + "\" unregistred");
+}
+
+bool NzShaderLibrary::Initialize()
+{
+	return true; // Que faire
+}
+
 void NzShaderLibrary::Uninitialize()
 {
 	for (auto it : s_library)
@@ -42,10 +48,4 @@ void NzShaderLibrary::Uninitialize()
 	s_library.clear();
 }
 
-void NzShaderLibrary::Unregister(const NzString& name)
-{
-	s_library.erase(name);
-	NazaraDebug("Shader \"" + name + "\" unregistred");
-}
-
 std::unordered_map<NzString, NzShaderRef> NzShaderLibrary::s_library;

src/Nazara/Renderer/UberShaderLibrary.cpp

@@ -23,17 +23,23 @@ bool NzUberShaderLibrary::Has(const NzString& name)
 	return s_library.find(name) != s_library.end();
 }
 
-bool NzUberShaderLibrary::Initialize()
-{
-	return true; // Que faire
-}
-
 void NzUberShaderLibrary::Register(const NzString& name, NzUberShader* uberShader)
 {
 	s_library.emplace(name, uberShader);
 	NazaraDebug("UberShader \"" + name + "\" registred");
 }
 
+void NzUberShaderLibrary::Unregister(const NzString& name)
+{
+	s_library.erase(name);
+	NazaraDebug("UberShader \"" + name + "\" unregistred");
+}
+
+bool NzUberShaderLibrary::Initialize()
+{
+	return true; // Que faire
+}
+
 void NzUberShaderLibrary::Uninitialize()
 {
 	for (auto it : s_library)
@@ -42,10 +48,4 @@ void NzUberShaderLibrary::Uninitialize()
 	s_library.clear();
 }
 
-void NzUberShaderLibrary::Unregister(const NzString& name)
-{
-	s_library.erase(name);
-	NazaraDebug("UberShader \"" + name + "\" unregistred");
-}
-
 std::unordered_map<NzString, NzUberShaderRef> NzUberShaderLibrary::s_library;