Merge branch 'master' into vulkan

Former-commit-id: 875dd773cefa6dde4744443851378e33bfab0ab8

src/Nazara/Core/File.cpp

@@ -454,24 +454,24 @@ namespace Nz
 		return true;
 	}
 
-    /*!
-    * \brief Sets the size of the file
-    * \return true if the file size has correctly changed
-    *
-    * \param size The size the file should have after this call
-    *
-    * \remark The cursor position is not affected by this call
-    * \remark The file must be open in write mode
-    */
-    bool File::SetSize(UInt64 size)
-    {
-        NazaraLock(m_mutex)
+	/*!
+	* \brief Sets the size of the file
+	* \return true if the file size has correctly changed
+	*
+	* \param size The size the file should have after this call
+	*
+	* \remark The cursor position is not affected by this call
+	* \remark The file must be open in write mode
+	*/
+	bool File::SetSize(UInt64 size)
+	{
+		NazaraLock(m_mutex)
 
-        NazaraAssert(IsOpen(), "File is not open");
-        NazaraAssert(IsWritable(), "File is not writable");
+		NazaraAssert(IsOpen(), "File is not open");
+		NazaraAssert(IsWritable(), "File is not writable");
 
-        return m_impl->SetSize(size);
-    }
+		return m_impl->SetSize(size);
+	}
 
 	/*!
 	* \brief Sets the file path

src/Nazara/Core/ParameterList.cpp

@@ -22,7 +22,6 @@ namespace Nz
 	/*!
 	* \brief Constructs a ParameterList object by copy
 	*/
-
 	ParameterList::ParameterList(const ParameterList& list)
 	{
 		operator=(list);
@@ -31,16 +30,14 @@ namespace Nz
 	/*!
 	* \brief Destructs the object and clears
 	*/
-
 	ParameterList::~ParameterList()
 	{
 		Clear();
 	}
 
 	/*!
-	* \brief Clears the list of parameters
+	* \brief Clears all the parameters
 	*/
-
 	void ParameterList::Clear()
 	{
 		for (auto it = m_parameters.begin(); it != m_parameters.end(); ++it)
@@ -50,17 +47,18 @@ namespace Nz
 	}
 
 	/*!
-	* \brief Gets a boolean parameter by name
-	* \return true if success
+	* \brief Gets a parameter as a boolean
+	* \return true if the parameter could be represented as a boolean
 	*
-	* \param name Name of the variable
-	* \param value Value to set
+	* \param name Name of the parameter
+	* \param value Pointer to a boolean to hold the retrieved value
 	*
-	* \remark Produces a NazaraAssert if pointer is invalid
-	* \remark Produces a silent NazaraError if name is not a variable
-	* \remark Produces a silent NazaraError if value could not be convertible
+	* \remark value must be a valid pointer
+	* \remark In case of failure, the variable pointed by value keep its value
+	* \remark If the parameter is not a boolean, a conversion will be performed, compatibles types are:
+	          Integer: 0 is interpreted as false, any other value is interpreted as true
+	          String:  Conversion obeys the rule as described by String::ToBool
 	*/
-
 	bool ParameterList::GetBooleanParameter(const String& name, bool* value) const
 	{
 		NazaraAssert(value, "Invalid pointer");
@@ -85,17 +83,17 @@ namespace Nz
 				return true;
 
 			case ParameterType_String:
+			{
+				bool converted;
+				if (it->second.value.stringVal.ToBool(&converted, String::CaseInsensitive))
 				{
-					bool converted;
-					if (it->second.value.stringVal.ToBool(&converted, String::CaseInsensitive))
-					{
-						*value = converted;
-						return true;
-					}
-
-					break;
+					*value = converted;
+					return true;
 				}
 
+				break;
+			}
+
 			case ParameterType_Float:
 			case ParameterType_None:
 			case ParameterType_Pointer:
@@ -108,17 +106,62 @@ namespace Nz
 	}
 
 	/*!
-	* \brief Gets a float parameter by name
-	* \return true if success
+	* \brief Gets a parameter as a color
+	* \return true if the parameter could be represented as a color
 	*
-	* \param name Name of the variable
-	* \param value Value to set
+	* \param name Name of the parameter
+	* \param value Pointer to a color to hold the retrieved value
 	*
-	* \remark Produces a NazaraAssert if pointer is invalid
-	* \remark Produces a silent NazaraError if name is not a variable
-	* \remark Produces a silent NazaraError if value could not be convertible
+	* \remark value must be a valid pointer
+	* \remark In case of failure, the variable pointed by value keep its value
+	* \remark If the parameter is not a color, the function fails
 	*/
+	bool ParameterList::GetColorParameter(const String& name, Color* value) const
+	{
+		NazaraAssert(value, "Invalid pointer");
 
+		ErrorFlags flags(ErrorFlag_Silent | ErrorFlag_ThrowExceptionDisabled);
+
+		auto it = m_parameters.find(name);
+		if (it == m_parameters.end())
+		{
+			NazaraError("Parameter \"" + name + "\" is not present");
+			return false;
+		}
+
+		switch (it->second.type)
+		{
+			case ParameterType_Color:
+				*value = it->second.value.colorVal;
+				return true;
+
+			case ParameterType_Boolean:
+			case ParameterType_Integer:
+			case ParameterType_String:
+			case ParameterType_Float:
+			case ParameterType_None:
+			case ParameterType_Pointer:
+			case ParameterType_Userdata:
+				break;
+		}
+
+		NazaraError("Parameter value is not representable as a color");
+		return false;
+	}
+
+	/*!
+	* \brief Gets a parameter as a float
+	* \return true if the parameter could be represented as a float
+	*
+	* \param name Name of the parameter
+	* \param value Pointer to a float to hold the retrieved value
+	*
+	* \remark value must be a valid pointer
+	* \remark In case of failure, the variable pointed by value keep its value
+	* \remark If the parameter is not a float, a conversion will be performed, compatibles types are:
+	          Integer: The integer value is converted to its float representation
+	          String:  Conversion obeys the rule as described by String::ToDouble
+	*/
 	bool ParameterList::GetFloatParameter(const String& name, float* value) const
 	{
 		NazaraAssert(value, "Invalid pointer");
@@ -164,19 +207,21 @@ namespace Nz
 		NazaraError("Parameter value is not representable as a float");
 		return false;
 	}
-
+	
 	/*!
-	* \brief Gets a integer parameter by name
-	* \return true if success
+	* \brief Gets a parameter as an integer
+	* \return true if the parameter could be represented as an integer
 	*
-	* \param name Name of the variable
-	* \param value Value to set
+	* \param name Name of the parameter
+	* \param value Pointer to an integer to hold the retrieved value
 	*
-	* \remark Produces a NazaraAssert if pointer is invalid
-	* \remark Produces a silent NazaraError if name is not a variable
-	* \remark Produces a silent NazaraError if value could not be convertible
+	* \remark value must be a valid pointer
+	* \remark In case of failure, the variable pointed by value keep its value
+	* \remark If the parameter is not a float, a conversion will be performed, compatibles types are:
+	          Boolean: The boolean is represented as 1 if true and 0 if false
+	          Float:   The floating-point value is truncated and converted to a integer
+	          String:  Conversion obeys the rule as described by String::ToInteger but fails if the value could not be represented as a int
 	*/
-
 	bool ParameterList::GetIntegerParameter(const String& name, int* value) const
 	{
 		NazaraAssert(value, "Invalid pointer");
@@ -229,15 +274,14 @@ namespace Nz
 	}
 
 	/*!
-	* \brief Gets a parameter type by name
-	* \return true if the parameter is present
+	* \brief Gets a parameter type
+	* \return true if the parameter is present, its type being written to type
 	*
 	* \param name Name of the variable
-	* \param type Pointer to a variable to hold result
+	* \param type Pointer to a variable to hold the result
 	*
-	* \remark Produces a NazaraAssert if type is invalid
+	* \remark type must be a valid pointer to a ParameterType variable
 	*/
-
 	bool ParameterList::GetParameterType(const String& name, ParameterType* type) const
 	{
 		NazaraAssert(type, "Invalid pointer");
@@ -252,17 +296,17 @@ namespace Nz
 	}
 
 	/*!
-	* \brief Gets a pointer parameter by name
-	* \return true if success
+	* \brief Gets a parameter as a pointer
+	* \return true if the parameter could be represented as a pointer
 	*
-	* \param name Name of the variable
-	* \param value Value to set
+	* \param name Name of the parameter
+	* \param value Pointer to a pointer to hold the retrieved value
 	*
-	* \remark Produces a NazaraAssert if pointer is invalid
-	* \remark Produces a silent NazaraError if name is not a variable
-	* \remark Produces a silent NazaraError if value could not be convertible
+	* \remark value must be a valid pointer
+	* \remark In case of failure, the variable pointed by value keep its value
+	* \remark If the parameter is not a pointer, a conversion will be performed, compatibles types are:
+	          Userdata: The pointer part of the userdata is returned
 	*/
-
 	bool ParameterList::GetPointerParameter(const String& name, void** value) const
 	{
 		NazaraAssert(value, "Invalid pointer");
@@ -299,17 +343,23 @@ namespace Nz
 	}
 
 	/*!
-	* \brief Gets a string parameter by name
-	* \return true if success
+	* \brief Gets a parameter as a string
+	* \return true if the parameter could be represented as a string
 	*
-	* \param name Name of the variable
-	* \param value Value to set
+	* \param name Name of the parameter
+	* \param value Pointer to a pointer to hold the retrieved value
 	*
-	* \remark Produces a NazaraAssert if pointer is invalid
-	* \remark Produces a silent NazaraError if name is not a variable
-	* \remark Produces a silent NazaraError if value could not be convertible
+	* \remark value must be a valid pointer
+	* \remark In case of failure, the variable pointed by value keep its value
+	* \remark If the parameter is not a string, a conversion will be performed, all types are compatibles:
+	          Boolean:  Conversion obeys the rules of String::Boolean
+	          Color:    Conversion obeys the rules of Color::ToString
+	          Float:    Conversion obeys the rules of String::Number
+	          Integer:  Conversion obeys the rules of String::Number
+	          None:     An empty string is returned
+	          Pointer:  Conversion obeys the rules of String::Pointer
+	          Userdata: Conversion obeys the rules of String::Pointer
 	*/
-
 	bool ParameterList::GetStringParameter(const String& name, String* value) const
 	{
 		NazaraAssert(value, "Invalid pointer");
@@ -329,6 +379,10 @@ namespace Nz
 				*value = String::Boolean(it->second.value.boolVal);
 				return true;
 
+			case ParameterType_Color:
+				*value = it->second.value.colorVal.ToString();
+				return true;
+
 			case ParameterType_Float:
 				*value = String::Number(it->second.value.floatVal);
 				return true;
@@ -357,19 +411,20 @@ namespace Nz
 		NazaraInternalError("Parameter value is not valid");
 		return false;
 	}
-
+	
 	/*!
-	* \brief Gets a user parameter by name
-	* \return true if success
+	* \brief Gets a parameter as an userdata
+	* \return true if the parameter could be represented as a userdata
 	*
-	* \param name Name of the variable
-	* \param value Value to set
+	* \param name Name of the parameter
+	* \param value Pointer to a pointer to hold the retrieved value
 	*
-	* \remark Produces a NazaraAssert if pointer is invalid
-	* \remark Produces a silent NazaraError if name is not a variable
-	* \remark Produces a silent NazaraError if value could not be convertible
+	* \remark value must be a valid pointer
+	* \remark In case of failure, the variable pointed by value keep its value
+	* \remark If the parameter is not an userdata, the function fails
+	*
+	* \see GetPointerParameter
 	*/
-
 	bool ParameterList::GetUserdataParameter(const String& name, void** value) const
 	{
 		NazaraAssert(value, "Invalid pointer");
@@ -396,25 +451,24 @@ namespace Nz
 	}
 
 	/*!
-	* \brief Checks whether the parameter list has a parameter with that name
+	* \brief Checks whether the parameter list contains a parameter named `name`
 	* \return true if found
 	*
 	* \param name Name of the parameter
 	*/
-
 	bool ParameterList::HasParameter(const String& name) const
 	{
 		return m_parameters.find(name) != m_parameters.end();
 	}
 
 	/*!
-	* \brief Removes the parameter with that name
+	* \brief Removes the parameter named `name`
 	*
-	* Removes the parameter with that name, if not found, nothing is done
+	* Search for a parameter named `name` and remove it from the parameter list, freeing up its memory
+	* Nothing is done if the parameter is not present in the parameter list
 	*
 	* \param name Name of the parameter
 	*/
-
 	void ParameterList::RemoveParameter(const String& name)
 	{
 		auto it = m_parameters.find(name);
@@ -426,11 +480,12 @@ namespace Nz
 	}
 
 	/*!
-	* \brief Sets the parameter with the name to ParameterType_None
+	* \brief Sets a null parameter named `name`
+	*
+	* If a parameter already exists with that name, it is destroyed and replaced by this call
 	*
 	* \param name Name of the parameter
 	*/
-
 	void ParameterList::SetParameter(const String& name)
 	{
 		Parameter& parameter = CreateValue(name);
@@ -438,12 +493,29 @@ namespace Nz
 	}
 
 	/*!
-	* \brief Sets the parameter with the name to the value
+	* \brief Sets a color parameter named `name`
+	*
+	* If a parameter already exists with that name, it is destroyed and replaced by this call
 	*
 	* \param name Name of the parameter
-	* \param value Value of the parameter
+	* \param value The color value
 	*/
+	void ParameterList::SetParameter(const String& name, const Color& value)
+	{
+		Parameter& parameter = CreateValue(name);
+		parameter.type = ParameterType_Color;
 
+		PlacementNew(&parameter.value.colorVal, value);
+	}
+
+	/*!
+	* \brief Sets a string parameter named `name`
+	*
+	* If a parameter already exists with that name, it is destroyed and replaced by this call
+	*
+	* \param name Name of the parameter
+	* \param value The string value
+	*/
 	void ParameterList::SetParameter(const String& name, const String& value)
 	{
 		Parameter& parameter = CreateValue(name);
@@ -453,12 +525,13 @@ namespace Nz
 	}
 
 	/*!
-	* \brief Sets the parameter with the name to the value
+	* \brief Sets a string parameter named `name`
+	*
+	* If a parameter already exists with that name, it is destroyed and replaced by this call
 	*
 	* \param name Name of the parameter
-	* \param value Value of the parameter
+	* \param value The string value
 	*/
-
 	void ParameterList::SetParameter(const String& name, const char* value)
 	{
 		Parameter& parameter = CreateValue(name);
@@ -468,41 +541,13 @@ namespace Nz
 	}
 
 	/*!
-	* \brief Sets the parameter with the name to the value
+	* \brief Sets a boolean parameter named `name`
+	*
+	* If a parameter already exists with that name, it is destroyed and replaced by this call
 	*
 	* \param name Name of the parameter
-	* \param value Value of the parameter
+	* \param value The boolean value
 	*/
-
-	void ParameterList::SetParameter(const String& name, void* value)
-	{
-		Parameter& parameter = CreateValue(name);
-		parameter.type = ParameterType_Pointer;
-		parameter.value.ptrVal = value;
-	}
-
-	/*!
-	* \brief Sets the parameter with the name to the value
-	*
-	* \param name Name of the parameter
-	* \param value Value of the parameter
-	* \param destructor Destructor for dynamic variable
-	*/
-
-	void ParameterList::SetParameter(const String& name, void* value, Destructor destructor)
-	{
-		Parameter& parameter = CreateValue(name);
-		parameter.type = ParameterType_Userdata;
-		parameter.value.userdataVal = new Parameter::UserdataValue(destructor, value);
-	}
-
-	/*!
-	* \brief Sets the parameter with the name to the value
-	*
-	* \param name Name of the parameter
-	* \param value Value of the parameter
-	*/
-
 	void ParameterList::SetParameter(const String& name, bool value)
 	{
 		Parameter& parameter = CreateValue(name);
@@ -511,12 +556,13 @@ namespace Nz
 	}
 
 	/*!
-	* \brief Sets the parameter with the name to the value
+	* \brief Sets a float parameter named `name`
+	*
+	* If a parameter already exists with that name, it is destroyed and replaced by this call
 	*
 	* \param name Name of the parameter
-	* \param value Value of the parameter
+	* \param value The float value
 	*/
-
 	void ParameterList::SetParameter(const String& name, float value)
 	{
 		Parameter& parameter = CreateValue(name);
@@ -525,26 +571,63 @@ namespace Nz
 	}
 
 	/*!
-	* \brief Sets the parameter with the name to the value
+	* \brief Sets an integer parameter named `name`
+	*
+	* If a parameter already exists with that name, it is destroyed and replaced by this call
 	*
 	* \param name Name of the parameter
-	* \param value Value of the parameter
+	* \param value The integer value
 	*/
-
 	void ParameterList::SetParameter(const String& name, int value)
 	{
 		Parameter& parameter = CreateValue(name);
 		parameter.type = ParameterType_Integer;
 		parameter.value.intVal = value;
 	}
+	
+	/*!
+	* \brief Sets a pointer parameter named `name`
+	*
+	* If a parameter already exists with that name, it is destroyed and replaced by this call
+	*
+	* \param name Name of the parameter
+	* \param value The pointer value
+	*
+	* \remark This sets a raw pointer, this class takes no responsibility toward it, 
+	          if you wish to destroy the pointed variable along with the parameter list, you should set a userdata
+	*/
+	void ParameterList::SetParameter(const String& name, void* value)
+	{
+		Parameter& parameter = CreateValue(name);
+		parameter.type = ParameterType_Pointer;
+		parameter.value.ptrVal = value;
+	}
 
 	/*!
-	* \brief Assigns the content of the other parameter list to this
+	* \brief Sets a userdata parameter named `name`
+	*
+	* If a parameter already exists with that name, it is destroyed and replaced by this call
+	*
+	* \param name Name of the parameter
+	* \param value The pointer value
+	* \param destructor The destructor function to be called upon parameter suppression
+	*
+	* \remark The destructor is called once when all copies of the userdata are destroyed, which means
+	          you can safely copy the parameter list around.
+	*/
+	void ParameterList::SetParameter(const String& name, void* value, Destructor destructor)
+	{
+		Parameter& parameter = CreateValue(name);
+		parameter.type = ParameterType_Userdata;
+		parameter.value.userdataVal = new Parameter::UserdataValue(destructor, value);
+	}
+
+	/*!
+	* \brief Copies the content of the other parameter list to this
 	* \return A reference to this
 	*
 	* \param list List to assign
 	*/
-
 	ParameterList& ParameterList::operator=(const ParameterList& list)
 	{
 		Clear();
@@ -627,6 +710,7 @@ namespace Nz
 				}
 
 			case ParameterType_Boolean:
+			case ParameterType_Color:
 			case ParameterType_Float:
 			case ParameterType_Integer:
 			case ParameterType_None:

src/Nazara/Core/Posix/FileImpl.cpp

@@ -118,6 +118,11 @@ namespace Nz
 		return lseek64(m_fileDescriptor, offset, moveMethod) != -1;
 	}
 
