sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' into vulkan 

Former-commit-id: 9f8a7fd431d09c2c656f0692c897a0a41a04f26e [formerly e007bba02b960164ab806d72f052044ccb7dec1c]
Former-commit-id: b881a70547ff9cc63d3dbd2123d9de7951ae59a3
This commit is contained in:
Lynix 2016-07-07 14:12:22 +02:00
parent bf47347609 068465b6b9
commit cdd96dd4aa
25 changed files with 860 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
SDK/include/NDK/Components/GraphicsComponent.hpp
View File

@ -31,6 +31,10 @@ namespace Ndk
inline void Attach(Nz::InstancedRenderableRef renderable, int renderOrder = 0);
inline void Clear();
inline void Detach(const Nz::InstancedRenderableRef& renderable);
inline void EnsureBoundingVolumeUpdate() const;
inline void EnsureTransformMatrixUpdate() const;
@ -63,6 +67,22 @@ namespace Ndk
{
}
Renderable(Renderable&& renderable) noexcept :
data(std::move(renderable.data)),
renderable(std::move(renderable.renderable)),
dataUpdated(renderable.dataUpdated)
{
}
Renderable& operator=(Renderable&& r) noexcept
{
data = std::move(r.data);
dataUpdated = r.dataUpdated;
renderable = std::move(r.renderable);
return *this;
}
NazaraSlot(Nz::InstancedRenderable, OnInstancedRenderableInvalidateData, renderableInvalidationSlot);
mutable Nz::InstancedRenderable::InstanceData data;

21
SDK/include/NDK/Components/GraphicsComponent.inl
View File

@ -3,6 +3,7 @@
// For conditions of distribution and use, see copyright notice in Prerequesites.hpp
#include <algorithm>
#include "GraphicsComponent.hpp"
namespace Ndk
{
@ -46,6 +47,26 @@ namespace Ndk
InvalidateBoundingVolume();
}
inline void GraphicsComponent::Clear()
{
m_renderables.clear();
InvalidateBoundingVolume();
}
inline void GraphicsComponent::Detach(const Nz::InstancedRenderableRef& renderable)
{
for (auto it = m_renderables.begin(); it != m_renderables.end(); ++it)
{
if (it->renderable == renderable)
{
InvalidateBoundingVolume();
m_renderables.erase(it);
break;
}
}
}
inline void GraphicsComponent::EnsureBoundingVolumeUpdate() const
{
if (!m_boundingVolumeUpdated)

25
include/Nazara/Core/ObjectRef.hpp
View File

@ -44,6 +44,31 @@ namespace Nz
T* m_object;
};
template<typename T> bool operator==(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs);
template<typename T> bool operator==(const T& lhs, const ObjectRef<T>& rhs);
template<typename T> bool operator==(const ObjectRef<T>& lhs, const T& rhs);
template<typename T> bool operator!=(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs);
template<typename T> bool operator!=(const T& lhs, const ObjectRef<T>& rhs);
template<typename T> bool operator!=(const ObjectRef<T>& lhs, const T& rhs);
template<typename T> bool operator<(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs);
template<typename T> bool operator<(const T& lhs, const ObjectRef<T>& rhs);
template<typename T> bool operator<(const ObjectRef<T>& lhs, const T& rhs);
template<typename T> bool operator<=(const ObjectRef<T>, const ObjectRef<T>& rhs);
template<typename T> bool operator<=(const T& lhs, const ObjectRef<T>& rhs);
template<typename T> bool operator<=(const ObjectRef<T>& lhs, const T& rhs);
template<typename T> bool operator>(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs);
template<typename T> bool operator>(const T& lhs, const ObjectRef<T>& rhs);
template<typename T> bool operator>(const ObjectRef<T>& lhs, const T& rhs);
template<typename T> bool operator>=(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs);
template<typename T> bool operator>=(const T& lhs, const ObjectRef<T>& rhs);
template<typename T> bool operator>=(const ObjectRef<T>& lhs, const T& rhs);
template<typename T> struct PointedType<ObjectRef<T>> { typedef T type; };
template<typename T> struct PointedType<ObjectRef<T> const> { typedef T type; };
}

235
include/Nazara/Core/ObjectRef.inl
View File

