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

Fixes a lot of warnings and move math enums to enum classes

This commit is contained in:
Jérôme Leclercq 2021-08-19 20:27:20 +02:00
parent a2a0e6bd54
commit 8db8533300
27 changed files with 323 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
examples/GraphicsTest/main.cpp
View File

@ -148,9 +148,9 @@ int main()
case Nz::WindowEventType::Resized: case Nz::WindowEventType::Resized:
{ {
Nz::Vector2ui windowSize = window.GetSize(); Nz::Vector2ui newWindowSize = window.GetSize();
viewerInstance.UpdateProjectionMatrix(Nz::Matrix4f::Perspective(Nz::DegreeAnglef(70.f), float(windowSize.x) / windowSize.y, 0.1f, 1000.f)); viewerInstance.UpdateProjectionMatrix(Nz::Matrix4f::Perspective(Nz::DegreeAnglef(70.f), float(newWindowSize.x) / newWindowSize.y, 0.1f, 1000.f));
viewerInstance.UpdateTargetSize(Nz::Vector2f(windowSize)); viewerInstance.UpdateTargetSize(Nz::Vector2f(newWindowSize));
break; break;
} }

18
include/Nazara/Graphics/CullingList.inl
View File

@ -33,7 +33,7 @@ namespace Nz
{ {
switch (frustum.Intersect(entry.box)) switch (frustum.Intersect(entry.box))
{ {
case IntersectionSide_Inside: case IntersectionSide::Inside:
m_fullyVisibleResults.push_back(entry.renderable); m_fullyVisibleResults.push_back(entry.renderable);
fullyVisibleHash = CombineHash(fullyVisibleHash, std::hash<const T*>()(entry.renderable)); fullyVisibleHash = CombineHash(fullyVisibleHash, std::hash<const T*>()(entry.renderable));
@ -41,7 +41,7 @@ namespace Nz
entry.forceInvalidation = false; entry.forceInvalidation = false;
break; break;
case IntersectionSide_Intersecting: case IntersectionSide::Intersecting:
m_partiallyVisibleResults.push_back(entry.renderable); m_partiallyVisibleResults.push_back(entry.renderable);
partiallyVisibleHash = CombineHash(partiallyVisibleHash, std::hash<const T*>()(entry.renderable)); partiallyVisibleHash = CombineHash(partiallyVisibleHash, std::hash<const T*>()(entry.renderable));
@ -49,7 +49,7 @@ namespace Nz
entry.forceInvalidation = false; entry.forceInvalidation = false;
break; break;
case IntersectionSide_Outside: case IntersectionSide::Outside:
break; break;
} }
} }
@ -70,7 +70,7 @@ namespace Nz
{ {
switch (frustum.Intersect(entry.sphere)) switch (frustum.Intersect(entry.sphere))
{ {
case IntersectionSide_Inside: case IntersectionSide::Inside:
m_fullyVisibleResults.push_back(entry.renderable); m_fullyVisibleResults.push_back(entry.renderable);
fullyVisibleHash = CombineHash(fullyVisibleHash, std::hash<const T*>()(entry.renderable)); fullyVisibleHash = CombineHash(fullyVisibleHash, std::hash<const T*>()(entry.renderable));
@ -78,7 +78,7 @@ namespace Nz
entry.forceInvalidation = false; entry.forceInvalidation = false;
break; break;
case IntersectionSide_Intersecting: case IntersectionSide::Intersecting:
m_partiallyVisibleResults.push_back(entry.renderable); m_partiallyVisibleResults.push_back(entry.renderable);
partiallyVisibleHash = CombineHash(partiallyVisibleHash, std::hash<const T*>()(entry.renderable)); partiallyVisibleHash = CombineHash(partiallyVisibleHash, std::hash<const T*>()(entry.renderable));
@ -86,7 +86,7 @@ namespace Nz
entry.forceInvalidation = false; entry.forceInvalidation = false;
break; break;
case IntersectionSide_Outside: case IntersectionSide::Outside:
break; break;
} }
} }
@ -95,7 +95,7 @@ namespace Nz
{ {
switch (frustum.Intersect(entry.volume)) switch (frustum.Intersect(entry.volume))
{ {
case IntersectionSide_Inside: case IntersectionSide::Inside:
m_fullyVisibleResults.push_back(entry.renderable); m_fullyVisibleResults.push_back(entry.renderable);
fullyVisibleHash = CombineHash(fullyVisibleHash, std::hash<const T*>()(entry.renderable)); fullyVisibleHash = CombineHash(fullyVisibleHash, std::hash<const T*>()(entry.renderable));
@ -103,7 +103,7 @@ namespace Nz
entry.forceInvalidation = false; entry.forceInvalidation = false;
break; break;
case IntersectionSide_Intersecting: case IntersectionSide::Intersecting:
m_partiallyVisibleResults.push_back(entry.renderable); m_partiallyVisibleResults.push_back(entry.renderable);
partiallyVisibleHash = CombineHash(partiallyVisibleHash, std::hash<const T*>()(entry.renderable)); partiallyVisibleHash = CombineHash(partiallyVisibleHash, std::hash<const T*>()(entry.renderable));
@ -111,7 +111,7 @@ namespace Nz
entry.forceInvalidation = false; entry.forceInvalidation = false;
break; break;
case IntersectionSide_Outside: case IntersectionSide::Outside:
break; break;
} }
} }

2
include/Nazara/Graphics/MaterialPipeline.inl
View File

@ -77,6 +77,8 @@ namespace std
Nz::HashCombine(seed, shader.uberShader.get()); Nz::HashCombine(seed, shader.uberShader.get());
} }
NazaraUnused(parameterIndex);
#undef NazaraPipelineMember #undef NazaraPipelineMember
#undef NazaraPipelineBoolMember #undef NazaraPipelineBoolMember

88
include/Nazara/Math/BoundingVolume.inl
View File