+	bool FileImpl::SetSize(UInt64 size)
+	{
+		return ftruncate64(m_fileDescriptor, size) != 0;
+	}
+
 	std::size_t FileImpl::Write(const void* buffer, std::size_t size)
 	{
 		lockf64(m_fileDescriptor, F_LOCK, size);

src/Nazara/Core/Posix/FileImpl.hpp

@@ -39,6 +39,7 @@ namespace Nz
 			bool Open(const String& filePath, UInt32 mode);
 			std::size_t Read(void* buffer, std::size_t size);
 			bool SetCursorPos(CursorPosition pos, Int64 offset);
+			bool SetSize(UInt64 size);
 			std::size_t Write(const void* buffer, std::size_t size);
 
 			FileImpl& operator=(const FileImpl&) = delete;

src/Nazara/Core/SerializationContext.cpp

@@ -0,0 +1,35 @@
+// Copyright (C) 2015 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/SerializationContext.hpp>
+#include <Nazara/Core/Algorithm.hpp>
+#include <Nazara/Core/Error.hpp>
+#include <Nazara/Core/Debug.hpp>
+
+namespace Nz
+{
+
+	/*!
+	* \ingroup core
+	* \class Nz::SerializationContext
+	* \brief Structure containing a serialization/unserialization context states
+	*/
+
+	/*!
+	 * Write bits to the stream (if any) and reset the current bit cursor
+	
+	* \see ResetBitPosition
+	*/
+	void SerializationContext::FlushBits()
+	{
+		if (currentBitPos != 8)
+		{
+			ResetBitPosition();
+
+			// Serialize will reset the bit position
+			if (!Serialize<UInt8>(*this, currentByte))
+				NazaraWarning("Failed to flush bits");
+		}
+	}
+}

src/Nazara/Core/String.cpp

@@ -4240,7 +4240,7 @@ namespace Nz
 				utf8::unchecked::iterator<const char*> it(m_sharedString->string.get());
 				do
 				{
-					if ((Unicode::GetCategory(*it) & Unicode::Category_Separator) == 0)
+					if (*it != '\t' && (Unicode::GetCategory(*it) & Unicode::Category_Separator) == 0)
 						break;
 				}
 				while (*++it);
@@ -4255,7 +4255,7 @@ namespace Nz
 				utf8::unchecked::iterator<const char*> it(&m_sharedString->string[m_sharedString->size]);
 				while ((it--).base() != m_sharedString->string.get())
 				{
-					if ((Unicode::GetCategory(*it) & Unicode::Category_Separator) == 0)
+					if (*it != '\t' && (Unicode::GetCategory(*it) & Unicode::Category_Separator) == 0)
 						break;
 				}
 
@@ -4271,7 +4271,8 @@ namespace Nz
 			{
 				for (; startPos < m_sharedString->size; ++startPos)
 				{
-					if ((Unicode::GetCategory(m_sharedString->string[startPos]) & Unicode::Category_Separator) == 0)
+                    char c = m_sharedString->string[startPos];
+					if (c != '\t' && (Unicode::GetCategory(c) & Unicode::Category_Separator) == 0)
 						break;
 				}
 			}
@@ -4281,7 +4282,8 @@ namespace Nz
 			{
 				for (; endPos > 0; --endPos)
 				{
-					if ((Unicode::GetCategory(m_sharedString->string[endPos]) & Unicode::Category_Separator) == 0)
+                    char c = m_sharedString->string[endPos];
+					if (c != '\t' && (Unicode::GetCategory(c) & Unicode::Category_Separator) == 0)
 						break;
 				}
 			}

src/Nazara/Graphics/DepthRenderQueue.cpp

@@ -0,0 +1,217 @@
+// Copyright (C) 2015 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Graphics module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Graphics/DepthRenderQueue.hpp>
+#include <Nazara/Graphics/AbstractViewer.hpp>
+#include <Nazara/Graphics/Material.hpp>
+#include <Nazara/Graphics/Debug.hpp>
+
+namespace Nz
+{
+	DepthRenderQueue::DepthRenderQueue()
+	{
+		// Material
+		m_baseMaterial = Material::New();
+		m_baseMaterial->Enable(RendererParameter_ColorWrite, false);
+		m_baseMaterial->Enable(RendererParameter_FaceCulling, false);
+		//m_baseMaterial->SetFaceCulling(FaceSide_Front);
+	}
+
+	void DepthRenderQueue::AddBillboard(int renderOrder, const Material* material, const Vector3f& position, const Vector2f& size, const Vector2f& sinCos, const Color& color)
+	{
+		NazaraAssert(material, "Invalid material");
+		NazaraUnused(renderOrder);
+
+		if (!IsMaterialSuitable(material))
+			return;
+
+		if (material->HasDepthMaterial())
+			material = material->GetDepthMaterial();
+		else
+			material = m_baseMaterial;
+
+		ForwardRenderQueue::AddBillboard(0, material, position, size, sinCos, color);
+	}
+
+	void DepthRenderQueue::AddBillboards(int renderOrder, const Material* material, unsigned int count, SparsePtr<const Vector3f> positionPtr, SparsePtr<const Vector2f> sizePtr, SparsePtr<const Vector2f> sinCosPtr, SparsePtr<const Color> colorPtr)
+	{
+		NazaraAssert(material, "Invalid material");
+		NazaraUnused(renderOrder);
+
+		if (!IsMaterialSuitable(material))
+			return;
+
+		if (material->HasDepthMaterial())
+			material = material->GetDepthMaterial();
+		else
+			material = m_baseMaterial;
+
+		ForwardRenderQueue::AddBillboards(0, material, count, positionPtr, sizePtr, sinCosPtr, colorPtr);
+	}
+
+	void DepthRenderQueue::AddBillboards(int renderOrder, const Material* material, unsigned int count, SparsePtr<const Vector3f> positionPtr, SparsePtr<const Vector2f> sizePtr, SparsePtr<const Vector2f> sinCosPtr, SparsePtr<const float> alphaPtr)
+	{
+		NazaraAssert(material, "Invalid material");
+		NazaraUnused(renderOrder);
+
+		if (!IsMaterialSuitable(material))
+			return;
+
+		if (material->HasDepthMaterial())
+			material = material->GetDepthMaterial();
+		else
+			material = m_baseMaterial;
+
+		ForwardRenderQueue::AddBillboards(0, material, count, positionPtr, sizePtr, sinCosPtr, alphaPtr);
+	}
+
+	void DepthRenderQueue::AddBillboards(int renderOrder, const Material* material, unsigned int count, SparsePtr<const Vector3f> positionPtr, SparsePtr<const Vector2f> sizePtr, SparsePtr<const float> anglePtr, SparsePtr<const Color> colorPtr)
+	{
+		NazaraAssert(material, "Invalid material");
+		NazaraUnused(renderOrder);
+
+		if (!IsMaterialSuitable(material))
+			return;
+
+		if (material->HasDepthMaterial())
+			material = material->GetDepthMaterial();
+		else
+			material = m_baseMaterial;
+
+		ForwardRenderQueue::AddBillboards(0, material, count, positionPtr, sizePtr, anglePtr, colorPtr);
+	}
+
+	void DepthRenderQueue::AddBillboards(int renderOrder, const Material* material, unsigned int count, SparsePtr<const Vector3f> positionPtr, SparsePtr<const Vector2f> sizePtr, SparsePtr<const float> anglePtr, SparsePtr<const float> alphaPtr)
+	{
+		NazaraAssert(material, "Invalid material");
+		NazaraUnused(renderOrder);
+
+		if (!IsMaterialSuitable(material))
+			return;
+
+		if (material->HasDepthMaterial())
+			material = material->GetDepthMaterial();
+		else
+			material = m_baseMaterial;
+
+		ForwardRenderQueue::AddBillboards(0, material, count, positionPtr, sizePtr, anglePtr, alphaPtr);
+	}
+
+	void DepthRenderQueue::AddBillboards(int renderOrder, const Material* material, unsigned int count, SparsePtr<const Vector3f> positionPtr, SparsePtr<const float> sizePtr, SparsePtr<const Vector2f> sinCosPtr, SparsePtr<const Color> colorPtr)
+	{
+		NazaraAssert(material, "Invalid material");
+		NazaraUnused(renderOrder);
+
+		if (!IsMaterialSuitable(material))
+			return;
+
+		if (material->HasDepthMaterial())
+			material = material->GetDepthMaterial();
+		else
+			material = m_baseMaterial;
+
+		ForwardRenderQueue::AddBillboards(0, material, count, positionPtr, sizePtr, sinCosPtr, colorPtr);
+	}
+
+	void DepthRenderQueue::AddBillboards(int renderOrder, const Material* material, unsigned int count, SparsePtr<const Vector3f> positionPtr, SparsePtr<const float> sizePtr, SparsePtr<const Vector2f> sinCosPtr, SparsePtr<const float> alphaPtr)
+	{
+		NazaraAssert(material, "Invalid material");
+		NazaraUnused(renderOrder);
+
+		if (!IsMaterialSuitable(material))
+			return;
+
+		if (material->HasDepthMaterial())
+			material = material->GetDepthMaterial();
+		else
+			material = m_baseMaterial;
+
+		ForwardRenderQueue::AddBillboards(0, material, count, positionPtr, sizePtr, sinCosPtr, alphaPtr);
+	}
+
+	void DepthRenderQueue::AddBillboards(int renderOrder, const Material* material, unsigned int count, SparsePtr<const Vector3f> positionPtr, SparsePtr<const float> sizePtr, SparsePtr<const float> anglePtr, SparsePtr<const Color> colorPtr)
+	{
+		NazaraAssert(material, "Invalid material");
+		NazaraUnused(renderOrder);
+
+		if (!IsMaterialSuitable(material))
+			return;
+
+		if (material->HasDepthMaterial())
+			material = material->GetDepthMaterial();
+		else
+			material = m_baseMaterial;
+
+		ForwardRenderQueue::AddBillboards(0, material, count, positionPtr, sizePtr, anglePtr, colorPtr);
+	}
+
+	void DepthRenderQueue::AddBillboards(int renderOrder, const Material* material, unsigned int count, SparsePtr<const Vector3f> positionPtr, SparsePtr<const float> sizePtr, SparsePtr<const float> anglePtr, SparsePtr<const float> alphaPtr)
+	{
+		NazaraAssert(material, "Invalid material");
+		NazaraUnused(renderOrder);
+
+		if (!IsMaterialSuitable(material))
+			return;
+
+		if (material->HasDepthMaterial())
+			material = material->GetDepthMaterial();
+		else
+			material = m_baseMaterial;
+
+		ForwardRenderQueue::AddBillboards(0, material, count, positionPtr, sizePtr, anglePtr, alphaPtr);
+	}
+
+	void DepthRenderQueue::AddDirectionalLight(const DirectionalLight& light)
+	{
+		NazaraAssert(false, "Depth render queue doesn't handle lights");
+		NazaraUnused(light);
+	}
+
+	void DepthRenderQueue::AddMesh(int renderOrder, const Material* material, const MeshData& meshData, const Boxf& meshAABB, const Matrix4f& transformMatrix)
+	{
+		NazaraAssert(material, "Invalid material");
+		NazaraUnused(renderOrder);
+		NazaraUnused(meshAABB);
+
+		if (!IsMaterialSuitable(material))
+			return;
+
+		if (material->HasDepthMaterial())
+			material = material->GetDepthMaterial();
+		else
+			material = m_baseMaterial;
+
+		ForwardRenderQueue::AddMesh(0, material, meshData, meshAABB, transformMatrix);
+	}
+
+	void DepthRenderQueue::AddPointLight(const PointLight& light)
+	{
+		NazaraAssert(false, "Depth render queue doesn't handle lights");
+		NazaraUnused(light);
+	}
+
+	void DepthRenderQueue::AddSpotLight(const SpotLight& light)
+	{
+		NazaraAssert(false, "Depth render queue doesn't handle lights");
+		NazaraUnused(light);
+	}
+
+	void DepthRenderQueue::AddSprites(int renderOrder, const Material* material, const VertexStruct_XYZ_Color_UV* vertices, unsigned int spriteCount, const Texture* overlay)
+	{
+		NazaraAssert(material, "Invalid material");
+		NazaraUnused(renderOrder);
+		NazaraUnused(overlay);
+
+		if (!IsMaterialSuitable(material))
+			return;
+
+		if (material->HasDepthMaterial())
+			material = material->GetDepthMaterial();
+		else
+			material = m_baseMaterial;
+
+		ForwardRenderQueue::AddSprites(0, material, vertices, spriteCount, overlay);
+	}
+}
+

src/Nazara/Graphics/DepthRenderTechnique.cpp

@@ -0,0 +1,539 @@
+// Copyright (C) 2015 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Graphics module"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Graphics/DepthRenderTechnique.hpp>
+#include <Nazara/Core/ErrorFlags.hpp>
+#include <Nazara/Core/OffsetOf.hpp>
+#include <Nazara/Graphics/AbstractBackground.hpp>
+#include <Nazara/Graphics/AbstractViewer.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/Renderer.hpp>
+#include <Nazara/Utility/BufferMapper.hpp>
+#include <Nazara/Utility/StaticMesh.hpp>
+#include <Nazara/Utility/VertexStruct.hpp>
+#include <limits>
+#include <memory>
+#include <Nazara/Graphics/Debug.hpp>
+
+namespace Nz
+{
+	namespace
+	{
+		struct BillboardPoint
+		{
+			Color color;
+			Vector3f position;
+			Vector2f size;
+			Vector2f sinCos; // must follow `size` (both will be sent as a Vector4f)
+			Vector2f uv;
+		};
+
+		unsigned int s_maxQuads = std::numeric_limits<UInt16>::max() / 6;
+		unsigned int s_vertexBufferSize = 4 * 1024 * 1024; // 4 MiB
+	}
+
+	DepthRenderTechnique::DepthRenderTechnique() :
+		m_vertexBuffer(BufferType_Vertex)
+	{
+		ErrorFlags flags(ErrorFlag_ThrowException, true);
+
+		m_vertexBuffer.Create(s_vertexBufferSize, DataStorage_Hardware, BufferUsage_Dynamic);
+
+		m_billboardPointBuffer.Reset(&s_billboardVertexDeclaration, &m_vertexBuffer);
+		m_spriteBuffer.Reset(VertexDeclaration::Get(VertexLayout_XYZ_Color_UV), &m_vertexBuffer);
+	}
+
+	void DepthRenderTechnique::Clear(const SceneData& sceneData) const
+	{
+		Renderer::Enable(RendererParameter_DepthBuffer, true);
+		Renderer::Enable(RendererParameter_DepthWrite, true);
+		Renderer::Clear(RendererBuffer_Depth);
+
+		// Just in case the background does render depth
+		//if (sceneData.background)
+		//	sceneData.background->Draw(sceneData.viewer);
+	}
+
+	bool DepthRenderTechnique::Draw(const SceneData& sceneData) const
+	{
+		for (auto& pair : m_renderQueue.layers)
+		{
+			ForwardRenderQueue::Layer& layer = pair.second;
+
+			if (!layer.opaqueModels.empty())
+				DrawOpaqueModels(sceneData, layer);
+
+			if (!layer.basicSprites.empty())
+				DrawBasicSprites(sceneData, layer);
+
+			if (!layer.billboards.empty())
+				DrawBillboards(sceneData, layer);
+
+			for (const Drawable* drawable : layer.otherDrawables)
+				drawable->Draw();
+		}
+
+		return true;
+	}
+
+	AbstractRenderQueue* DepthRenderTechnique::GetRenderQueue()
+	{
+		return &m_renderQueue;
+	}
+
+	RenderTechniqueType DepthRenderTechnique::GetType() const
+	{
+		return RenderTechniqueType_Depth;
+	}
+
+	bool DepthRenderTechnique::Initialize()
+	{
+		try
+		{
+			ErrorFlags flags(ErrorFlag_ThrowException, true);
+
+			s_quadIndexBuffer.Reset(false, s_maxQuads * 6, DataStorage_Hardware, BufferUsage_Static);
+
+			BufferMapper<IndexBuffer> mapper(s_quadIndexBuffer, BufferAccess_WriteOnly);
+			UInt16* indices = static_cast<UInt16*>(mapper.GetPointer());
+
+			for (unsigned int i = 0; i < s_maxQuads; ++i)
+			{
+				*indices++ = i * 4 + 0;
+				*indices++ = i * 4 + 2;
+				*indices++ = i * 4 + 1;
+
+				*indices++ = i * 4 + 2;
+				*indices++ = i * 4 + 3;
+				*indices++ = i * 4 + 1;
+			}
+
+			mapper.Unmap(); // Inutile de garder le buffer ouvert plus longtemps
+
+			// Quad buffer (utilisé pour l'instancing de billboard et de sprites)
+			//Note: Les UV sont calculés dans le shader
+			s_quadVertexBuffer.Reset(VertexDeclaration::Get(VertexLayout_XY), 4, DataStorage_Hardware, BufferUsage_Static);
+
+			float vertices[2 * 4] = {
+			   -0.5f, -0.5f,
+			    0.5f, -0.5f,
+			   -0.5f, 0.5f,
+			    0.5f, 0.5f,
+			};
+
+			s_quadVertexBuffer.FillRaw(vertices, 0, sizeof(vertices));
+
+			// Déclaration lors du rendu des billboards par sommet
+			s_billboardVertexDeclaration.EnableComponent(VertexComponent_Color, ComponentType_Color, NazaraOffsetOf(BillboardPoint, color));
+			s_billboardVertexDeclaration.EnableComponent(VertexComponent_Position, ComponentType_Float3, NazaraOffsetOf(BillboardPoint, position));
+			s_billboardVertexDeclaration.EnableComponent(VertexComponent_TexCoord, ComponentType_Float2, NazaraOffsetOf(BillboardPoint, uv));
+			s_billboardVertexDeclaration.EnableComponent(VertexComponent_Userdata0, ComponentType_Float4, NazaraOffsetOf(BillboardPoint, size)); // Englobe sincos
+
+			// Declaration utilisée lors du rendu des billboards par instancing
+			// L'avantage ici est la copie directe (std::memcpy) des données de la RenderQueue vers le buffer GPU
+			s_billboardInstanceDeclaration.EnableComponent(VertexComponent_InstanceData0, ComponentType_Float3, NazaraOffsetOf(ForwardRenderQueue::BillboardData, center));
+			s_billboardInstanceDeclaration.EnableComponent(VertexComponent_InstanceData1, ComponentType_Float4, NazaraOffsetOf(ForwardRenderQueue::BillboardData, size)); // Englobe sincos
+			s_billboardInstanceDeclaration.EnableComponent(VertexComponent_InstanceData2, ComponentType_Color, NazaraOffsetOf(ForwardRenderQueue::BillboardData, color));
+		}
+		catch (const std::exception& e)
+		{
+			NazaraError("Failed to initialise: " + String(e.what()));
+			return false;
+		}
+
+		return true;
+	}
+
+	void DepthRenderTechnique::Uninitialize()
+	{
+		s_quadIndexBuffer.Reset();
+		s_quadVertexBuffer.Reset();
+	}
+	
+	void DepthRenderTechnique::DrawBasicSprites(const SceneData& sceneData, ForwardRenderQueue::Layer& layer) const
+	{
+		const Shader* lastShader = nullptr;
+		const ShaderUniforms* shaderUniforms = nullptr;
+
+		Renderer::SetIndexBuffer(&s_quadIndexBuffer);
+		Renderer::SetMatrix(MatrixType_World, Matrix4f::Identity());
+		Renderer::SetVertexBuffer(&m_spriteBuffer);
+
+		for (auto& matIt : layer.basicSprites)
+		{
+			const Material* material = matIt.first;
+			auto& matEntry = matIt.second;
+
+			if (matEntry.enabled)
+			{
+				auto& overlayMap = matEntry.overlayMap;
+				for (auto& overlayIt : overlayMap)
+				{
+					const Texture* overlay = overlayIt.first;
+					auto& spriteChainVector = overlayIt.second.spriteChains;
+
+					unsigned int spriteChainCount = spriteChainVector.size();
+					if (spriteChainCount > 0)
+					{
+						// On commence par appliquer du matériau (et récupérer le shader ainsi activé)
+						UInt32 flags = 0;
+						if (overlay)
+							flags |= ShaderFlags_TextureOverlay;
+
+						UInt8 overlayUnit;
+						const Shader* shader = material->Apply(flags, 0, &overlayUnit);
+
+						if (overlay)
+						{
+							overlayUnit++;
+							Renderer::SetTexture(overlayUnit, overlay);
+							Renderer::SetTextureSampler(overlayUnit, material->GetDiffuseSampler());
+						}
+
+						// Les uniformes sont conservées au sein d'un programme, inutile de les renvoyer tant qu'il ne change pas
+						if (shader != lastShader)
+						{
+							// Index des uniformes dans le shader
+							shaderUniforms = GetShaderUniforms(shader);
+
+							// Overlay
+							shader->SendInteger(shaderUniforms->textureOverlay, overlayUnit);
+							// Position de la caméra
+							shader->SendVector(shaderUniforms->eyePosition, Renderer::GetMatrix(MatrixType_ViewProj).GetTranslation());
+
+							lastShader = shader;
+						}
+
+						unsigned int spriteChain = 0; // Quelle chaîne de sprite traitons-nous
+						unsigned int spriteChainOffset = 0; // À quel offset dans la dernière chaîne nous sommes-nous arrêtés
+
+						do
+						{
+							// On ouvre le buffer en écriture
+							BufferMapper<VertexBuffer> vertexMapper(m_spriteBuffer, BufferAccess_DiscardAndWrite);
+							VertexStruct_XYZ_Color_UV* vertices = reinterpret_cast<VertexStruct_XYZ_Color_UV*>(vertexMapper.GetPointer());
+
+							unsigned int spriteCount = 0;
+							unsigned int maxSpriteCount = std::min(s_maxQuads, m_spriteBuffer.GetVertexCount()/4);
+
+							do
+							{
+								ForwardRenderQueue::SpriteChain_XYZ_Color_UV& currentChain = spriteChainVector[spriteChain];
+								unsigned int count = std::min(maxSpriteCount - spriteCount, currentChain.spriteCount - spriteChainOffset);
+
+								std::memcpy(vertices, currentChain.vertices + spriteChainOffset*4, 4*count*sizeof(VertexStruct_XYZ_Color_UV));
+								vertices += count*4;
+
+								spriteCount += count;
+								spriteChainOffset += count;
+
+								// Avons-nous traité la chaîne entière ?
+								if (spriteChainOffset == currentChain.spriteCount)
+								{
+									spriteChain++;
+									spriteChainOffset = 0;
+								}
+							}
+							while (spriteCount < maxSpriteCount && spriteChain < spriteChainCount);
+
+							vertexMapper.Unmap();
+
+							Renderer::DrawIndexedPrimitives(PrimitiveMode_TriangleList, 0, spriteCount*6);
+						}
+						while (spriteChain < spriteChainCount);
+
+						spriteChainVector.clear();
+					}
+				}
+
+				// On remet à zéro
+				matEntry.enabled = false;
+			}
+		}
+	}
+
+	void DepthRenderTechnique::DrawBillboards(const SceneData& sceneData, ForwardRenderQueue::Layer& layer) const
+	{
+		const Shader* lastShader = nullptr;
+		const ShaderUniforms* shaderUniforms = nullptr;
+
+		if (Renderer::HasCapability(RendererCap_Instancing))
+		{
+			VertexBuffer* instanceBuffer = Renderer::GetInstanceBuffer();
+			instanceBuffer->SetVertexDeclaration(&s_billboardInstanceDeclaration);
+
+			Renderer::SetVertexBuffer(&s_quadVertexBuffer);
+
+			for (auto& matIt : layer.billboards)
+			{
+				const Material* material = matIt.first;
+				auto& entry = matIt.second;
+				auto& billboardVector = entry.billboards;
+
+				unsigned int billboardCount = billboardVector.size();
+				if (billboardCount > 0)
+				{
+					// On commence par appliquer du matériau (et récupérer le shader ainsi activé)
+					const Shader* shader = material->Apply(ShaderFlags_Billboard | ShaderFlags_Instancing | ShaderFlags_VertexColor);
+
+					// Les uniformes sont conservées au sein d'un programme, inutile de les renvoyer tant qu'il ne change pas
+					if (shader != lastShader)
+					{
+						// Index des uniformes dans le shader
+						shaderUniforms = GetShaderUniforms(shader);
+
+						// Position de la caméra
+						shader->SendVector(shaderUniforms->eyePosition, Renderer::GetMatrix(MatrixType_ViewProj).GetTranslation());
+
+						lastShader = shader;
+					}
+
+					const ForwardRenderQueue::BillboardData* data = &billboardVector[0];
+					unsigned int maxBillboardPerDraw = instanceBuffer->GetVertexCount();
+					do
+					{
+						unsigned int renderedBillboardCount = std::min(billboardCount, maxBillboardPerDraw);
+						billboardCount -= renderedBillboardCount;
+
+						instanceBuffer->Fill(data, 0, renderedBillboardCount, true);
+						data += renderedBillboardCount;
+
+						Renderer::DrawPrimitivesInstanced(renderedBillboardCount, PrimitiveMode_TriangleStrip, 0, 4);
+					}
+					while (billboardCount > 0);
+
+					billboardVector.clear();
+				}
+			}
+		}
+		else
+		{
+			Renderer::SetIndexBuffer(&s_quadIndexBuffer);
+			Renderer::SetVertexBuffer(&m_billboardPointBuffer);
+
+			for (auto& matIt : layer.billboards)
+			{
+				const Material* material = matIt.first;
+				auto& entry = matIt.second;
+				auto& billboardVector = entry.billboards;
+
+				unsigned int billboardCount = billboardVector.size();
+				if (billboardCount > 0)
+				{
+					// On commence par appliquer du matériau (et récupérer le shader ainsi activé)
+					const Shader* shader = material->Apply(ShaderFlags_Billboard | ShaderFlags_VertexColor);
+
+					// Les uniformes sont conservées au sein d'un programme, inutile de les renvoyer tant qu'il ne change pas
+					if (shader != lastShader)
+					{
+						// Index des uniformes dans le shader
+						shaderUniforms = GetShaderUniforms(shader);
+
+						// Position de la caméra
+						shader->SendVector(shaderUniforms->eyePosition, Renderer::GetMatrix(MatrixType_ViewProj).GetTranslation());
+
+						lastShader = shader;
+					}
+
+					const ForwardRenderQueue::BillboardData* data = &billboardVector[0];
+					unsigned int maxBillboardPerDraw = std::min(s_maxQuads, m_billboardPointBuffer.GetVertexCount()/4);
+
+					do
+					{
+						unsigned int renderedBillboardCount = std::min(billboardCount, maxBillboardPerDraw);
+						billboardCount -= renderedBillboardCount;
+
+						BufferMapper<VertexBuffer> vertexMapper(m_billboardPointBuffer, BufferAccess_DiscardAndWrite, 0, renderedBillboardCount*4);
+						BillboardPoint* vertices = reinterpret_cast<BillboardPoint*>(vertexMapper.GetPointer());
+
+						for (unsigned int i = 0; i < renderedBillboardCount; ++i)
+						{
+							const ForwardRenderQueue::BillboardData& billboard = *data++;
+
+							vertices->color = billboard.color;
+							vertices->position = billboard.center;
+							vertices->sinCos = billboard.sinCos;
+							vertices->size = billboard.size;
+							vertices->uv.Set(0.f, 1.f);
+							vertices++;
+
+							vertices->color = billboard.color;
+							vertices->position = billboard.center;
+							vertices->sinCos = billboard.sinCos;
+							vertices->size = billboard.size;
+							vertices->uv.Set(1.f, 1.f);
+							vertices++;
+
+							vertices->color = billboard.color;
+							vertices->position = billboard.center;
+							vertices->sinCos = billboard.sinCos;
+							vertices->size = billboard.size;
+							vertices->uv.Set(0.f, 0.f);
+							vertices++;
+
+							vertices->color = billboard.color;
+							vertices->position = billboard.center;
+							vertices->sinCos = billboard.sinCos;
+							vertices->size = billboard.size;
+							vertices->uv.Set(1.f, 0.f);
+							vertices++;
+						}
+
+						vertexMapper.Unmap();
+
+						Renderer::DrawIndexedPrimitives(PrimitiveMode_TriangleList, 0, renderedBillboardCount*6);
+					}
+					while (billboardCount > 0);
+
+					billboardVector.clear();
+				}
+			}
+		}
+	}
+
+	void DepthRenderTechnique::DrawOpaqueModels(const SceneData& sceneData, ForwardRenderQueue::Layer& layer) const
+	{
+		const Shader* lastShader = nullptr;
+		const ShaderUniforms* shaderUniforms = nullptr;
+
+		for (auto& matIt : layer.opaqueModels)
+		{
+			auto& matEntry = matIt.second;
+
+			if (matEntry.enabled)
+			{
+				ForwardRenderQueue::MeshInstanceContainer& meshInstances = matEntry.meshMap;
+
+				if (!meshInstances.empty())
+				{
+					const Material* material = matIt.first;
+
+					bool instancing = m_instancingEnabled && matEntry.instancingEnabled;
+
+					// On commence par appliquer du matériau (et récupérer le shader ainsi activé)
+					UInt8 freeTextureUnit;
+					const Shader* shader = material->Apply((instancing) ? ShaderFlags_Instancing : 0, 0, &freeTextureUnit);
+
+					// Les uniformes sont conservées au sein d'un programme, inutile de les renvoyer tant qu'il ne change pas
+					if (shader != lastShader)
+					{
+						// Index des uniformes dans le shader
+						shaderUniforms = GetShaderUniforms(shader);
+						lastShader = shader;
+					}
+
+					// Meshes
+					for (auto& meshIt : meshInstances)
+					{
+						const MeshData& meshData = meshIt.first;
+						auto& meshEntry = meshIt.second;
+
+						const Spheref& squaredBoundingSphere = meshEntry.squaredBoundingSphere;
+						std::vector<Matrix4f>& instances = meshEntry.instances;
+
+						if (!instances.empty())
+						{
+							const IndexBuffer* indexBuffer = meshData.indexBuffer;
+							const VertexBuffer* vertexBuffer = meshData.vertexBuffer;
+
+							// Gestion du draw call avant la boucle de rendu
+							Renderer::DrawCall drawFunc;
+							Renderer::DrawCallInstanced instancedDrawFunc;
+							unsigned int indexCount;
+
+							if (indexBuffer)
+							{
+								drawFunc = Renderer::DrawIndexedPrimitives;
+								instancedDrawFunc = Renderer::DrawIndexedPrimitivesInstanced;
+								indexCount = indexBuffer->GetIndexCount();
+							}
+							else
+							{
+								drawFunc = Renderer::DrawPrimitives;
+								instancedDrawFunc = Renderer::DrawPrimitivesInstanced;
+								indexCount = vertexBuffer->GetVertexCount();
+							}
+
+							Renderer::SetIndexBuffer(indexBuffer);
+							Renderer::SetVertexBuffer(vertexBuffer);
+
+							if (instancing)
+							{
+								// On calcule le nombre d'instances que l'on pourra afficher cette fois-ci (Selon la taille du buffer d'instancing)
+								VertexBuffer* instanceBuffer = Renderer::GetInstanceBuffer();
+								instanceBuffer->SetVertexDeclaration(VertexDeclaration::Get(VertexLayout_Matrix4));
+
+								const Matrix4f* instanceMatrices = &instances[0];
+								unsigned int instanceCount = instances.size();
+								unsigned int maxInstanceCount = instanceBuffer->GetVertexCount(); // Le nombre maximum d'instances en une fois
+
+								while (instanceCount > 0)
+								{
+									// On calcule le nombre d'instances que l'on pourra afficher cette fois-ci (Selon la taille du buffer d'instancing)
+									unsigned int renderedInstanceCount = std::min(instanceCount, maxInstanceCount);
+									instanceCount -= renderedInstanceCount;
+
+									// On remplit l'instancing buffer avec nos matrices world
+									instanceBuffer->Fill(instanceMatrices, 0, renderedInstanceCount, true);
+									instanceMatrices += renderedInstanceCount;
+
+									// Et on affiche
+									instancedDrawFunc(renderedInstanceCount, meshData.primitiveMode, 0, indexCount);
+								}
+							}
+							else
+							{
+								// Sans instancing, on doit effectuer un draw call pour chaque instance
+								// Cela reste néanmoins plus rapide que l'instancing en dessous d'un certain nombre d'instances
+								// À cause du temps de modification du buffer d'instancing
+								for (const Matrix4f& matrix : instances)
+								{
+									Renderer::SetMatrix(MatrixType_World, matrix);
+									drawFunc(meshData.primitiveMode, 0, indexCount);
+								}
+							}
+							instances.clear();
+						}
+					}
+				}
+
+				// Et on remet à zéro les données
+				matEntry.enabled = false;
+				matEntry.instancingEnabled = false;
+			}
+		}
+	}
+
+	const DepthRenderTechnique::ShaderUniforms* DepthRenderTechnique::GetShaderUniforms(const Shader* shader) const
+	{
+		auto it = m_shaderUniforms.find(shader);
+		if (it == m_shaderUniforms.end())
+		{
+			ShaderUniforms uniforms;
+			uniforms.shaderReleaseSlot.Connect(shader->OnShaderRelease, this, &DepthRenderTechnique::OnShaderInvalidated);
+			uniforms.shaderUniformInvalidatedSlot.Connect(shader->OnShaderUniformInvalidated, this, &DepthRenderTechnique::OnShaderInvalidated);
+
+			uniforms.eyePosition = shader->GetUniformLocation("EyePosition");
+			uniforms.textureOverlay = shader->GetUniformLocation("TextureOverlay");
+
+			it = m_shaderUniforms.emplace(shader, std::move(uniforms)).first;
+		}
+
+		return &it->second;
+	}
+
+	void DepthRenderTechnique::OnShaderInvalidated(const Shader* shader) const
+	{
+		m_shaderUniforms.erase(shader);
+	}
+
+	IndexBuffer DepthRenderTechnique::s_quadIndexBuffer;
+	VertexBuffer DepthRenderTechnique::s_quadVertexBuffer;
+	VertexDeclaration DepthRenderTechnique::s_billboardInstanceDeclaration;
+	VertexDeclaration DepthRenderTechnique::s_billboardVertexDeclaration;
+}

src/Nazara/Graphics/Formats/MeshLoader.cpp

@@ -3,9 +3,11 @@
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
 #include <Nazara/Graphics/Formats/MeshLoader.hpp>
+#include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Graphics/Material.hpp>
 #include <Nazara/Graphics/Model.hpp>
 #include <Nazara/Graphics/SkeletalModel.hpp>
+#include <Nazara/Utility/MaterialData.hpp>
 #include <Nazara/Utility/Mesh.hpp>
 #include <memory>
 #include <Nazara/Graphics/Debug.hpp>
@@ -14,6 +16,33 @@ namespace Nz
 {
 	namespace
 	{
+		void LoadMaterials(Model* model, const ModelParameters& parameters)
+		{
+			unsigned int matCount = model->GetMaterialCount();
+
+			for (unsigned int i = 0; i < matCount; ++i)
+			{
+				const ParameterList& matData = model->GetMesh()->GetMaterialData(i);
+
+				String filePath;
+				if (matData.GetStringParameter(MaterialData::FilePath, &filePath))
+				{
+					MaterialRef material = Material::New();
+					if (material->LoadFromFile(filePath, parameters.material))
+						model->SetMaterial(i, std::move(material));
+					else
+						NazaraWarning("Failed to load material from file " + String::Number(i));
+				}
+				else if (matData.HasParameter(MaterialData::CustomDefined))
+				{
+					MaterialRef material = Material::New();
+					material->BuildFromParameters(matData, parameters.material);
+
+					model->SetMaterial(i, std::move(material));
+				}
+			}
+		}
+
 		Ternary CheckStatic(Stream& stream, const ModelParameters& parameters)
 		{
 			NazaraUnused(stream);
@@ -46,22 +75,7 @@ namespace Nz
 			model->SetMesh(mesh);
 
 			if (parameters.loadMaterials)
-			{
-				unsigned int matCount = model->GetMaterialCount();
-
-				for (unsigned int i = 0; i < matCount; ++i)
-				{
-					String mat = mesh->GetMaterial(i);
-					if (!mat.IsEmpty())
-					{
-						MaterialRef material = Material::New();
-						if (material->LoadFromFile(mat, parameters.material))
-							model->SetMaterial(i, material);
-						else
-							NazaraWarning("Failed to load material #" + String::Number(i));
-					}
-				}
-			}
+				LoadMaterials(model, parameters);
 
 			return true;
 		}
@@ -98,22 +112,7 @@ namespace Nz
 			model->SetMesh(mesh);
 
 			if (parameters.loadMaterials)
-			{
-				unsigned int matCount = model->GetMaterialCount();
-
-				for (unsigned int i = 0; i < matCount; ++i)
-				{
-					String mat = mesh->GetMaterial(i);
-					if (!mat.IsEmpty())
-					{
-						MaterialRef material = Material::New();
-						if (material->LoadFromFile(mat, parameters.material))
-							model->SetMaterial(i, material);
-						else
-							NazaraWarning("Failed to load material #" + String::Number(i));
-					}
-				}
-			}
+				LoadMaterials(model, parameters);
 
 			return true;
 		}

src/Nazara/Graphics/ForwardRenderQueue.cpp

@@ -77,7 +77,7 @@ namespace Nz
 	{
 		NazaraAssert(material, "Invalid material");
 
-		///DOC: sinCosPtr et alphaPtr peuvent être nuls, ils seont remplacés respectivement par Vector2f(0.f, 1.f) et Color::White
+		///DOC: sinCosPtr et alphaPtr peuvent être nuls, ils seront remplacés respectivement par Vector2f(0.f, 1.f) et Color::White
 		Vector2f defaultSinCos(0.f, 1.f); // sin(0) = 0, cos(0) = 1
 
 		if (!sinCosPtr)
@@ -120,7 +120,7 @@ namespace Nz
 	{
 		NazaraAssert(material, "Invalid material");
 
-		///DOC: sinCosPtr et colorPtr peuvent être nuls, ils seont remplacés respectivement par Vector2f(0.f, 1.f) et Color::White
+		///DOC: sinCosPtr et colorPtr peuvent être nuls, ils seront remplacés respectivement par Vector2f(0.f, 1.f) et Color::White
 		float defaultRotation = 0.f;
 
 		if (!anglePtr)
@@ -165,7 +165,7 @@ namespace Nz
 	{
 		NazaraAssert(material, "Invalid material");
 
-		///DOC: sinCosPtr et alphaPtr peuvent être nuls, ils seont remplacés respectivement par Vector2f(0.f, 1.f) et Color::White
+		///DOC: sinCosPtr et alphaPtr peuvent être nuls, ils seront remplacés respectivement par Vector2f(0.f, 1.f) et Color::White
 		float defaultRotation = 0.f;
 
 		if (!anglePtr)
@@ -212,7 +212,7 @@ namespace Nz
 	{
 		NazaraAssert(material, "Invalid material");
 
-		///DOC: sinCosPtr et colorPtr peuvent être nuls, ils seont remplacés respectivement par Vector2f(0.f, 1.f) et Color::White
+		///DOC: sinCosPtr et colorPtr peuvent être nuls, ils seront remplacés respectivement par Vector2f(0.f, 1.f) et Color::White
 		Vector2f defaultSinCos(0.f, 1.f); // sin(0) = 0, cos(0) = 1
 
 		if (!sinCosPtr)
@@ -253,7 +253,7 @@ namespace Nz
 	{
 		NazaraAssert(material, "Invalid material");
 
-		///DOC: sinCosPtr et alphaPtr peuvent être nuls, ils seont remplacés respectivement par Vector2f(0.f, 1.f) et Color::White
+		///DOC: sinCosPtr et alphaPtr peuvent être nuls, ils seront remplacés respectivement par Vector2f(0.f, 1.f) et Color::White
 		Vector2f defaultSinCos(0.f, 1.f); // sin(0) = 0, cos(0) = 1
 
 		if (!sinCosPtr)
@@ -296,7 +296,7 @@ namespace Nz
 	{
 		NazaraAssert(material, "Invalid material");
 
-		///DOC: sinCosPtr et colorPtr peuvent être nuls, ils seont remplacés respectivement par Vector2f(0.f, 1.f) et Color::White
+		///DOC: sinCosPtr et colorPtr peuvent être nuls, ils seront remplacés respectivement par Vector2f(0.f, 1.f) et Color::White
 		float defaultRotation = 0.f;
 
 		if (!anglePtr)
@@ -341,7 +341,7 @@ namespace Nz
 	{
 		NazaraAssert(material, "Invalid material");
 
-		///DOC: sinCosPtr et alphaPtr peuvent être nuls, ils seont remplacés respectivement par Vector2f(0.f, 1.f) et Color::White
+		///DOC: sinCosPtr et alphaPtr peuvent être nuls, ils seront remplacés respectivement par Vector2f(0.f, 1.f) et Color::White
 		float defaultRotation = 0.f;
 
 		if (!anglePtr)

src/Nazara/Graphics/ForwardRenderTechnique.cpp

@@ -29,7 +29,7 @@ namespace Nz
 			Color color;
 			Vector3f position;
 			Vector2f size;
-			Vector2f sinCos; // doit suivre size
+			Vector2f sinCos; // must follow `size` (both will be sent as a Vector4f)
 			Vector2f uv;
 		};
 
@@ -156,6 +156,9 @@ namespace Nz
 			s_billboardInstanceDeclaration.EnableComponent(VertexComponent_InstanceData0, ComponentType_Float3, NazaraOffsetOf(ForwardRenderQueue::BillboardData, center));
 			s_billboardInstanceDeclaration.EnableComponent(VertexComponent_InstanceData1, ComponentType_Float4, NazaraOffsetOf(ForwardRenderQueue::BillboardData, size)); // Englobe sincos
 			s_billboardInstanceDeclaration.EnableComponent(VertexComponent_InstanceData2, ComponentType_Color,  NazaraOffsetOf(ForwardRenderQueue::BillboardData, color));
+
+			s_shadowSampler.SetFilterMode(SamplerFilter_Bilinear);
+			s_shadowSampler.SetWrapMode(SamplerWrap_Clamp);
 		}
 		catch (const std::exception& e)
 		{
@@ -487,7 +490,8 @@ namespace Nz
 					bool instancing = m_instancingEnabled && (!material->IsLightingEnabled() || noPointSpotLight) && matEntry.instancingEnabled;
 
 					// On commence par appliquer du matériau (et récupérer le shader ainsi activé)
-					const Shader* shader = material->Apply((instancing) ? ShaderFlags_Instancing : 0);
+					UInt8 freeTextureUnit;
+					const Shader* shader = material->Apply((instancing) ? ShaderFlags_Instancing : 0, 0, &freeTextureUnit);
 
 					// Les uniformes sont conservées au sein d'un programme, inutile de les renvoyer tant qu'il ne change pas
 					if (shader != lastShader)
@@ -571,7 +575,10 @@ namespace Nz
 
 										// Sends the uniforms
 										for (unsigned int i = 0; i < NAZARA_GRAPHICS_MAX_LIGHT_PER_PASS; ++i)
-											SendLightUniforms(shader, shaderUniforms->lightUniforms, lightIndex++, i*shaderUniforms->lightOffset);
+											SendLightUniforms(shader, shaderUniforms->lightUniforms, lightIndex++, shaderUniforms->lightOffset*i, freeTextureUnit + i);
+
+										// Et on passe à l'affichage
+										drawFunc(meshData.primitiveMode, 0, indexCount);
 									}
 
 									const Matrix4f* instanceMatrices = &instances[0];
@@ -630,7 +637,7 @@ namespace Nz
 
 											// Sends the light uniforms to the shader
 											for (unsigned int i = 0; i < NAZARA_GRAPHICS_MAX_LIGHT_PER_PASS; ++i)
-												SendLightUniforms(shader, shaderUniforms->lightUniforms, lightIndex++, shaderUniforms->lightOffset*i);
+												SendLightUniforms(shader, shaderUniforms->lightUniforms, lightIndex++, shaderUniforms->lightOffset*i, freeTextureUnit + i);
 
 											// Et on passe à l'affichage
 											drawFunc(meshData.primitiveMode, 0, indexCount);
@@ -680,7 +687,8 @@ namespace Nz
 			const Material* material = modelData.material;
 
 			// On commence par appliquer du matériau (et récupérer le shader ainsi activé)
-			const Shader* shader = material->Apply();
+			UInt8 freeTextureUnit;
+			const Shader* shader = material->Apply(0, 0, &freeTextureUnit);
 
 			// Les uniformes sont conservées au sein d'un programme, inutile de les renvoyer tant qu'il ne change pas
 			if (shader != lastShader)
@@ -699,7 +707,7 @@ namespace Nz
 					lightCount = std::min(m_renderQueue.directionalLights.size(), static_cast<decltype(m_renderQueue.directionalLights.size())>(NAZARA_GRAPHICS_MAX_LIGHT_PER_PASS));
 
 					for (unsigned int i = 0; i < lightCount; ++i)
-						SendLightUniforms(shader, shaderUniforms->lightUniforms, i, shaderUniforms->lightOffset * i);
+						SendLightUniforms(shader, shaderUniforms->lightUniforms, i, shaderUniforms->lightOffset * i, freeTextureUnit++);
 				}
 
 				lastShader = shader;
@@ -738,7 +746,7 @@ namespace Nz
 				ChooseLights(Spheref(position, radius), false);
 
 				for (unsigned int i = lightCount; i < NAZARA_GRAPHICS_MAX_LIGHT_PER_PASS; ++i)
-					SendLightUniforms(shader, shaderUniforms->lightUniforms, i, shaderUniforms->lightOffset*i);
+					SendLightUniforms(shader, shaderUniforms->lightUniforms, i, shaderUniforms->lightOffset*i, freeTextureUnit++);
 			}
 
 			Renderer::SetMatrix(MatrixType_World, matrix);
@@ -770,9 +778,13 @@ namespace Nz
 				uniforms.lightUniforms.locations.type = type0Location;
 				uniforms.lightUniforms.locations.color = shader->GetUniformLocation("Lights[0].color");
 				uniforms.lightUniforms.locations.factors = shader->GetUniformLocation("Lights[0].factors");
+				uniforms.lightUniforms.locations.lightViewProjMatrix = shader->GetUniformLocation("LightViewProjMatrix[0]");
 				uniforms.lightUniforms.locations.parameters1 = shader->GetUniformLocation("Lights[0].parameters1");
 				uniforms.lightUniforms.locations.parameters2 = shader->GetUniformLocation("Lights[0].parameters2");
 				uniforms.lightUniforms.locations.parameters3 = shader->GetUniformLocation("Lights[0].parameters3");
+				uniforms.lightUniforms.locations.pointLightShadowMap = shader->GetUniformLocation("PointLightShadowMap[0]");
+				uniforms.lightUniforms.locations.shadowMapping = shader->GetUniformLocation("Lights[0].shadowMapping");
+				uniforms.lightUniforms.locations.directionalSpotLightShadowMap = shader->GetUniformLocation("DirectionalSpotLightShadowMap[0]");
 			}
 			else
 				uniforms.hasLightUniforms = false;
@@ -789,6 +801,7 @@ namespace Nz
 	}
 
 	IndexBuffer ForwardRenderTechnique::s_quadIndexBuffer;
+	TextureSampler ForwardRenderTechnique::s_shadowSampler;
 	VertexBuffer ForwardRenderTechnique::s_quadVertexBuffer;
 	VertexDeclaration ForwardRenderTechnique::s_billboardInstanceDeclaration;
 	VertexDeclaration ForwardRenderTechnique::s_billboardVertexDeclaration;

src/Nazara/Graphics/Graphics.cpp

@@ -8,6 +8,7 @@
 #include <Nazara/Core/Log.hpp>
 #include <Nazara/Graphics/Config.hpp>
 #include <Nazara/Graphics/DeferredRenderTechnique.hpp>
+#include <Nazara/Graphics/DepthRenderTechnique.hpp>
 #include <Nazara/Graphics/ForwardRenderTechnique.hpp>
 #include <Nazara/Graphics/GuillotineTextureAtlas.hpp>
 #include <Nazara/Graphics/Material.hpp>
@@ -20,7 +21,6 @@
 #include <Nazara/Graphics/SkyboxBackground.hpp>
 #include <Nazara/Graphics/Sprite.hpp>
 #include <Nazara/Graphics/Formats/MeshLoader.hpp>
-#include <Nazara/Graphics/Formats/OBJLoader.hpp>
 #include <Nazara/Graphics/Formats/TextureLoader.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Utility/Font.hpp>
@@ -96,14 +96,17 @@ namespace Nz
 			return false;
 		}
 
-		// Loaders
-		Loaders::RegisterOBJ();
-
 		// Loaders génériques
 		Loaders::RegisterMesh();
 		Loaders::RegisterTexture();
 
 		// RenderTechniques
+		if (!DepthRenderTechnique::Initialize())
+		{
+			NazaraError("Failed to initialize Depth Rendering");
+			return false;
+		}
+
 		if (!ForwardRenderTechnique::Initialize())
 		{
 			NazaraError("Failed to initialize Forward Rendering");
@@ -176,10 +179,10 @@ namespace Nz
 
 		// Loaders
 		Loaders::UnregisterMesh();
-		Loaders::UnregisterOBJ();
 		Loaders::UnregisterTexture();
 
 		DeferredRenderTechnique::Uninitialize();
+		DepthRenderTechnique::Uninitialize();
 		ForwardRenderTechnique::Uninitialize();
 		SkinningManager::Uninitialize();
 		ParticleRenderer::Uninitialize();

src/Nazara/Graphics/Light.cpp

@@ -5,6 +5,7 @@
 #include <Nazara/Graphics/Light.hpp>
 #include <Nazara/Core/Error.hpp>
 #include <Nazara/Graphics/AbstractRenderQueue.hpp>
+#include <Nazara/Graphics/Enums.hpp>
 #include <Nazara/Math/Algorithm.hpp>
 #include <Nazara/Math/Sphere.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
@@ -18,7 +19,11 @@
 namespace Nz
 {
 	Light::Light(LightType type) :
-	m_type(type)
+	m_type(type),
+	m_shadowMapFormat(PixelFormatType_Depth16),
+	m_shadowMapSize(512, 512),
+	m_shadowCastingEnabled(false),
+	m_shadowMapUpdated(false)
 	{
 		SetAmbientFactor((type == LightType_Directional) ? 0.2f : 0.f);
 		SetAttenuation(0.9f);
@@ -31,6 +36,11 @@ namespace Nz
 
 	void Light::AddToRenderQueue(AbstractRenderQueue* renderQueue, const Matrix4f& transformMatrix) const
 	{
+		static Matrix4f biasMatrix(0.5f, 0.f, 0.f, 0.f,
+		                           0.f, 0.5f, 0.f, 0.f,
+								   0.f, 0.f, 0.5f, 0.f,
+								   0.5f, 0.5f, 0.5f, 1.f);
+
 		switch (m_type)
 		{
 			case LightType_Directional:
@@ -40,6 +50,8 @@ namespace Nz
 				light.color = m_color;
 				light.diffuseFactor = m_diffuseFactor;
 				light.direction = transformMatrix.Transform(Vector3f::Forward(), 0.f);
+				light.shadowMap = m_shadowMap.Get();
+				light.transformMatrix = Matrix4f::ViewMatrix(transformMatrix.GetRotation() * Vector3f::Forward() * 100.f, transformMatrix.GetRotation()) * Matrix4f::Ortho(0.f, 100.f, 100.f, 0.f, 1.f, 100.f) * biasMatrix;
 
 				renderQueue->AddDirectionalLight(light);
 				break;
@@ -55,6 +67,7 @@ namespace Nz
 				light.invRadius = m_invRadius;
 				light.position = transformMatrix.GetTranslation();
 				light.radius = m_radius;
+				light.shadowMap = m_shadowMap.Get();
 
 				renderQueue->AddPointLight(light);
 				break;
@@ -74,6 +87,8 @@ namespace Nz
 				light.outerAngleTangent = m_outerAngleTangent;
 				light.position = transformMatrix.GetTranslation();
 				light.radius = m_radius;
+				light.shadowMap = m_shadowMap.Get();
+				light.transformMatrix = Matrix4f::ViewMatrix(transformMatrix.GetTranslation(), transformMatrix.GetRotation()) * Matrix4f::Perspective(m_outerAngle*2.f, 1.f, 0.1f, m_radius) * biasMatrix;
 
 				renderQueue->AddSpotLight(light);
 				break;
@@ -178,4 +193,19 @@ namespace Nz
 				break;
 			}
 	}
+
+	void Light::UpdateShadowMap() const
+	{
+		if (m_shadowCastingEnabled)
+		{
+			if (!m_shadowMap)
+				m_shadowMap = Texture::New();
+
+			m_shadowMap->Create((m_type == LightType_Point) ? ImageType_Cubemap : ImageType_2D, m_shadowMapFormat, m_shadowMapSize.x, m_shadowMapSize.y);
+		}
+		else
+			m_shadowMap.Reset();
+
+		m_shadowMapUpdated = true;
+	}
 }

src/Nazara/Graphics/Material.cpp

@@ -7,6 +7,7 @@
 #endif
 
 #include <Nazara/Graphics/Material.hpp>
+#include <Nazara/Core/ErrorFlags.hpp>
 #include <Nazara/Renderer/OpenGL.hpp>
 #include <Nazara/Renderer/Renderer.hpp>
 #include <Nazara/Renderer/UberShaderPreprocessor.hpp>
@@ -43,23 +44,6 @@ namespace Nz
 		return true;
 	}
 
-	Material::Material()
-	{
-		Reset();
-	}
-
-	Material::Material(const Material& material) :
-	RefCounted(),
-	Resource(material)
-	{
-		Copy(material);
-	}
-
-	Material::~Material()
-	{
-		OnMaterialRelease(this);
-	}
-
 	const Shader* Material::Apply(UInt32 shaderFlags, UInt8 textureUnit, UInt8* lastUsedUnit) const
 	{
 		const ShaderInstance& instance = m_shaders[shaderFlags];
@@ -139,240 +123,164 @@ namespace Nz
 		return instance.shader;
 	}
 
-	void Material::Enable(RendererParameter renderParameter, bool enable)
+	void Material::BuildFromParameters(const ParameterList& matData, const MaterialParams& matParams)
 	{
-		#ifdef NAZARA_DEBUG
-		if (renderParameter > RendererParameter_Max)
-		{
-			NazaraError("Renderer parameter out of enum");
-			return;
-		}
-		#endif
+		Color color;
+		bool isEnabled;
+		float fValue;
+		int iValue;
+		String path;
 
-		m_states.parameters[renderParameter] = enable;
-	}
+		ErrorFlags errFlags(ErrorFlag_Silent | ErrorFlag_ThrowExceptionDisabled, true);
 
-	void Material::EnableAlphaTest(bool alphaTest)
-	{
-		m_alphaTestEnabled = alphaTest;
 
-		InvalidateShaders();
-	}
+		if (matData.GetFloatParameter(MaterialData::AlphaThreshold, &fValue))
+			SetAlphaThreshold(fValue);
 
-	void Material::EnableDepthSorting(bool depthSorting)
-	{
-		m_depthSortingEnabled = depthSorting;
-	}
+		if (matData.GetBooleanParameter(MaterialData::AlphaTest, &isEnabled))
+			EnableAlphaTest(isEnabled);
 
-	void Material::EnableLighting(bool lighting)
-	{
-		m_lightingEnabled = lighting;
+		if (matData.GetColorParameter(MaterialData::AmbientColor, &color))
+			SetAmbientColor(color);
 
-		InvalidateShaders();
-	}
+		if (matData.GetIntegerParameter(MaterialData::DepthFunc, &iValue))
+			SetDepthFunc(static_cast<RendererComparison>(iValue));
 
-	void Material::EnableTransform(bool transform)
-	{
-		m_transformEnabled = transform;
+		if (matData.GetBooleanParameter(MaterialData::DepthSorting, &isEnabled))
+			EnableDepthSorting(isEnabled);
 
-		InvalidateShaders();
-	}
+		if (matData.GetColorParameter(MaterialData::DiffuseColor, &color))
+			SetDiffuseColor(color);
 
-	Texture* Material::GetAlphaMap() const
-	{
-		return m_alphaMap;
-	}
+		if (matData.GetIntegerParameter(MaterialData::DstBlend, &iValue))
+			SetDstBlend(static_cast<BlendFunc>(iValue));
 
-	float Material::GetAlphaThreshold() const
-	{
-		return m_alphaThreshold;
-	}
+		if (matData.GetIntegerParameter(MaterialData::FaceCulling, &iValue))
+			SetFaceCulling(static_cast<FaceSide>(iValue));
 
-	Color Material::GetAmbientColor() const
-	{
-		return m_ambientColor;
-	}
+		if (matData.GetIntegerParameter(MaterialData::FaceFilling, &iValue))
+			SetFaceFilling(static_cast<FaceFilling>(iValue));
 
-	RendererComparison Material::GetDepthFunc() const
-	{
-		return m_states.depthFunc;
-	}
+		if (matData.GetBooleanParameter(MaterialData::Lighting, &isEnabled))
+			EnableLighting(isEnabled);
 
-	Color Material::GetDiffuseColor() const
-	{
-		return m_diffuseColor;
-	}
+		if (matData.GetFloatParameter(MaterialData::LineWidth, &fValue))
+			m_states.lineWidth = fValue;
 
-	TextureSampler& Material::GetDiffuseSampler()
-	{
-		return m_diffuseSampler;
-	}
+		if (matData.GetFloatParameter(MaterialData::PointSize, &fValue))
+			m_states.pointSize = fValue;
 
-	const TextureSampler& Material::GetDiffuseSampler() const
-	{
-		return m_diffuseSampler;
-	}
+		if (matData.GetColorParameter(MaterialData::SpecularColor, &color))
+			SetSpecularColor(color);
 
-	Texture* Material::GetDiffuseMap() const
-	{
-		return m_diffuseMap;
-	}
+		if (matData.GetFloatParameter(MaterialData::Shininess, &fValue))
+			SetShininess(fValue);
 
-	BlendFunc Material::GetDstBlend() const
-	{
-		return m_states.dstBlend;
-	}
+		if (matData.GetIntegerParameter(MaterialData::SrcBlend, &iValue))
+			SetSrcBlend(static_cast<BlendFunc>(iValue));
 
-	Texture* Material::GetEmissiveMap() const
-	{
-		return m_emissiveMap;
-	}
+		if (matData.GetBooleanParameter(MaterialData::Transform, &isEnabled))
+			EnableTransform(isEnabled);
 
-	FaceSide Material::GetFaceCulling() const
-	{
-		return m_states.faceCulling;
-	}
+		// RendererParameter
+		if (matData.GetBooleanParameter(MaterialData::Blending, &isEnabled))
+			Enable(RendererParameter_Blend, isEnabled);
 
-	FaceFilling Material::GetFaceFilling() const
-	{
-		return m_states.faceFilling;
-	}
+		if (matData.GetBooleanParameter(MaterialData::ColorWrite, &isEnabled))
+			Enable(RendererParameter_ColorWrite, isEnabled);
 
-	Texture* Material::GetHeightMap() const
-	{
-		return m_heightMap;
-	}
+		if (matData.GetBooleanParameter(MaterialData::DepthBuffer, &isEnabled))
+			Enable(RendererParameter_DepthBuffer, isEnabled);
 
-	Texture* Material::GetNormalMap() const
-	{
-		return m_normalMap;
-	}
+		if (matData.GetBooleanParameter(MaterialData::DepthWrite, &isEnabled))
+			Enable(RendererParameter_DepthWrite, isEnabled);
 
-	const RenderStates& Material::GetRenderStates() const
-	{
-		return m_states;
-	}
+		if (matData.GetBooleanParameter(MaterialData::FaceCulling, &isEnabled))
+			Enable(RendererParameter_FaceCulling, isEnabled);
 
-	const UberShader* Material::GetShader() const
-	{
-		return m_uberShader;
-	}
+		if (matData.GetBooleanParameter(MaterialData::ScissorTest, &isEnabled))
+			Enable(RendererParameter_ScissorTest, isEnabled);
 
-	const UberShaderInstance* Material::GetShaderInstance(UInt32 flags) const
-	{
-		const ShaderInstance& instance = m_shaders[flags];
-		if (!instance.uberInstance)
-			GenerateShader(flags);
+		if (matData.GetBooleanParameter(MaterialData::StencilTest, &isEnabled))
+			Enable(RendererParameter_StencilTest, isEnabled);
 
-		return instance.uberInstance;
-	}
+		// Samplers
+		if (matData.GetIntegerParameter(MaterialData::DiffuseAnisotropyLevel, &iValue))
+			m_diffuseSampler.SetAnisotropyLevel(static_cast<UInt8>(iValue));
 
-	float Material::GetShininess() const
-	{
-		return m_shininess;
-	}
+		if (matData.GetIntegerParameter(MaterialData::DiffuseFilter, &iValue))
+			m_diffuseSampler.SetFilterMode(static_cast<SamplerFilter>(iValue));
 
-	Color Material::GetSpecularColor() const
-	{
-		return m_specularColor;
-	}
+		if (matData.GetIntegerParameter(MaterialData::DiffuseWrap, &iValue))
+			m_diffuseSampler.SetWrapMode(static_cast<SamplerWrap>(iValue));
 
-	Texture* Material::GetSpecularMap() const
-	{
-		return m_specularMap;
-	}
+		if (matData.GetIntegerParameter(MaterialData::SpecularAnisotropyLevel, &iValue))
+			m_specularSampler.SetAnisotropyLevel(static_cast<UInt8>(iValue));
 
-	TextureSampler& Material::GetSpecularSampler()
-	{
-		return m_specularSampler;
-	}
+		if (matData.GetIntegerParameter(MaterialData::SpecularFilter, &iValue))
+			m_specularSampler.SetFilterMode(static_cast<SamplerFilter>(iValue));
 
-	const TextureSampler& Material::GetSpecularSampler() const
-	{
-		return m_specularSampler;
-	}
+		if (matData.GetIntegerParameter(MaterialData::SpecularWrap, &iValue))
+			m_specularSampler.SetWrapMode(static_cast<SamplerWrap>(iValue));
 
-	BlendFunc Material::GetSrcBlend() const
-	{
-		return m_states.srcBlend;
-	}
+		// Stencil
+		if (matData.GetIntegerParameter(MaterialData::StencilCompare, &iValue))
+			m_states.frontFace.stencilCompare = static_cast<RendererComparison>(iValue);
 
-	bool Material::HasAlphaMap() const
-	{
-		return m_alphaMap.IsValid();
-	}
+		if (matData.GetIntegerParameter(MaterialData::StencilFail, &iValue))
+			m_states.frontFace.stencilFail = static_cast<StencilOperation>(iValue);
 
-	bool Material::HasDiffuseMap() const
-	{
-		return m_diffuseMap.IsValid();
-	}
+		if (matData.GetIntegerParameter(MaterialData::StencilPass, &iValue))
+			m_states.frontFace.stencilPass = static_cast<StencilOperation>(iValue);
 
-	bool Material::HasEmissiveMap() const
-	{
-		return m_emissiveMap.IsValid();
-	}
+		if (matData.GetIntegerParameter(MaterialData::StencilZFail, &iValue))
+			m_states.frontFace.stencilZFail = static_cast<StencilOperation>(iValue);
 
-	bool Material::HasHeightMap() const
-	{
-		return m_heightMap.IsValid();
-	}
+		if (matData.GetIntegerParameter(MaterialData::StencilMask, &iValue))
+			m_states.frontFace.stencilMask = static_cast<UInt32>(iValue);
 
-	bool Material::HasNormalMap() const
-	{
-		return m_normalMap.IsValid();
-	}
+		if (matData.GetIntegerParameter(MaterialData::StencilReference, &iValue))
+			m_states.frontFace.stencilReference = static_cast<unsigned int>(iValue);
 
-	bool Material::HasSpecularMap() const
-	{
-		return m_specularMap.IsValid();
-	}
+		// Stencil (back)
+		if (matData.GetIntegerParameter(MaterialData::BackFaceStencilCompare, &iValue))
+			m_states.backFace.stencilCompare = static_cast<RendererComparison>(iValue);
 
-	bool Material::IsAlphaTestEnabled() const
-	{
-		return m_alphaTestEnabled;
-	}
+		if (matData.GetIntegerParameter(MaterialData::BackFaceStencilFail, &iValue))
+			m_states.backFace.stencilFail = static_cast<StencilOperation>(iValue);
 
-	bool Material::IsDepthSortingEnabled() const
-	{
-		return m_depthSortingEnabled;
-	}
+		if (matData.GetIntegerParameter(MaterialData::BackFaceStencilPass, &iValue))
+			m_states.backFace.stencilPass = static_cast<StencilOperation>(iValue);
 
-	bool Material::IsEnabled(RendererParameter parameter) const
-	{
-		#ifdef NAZARA_DEBUG
-		if (parameter > RendererParameter_Max)
-		{
-			NazaraError("Renderer parameter out of enum");
-			return false;
-		}
-		#endif
+		if (matData.GetIntegerParameter(MaterialData::BackFaceStencilZFail, &iValue))
+			m_states.backFace.stencilZFail = static_cast<StencilOperation>(iValue);
 
-		return m_states.parameters[parameter];
-	}
+		if (matData.GetIntegerParameter(MaterialData::BackFaceStencilMask, &iValue))
+			m_states.backFace.stencilMask = static_cast<UInt32>(iValue);
 
-	bool Material::IsLightingEnabled() const
-	{
-		return m_lightingEnabled;
-	}
+		if (matData.GetIntegerParameter(MaterialData::BackFaceStencilReference, &iValue))
+			m_states.backFace.stencilReference = static_cast<unsigned int>(iValue);
 
-	bool Material::IsTransformEnabled() const
-	{
-		return m_transformEnabled;
-	}
+		// Textures
+		if (matParams.loadAlphaMap && matData.GetStringParameter(MaterialData::AlphaTexturePath, &path))
+			SetAlphaMap(path);
 
-	bool Material::LoadFromFile(const String& filePath, const MaterialParams& params)
-	{
-		return MaterialLoader::LoadFromFile(this, filePath, params);
-	}
+		if (matParams.loadDiffuseMap && matData.GetStringParameter(MaterialData::DiffuseTexturePath, &path))
+			SetDiffuseMap(path);
 
-	bool Material::LoadFromMemory(const void* data, std::size_t size, const MaterialParams& params)
-	{
-		return MaterialLoader::LoadFromMemory(this, data, size, params);
-	}
+		if (matParams.loadEmissiveMap && matData.GetStringParameter(MaterialData::EmissiveTexturePath, &path))
+			SetEmissiveMap(path);
 
-	bool Material::LoadFromStream(Stream& stream, const MaterialParams& params)
-	{
-		return MaterialLoader::LoadFromStream(this, stream, params);
+		if (matParams.loadHeightMap && matData.GetStringParameter(MaterialData::HeightTexturePath, &path))
+			SetHeightMap(path);
+
+		if (matParams.loadNormalMap && matData.GetStringParameter(MaterialData::NormalTexturePath, &path))
+			SetNormalMap(path);
+
+		if (matParams.loadSpecularMap && matData.GetStringParameter(MaterialData::SpecularTexturePath, &path))
+			SetSpecularMap(path);
+
+		SetShader(matParams.shaderName);
 	}
 
 	void Material::Reset()
@@ -380,6 +288,7 @@ namespace Nz
 		OnMaterialReset(this);
 
 		m_alphaMap.Reset();
+		m_depthMaterial.Reset();
 		m_diffuseMap.Reset();
 		m_emissiveMap.Reset();
 		m_heightMap.Reset();
@@ -397,6 +306,8 @@ namespace Nz
 		m_diffuseColor = Color::White;
 		m_diffuseSampler = TextureSampler();
 		m_lightingEnabled = true;
+		m_shadowCastingEnabled = true;
+		m_shadowReceiveEnabled = true;
 		m_shininess = 50.f;
 		m_specularColor = Color::White;
 		m_specularSampler = TextureSampler();
@@ -408,252 +319,32 @@ namespace Nz
 		SetShader("Basic");
 	}
 
-	bool Material::SetAlphaMap(const String& textureName)
-	{
-		TextureRef texture = TextureLibrary::Query(textureName);
-		if (!texture)
-		{
-			texture = TextureManager::Get(textureName);
-			if (!texture)
-				return false;
-		}
-
-		SetAlphaMap(std::move(texture));
-		return true;
-	}
-
-	void Material::SetAlphaMap(TextureRef alphaMap)
-	{
-		m_alphaMap = std::move(alphaMap);
-
-		InvalidateShaders();
-	}
-
-	void Material::SetAlphaThreshold(float alphaThreshold)
-	{
-		m_alphaThreshold = alphaThreshold;
-	}
-
-	void Material::SetAmbientColor(const Color& ambient)
-	{
-		m_ambientColor = ambient;
-	}
-
-	void Material::SetDepthFunc(RendererComparison depthFunc)
-	{
-		m_states.depthFunc = depthFunc;
-	}
-
-	void Material::SetDiffuseColor(const Color& diffuse)
-	{
-		m_diffuseColor = diffuse;
-	}
-
-	bool Material::SetDiffuseMap(const String& textureName)
-	{
-		TextureRef texture = TextureLibrary::Query(textureName);
-		if (!texture)
-		{
-			texture = TextureManager::Get(textureName);
-			if (!texture)
-				return false;
-		}
-
-		SetDiffuseMap(std::move(texture));
-		return true;
-	}
-
-	void Material::SetDiffuseMap(TextureRef diffuseMap)
-	{
-		m_diffuseMap = std::move(diffuseMap);
-
-		InvalidateShaders();
-	}
-
-	void Material::SetDiffuseSampler(const TextureSampler& sampler)
-	{
-		m_diffuseSampler = sampler;
-	}
-
-	void Material::SetDstBlend(BlendFunc func)
-	{
-		m_states.dstBlend = func;
-	}
-
-	bool Material::SetEmissiveMap(const String& textureName)
-	{
-		TextureRef texture = TextureLibrary::Query(textureName);
-		if (!texture)
-		{
-			texture = TextureManager::Get(textureName);
-			if (!texture)
-				return false;
-		}
-
-		SetEmissiveMap(std::move(texture));
-		return true;
-	}
-
-	void Material::SetEmissiveMap(TextureRef emissiveMap)
-	{
-		m_emissiveMap = std::move(emissiveMap);
-
-		InvalidateShaders();
-	}
-
-	void Material::SetFaceCulling(FaceSide faceSide)
-	{
-		m_states.faceCulling = faceSide;
-	}
-
-	void Material::SetFaceFilling(FaceFilling filling)
-	{
-		m_states.faceFilling = filling;
-	}
-
-	bool Material::SetHeightMap(const String& textureName)
-	{
-		TextureRef texture = TextureLibrary::Query(textureName);
-		if (!texture)
-		{
-			texture = TextureManager::Get(textureName);
-			if (!texture)
-				return false;
-		}
-
-		SetHeightMap(std::move(texture));
-		return true;
-	}
-
-	void Material::SetHeightMap(TextureRef heightMap)
-	{
-		m_heightMap = std::move(heightMap);
-
-		InvalidateShaders();
-	}
-
-	bool Material::SetNormalMap(const String& textureName)
-	{
-		TextureRef texture = TextureLibrary::Query(textureName);
-		if (!texture)
-		{
-			texture = TextureManager::Get(textureName);
-			if (!texture)
-				return false;
-		}
-
-		SetNormalMap(std::move(texture));
-		return true;
-	}
-
-	void Material::SetNormalMap(TextureRef normalMap)
-	{
-		m_normalMap = std::move(normalMap);
-
-		InvalidateShaders();
-	}
-
-	void Material::SetRenderStates(const RenderStates& states)
-	{
-		m_states = states;
-	}
-
-	void Material::SetShader(UberShaderConstRef uberShader)
-	{
-		m_uberShader = std::move(uberShader);
-
-		InvalidateShaders();
-	}
-
-	bool Material::SetShader(const String& uberShaderName)
-	{
-		UberShaderConstRef uberShader = UberShaderLibrary::Get(uberShaderName);
-		if (!uberShader)
-			return false;
-
-		SetShader(std::move(uberShader));
-		return true;
-	}
-
-	void Material::SetShininess(float shininess)
-	{
-		m_shininess = shininess;
-	}
-
-	void Material::SetSpecularColor(const Color& specular)
-	{
-		m_specularColor = specular;
-	}
-
-	bool Material::SetSpecularMap(const String& textureName)
-	{
-		TextureRef texture = TextureLibrary::Query(textureName);
-		if (!texture)
-		{
-			texture = TextureManager::Get(textureName);
-			if (!texture)
-				return false;
-		}
-
-		SetSpecularMap(std::move(texture));
-		return true;
-	}
-
-	void Material::SetSpecularMap(TextureRef specularMap)
-	{
-		m_specularMap = std::move(specularMap);
-
-		InvalidateShaders();
-	}
-
-	void Material::SetSpecularSampler(const TextureSampler& sampler)
-	{
-		m_specularSampler = sampler;
-	}
-
-	void Material::SetSrcBlend(BlendFunc func)
-	{
-		m_states.srcBlend = func;
-	}
-
-	Material& Material::operator=(const Material& material)
-	{
-		Resource::operator=(material);
-
-		Copy(material);
-		return *this;
-	}
-
-	MaterialRef Material::GetDefault()
-	{
-		return s_defaultMaterial;
-	}
-
 	void Material::Copy(const Material& material)
 	{
 		// Copie des états de base
-		m_alphaTestEnabled    = material.m_alphaTestEnabled;
-		m_alphaThreshold      = material.m_alphaThreshold;
-		m_ambientColor        = material.m_ambientColor;
-		m_depthSortingEnabled = material.m_depthSortingEnabled;
-		m_diffuseColor        = material.m_diffuseColor;
-		m_diffuseSampler      = material.m_diffuseSampler;
-		m_lightingEnabled     = material.m_lightingEnabled;
-		m_shininess           = material.m_shininess;
-		m_specularColor       = material.m_specularColor;
-		m_specularSampler     = material.m_specularSampler;
-		m_states              = material.m_states;
-		m_transformEnabled    = material.m_transformEnabled;
+		m_alphaTestEnabled     = material.m_alphaTestEnabled;
+		m_alphaThreshold       = material.m_alphaThreshold;
+		m_ambientColor         = material.m_ambientColor;
+		m_depthSortingEnabled  = material.m_depthSortingEnabled;
+		m_diffuseColor         = material.m_diffuseColor;
+		m_diffuseSampler       = material.m_diffuseSampler;
+		m_lightingEnabled      = material.m_lightingEnabled;
+		m_shininess            = material.m_shininess;
+		m_shadowCastingEnabled = material.m_shadowCastingEnabled;
+		m_shadowReceiveEnabled = material.m_shadowReceiveEnabled;
+		m_specularColor        = material.m_specularColor;
+		m_specularSampler      = material.m_specularSampler;
+		m_states               = material.m_states;
+		m_transformEnabled     = material.m_transformEnabled;
 
 		// Copie des références de texture
-		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;
-
-		// Copie de la référence vers l'Über-Shader
+		m_alphaMap      = material.m_alphaMap;
+		m_depthMaterial = material.m_depthMaterial;
+		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;
 
 		// On copie les instances de shader par la même occasion
@@ -671,6 +362,7 @@ namespace Nz
 		list.SetParameter("LIGHTING", m_lightingEnabled);
 		list.SetParameter("NORMAL_MAPPING", m_normalMap.IsValid());
 		list.SetParameter("PARALLAX_MAPPING", m_heightMap.IsValid());
+		list.SetParameter("SHADOW_MAPPING", m_shadowReceiveEnabled);
 		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() ||
@@ -704,12 +396,6 @@ namespace Nz
 		#undef CacheUniform
 	}
 
-	void Material::InvalidateShaders()
-	{
-		for (ShaderInstance& instance : m_shaders)
-			instance.uberInstance = nullptr;
-	}
-
 	bool Material::Initialize()
 	{
 		if (!MaterialLibrary::Initialize())
@@ -744,18 +430,35 @@ namespace Nz
 			String fragmentShader(reinterpret_cast<const char*>(r_phongLightingFragmentShader), sizeof(r_phongLightingFragmentShader));
 			String vertexShader(reinterpret_cast<const char*>(r_phongLightingVertexShader), sizeof(r_phongLightingVertexShader));
 
-			uberShader->SetShader(ShaderStageType_Fragment, fragmentShader, "FLAG_DEFERRED FLAG_TEXTUREOVERLAY ALPHA_MAPPING ALPHA_TEST AUTO_TEXCOORDS DIFFUSE_MAPPING EMISSIVE_MAPPING LIGHTING NORMAL_MAPPING PARALLAX_MAPPING SPECULAR_MAPPING");
-			uberShader->SetShader(ShaderStageType_Vertex, vertexShader, "FLAG_BILLBOARD FLAG_DEFERRED FLAG_INSTANCING FLAG_VERTEXCOLOR COMPUTE_TBNMATRIX LIGHTING PARALLAX_MAPPING TEXTURE_MAPPING TRANSFORM UNIFORM_VERTEX_DEPTH");
+			uberShader->SetShader(ShaderStageType_Fragment, fragmentShader, "FLAG_DEFERRED FLAG_TEXTUREOVERLAY ALPHA_MAPPING ALPHA_TEST AUTO_TEXCOORDS DIFFUSE_MAPPING EMISSIVE_MAPPING LIGHTING NORMAL_MAPPING PARALLAX_MAPPING SHADOW_MAPPING SPECULAR_MAPPING");
+			uberShader->SetShader(ShaderStageType_Vertex, vertexShader, "FLAG_BILLBOARD FLAG_DEFERRED FLAG_INSTANCING FLAG_VERTEXCOLOR COMPUTE_TBNMATRIX LIGHTING PARALLAX_MAPPING SHADOW_MAPPING TEXTURE_MAPPING TRANSFORM UNIFORM_VERTEX_DEPTH");
 
 			UberShaderLibrary::Register("PhongLighting", uberShader);
 		}
 
-		// Une fois les shaders de base enregistrés, on peut créer le matériau par défaut
-		s_defaultMaterial = Material::New();
+		// Once the base shaders are registered, we can now set some default materials
+		s_defaultMaterial = New();
 		s_defaultMaterial->Enable(RendererParameter_FaceCulling, false);
 		s_defaultMaterial->SetFaceFilling(FaceFilling_Line);
 		MaterialLibrary::Register("Default", s_defaultMaterial);
 
+        MaterialRef mat;
+
+        mat = New();
+        mat->Enable(RendererParameter_DepthWrite, false);
+        mat->Enable(RendererParameter_FaceCulling, false);
+        mat->EnableLighting(false);
+        MaterialLibrary::Register("Basic2D", std::move(mat));
+
+        mat = New();
+        mat->Enable(RendererParameter_Blend, true);
+        mat->Enable(RendererParameter_DepthWrite, false);
+        mat->Enable(RendererParameter_FaceCulling, false);
+        mat->EnableLighting(false);
+        mat->SetDstBlend(BlendFunc_InvSrcAlpha);
+        mat->SetSrcBlend(BlendFunc_SrcAlpha);
+        MaterialLibrary::Register("Translucent2D", std::move(mat));
+
 		return true;
 	}
 

src/Nazara/Graphics/RenderTechniques.cpp

@@ -18,6 +18,7 @@ namespace Nz
 			"Advanced Forward",
 			"Basic Forward",
 			"Deferred Shading",
+			"Depth Pass",
 			"Light Pre-Pass",
 			"User"
 		};

