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

Various fixes 

Former-commit-id: 26dfbdb3388c845a6e3039f816f19ffbb462d7b8 [formerly a6437e0b6e48dbd630440f8d2629b32e4756b48e]
Former-commit-id: 8a1855fc1d4d7c343b7e1fdcd3c6a31f3134a59a
This commit is contained in:
Gawaboumga 2016-07-28 19:22:41 +02:00
parent 84c26ee77d
commit 96dc8c001e
26 changed files with 141 additions and 126 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/Nazara/Core/Algorithm.inl
View File

@ -124,6 +124,7 @@ namespace Nz
template<typename T, std::size_t N>
constexpr std::size_t CountOf(T(&name)[N]) noexcept
{
NazaraUnused(name);
return N;
}

38
include/Nazara/Core/ByteArray.inl
View File

@ -23,10 +23,10 @@ namespace Nz
/*!
* \brief Constructs a ByteArray object with a raw memory and a size
*
* \param ptr Pointer to raw memory
* \param buffer Pointer to raw memory
* \param n Size that can be accessed
*
* \remark If preallocated space of ptr is less than the size, the behaviour is undefined
* \remark If preallocated space of buffer is less than the size, the behaviour is undefined
*/
inline ByteArray::ByteArray(const void* buffer, size_type n) :
@ -62,10 +62,10 @@ namespace Nz
/*!
* \brief Appends the content of raw memory
*
* \param ptr Constant pointer to raw memory
* \param buffer Constant pointer to raw memory
* \param n Size that can be read
*
* \remark If preallocated space of ptr is less than the size, the behaviour is undefined
* \remark If preallocated space of buffer is less than the size, the behaviour is undefined
*
* \see Insert
*/
@ -298,11 +298,11 @@ namespace Nz
}
/*!
* \brief Inserts n times the same value at the iterator position
* \brief Inserts n times the same byte at the iterator position
*
* \param pos Iterator to the position
* \param n Number of repetitions
* \param value Value to repeat
* \param byte Value to repeat
*/
inline ByteArray::iterator ByteArray::Insert(const_iterator pos, size_type n, value_type byte)
@ -359,10 +359,10 @@ namespace Nz
/*!
* \brief Prepends the content of raw memory
*
* \param ptr Constant pointer to raw memory
* \param buffer Constant pointer to raw memory
* \param n Size that can be read
*
* \remark If preallocated space of ptr is less than the size, the behaviour is undefined
* \remark If preallocated space of buffer is less than the size, the behaviour is undefined
*
* \see Insert
*/
@ -682,8 +682,7 @@ namespace Nz
* \brief Checks whether the first byte array is equal to the second byte array
* \return true if it is the case
*
* \param first ByteArray to compare in left hand side
* \param second ByteArray to compare in right hand side
* \param rhs ByteArray to compare with
*/
inline bool ByteArray::operator==(const ByteArray& rhs) const
@ -695,8 +694,7 @@ namespace Nz
* \brief Checks whether the first byte array is equal to the second byte array
* \return false if it is the case
*
* \param first ByteArray to compare in left hand side
* \param second ByteArray to compare in right hand side
* \param rhs ByteArray to compare with
*/
inline bool ByteArray::operator!=(const ByteArray& rhs) const
@ -708,8 +706,7 @@ namespace Nz
* \brief Checks whether the first byte array is less than the second byte array
* \return true if it is the case
*
* \param first ByteArray to compare in left hand side
* \param second ByteArray to compare in right hand side
* \param rhs ByteArray to compare with
*/
inline bool ByteArray::operator<(const ByteArray& rhs) const
@ -721,8 +718,7 @@ namespace Nz
* \brief Checks whether the first byte array is less or equal than the second byte array
* \return true if it is the case
*
* \param first ByteArray to compare in left hand side
* \param second ByteArray to compare in right hand side
* \param rhs ByteArray to compare with
*/
inline bool ByteArray::operator<=(const ByteArray& rhs) const
@ -731,11 +727,10 @@ namespace Nz
}
/*!
* \brief Checks whether the first byte array is greather than the second byte array
* \brief Checks whether the first byte array is greater than the second byte array
* \return true if it is the case
*
* \param first ByteArray to compare in left hand side
* \param second ByteArray to compare in right hand side
* \param rhs ByteArray to compare with
*/
inline bool ByteArray::operator>(const ByteArray& rhs) const
@ -744,11 +739,10 @@ namespace Nz
}
/*!
* \brief Checks whether the first byte array is greather or equal than the second byte array
* \brief Checks whether the first byte array is greater or equal than the second byte array
* \return true if it is the case
*
* \param first ByteArray to compare in left hand side
* \param second ByteArray to compare in right hand side
* \param rhs ByteArray to compare with
*/
inline bool ByteArray::operator>=(const ByteArray& rhs) const