@ -24,12 +24,12 @@ namespace Nz
/*! /*!
* \brief Constructs a BoundingVolume object by default * \brief Constructs a BoundingVolume object by default
* *
* \remark extend is set to Extend_Null, aabb and obb are uninitialized * \remark extend is set to Extend::Null, aabb and obb are uninitialized
*/ */
template<typename T> template<typename T>
BoundingVolume<T>::BoundingVolume() : BoundingVolume<T>::BoundingVolume() :
extend(Extend_Null) extend(Extend::Null)
{ {
} }
@ -136,31 +136,31 @@ namespace Nz
{ {
switch (extend) switch (extend)
{ {
case Extend_Finite: case Extend::Finite:
{ {
switch (volume.extend) switch (volume.extend)
{ {
case Extend_Finite: case Extend::Finite:
{ {
// Extend the OBB local box // Extend the OBB local box
obb.localBox.ExtendTo(volume.obb.localBox); obb.localBox.ExtendTo(volume.obb.localBox);
break; break;
} }
case Extend_Infinite: case Extend::Infinite:
MakeInfinite(); MakeInfinite();
break; break;
case Extend_Null: case Extend::Null:
break; break;
} }
break; break;
} }
case Extend_Infinite: case Extend::Infinite:
break; //< We already contain the bounding volume break; //< We already contain the bounding volume
case Extend_Null: case Extend::Null:
Set(volume); Set(volume);
break; break;
} }
@ -170,40 +170,40 @@ namespace Nz
/*! /*!
* \brief Checks whether the volume is finite * \brief Checks whether the volume is finite
* \return true if extend is Extend_Finite * \return true if extend is Extend::Finite
*/ */
template<typename T> template<typename T>
bool BoundingVolume<T>::IsFinite() const bool BoundingVolume<T>::IsFinite() const
{ {
return extend == Extend_Finite; return extend == Extend::Finite;
} }
/*! /*!
* \brief Checks whether the volume is infinite * \brief Checks whether the volume is infinite
* \return true if extend is Extend_Infinite * \return true if extend is Extend::Infinite
*/ */
template<typename T> template<typename T>
bool BoundingVolume<T>::IsInfinite() const bool BoundingVolume<T>::IsInfinite() const
{ {
return extend == Extend_Infinite; return extend == Extend::Infinite;
} }
/*! /*!
* \brief Checks whether the volume is null * \brief Checks whether the volume is null
* \return true if extend is Extend_Null * \return true if extend is Extend::Null
*/ */
template<typename T> template<typename T>
bool BoundingVolume<T>::IsNull() const bool BoundingVolume<T>::IsNull() const
{ {
return extend == Extend_Null; return extend == Extend::Null;
} }
/*! /*!
* \brief Makes the bounding volume infinite * \brief Makes the bounding volume infinite
* \return A reference to this bounding volume with Extend_Infinite for extend * \return A reference to this bounding volume with Extend::Infinite for extend
* *
* \see Infinite * \see Infinite
*/ */
@ -211,14 +211,14 @@ namespace Nz
template<typename T> template<typename T>
BoundingVolume<T>& BoundingVolume<T>::MakeInfinite() BoundingVolume<T>& BoundingVolume<T>::MakeInfinite()
{ {
extend = Extend_Infinite; extend = Extend::Infinite;
return *this; return *this;
} }
/*! /*!
* \brief Makes the bounding volume null * \brief Makes the bounding volume null
* \return A reference to this bounding volume with Extend_Null for extend * \return A reference to this bounding volume with Extend::Null for extend
* *
* \see Null * \see Null
*/ */
@ -226,7 +226,7 @@ namespace Nz
template<typename T> template<typename T>
BoundingVolume<T>& BoundingVolume<T>::MakeNull() BoundingVolume<T>& BoundingVolume<T>::MakeNull()
{ {
extend = Extend_Null; extend = Extend::Null;
return *this; return *this;
} }
@ -237,7 +237,7 @@ namespace Nz
* *
* \param Extend New extend * \param Extend New extend
* *
* \remark This method is meant to be called with Extend_Infinite or Extend_Null * \remark This method is meant to be called with Extend::Infinite or Extend::Null
*/ */
template<typename T> template<typename T>
@ -264,7 +264,7 @@ namespace Nz
BoundingVolume<T>& BoundingVolume<T>::Set(T X, T Y, T Z, T Width, T Height, T Depth) BoundingVolume<T>& BoundingVolume<T>::Set(T X, T Y, T Z, T Width, T Height, T Depth)
{ {
obb.Set(X, Y, Z, Width, Height, Depth); obb.Set(X, Y, Z, Width, Height, Depth);
extend = Extend_Finite; extend = Extend::Finite;
return *this; return *this;
} }
@ -296,7 +296,7 @@ namespace Nz
BoundingVolume<T>& BoundingVolume<T>::Set(const Box<T>& box) BoundingVolume<T>& BoundingVolume<T>::Set(const Box<T>& box)
{ {
obb.Set(box); obb.Set(box);
extend = Extend_Finite; extend = Extend::Finite;
return *this; return *this;
} }
@ -312,7 +312,7 @@ namespace Nz
BoundingVolume<T>& BoundingVolume<T>::Set(const OrientedBox<T>& orientedBox) BoundingVolume<T>& BoundingVolume<T>::Set(const OrientedBox<T>& orientedBox)
{ {
obb.Set(orientedBox); obb.Set(orientedBox);
extend = Extend_Finite; extend = Extend::Finite;
return *this; return *this;
} }
@ -329,7 +329,7 @@ namespace Nz
BoundingVolume<T>& BoundingVolume<T>::Set(const Vector3<T>& vec1, const Vector3<T>& vec2) BoundingVolume<T>& BoundingVolume<T>::Set(const Vector3<T>& vec1, const Vector3<T>& vec2)
{ {
obb.Set(vec1, vec2); obb.Set(vec1, vec2);
extend = Extend_Finite; extend = Extend::Finite;
return *this; return *this;
} }
@ -441,7 +441,7 @@ namespace Nz
bool BoundingVolume<T>::operator==(const BoundingVolume& volume) const bool BoundingVolume<T>::operator==(const BoundingVolume& volume) const
{ {
if (extend == volume.extend) if (extend == volume.extend)
if (extend == Extend_Finite) if (extend == Extend::Finite)
return obb == volume.obb; return obb == volume.obb;
else else
return true; return true;
@ -463,8 +463,8 @@ namespace Nz
} }
/*! /*!
* \brief Shorthand for the bounding volume (Extend_Infinite) * \brief Shorthand for the bounding volume (Extend::Infinite)
* \return A bounding volume with Extend_Infinite * \return A bounding volume with Extend::Infinite
* *
* \see MakeInfinite * \see MakeInfinite
*/ */
@ -512,11 +512,11 @@ namespace Nz
switch (to.extend) switch (to.extend)
{ {
case Extend_Finite: case Extend::Finite:
{ {
switch (from.extend) switch (from.extend)
{ {
case Extend_Finite: case Extend::Finite:
{ {
BoundingVolume volume; BoundingVolume volume;
volume.Set(OrientedBox<T>::Lerp(from.obb, to.obb, interpolation)); volume.Set(OrientedBox<T>::Lerp(from.obb, to.obb, interpolation));
@ -524,49 +524,49 @@ namespace Nz
return volume; return volume;
} }
case Extend_Infinite: case Extend::Infinite:
return Infinite(); return Infinite();
case Extend_Null: case Extend::Null:
return to.obb * interpolation; return to.obb * interpolation;
} }
// If we arrive here, the extend is invalid // If we arrive here, the extend is invalid
NazaraError("Invalid extend type (From) (0x" + NumberToString(from.extend, 16) + ')'); NazaraError("Invalid extend type (From) (0x" + NumberToString(UnderlyingCast(from.extend), 16) + ')');
return Null(); return Null();
} }
case Extend_Infinite: case Extend::Infinite:
return Infinite(); // A little bit of infinity is already too much ;) return Infinite(); // A little bit of infinity is already too much ;)
case Extend_Null: case Extend::Null:
{ {
switch (from.extend) switch (from.extend)
{ {
case Extend_Finite: case Extend::Finite:
return from.obb * (T(1.0) - interpolation); return from.obb * (T(1.0) - interpolation);
case Extend_Infinite: case Extend::Infinite:
return Infinite(); return Infinite();
case Extend_Null: case Extend::Null:
return Null(); return Null();
} }
// If we arrive here, the extend is invalid // If we arrive here, the extend is invalid
NazaraError("Invalid extend type (From) (0x" + NumberToString(from.extend, 16) + ')'); NazaraError("Invalid extend type (From) (0x" + NumberToString(UnderlyingCast(from.extend), 16) + ')');
return Null(); return Null();
} }
} }
// If we arrive here, the extend is invalid // If we arrive here, the extend is invalid
NazaraError("Invalid extend type (To) (0x" + NumberToString(to.extend, 16) + ')'); NazaraError("Invalid extend type (To) (0x" + NumberToString(UnderlyingCast(to.extend), 16) + ')');
return Null(); return Null();
} }
/*! /*!
* \brief Shorthand for the bounding volume (Extend_Null) * \brief Shorthand for the bounding volume (Extend::Null)
* \return A bounding volume with Extend_Null * \return A bounding volume with Extend::Null
* *
* \see MakeNull * \see MakeNull
*/ */
@ -620,7 +620,7 @@ namespace Nz
if (!Unserialize(context, &extend)) if (!Unserialize(context, &extend))
return false; return false;
if (extend > Extend_Max) if (extend > UnderlyingCast(Extend::Max))
return false; return false;
boundingVolume->extend = static_cast<Extend>(extend); boundingVolume->extend = static_cast<Extend>(extend);
@ -648,15 +648,15 @@ std::ostream& operator<<(std::ostream& out, const Nz::BoundingVolume<T>& volume)
{ {
switch (volume.extend) switch (volume.extend)
{ {
case Nz::Extend_Finite: case Nz::Extend::Finite:
out << "BoundingVolume(localBox=" << volume.obb.localBox << ')'; out << "BoundingVolume(localBox=" << volume.obb.localBox << ')';
break; break;
case Nz::Extend_Infinite: case Nz::Extend::Infinite:
out << "BoundingVolume(Infinite)"; out << "BoundingVolume(Infinite)";
break; break;
case Nz::Extend_Null: case Nz::Extend::Null:
out << "BoundingVolume(Null)"; out << "BoundingVolume(Null)";
break; break;
} }

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

@ -276,32 +276,32 @@ namespace Nz
{ {
switch (corner) switch (corner)
{ {
case BoxCorner_FarLeftBottom: case BoxCorner::FarLeftBottom:
return Vector3<T>(x, y, z); return Vector3<T>(x, y, z);
case BoxCorner_FarLeftTop: case BoxCorner::FarLeftTop:
return Vector3<T>(x, y + height, z); return Vector3<T>(x, y + height, z);
case BoxCorner_FarRightBottom: case BoxCorner::FarRightBottom:
return Vector3<T>(x + width, y, z); return Vector3<T>(x + width, y, z);
case BoxCorner_FarRightTop: case BoxCorner::FarRightTop:
return Vector3<T>(x + width, y + height, z); return Vector3<T>(x + width, y + height, z);
case BoxCorner_NearLeftBottom: case BoxCorner::NearLeftBottom:
return Vector3<T>(x, y, z + depth); return Vector3<T>(x, y, z + depth);
case BoxCorner_NearLeftTop: case BoxCorner::NearLeftTop:
return Vector3<T>(x, y + height, z + depth); return Vector3<T>(x, y + height, z + depth);
case BoxCorner_NearRightBottom: case BoxCorner::NearRightBottom:
return Vector3<T>(x + width, y, z + depth); return Vector3<T>(x + width, y, z + depth);
case BoxCorner_NearRightTop: case BoxCorner::NearRightTop:
return Vector3<T>(x + width, y + height, z + depth); return Vector3<T>(x + width, y + height, z + depth);
} }
NazaraError("Corner not handled (0x" + NumberToString(corner, 16) + ')'); NazaraError("Corner not handled (0x" + NumberToString(UnderlyingCast(corner), 16) + ')');
return Vector3<T>(); return Vector3<T>();
} }
@ -318,7 +318,7 @@ namespace Nz
/*! /*!
* \brief Gets a Vector3 for the maximum point * \brief Gets a Vector3 for the maximum point
* \return The BoxCorner_NearRightTop of the box * \return The BoxCorner::NearRightTop of the box
* *
* \see GetCorner * \see GetCorner
*/ */
@ -331,7 +331,7 @@ namespace Nz
/*! /*!
* \brief Gets a Vector3 for the minimum point * \brief Gets a Vector3 for the minimum point
* \return The BoxCorner_FarLeftBottom of the box * \return The BoxCorner::FarLeftBottom of the box
* *
* \see GetCorner, GetPosition * \see GetCorner, GetPosition
*/ */
@ -370,7 +370,7 @@ namespace Nz
/*! /*!
* \brief Gets a Vector3 for the position * \brief Gets a Vector3 for the position
* \return The BoxCorner_FarLeftBottom of the box * \return The BoxCorner::FarLeftBottom of the box
* *
* \see GetCorner, GetMinimum * \see GetCorner, GetMinimum
*/ */

78
include/Nazara/Math/Enums.hpp
View File

@ -7,6 +7,8 @@
#ifndef NAZARA_ENUMS_MATH_HPP #ifndef NAZARA_ENUMS_MATH_HPP
#define NAZARA_ENUMS_MATH_HPP #define NAZARA_ENUMS_MATH_HPP
#include <Nazara/Core/Algorithm.hpp>
namespace Nz namespace Nz
{ {
enum class AngleUnit enum class AngleUnit
@ -15,58 +17,62 @@ namespace Nz
Radian Radian
}; };
enum BoxCorner enum class BoxCorner
{ {
BoxCorner_FarLeftBottom, FarLeftBottom,
BoxCorner_FarLeftTop, FarLeftTop,
BoxCorner_FarRightBottom, FarRightBottom,
BoxCorner_FarRightTop, FarRightTop,
BoxCorner_NearLeftBottom, NearLeftBottom,
BoxCorner_NearLeftTop, NearLeftTop,
BoxCorner_NearRightBottom, NearRightBottom,
BoxCorner_NearRightTop, NearRightTop,
BoxCorner_Max = BoxCorner_NearRightTop Max = NearRightTop
}; };
enum Extend constexpr std::size_t BoxCornerCount = UnderlyingCast(BoxCorner::Max) + 1;
{
Extend_Finite,
Extend_Infinite,
Extend_Null,
Extend_Max = Extend_Null enum class Extend
{
Finite,
Infinite,
Null,
Max = Null
}; };
enum FrustumPlane enum class FrustumPlane
{ {
FrustumPlane_Bottom, Bottom,
FrustumPlane_Far, Far,
FrustumPlane_Left, Left,
FrustumPlane_Near, Near,
FrustumPlane_Right, Right,
FrustumPlane_Top, Top,
FrustumPlane_Max = FrustumPlane_Top Max = Top
}; };
enum IntersectionSide constexpr std::size_t FrustumPlaneCount = UnderlyingCast(FrustumPlane::Max) + 1;
{
IntersectionSide_Inside,
IntersectionSide_Intersecting,
IntersectionSide_Outside,
IntersectionSide_Max = IntersectionSide_Outside enum class IntersectionSide
{
Inside,
Intersecting,
Outside,
Max = Outside
}; };
enum RectCorner enum class RectCorner
{ {
RectCorner_LeftBottom, LeftBottom,
RectCorner_LeftTop, LeftTop,
RectCorner_RightBottom, RightBottom,
RectCorner_RightTop, RightTop,
RectCorner_Max = RectCorner_RightTop Max = RightTop
}; };
} }

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

@ -49,7 +49,7 @@ namespace Nz
IntersectionSide Intersect(const Box<T>& box) const; IntersectionSide Intersect(const Box<T>& box) const;
IntersectionSide Intersect(const OrientedBox<T>& orientedBox) const; IntersectionSide Intersect(const OrientedBox<T>& orientedBox) const;
IntersectionSide Intersect(const Sphere<T>& sphere) const; IntersectionSide Intersect(const Sphere<T>& sphere) const;
IntersectionSide Intersect(const Vector3<T>* points, unsigned int pointCount) const; IntersectionSide Intersect(const Vector3<T>* points, std::size_t pointCount) const;
Frustum& operator=(const Frustum& other) = default; Frustum& operator=(const Frustum& other) = default;
@ -64,8 +64,8 @@ namespace Nz
friend bool Unserialize(SerializationContext& context, Frustum<U>* frustum, TypeTag<Frustum<U>>); friend bool Unserialize(SerializationContext& context, Frustum<U>* frustum, TypeTag<Frustum<U>>);
private: private:
Vector3<T> m_corners[BoxCorner_Max+1]; Vector3<T> m_corners[BoxCornerCount];
Plane<T> m_planes[FrustumPlane_Max+1]; Plane<T> m_planes[FrustumPlaneCount];
}; };
using Frustumd = Frustum<double>; using Frustumd = Frustum<double>;

178
include/Nazara/Math/Frustum.inl
View File