src/Nazara/Graphics/Resources/Shaders/PhongLighting/core.frag

@@ -8,6 +8,7 @@ layout(early_fragment_tests) in;
 
 /********************Entrant********************/
 in vec4 vColor;
+in vec4 vLightSpacePos[3];
 in mat3 vLightToWorld;
 in vec3 vNormal;
 in vec2 vTexCoord;
@@ -29,10 +30,13 @@ struct Light
 	vec4 parameters1;
 	vec4 parameters2;
 	vec2 parameters3;
+	bool shadowMapping;
 };
 
 // Lumières
 uniform Light Lights[3];
+uniform samplerCube PointLightShadowMap[3];
+uniform sampler2D DirectionalSpotLightShadowMap[3];
 
 // Matériau
 uniform sampler2D MaterialAlphaMap;
@@ -81,6 +85,41 @@ vec4 EncodeNormal(in vec3 normal)
 	return vec4(vec2(atan(normal.y, normal.x)/kPI, normal.z), 0.0, 0.0);
 }
 
+float VectorToDepthValue(vec3 vec, float zNear, float zFar)
+{
+	vec3 absVec = abs(vec);
+	float localZ = max(absVec.x, max(absVec.y, absVec.z));
+
+	float normZ = ((zFar + zNear) * localZ - (2.0*zFar*zNear)) / ((zFar - zNear)*localZ);
+	return (normZ + 1.0) * 0.5;
+}
+
+float CalculateDirectionalShadowFactor(int lightIndex)
+{
+	vec4 lightSpacePos = vLightSpacePos[lightIndex];
+	return (texture(DirectionalSpotLightShadowMap[lightIndex], lightSpacePos.xy).x >= (lightSpacePos.z - 0.0005)) ? 1.0 : 0.0;
+}
+
+float CalculatePointShadowFactor(int lightIndex, vec3 lightToWorld, float zNear, float zFar)
+{
+	return (texture(PointLightShadowMap[lightIndex], vec3(lightToWorld.x, -lightToWorld.y, -lightToWorld.z)).x >= VectorToDepthValue(lightToWorld, zNear, zFar)) ? 1.0 : 0.0;
+}
+
+float CalculateSpotShadowFactor(int lightIndex)
+{
+	vec4 lightSpacePos = vLightSpacePos[lightIndex];
+
+	float visibility = 1.0;
+	float x,y;
+	for (y = -3.5; y <= 3.5; y+= 1.0)
+		for (x = -3.5; x <= 3.5; x+= 1.0)
+			visibility += (textureProj(DirectionalSpotLightShadowMap[lightIndex], lightSpacePos.xyw + vec3(x/1024.0 * lightSpacePos.w, y/1024.0 * lightSpacePos.w, 0.0)).x >= (lightSpacePos.z - 0.0005)/lightSpacePos.w) ? 1.0 : 0.0;
+
+	visibility /= 64.0;
+	
+	return visibility;
+}
+
 void main()
 {
 	vec4 diffuseColor = MaterialDiffuse * vColor;
@@ -168,6 +207,10 @@ void main()
 
 		for (int i = 0; i < 3; ++i)
 		{
+			vec4 lightColor = Lights[i].color;
+			float lightAmbientFactor = Lights[i].factors.x;
+			float lightDiffuseFactor = Lights[i].factors.y;
+
 			switch (Lights[i].type)
 			{
 				case LIGHT_DIRECTIONAL:
@@ -175,75 +218,120 @@ void main()
 					vec3 lightDir = -Lights[i].parameters1.xyz;
 
 					// Ambient
-					lightAmbient += Lights[i].color.rgb * Lights[i].factors.x * (MaterialAmbient.rgb + SceneAmbient.rgb);
+					lightAmbient += lightColor.rgb * lightAmbientFactor * (MaterialAmbient.rgb + SceneAmbient.rgb);
+
+					float att = 1.0;
+
+					#if SHADOW_MAPPING
+					if (Lights[i].shadowMapping)
+					{
+						float shadowFactor = CalculateDirectionalShadowFactor(i);
+						if (shadowFactor == 0.0)
+							break;
+							
+						att *= shadowFactor;
+					}
+					#endif
 
 					// Diffuse
 					float lambert = max(dot(normal, lightDir), 0.0);
 
-					lightDiffuse += lambert * Lights[i].color.rgb * Lights[i].factors.y;
+					lightDiffuse += att * lambert * lightColor.rgb * lightDiffuseFactor;
 
 					// Specular
 					vec3 reflection = reflect(-lightDir, normal);
 					float specularFactor = max(dot(reflection, eyeVec), 0.0);
 					specularFactor = pow(specularFactor, MaterialShininess);
 
-					lightSpecular += specularFactor * Lights[i].color.rgb;
+					lightSpecular += att * specularFactor * lightColor.rgb;
 					break;
 				}
 
 				case LIGHT_POINT:
 				{
-					vec3 lightDir = Lights[i].parameters1.xyz - vWorldPos;
-					float lightDirLength = length(lightDir);
-					lightDir /= lightDirLength; // Normalisation
+					vec3 lightPos = Lights[i].parameters1.xyz;
+					float lightAttenuation = Lights[i].parameters1.w;
+					float lightInvRadius = Lights[i].parameters2.w;
 					
-					float att = max(Lights[i].parameters1.w - Lights[i].parameters2.w*lightDirLength, 0.0);
+					vec3 worldToLight = lightPos - vWorldPos;
+					float lightDirLength = length(worldToLight);
+					vec3 lightDir = worldToLight / lightDirLength; // Normalisation
+					
+					float att = max(lightAttenuation - lightInvRadius * lightDirLength, 0.0);
 
 					// Ambient
-					lightAmbient += att * Lights[i].color.rgb * Lights[i].factors.x * (MaterialAmbient.rgb + SceneAmbient.rgb);
+					lightAmbient += att * lightColor.rgb * lightAmbientFactor * (MaterialAmbient.rgb + SceneAmbient.rgb);
+
+					#if SHADOW_MAPPING
+					if (Lights[i].shadowMapping)
+					{
+						float shadowFactor = CalculatePointShadowFactor(i, vWorldPos - lightPos, 0.1, 50.0);
+						if (shadowFactor == 0.0)
+							break;
+							
+						att *= shadowFactor;
+					}
+					#endif
 
 					// Diffuse
 					float lambert = max(dot(normal, lightDir), 0.0);
 					
-					lightDiffuse += att * lambert * Lights[i].color.rgb * Lights[i].factors.y;
+					lightDiffuse += att * lambert * lightColor.rgb * lightDiffuseFactor;
 
 					// Specular
 					vec3 reflection = reflect(-lightDir, normal);
 					float specularFactor = max(dot(reflection, eyeVec), 0.0);
 					specularFactor = pow(specularFactor, MaterialShininess);
 
-					lightSpecular += att * specularFactor * Lights[i].color.rgb;
+					lightSpecular += att * specularFactor * lightColor.rgb;
 					break;
 				}
 
 				case LIGHT_SPOT:
 				{
-					vec3 lightDir = Lights[i].parameters1.xyz - vWorldPos;
-					float lightDirLength = length(lightDir);
-					lightDir /= lightDirLength; // Normalisation
+					vec3 lightPos = Lights[i].parameters1.xyz;
+					vec3 lightDir = Lights[i].parameters2.xyz;
+					float lightAttenuation = Lights[i].parameters1.w;
+					float lightInvRadius = Lights[i].parameters2.w;
+					float lightInnerAngle = Lights[i].parameters3.x;
+					float lightOuterAngle = Lights[i].parameters3.y;
+
+					vec3 worldToLight = lightPos - vWorldPos;
+					float lightDistance = length(worldToLight);
+					worldToLight /= lightDistance; // Normalisation
 					
-					float att = max(Lights[i].parameters1.w - Lights[i].parameters2.w*lightDirLength, 0.0);
+					float att = max(lightAttenuation - lightInvRadius * lightDistance, 0.0);
 
 					// Ambient
-					lightAmbient += att * Lights[i].color.rgb * Lights[i].factors.x * (MaterialAmbient.rgb + SceneAmbient.rgb);
+					lightAmbient += att * lightColor.rgb * lightAmbientFactor * (MaterialAmbient.rgb + SceneAmbient.rgb);
+
+					#if SHADOW_MAPPING
+					if (Lights[i].shadowMapping)
+					{
+						float shadowFactor = CalculateSpotShadowFactor(i);
+						if (shadowFactor == 0.0)
+							break;
+							
+						att *= shadowFactor;
+					}
+					#endif
 
 					// Modification de l'atténuation pour gérer le spot
-					float curAngle = dot(Lights[i].parameters2.xyz, -lightDir);
-					float outerAngle = Lights[i].parameters3.y;
-					float innerMinusOuterAngle = Lights[i].parameters3.x - outerAngle;
-					att *= max((curAngle - outerAngle) / innerMinusOuterAngle, 0.0);
+					float curAngle = dot(lightDir, -worldToLight);
+					float innerMinusOuterAngle = lightInnerAngle - lightOuterAngle;
+					att *= max((curAngle - lightOuterAngle) / innerMinusOuterAngle, 0.0);
 
 					// Diffuse
-					float lambert = max(dot(normal, lightDir), 0.0);
+					float lambert = max(dot(normal, worldToLight), 0.0);
 
-					lightDiffuse += att * lambert * Lights[i].color.rgb * Lights[i].factors.y;
+					lightDiffuse += att * lambert * lightColor.rgb * lightDiffuseFactor;
 
 					// Specular
-					vec3 reflection = reflect(-lightDir, normal);
+					vec3 reflection = reflect(-worldToLight, normal);
 					float specularFactor = max(dot(reflection, eyeVec), 0.0);
 					specularFactor = pow(specularFactor, MaterialShininess);
 
-					lightSpecular += att * specularFactor * Lights[i].color.rgb;
+					lightSpecular += att * specularFactor * lightColor.rgb;
 					break;
 				}
 				
@@ -256,61 +344,110 @@ void main()
 	{
 		for (int i = 0; i < 3; ++i)
 		{
+			vec4 lightColor = Lights[i].color;
+			float lightAmbientFactor = Lights[i].factors.x;
+			float lightDiffuseFactor = Lights[i].factors.y;
+
 			switch (Lights[i].type)
 			{
 				case LIGHT_DIRECTIONAL:
 				{
-					vec3 lightDir = normalize(-Lights[i].parameters1.xyz);
+					vec3 lightDir = -Lights[i].parameters1.xyz;
 
 					// Ambient
-					lightAmbient += Lights[i].color.rgb * Lights[i].factors.x * (MaterialAmbient.rgb + SceneAmbient.rgb);
+					lightAmbient += lightColor.rgb * lightAmbientFactor * (MaterialAmbient.rgb + SceneAmbient.rgb);
+
+					float att = 1.0;
+
+					#if SHADOW_MAPPING
+					if (Lights[i].shadowMapping)
+					{
+						float shadowFactor = CalculateDirectionalShadowFactor(i);
+						if (shadowFactor == 0.0)
+							break;
+							
+						att *= shadowFactor;
+					}
+					#endif
 
 					// Diffuse
 					float lambert = max(dot(normal, lightDir), 0.0);
 
-					lightDiffuse += lambert * Lights[i].color.rgb * Lights[i].factors.y;
+					lightDiffuse += att * lambert * lightColor.rgb * lightDiffuseFactor;
 					break;
 				}
 
 				case LIGHT_POINT:
 				{
-					vec3 lightDir = Lights[i].parameters1.xyz - vWorldPos;
-					float lightDirLength = length(lightDir);
-					lightDir /= lightDirLength; // Normalisation
+					vec3 lightPos = Lights[i].parameters1.xyz;
+					float lightAttenuation = Lights[i].parameters1.w;
+					float lightInvRadius = Lights[i].parameters2.w;
 					
-					float att = max(Lights[i].parameters1.w - Lights[i].parameters2.w*lightDirLength, 0.0);
+					vec3 worldToLight = lightPos - vWorldPos;
+					float lightDirLength = length(worldToLight);
+					vec3 lightDir = worldToLight / lightDirLength; // Normalisation
+					
+					float att = max(lightAttenuation - lightInvRadius * lightDirLength, 0.0);
 
 					// Ambient
-					lightAmbient += att * Lights[i].color.rgb * Lights[i].factors.x * (MaterialAmbient.rgb + SceneAmbient.rgb);
+					lightAmbient += att * lightColor.rgb * lightAmbientFactor * (MaterialAmbient.rgb + SceneAmbient.rgb);
+
+					#if SHADOW_MAPPING
+					if (Lights[i].shadowMapping)
+					{
+						float shadowFactor = CalculatePointShadowFactor(i, vWorldPos - lightPos, 0.1, 50.0);
+						if (shadowFactor == 0.0)
+							break;
+							
+						att *= shadowFactor;
+					}
+					#endif
 
 					// Diffuse
 					float lambert = max(dot(normal, lightDir), 0.0);
 					
-					lightDiffuse += att * lambert * Lights[i].color.rgb * Lights[i].factors.y;
+					lightDiffuse += att * lambert * lightColor.rgb * lightDiffuseFactor;
 					break;
 				}
 
 				case LIGHT_SPOT:
 				{
-					vec3 lightDir = Lights[i].parameters1.xyz - vWorldPos;
-					float lightDirLength = length(lightDir);
-					lightDir /= lightDirLength; // Normalisation
+					vec3 lightPos = Lights[i].parameters1.xyz;
+					vec3 lightDir = Lights[i].parameters2.xyz;
+					float lightAttenuation = Lights[i].parameters1.w;
+					float lightInvRadius = Lights[i].parameters2.w;
+					float lightInnerAngle = Lights[i].parameters3.x;
+					float lightOuterAngle = Lights[i].parameters3.y;
+
+					vec3 worldToLight = lightPos - vWorldPos;
+					float lightDistance = length(worldToLight);
+					worldToLight /= lightDistance; // Normalisation
 					
-					float att = max(Lights[i].parameters1.w - Lights[i].parameters2.w*lightDirLength, 0.0);
+					float att = max(lightAttenuation - lightInvRadius * lightDistance, 0.0);
 
 					// Ambient
-					lightAmbient += att * Lights[i].color.rgb * Lights[i].factors.x * (MaterialAmbient.rgb + SceneAmbient.rgb);
+					lightAmbient += att * lightColor.rgb * lightAmbientFactor * (MaterialAmbient.rgb + SceneAmbient.rgb);
+
+					#if SHADOW_MAPPING
+					if (Lights[i].shadowMapping)
+					{
+						float shadowFactor = CalculateSpotShadowFactor(i);
+						if (shadowFactor == 0.0)
+							break;
+							
+						att *= shadowFactor;
+					}
+					#endif
 
 					// Modification de l'atténuation pour gérer le spot
-					float curAngle = dot(Lights[i].parameters2.xyz, -lightDir);
-					float outerAngle = Lights[i].parameters3.y;
-					float innerMinusOuterAngle = Lights[i].parameters3.x - outerAngle;
-					att *= max((curAngle - outerAngle) / innerMinusOuterAngle, 0.0);
+					float curAngle = dot(lightDir, -worldToLight);
+					float innerMinusOuterAngle = lightInnerAngle - lightOuterAngle;
+					att *= max((curAngle - lightOuterAngle) / innerMinusOuterAngle, 0.0);
 
 					// Diffuse
-					float lambert = max(dot(normal, lightDir), 0.0);
+					float lambert = max(dot(normal, worldToLight), 0.0);
 
-					lightDiffuse += att * lambert * Lights[i].color.rgb * Lights[i].factors.y;
+					lightDiffuse += att * lambert * lightColor.rgb * lightDiffuseFactor;
 				}
 				
 				default:
@@ -318,7 +455,7 @@ void main()
 			}
 		}
 	}
-
+	
 	lightSpecular *= MaterialSpecular.rgb;
 		#if SPECULAR_MAPPING
 	lightSpecular *= texture(MaterialSpecularMap, texCoord).rgb; // Utiliser l'alpha de MaterialSpecular n'aurait aucun sens
@@ -340,3 +477,4 @@ void main()
 	#endif // LIGHTING
 #endif // FLAG_DEFERRED
 }
+

src/Nazara/Graphics/Resources/Shaders/PhongLighting/core.vert

@@ -15,6 +15,7 @@ in vec2 VertexTexCoord;
 
 /********************Sortant********************/
 out vec4 vColor;
+out vec4 vLightSpacePos[3];
 out mat3 vLightToWorld;
 out vec3 vNormal;
 out vec2 vTexCoord;
@@ -23,6 +24,8 @@ out vec3 vWorldPos;
 
 /********************Uniformes********************/
 uniform vec3 EyePosition;
+uniform mat4 InvViewMatrix;
+uniform mat4 LightViewProjMatrix[3];
 uniform float VertexDepth;
 uniform mat4 ViewProjMatrix;
 uniform mat4 WorldMatrix;
@@ -121,6 +124,11 @@ void main()
 	#endif
 #endif
 
+#if SHADOW_MAPPING
+	for (int i = 0; i < 3; ++i)
+		vLightSpacePos[i] = LightViewProjMatrix[i] * WorldMatrix * vec4(VertexPosition, 1.0);
+#endif
+
 #if TEXTURE_MAPPING
 	vTexCoord = VertexTexCoord;
 #endif

src/Nazara/Renderer/OpenGL.cpp

@@ -995,6 +995,7 @@ namespace Nz
 			glUniformMatrix4fv = reinterpret_cast<PFNGLUNIFORMMATRIX4FVPROC>(LoadEntry("glUniformMatrix4fv"));
 			glUnmapBuffer = reinterpret_cast<PFNGLUNMAPBUFFERPROC>(LoadEntry("glUnmapBuffer"));
 			glUseProgram = reinterpret_cast<PFNGLUSEPROGRAMPROC>(LoadEntry("glUseProgram"));
+			glValidateProgram = reinterpret_cast<PFNGLVALIDATEPROGRAMPROC>(LoadEntry("glValidateProgram"));
 			glVertexAttrib4f = reinterpret_cast<PFNGLVERTEXATTRIB4FPROC>(LoadEntry("glVertexAttrib4f"));
 			glVertexAttribDivisor = reinterpret_cast<PFNGLVERTEXATTRIBDIVISORPROC>(LoadEntry("glVertexAttribDivisor"));
 			glVertexAttribPointer = reinterpret_cast<PFNGLVERTEXATTRIBPOINTERPROC>(LoadEntry("glVertexAttribPointer"));
@@ -1684,24 +1685,44 @@ namespace Nz
 				format->dataFormat = GL_DEPTH_COMPONENT;
 				format->dataType = GL_UNSIGNED_SHORT;
 				format->internalFormat = GL_DEPTH_COMPONENT16;
+
+				format->swizzle[0] = GL_RED;
+				format->swizzle[1] = GL_RED;
+				format->swizzle[2] = GL_RED;
+				format->swizzle[3] = GL_ONE;
 				return true;
 
 			case PixelFormatType_Depth24:
 				format->dataFormat = GL_DEPTH_COMPONENT;
 				format->dataType = GL_UNSIGNED_INT;
 				format->internalFormat = GL_DEPTH_COMPONENT24;
+
+				format->swizzle[0] = GL_RED;
+				format->swizzle[1] = GL_RED;
+				format->swizzle[2] = GL_RED;
+				format->swizzle[3] = GL_ONE;
 				return true;
 
 			case PixelFormatType_Depth24Stencil8:
 				format->dataFormat = GL_DEPTH_STENCIL;
 				format->dataType = GL_UNSIGNED_INT_24_8;
 				format->internalFormat = GL_DEPTH24_STENCIL8;
+
+				format->swizzle[0] = GL_RED;
+				format->swizzle[1] = GL_RED;
+				format->swizzle[2] = GL_RED;
+				format->swizzle[3] = GL_GREEN;
 				return true;
 
 			case PixelFormatType_Depth32:
 				format->dataFormat = GL_DEPTH_COMPONENT;
 				format->dataType = GL_UNSIGNED_BYTE;
 				format->internalFormat = GL_DEPTH_COMPONENT32;
+
+				format->swizzle[0] = GL_RED;
+				format->swizzle[1] = GL_RED;
+				format->swizzle[2] = GL_RED;
+				format->swizzle[3] = GL_ONE;
 				return true;
 
 			case PixelFormatType_Stencil1:
@@ -2248,12 +2269,14 @@ PFNGLUNIFORMMATRIX4DVPROC         glUniformMatrix4dv         = nullptr;
 PFNGLUNIFORMMATRIX4FVPROC         glUniformMatrix4fv         = nullptr;
 PFNGLUNMAPBUFFERPROC              glUnmapBuffer              = nullptr;
 PFNGLUSEPROGRAMPROC               glUseProgram               = nullptr;
+PFNGLVALIDATEPROGRAMPROC          glValidateProgram          = nullptr;
 PFNGLVERTEXATTRIB4FPROC           glVertexAttrib4f           = nullptr;
 PFNGLVERTEXATTRIBDIVISORPROC      glVertexAttribDivisor      = nullptr;
 PFNGLVERTEXATTRIBPOINTERPROC      glVertexAttribPointer      = nullptr;
 PFNGLVERTEXATTRIBIPOINTERPROC     glVertexAttribIPointer     = nullptr;
 PFNGLVERTEXATTRIBLPOINTERPROC     glVertexAttribLPointer     = nullptr;
 PFNGLVIEWPORTPROC                 glViewport                 = nullptr;
+
 #if defined(NAZARA_PLATFORM_WINDOWS)
 PFNWGLCHOOSEPIXELFORMATARBPROC    wglChoosePixelFormat       = nullptr;
 PFNWGLCREATECONTEXTATTRIBSARBPROC wglCreateContextAttribs    = nullptr;

src/Nazara/Renderer/RenderTexture.cpp

@@ -156,9 +156,6 @@ namespace Nz
 		InvalidateSize();
 		InvalidateTargets();
 
-		if (attachmentPoint == AttachmentPoint_Color && !m_impl->userDefinedTargets)
-			m_impl->colorTargets.push_back(index);
-
 		return true;
 	}
 