75
include/Nazara/Core/ObjectHandle.inl
View File

@ -291,15 +291,16 @@ namespace Nz
template<typename T>
std::ostream& operator<<(std::ostream& out, const ObjectHandle<T>& handle)
{
return handle.ToString();
out << handle.ToString();
return out;
}
/*!
* \brief Checks whether the first object handle is equal to the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator==(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
@ -311,8 +312,8 @@ namespace Nz
* \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 ObjectHandle to compare in right hand side
* \param lhs Object to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator==(const T& lhs, const ObjectHandle<T>& rhs)
@ -324,8 +325,8 @@ namespace Nz
* \brief Checks whether the object handle is equal to the second object
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second Object to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs Object to compare in right hand side
*/
template<typename T>
bool operator==(const ObjectHandle<T>& lhs, const T& rhs)
@ -337,8 +338,8 @@ namespace Nz
* \brief Checks whether the first object handle is equal to the second object handle
* \return false if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator!=(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
@ -350,8 +351,8 @@ namespace Nz
* \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 ObjectHandle to compare in right hand side
* \param lhs Object to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator!=(const T& lhs, const ObjectHandle<T>& rhs)
@ -363,8 +364,8 @@ namespace Nz
* \brief Checks whether the object handle is equal to the second object
* \return false if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second Object to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs Object to compare in right hand side
*/
template<typename T>
bool operator!=(const ObjectHandle<T>& lhs, const T& rhs)
@ -376,8 +377,8 @@ namespace Nz
* \brief Checks whether the first object handle is less than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator<(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
@ -389,8 +390,8 @@ namespace Nz
* \brief Checks whether the first object handle is less than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator<(const T& lhs, const ObjectHandle<T>& rhs)
@ -402,8 +403,8 @@ namespace Nz
* \brief Checks whether the first object handle is less than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator<(const ObjectHandle<T>& lhs, const T& rhs)
@ -415,8 +416,8 @@ namespace Nz
* \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 ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator<=(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
@ -428,8 +429,8 @@ namespace Nz
* \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 ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator<=(const T& lhs, const ObjectHandle<T>& rhs)
@ -441,8 +442,8 @@ namespace Nz
* \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 ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator<=(const ObjectHandle<T>& lhs, const T& rhs)
@ -454,8 +455,8 @@ namespace Nz
* \brief Checks whether the first object handle is greather than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator>(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
@ -467,8 +468,8 @@ namespace Nz
* \brief Checks whether the first object handle is greather than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator>(const T& lhs, const ObjectHandle<T>& rhs)
@ -480,8 +481,8 @@ namespace Nz
* \brief Checks whether the first object handle is greather than the second object handle
* \return true if it is the case
*
* \param first ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator>(const ObjectHandle<T>& lhs, const T& rhs)
@ -493,8 +494,8 @@ namespace Nz
* \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 ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator>=(const ObjectHandle<T>& lhs, const ObjectHandle<T>& rhs)
@ -506,8 +507,8 @@ namespace Nz
* \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 ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator>=(const T& lhs, const ObjectHandle<T>& rhs)
@ -519,8 +520,8 @@ namespace Nz
* \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 ObjectHandle to compare in left hand side
* \param second ObjectHandle to compare in right hand side
* \param lhs ObjectHandle to compare in left hand side
* \param rhs ObjectHandle to compare in right hand side
*/
template<typename T>
bool operator>=(const ObjectHandle<T>& lhs, const T& rhs)

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

@ -251,8 +251,8 @@ namespace Nz
* \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
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator==(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
@ -264,8 +264,8 @@ namespace Nz
* \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
* \param lhs Object to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator==(const T& lhs, const ObjectRef<T>& rhs)
@ -277,8 +277,8 @@ namespace Nz
* \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
* \param lhs ObjectRef to compare in left hand side
* \param rhs Object to compare in right hand side
*/
template<typename T>
bool operator==(const ObjectRef<T>& lhs, const T& rhs)
@ -290,8 +290,8 @@ namespace Nz
* \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
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator!=(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
@ -303,8 +303,8 @@ namespace Nz
* \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
* \param lhs Object to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator!=(const T& lhs, const ObjectRef<T>& rhs)
@ -316,8 +316,8 @@ namespace Nz
* \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
* \param lhs ObjectRef to compare in left hand side
* \param rhs Object to compare in right hand side
*/
template<typename T>
bool operator!=(const ObjectRef<T>& lhs, const T& rhs)
@ -329,8 +329,8 @@ namespace Nz
* \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
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
@ -342,8 +342,8 @@ namespace Nz
* \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
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<(const T& lhs, const ObjectRef<T>& rhs)
@ -355,8 +355,8 @@ namespace Nz
* \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
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<(const ObjectRef<T>& lhs, const T& rhs)
@ -368,8 +368,8 @@ namespace Nz
* \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
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<=(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
@ -381,8 +381,8 @@ namespace Nz
* \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
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<=(const T& lhs, const ObjectRef<T>& rhs)
@ -394,8 +394,8 @@ namespace Nz
* \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
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator<=(const ObjectRef<T>& lhs, const T& rhs)
@ -407,8 +407,8 @@ namespace Nz
* \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
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
@ -420,8 +420,8 @@ namespace Nz
* \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
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>(const T& lhs, const ObjectRef<T>& rhs)
@ -433,8 +433,8 @@ namespace Nz
* \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
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>(const ObjectRef<T>& lhs, const T& rhs)
@ -446,8 +446,8 @@ namespace Nz
* \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
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>=(const ObjectRef<T>& lhs, const ObjectRef<T>& rhs)
@ -459,8 +459,8 @@ namespace Nz
* \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
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>=(const T& lhs, const ObjectRef<T>& rhs)
@ -472,8 +472,8 @@ namespace Nz
* \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
* \param lhs ObjectRef to compare in left hand side
* \param rhs ObjectRef to compare in right hand side
*/
template<typename T>
bool operator>=(const ObjectRef<T>& lhs, const T& rhs)

7
include/Nazara/Core/String.inl
View File

@ -83,6 +83,9 @@ namespace Nz
}
namespace std
{
template<>
struct hash<Nz::String>
{
/*!
* \brief Specialisation of std to hash
@ -90,10 +93,6 @@ namespace std
*
* \param str String to hash
*/
template<>
struct hash<Nz::String>
{
size_t operator()(const Nz::String& str) const
{
// Algorithme DJB2

4
include/Nazara/Graphics/Renderable.inl
View File

@ -24,9 +24,7 @@ namespace Nz
}
/*!
* \brief Updates the bounding volume by a matrix
*
* \param transformMatrix Matrix transformation for our bounding volume
* \brief Updates the bounding volume
*/
inline void Renderable::UpdateBoundingVolume() const

6
include/Nazara/Math/Algorithm.inl
View File

@ -105,7 +105,7 @@ namespace Nz
*
* \param value Initial value
* \param objective Target value
* \parma increment One step value
* \param increment One step value
*/
template<typename T>
@ -412,7 +412,7 @@ namespace Nz
* \brief Gets the log in base 2 of integral number, only works for power of two !
* \return Log of the number
*
* \param number To get log in base 2
* \param pot To get log in base 2
*
* \remark Only works for power of two
* \remark If number is 0, 0 is returned
@ -431,7 +431,7 @@ namespace Nz
* \return base^exponent for integral
*
* \param base Base of the exponentation
* \parma exponent Power for the base
* \param exponent Power for the base
*/
//TODO: Mark as constexpr when supported by all major compilers

1
include/Nazara/Math/BoundingVolume.hpp
View File

@ -53,6 +53,7 @@ namespace Nz
void Update(const Vector3<T>& translation);
BoundingVolume operator*(T scalar) const;
BoundingVolume& operator=(const BoundingVolume& other) = default;
BoundingVolume& operator*=(T scalar);

1
include/Nazara/Math/Box.hpp
View File

@ -79,6 +79,7 @@ namespace Nz
Box operator*(T scalar) const;
Box operator*(const Vector3<T>& vec) const;
Box& operator=(const Box& other) = default;
Box& operator*=(T scalar);
Box& operator*=(const Vector3<T>& vec);

2
include/Nazara/Math/Box.inl
View File

@ -787,7 +787,7 @@ namespace Nz
* \brief Multiplies the lengths with the scalar
* \return A box where the position is the same and width, height and depth are the product of the old width, height and depth and the scalar
*
* \param scale The scalar to multiply width, height and depth with
* \param scalar The scalar to multiply width, height and depth with
*/
template<typename T>

1
include/Nazara/Math/EulerAngles.hpp
View File

@ -47,6 +47,7 @@ namespace Nz
EulerAngles operator-(const EulerAngles& angles) const;
/*EulerAngles operator*(const EulerAngles& angles) const;
EulerAngles operator/(const EulerAngles& angles) const;*/
EulerAngles& operator=(const EulerAngles& other) = default;
EulerAngles& operator+=(const EulerAngles& angles);
EulerAngles& operator-=(const EulerAngles& angles);

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

@ -50,6 +50,8 @@ namespace Nz
IntersectionSide Intersect(const Sphere<T>& sphere) const;
IntersectionSide Intersect(const Vector3<T>* points, unsigned int pointCount) const;
Frustum& operator=(const Frustum& other) = default;
Frustum& Set(const Frustum& frustum);
template<typename U> Frustum& Set(const Frustum<U>& frustum);

8
include/Nazara/Math/Matrix4.inl
View File

@ -750,7 +750,7 @@ namespace Nz
* \brief Inverts this matrix
* \return A reference to this matrix inverted
*
* \param bool Optional argument to know if matrix has been successfully inverted
* \param succeeded Optional argument to know if matrix has been successfully inverted
*
* \see InverseAffine
*/
@ -769,7 +769,7 @@ namespace Nz
* \brief Inverts this matrix
* \return A reference to this matrix inverted
*
* \param bool Optional argument to know if matrix has been successfully inverted
* \param succeeded Optional argument to know if matrix has been successfully inverted
*
* \see Inverse
*/
@ -1487,7 +1487,7 @@ namespace Nz
* \brief Compares the matrix to other one
* \return true if the matrices are the same
*
* \param matrix Other matrix to compare with
* \param mat Other matrix to compare with
*/
template<typename T>
@ -1504,7 +1504,7 @@ namespace Nz
* \brief Compares the matrix to other one
* \return false if the matrices are the same
*
* \param matrix Other matrix to compare with
* \param mat Other matrix to compare with
*/
template<typename T>

1
include/Nazara/Math/OrientedBox.hpp
View File

@ -52,6 +52,7 @@ namespace Nz
Vector3<T> operator()(unsigned int i) const;
OrientedBox operator*(T scalar) const;
OrientedBox& operator=(const OrientedBox& other) = default;
OrientedBox& operator*=(T scalar);

2
include/Nazara/Math/OrientedBox.inl
View File

@ -340,7 +340,7 @@ namespace Nz
* \brief Multiplies the lengths with the scalar
* \return A OrientedBox where the position is the same and width, height and depth are the product of the old width, height and depth and the scalar
*
* \param scale The scalar to multiply width, height and depth with
* \param scalar The scalar to multiply width, height and depth with
*/
template<typename T>

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

@ -45,6 +45,8 @@ namespace Nz
String ToString() const;
Plane& operator=(const Plane& other) = default;
bool operator==(const Plane& plane) const;
bool operator!=(const Plane& plane) const;

1
include/Nazara/Math/Ray.hpp
View File

@ -61,6 +61,7 @@ namespace Nz
String ToString() const;
Vector3<T> operator*(T lambda) const;
Ray& operator=(const Ray& other) = default;
bool operator==(const Ray& ray) const;
bool operator!=(const Ray& ray) const;

1
include/Nazara/Math/Rect.hpp
View File

@ -71,6 +71,7 @@ namespace Nz
Rect operator*(const Vector2<T>& vec) const;
Rect operator/(T scalar) const;
Rect operator/(const Vector2<T>& vec) const;
Rect& operator=(const Rect& other) = default;
Rect& operator*=(T scalar);
Rect& operator*=(const Vector2<T>& vec);

8
include/Nazara/Math/Rect.inl
View File

@ -629,7 +629,7 @@ namespace Nz
* \brief Multiplies the lengths with the scalar
* \return A rectangle where the position is the same and width and height are the product of the old width and height and the scalar
*
* \param scale The scalar to multiply width and height with
* \param scalar The scalar to multiply width and height with
*/
template<typename T>
@ -655,7 +655,7 @@ namespace Nz
* \brief Divides the lengths with the scalar
* \return A rectangle where the position is the same and width and height are the quotient of the old width and height and the scalar
*
* \param scale The scalar to divide width and height with
* \param scalar The scalar to divide width and height with
*/
template<typename T>
@ -745,7 +745,7 @@ namespace Nz
* \brief Compares the rectangle to other one
* \return true if the rectangles are the same
*
* \param rec Other rectangle to compare with
* \param rect Other rectangle to compare with
*/
template<typename T>
@ -759,7 +759,7 @@ namespace Nz
* \brief Compares the rectangle to other one
* \return false if the rectangles are the same
*
* \param rec Other rectangle to compare with
* \param rect Other rectangle to compare with
*/
template<typename T>

1
include/Nazara/Math/Sphere.hpp
View File

@ -67,6 +67,7 @@ namespace Nz
T operator[](unsigned int i) const;
Sphere operator*(T scalar) const;
Sphere& operator=(const Sphere& other) = default;
Sphere& operator*=(T scalar);

1
include/Nazara/Math/Vector2.hpp
View File

@ -76,6 +76,7 @@ namespace Nz
Vector2 operator*(T scale) const;
Vector2 operator/(const Vector2& vec) const;
Vector2 operator/(T scale) const;
Vector2& operator=(const Vector2& other) = default;
Vector2& operator+=(const Vector2& vec);
Vector2& operator-=(const Vector2& vec);

1
include/Nazara/Math/Vector3.hpp
View File

@ -87,6 +87,7 @@ namespace Nz
Vector3 operator*(T scale) const;
Vector3 operator/(const Vector3& vec) const;
Vector3 operator/(T scale) const;
Vector3& operator=(const Vector3& vec) = default;
Vector3& operator+=(const Vector3& vec);
Vector3& operator-=(const Vector3& vec);

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

@ -74,6 +74,7 @@ namespace Nz
Vector4 operator*(T scale) const;
Vector4 operator/(const Vector4& vec) const;
Vector4 operator/(T scale) const;
Vector4& operator=(const Vector4& other) = default;
Vector4& operator+=(const Vector4& vec);
Vector4& operator-=(const Vector4& vec);

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

@ -725,7 +725,7 @@ namespace Nz
return true;
else if (path.Match("\\\\*")) // Ex: \\Laptop
return true;
else if (path.StartsWith('\\')) // Special : '\' refering to the root
else if (path.StartsWith('\\')) // Special : '\' referring to the root
return true;
else
return false;

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

@ -1,4 +1,3 @@
#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

9
src/Nazara/Utility/Image.cpp
View File

@ -1352,6 +1352,15 @@ namespace Nz
void Image::Copy(UInt8* destination, const UInt8* source, PixelFormatType format, unsigned int width, unsigned int height, unsigned int depth, unsigned int dstWidth, unsigned int dstHeight, unsigned int srcWidth, unsigned int srcHeight)
{
#if NAZARA_UTILITY_SAFE
if (width == 0)
NazaraError("Width must be greater than zero");
if (height == 0)
NazaraError("Height must be greater than zero");
if (depth == 0)
NazaraError("Depth must be greater than zero");
#endif
if (dstWidth == 0)
dstWidth = width;