@ -16,7 +16,7 @@ namespace Nz
{ {
/*! /*!
* \ingroup math * \ingroup math
* \class Nz::Frustum * \class Nz::Frustum
* \brief Math class that represents a frustum in the three dimensional vector space * \brief Math class that represents a frustum in the three dimensional vector space
* *
@ -69,23 +69,23 @@ namespace Nz
Vector3<T> fc = eye + f * zFar; Vector3<T> fc = eye + f * zFar;
// Computing the frustum // Computing the frustum
m_corners[BoxCorner_FarLeftBottom] = fc - u * farH - s * farW; m_corners[UnderlyingCast(BoxCorner::FarLeftBottom)] = fc - u * farH - s * farW;
m_corners[BoxCorner_FarLeftTop] = fc + u * farH - s * farW; m_corners[UnderlyingCast(BoxCorner::FarLeftTop)] = fc + u * farH - s * farW;
m_corners[BoxCorner_FarRightTop] = fc + u * farH + s * farW; m_corners[UnderlyingCast(BoxCorner::FarRightTop)] = fc + u * farH + s * farW;
m_corners[BoxCorner_FarRightBottom] = fc - u * farH + s * farW; m_corners[UnderlyingCast(BoxCorner::FarRightBottom)] = fc - u * farH + s * farW;
m_corners[BoxCorner_NearLeftBottom] = nc - u * nearH - s * nearW; m_corners[UnderlyingCast(BoxCorner::NearLeftBottom)] = nc - u * nearH - s * nearW;
m_corners[BoxCorner_NearLeftTop] = nc + u * nearH - s * nearW; m_corners[UnderlyingCast(BoxCorner::NearLeftTop)] = nc + u * nearH - s * nearW;
m_corners[BoxCorner_NearRightTop] = nc + u * nearH + s * nearW; m_corners[UnderlyingCast(BoxCorner::NearRightTop)] = nc + u * nearH + s * nearW;
m_corners[BoxCorner_NearRightBottom] = nc - u * nearH + s * nearW; m_corners[UnderlyingCast(BoxCorner::NearRightBottom)] = nc - u * nearH + s * nearW;
// Construction of frustum's planes // Construction of frustum's planes
m_planes[FrustumPlane_Bottom].Set(m_corners[BoxCorner_NearLeftBottom], m_corners[BoxCorner_NearRightBottom], m_corners[BoxCorner_FarRightBottom]); m_planes[UnderlyingCast(FrustumPlane::Bottom)].Set(m_corners[UnderlyingCast(BoxCorner::NearLeftBottom)], m_corners[UnderlyingCast(BoxCorner::NearRightBottom)], m_corners[UnderlyingCast(BoxCorner::FarRightBottom)]);
m_planes[FrustumPlane_Far].Set(m_corners[BoxCorner_FarRightTop], m_corners[BoxCorner_FarLeftTop], m_corners[BoxCorner_FarLeftBottom]); m_planes[UnderlyingCast(FrustumPlane::Far)].Set(m_corners[UnderlyingCast(BoxCorner::FarRightTop)], m_corners[UnderlyingCast(BoxCorner::FarLeftTop)], m_corners[UnderlyingCast(BoxCorner::FarLeftBottom)]);
m_planes[FrustumPlane_Left].Set(m_corners[BoxCorner_NearLeftTop], m_corners[BoxCorner_NearLeftBottom], m_corners[BoxCorner_FarLeftBottom]); m_planes[UnderlyingCast(FrustumPlane::Left)].Set(m_corners[UnderlyingCast(BoxCorner::NearLeftTop)], m_corners[UnderlyingCast(BoxCorner::NearLeftBottom)], m_corners[UnderlyingCast(BoxCorner::FarLeftBottom)]);
m_planes[FrustumPlane_Near].Set(m_corners[BoxCorner_NearLeftTop], m_corners[BoxCorner_NearRightTop], m_corners[BoxCorner_NearRightBottom]); m_planes[UnderlyingCast(FrustumPlane::Near)].Set(m_corners[UnderlyingCast(BoxCorner::NearLeftTop)], m_corners[UnderlyingCast(BoxCorner::NearRightTop)], m_corners[UnderlyingCast(BoxCorner::NearRightBottom)]);
m_planes[FrustumPlane_Right].Set(m_corners[BoxCorner_NearRightBottom], m_corners[BoxCorner_NearRightTop], m_corners[BoxCorner_FarRightBottom]); m_planes[UnderlyingCast(FrustumPlane::Right)].Set(m_corners[UnderlyingCast(BoxCorner::NearRightBottom)], m_corners[UnderlyingCast(BoxCorner::NearRightTop)], m_corners[UnderlyingCast(BoxCorner::FarRightBottom)]);
m_planes[FrustumPlane_Top].Set(m_corners[BoxCorner_NearRightTop], m_corners[BoxCorner_NearLeftTop], m_corners[BoxCorner_FarLeftTop]); m_planes[UnderlyingCast(FrustumPlane::Top)].Set(m_corners[UnderlyingCast(BoxCorner::NearRightTop)], m_corners[UnderlyingCast(BoxCorner::NearLeftTop)], m_corners[UnderlyingCast(BoxCorner::FarLeftTop)]);
return *this; return *this;
} }
@ -107,33 +107,33 @@ namespace Nz
{ {
switch (volume.extend) switch (volume.extend)
{ {
case Extend_Finite: case Extend::Finite:
{ {
IntersectionSide side = Intersect(volume.aabb); IntersectionSide side = Intersect(volume.aabb);
switch (side) switch (side)
{ {
case IntersectionSide_Inside: case IntersectionSide::Inside:
return true; return true;
case IntersectionSide_Intersecting: case IntersectionSide::Intersecting:
return Contains(volume.obb); return Contains(volume.obb);
case IntersectionSide_Outside: case IntersectionSide::Outside:
return false; return false;
} }
NazaraError("Invalid intersection side (0x" + NumberToString(side, 16) + ')'); NazaraError("Invalid intersection side (0x" + NumberToString(UnderlyingCast(side), 16) + ')');
return false; return false;
} }
case Extend_Infinite: case Extend::Infinite:
return true; return true;
case Extend_Null: case Extend::Null:
return false; return false;
} }
NazaraError("Invalid extend type (0x" + NumberToString(volume.extend, 16) + ')'); NazaraError("Invalid extend type (0x" + NumberToString(UnderlyingCast(volume.extend), 16) + ')');
return false; return false;
} }
@ -148,7 +148,7 @@ namespace Nz
bool Frustum<T>::Contains(const Box<T>& box) const bool Frustum<T>::Contains(const Box<T>& box) const
{ {
// http://www.lighthouse3d.com/tutorials/view-frustum-culling/geometric-approach-testing-boxes-ii/ // http://www.lighthouse3d.com/tutorials/view-frustum-culling/geometric-approach-testing-boxes-ii/
for (unsigned int i = 0; i <= FrustumPlane_Max; i++) for (unsigned int i = 0; i < FrustumPlaneCount; i++)
{ {
if (m_planes[i].Distance(box.GetPositiveVertex(m_planes[i].normal)) < T(0.0)) if (m_planes[i].Distance(box.GetPositiveVertex(m_planes[i].normal)) < T(0.0))
return false; return false;
@ -180,7 +180,7 @@ namespace Nz
template<typename T> template<typename T>
bool Frustum<T>::Contains(const Sphere<T>& sphere) const bool Frustum<T>::Contains(const Sphere<T>& sphere) const
{ {
for (unsigned int i = 0; i <= FrustumPlane_Max; i++) for (unsigned int i = 0; i < FrustumPlaneCount; i++)
{ {
if (m_planes[i].Distance(sphere.GetPosition()) < -sphere.radius) if (m_planes[i].Distance(sphere.GetPosition()) < -sphere.radius)
return false; return false;
@ -199,7 +199,7 @@ namespace Nz
template<typename T> template<typename T>
bool Frustum<T>::Contains(const Vector3<T>& point) const bool Frustum<T>::Contains(const Vector3<T>& point) const
{ {
for (unsigned int i = 0; i <= FrustumPlane_Max; ++i) for (unsigned int i = 0; i < FrustumPlaneCount; ++i)
{ {
if (m_planes[i].Distance(point) < T(0.0)) if (m_planes[i].Distance(point) < T(0.0))
return false; return false;
@ -219,7 +219,7 @@ namespace Nz
template<typename T> template<typename T>
bool Frustum<T>::Contains(const Vector3<T>* points, unsigned int pointCount) const bool Frustum<T>::Contains(const Vector3<T>* points, unsigned int pointCount) const
{ {
for (unsigned int i = 0; i <= FrustumPlane_Max; ++i) for (unsigned int i = 0; i < FrustumPlaneCount; ++i)
{ {
unsigned int j; unsigned int j;
for (j = 0; j < pointCount; j++ ) for (j = 0; j < pointCount; j++ )
@ -264,7 +264,7 @@ namespace Nz
plane[2] *= invLength; plane[2] *= invLength;
plane[3] *= -invLength; plane[3] *= -invLength;
m_planes[FrustumPlane_Right].Set(plane); m_planes[FrustumPlane::Right].Set(plane);
// Extract the numbers for the LEFT plane // Extract the numbers for the LEFT plane
plane[0] = clipMatrix[ 3] + clipMatrix[ 0]; plane[0] = clipMatrix[ 3] + clipMatrix[ 0];
@ -279,7 +279,7 @@ namespace Nz
plane[2] *= invLength; plane[2] *= invLength;
plane[3] *= -invLength; plane[3] *= -invLength;
m_planes[FrustumPlane_Left].Set(plane); m_planes[FrustumPlane::Left].Set(plane);
// Extract the BOTTOM plane // Extract the BOTTOM plane
plane[0] = clipMatrix[ 3] + clipMatrix[ 1]; plane[0] = clipMatrix[ 3] + clipMatrix[ 1];
@ -294,7 +294,7 @@ namespace Nz
plane[2] *= invLength; plane[2] *= invLength;
plane[3] *= -invLength; plane[3] *= -invLength;
m_planes[FrustumPlane_Bottom].Set(plane); m_planes[FrustumPlane::Bottom].Set(plane);
// Extract the TOP plane // Extract the TOP plane
plane[0] = clipMatrix[ 3] - clipMatrix[ 1]; plane[0] = clipMatrix[ 3] - clipMatrix[ 1];
@ -309,7 +309,7 @@ namespace Nz
plane[2] *= invLength; plane[2] *= invLength;
plane[3] *= -invLength; plane[3] *= -invLength;
m_planes[FrustumPlane_Top].Set(plane); m_planes[FrustumPlane::Top].Set(plane);
// Extract the FAR plane // Extract the FAR plane
plane[0] = clipMatrix[ 3] - clipMatrix[ 2]; plane[0] = clipMatrix[ 3] - clipMatrix[ 2];
@ -324,7 +324,7 @@ namespace Nz
plane[2] *= invLength; plane[2] *= invLength;
plane[3] *= -invLength; plane[3] *= -invLength;
m_planes[FrustumPlane_Far].Set(plane); m_planes[FrustumPlane::Far].Set(plane);
// Extract the NEAR plane // Extract the NEAR plane
plane[0] = clipMatrix[ 3] + clipMatrix[ 2]; plane[0] = clipMatrix[ 3] + clipMatrix[ 2];
@ -339,7 +339,7 @@ namespace Nz
plane[2] *= invLength; plane[2] *= invLength;
plane[3] *= -invLength; plane[3] *= -invLength;
m_planes[FrustumPlane_Near].Set(plane); m_planes[FrustumPlane::Near].Set(plane);
// Once planes have been extracted, we must extract points of the frustum // Once planes have been extracted, we must extract points of the frustum
// Based on: http://www.gamedev.net/topic/393309-calculating-the-view-frustums-vertices/ // Based on: http://www.gamedev.net/topic/393309-calculating-the-view-frustums-vertices/
@ -354,56 +354,56 @@ namespace Nz
corner = invClipMatrix.Transform(corner); corner = invClipMatrix.Transform(corner);
corner.Normalize(); corner.Normalize();
m_corners[BoxCorner_FarLeftBottom] = Vector3<T>(corner.x, corner.y, corner.z); m_corners[BoxCorner::FarLeftBottom] = Vector3<T>(corner.x, corner.y, corner.z);
// FarLeftTop // FarLeftTop
corner.Set(T(-1.0), T(1.0), T(1.0)); corner.Set(T(-1.0), T(1.0), T(1.0));
corner = invClipMatrix.Transform(corner); corner = invClipMatrix.Transform(corner);
corner.Normalize(); corner.Normalize();
m_corners[BoxCorner_FarLeftTop] = Vector3<T>(corner.x, corner.y, corner.z); m_corners[BoxCorner::FarLeftTop] = Vector3<T>(corner.x, corner.y, corner.z);
// FarRightBottom // FarRightBottom
corner.Set(T(1.0), T(-1.0), T(1.0)); corner.Set(T(1.0), T(-1.0), T(1.0));
corner = invClipMatrix.Transform(corner); corner = invClipMatrix.Transform(corner);
corner.Normalize(); corner.Normalize();
m_corners[BoxCorner_FarRightBottom] = Vector3<T>(corner.x, corner.y, corner.z); m_corners[BoxCorner::FarRightBottom] = Vector3<T>(corner.x, corner.y, corner.z);
// FarRightTop // FarRightTop
corner.Set(T(1.0), T(1.0), T(1.0)); corner.Set(T(1.0), T(1.0), T(1.0));
corner = invClipMatrix.Transform(corner); corner = invClipMatrix.Transform(corner);
corner.Normalize(); corner.Normalize();
m_corners[BoxCorner_FarRightTop] = Vector3<T>(corner.x, corner.y, corner.z); m_corners[BoxCorner::FarRightTop] = Vector3<T>(corner.x, corner.y, corner.z);
// NearLeftBottom // NearLeftBottom
corner.Set(T(-1.0), T(-1.0), T(0.0)); corner.Set(T(-1.0), T(-1.0), T(0.0));
corner = invClipMatrix.Transform(corner); corner = invClipMatrix.Transform(corner);
corner.Normalize(); corner.Normalize();
m_corners[BoxCorner_NearLeftBottom] = Vector3<T>(corner.x, corner.y, corner.z); m_corners[BoxCorner::NearLeftBottom] = Vector3<T>(corner.x, corner.y, corner.z);
// NearLeftTop // NearLeftTop
corner.Set(T(-1.0), T(1.0), T(0.0)); corner.Set(T(-1.0), T(1.0), T(0.0));
corner = invClipMatrix.Transform(corner); corner = invClipMatrix.Transform(corner);
corner.Normalize(); corner.Normalize();
m_corners[BoxCorner_NearLeftTop] = Vector3<T>(corner.x, corner.y, corner.z); m_corners[BoxCorner::NearLeftTop] = Vector3<T>(corner.x, corner.y, corner.z);
// NearRightBottom // NearRightBottom
corner.Set(T(1.0), T(-1.0), T(0.0)); corner.Set(T(1.0), T(-1.0), T(0.0));
corner = invClipMatrix.Transform(corner); corner = invClipMatrix.Transform(corner);
corner.Normalize(); corner.Normalize();
m_corners[BoxCorner_NearRightBottom] = Vector3<T>(corner.x, corner.y, corner.z); m_corners[BoxCorner::NearRightBottom] = Vector3<T>(corner.x, corner.y, corner.z);
// NearRightTop // NearRightTop
corner.Set(T(1.0), T(1.0), T(0.0)); corner.Set(T(1.0), T(1.0), T(0.0));
corner = invClipMatrix.Transform(corner); corner = invClipMatrix.Transform(corner);
corner.Normalize(); corner.Normalize();
m_corners[BoxCorner_NearRightTop] = Vector3<T>(corner.x, corner.y, corner.z); m_corners[BoxCorner::NearRightTop] = Vector3<T>(corner.x, corner.y, corner.z);
} }
else else
NazaraWarning("Clip matrix is not invertible, failed to compute frustum corners"); NazaraWarning("Clip matrix is not invertible, failed to compute frustum corners");
@ -440,7 +440,7 @@ namespace Nz
const Vector3<T>& Frustum<T>::GetCorner(BoxCorner corner) const const Vector3<T>& Frustum<T>::GetCorner(BoxCorner corner) const
{ {
#ifdef NAZARA_DEBUG #ifdef NAZARA_DEBUG
if (corner > BoxCorner_Max) if (corner > BoxCornerCount)
{ {
NazaraError("Corner not handled (0x" + NumberToString(corner, 16) + ')'); NazaraError("Corner not handled (0x" + NumberToString(corner, 16) + ')');
@ -449,7 +449,7 @@ namespace Nz
} }
#endif #endif
return m_corners[corner]; return m_corners[UnderlyingCast(corner)];
} }
/*! /*!
@ -465,7 +465,7 @@ namespace Nz
const Plane<T>& Frustum<T>::GetPlane(FrustumPlane plane) const const Plane<T>& Frustum<T>::GetPlane(FrustumPlane plane) const
{ {
#ifdef NAZARA_DEBUG #ifdef NAZARA_DEBUG
if (plane > FrustumPlane_Max) if (plane > FrustumPlane::Max)
{ {
NazaraError("Frustum plane not handled (0x" + NumberToString(plane, 16) + ')'); NazaraError("Frustum plane not handled (0x" + NumberToString(plane, 16) + ')');
@ -474,7 +474,7 @@ namespace Nz
} }
#endif #endif
return m_planes[plane]; return m_planes[UnderlyingCast(plane)];
} }
/*! /*!
@ -483,10 +483,10 @@ namespace Nz
* *
* \param volume Volume to check * \param volume Volume to check
* *
* \remark If volume is infinite, IntersectionSide_Intersecting is returned * \remark If volume is infinite, IntersectionSide::Intersecting is returned
* \remark If volume is null, IntersectionSide_Outside is returned * \remark If volume is null, IntersectionSide::Outside is returned
* \remark If enumeration of the volume is not defined in Extend, a NazaraError is thrown and IntersectionSide_Outside is returned * \remark If enumeration of the volume is not defined in Extend, a NazaraError is thrown and IntersectionSide::Outside is returned
* \remark If enumeration of the intersection is not defined in IntersectionSide, a NazaraError is thrown and IntersectionSide_Outside is returned. This should not never happen for a user of the library * \remark If enumeration of the intersection is not defined in IntersectionSide, a NazaraError is thrown and IntersectionSide::Outside is returned. This should not never happen for a user of the library
*/ */
template<typename T> template<typename T>
@ -494,34 +494,34 @@ namespace Nz
{ {
switch (volume.extend) switch (volume.extend)
{ {
case Extend_Finite: case Extend::Finite:
{ {
IntersectionSide side = Intersect(volume.aabb); IntersectionSide side = Intersect(volume.aabb);
switch (side) switch (side)
{ {
case IntersectionSide_Inside: case IntersectionSide::Inside:
return IntersectionSide_Inside; return IntersectionSide::Inside;
case IntersectionSide_Intersecting: case IntersectionSide::Intersecting:
return Intersect(volume.obb); return Intersect(volume.obb);
case IntersectionSide_Outside: case IntersectionSide::Outside:
return IntersectionSide_Outside; return IntersectionSide::Outside;
} }
NazaraError("Invalid intersection side (0x" + NumberToString(side, 16) + ')'); NazaraError("Invalid intersection side (0x" + NumberToString(UnderlyingCast(side), 16) + ')');
return IntersectionSide_Outside; return IntersectionSide::Outside;
} }
case Extend_Infinite: case Extend::Infinite:
return IntersectionSide_Intersecting; // We can not contain infinity return IntersectionSide::Intersecting; // We can not contain infinity
case Extend_Null: case Extend::Null:
return IntersectionSide_Outside; return IntersectionSide::Outside;
} }
NazaraError("Invalid extend type (0x" + NumberToString(volume.extend, 16) + ')'); NazaraError("Invalid extend type (0x" + NumberToString(UnderlyingCast(volume.extend), 16) + ')');
return IntersectionSide_Outside; return IntersectionSide::Outside;
} }
/*! /*!
@ -535,14 +535,14 @@ namespace Nz
IntersectionSide Frustum<T>::Intersect(const Box<T>& box) const IntersectionSide Frustum<T>::Intersect(const Box<T>& box) const
{ {
// http://www.lighthouse3d.com/tutorials/view-frustum-culling/geometric-approach-testing-boxes-ii/ // http://www.lighthouse3d.com/tutorials/view-frustum-culling/geometric-approach-testing-boxes-ii/
IntersectionSide side = IntersectionSide_Inside; IntersectionSide side = IntersectionSide::Inside;
for (unsigned int i = 0; i <= FrustumPlane_Max; i++) for (std::size_t i = 0; i < FrustumPlaneCount; i++)
{ {
if (m_planes[i].Distance(box.GetPositiveVertex(m_planes[i].normal)) < T(0.0)) if (m_planes[i].Distance(box.GetPositiveVertex(m_planes[i].normal)) < T(0.0))
return IntersectionSide_Outside; return IntersectionSide::Outside;
else if (m_planes[i].Distance(box.GetNegativeVertex(m_planes[i].normal)) < T(0.0)) else if (m_planes[i].Distance(box.GetNegativeVertex(m_planes[i].normal)) < T(0.0))
side = IntersectionSide_Intersecting; side = IntersectionSide::Intersecting;
} }
return side; return side;
@ -572,15 +572,15 @@ namespace Nz
IntersectionSide Frustum<T>::Intersect(const Sphere<T>& sphere) const IntersectionSide Frustum<T>::Intersect(const Sphere<T>& sphere) const
{ {
// http://www.lighthouse3d.com/tutorials/view-frustum-culling/geometric-approach-testing-points-and-spheres/ // http://www.lighthouse3d.com/tutorials/view-frustum-culling/geometric-approach-testing-points-and-spheres/
IntersectionSide side = IntersectionSide_Inside; IntersectionSide side = IntersectionSide::Inside;
for (unsigned int i = 0; i <= FrustumPlane_Max; i++) for (std::size_t i = 0; i < FrustumPlaneCount; i++)
{ {
T distance = m_planes[i].Distance(sphere.GetPosition()); T distance = m_planes[i].Distance(sphere.GetPosition());
if (distance < -sphere.radius) if (distance < -sphere.radius)
return IntersectionSide_Outside; return IntersectionSide::Outside;
else if (distance < sphere.radius) else if (distance < sphere.radius)
side = IntersectionSide_Intersecting; side = IntersectionSide::Intersecting;
} }
return side; return side;
@ -595,13 +595,13 @@ namespace Nz
*/ */
template<typename T> template<typename T>
IntersectionSide Frustum<T>::Intersect(const Vector3<T>* points, unsigned int pointCount) const IntersectionSide Frustum<T>::Intersect(const Vector3<T>* points, std::size_t pointCount) const
{ {
unsigned int c = 0; std::size_t c = 0;
for (unsigned int i = 0; i <= FrustumPlane_Max; ++i) for (std::size_t i = 0; i < FrustumPlaneCount; ++i)
{ {
unsigned int j; std::size_t j;
for (j = 0; j < pointCount; j++ ) for (j = 0; j < pointCount; j++ )
{ {
if (m_planes[i].Distance(points[j]) > T(0.0)) if (m_planes[i].Distance(points[j]) > T(0.0))
@ -609,12 +609,12 @@ namespace Nz
} }
if (j == pointCount) if (j == pointCount)
return IntersectionSide_Outside; return IntersectionSide::Outside;
else else
c++; c++;
} }
return (c == 6) ? IntersectionSide_Inside : IntersectionSide_Intersecting; return (c == 6) ? IntersectionSide::Inside : IntersectionSide::Intersecting;
} }
/*! /*!
@ -628,10 +628,10 @@ namespace Nz
template<typename U> template<typename U>
Frustum<T>& Frustum<T>::Set(const Frustum<U>& frustum) Frustum<T>& Frustum<T>::Set(const Frustum<U>& frustum)
{ {
for (unsigned int i = 0; i <= BoxCorner_Max; ++i) for (unsigned int i = 0; i < BoxCornerCount; ++i)
m_corners[i].Set(frustum.m_corners[i]); m_corners[i].Set(frustum.m_corners[i]);
for (unsigned int i = 0; i <= FrustumPlane_Max; ++i) for (unsigned int i = 0; i < FrustumPlaneCount; ++i)
m_planes[i].Set(frustum.m_planes[i]); m_planes[i].Set(frustum.m_planes[i]);
return *this; return *this;
@ -661,13 +661,13 @@ namespace Nz
template<typename T> template<typename T>
bool Serialize(SerializationContext& context, const Frustum<T>& frustum, TypeTag<Frustum<T>>) bool Serialize(SerializationContext& context, const Frustum<T>& frustum, TypeTag<Frustum<T>>)
{ {
for (unsigned int i = 0; i <= BoxCorner_Max; ++i) for (unsigned int i = 0; i < BoxCornerCount; ++i)
{ {
if (!Serialize(context, frustum.m_corners[i])) if (!Serialize(context, frustum.m_corners[i]))
return false; return false;
} }
for (unsigned int i = 0; i <= FrustumPlane_Max; ++i) for (unsigned int i = 0; i < FrustumPlaneCount; ++i)
{ {
if (!Serialize(context, frustum.m_planes[i])) if (!Serialize(context, frustum.m_planes[i]))
return false; return false;
@ -686,13 +686,13 @@ namespace Nz
template<typename T> template<typename T>
bool Unserialize(SerializationContext& context, Frustum<T>* frustum, TypeTag<Frustum<T>>) bool Unserialize(SerializationContext& context, Frustum<T>* frustum, TypeTag<Frustum<T>>)
{ {
for (unsigned int i = 0; i <= BoxCorner_Max; ++i) for (unsigned int i = 0; i < BoxCornerCount; ++i)
{ {
if (!Unserialize(context, &frustum->m_corners[i])) if (!Unserialize(context, &frustum->m_corners[i]))
return false; return false;
} }
for (unsigned int i = 0; i <= FrustumPlane_Max; ++i) for (unsigned int i = 0; i < FrustumPlaneCount; ++i)
{ {
if (!Unserialize(context, &frustum->m_planes[i])) if (!Unserialize(context, &frustum->m_planes[i]))
return false; return false;
@ -713,12 +713,12 @@ namespace Nz
template<typename T> template<typename T>
std::ostream& operator<<(std::ostream& out, const Nz::Frustum<T>& frustum) std::ostream& operator<<(std::ostream& out, const Nz::Frustum<T>& frustum)
{ {
return out << "Frustum(Bottom: " << frustum.GetPlane(Nz::FrustumPlane_Bottom) << ",\n" return out << "Frustum(Bottom: " << frustum.GetPlane(Nz::FrustumPlane::Bottom) << ",\n"
<< " Far: " << frustum.GetPlane(Nz::FrustumPlane_Far) << ",\n" << " Far: " << frustum.GetPlane(Nz::FrustumPlane::Far) << ",\n"
<< " Left: " << frustum.GetPlane(Nz::FrustumPlane_Left) << ",\n" << " Left: " << frustum.GetPlane(Nz::FrustumPlane::Left) << ",\n"
<< " Near: " << frustum.GetPlane(Nz::FrustumPlane_Near) << ",\n" << " Near: " << frustum.GetPlane(Nz::FrustumPlane::Near) << ",\n"
<< " Right: " << frustum.GetPlane(Nz::FrustumPlane_Right) << ",\n" << " Right: " << frustum.GetPlane(Nz::FrustumPlane::Right) << ",\n"
<< " Top: " << frustum.GetPlane(Nz::FrustumPlane_Top) << ")\n"; << " Top: " << frustum.GetPlane(Nz::FrustumPlane::Top) << ")\n";
} }
#include <Nazara/Core/DebugOff.hpp> #include <Nazara/Core/DebugOff.hpp>

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

@ -63,7 +63,7 @@ namespace Nz
Box<T> localBox; Box<T> localBox;
private: private:
Vector3<T> m_corners[BoxCorner_Max+1]; // Ne peuvent pas être modifiés directement Vector3<T> m_corners[BoxCornerCount];
}; };
using OrientedBoxd = OrientedBox<double>; using OrientedBoxd = OrientedBox<double>;

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

@ -89,7 +89,7 @@ namespace Nz
const Vector3<T>& OrientedBox<T>::GetCorner(BoxCorner corner) const const Vector3<T>& OrientedBox<T>::GetCorner(BoxCorner corner) const
{ {
#ifdef NAZARA_DEBUG #ifdef NAZARA_DEBUG
if (corner > BoxCorner_Max) if (corner > BoxCornerCount)
{ {
NazaraError("Corner not handled (0x" + NumberToString(corner, 16) + ')'); NazaraError("Corner not handled (0x" + NumberToString(corner, 16) + ')');
@ -98,7 +98,7 @@ namespace Nz
} }
#endif #endif
return m_corners[corner]; return m_corners[UnderlyingCast(corner)];
} }
template<typename T> template<typename T>
@ -195,7 +195,7 @@ namespace Nz
template<typename U> template<typename U>
OrientedBox<T>& OrientedBox<T>::Set(const OrientedBox<U>& orientedBox) OrientedBox<T>& OrientedBox<T>::Set(const OrientedBox<U>& orientedBox)
{ {
for (unsigned int i = 0; i <= BoxCorner_Max; ++i) for (unsigned int i = 0; i < BoxCornerCount; ++i)
m_corners[i].Set(orientedBox(i)); m_corners[i].Set(orientedBox(i));
localBox.Set(orientedBox.localBox); localBox.Set(orientedBox.localBox);
@ -226,7 +226,7 @@ namespace Nz
template<typename T> template<typename T>
void OrientedBox<T>::Update(const Matrix4<T>& transformMatrix) void OrientedBox<T>::Update(const Matrix4<T>& transformMatrix)
{ {
for (unsigned int i = 0; i <= BoxCorner_Max; ++i) for (unsigned int i = 0; i < BoxCornerCount; ++i)
m_corners[i] = transformMatrix.Transform(localBox.GetCorner(static_cast<BoxCorner>(i))); m_corners[i] = transformMatrix.Transform(localBox.GetCorner(static_cast<BoxCorner>(i)));
} }
@ -239,7 +239,7 @@ namespace Nz
template<typename T> template<typename T>
void OrientedBox<T>::Update(const Vector3<T>& translation) void OrientedBox<T>::Update(const Vector3<T>& translation)
{ {
for (unsigned int i = 0; i <= BoxCorner_Max; ++i) for (unsigned int i = 0; i < BoxCornerCount; ++i)
m_corners[i] = localBox.GetCorner(static_cast<BoxCorner>(i)) + translation; m_corners[i] = localBox.GetCorner(static_cast<BoxCorner>(i)) + translation;
} }
@ -247,18 +247,18 @@ namespace Nz
* \brief Gets the ith corner of the oriented box * \brief Gets the ith corner of the oriented box
* \return A reference to this corner * \return A reference to this corner
* *
* \remark Produce a NazaraError if you try to access to index greather than BoxCorner_Max with NAZARA_MATH_SAFE defined. If not, it is undefined behaviour * \remark Produce a NazaraError if you try to access to index greather than BoxCorner::Max with NAZARA_MATH_SAFE defined. If not, it is undefined behaviour
* \throw std::out_of_range if NAZARA_MATH_SAFE is defined and you try to acces to index greather than BoxCorner_Max * \throw std::out_of_range if NAZARA_MATH_SAFE is defined and you try to acces to index greather than BoxCorner::Max
*/ */
template<typename T> template<typename T>
Vector3<T>& OrientedBox<T>::operator()(unsigned int i) Vector3<T>& OrientedBox<T>::operator()(unsigned int i)
{ {
#if NAZARA_MATH_SAFE #if NAZARA_MATH_SAFE
if (i > BoxCorner_Max) if (i > BoxCornerCount)
{ {
std::ostringstream ss; std::ostringstream ss;
ss << "Index out of range: (" << i << " >= " << BoxCorner_Max << ")"; ss << "Index out of range: (" << i << " >= " << BoxCornerCount << ")";
NazaraError(ss.str()); NazaraError(ss.str());
throw std::out_of_range(ss.str()); throw std::out_of_range(ss.str());
@ -272,18 +272,18 @@ namespace Nz
* \brief Gets the ith corner of the oriented box * \brief Gets the ith corner of the oriented box
* \return A reference to this corner * \return A reference to this corner
* *
* \remark Produce a NazaraError if you try to access to index greather than BoxCorner_Max with NAZARA_MATH_SAFE defined. If not, it is undefined behaviour * \remark Produce a NazaraError if you try to access to index greather than BoxCorner::Max with NAZARA_MATH_SAFE defined. If not, it is undefined behaviour
* \throw std::out_of_range if NAZARA_MATH_SAFE is defined and you try to acces to index greather than BoxCorner_Max * \throw std::out_of_range if NAZARA_MATH_SAFE is defined and you try to acces to index greather than BoxCorner::Max
*/ */
template<typename T> template<typename T>
Vector3<T> OrientedBox<T>::operator()(unsigned int i) const Vector3<T> OrientedBox<T>::operator()(unsigned int i) const
{ {
#if NAZARA_MATH_SAFE #if NAZARA_MATH_SAFE
if (i > BoxCorner_Max) if (i > BoxCornerCount)
{ {
std::ostringstream ss; std::ostringstream ss;
ss << "Index out of range: (" << i << " >= " << BoxCorner_Max << ")"; ss << "Index out of range: (" << i << " >= " << BoxCornerCount << ")";
NazaraError(ss.str()); NazaraError(ss.str());
throw std::out_of_range(ss.str()); throw std::out_of_range(ss.str());
@ -437,14 +437,14 @@ namespace Nz
template<typename T> template<typename T>
std::ostream& operator<<(std::ostream& out, const Nz::OrientedBox<T>& orientedBox) std::ostream& operator<<(std::ostream& out, const Nz::OrientedBox<T>& orientedBox)
{ {
return out << "OrientedBox(FLB: " << orientedBox.GetCorner(Nz::BoxCorner_FarLeftBottom) << ",\n" return out << "OrientedBox(FLB: " << orientedBox.GetCorner(Nz::BoxCorner::FarLeftBottom) << ",\n"
<< " FLT: " << orientedBox.GetCorner(Nz::BoxCorner_FarLeftTop) << ",\n" << " FLT: " << orientedBox.GetCorner(Nz::BoxCorner::FarLeftTop) << ",\n"
<< " FRB: " << orientedBox.GetCorner(Nz::BoxCorner_FarRightBottom) << ",\n" << " FRB: " << orientedBox.GetCorner(Nz::BoxCorner::FarRightBottom) << ",\n"
<< " FRT: " << orientedBox.GetCorner(Nz::BoxCorner_FarRightTop) << ",\n" << " FRT: " << orientedBox.GetCorner(Nz::BoxCorner::FarRightTop) << ",\n"
<< " NLB: " << orientedBox.GetCorner(Nz::BoxCorner_NearLeftBottom) << ",\n" << " NLB: " << orientedBox.GetCorner(Nz::BoxCorner::NearLeftBottom) << ",\n"
<< " NLT: " << orientedBox.GetCorner(Nz::BoxCorner_NearLeftTop) << ",\n" << " NLT: " << orientedBox.GetCorner(Nz::BoxCorner::NearLeftTop) << ",\n"
<< " NRB: " << orientedBox.GetCorner(Nz::BoxCorner_NearRightBottom) << ",\n" << " NRB: " << orientedBox.GetCorner(Nz::BoxCorner::NearRightBottom) << ",\n"
<< " NRT: " << orientedBox.GetCorner(Nz::BoxCorner_NearRightTop) << ")\n"; << " NRT: " << orientedBox.GetCorner(Nz::BoxCorner::NearRightTop) << ")\n";
} }
#include <Nazara/Core/DebugOff.hpp> #include <Nazara/Core/DebugOff.hpp>

22
include/Nazara/Math/Ray.inl
View File

@ -141,8 +141,8 @@ namespace Nz
* \param closestHit Optional argument to get the closest parameter where the intersection is only if it happened * \param closestHit Optional argument to get the closest parameter where the intersection is only if it happened
* \param furthestHit Optional argument to get the furthest parameter where the intersection is only if it happened * \param furthestHit Optional argument to get the furthest parameter where the intersection is only if it happened
* *
* \remark If BoundingVolume is Extend_Infinite, then closestHit and furthestHit are equal to 0 et infinity * \remark If BoundingVolume is Extend::Infinite, then closestHit and furthestHit are equal to 0 et infinity
* \remark If BoundingVolume is Extend_Null, then closestHit and furthestHit are unchanged * \remark If BoundingVolume is Extend::Null, then closestHit and furthestHit are unchanged
* \remark If enumeration of BoundingVolume is not defined in Extend, a NazaraError is thrown and closestHit and furthestHit are unchanged * \remark If enumeration of BoundingVolume is not defined in Extend, a NazaraError is thrown and closestHit and furthestHit are unchanged
* *
* \see Intersect * \see Intersect
@ -153,7 +153,7 @@ namespace Nz
{ {
switch (volume.extend) switch (volume.extend)
{ {
case Extend_Finite: case Extend::Finite:
{ {
if (Intersect(volume.aabb)) if (Intersect(volume.aabb))
return Intersect(volume.obb, closestHit, furthestHit); return Intersect(volume.obb, closestHit, furthestHit);
@ -161,7 +161,7 @@ namespace Nz
return false; return false;
} }
case Extend_Infinite: case Extend::Infinite:
{ {
if (closestHit) if (closestHit)
*closestHit = T(0.0); *closestHit = T(0.0);
@ -172,11 +172,11 @@ namespace Nz
return true; return true;
} }
case Extend_Null: case Extend::Null:
return false; return false;
} }
NazaraError("Invalid extend type (0x" + NumberToString(volume.extend, 16) + ')'); NazaraError("Invalid extend type (0x" + NumberToString(UnderlyingCast(volume.extend), 16) + ')');
return false; return false;
} }
@ -321,12 +321,12 @@ namespace Nz
template<typename T> template<typename T>
bool Ray<T>::Intersect(const OrientedBox<T>& orientedBox, T* closestHit, T* furthestHit) const bool Ray<T>::Intersect(const OrientedBox<T>& orientedBox, T* closestHit, T* furthestHit) const
{ {
Vector3<T> corner = orientedBox.GetCorner(BoxCorner_FarLeftBottom); Vector3<T> corner = orientedBox.GetCorner(BoxCorner::FarLeftBottom);
Vector3<T> oppositeCorner = orientedBox.GetCorner(BoxCorner_NearRightTop); Vector3<T> oppositeCorner = orientedBox.GetCorner(BoxCorner::NearRightTop);
Vector3<T> width = (orientedBox.GetCorner(BoxCorner_NearLeftBottom) - corner); Vector3<T> width = (orientedBox.GetCorner(BoxCorner::NearLeftBottom) - corner);
Vector3<T> height = (orientedBox.GetCorner(BoxCorner_FarLeftTop) - corner); Vector3<T> height = (orientedBox.GetCorner(BoxCorner::FarLeftTop) - corner);
Vector3<T> depth = (orientedBox.GetCorner(BoxCorner_FarRightBottom) - corner); Vector3<T> depth = (orientedBox.GetCorner(BoxCorner::FarRightBottom) - corner);
// Construction de la matrice de transformation de l'OBB // Construction de la matrice de transformation de l'OBB
Matrix4<T> matrix(width.x, height.x, depth.x, corner.x, Matrix4<T> matrix(width.x, height.x, depth.x, corner.x,

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

@ -239,20 +239,20 @@ namespace Nz
{ {
switch (corner) switch (corner)
{ {
case RectCorner_LeftBottom: case RectCorner::LeftBottom:
return Vector2<T>(x, y + height); return Vector2<T>(x, y + height);
case RectCorner_LeftTop: case RectCorner::LeftTop:
return Vector2<T>(x, y); return Vector2<T>(x, y);
case RectCorner_RightBottom: case RectCorner::RightBottom:
return Vector2<T>(x + width, y + height); return Vector2<T>(x + width, y + height);
case RectCorner_RightTop: case RectCorner::RightTop:
return Vector2<T>(x + width, y); return Vector2<T>(x + width, y);
} }
NazaraError("Corner not handled (0x" + NumberToString(corner, 16) + ')'); NazaraError("Corner not handled (0x" + NumberToString(UnderlyingCast(corner), 16) + ')');
return Vector2<T>(); return Vector2<T>();
} }
@ -269,7 +269,7 @@ namespace Nz
/*! /*!
* \brief Gets a Vector2 for the maximum point * \brief Gets a Vector2 for the maximum point
* \return The RectCorner_RightBottom of the rectangle * \return The RectCorner::RightBottom of the rectangle
* *
* \see GetCorner * \see GetCorner
*/ */
@ -282,7 +282,7 @@ namespace Nz
/*! /*!
* \brief Gets a Vector2 for the minimum point * \brief Gets a Vector2 for the minimum point
* \return The RectCorner_LeftTop of the rectangle * \return The RectCorner::LeftTop of the rectangle
* *
* \see GetCorner, GetPosition * \see GetCorner, GetPosition
*/ */
@ -318,7 +318,7 @@ namespace Nz
/*! /*!
* \brief Gets a Vector2 for the position * \brief Gets a Vector2 for the position
* \return The RectCorner_LeftTop of the rectangle * \return The RectCorner::LeftTop of the rectangle
* *
* \see GetCorner, GetMinimum * \see GetCorner, GetMinimum
*/ */

24
include/Nazara/Utility/Algorithm.hpp
View File

@ -42,14 +42,14 @@ namespace Nz
SparsePtr<Vector2f> uvPtr; SparsePtr<Vector2f> uvPtr;
}; };
NAZARA_UTILITY_API Boxf ComputeAABB(SparsePtr<const Vector3f> positionPtr, unsigned int vertexCount); NAZARA_UTILITY_API Boxf ComputeAABB(SparsePtr<const Vector3f> positionPtr, std::size_t vertexCount);
NAZARA_UTILITY_API void ComputeBoxIndexVertexCount(const Vector3ui& subdivision, unsigned int* indexCount, unsigned int* vertexCount); NAZARA_UTILITY_API void ComputeBoxIndexVertexCount(const Vector3ui& subdivision, std::size_t* indexCount, std::size_t* vertexCount);
NAZARA_UTILITY_API unsigned int ComputeCacheMissCount(IndexIterator indices, unsigned int indexCount); NAZARA_UTILITY_API unsigned int ComputeCacheMissCount(IndexIterator indices, std::size_t indexCount);
NAZARA_UTILITY_API void ComputeConeIndexVertexCount(unsigned int subdivision, unsigned int* indexCount, unsigned int* vertexCount); NAZARA_UTILITY_API void ComputeConeIndexVertexCount(unsigned int subdivision, std::size_t* indexCount, std::size_t* vertexCount);
NAZARA_UTILITY_API void ComputeCubicSphereIndexVertexCount(unsigned int subdivision, unsigned int* indexCount, unsigned int* vertexCount); NAZARA_UTILITY_API void ComputeCubicSphereIndexVertexCount(unsigned int subdivision, std::size_t* indexCount, std::size_t* vertexCount);
NAZARA_UTILITY_API void ComputeIcoSphereIndexVertexCount(unsigned int recursionLevel, unsigned int* indexCount, unsigned int* vertexCount); NAZARA_UTILITY_API void ComputeIcoSphereIndexVertexCount(unsigned int recursionLevel, std::size_t* indexCount, std::size_t* vertexCount);
NAZARA_UTILITY_API void ComputePlaneIndexVertexCount(const Vector2ui& subdivision, unsigned int* indexCount, unsigned int* vertexCount); NAZARA_UTILITY_API void ComputePlaneIndexVertexCount(const Vector2ui& subdivision, std::size_t* indexCount, std::size_t* vertexCount);
NAZARA_UTILITY_API void ComputeUvSphereIndexVertexCount(unsigned int sliceCount, unsigned int stackCount, unsigned int* indexCount, unsigned int* vertexCount); NAZARA_UTILITY_API void ComputeUvSphereIndexVertexCount(unsigned int sliceCount, unsigned int stackCount, std::size_t* indexCount, std::size_t* vertexCount);
NAZARA_UTILITY_API void GenerateBox(const Vector3f& lengths, const Vector3ui& subdivision, const Matrix4f& matrix, const Rectf& textureCoords, VertexPointers vertexPointers, IndexIterator indices, Boxf* aabb = nullptr, unsigned int indexOffset = 0); NAZARA_UTILITY_API void GenerateBox(const Vector3f& lengths, const Vector3ui& subdivision, const Matrix4f& matrix, const Rectf& textureCoords, VertexPointers vertexPointers, IndexIterator indices, Boxf* aabb = nullptr, unsigned int indexOffset = 0);
NAZARA_UTILITY_API void GenerateCone(float length, float radius, unsigned int subdivision, const Matrix4f& matrix, const Rectf& textureCoords, VertexPointers vertexPointers, IndexIterator indices, Boxf* aabb = nullptr, unsigned int indexOffset = 0); NAZARA_UTILITY_API void GenerateCone(float length, float radius, unsigned int subdivision, const Matrix4f& matrix, const Rectf& textureCoords, VertexPointers vertexPointers, IndexIterator indices, Boxf* aabb = nullptr, unsigned int indexOffset = 0);
@ -60,11 +60,11 @@ namespace Nz
NAZARA_UTILITY_API void OptimizeIndices(IndexIterator indices, unsigned int indexCount); NAZARA_UTILITY_API void OptimizeIndices(IndexIterator indices, unsigned int indexCount);
NAZARA_UTILITY_API void SkinPosition(const SkinningData& data, unsigned int startVertex, unsigned int vertexCount); NAZARA_UTILITY_API void SkinPosition(const SkinningData& data, std::size_t startVertex, std::size_t vertexCount);
NAZARA_UTILITY_API void SkinPositionNormal(const SkinningData& data, unsigned int startVertex, unsigned int vertexCount); NAZARA_UTILITY_API void SkinPositionNormal(const SkinningData& data, std::size_t startVertex, std::size_t vertexCount);
NAZARA_UTILITY_API void SkinPositionNormalTangent(const SkinningData& data, unsigned int startVertex, unsigned int vertexCount); NAZARA_UTILITY_API void SkinPositionNormalTangent(const SkinningData& data, std::size_t startVertex, std::size_t vertexCount);
NAZARA_UTILITY_API void TransformVertices(VertexPointers vertexPointers, unsigned int vertexCount, const Matrix4f& matrix); NAZARA_UTILITY_API void TransformVertices(VertexPointers vertexPointers, std::size_t vertexCount, const Matrix4f& matrix);
template<typename T> constexpr ComponentType ComponentTypeId(); template<typename T> constexpr ComponentType ComponentTypeId();
template<typename T> constexpr ComponentType GetComponentTypeOf(); template<typename T> constexpr ComponentType GetComponentTypeOf();

4
src/Nazara/Shader/GlslWriter.cpp
View File

@ -46,12 +46,12 @@ namespace Nz
currentFunction->calledFunctions.UnboundedSet(std::get<std::size_t>(node.targetFunction)); currentFunction->calledFunctions.UnboundedSet(std::get<std::size_t>(node.targetFunction));
} }
void Visit(ShaderAst::ConditionalExpression& node) override void Visit(ShaderAst::ConditionalExpression& /*node*/) override
{ {
throw std::runtime_error("unexpected conditional expression, is shader sanitized?"); throw std::runtime_error("unexpected conditional expression, is shader sanitized?");
} }
void Visit(ShaderAst::ConditionalStatement& node) override void Visit(ShaderAst::ConditionalStatement& /*node*/) override
{ {
throw std::runtime_error("unexpected conditional statement, is shader sanitized?"); throw std::runtime_error("unexpected conditional statement, is shader sanitized?");
} }

2
src/Nazara/Shader/LangWriter.cpp
View File

@ -94,7 +94,7 @@ namespace Nz
unsigned int indentLevel = 0; unsigned int indentLevel = 0;
}; };
std::string LangWriter::Generate(ShaderAst::Statement& shader, const States& states) std::string LangWriter::Generate(ShaderAst::Statement& shader, const States& /*states*/)
{ {
State state; State state;
m_currentState = &state; m_currentState = &state;

38
src/Nazara/Utility/AlgorithmUtility.cpp
View File

@ -634,7 +634,7 @@ namespace Nz
/**********************************Compute**********************************/ /**********************************Compute**********************************/
Boxf ComputeAABB(SparsePtr<const Vector3f> positionPtr, unsigned int vertexCount) Boxf ComputeAABB(SparsePtr<const Vector3f> positionPtr, std::size_t vertexCount)
{ {
Boxf aabb; Boxf aabb;
if (vertexCount > 0) if (vertexCount > 0)
@ -651,10 +651,10 @@ namespace Nz
return aabb; return aabb;
} }
void ComputeBoxIndexVertexCount(const Vector3ui& subdivision, unsigned int* indexCount, unsigned int* vertexCount) void ComputeBoxIndexVertexCount(const Vector3ui& subdivision, std::size_t* indexCount, std::size_t* vertexCount)
{ {
unsigned int xIndexCount, yIndexCount, zIndexCount; std::size_t xIndexCount, yIndexCount, zIndexCount;
unsigned int xVertexCount, yVertexCount, zVertexCount; std::size_t xVertexCount, yVertexCount, zVertexCount;
ComputePlaneIndexVertexCount(Vector2ui(subdivision.y, subdivision.z), &xIndexCount, &xVertexCount); ComputePlaneIndexVertexCount(Vector2ui(subdivision.y, subdivision.z), &xIndexCount, &xVertexCount);
ComputePlaneIndexVertexCount(Vector2ui(subdivision.x, subdivision.z), &yIndexCount, &yVertexCount); ComputePlaneIndexVertexCount(Vector2ui(subdivision.x, subdivision.z), &yIndexCount, &yVertexCount);
@ -667,13 +667,13 @@ namespace Nz
*vertexCount = xVertexCount*2 + yVertexCount*2 + zVertexCount*2; *vertexCount = xVertexCount*2 + yVertexCount*2 + zVertexCount*2;
} }
unsigned int ComputeCacheMissCount(IndexIterator indices, unsigned int indexCount) unsigned int ComputeCacheMissCount(IndexIterator indices, std::size_t indexCount)
{ {
VertexCache cache(indices, indexCount); VertexCache cache(indices, indexCount);
return cache.GetMissCount(); return cache.GetMissCount();
} }
void ComputeConeIndexVertexCount(unsigned int subdivision, unsigned int* indexCount, unsigned int* vertexCount) void ComputeConeIndexVertexCount(unsigned int subdivision, std::size_t* indexCount, std::size_t* vertexCount)
{ {
if (indexCount) if (indexCount)
*indexCount = (subdivision-1)*6; *indexCount = (subdivision-1)*6;
@ -682,7 +682,7 @@ namespace Nz
*vertexCount = subdivision + 2; *vertexCount = subdivision + 2;
} }
void ComputeCubicSphereIndexVertexCount(unsigned int subdivision, unsigned int* indexCount, unsigned int* vertexCount) void ComputeCubicSphereIndexVertexCount(unsigned int subdivision, std::size_t* indexCount, std::size_t* vertexCount)
{ {
// Comme tous nos plans sont identiques, on peut optimiser un peu // Comme tous nos plans sont identiques, on peut optimiser un peu
ComputePlaneIndexVertexCount(Vector2ui(subdivision), indexCount, vertexCount); ComputePlaneIndexVertexCount(Vector2ui(subdivision), indexCount, vertexCount);
@ -694,7 +694,7 @@ namespace Nz
*vertexCount *= 6; *vertexCount *= 6;
} }
void ComputeIcoSphereIndexVertexCount(unsigned int recursionLevel, unsigned int* indexCount, unsigned int* vertexCount) void ComputeIcoSphereIndexVertexCount(unsigned int recursionLevel, std::size_t* indexCount, std::size_t* vertexCount)
{ {
if (indexCount) if (indexCount)
*indexCount = 3 * 20 * IntegralPow(4, recursionLevel); *indexCount = 3 * 20 * IntegralPow(4, recursionLevel);
@ -703,7 +703,7 @@ namespace Nz
*vertexCount = IntegralPow(4, recursionLevel)*10 + 2; *vertexCount = IntegralPow(4, recursionLevel)*10 + 2;
} }
void ComputePlaneIndexVertexCount(const Vector2ui& subdivision, unsigned int* indexCount, unsigned int* vertexCount) void ComputePlaneIndexVertexCount(const Vector2ui& subdivision, std::size_t* indexCount, std::size_t* vertexCount)
{ {
// Le nombre de faces appartenant à un axe est équivalent à 2 exposant la subdivision (1,2,4,8,16,32,...) // Le nombre de faces appartenant à un axe est équivalent à 2 exposant la subdivision (1,2,4,8,16,32,...)
unsigned int horizontalFaceCount = (1 << subdivision.x); unsigned int horizontalFaceCount = (1 << subdivision.x);
@ -720,7 +720,7 @@ namespace Nz
*vertexCount = horizontalVertexCount*verticalVertexCount; *vertexCount = horizontalVertexCount*verticalVertexCount;
} }
void ComputeUvSphereIndexVertexCount(unsigned int sliceCount, unsigned int stackCount, unsigned int* indexCount, unsigned int* vertexCount) void ComputeUvSphereIndexVertexCount(unsigned int sliceCount, unsigned int stackCount, std::size_t* indexCount, std::size_t* vertexCount)
{ {
if (indexCount) if (indexCount)
*indexCount = (sliceCount-1) * (stackCount-1) * 6; *indexCount = (sliceCount-1) * (stackCount-1) * 6;
@ -733,8 +733,8 @@ namespace Nz
void GenerateBox(const Vector3f& lengths, const Vector3ui& subdivision, const Matrix4f& matrix, const Rectf& textureCoords, VertexPointers vertexPointers, IndexIterator indices, Boxf* aabb, unsigned int indexOffset) void GenerateBox(const Vector3f& lengths, const Vector3ui& subdivision, const Matrix4f& matrix, const Rectf& textureCoords, VertexPointers vertexPointers, IndexIterator indices, Boxf* aabb, unsigned int indexOffset)
{ {
unsigned int xIndexCount, yIndexCount, zIndexCount; std::size_t xIndexCount, yIndexCount, zIndexCount;
unsigned int xVertexCount, yVertexCount, zVertexCount; std::size_t xVertexCount, yVertexCount, zVertexCount;
ComputePlaneIndexVertexCount(Vector2ui(subdivision.y, subdivision.z), &xIndexCount, &xVertexCount); ComputePlaneIndexVertexCount(Vector2ui(subdivision.y, subdivision.z), &xIndexCount, &xVertexCount);
ComputePlaneIndexVertexCount(Vector2ui(subdivision.x, subdivision.z), &yIndexCount, &yVertexCount); ComputePlaneIndexVertexCount(Vector2ui(subdivision.x, subdivision.z), &yIndexCount, &yVertexCount);
@ -901,7 +901,7 @@ namespace Nz
void GenerateCubicSphere(float size, unsigned int subdivision, const Matrix4f& matrix, const Rectf& textureCoords, VertexPointers vertexPointers, IndexIterator indices, Boxf* aabb, unsigned int indexOffset) void GenerateCubicSphere(float size, unsigned int subdivision, const Matrix4f& matrix, const Rectf& textureCoords, VertexPointers vertexPointers, IndexIterator indices, Boxf* aabb, unsigned int indexOffset)
{ {
///DOC: Cette fonction va accéder aux pointeurs en écriture ET en lecture ///DOC: Cette fonction va accéder aux pointeurs en écriture ET en lecture
unsigned int vertexCount; std::size_t vertexCount;
ComputeBoxIndexVertexCount(Vector3ui(subdivision), nullptr, &vertexCount); ComputeBoxIndexVertexCount(Vector3ui(subdivision), nullptr, &vertexCount);
// On envoie une matrice identité de sorte à ce que la boîte ne subisse aucune transformation (rendant plus facile l'étape suivante) // On envoie une matrice identité de sorte à ce que la boîte ne subisse aucune transformation (rendant plus facile l'étape suivante)
@ -1057,12 +1057,12 @@ namespace Nz
const SkeletalMeshVertex* inputVertex = &skinningInfos.inputVertex[startVertex]; const SkeletalMeshVertex* inputVertex = &skinningInfos.inputVertex[startVertex];
MeshVertex* outputVertex = &skinningInfos.outputVertex[startVertex]; MeshVertex* outputVertex = &skinningInfos.outputVertex[startVertex];
unsigned int endVertex = startVertex + vertexCount - 1; std::size_t endVertex = startVertex + vertexCount - 1;
for (unsigned int i = startVertex; i <= endVertex; ++i) for (std::size_t i = startVertex; i <= endVertex; ++i)
{ {
Vector3f finalPosition(Vector3f::Zero()); Vector3f finalPosition(Vector3f::Zero());
for (int j = 0; j < inputVertex->weightCount; ++j) for (Int32 j = 0; j < inputVertex->weightCount; ++j)
{ {
Matrix4f mat(skinningInfos.joints[inputVertex->jointIndexes[j]].GetSkinningMatrix()); Matrix4f mat(skinningInfos.joints[inputVertex->jointIndexes[j]].GetSkinningMatrix());
mat *= inputVertex->weights[j]; mat *= inputVertex->weights[j];
@ -1083,13 +1083,13 @@ namespace Nz
const SkeletalMeshVertex* inputVertex = &skinningInfos.inputVertex[startVertex]; const SkeletalMeshVertex* inputVertex = &skinningInfos.inputVertex[startVertex];
MeshVertex* outputVertex = &skinningInfos.outputVertex[startVertex]; MeshVertex* outputVertex = &skinningInfos.outputVertex[startVertex];
unsigned int endVertex = startVertex + vertexCount - 1; std::size_t endVertex = startVertex + vertexCount - 1;
for (unsigned int i = startVertex; i <= endVertex; ++i) for (std::size_t i = startVertex; i <= endVertex; ++i)
{ {
Vector3f finalPosition(Vector3f::Zero()); Vector3f finalPosition(Vector3f::Zero());
Vector3f finalNormal(Vector3f::Zero()); Vector3f finalNormal(Vector3f::Zero());
for (int j = 0; j < inputVertex->weightCount; ++j) for (Int32 j = 0; j < inputVertex->weightCount; ++j)
{ {
Matrix4f mat(skinningInfos.joints[inputVertex->jointIndexes[j]].GetSkinningMatrix()); Matrix4f mat(skinningInfos.joints[inputVertex->jointIndexes[j]].GetSkinningMatrix());
mat *= inputVertex->weights[j]; mat *= inputVertex->weights[j];

24
src/Nazara/Utility/Mesh.cpp
View File

@ -108,8 +108,8 @@ namespace Nz
{ {
case PrimitiveType::Box: case PrimitiveType::Box:
{ {
unsigned int indexCount; std::size_t indexCount;
unsigned int vertexCount; std::size_t vertexCount;
ComputeBoxIndexVertexCount(primitive.box.subdivision, &indexCount, &vertexCount); ComputeBoxIndexVertexCount(primitive.box.subdivision, &indexCount, &vertexCount);
indexBuffer = std::make_shared<IndexBuffer>(vertexCount > std::numeric_limits<UInt16>::max(), indexCount, params.storage, params.indexBufferFlags); indexBuffer = std::make_shared<IndexBuffer>(vertexCount > std::numeric_limits<UInt16>::max(), indexCount, params.storage, params.indexBufferFlags);
@ -130,8 +130,8 @@ namespace Nz
case PrimitiveType::Cone: case PrimitiveType::Cone:
{ {
unsigned int indexCount; std::size_t indexCount;
unsigned int vertexCount; std::size_t vertexCount;
ComputeConeIndexVertexCount(primitive.cone.subdivision, &indexCount, &vertexCount); ComputeConeIndexVertexCount(primitive.cone.subdivision, &indexCount, &vertexCount);
indexBuffer = std::make_shared<IndexBuffer>(vertexCount > std::numeric_limits<UInt16>::max(), indexCount, params.storage, params.indexBufferFlags); indexBuffer = std::make_shared<IndexBuffer>(vertexCount > std::numeric_limits<UInt16>::max(), indexCount, params.storage, params.indexBufferFlags);
@ -152,8 +152,8 @@ namespace Nz
case PrimitiveType::Plane: case PrimitiveType::Plane:
{ {
unsigned int indexCount; std::size_t indexCount;
unsigned int vertexCount; std::size_t vertexCount;
ComputePlaneIndexVertexCount(primitive.plane.subdivision, &indexCount, &vertexCount); ComputePlaneIndexVertexCount(primitive.plane.subdivision, &indexCount, &vertexCount);
indexBuffer = std::make_shared<IndexBuffer>(vertexCount > std::numeric_limits<UInt16>::max(), indexCount, params.storage, params.indexBufferFlags); indexBuffer = std::make_shared<IndexBuffer>(vertexCount > std::numeric_limits<UInt16>::max(), indexCount, params.storage, params.indexBufferFlags);
@ -178,8 +178,8 @@ namespace Nz
{ {
case SphereType::Cubic: case SphereType::Cubic:
{ {
unsigned int indexCount; std::size_t indexCount;
unsigned int vertexCount; std::size_t vertexCount;
ComputeCubicSphereIndexVertexCount(primitive.sphere.cubic.subdivision, &indexCount, &vertexCount); ComputeCubicSphereIndexVertexCount(primitive.sphere.cubic.subdivision, &indexCount, &vertexCount);
indexBuffer = std::make_shared<IndexBuffer>(vertexCount > std::numeric_limits<UInt16>::max(), indexCount, params.storage, params.indexBufferFlags); indexBuffer = std::make_shared<IndexBuffer>(vertexCount > std::numeric_limits<UInt16>::max(), indexCount, params.storage, params.indexBufferFlags);
@ -200,8 +200,8 @@ namespace Nz
case SphereType::Ico: case SphereType::Ico:
{ {
unsigned int indexCount; std::size_t indexCount;
unsigned int vertexCount; std::size_t vertexCount;
ComputeIcoSphereIndexVertexCount(primitive.sphere.ico.recursionLevel, &indexCount, &vertexCount); ComputeIcoSphereIndexVertexCount(primitive.sphere.ico.recursionLevel, &indexCount, &vertexCount);
indexBuffer = std::make_shared<IndexBuffer>(vertexCount > std::numeric_limits<UInt16>::max(), indexCount, params.storage, params.indexBufferFlags); indexBuffer = std::make_shared<IndexBuffer>(vertexCount > std::numeric_limits<UInt16>::max(), indexCount, params.storage, params.indexBufferFlags);
@ -222,8 +222,8 @@ namespace Nz
case SphereType::UV: case SphereType::UV:
{ {
unsigned int indexCount; std::size_t indexCount;
unsigned int vertexCount; std::size_t vertexCount;
ComputeUvSphereIndexVertexCount(primitive.sphere.uv.sliceCount, primitive.sphere.uv.stackCount, &indexCount, &vertexCount); ComputeUvSphereIndexVertexCount(primitive.sphere.uv.sliceCount, primitive.sphere.uv.stackCount, &indexCount, &vertexCount);
indexBuffer = std::make_shared<IndexBuffer>(vertexCount > std::numeric_limits<UInt16>::max(), indexCount, params.storage, params.indexBufferFlags); indexBuffer = std::make_shared<IndexBuffer>(vertexCount > std::numeric_limits<UInt16>::max(), indexCount, params.storage, params.indexBufferFlags);

8
src/Nazara/Utility/RichTextDrawer.cpp
View File

@ -460,10 +460,10 @@ namespace Nz
glyph.atlas = nullptr; glyph.atlas = nullptr;
glyph.bounds.Set(m_drawPos.x, m_lines.back().bounds.y, advance, lineHeight); glyph.bounds.Set(m_drawPos.x, m_lines.back().bounds.y, advance, lineHeight);
glyph.corners[0].Set(glyph.bounds.GetCorner(RectCorner_LeftTop)); glyph.corners[0].Set(glyph.bounds.GetCorner(RectCorner::LeftTop));
glyph.corners[1].Set(glyph.bounds.GetCorner(RectCorner_RightTop)); glyph.corners[1].Set(glyph.bounds.GetCorner(RectCorner::RightTop));
glyph.corners[2].Set(glyph.bounds.GetCorner(RectCorner_LeftBottom)); glyph.corners[2].Set(glyph.bounds.GetCorner(RectCorner::LeftBottom));
glyph.corners[3].Set(glyph.bounds.GetCorner(RectCorner_RightBottom)); glyph.corners[3].Set(glyph.bounds.GetCorner(RectCorner::RightBottom));
} }
m_lines.back().bounds.ExtendTo(glyph.bounds); m_lines.back().bounds.ExtendTo(glyph.bounds);

8
src/Nazara/Utility/SimpleTextDrawer.cpp
View File

@ -247,10 +247,10 @@ namespace Nz
glyph.atlas = nullptr; glyph.atlas = nullptr;
glyph.bounds.Set(m_drawPos.x, m_lines.back().bounds.y, advance, GetLineHeight(sizeInfo)); glyph.bounds.Set(m_drawPos.x, m_lines.back().bounds.y, advance, GetLineHeight(sizeInfo));
glyph.corners[0].Set(glyph.bounds.GetCorner(RectCorner_LeftTop)); glyph.corners[0].Set(glyph.bounds.GetCorner(RectCorner::LeftTop));
glyph.corners[1].Set(glyph.bounds.GetCorner(RectCorner_RightTop)); glyph.corners[1].Set(glyph.bounds.GetCorner(RectCorner::RightTop));
glyph.corners[2].Set(glyph.bounds.GetCorner(RectCorner_LeftBottom)); glyph.corners[2].Set(glyph.bounds.GetCorner(RectCorner::LeftBottom));
glyph.corners[3].Set(glyph.bounds.GetCorner(RectCorner_RightBottom)); glyph.corners[3].Set(glyph.bounds.GetCorner(RectCorner::RightBottom));
} }
m_lines.back().bounds.ExtendTo(glyph.bounds); m_lines.back().bounds.ExtendTo(glyph.bounds);

4
src/Nazara/Utility/StaticMesh.cpp
View File

@ -25,8 +25,8 @@ namespace Nz
VertexMapper mapper(*m_vertexBuffer); VertexMapper mapper(*m_vertexBuffer);
SparsePtr<Vector3f> position = mapper.GetComponentPtr<Vector3f>(VertexComponent::Position); SparsePtr<Vector3f> position = mapper.GetComponentPtr<Vector3f>(VertexComponent::Position);
unsigned int vertexCount = m_vertexBuffer->GetVertexCount(); std::size_t vertexCount = m_vertexBuffer->GetVertexCount();
for (unsigned int i = 0; i < vertexCount; ++i) for (std::size_t i = 0; i < vertexCount; ++i)
*position++ -= offset; *position++ -= offset;
m_aabb.x -= offset.x; m_aabb.x -= offset.x;

4
tests/Engine/Core/SerializationTest.cpp
View File

@ -92,11 +92,11 @@ SCENARIO("Serialization", "[CORE][SERIALIZATION]")
Nz::Frustumf copy(frustum); Nz::Frustumf copy(frustum);
REQUIRE(Serialize(context, frustum)); REQUIRE(Serialize(context, frustum));
frustum.Build(50, 40, 20, 100, Nz::Vector3f::UnitX(), Nz::Vector3f::UnitZ()); frustum.Build(50, 40, 20, 100, Nz::Vector3f::UnitX(), Nz::Vector3f::UnitZ());
for (unsigned int i = 0; i <= Nz::BoxCorner_Max; ++i) for (unsigned int i = 0; i < Nz::BoxCornerCount; ++i)
REQUIRE(frustum.GetCorner(static_cast<Nz::BoxCorner>(i)) != copy.GetCorner(static_cast<Nz::BoxCorner>(i))); REQUIRE(frustum.GetCorner(static_cast<Nz::BoxCorner>(i)) != copy.GetCorner(static_cast<Nz::BoxCorner>(i)));
context.stream->SetCursorPos(0); context.stream->SetCursorPos(0);
REQUIRE(Unserialize(context, &frustum)); REQUIRE(Unserialize(context, &frustum));
for (unsigned int i = 0; i <= Nz::BoxCorner_Max; ++i) for (unsigned int i = 0; i < Nz::BoxCornerCount; ++i)
REQUIRE(frustum.GetCorner(static_cast<Nz::BoxCorner>(i)) == copy.GetCorner(static_cast<Nz::BoxCorner>(i))); REQUIRE(frustum.GetCorner(static_cast<Nz::BoxCorner>(i)) == copy.GetCorner(static_cast<Nz::BoxCorner>(i)));
} }

4
tests/Engine/Math/BoundingVolumeTest.cpp
View File

@ -122,8 +122,8 @@ SCENARIO("BoundingVolume", "[MATH][BOUNDINGVOLUME]")
Nz::BoundingVolumef centerAndUnit(centerAndUnitOBB); Nz::BoundingVolumef centerAndUnit(centerAndUnitOBB);
Nz::BoundingVolumef nullBoundingVolume(Nz::Extend_Null); Nz::BoundingVolumef nullBoundingVolume(Nz::Extend::Null);
Nz::BoundingVolumef infiniteBoundingVolume(Nz::Extend_Infinite); Nz::BoundingVolumef infiniteBoundingVolume(Nz::Extend::Infinite);
THEN("Normal to null should give a smaller volume") THEN("Normal to null should give a smaller volume")
{ {

2
tests/Engine/Math/BoxTest.cpp
View File

@ -33,7 +33,7 @@ SCENARIO("Box", "[MATH][BOX]")
{ {
REQUIRE(firstCenterAndUnit.GetBoundingSphere() == Nz::Spheref(Nz::Vector3f::Unit() * 0.5f, std::sqrt(3.f * 0.5f * 0.5f))); REQUIRE(firstCenterAndUnit.GetBoundingSphere() == Nz::Spheref(Nz::Vector3f::Unit() * 0.5f, std::sqrt(3.f * 0.5f * 0.5f)));
REQUIRE(firstCenterAndUnit.GetCenter() == (Nz::Vector3f::Unit() * 0.5f)); REQUIRE(firstCenterAndUnit.GetCenter() == (Nz::Vector3f::Unit() * 0.5f));
REQUIRE(firstCenterAndUnit.GetCorner(Nz::BoxCorner_FarLeftTop) == Nz::Vector3f::UnitY()); REQUIRE(firstCenterAndUnit.GetCorner(Nz::BoxCorner::FarLeftTop) == Nz::Vector3f::UnitY());
REQUIRE(firstCenterAndUnit.GetLengths() == Nz::Vector3f::Unit()); REQUIRE(firstCenterAndUnit.GetLengths() == Nz::Vector3f::Unit());
REQUIRE(firstCenterAndUnit.GetMaximum() == Nz::Vector3f::Unit()); REQUIRE(firstCenterAndUnit.GetMaximum() == Nz::Vector3f::Unit());
REQUIRE(firstCenterAndUnit.GetMinimum() == Nz::Vector3f::Zero()); REQUIRE(firstCenterAndUnit.GetMinimum() == Nz::Vector3f::Zero());

26
tests/Engine/Math/FrustumTest.cpp
View File

@ -14,16 +14,16 @@ SCENARIO("Frustum", "[MATH][FRUSTUM]")
{ {
Nz::BoundingVolumef bv(Nz::Vector3f::Zero(), Nz::Vector3f::Unit()); Nz::BoundingVolumef bv(Nz::Vector3f::Zero(), Nz::Vector3f::Unit());
bv.Update(Nz::Matrix4f::Identity()); bv.Update(Nz::Matrix4f::Identity());
REQUIRE(Nz::IntersectionSide_Outside == frustum.Intersect(bv)); REQUIRE(Nz::IntersectionSide::Outside == frustum.Intersect(bv));
REQUIRE(Nz::IntersectionSide_Outside == frustum.Intersect(Nz::Boxf(Nz::Vector3f::Zero(), Nz::Vector3f::Unit() * 0.9f))); REQUIRE(Nz::IntersectionSide::Outside == frustum.Intersect(Nz::Boxf(Nz::Vector3f::Zero(), Nz::Vector3f::Unit() * 0.9f)));
Nz::OrientedBoxf obb(Nz::Vector3f::Zero(), Nz::Vector3f::Unit() * 0.9f); Nz::OrientedBoxf obb(Nz::Vector3f::Zero(), Nz::Vector3f::Unit() * 0.9f);
obb.Update(Nz::Matrix4f::Identity()); obb.Update(Nz::Matrix4f::Identity());
REQUIRE(Nz::IntersectionSide_Outside == frustum.Intersect(obb)); REQUIRE(Nz::IntersectionSide::Outside == frustum.Intersect(obb));
REQUIRE(Nz::IntersectionSide_Outside == frustum.Intersect(Nz::Spheref(Nz::Vector3f::Zero(), 0.5f))); REQUIRE(Nz::IntersectionSide::Outside == frustum.Intersect(Nz::Spheref(Nz::Vector3f::Zero(), 0.5f)));
Nz::Vector3f tmp = Nz::Vector3f::Zero(); Nz::Vector3f tmp = Nz::Vector3f::Zero();
REQUIRE(Nz::IntersectionSide_Outside == frustum.Intersect(&tmp, 1)); REQUIRE(Nz::IntersectionSide::Outside == frustum.Intersect(&tmp, 1));
tmp = Nz::Vector3f::UnitX() * -10.f; tmp = Nz::Vector3f::UnitX() * -10.f;
REQUIRE(Nz::IntersectionSide_Outside == frustum.Intersect(&tmp, 1)); REQUIRE(Nz::IntersectionSide::Outside == frustum.Intersect(&tmp, 1));
} }
} }
@ -34,14 +34,14 @@ SCENARIO("Frustum", "[MATH][FRUSTUM]")
Nz::BoundingVolumef bv(500.f, -0.5f, -0.5f, 1.f, 1.f, 1.f); Nz::BoundingVolumef bv(500.f, -0.5f, -0.5f, 1.f, 1.f, 1.f);
bv.Update(Nz::Matrix4f::Identity()); bv.Update(Nz::Matrix4f::Identity());
REQUIRE(Nz::IntersectionSide_Inside == frustum.Intersect(bv)); REQUIRE(Nz::IntersectionSide::Inside == frustum.Intersect(bv));
REQUIRE(Nz::IntersectionSide_Inside == frustum.Intersect(Nz::Boxf(Nz::Vector3f::UnitX() * 500.f, Nz::Vector3f::Unit()))); REQUIRE(Nz::IntersectionSide::Inside == frustum.Intersect(Nz::Boxf(Nz::Vector3f::UnitX() * 500.f, Nz::Vector3f::Unit())));
Nz::OrientedBoxf obb(Nz::Vector3f::UnitX() * 100.f, Nz::Vector3f::Unit()); Nz::OrientedBoxf obb(Nz::Vector3f::UnitX() * 100.f, Nz::Vector3f::Unit());
obb.Update(Nz::Matrix4f::Identity()); obb.Update(Nz::Matrix4f::Identity());
REQUIRE(Nz::IntersectionSide_Inside == frustum.Intersect(obb)); REQUIRE(Nz::IntersectionSide::Inside == frustum.Intersect(obb));
REQUIRE(Nz::IntersectionSide_Inside == frustum.Intersect(Nz::Spheref(Nz::Vector3f::UnitX() * 100.f, 0.5f))); REQUIRE(Nz::IntersectionSide::Inside == frustum.Intersect(Nz::Spheref(Nz::Vector3f::UnitX() * 100.f, 0.5f)));
Nz::Vector3f tmp = Nz::Vector3f::UnitX() * 100.f; Nz::Vector3f tmp = Nz::Vector3f::UnitX() * 100.f;
REQUIRE(Nz::IntersectionSide_Inside == frustum.Intersect(&tmp, 1)); REQUIRE(Nz::IntersectionSide::Inside == frustum.Intersect(&tmp, 1));
} }
} }
@ -87,8 +87,8 @@ SCENARIO("Frustum", "[MATH][FRUSTUM]")
CHECK(!frustum.Contains(nullVolume)); CHECK(!frustum.Contains(nullVolume));
Nz::BoundingVolumef infiniteVolume = Nz::BoundingVolumef::Infinite(); Nz::BoundingVolumef infiniteVolume = Nz::BoundingVolumef::Infinite();
CHECK(frustum.Contains(infiniteVolume)); CHECK(frustum.Contains(infiniteVolume));
REQUIRE(frustum.Intersect(nullVolume) == Nz::IntersectionSide_Outside); REQUIRE(frustum.Intersect(nullVolume) == Nz::IntersectionSide::Outside);
REQUIRE(frustum.Intersect(infiniteVolume) == Nz::IntersectionSide_Intersecting); REQUIRE(frustum.Intersect(infiniteVolume) == Nz::IntersectionSide::Intersecting);
} }
} }
} }

2
tests/Engine/Math/OrientedBoxTest.cpp
View File

@ -37,7 +37,7 @@ SCENARIO("OrientedBox", "[MATH][ORIENTEDBOX]")
secondCenterAndUnit.Update(Nz::Matrix4f::Scale(Nz::Vector3f::Unit() * 2.f)); secondCenterAndUnit.Update(Nz::Matrix4f::Scale(Nz::Vector3f::Unit() * 2.f));
REQUIRE(firstCenterAndUnit != secondCenterAndUnit); REQUIRE(firstCenterAndUnit != secondCenterAndUnit);
for (unsigned int i = 0; i <= Nz::BoxCorner_Max; ++i) for (unsigned int i = 0; i < Nz::BoxCornerCount; ++i)
{ {
REQUIRE(firstCenterAndUnit(i) == secondCenterAndUnit(i)); REQUIRE(firstCenterAndUnit(i) == secondCenterAndUnit(i));
} }

4
tests/Engine/Math/RayTest.cpp
View File

@ -83,12 +83,12 @@ SCENARIO("Ray", "[MATH][RAY]")
THEN("For the bounding volume collision's") THEN("For the bounding volume collision's")
{ {
Nz::BoundingVolumef nullVolume(Nz::Extend_Null); Nz::BoundingVolumef nullVolume(Nz::Extend::Null);
CHECK(!ray.Intersect(nullVolume)); CHECK(!ray.Intersect(nullVolume));
float tmpClosest = -1.f; float tmpClosest = -1.f;
float tmpFurthest = -1.f; float tmpFurthest = -1.f;
Nz::BoundingVolumef infiniteVolume(Nz::Extend_Infinite); Nz::BoundingVolumef infiniteVolume(Nz::Extend::Infinite);
CHECK(ray.Intersect(infiniteVolume, &tmpClosest, &tmpFurthest)); CHECK(ray.Intersect(infiniteVolume, &tmpClosest, &tmpFurthest));
CHECK(tmpClosest == Approx(0.f)); CHECK(tmpClosest == Approx(0.f));
CHECK(tmpFurthest == std::numeric_limits<float>::infinity()); CHECK(tmpFurthest == std::numeric_limits<float>::infinity());

2
tests/Engine/Math/RectTest.cpp
View File

@ -14,7 +14,7 @@ SCENARIO("Rect", "[MATH][RECT]")
{ {
CHECK(firstCenterAndUnit == secondCenterAndUnit); CHECK(firstCenterAndUnit == secondCenterAndUnit);
CHECK(firstCenterAndUnit.GetCenter() == secondCenterAndUnit.GetCenter()); CHECK(firstCenterAndUnit.GetCenter() == secondCenterAndUnit.GetCenter());
CHECK(firstCenterAndUnit.GetCorner(Nz::RectCorner_LeftBottom) == secondCenterAndUnit.GetCorner(Nz::RectCorner_LeftBottom)); CHECK(firstCenterAndUnit.GetCorner(Nz::RectCorner::LeftBottom) == secondCenterAndUnit.GetCorner(Nz::RectCorner::LeftBottom));
CHECK(firstCenterAndUnit.IsValid()); CHECK(firstCenterAndUnit.IsValid());
} }
} }