@@ -293,9 +290,6 @@ namespace Nz
 		InvalidateSize();
 		InvalidateTargets();
 
-		if (attachmentPoint == AttachmentPoint_Color && !m_impl->userDefinedTargets)
-			m_impl->colorTargets.push_back(index);
-
 		return true;
 	}
 
@@ -819,6 +813,15 @@ namespace Nz
 
 	void RenderTexture::UpdateTargets() const
 	{
+		if (!m_impl->userDefinedTargets)
+		{
+			m_impl->colorTargets.clear();
+
+			unsigned int colorIndex = 0;
+			for (unsigned int index = attachmentIndex[AttachmentPoint_Color]; index < m_impl->attachments.size(); ++index)
+				m_impl->colorTargets.push_back(colorIndex++);
+		}
+
 		if (m_impl->colorTargets.empty())
 		{
 			m_impl->drawBuffers.resize(1);

src/Nazara/Renderer/Renderer.cpp

@@ -1713,6 +1713,14 @@ namespace Nz
 		// Et on termine par envoyer nos états au driver
 		OpenGL::ApplyStates(s_states);
 
+		#ifdef NAZARA_DEBUG
+		if (!s_shader->Validate())
+		{
+			NazaraError(Error::GetLastError());
+			return false;
+		}
+		#endif
+
 		return true;
 	}
 

src/Nazara/Renderer/Shader.cpp

@@ -747,6 +747,31 @@ namespace Nz
 		}
 	}
 