@ -245,6 +245,241 @@ namespace Nz
return *this;
}
/*!
* \brief Checks whether the first object handle is equal to the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
*/
template<typename T>
bool operator==(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
{
return lhs.Get() == rhs.Get();
}
/*!
* \brief Checks whether the object is equal to the second object handle
* \return true if it is the case
*
* \param first Object to compare in left hand side
* \param second ObjectRef to compare in right hand side
*/
template<typename T>
bool operator==(const T& lhs, const ObjectRef<T>& rhs)
{
return &lhs == rhs.Get();
}
/*!
* \brief Checks whether the object handle is equal to the second object
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second Object to compare in right hand side
*/
template<typename T>
bool operator==(const ObjectRef<T>& lhs, const T& rhs)
{
return lhs.Get() == &rhs;
}
/*!
* \brief Checks whether the first object handle is equal to the second object handle
* \return false if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
*/
template<typename T>
bool operator!=(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
{
return !(lhs == rhs);
}
/*!
* \brief Checks whether the object is equal to the second object handle
* \return false if it is the case
*
* \param first Object to compare in left hand side
* \param second ObjectRef to compare in right hand side
*/
template<typename T>
bool operator!=(const T& lhs, const ObjectRef<T>& rhs)
{
return !(lhs == rhs);
}
/*!
* \brief Checks whether the object handle is equal to the second object
* \return false if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second Object to compare in right hand side
*/
template<typename T>
bool operator!=(const ObjectRef<T>& lhs, const T& rhs)
{
return !(lhs == rhs);
}
/*!
* \brief Checks whether the first object handle is less than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
{
return lhs.m_object < rhs.m_object;
}
/*!
* \brief Checks whether the first object handle is less than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<(const T& lhs, const ObjectRef<T>& rhs)
{
return &lhs < rhs.m_object;
}
/*!
* \brief Checks whether the first object handle is less than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<(const ObjectRef<T>& lhs, const T& rhs)
{
return lhs.m_object < &rhs;
}
/*!
* \brief Checks whether the first object handle is less or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<=(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
{
return !(lhs > rhs);
}
/*!
* \brief Checks whether the first object handle is less or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<=(const T& lhs, const ObjectRef<T>& rhs)
{
return !(lhs > rhs);
}
/*!
* \brief Checks whether the first object handle is less or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<=(const ObjectRef<T>& lhs, const T& rhs)
{
return !(lhs > rhs);
}
/*!
* \brief Checks whether the first object handle is greather than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
{
return rhs < lhs;
}
/*!
* \brief Checks whether the first object handle is greather than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>(const T& lhs, const ObjectRef<T>& rhs)
{
return rhs < lhs;
}
/*!
* \brief Checks whether the first object handle is greather than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>(const ObjectRef<T>& lhs, const T& rhs)
{
return rhs < lhs;
}
/*!
* \brief Checks whether the first object handle is greather or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>=(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
{
return !(lhs < rhs);
}
/*!
* \brief Checks whether the first object handle is greather or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>=(const T& lhs, const ObjectRef<T>& rhs)
{
return !(lhs < rhs);
}
/*!
* \brief Checks whether the first object handle is greather or equal than the second object handle
* \return true if it is the case
*
* \param first ObjectRef to compare in left hand side
* \param second ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>=(const ObjectRef<T>& lhs, const T& rhs)
{
return !(lhs < rhs);
}
}
namespace std

4
include/Nazara/Core/StringStream.hpp
View File

@ -22,6 +22,10 @@ namespace Nz
StringStream(const StringStream&) = default;
StringStream(StringStream&&) noexcept = default;
void Clear();
std::size_t GetBufferSize() const;
String ToString() const;
StringStream& operator=(const StringStream&) = default;

17
include/Nazara/Graphics/InstancedRenderable.hpp
View File

@ -55,14 +55,27 @@ namespace Nz
struct InstanceData
{
InstanceData(Matrix4f& referenceMatrix) :
transformMatrix(referenceMatrix),
transformMatrix(&referenceMatrix),
flags(0)
{
}
InstanceData(InstanceData&& instanceData) noexcept = default;
InstanceData& operator=(InstanceData&& instanceData) noexcept
{
data = std::move(instanceData.data);
flags = instanceData.flags;
renderOrder = instanceData.renderOrder;
transformMatrix = instanceData.transformMatrix;
volume = instanceData.volume;
return *this;
}
std::vector<UInt8> data;
BoundingVolumef volume;
Matrix4f& transformMatrix;
Matrix4f* transformMatrix;
UInt32 flags;
int renderOrder;
};

2
include/Nazara/Graphics/Material.hpp
View File

@ -120,6 +120,8 @@ namespace Nz
void Reset();
void SaveToParameters(ParameterList* matData);
inline bool SetAlphaMap(const String& textureName);
inline void SetAlphaMap(TextureRef alphaMap);
inline void SetAlphaThreshold(float alphaThreshold);

2
include/Nazara/Math/Vector4.hpp
View File

@ -28,7 +28,7 @@ namespace Nz
explicit Vector4(T scale);
Vector4(const T vec[4]);
Vector4(const Vector2<T>& vec, T Z = 0.0, T W = 1.0);
Vector4(const Vector3<T>& vec, T W = 0.0);
Vector4(const Vector3<T>& vec, T W = 1.0);
template<typename U> explicit Vector4(const Vector4<U>& vec);
Vector4(const Vector4& vec) = default;
~Vector4() = default;

3
include/Nazara/Renderer/RenderWindow.hpp
View File

@ -65,12 +65,11 @@ namespace Nz
protected:
bool Activate() const override;
void EnsureTargetUpdated() const override;
private:
bool OnWindowCreated() override;
void OnWindowDestroy() override;
void OnWindowResized() override;
private:
mutable std::vector<UInt8> m_buffer;
Clock m_clock;
ContextParameters m_parameters;

52
include/Nazara/Utility/Formats/OBJParser.hpp
View File

@ -29,51 +29,61 @@ namespace Nz
struct Face
{
std::vector<FaceVertex> vertices;
std::size_t firstVertex;
std::size_t vertexCount;
};
struct Mesh
{
std::vector<Face> faces;
std::vector<FaceVertex> vertices;
String name;
unsigned int material;
std::size_t material;
};
OBJParser(Stream& stream$);
~OBJParser();
OBJParser() = default;
~OBJParser() = default;
const String* GetMaterials() const;
unsigned int GetMaterialCount() const;
const Mesh* GetMeshes() const;
unsigned int GetMeshCount() const;
const String& GetMtlLib() const;
const Vector3f* GetNormals() const;
unsigned int GetNormalCount() const;
const Vector4f* GetPositions() const;
unsigned int GetPositionCount() const;
const Vector3f* GetTexCoords() const;
unsigned int GetTexCoordCount() const;
inline const String* GetMaterials() const;
inline unsigned int GetMaterialCount() const;
inline const Mesh* GetMeshes() const;
inline unsigned int GetMeshCount() const;
inline const String& GetMtlLib() const;
inline const Vector3f* GetNormals() const;
inline unsigned int GetNormalCount() const;
inline const Vector4f* GetPositions() const;
inline unsigned int GetPositionCount() const;
inline const Vector3f* GetTexCoords() const;
inline unsigned int GetTexCoordCount() const;
bool Parse(std::size_t reservedVertexCount = 100);
bool Parse(Stream& stream, std::size_t reservedVertexCount = 100);
bool Save(Stream& stream) const;
private:
bool Advance(bool required = true);
void Error(const String& message);
void Warning(const String& message);
void UnrecognizedLine(bool error = false);
template<typename T> void Emit(const T& text) const;
inline void EmitLine() const;
template<typename T> void EmitLine(const T& line) const;
inline void Error(const String& message);
inline void Flush() const;
inline void Warning(const String& message);
inline void UnrecognizedLine(bool error = false);
std::vector<Mesh> m_meshes;
std::vector<String> m_materials;
std::vector<Vector3f> m_normals;
std::vector<Vector4f> m_positions;
std::vector<Vector3f> m_texCoords;
Stream& m_stream;
mutable Stream* m_currentStream;
String m_currentLine;
String m_mtlLib;
mutable StringStream m_outputStream;
bool m_keepLastLine;
unsigned int m_lineCount;
unsigned int m_streamFlags;
};
}
#include <Nazara/Utility/Formats/OBJParser.inl>
#endif // NAZARA_FORMATS_OBJPARSER_HPP

113
include/Nazara/Utility/Formats/OBJParser.inl Normal file
View File

@ -0,0 +1,113 @@
// 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/Utility/Formats/OBJParser.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Utility/Debug.hpp>
namespace Nz
{
inline const String* OBJParser::GetMaterials() const
{
return m_materials.data();
}
inline unsigned int OBJParser::GetMaterialCount() const
{
return m_materials.size();
}
inline const OBJParser::Mesh* OBJParser::GetMeshes() const
{
return m_meshes.data();
}
inline unsigned int OBJParser::GetMeshCount() const
{
return m_meshes.size();
}
inline const String& OBJParser::GetMtlLib() const
{
return m_mtlLib;
}
inline const Vector3f* OBJParser::GetNormals() const
{
return m_normals.data();
}
inline unsigned int OBJParser::GetNormalCount() const
{
return m_normals.size();
}
inline const Vector4f* OBJParser::GetPositions() const
{
return m_positions.data();
}
inline unsigned int OBJParser::GetPositionCount() const
{
return m_positions.size();
}
inline const Vector3f* OBJParser::GetTexCoords() const
{
return m_texCoords.data();
}
inline unsigned int OBJParser::GetTexCoordCount() const
{
return m_texCoords.size();
}
template<typename T>
void OBJParser::Emit(const T& text) const
{
m_outputStream << text;
if (m_outputStream.GetBufferSize() > 1024 * 1024)
Flush();
}
inline void OBJParser::EmitLine() const
{
Emit('\n');
}
template<typename T>
void OBJParser::EmitLine(const T& line) const
{
Emit(line);
Emit('\n');
}
inline void OBJParser::Error(const String& message)
{
NazaraError(message + " at line #" + String::Number(m_lineCount));
}
inline void OBJParser::Flush() const
{
m_currentStream->Write(m_outputStream);
m_outputStream.Clear();
}
inline void OBJParser::Warning(const String& message)
{
NazaraWarning(message + " at line #" + String::Number(m_lineCount));
}
inline void OBJParser::UnrecognizedLine(bool error)
{
String message = "Unrecognized \"" + m_currentLine + '"';
if (error)
Error(message);
else
Warning(message);
}
}
#include <Nazara/Utility/DebugOff.hpp>

1
include/Nazara/Utility/MaterialData.hpp
View File

@ -22,6 +22,7 @@ namespace Nz
static constexpr const char* BackFaceStencilReference = "MatBackFaceStencilReference";
static constexpr const char* BackFaceStencilZFail = "MatBackFaceStencilZFail";
static constexpr const char* Blending = "MatBlending";
static constexpr const char* CullingSide = "MatCullingSide";
static constexpr const char* CustomDefined = "MatCustomDefined";
static constexpr const char* ColorWrite = "MatColorWrite";
static constexpr const char* DepthBuffer = "MatDepthBuffer";

11
src/Nazara/Core/PluginManager.cpp
View File

@ -19,8 +19,7 @@ namespace Nz
String s_pluginFiles[] =
{
"NazaraAssimp", // Plugin_Assimp
"NazaraFreetype" // Plugin_FreeType
"PluginAssimp", // Plugin_Assimp
};
}
@ -80,7 +79,13 @@ namespace Nz
bool PluginManager::Mount(Plugin plugin)
{
return Mount(s_pluginFiles[plugin]);
Nz::String pluginName = s_pluginFiles[plugin];
#ifdef NAZARA_DEBUG
if (Mount(pluginName + "-d", true))
return true;
#endif
return Mount(pluginName, true);
}
/*!

2
src/Nazara/Core/String.cpp
View File

@ -211,7 +211,7 @@ namespace Nz
*/
String::String(const std::string& string) :
String(string.c_str(), string.size())
String(string.data(), string.size())
{
}

41
src/Nazara/Core/StringStream.cpp
View File

@ -1,3 +1,4 @@
#include "..\..\..\include\Nazara\Core\StringStream.hpp"
// 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
@ -16,7 +17,6 @@ namespace Nz
/*!
* \brief Constructs a StringStream object by default
*/
StringStream::StringStream() :
m_bufferSize(0)
{
@ -27,18 +27,34 @@ namespace Nz
*
* \param str First value of the stream
*/
StringStream::StringStream(const String& str) :
m_bufferSize(str.GetSize())
{
m_strings.push_back(str);
}
/*!
* \brief Resets the state of the stream, erasing every contained text
*/
void StringStream::Clear()
{
m_bufferSize = 0;
m_strings.clear();
}
/*!
* \brief Get the current buffer size
* \return The internal accumulation buffer size, this is equivalent to the size of the final string
*/
std::size_t StringStream::GetBufferSize() const
{
return m_bufferSize;
}
/*!
* \brief Gives a string representation
* \return A string representation of the object where every objects of the stream has been converted with Nz::String
*/
String StringStream::ToString() const
{
String string;
@ -56,7 +72,6 @@ namespace Nz
*
* \param boolean Boolean value
*/
StringStream& StringStream::operator<<(bool boolean)
{
m_strings.push_back(String::Boolean(boolean));
@ -71,7 +86,6 @@ namespace Nz
*
* \param number Short value
*/
StringStream& StringStream::operator<<(short number)
{
m_strings.push_back(String::Number(number));
@ -86,7 +100,6 @@ namespace Nz
*
* \param number Short value
*/
StringStream& StringStream::operator<<(unsigned short number)
{
m_strings.push_back(String::Number(number));
@ -101,7 +114,6 @@ namespace Nz
*
* \param number Int value
*/
StringStream& StringStream::operator<<(int number)
{
m_strings.push_back(String::Number(number));
@ -116,7 +128,6 @@ namespace Nz
*
* \param number Int value
*/
StringStream& StringStream::operator<<(unsigned int number)
{
m_strings.push_back(String::Number(number));
@ -131,7 +142,6 @@ namespace Nz
*
* \param number Long value
*/
StringStream& StringStream::operator<<(long number)
{
m_strings.push_back(String::Number(number));
@ -146,7 +156,6 @@ namespace Nz
*
* \param number Long value
*/
StringStream& StringStream::operator<<(unsigned long number)
{
m_strings.push_back(String::Number(number));
@ -161,7 +170,6 @@ namespace Nz
*
* \param number Long long value
*/
StringStream& StringStream::operator<<(long long number)
{
m_strings.push_back(String::Number(number));
@ -176,7 +184,6 @@ namespace Nz
*
* \param number Long long value
*/
StringStream& StringStream::operator<<(unsigned long long number)
{
m_strings.push_back(String::Number(number));
@ -191,7 +198,6 @@ namespace Nz
*
* \param number Float value
*/
StringStream& StringStream::operator<<(float number)
{
m_strings.push_back(String::Number(number));
@ -206,7 +212,6 @@ namespace Nz
*
* \param number Double value
*/
StringStream& StringStream::operator<<(double number)
{
m_strings.push_back(String::Number(number));
@ -221,7 +226,6 @@ namespace Nz
*
* \param number Long double value
*/
StringStream& StringStream::operator<<(long double number)
{
m_strings.push_back(String::Number(number));
@ -236,7 +240,6 @@ namespace Nz
*
* \param character Char value
*/
StringStream& StringStream::operator<<(char character)
{
m_strings.push_back(String(character));
@ -251,7 +254,6 @@ namespace Nz
*
* \param character Char value
*/
StringStream& StringStream::operator<<(unsigned char character)
{
m_strings.push_back(String(static_cast<char>(character)));
@ -266,7 +268,6 @@ namespace Nz
*
* \param string String value
*/
StringStream& StringStream::operator<<(const char* string)
{
m_strings.push_back(string);
@ -281,7 +282,6 @@ namespace Nz
*
* \param string String value
*/
StringStream& StringStream::operator<<(const std::string& string)
{
m_strings.push_back(string);
@ -296,7 +296,6 @@ namespace Nz
*
* \param string String value
*/
StringStream& StringStream::operator<<(const String& string)
{
m_strings.push_back(string);
@ -311,7 +310,6 @@ namespace Nz
*
* \param ptr Pointer value
*/
StringStream& StringStream::operator<<(const void* ptr)
{
m_strings.push_back(String::Pointer(ptr));
@ -324,7 +322,6 @@ namespace Nz
* \brief Converts this to Nz::String
* \return The string representation of the stream
*/
StringStream::operator String() const
{
return ToString();

2
src/Nazara/Graphics/Billboard.cpp
View File

@ -30,7 +30,7 @@ namespace Nz
if (!m_material)
return;
renderQueue->AddBillboard(instanceData.renderOrder, m_material, instanceData.transformMatrix.GetTranslation(), m_size, m_sinCos, m_color);
renderQueue->AddBillboard(instanceData.renderOrder, m_material, instanceData.transformMatrix->GetTranslation(), m_size, m_sinCos, m_color);
}
/*

2
src/Nazara/Graphics/InstancedRenderable.cpp
View File

@ -80,7 +80,7 @@ namespace Nz
NazaraAssert(instanceData, "Invalid instance data");
NazaraUnused(instanceData);
instanceData->volume.Update(instanceData->transformMatrix);
instanceData->volume.Update(*instanceData->transformMatrix);
}
/*!

106
src/Nazara/Graphics/Material.cpp
View File

@ -170,6 +170,9 @@ namespace Nz
if (matData.GetColorParameter(MaterialData::AmbientColor, &color))
SetAmbientColor(color);
if (matData.GetIntegerParameter(MaterialData::CullingSide, &iValue))
SetFaceCulling(static_cast<FaceSide>(iValue));
if (matData.GetIntegerParameter(MaterialData::DepthFunc, &iValue))
SetDepthFunc(static_cast<RendererComparison>(iValue));
@ -182,9 +185,6 @@ namespace Nz
if (matData.GetIntegerParameter(MaterialData::DstBlend, &iValue))
SetDstBlend(static_cast<BlendFunc>(iValue));
if (matData.GetIntegerParameter(MaterialData::FaceCulling, &iValue))
SetFaceCulling(static_cast<FaceSide>(iValue));
if (matData.GetIntegerParameter(MaterialData::FaceFilling, &iValue))
SetFaceFilling(static_cast<FaceFilling>(iValue));
@ -310,10 +310,108 @@ namespace Nz
SetShader(matParams.shaderName);
}
void Material::SaveToParameters(ParameterList* matData)
{
NazaraAssert(matData, "Invalid ParameterList");
matData->SetParameter(MaterialData::AlphaTest, IsAlphaTestEnabled());
matData->SetParameter(MaterialData::AlphaThreshold, GetAlphaThreshold());
matData->SetParameter(MaterialData::AmbientColor, GetAmbientColor());
matData->SetParameter(MaterialData::CullingSide, int(GetFaceCulling()));
matData->SetParameter(MaterialData::DepthFunc, int(GetDepthFunc()));
matData->SetParameter(MaterialData::DepthSorting, IsDepthSortingEnabled());
matData->SetParameter(MaterialData::DiffuseColor, GetDiffuseColor());
matData->SetParameter(MaterialData::DstBlend, int(GetDstBlend()));
matData->SetParameter(MaterialData::FaceFilling, int(GetFaceFilling()));
matData->SetParameter(MaterialData::Lighting, IsLightingEnabled());
matData->SetParameter(MaterialData::LineWidth, GetRenderStates().lineWidth);
matData->SetParameter(MaterialData::PointSize, GetRenderStates().pointSize);
matData->SetParameter(MaterialData::Shininess, GetShininess());
matData->SetParameter(MaterialData::SpecularColor, GetSpecularColor());
matData->SetParameter(MaterialData::SrcBlend, int(GetSrcBlend()));
matData->SetParameter(MaterialData::Transform, IsTransformEnabled());
// RendererParameter
matData->SetParameter(MaterialData::Blending, GetRenderStates().parameters[RendererParameter_Blend]);
matData->SetParameter(MaterialData::ColorWrite, GetRenderStates().parameters[RendererParameter_ColorWrite]);
matData->SetParameter(MaterialData::DepthBuffer, GetRenderStates().parameters[RendererParameter_DepthBuffer]);
matData->SetParameter(MaterialData::DepthWrite, GetRenderStates().parameters[RendererParameter_DepthWrite]);
matData->SetParameter(MaterialData::FaceCulling, GetRenderStates().parameters[RendererParameter_FaceCulling]);
matData->SetParameter(MaterialData::ScissorTest, GetRenderStates().parameters[RendererParameter_ScissorTest]);
matData->SetParameter(MaterialData::StencilTest, GetRenderStates().parameters[RendererParameter_StencilTest]);
// Samplers
matData->SetParameter(MaterialData::DiffuseAnisotropyLevel, int(GetDiffuseSampler().GetAnisotropicLevel()));
matData->SetParameter(MaterialData::DiffuseFilter, int(GetDiffuseSampler().GetFilterMode()));
matData->SetParameter(MaterialData::DiffuseWrap, int(GetDiffuseSampler().GetWrapMode()));
matData->SetParameter(MaterialData::SpecularAnisotropyLevel, int(GetSpecularSampler().GetAnisotropicLevel()));
matData->SetParameter(MaterialData::SpecularFilter, int(GetSpecularSampler().GetFilterMode()));
matData->SetParameter(MaterialData::SpecularWrap, int(GetSpecularSampler().GetWrapMode()));
// Stencil
matData->SetParameter(MaterialData::StencilCompare, int(GetRenderStates().frontFace.stencilCompare));
matData->SetParameter(MaterialData::StencilFail, int(GetRenderStates().frontFace.stencilFail));
matData->SetParameter(MaterialData::StencilPass, int(GetRenderStates().frontFace.stencilPass));
matData->SetParameter(MaterialData::StencilZFail, int(GetRenderStates().frontFace.stencilZFail));
matData->SetParameter(MaterialData::StencilMask, int(GetRenderStates().frontFace.stencilMask));
matData->SetParameter(MaterialData::StencilReference, int(GetRenderStates().frontFace.stencilReference));
// Stencil (back)
matData->SetParameter(MaterialData::BackFaceStencilCompare, int(GetRenderStates().backFace.stencilCompare));
matData->SetParameter(MaterialData::BackFaceStencilFail, int(GetRenderStates().backFace.stencilFail));
matData->SetParameter(MaterialData::BackFaceStencilPass, int(GetRenderStates().backFace.stencilPass));
matData->SetParameter(MaterialData::BackFaceStencilZFail, int(GetRenderStates().backFace.stencilZFail));
matData->SetParameter(MaterialData::BackFaceStencilMask, int(GetRenderStates().backFace.stencilMask));
matData->SetParameter(MaterialData::BackFaceStencilReference, int(GetRenderStates().backFace.stencilReference));
// Textures
if (HasAlphaMap())
{
const String& path = GetAlphaMap()->GetFilePath();
if (!path.IsEmpty())
matData->SetParameter(MaterialData::AlphaTexturePath, path);
}
if (HasDiffuseMap())
{
const String& path = GetDiffuseMap()->GetFilePath();
if (!path.IsEmpty())
matData->SetParameter(MaterialData::DiffuseTexturePath, path);
}
if (HasEmissiveMap())
{
const String& path = GetEmissiveMap()->GetFilePath();
if (!path.IsEmpty())
matData->SetParameter(MaterialData::EmissiveTexturePath, path);
}
if (HasHeightMap())
{
const String& path = GetHeightMap()->GetFilePath();
if (!path.IsEmpty())
matData->SetParameter(MaterialData::HeightTexturePath, path);
}
if (HasNormalMap())
{
const String& path = GetNormalMap()->GetFilePath();
if (!path.IsEmpty())
matData->SetParameter(MaterialData::NormalTexturePath, path);
}
if (HasSpecularMap())
{
const String& path = GetSpecularMap()->GetFilePath();
if (!path.IsEmpty())
matData->SetParameter(MaterialData::SpecularTexturePath, path);
}
}
/*!
* \brief Resets the material, cleans everything
*/
void Material::Reset()
{
OnMaterialReset(this);

2
src/Nazara/Graphics/Model.cpp
View File

@ -82,7 +82,7 @@ namespace Nz
meshData.primitiveMode = mesh->GetPrimitiveMode();
meshData.vertexBuffer = mesh->GetVertexBuffer();
renderQueue->AddMesh(instanceData.renderOrder, material, meshData, mesh->GetAABB(), instanceData.transformMatrix);
renderQueue->AddMesh(instanceData.renderOrder, material, meshData, mesh->GetAABB(), *instanceData.transformMatrix);
}
}

2
src/Nazara/Graphics/SkeletalModel.cpp
View File

@ -69,7 +69,7 @@ namespace Nz
meshData.primitiveMode = mesh->GetPrimitiveMode();
meshData.vertexBuffer = SkinningManager::GetBuffer(mesh, &m_skeleton);
renderQueue->AddMesh(instanceData.renderOrder, material, meshData, m_skeleton.GetAABB(), instanceData.transformMatrix);
renderQueue->AddMesh(instanceData.renderOrder, material, meshData, m_skeleton.GetAABB(), *instanceData.transformMatrix);
}
}

8
src/Nazara/Graphics/Sprite.cpp
View File

@ -58,19 +58,19 @@ namespace Nz
SparsePtr<Vector2f> texCoordPtr(&vertices[0].uv, sizeof(VertexStruct_XYZ_Color_UV));
*colorPtr++ = m_color;
*posPtr++ = instanceData->transformMatrix.Transform(Vector3f(0.f));
*posPtr++ = instanceData->transformMatrix->Transform(Vector3f(0.f));
*texCoordPtr++ = m_textureCoords.GetCorner(RectCorner_LeftTop);
*colorPtr++ = m_color;
*posPtr++ = instanceData->transformMatrix.Transform(m_size.x*Vector3f::Right());
*posPtr++ = instanceData->transformMatrix->Transform(m_size.x*Vector3f::Right());
*texCoordPtr++ = m_textureCoords.GetCorner(RectCorner_RightTop);
*colorPtr++ = m_color;
*posPtr++ = instanceData->transformMatrix.Transform(m_size.y*Vector3f::Down());
*posPtr++ = instanceData->transformMatrix->Transform(m_size.y*Vector3f::Down());
*texCoordPtr++ = m_textureCoords.GetCorner(RectCorner_LeftBottom);
*colorPtr++ = m_color;
*posPtr++ = instanceData->transformMatrix.Transform(m_size.x*Vector3f::Right() + m_size.y*Vector3f::Down());
*posPtr++ = instanceData->transformMatrix->Transform(m_size.x*Vector3f::Right() + m_size.y*Vector3f::Down());
*texCoordPtr++ = m_textureCoords.GetCorner(RectCorner_RightBottom);
}

2
src/Nazara/Graphics/TextSprite.cpp
View File

@ -310,7 +310,7 @@ namespace Nz
Vector3f localPos = localVertex->position.x*Vector3f::Right() + localVertex->position.y*Vector3f::Down();
localPos *= m_scale;
*pos++ = instanceData->transformMatrix.Transform(localPos);
*pos++ = instanceData->transformMatrix->Transform(localPos);
*color++ = m_color * localVertex->color;
*uv++ = localVertex->uv;

3
src/Nazara/Renderer/Texture.cpp
View File

@ -582,6 +582,9 @@ namespace Nz
}
}
// Keep resource path info
SetFilePath(image.GetFilePath());
destroyOnExit.Reset();
return true;

20
src/Nazara/Utility/Formats/OBJLoader.cpp
View File

@ -123,8 +123,8 @@ namespace Nz
if (!parameters.custom.GetIntegerParameter("NativeOBJLoader_VertexCount", &reservedVertexCount))
reservedVertexCount = 100;
OBJParser parser(stream);
if (!parser.Parse(reservedVertexCount))
OBJParser parser;
if (!parser.Parse(stream, reservedVertexCount))
{
NazaraError("OBJ parser failed");
return false;
@ -184,16 +184,17 @@ namespace Nz
};
std::unordered_map<OBJParser::FaceVertex, unsigned int, FaceVertexHasher, FaceVertexComparator> vertices;
vertices.reserve(meshes[i].vertices.size());
unsigned int vertexCount = 0;
for (unsigned int j = 0; j < faceCount; ++j)
{
unsigned int faceVertexCount = meshes[i].faces[j].vertices.size();
unsigned int faceVertexCount = meshes[i].faces[j].vertexCount;
faceIndices.resize(faceVertexCount);
for (unsigned int k = 0; k < faceVertexCount; ++k)
{
const OBJParser::FaceVertex& vertex = meshes[i].faces[j].vertices[k];
const OBJParser::FaceVertex& vertex = meshes[i].vertices[meshes[i].faces[j].firstVertex + k];
auto it = vertices.find(vertex);
if (it == vertices.end())
@ -202,6 +203,7 @@ namespace Nz
faceIndices[k] = it->second;
}
// Triangulation
for (unsigned int k = 1; k < faceVertexCount-1; ++k)
{
indices.push_back(faceIndices[0]);
@ -233,17 +235,17 @@ namespace Nz
MeshVertex& vertex = meshVertices[index];
const Vector4f& vec = positions[vertexIndices.position];
const Vector4f& vec = positions[vertexIndices.position-1];
vertex.position = Vector3f(parameters.matrix * vec);
if (vertexIndices.normal >= 0)
vertex.normal = normals[vertexIndices.normal];
if (vertexIndices.normal > 0)
vertex.normal = normals[vertexIndices.normal-1];
else
hasNormals = false;
if (vertexIndices.texCoord >= 0)
if (vertexIndices.texCoord > 0)
{
const Vector3f& uvw = texCoords[vertexIndices.texCoord];
const Vector3f& uvw = texCoords[vertexIndices.texCoord-1];
vertex.uv.Set(uvw.x, (parameters.flipUVs) ? 1.f - uvw.y : uvw.y); // Inversion des UVs si demandé
}
else

395
src/Nazara/Utility/Formats/OBJParser.cpp
View File

@ -3,7 +3,7 @@
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Utility/Formats/OBJParser.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/CallOnExit.hpp>
#include <Nazara/Core/Log.hpp>
#include <Nazara/Utility/Config.hpp>
#include <cctype>
@ -13,77 +13,22 @@
namespace Nz
{
OBJParser::OBJParser(Stream& stream) :
m_stream(stream),
m_streamFlags(stream.GetStreamOptions()) //< Saves stream flags
bool OBJParser::Parse(Nz::Stream& stream, std::size_t reservedVertexCount)
{
m_stream.EnableTextMode(true);
m_currentStream = &stream;
// Force stream in text mode, reset it at the end
Nz::CallOnExit resetTextMode;
if ((stream.GetStreamOptions() & StreamOption_Text) == 0)
{
stream.EnableTextMode(true);
resetTextMode.Reset([&stream] ()
{
stream.EnableTextMode(false);
});
}
OBJParser::~OBJParser()
{
// Reset stream flags
if ((m_streamFlags & StreamOption_Text) == 0)
m_stream.EnableTextMode(false);
}
const String* OBJParser::GetMaterials() const
{
return m_materials.data();
}
unsigned int OBJParser::GetMaterialCount() const
{
return m_materials.size();
}
const OBJParser::Mesh* OBJParser::GetMeshes() const
{
return m_meshes.data();
}
unsigned int OBJParser::GetMeshCount() const
{
return m_meshes.size();
}
const String& OBJParser::GetMtlLib() const
{
return m_mtlLib;
}
const Vector3f* OBJParser::GetNormals() const
{
return m_normals.data();
}
unsigned int OBJParser::GetNormalCount() const
{
return m_normals.size();
}
const Vector4f* OBJParser::GetPositions() const
{
return m_positions.data();
}
unsigned int OBJParser::GetPositionCount() const
{
return m_positions.size();
}
const Vector3f* OBJParser::GetTexCoords() const
{
return m_texCoords.data();
}
unsigned int OBJParser::GetTexCoordCount() const
{
return m_texCoords.size();
}
bool OBJParser::Parse(std::size_t reservedVertexCount)
{
String matName, meshName;
matName = meshName = "default";
m_keepLastLine = false;
@ -100,32 +45,56 @@ namespace Nz
m_positions.reserve(reservedVertexCount);
m_texCoords.reserve(reservedVertexCount);
// On va regrouper les meshs par nom et par matériau
using FaceVec = std::vector<Face>;
using MatPair = std::pair<FaceVec, unsigned int>;
std::unordered_map<String, std::unordered_map<String, MatPair>> meshes;
// Sort meshes by material and group
using MatPair = std::pair<Mesh, unsigned int>;
std::unordered_map<String, std::unordered_map<String, MatPair>> meshesByName;
unsigned int matIndex = 0;
auto GetMaterial = [&meshes, &matIndex] (const String& mesh, const String& material) -> FaceVec*
std::size_t faceReserve = 0;
std::size_t vertexReserve = 0;
unsigned int matCount = 0;
auto GetMaterial = [&] (const String& meshName, const String& matName) -> Mesh*
{
auto& map = meshes[mesh];
auto it = map.find(material);
auto& map = meshesByName[meshName];
auto it = map.find(matName);
if (it == map.end())
it = map.insert(std::make_pair(material, MatPair(FaceVec(), matIndex++))).first;
it = map.insert(std::make_pair(matName, MatPair(Mesh(), matCount++))).first;
Mesh& mesh = it->second.first;
mesh.faces.reserve(faceReserve);
mesh.vertices.reserve(vertexReserve);
faceReserve = 0;
vertexReserve = 0;
return &(it->second.first);
};
// On prépare le mesh par défaut
FaceVec* currentMesh = nullptr;
Mesh* currentMesh = nullptr;
while (Advance(false))
{
switch (std::tolower(m_currentLine[0]))
{
case 'f': // Une face
case '#': //< Comment
// Some softwares write comments to gives the number of vertex/faces an importer can expect
std::size_t data;
if (std::sscanf(m_currentLine.GetConstBuffer(), "# position count: %zu", &data) == 1)
m_positions.reserve(data);
else if (std::sscanf(m_currentLine.GetConstBuffer(), "# normal count: %zu", &data) == 1)
m_normals.reserve(data);
else if (std::sscanf(m_currentLine.GetConstBuffer(), "# texcoords count: %zu", &data) == 1)
m_texCoords.reserve(data);
else if (std::sscanf(m_currentLine.GetConstBuffer(), "# face count: %zu", &data) == 1)
faceReserve = data;
else if (std::sscanf(m_currentLine.GetConstBuffer(), "# vertex count: %zu", &data) == 1)
vertexReserve = data;
break;
case 'f': //< Face
{
if (m_currentLine.GetSize() < 7) // Le minimum syndical pour définir une face de trois sommets (f 1 2 3)
if (m_currentLine.GetSize() < 7) // Since we only treat triangles, this is the minimum length of a face line (f 1 2 3)
{
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
UnrecognizedLine();
@ -142,17 +111,23 @@ namespace Nz
break;
}
if (!currentMesh)
currentMesh = GetMaterial(meshName, matName);
Face face;
face.vertices.resize(vertexCount);
face.firstVertex = currentMesh->vertices.size();
face.vertexCount = vertexCount;
currentMesh->vertices.resize(face.firstVertex + vertexCount, FaceVertex{0, 0, 0});
bool error = false;
unsigned int pos = 2;
for (unsigned int i = 0; i < vertexCount; ++i)
{
int offset;
int& n = face.vertices[i].normal;
int& p = face.vertices[i].position;
int& t = face.vertices[i].texCoord;
int& n = currentMesh->vertices[face.firstVertex + i].normal;
int& p = currentMesh->vertices[face.firstVertex + i].position;
int& t = currentMesh->vertices[face.firstVertex + i].texCoord;
if (std::sscanf(&m_currentLine[pos], "%d/%d/%d%n", &p, &t, &n, &offset) != 3)
{
@ -168,22 +143,13 @@ namespace Nz
error = true;
break;
}
else
{
n = 0;
t = 0;
}
}
else
n = 0;
}
else
t = 0;
}
if (p < 0)
{
p += m_positions.size();
p += m_positions.size() - 1;
if (p < 0)
{
Error("Vertex index out of range (" + String::Number(p) + " < 0");
@ -191,48 +157,42 @@ namespace Nz
break;
}
}
else
p--;
if (n < 0)
{
n += m_normals.size();
n += m_normals.size() - 1;
if (n < 0)
{
Error("Vertex index out of range (" + String::Number(n) + " < 0");
Error("Normal index out of range (" + String::Number(n) + " < 0");
error = true;
break;
}
}
else
n--;
if (t < 0)
{
t += m_texCoords.size();
t += m_texCoords.size() - 1;
if (t < 0)
{
Error("Vertex index out of range (" + String::Number(t) + " < 0");
Error("Texture coordinates index out of range (" + String::Number(t) + " < 0");
error = true;
break;
}
}
else
t--;
if (static_cast<unsigned int>(p) >= m_positions.size())
if (static_cast<std::size_t>(p) > m_positions.size())
{
Error("Vertex index out of range (" + String::Number(p) + " >= " + String::Number(m_positions.size()) + ')');
error = true;
break;
}
else if (n >= 0 && static_cast<unsigned int>(n) >= m_normals.size())
else if (n != 0 && static_cast<std::size_t>(n) > m_normals.size())
{
Error("Normal index out of range (" + String::Number(n) + " >= " + String::Number(m_normals.size()) + ')');
error = true;
break;
}
else if (t >= 0 && static_cast<unsigned int>(t) >= m_texCoords.size())
else if (t != 0 && static_cast<std::size_t>(t) > m_texCoords.size())
{
Error("TexCoord index out of range (" + String::Number(t) + " >= " + String::Number(m_texCoords.size()) + ')');
error = true;
@ -243,17 +203,14 @@ namespace Nz
}
if (!error)
{
if (!currentMesh)
currentMesh = GetMaterial(meshName, matName);
currentMesh->push_back(std::move(face));
}
currentMesh->faces.push_back(std::move(face));
else
currentMesh->vertices.resize(face.firstVertex); //< Remove vertices
break;
}
case 'm':
case 'm': //< MTLLib
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
if (m_currentLine.GetWord(0).ToLower() != "mtllib")
UnrecognizedLine();
@ -262,8 +219,8 @@ namespace Nz
m_mtlLib = m_currentLine.SubString(m_currentLine.GetWordPosition(1));
break;
case 'g':
case 'o':
case 'g': //< Group (inside a mesh)
case 'o': //< Object (defines a mesh)
{
if (m_currentLine.GetSize() <= 2 || m_currentLine[1] != ' ')
{
@ -283,12 +240,12 @@ namespace Nz
}
meshName = objectName;
currentMesh = GetMaterial(meshName, matName);
currentMesh = nullptr;
break;
}
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
case 's':
case 's': //< Smooth
if (m_currentLine.GetSize() <= 2 || m_currentLine[1] == ' ')
{
String param = m_currentLine.SubString(2);
@ -300,13 +257,14 @@ namespace Nz
break;
#endif
case 'u':
case 'u': //< Usemtl
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
if (m_currentLine.GetWord(0) != "usemtl")
UnrecognizedLine();
#endif
matName = m_currentLine.SubString(m_currentLine.GetWordPosition(1));
currentMesh = nullptr;
if (matName.IsEmpty())
{
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
@ -314,18 +272,16 @@ namespace Nz
#endif
break;
}
currentMesh = GetMaterial(meshName, matName);
break;
case 'v':
case 'v': //< Position/Normal/Texcoords
{
String word = m_currentLine.GetWord(0).ToLower();
if (word == 'v')
{
Vector4f vertex(Vector3f::Zero(), 1.f);
unsigned int paramCount = std::sscanf(&m_currentLine[2], "%f %f %f %f", &vertex.x, &vertex.y, &vertex.z, &vertex.w);
if (paramCount >= 3)
if (paramCount >= 1)
m_positions.push_back(vertex);
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
else
@ -371,26 +327,24 @@ namespace Nz
}
std::unordered_map<String, unsigned int> materials;
m_materials.resize(matIndex);
m_materials.resize(matCount);
for (auto& meshIt : meshes)
for (auto& meshPair : meshesByName)
{
for (auto& matIt : meshIt.second)
for (auto& matPair : meshPair.second)
{
auto& faceVec = matIt.second.first;
unsigned int index = matIt.second.second;
if (!faceVec.empty())
Mesh& mesh = matPair.second.first;
unsigned int index = matPair.second.second;
if (!mesh.faces.empty())
{
Mesh mesh;
mesh.faces = std::move(faceVec);
mesh.name = meshIt.first;
mesh.name = meshPair.first;
auto it = materials.find(matIt.first);
auto it = materials.find(matPair.first);
if (it == materials.end())
{
mesh.material = index;
materials[matIt.first] = index;
m_materials[index] = matIt.first;
materials[matPair.first] = index;
m_materials[index] = matPair.first;
}
else
mesh.material = it->second;
@ -409,13 +363,155 @@ namespace Nz
return true;
}
bool OBJParser::Save(Stream& stream) const
{
m_currentStream = &stream;
// Force stream in text mode, reset it at the end
Nz::CallOnExit resetTextMode;
if ((stream.GetStreamOptions() & StreamOption_Text) == 0)
{
stream.EnableTextMode(true);
resetTextMode.Reset([&stream] ()
{
stream.EnableTextMode(false);
});
}
m_outputStream.Clear();
EmitLine("# Exported by Nazara Engine");
if (!m_mtlLib.IsEmpty())
{
Emit("mtlib ");
EmitLine(m_mtlLib);
EmitLine();
}
Emit("# position count: ");
EmitLine(m_positions.size());
for (const Nz::Vector4f& position : m_positions)
{
Emit("v ");
Emit(position.x);
Emit(' ');
Emit(position.y);
if (!NumberEquals(position.z, 0.f) || !NumberEquals(position.w, 1.f))
{
Emit(' ');
Emit(position.z);
if (!NumberEquals(position.w, 1.f))
{
Emit(' ');
Emit(position.w);
}
}
EmitLine();
}
EmitLine();
Emit("# normal count: ");
EmitLine(m_normals.size());
for (const Nz::Vector3f& normal : m_normals)
{
Emit("vn ");
Emit(normal.x);
Emit(' ');
Emit(normal.y);
Emit(' ');
Emit(normal.y);
EmitLine();
}
EmitLine();
Emit("# texcoords count: ");
EmitLine(m_texCoords.size());
for (const Nz::Vector3f& uvw : m_texCoords)
{
Emit("vt ");
Emit(uvw.x);
Emit(' ');
Emit(uvw.y);
if (NumberEquals(uvw.z, 0.f))
{
Emit(' ');
Emit(uvw.z);
}
EmitLine();
}
EmitLine();
std::unordered_map<std::size_t /* mesh */, std::vector<std::size_t> /* meshes*/> meshesByMaterials;
std::size_t meshIndex = 0;
for (const Mesh& mesh : m_meshes)
meshesByMaterials[mesh.material].push_back(meshIndex++);
for (auto& pair : meshesByMaterials)
{
Emit("usemtl ");
EmitLine(m_materials[pair.first]);
Emit("# groups count: ");
EmitLine(pair.second.size());
EmitLine();
for (std::size_t meshIndex : pair.second)
{
const Mesh& mesh = m_meshes[meshIndex];
Emit("g ");
EmitLine(mesh.name);
EmitLine();
Emit("# face count: ");
EmitLine(mesh.faces.size());
Emit("# vertex count: ");
EmitLine(mesh.vertices.size());
for (const Face& face : mesh.faces)
{
Emit('f');
for (std::size_t i = 0; i < face.vertexCount; ++i)
{
Emit(' ');
const FaceVertex& faceVertex = mesh.vertices[face.firstVertex + i];
Emit(faceVertex.position);
if (faceVertex.texCoord != 0 || faceVertex.normal != 0)
{
Emit('/');
if (faceVertex.texCoord != 0)
Emit(faceVertex.texCoord);
if (faceVertex.normal != 0)
{
Emit('/');
Emit(faceVertex.normal);
}
}
}
EmitLine();
}
}
EmitLine();
}
Flush();
return true;
}
bool OBJParser::Advance(bool required)
{
if (!m_keepLastLine)
{
do
{
if (m_stream.EndOfStream())
if (m_currentStream->EndOfStream())
{
if (required)
Error("Incomplete OBJ file");
@ -425,9 +521,8 @@ namespace Nz
m_lineCount++;
m_currentLine = m_stream.ReadLine();
m_currentLine = m_currentLine.SubStringTo("#"); // On ignore les commentaires
m_currentLine.Simplify(); // Pour un traitement plus simple
m_currentLine = m_currentStream->ReadLine();
m_currentLine.Simplify(); // Simplify lines (convert multiple blanks into a single space and trims)
}
while (m_currentLine.IsEmpty());
}
@ -436,24 +531,4 @@ namespace Nz
return true;
}
void OBJParser::Error(const String& message)
{
NazaraError(message + " at line #" + String::Number(m_lineCount));
}
void OBJParser::Warning(const String& message)
{
NazaraWarning(message + " at line #" + String::Number(m_lineCount));
}
void OBJParser::UnrecognizedLine(bool error)
{
String message = "Unrecognized \"" + m_currentLine + '"';
if (error)
Error(message);
else
Warning(message);
}
}