+	bool Shader::Validate() const
+	{
+		#if NAZARA_RENDERER_SAFE
+		if (!m_program)
+		{
+			NazaraError("Shader is not initialized");
+			return false;
+		}
+		#endif
+
+		glValidateProgram(m_program);
+
+		GLint success;
+		glGetProgramiv(m_program, GL_VALIDATE_STATUS, &success);
+
+		if (success == GL_TRUE)
+			return true;
+		else
+		{
+			NazaraError("Failed to validate shader: " + GetLog());
+			return false;
+		}
+	}
+
+
 	unsigned int Shader::GetOpenGLID() const
 	{
 		return m_program;

src/Nazara/Renderer/Texture.cpp

@@ -1306,6 +1306,12 @@ namespace Nz
 			glTexParameteri(target, GL_TEXTURE_SWIZZLE_A, openGLFormat.swizzle[3]);
 		}
 
+		if (!proxy && PixelFormat::GetType(m_impl->format) == PixelFormatTypeType_Depth)
+		{
+			glTexParameteri(target, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
+			glTexParameteri(target, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
+		}
+
 		return true;
 	}
 

src/Nazara/Utility/Formats/DDSConstants.hpp

@@ -8,7 +8,7 @@
 #define NAZARA_LOADERS_DDS_CONSTANTS_HPP
 
 #include <Nazara/Prerequesites.hpp>
-#include <Nazara/Core/Serialization.hpp>
+#include <Nazara/Core/SerializationContext.hpp>
 #include <Nazara/Utility/Config.hpp>
 
 namespace Nz

src/Nazara/Utility/Formats/DDSLoader.cpp

@@ -65,7 +65,7 @@ namespace Nz
 					headerDX10.resourceDimension = D3D10_RESOURCE_DIMENSION_UNKNOWN;
 				}
 
-				if (header.flags & DDSD_WIDTH == 0)
+				if ((header.flags & DDSD_WIDTH) == 0)
 					NazaraWarning("Ill-formed DDS file, doesn't have a width flag");
 
 				unsigned int width = std::max(header.width, 1U);
@@ -141,7 +141,7 @@ namespace Nz
 				{
 					if (header.ddsCaps[1] & DDSCAPS2_CUBEMAP)
 					{
-						if (header.ddsCaps[1] & DDSCAPS2_CUBEMAP_ALLFACES != DDSCAPS2_CUBEMAP_ALLFACES)
+						if ((header.ddsCaps[1] & DDSCAPS2_CUBEMAP_ALLFACES) != DDSCAPS2_CUBEMAP_ALLFACES)
 						{
 							NazaraError("Partial cubemap are not yet supported, sorry");
 							return false;

src/Nazara/Utility/Formats/MD2Loader.cpp

@@ -9,6 +9,7 @@
 #include <Nazara/Math/Algorithm.hpp>
 #include <Nazara/Math/Quaternion.hpp>
 #include <Nazara/Utility/BufferMapper.hpp>
+#include <Nazara/Utility/MaterialData.hpp>
 #include <Nazara/Utility/Mesh.hpp>
 #include <Nazara/Utility/StaticMesh.hpp>
 #include <Nazara/Utility/Formats/MD2Constants.hpp>
@@ -99,7 +100,11 @@ namespace Nz
 					for (unsigned int i = 0; i < header.num_skins; ++i)
 					{
 						stream.Read(skin, 68*sizeof(char));
-						mesh->SetMaterial(i, baseDir + skin);
+
+						ParameterList matData;
+						matData.SetParameter(MaterialData::FilePath, baseDir + skin);
+
+						mesh->SetMaterialData(i, std::move(matData));
 					}
 				}
 			}

src/Nazara/Utility/Formats/MD5MeshLoader.cpp

@@ -5,6 +5,7 @@
 #include <Nazara/Utility/Formats/MD5MeshLoader.hpp>
 #include <Nazara/Utility/IndexIterator.hpp>
 #include <Nazara/Utility/IndexMapper.hpp>
+#include <Nazara/Utility/MaterialData.hpp>
 #include <Nazara/Utility/SkeletalMesh.hpp>
 #include <Nazara/Utility/StaticMesh.hpp>
 #include <Nazara/Utility/Formats/MD5MeshParser.hpp>
@@ -41,7 +42,7 @@ namespace Nz
 
 			// Pour que le squelette soit correctement aligné, il faut appliquer un quaternion "de correction" aux joints à la base du squelette
 			Quaternionf rotationQuat = Quaternionf::RotationBetween(Vector3f::UnitX(), Vector3f::Forward()) *
-										 Quaternionf::RotationBetween(Vector3f::UnitZ(), Vector3f::Up());
+			                           Quaternionf::RotationBetween(Vector3f::UnitZ(), Vector3f::Up());
 
 			String baseDir = stream.GetDirectory();
 
@@ -189,7 +190,10 @@ namespace Nz
 					vertexMapper.Unmap();
 
 					// Material
-					mesh->SetMaterial(i, baseDir + md5Mesh.shader);
+					ParameterList matData;
+					matData.SetParameter(MaterialData::FilePath, baseDir + md5Mesh.shader);
+
+					mesh->SetMaterialData(i, std::move(matData));
 
 					// Submesh
 					SkeletalMeshRef subMesh = SkeletalMesh::New(mesh);
@@ -285,7 +289,10 @@ namespace Nz
 					mesh->AddSubMesh(subMesh);
 
 					// Material
-					mesh->SetMaterial(i, baseDir + md5Mesh.shader);
+					ParameterList matData;
+					matData.SetParameter(MaterialData::FilePath, baseDir + md5Mesh.shader);
+
+					mesh->SetMaterialData(i, std::move(matData));
 				}
 
 				if (parameters.center)

src/Nazara/Utility/Formats/MD5MeshParser.cpp

@@ -194,6 +194,7 @@ namespace Nz
 				m_currentLine = m_stream.ReadLine();
 				m_currentLine = m_currentLine.SubStringTo("//"); // On ignore les commentaires
 				m_currentLine.Simplify(); // Pour un traitement plus simple
+				m_currentLine.Trim();
 			}
 			while (m_currentLine.IsEmpty());
 		}

src/Nazara/Utility/Formats/OBJLoader.cpp

@@ -1,14 +1,13 @@
-// Copyright (C) 2015 Jérôme Leclercq
-// This file is part of the "Nazara Engine - Graphics module"
+// Copyright (C) 2016 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Utility module"
 // For conditions of distribution and use, see copyright notice in Config.hpp
 
-#include <Nazara/Graphics/Formats/OBJLoader.hpp>
+#include <Nazara/Utility/Formats/OBJLoader.hpp>
 #include <Nazara/Core/Algorithm.hpp>
 #include <Nazara/Core/ErrorFlags.hpp>
-#include <Nazara/Graphics/Material.hpp>
-#include <Nazara/Graphics/Model.hpp>
 #include <Nazara/Utility/BufferMapper.hpp>
 #include <Nazara/Utility/IndexMapper.hpp>
+#include <Nazara/Utility/MaterialData.hpp>
 #include <Nazara/Utility/Mesh.hpp>
 #include <Nazara/Utility/StaticMesh.hpp>
 #include <Nazara/Utility/Formats/MTLParser.hpp>
@@ -17,7 +16,7 @@
 #include <limits>
 #include <memory>
 #include <unordered_map>
-#include <Nazara/Graphics/Debug.hpp>
+#include <Nazara/Utility/Debug.hpp>
 
 ///TODO: N'avoir qu'un seul VertexBuffer communs à tous les meshes
 
@@ -30,7 +29,7 @@ namespace Nz
 			return (extension == "obj");
 		}
 
-		Ternary Check(Stream& stream, const ModelParameters& parameters)
+		Ternary Check(Stream& stream, const MeshParams& parameters)
 		{
 			NazaraUnused(stream);
 
@@ -41,7 +40,7 @@ namespace Nz
 			return Ternary_Unknown;
 		}
 
-		bool LoadMaterials(Model* model, const String& filePath, const MaterialParams& parameters, const String* materials, const OBJParser::Mesh* meshes, unsigned int meshCount)
+		bool ParseMTL(Mesh* mesh, const String& filePath, const String* materials, const OBJParser::Mesh* meshes, unsigned int meshCount)
 		{
 			File file(filePath);
 			if (!file.Open(OpenMode_ReadOnly | OpenMode_Text))
@@ -57,7 +56,7 @@ namespace Nz
 				return false;
 			}
 
-			std::unordered_map<String, MaterialRef> materialCache;
+			std::unordered_map<String, ParameterList> materialCache;
 			String baseDir = file.GetDirectory();
 			for (unsigned int i = 0; i < meshCount; ++i)
 			{
@@ -72,8 +71,9 @@ namespace Nz
 				auto it = materialCache.find(matName);
 				if (it == materialCache.end())
 				{
-					MaterialRef material = Material::New();
-					material->SetShader(parameters.shaderName);
+					ParameterList data;
+
+					data.SetParameter(MaterialData::CustomDefined);
 
 					UInt8 alphaValue = static_cast<UInt8>(mtlMat->alpha*255.f);
 
@@ -84,54 +84,40 @@ namespace Nz
 					diffuseColor.a = alphaValue;
 					specularColor.a = alphaValue;
 
-					material->SetAmbientColor(ambientColor);
-					material->SetDiffuseColor(diffuseColor);
-					material->SetSpecularColor(specularColor);
-					material->SetShininess(mtlMat->shininess);
+					data.SetParameter(MaterialData::AmbientColor, ambientColor);
+					data.SetParameter(MaterialData::DiffuseColor, diffuseColor);
+					data.SetParameter(MaterialData::Shininess, mtlMat->shininess);
+					data.SetParameter(MaterialData::SpecularColor, specularColor);
 
-					bool isTranslucent = (alphaValue != 255);
+					if (!mtlMat->alphaMap.IsEmpty())
+						data.SetParameter(MaterialData::AlphaTexturePath, baseDir + mtlMat->alphaMap);
 
-					if (parameters.loadAlphaMap && !mtlMat->alphaMap.IsEmpty())
+					if (!mtlMat->diffuseMap.IsEmpty())
+						data.SetParameter(MaterialData::DiffuseTexturePath, baseDir + mtlMat->diffuseMap);
+
+					if (!mtlMat->specularMap.IsEmpty())
+						data.SetParameter(MaterialData::SpecularTexturePath, baseDir + mtlMat->specularMap);
+
+					// If we either have an alpha value or an alpha map, let's configure the material for transparency
+					if (alphaValue != 255 || !mtlMat->alphaMap.IsEmpty())
 					{
-						if (material->SetAlphaMap(baseDir + mtlMat->alphaMap))
-							isTranslucent = true; // Une alpha map indique de la transparence
-						else
-							NazaraWarning("Failed to load alpha map (" + mtlMat->alphaMap + ')');
+						// Some default settings
+						data.SetParameter(MaterialData::Blending, true);
+						data.SetParameter(MaterialData::DepthWrite, true);
+						data.SetParameter(MaterialData::DstBlend, static_cast<int>(BlendFunc_InvSrcAlpha));
+						data.SetParameter(MaterialData::SrcBlend, static_cast<int>(BlendFunc_SrcAlpha));
 					}
 
-					if (parameters.loadDiffuseMap && !mtlMat->diffuseMap.IsEmpty())
-					{
-						if (!material->SetDiffuseMap(baseDir + mtlMat->diffuseMap))
-							NazaraWarning("Failed to load diffuse map (" + mtlMat->diffuseMap + ')');
-					}
-
-					if (parameters.loadSpecularMap && !mtlMat->specularMap.IsEmpty())
-					{
-						if (!material->SetSpecularMap(baseDir + mtlMat->specularMap))
-							NazaraWarning("Failed to load specular map (" + mtlMat->specularMap + ')');
-					}
-
-					// Si nous avons une alpha map ou des couleurs transparentes,
-					// nous devons configurer le matériau pour accepter la transparence au mieux
-					if (isTranslucent)
-					{
-						// On paramètre le matériau pour accepter la transparence au mieux
-						material->Enable(RendererParameter_Blend, true);
-						material->Enable(RendererParameter_DepthWrite, false);
-						material->SetDstBlend(BlendFunc_InvSrcAlpha);
-						material->SetSrcBlend(BlendFunc_SrcAlpha);
-					}
-
-					it = materialCache.emplace(matName, std::move(material)).first;
+					it = materialCache.emplace(matName, std::move(data)).first;
 				}
 
-				model->SetMaterial(meshes[i].material, it->second);
+				mesh->SetMaterialData(meshes[i].material, it->second);
 			}
 
 			return true;
 		}
 
-		bool Load(Model* model, Stream& stream, const ModelParameters& parameters)
+		bool Load(Mesh* mesh, Stream& stream, const MeshParams& parameters)
 		{
 			int reservedVertexCount;
 			if (!parameters.custom.GetIntegerParameter("NativeOBJLoader_VertexCount", &reservedVertexCount))
@@ -144,12 +130,7 @@ namespace Nz
 				return false;
 			}
 
-			MeshRef mesh = Mesh::New();
-			if (!mesh->CreateStatic()) // Ne devrait jamais échouer
-			{
-				NazaraInternalError("Failed to create mesh");
-				return false;
-			}
+			mesh->CreateStatic();
 
 			const String* materials = parser.GetMaterials();
 			const Vector4f* positions = parser.GetPositions();
@@ -160,8 +141,8 @@ namespace Nz
 			unsigned int meshCount = parser.GetMeshCount();
 
 			NazaraAssert(materials != nullptr && positions != nullptr && normals != nullptr &&
-						 texCoords != nullptr && meshes != nullptr && meshCount > 0,
-						 "Invalid OBJParser output");
+			             texCoords != nullptr && meshes != nullptr && meshCount > 0,
+			             "Invalid OBJParser output");
 
 			// Un conteneur temporaire pour contenir les indices de face avant triangulation
 			std::vector<unsigned int> faceIndices(3); // Comme il y aura au moins trois sommets
@@ -197,8 +178,8 @@ namespace Nz
 					bool operator()(const OBJParser::FaceVertex& lhs, const OBJParser::FaceVertex& rhs) const
 					{
 						return lhs.normal == rhs.normal &&
-							   lhs.position == rhs.position &&
-							   lhs.texCoord == rhs.texCoord;
+						       lhs.position == rhs.position &&
+						       lhs.texCoord == rhs.texCoord;
 					}
 				};
 
@@ -230,8 +211,8 @@ namespace Nz
 				}
 
 				// Création des buffers
-				IndexBufferRef indexBuffer = IndexBuffer::New(vertexCount > std::numeric_limits<UInt16>::max(), indices.size(), parameters.mesh.storage, BufferUsage_Static);
-				VertexBufferRef vertexBuffer = VertexBuffer::New(VertexDeclaration::Get(VertexLayout_XYZ_Normal_UV_Tangent), vertexCount, parameters.mesh.storage, BufferUsage_Static);
+				IndexBufferRef indexBuffer = IndexBuffer::New(vertexCount > std::numeric_limits<UInt16>::max(), indices.size(), parameters.storage, BufferUsage_Static);
+				VertexBufferRef vertexBuffer = VertexBuffer::New(VertexDeclaration::Get(VertexLayout_XYZ_Normal_UV_Tangent), vertexCount, parameters.storage, BufferUsage_Static);
 
 				// Remplissage des indices
 				IndexMapper indexMapper(indexBuffer, BufferAccess_WriteOnly);
@@ -254,7 +235,7 @@ namespace Nz
 
 					const Vector4f& vec = positions[vertexIndices.position];
 					vertex.position.Set(vec.x, vec.y, vec.z);
-					vertex.position *= parameters.mesh.scale/vec.w;
+					vertex.position *= parameters.scale/vec.w;
 
 					if (vertexIndices.normal >= 0)
 						vertex.normal = normals[vertexIndices.normal];
@@ -264,7 +245,7 @@ namespace Nz
 					if (vertexIndices.texCoord >= 0)
 					{
 						const Vector3f& uvw = texCoords[vertexIndices.texCoord];
-						vertex.uv.Set(uvw.x, (parameters.mesh.flipUVs) ? 1.f - uvw.y : uvw.y); // Inversion des UVs si demandé
+						vertex.uv.Set(uvw.x, (parameters.flipUVs) ? 1.f - uvw.y : uvw.y); // Inversion des UVs si demandé
 					}
 					else
 						hasTexCoords = false;
@@ -279,7 +260,7 @@ namespace Nz
 					continue;
 				}
 
-				if (parameters.mesh.optimizeIndexBuffers)
+				if (parameters.optimizeIndexBuffers)
 					indexBuffer->Optimize();
 
 				subMesh->GenerateAABB();
@@ -299,17 +280,15 @@ namespace Nz
 			}
 			mesh->SetMaterialCount(parser.GetMaterialCount());
 
-			if (parameters.mesh.center)
+			if (parameters.center)
 				mesh->Recenter();
 
-			model->SetMesh(mesh);
-
 			// On charge les matériaux si demandé
 			String mtlLib = parser.GetMtlLib();
-			if (parameters.loadMaterials && !mtlLib.IsEmpty())
+			if (!mtlLib.IsEmpty())
 			{
 				ErrorFlags flags(ErrorFlag_ThrowExceptionDisabled);
-				LoadMaterials(model, stream.GetDirectory() + mtlLib, parameters.material, materials, meshes, meshCount);
+				ParseMTL(mesh, stream.GetDirectory() + mtlLib, materials, meshes, meshCount);
 			}
 
 			return true;
@@ -320,12 +299,12 @@ namespace Nz
 	{
 		void RegisterOBJ()
 		{
-			ModelLoader::RegisterLoader(IsSupported, Check, Load);
+			MeshLoader::RegisterLoader(IsSupported, Check, Load);
 		}
 
 		void UnregisterOBJ()
 		{
-			ModelLoader::UnregisterLoader(IsSupported, Check, Load);
+			MeshLoader::UnregisterLoader(IsSupported, Check, Load);
 		}
 	}
 }

src/Nazara/Utility/Mesh.cpp

@@ -52,11 +52,11 @@ namespace Nz
 	{
 		MeshImpl()
 		{
-			materials.resize(1); // Un matériau par défaut
+			materialData.resize(1); // Un matériau par défaut
 		}
 
 		std::unordered_map<String, unsigned int> subMeshMap;
-		std::vector<String> materials;
+		std::vector<ParameterList> materialData;
 		std::vector<SubMeshRef> subMeshes;
 		AnimationType animationType;
 		Boxf aabb;
@@ -75,93 +75,36 @@ namespace Nz
 
 	void Mesh::AddSubMesh(SubMesh* subMesh)
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return;
-		}
+		NazaraAssert(m_impl, "Mesh should be created first");
+		NazaraAssert(subMesh, "Invalid submesh");
+		NazaraAssert(subMesh->GetAnimationType() == m_impl->animationType, "Submesh animation type doesn't match mesh animation type");
 
-		if (!subMesh)
-		{
-			NazaraError("Invalid submesh");
-			return;
-		}
-
-		if (subMesh->GetAnimationType() != m_impl->animationType)
-		{
-			NazaraError("Submesh animation type must match mesh animation type");
-			return;
-		}
-		#endif
-
-		m_impl->aabbUpdated = false; // On invalide l'AABB
 		m_impl->subMeshes.push_back(subMesh);
+
+		InvalidateAABB();
 	}
 
 	void Mesh::AddSubMesh(const String& identifier, SubMesh* subMesh)
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return;
-		}
-
-		if (identifier.IsEmpty())
-		{
-			NazaraError("Identifier is empty");
-			return;
-		}
-
-		auto it = m_impl->subMeshMap.find(identifier);
-		if (it != m_impl->subMeshMap.end())
-		{
-			NazaraError("SubMesh identifier \"" + identifier + "\" is already used");
-			return;
-		}
-
-		if (!subMesh)
-		{
-			NazaraError("Invalid submesh");
-			return;
-		}
-
-		if (m_impl->animationType != subMesh->GetAnimationType())
-		{
-			NazaraError("Submesh animation type must match mesh animation type");
-			return;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
+		NazaraAssert(!identifier.IsEmpty(), "Identifier is empty");
+		NazaraAssert(m_impl->subMeshMap.find(identifier) == m_impl->subMeshMap.end(), "SubMesh identifier \"" + identifier + "\" is already in use");
+		NazaraAssert(subMesh, "Invalid submesh");
+		NazaraAssert(subMesh->GetAnimationType() == m_impl->animationType, "Submesh animation type doesn't match mesh animation type");
 
 		int index = m_impl->subMeshes.size();
 
-		m_impl->aabbUpdated = false; // On invalide l'AABB
 		m_impl->subMeshes.push_back(subMesh);
 		m_impl->subMeshMap[identifier] = index;
+
+		InvalidateAABB();
 	}
 
 	SubMesh* Mesh::BuildSubMesh(const Primitive& primitive, const MeshParams& params)
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return nullptr;
-		}
-
-		if (m_impl->animationType != AnimationType_Static)
-		{
-			NazaraError("Mesh must be static");
-			return nullptr;
-		}
-
-		if (!params.IsValid())
-		{
-			NazaraError("Parameters must be valid");
-			return nullptr;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
+		NazaraAssert(m_impl->animationType == AnimationType_Static, "Submesh building only works for static meshes");
+		NazaraAssert(params.IsValid(), "Invalid parameters");
 
 		Boxf aabb;
 		IndexBufferRef indexBuffer;
@@ -333,17 +276,7 @@ namespace Nz
 
 	void Mesh::BuildSubMeshes(const PrimitiveList& list, const MeshParams& params)
 	{
-		unsigned int primitiveCount = list.GetSize();
-
-		#if NAZARA_UTILITY_SAFE
-		if (primitiveCount == 0)
-		{
-			NazaraError("PrimitiveList must have at least one primitive");
-			return;
-		}
-		#endif
-
-		for (unsigned int i = 0; i < primitiveCount; ++i)
+		for (unsigned int i = 0; i < list.GetSize(); ++i)
 			BuildSubMesh(list.GetPrimitive(i), params);
 	}
 
@@ -351,18 +284,17 @@ namespace Nz
 	{
 		Destroy();
 
-		m_impl = new MeshImpl;
-		m_impl->animationType = AnimationType_Skeletal;
-		m_impl->jointCount = jointCount;
-		if (!m_impl->skeleton.Create(jointCount))
+		std::unique_ptr<MeshImpl> impl(new MeshImpl);
+		impl->animationType = AnimationType_Skeletal;
+		impl->jointCount = jointCount;
+		if (!impl->skeleton.Create(jointCount))
 		{
-			delete m_impl;
-			m_impl = nullptr;
-
 			NazaraError("Failed to create skeleton");
 			return false;
 		}
 
+		m_impl = impl.release();
+
 		return true;
 	}
 
@@ -389,13 +321,7 @@ namespace Nz
 
 	void Mesh::GenerateNormals()
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		for (SubMesh* subMesh : m_impl->subMeshes)
 			subMesh->GenerateNormals();
@@ -403,13 +329,7 @@ namespace Nz
 
 	void Mesh::GenerateNormalsAndTangents()
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		for (SubMesh* subMesh : m_impl->subMeshes)
 			subMesh->GenerateNormalsAndTangents();
@@ -417,13 +337,7 @@ namespace Nz
 
 	void Mesh::GenerateTangents()
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		for (SubMesh* subMesh : m_impl->subMeshes)
 			subMesh->GenerateTangents();
@@ -431,15 +345,7 @@ namespace Nz
 
 	const Boxf& Mesh::GetAABB() const
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-
-			static Boxf dummy;
-			return dummy;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		if (!m_impl->aabbUpdated)
 		{
@@ -461,248 +367,121 @@ namespace Nz
 
 	String Mesh::GetAnimation() const
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return String();
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		return m_impl->animationPath;
 	}
 
 	AnimationType Mesh::GetAnimationType() const
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return AnimationType_Static;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		return m_impl->animationType;
 	}
 
 	unsigned int Mesh::GetJointCount() const
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return 0;
-		}
-
-		if (m_impl->animationType != AnimationType_Skeletal)
-		{
-			NazaraError("Mesh's animation type is not skeletal");
-			return 0;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
+		NazaraAssert(m_impl->animationType == AnimationType_Skeletal, "Mesh is not skeletal");
 
 		return m_impl->jointCount;
 	}
 
-	String Mesh::GetMaterial(unsigned int index) const
+	ParameterList& Mesh::GetMaterialData(unsigned int index)
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return String();
-		}
+		NazaraAssert(m_impl, "Mesh should be created first");
+		NazaraAssert(index < m_impl->materialData.size(), "Material index out of range");
 
-		if (index >= m_impl->materials.size())
-		{
-			NazaraError("Material index out of range (" + String::Number(index) + " >= " + String::Number(m_impl->materials.size()) + ')');
-			return String();
-		}
-		#endif
+		return m_impl->materialData[index];
+	}
 
-		return m_impl->materials[index];
+	const ParameterList& Mesh::GetMaterialData(unsigned int index) const
+	{
+		NazaraAssert(m_impl, "Mesh should be created first");
+		NazaraAssert(index < m_impl->materialData.size(), "Material index out of range");
+
+		return m_impl->materialData[index];
 	}
 
 	unsigned int Mesh::GetMaterialCount() const
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return 0;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
-		return m_impl->materials.size();
+		return m_impl->materialData.size();
 	}
 
 	Skeleton* Mesh::GetSkeleton()
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Animation not created");
-			return nullptr;
-		}
-
-		if (m_impl->animationType != AnimationType_Skeletal)
-		{
-			NazaraError("Mesh's animation type is not skeletal");
-			return nullptr;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
+		NazaraAssert(m_impl->animationType == AnimationType_Skeletal, "Mesh is not skeletal");
 
 		return &m_impl->skeleton;
 	}
 
 	const Skeleton* Mesh::GetSkeleton() const
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Animation not created");
-			return nullptr;
-		}
-
-		if (m_impl->animationType != AnimationType_Skeletal)
-		{
-			NazaraError("Mesh's animation type is not skeletal");
-			return nullptr;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
+		NazaraAssert(m_impl->animationType == AnimationType_Skeletal, "Mesh is not skeletal");
 
 		return &m_impl->skeleton;
 	}
 
 	SubMesh* Mesh::GetSubMesh(const String& identifier)
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return nullptr;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		auto it = m_impl->subMeshMap.find(identifier);
-
-		#if NAZARA_UTILITY_SAFE
-		if (it == m_impl->subMeshMap.end())
-		{
-			NazaraError("SubMesh not found");
-			return nullptr;
-		}
-		#endif
+		NazaraAssert(it != m_impl->subMeshMap.end(), "SubMesh " + identifier + " not found");
 
 		return m_impl->subMeshes[it->second];
 	}
 
 	SubMesh* Mesh::GetSubMesh(unsigned int index)
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return nullptr;
-		}
-
-		if (index >= m_impl->subMeshes.size())
-		{
-			NazaraError("SubMesh index out of range (" + String::Number(index) + " >= " + String::Number(m_impl->subMeshes.size()) + ')');
-			return nullptr;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
+		NazaraAssert(index < m_impl->subMeshes.size(), "Submesh index out of range");
 
 		return m_impl->subMeshes[index];
 	}
 
 	const SubMesh* Mesh::GetSubMesh(const String& identifier) const
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return nullptr;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		auto it = m_impl->subMeshMap.find(identifier);
-
-		#if NAZARA_UTILITY_SAFE
-		if (it == m_impl->subMeshMap.end())
-		{
-			NazaraError("SubMesh not found");
-			return nullptr;
-		}
-		#endif
+		NazaraAssert(it != m_impl->subMeshMap.end(), "SubMesh " + identifier + " not found");
 
 		return m_impl->subMeshes[it->second];
 	}
 
 	const SubMesh* Mesh::GetSubMesh(unsigned int index) const
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return nullptr;
-		}
-
-		if (index >= m_impl->subMeshes.size())
-		{
-			NazaraError("SubMesh index out of range (" + String::Number(index) + " >= " + String::Number(m_impl->subMeshes.size()) + ')');
-			return nullptr;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
+		NazaraAssert(index < m_impl->subMeshes.size(), "Submesh index out of range");
 
 		return m_impl->subMeshes[index];
 	}
 
 	unsigned int Mesh::GetSubMeshCount() const
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return 0;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		return m_impl->subMeshes.size();
 	}
 
 	int Mesh::GetSubMeshIndex(const String& identifier) const
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return -1;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		auto it = m_impl->subMeshMap.find(identifier);
-
-		#if NAZARA_UTILITY_SAFE
-		if (it == m_impl->subMeshMap.end())
-		{
-			NazaraError("SubMesh not found");
-			return -1;
-		}
-		#endif
+		NazaraAssert(it != m_impl->subMeshMap.end(), "SubMesh " + identifier + " not found");
 
 		return it->second;
 	}
 
 	unsigned int Mesh::GetTriangleCount() const
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return 0;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		unsigned int triangleCount = 0;
 		for (SubMesh* subMesh : m_impl->subMeshes)
@@ -713,13 +492,7 @@ namespace Nz
 
 	unsigned int Mesh::GetVertexCount() const
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return 0;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		unsigned int vertexCount = 0;
 		for (SubMesh* subMesh : m_impl->subMeshes)
@@ -730,52 +503,28 @@ namespace Nz
 
 	void Mesh::InvalidateAABB() const
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		m_impl->aabbUpdated = false;
 	}
 
 	bool Mesh::HasSubMesh(const String& identifier) const
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return false;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		return m_impl->subMeshMap.find(identifier) != m_impl->subMeshMap.end();
 	}
 
 	bool Mesh::HasSubMesh(unsigned int index) const
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return false;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		return index < m_impl->subMeshes.size();
 	}
 
 	bool Mesh::IsAnimable() const
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return false;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		return m_impl->animationType != AnimationType_Static;
 	}
@@ -802,21 +551,10 @@ namespace Nz
 
 	void Mesh::Recenter()
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return;
-		}
+		NazaraAssert(m_impl, "Mesh should be created first");
+		NazaraAssert(m_impl->animationType == AnimationType_Static, "Mesh is not static");
 
-		if (m_impl->animationType != AnimationType_Static)
-		{
-			NazaraError("Mesh must be static");
-			return;
-		}
-		#endif
-
-		// Le centre de notre mesh est le centre de l'AABB *globale*
+		// The center of our mesh is the center of our *global* AABB
 		Vector3f center = GetAABB().GetCenter();
 
 		for (SubMesh* subMesh : m_impl->subMeshes)
@@ -833,119 +571,62 @@ namespace Nz
 				vertices++;
 			}
 
-			// l'AABB ne change pas de dimensions mais seulement de position, appliquons-lui le même procédé
+			// Our AABB doesn't change shape, only position
 			Boxf aabb = staticMesh->GetAABB();
 			aabb.Translate(-center);
 
 			staticMesh->SetAABB(aabb);
 		}
 
-		// Il ne faut pas oublier d'invalider notre AABB
-		m_impl->aabbUpdated = false;
+		InvalidateAABB();
 	}
 
 	void Mesh::RemoveSubMesh(const String& identifier)
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return;
-		}
-
-		auto it = m_impl->subMeshMap.find(identifier);
-		if (it == m_impl->subMeshMap.end())
-		{
-			NazaraError("SubMesh not found");
-			return;
-		}
-
-		unsigned int index = it->second;
-		#else
-		unsigned int index = m_impl->subMeshMap[identifier];
-		#endif
+		unsigned int index = GetSubMeshIndex(identifier);
 
 		// On déplace l'itérateur du début d'une distance de x
 		auto it2 = m_impl->subMeshes.begin();
 		std::advance(it2, index);
 		m_impl->subMeshes.erase(it2);
 
-		m_impl->aabbUpdated = false; // On invalide l'AABB
+		InvalidateAABB();
 	}
 
 	void Mesh::RemoveSubMesh(unsigned int index)
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return;
-		}
-
-		if (index >= m_impl->subMeshes.size())
-		{
-			NazaraError("SubMesh index out of range (" + String::Number(index) + " >= " + String::Number(m_impl->subMeshes.size()) + ')');
-			return;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
+		NazaraAssert(index < m_impl->subMeshes.size(), "Submesh index out of range");
 
 		// On déplace l'itérateur du début de x
 		auto it = m_impl->subMeshes.begin();
 		std::advance(it, index);
 		m_impl->subMeshes.erase(it);
 
-		m_impl->aabbUpdated = false; // On invalide l'AABB
+		InvalidateAABB();
 	}
 
 	void Mesh::SetAnimation(const String& animationPath)
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return;
-		}
-		#endif
+		NazaraAssert(m_impl, "Mesh should be created first");
 
 		m_impl->animationPath = animationPath;
 	}
 
-	void Mesh::SetMaterial(unsigned int matIndex, const String& materialPath)
+	void Mesh::SetMaterialData(unsigned int matIndex, ParameterList data)
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return;
-		}
+		NazaraAssert(m_impl, "Mesh should be created first");
+		NazaraAssert(matIndex < m_impl->materialData.size(), "Material index out of range");
 
-		if (matIndex >= m_impl->materials.size())
-		{
-			NazaraError("Material index out of range (" + String::Number(matIndex) + " >= " + String::Number(m_impl->materials.size()) + ')');
-			return;
-		}
-		#endif
-
-		m_impl->materials[matIndex] = materialPath;
+		m_impl->materialData[matIndex] = std::move(data);
 	}
 
 	void Mesh::SetMaterialCount(unsigned int matCount)
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return;
-		}
+		NazaraAssert(m_impl, "Mesh should be created first");
+		NazaraAssert(matCount > 0, "A mesh should have at least a material");
 
-		if (matCount == 0)
-		{
-			NazaraError("A mesh should have at least a material");
-			return;
-		}
-		#endif
-
-		m_impl->materials.resize(matCount);
+		m_impl->materialData.resize(matCount);
 
 		#ifdef NAZARA_DEBUG
 		for (SubMesh* subMesh : m_impl->subMeshes)
@@ -953,7 +634,7 @@ namespace Nz
 			unsigned int matIndex = subMesh->GetMaterialIndex();
 			if (matIndex >= matCount)
 			{
-				subMesh->SetMaterialIndex(0); // Pour empêcher un crash
+				subMesh->SetMaterialIndex(0); // To prevent a crash
 				NazaraWarning("SubMesh " + String::Pointer(subMesh) + " material index is over mesh new material count (" + String::Number(matIndex) + " >= " + String::Number(matCount) + "), setting it to first material");
 			}
 		}
@@ -962,22 +643,8 @@ namespace Nz
 
 	void Mesh::Transform(const Matrix4f& matrix)
 	{
-		#if NAZARA_UTILITY_SAFE
-		if (!m_impl)
-		{
-			NazaraError("Mesh not created");
-			return;
-		}
-
-		if (m_impl->animationType != AnimationType_Static)
-		{
-			NazaraError("Mesh must be static");
-			return;
-		}
-		#endif
-
-		if (matrix.IsIdentity())
-			return;
+		NazaraAssert(m_impl, "Mesh should be created first");
+		NazaraAssert(m_impl->animationType == AnimationType_Static, "Mesh is not static");
 
 		for (SubMesh* subMesh : m_impl->subMeshes)
 		{
@@ -1000,8 +667,7 @@ namespace Nz
 			staticMesh->SetAABB(aabb);
 		}
 
-		// Il ne faut pas oublier d'invalider notre AABB
-		m_impl->aabbUpdated = false;
+		InvalidateAABB();
 	}
 
 	bool Mesh::Initialize()

src/Nazara/Utility/SimpleTextDrawer.cpp

@@ -49,7 +49,7 @@ namespace Nz
 		ClearGlyphs();
 	}
 
-	const Rectui& SimpleTextDrawer::GetBounds() const
+	const Recti& SimpleTextDrawer::GetBounds() const
 	{
 		if (!m_glyphUpdated)
 			UpdateGlyphs();

src/Nazara/Utility/SubMesh.cpp

@@ -209,5 +209,5 @@ namespace Nz
 	void SubMesh::SetMaterialIndex(unsigned int matIndex)
 	{
 		m_matIndex = matIndex;
-}
+	}
 }

src/Nazara/Utility/Utility.cpp

@@ -25,6 +25,7 @@
 #include <Nazara/Utility/Formats/MD2Loader.hpp>
 #include <Nazara/Utility/Formats/MD5AnimLoader.hpp>
 #include <Nazara/Utility/Formats/MD5MeshLoader.hpp>
+#include <Nazara/Utility/Formats/OBJLoader.hpp>
 #include <Nazara/Utility/Formats/PCXLoader.hpp>
 #include <Nazara/Utility/Formats/STBLoader.hpp>
 #include <Nazara/Utility/Formats/STBSaver.hpp>
@@ -114,7 +115,7 @@ namespace Nz
 		Loaders::RegisterFreeType();
 
 		// Image
-		Loaders::RegisterDDSLoader(); // Generic loader (STB)
+		Loaders::RegisterDDSLoader(); // DDS Loader (DirectX format)
 		Loaders::RegisterSTBLoader(); // Generic loader (STB)
 		Loaders::RegisterSTBSaver();  // Generic saver (STB)
 
@@ -122,6 +123,9 @@ namespace Nz
 		// Animation
 		Loaders::RegisterMD5Anim(); // Loader de fichiers .md5anim (v10)
 
+		// Mesh (text)
+		Loaders::RegisterOBJ();
+
 		// Mesh
 		Loaders::RegisterMD2(); // Loader de fichiers .md2 (v8)
 		Loaders::RegisterMD5Mesh(); // Loader de fichiers .md5mesh (v10)
@@ -158,6 +162,7 @@ namespace Nz
 		Loaders::UnregisterMD2();
 		Loaders::UnregisterMD5Anim();
 		Loaders::UnregisterMD5Mesh();
+		Loaders::UnregisterOBJ();
 		Loaders::UnregisterPCX();
 		Loaders::UnregisterSTBLoader();
 		Loaders::UnregisterSTBSaver();