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

Removed AxisAlignedBox (Replaced by BoundingBox) 

Former-commit-id: 931dd6710caf49aeaede51efe209d714f080c44b
This commit is contained in:
Lynix 2013-02-21 18:28:32 +01:00
parent 2e6b864cad
commit 1b5215d4c2
22 changed files with 561 additions and 768 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

87
include/Nazara/Math/AxisAlignedBox.hpp
View File

@ -1,87 +0,0 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Mathematics module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#ifndef NAZARA_AXISALIGNEDBOX_HPP
#define NAZARA_AXISALIGNEDBOX_HPP
#include <Nazara/Core/String.hpp>
#include <Nazara/Math/Cube.hpp>
#include <Nazara/Math/Enums.hpp>
#include <Nazara/Math/Matrix4.hpp>
#include <Nazara/Math/Vector3.hpp>
template<typename T>
class NzAxisAlignedBox
{
public:
NzAxisAlignedBox();
NzAxisAlignedBox(nzExtend Extend);
NzAxisAlignedBox(T X, T Y, T Z, T Width, T Height, T Depth);
NzAxisAlignedBox(const NzCube<T>& Cube);
NzAxisAlignedBox(const NzVector3<T>& vec1, const NzVector3<T>& vec2);
template<typename U> explicit NzAxisAlignedBox(const NzAxisAlignedBox<U>& box);
NzAxisAlignedBox(const NzAxisAlignedBox& box) = default;
~NzAxisAlignedBox() = default;
bool Contains(T X, T Y, T Z) const;
bool Contains(const NzAxisAlignedBox& box) const;
bool Contains(const NzVector3<T>& vector) const;
NzAxisAlignedBox& ExtendTo(T X, T Y, T Z);
NzAxisAlignedBox& ExtendTo(const NzAxisAlignedBox& box);
NzAxisAlignedBox& ExtendTo(const NzVector3<T>& vector);
NzVector3<T> GetCorner(nzCorner corner) const;
NzVector3<T> GetCenter() const;
NzCube<T> GetCube() const;
nzExtend GetExtend() const;
NzVector3<T> GetNegativeVertex(const NzVector3<T>& normal) const;
NzVector3<T> GetPosition() const;
NzVector3<T> GetPositiveVertex(const NzVector3<T>& normal) const;
NzVector3<T> GetSize() const;
bool Intersect(const NzAxisAlignedBox& box, NzAxisAlignedBox* intersection = nullptr) const;
bool IsFinite() const;
bool IsInfinite() const;
bool IsNull() const;
NzAxisAlignedBox& MakeInfinite();
NzAxisAlignedBox& MakeNull();
NzAxisAlignedBox& Set(nzExtend Extend);
NzAxisAlignedBox& Set(T X, T Y, T Z, T Width, T Height, T Depth);
NzAxisAlignedBox& Set(const NzAxisAlignedBox<T>& box);
NzAxisAlignedBox& Set(const NzCube<T>& Cube);
NzAxisAlignedBox& Set(const NzVector3<T>& vec1, const NzVector3<T>& vec2);
template<typename U> NzAxisAlignedBox& Set(const NzAxisAlignedBox<U>& box);
NzString ToString() const;
NzAxisAlignedBox& Transform(const NzMatrix4<T>& matrix, bool applyTranslation = true);
NzAxisAlignedBox operator*(T scalar) const;
NzAxisAlignedBox& operator*=(T scalar);
bool operator==(const NzAxisAlignedBox& box) const;
bool operator!=(const NzAxisAlignedBox& box) const;
static NzAxisAlignedBox Infinite();
static NzAxisAlignedBox Lerp(const NzAxisAlignedBox& from, const NzAxisAlignedBox& to, T interpolation);
static NzAxisAlignedBox Null();
nzExtend extend;
NzCube<T> cube;
};
template<typename T>
std::ostream& operator<<(std::ostream& out, const NzAxisAlignedBox<T>& box);
typedef NzAxisAlignedBox<double> NzAxisAlignedBoxd;
typedef NzAxisAlignedBox<float> NzAxisAlignedBoxf;
#include <Nazara/Math/AxisAlignedBox.inl>
#endif // NAZARA_AXISALIGNEDBOX_HPP

610
include/Nazara/Math/AxisAlignedBox.inl
View File

@ -1,610 +0,0 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Mathematics module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/StringStream.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Math/Basic.hpp>
#include <algorithm>
#include <cstring>
#include <Nazara/Core/Debug.hpp>
#define F(a) static_cast<T>(a)
template<typename T>
NzAxisAlignedBox<T>::NzAxisAlignedBox() :
extend(nzExtend_Null)
{
}
template<typename T>
NzAxisAlignedBox<T>::NzAxisAlignedBox(nzExtend Extend)
{
Set(Extend);
}
template<typename T>
NzAxisAlignedBox<T>::NzAxisAlignedBox(T X, T Y, T Z, T Width, T Height, T Depth)
{
Set(X, Y, Z, Width, Height, Depth);
}
template<typename T>
NzAxisAlignedBox<T>::NzAxisAlignedBox(const NzCube<T>& Cube)
{
Set(Cube);
}
template<typename T>
NzAxisAlignedBox<T>::NzAxisAlignedBox(const NzVector3<T>& vec1, const NzVector3<T>& vec2)
{
Set(vec1, vec2);
}
template<typename T>
template<typename U>
NzAxisAlignedBox<T>::NzAxisAlignedBox(const NzAxisAlignedBox<U>& box)
{
Set(box);
}
template<typename T>
bool NzAxisAlignedBox<T>::Contains(T x, T y, T z) const
{
switch (extend)
{
case nzExtend_Finite:
return cube.Contains(x, y, z);
case nzExtend_Infinite:
return true;
case nzExtend_Null:
return false;
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (0x" + NzString::Number(extend, 16) + ')');
return false;
}
template<typename T>
bool NzAxisAlignedBox<T>::Contains(const NzAxisAlignedBox& box) const
{
if (extend == nzExtend_Null || box.extend == nzExtend_Null)
return false;
else if (extend == nzExtend_Infinite || box.extend == nzExtend_Infinite)
return true;
return cube.Contains(box.cube);
}
template<typename T>
bool NzAxisAlignedBox<T>::Contains(const NzVector3<T>& vector) const
{
switch (extend)
{
case nzExtend_Finite:
return cube.Contains(vector);
case nzExtend_Infinite:
return true;
case nzExtend_Null:
return false;
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (0x" + NzString::Number(extend, 16) + ')');
return false;
}
template<typename T>
NzAxisAlignedBox<T>& NzAxisAlignedBox<T>::ExtendTo(T X, T Y, T Z)
{
switch (extend)
{
case nzExtend_Finite:
cube.ExtendTo(X, Y, Z);
return *this;
case nzExtend_Infinite:
return *this; // Rien à faire
case nzExtend_Null:
return Set(cube.Set(X, Y, Z, F(0.0), F(0.0), F(0.0)));;
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (0x" + NzString::Number(extend, 16) + ')');
return *this;
}
template<typename T>
NzAxisAlignedBox<T>& NzAxisAlignedBox<T>::ExtendTo(const NzAxisAlignedBox& box)
{
switch (extend)
{
case nzExtend_Finite:
switch (box.extend)
{
case nzExtend_Finite:
cube.ExtendTo(box.cube);
return *this;
case nzExtend_Infinite:
return MakeInfinite();
case nzExtend_Null:
return *this;
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (0x" + NzString::Number(box.extend, 16) + ')');
return *this;
case nzExtend_Infinite:
return *this; // Rien à faire
case nzExtend_Null:
return Set(box);
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (0x" + NzString::Number(extend, 16) + ')');
return *this;
}
template<typename T>
NzAxisAlignedBox<T>& NzAxisAlignedBox<T>::ExtendTo(const NzVector3<T>& vector)
{
return ExtendTo(vector.x, vector.y, vector.z);
}
template<typename T>
NzVector3<T> NzAxisAlignedBox<T>::GetCorner(nzCorner corner) const
{
switch (extend)
{
case nzExtend_Finite:
return cube.GetCorner(corner);
case nzExtend_Infinite:
// Il est possible de renvoyer un vecteur avec des flottants infinis dont le signe dépend du coin
// Bien que ça soit plus juste mathématiquement, je ne vois pas l'intérêt...
NazaraError("Infinite AABB has no corner");
return NzVector3<T>();
case nzExtend_Null:
return NzVector3<T>::Zero();
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (0x" + NzString::Number(extend, 16) + ')');
return NzVector3<T>();
}
template<typename T>
NzCube<T> NzAxisAlignedBox<T>::GetCube() const
{
return cube;
}
template<typename T>
nzExtend NzAxisAlignedBox<T>::GetExtend() const
{
return extend;
}
template<typename T>
NzVector3<T> NzAxisAlignedBox<T>::GetNegativeVertex(const NzVector3<T>& normal) const
{
switch (extend)
{
case nzExtend_Finite:
return cube.GetNegativeVertex(normal);
case nzExtend_Infinite:
// Il est possible de renvoyer un vecteur avec des flottants infinis dont le signe dépend de la normale
// Bien que ça soit plus juste mathématiquement, je ne vois pas l'intérêt...
NazaraError("Infinite AABB has no negative vertex");
return NzVector3<T>();
case nzExtend_Null:
return NzVector3<T>::Zero();
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (0x" + NzString::Number(extend, 16) + ')');
return NzVector3<T>();
}
template<typename T>
NzVector3<T> NzAxisAlignedBox<T>::GetPosition() const
{
switch (extend)
{
case nzExtend_Finite:
return cube.GetPosition();
case nzExtend_Infinite:
// Il est possible de renvoyer un vecteur avec des flottants infinis
// Bien que ça soit plus juste mathématiquement, je ne vois pas l'intérêt...
NazaraError("Infinite AABB has no position");
return NzVector3<T>();
case nzExtend_Null:
return NzVector3<T>::Zero();
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (0x" + NzString::Number(extend, 16) + ')');
return NzVector3<T>();
}
template<typename T>
NzVector3<T> NzAxisAlignedBox<T>::GetPositiveVertex(const NzVector3<T>& normal) const
{
switch (extend)
{
case nzExtend_Finite:
return cube.GetPositiveVertex(normal);
case nzExtend_Infinite:
// Il est possible de renvoyer un vecteur avec des flottants infinis dont le signe dépend de la normale
// Bien que ça soit plus juste mathématiquement, je ne vois pas l'intérêt...
NazaraError("Infinite AABB has no corner");
return NzVector3<T>();
case nzExtend_Null:
return NzVector3<T>::Zero();
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (0x" + NzString::Number(extend, 16) + ')');
return NzVector3<T>();
}
template<typename T>
NzVector3<T> NzAxisAlignedBox<T>::GetSize() const
{
switch (extend)
{
case nzExtend_Finite:
return cube.GetSize();
case nzExtend_Infinite:
// Il est possible de renvoyer un vecteur avec des flottants infinis
// Bien que ça soit plus juste mathématiquement, je ne vois pas l'intérêt...
NazaraError("Infinite AABB has no size");
return NzVector3<T>();
case nzExtend_Null:
return NzVector3<T>::Zero();
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (0x" + NzString::Number(extend, 16) + ')');
return NzVector3<T>();
}
template<typename T>
bool NzAxisAlignedBox<T>::Intersect(const NzAxisAlignedBox& box, NzAxisAlignedBox* intersection) const
{
switch (extend)
{
case nzExtend_Finite:
{
switch (box.extend)
{
case nzExtend_Finite:
{
if (cube.Intersect(box.cube, &intersection->cube))
{
intersection->extend = nzExtend_Finite;
return true;
}
else
return false;
}
case nzExtend_Infinite:
intersection->Set(*this);
return true;
case nzExtend_Null:
return false;
}
NazaraError("Invalid extend type (0x" + NzString::Number(box.extend, 16) + ')');
return false;
}
case nzExtend_Infinite:
if (!box.IsNull()) // Si l'AABB n'est pas nulle, c'est qu'elle est finie ou infinie
{
// Et dans ce cas, il y a toujous intersection équivalente à la seconde AABB
intersection->Set(box);
return true;
}
else
return false;
case nzExtend_Null:
return false; // N'a jamais de collision avec quoi que ce soit
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (0x" + NzString::Number(extend, 16) + ')');
return false;
}
template<typename T>
bool NzAxisAlignedBox<T>::IsFinite() const
{
return extend == nzExtend_Finite;
}
template<typename T>
bool NzAxisAlignedBox<T>::IsInfinite() const
{
return extend == nzExtend_Infinite;
}
template<typename T>
bool NzAxisAlignedBox<T>::IsNull() const
{
return extend == nzExtend_Null;
}
template<typename T>
NzAxisAlignedBox<T>& NzAxisAlignedBox<T>::MakeInfinite()
{
extend = nzExtend_Infinite;
return *this;
}
template<typename T>
NzAxisAlignedBox<T>& NzAxisAlignedBox<T>::MakeNull()
{
extend = nzExtend_Null;
return *this;
}
template<typename T>
NzAxisAlignedBox<T>& NzAxisAlignedBox<T>::Set(nzExtend Extend)
{
extend = Extend;
return *this;
}
template<typename T>
NzAxisAlignedBox<T>& NzAxisAlignedBox<T>::Set(T X, T Y, T Z, T Width, T Height, T Depth)
{
cube.Set(X, Y, Z, Width, Height, Depth);
extend = nzExtend_Finite;
return *this;
}
template<typename T>
NzAxisAlignedBox<T>& NzAxisAlignedBox<T>::Set(const NzAxisAlignedBox<T>& box)
{
std::memcpy(this, &box, sizeof(NzAxisAlignedBox));
return *this;
}
template<typename T>
NzAxisAlignedBox<T>& NzAxisAlignedBox<T>::Set(const NzCube<T>& Cube)
{
cube.Set(Cube);
extend = nzExtend_Finite;
return *this;
}
template<typename T>
NzAxisAlignedBox<T>& NzAxisAlignedBox<T>::Set(const NzVector3<T>& vec1, const NzVector3<T>& vec2)
{
cube.Set(vec1, vec2);
extend = nzExtend_Finite;
return *this;
}
template<typename T>
template<typename U>
NzAxisAlignedBox<T>& NzAxisAlignedBox<T>::Set(const NzAxisAlignedBox<U>& box)
{
cube.Set(box);
extend = nzExtend_Finite;
return *this;
}
template<typename T>
NzString NzAxisAlignedBox<T>::ToString() const
{
switch (extend)
{
case nzExtend_Finite:
return "NzAxisAlignedBox(min=" + cube.GetPosition().ToString() + ", max=" + (cube.GetPosition()+cube.GetSize()).ToString() + ')';
case nzExtend_Infinite:
return "NzAxisAlignedBox(Infinite)";
case nzExtend_Null:
return "NzAxisAlignedBox(Null)";
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (0x" + NzString::Number(extend, 16) + ')');
return "NzAxisAlignedBox(ERROR)";
}
template<typename T>
NzAxisAlignedBox<T>& NzAxisAlignedBox<T>::Transform(const NzMatrix4<T>& matrix, bool applyTranslation)
{
if (extend != nzExtend_Finite)
return *this; // Toute transformation d'une AABox autre que finie résultera en la même AABox
NzVector3<T> center = matrix.Transform(cube.GetCenter(), (applyTranslation) ? F(1.0) : F(0.0)); // Valeur multipliant la translation
NzVector3<T> halfSize = cube.GetSize() * F(0.5);
halfSize.Set(std::fabs(matrix(0,0))*halfSize.x + std::fabs(matrix(1,0))*halfSize.y + std::fabs(matrix(2,0))*halfSize.z,
std::fabs(matrix(0,1))*halfSize.x + std::fabs(matrix(1,1))*halfSize.y + std::fabs(matrix(2,1))*halfSize.z,
std::fabs(matrix(0,2))*halfSize.x + std::fabs(matrix(1,2))*halfSize.y + std::fabs(matrix(2,2))*halfSize.z);
cube.Set(center - halfSize, center + halfSize);
return *this;
}
template<typename T>
NzAxisAlignedBox<T> NzAxisAlignedBox<T>::operator*(T scalar) const
{
NzAxisAlignedBox box(*this);
box *= scalar;
return box;
}
template<typename T>
NzAxisAlignedBox<T>& NzAxisAlignedBox<T>::operator*=(T scalar)
{
switch (extend)
{
case nzExtend_Finite:
cube *= scalar;
return *this;
case nzExtend_Infinite:
// L'infini multiplié par quoi que ce soit d'autre que zéro reste l'infini
// (On ne se préoccupe pas de l'infini de signe négatif, car ça finirait par être équivalent)
if (NzNumberEquals(scalar, F(0.0)))
MakeNull();
return *this;
case nzExtend_Null:
return *this; //
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (0x" + NzString::Number(extend, 16) + ')');
return NzVector3<T>();
}
template<typename T>
bool NzAxisAlignedBox<T>::operator==(const NzAxisAlignedBox& box) const
{
if (extend == box.extend)
return cube == box.cube;
else
return false;
}
template<typename T>
bool NzAxisAlignedBox<T>::operator!=(const NzAxisAlignedBox& box) const
{
return !operator==(box);
}
template<typename T>
NzAxisAlignedBox<T> NzAxisAlignedBox<T>::Infinite()
{
NzAxisAlignedBox box;
box.MakeInfinite();
return box;
}
template<typename T>
NzAxisAlignedBox<T> NzAxisAlignedBox<T>::Lerp(const NzAxisAlignedBox& from, const NzAxisAlignedBox& to, T interpolation)
{
#ifdef NAZARA_DEBUG
if (interpolation < 0.f || interpolation > 1.f)
{
NazaraError("Interpolation must be in range [0..1] (Got " + NzString::Number(interpolation) + ')');
return Null();
}
#endif
if (NzNumberEquals(interpolation, 0.f))
return from;
if (NzNumberEquals(interpolation, 1.f))
return to;
switch (to.extend)
{
case nzExtend_Finite:
{
switch (from.extend)
{
case nzExtend_Finite:
return NzCube<T>::Lerp(from.cube, to.cube, interpolation);
case nzExtend_Infinite:
return Infinite();
case nzExtend_Null:
return from.cube * interpolation;
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (From AABB) (0x" + NzString::Number(from.extend, 16) + ')');
return Null();
}
case nzExtend_Infinite:
return Infinite(); // Un petit peu d'infini est infini quand même ;)
case nzExtend_Null:
{
switch (from.extend)
{
case nzExtend_Finite:
return from.cube * (F(1.0) - interpolation);
case nzExtend_Infinite:
return Infinite();
case nzExtend_Null:
return Null();
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (From AABB) (0x" + NzString::Number(from.extend, 16) + ')');
return Null();
}
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (To AABB) (0x" + NzString::Number(from.extend, 16) + ')');
return Null();
}
template<typename T>
NzAxisAlignedBox<T> NzAxisAlignedBox<T>::Null()
{
NzAxisAlignedBox box;
box.MakeNull();
return box;
}
template<typename T>
std::ostream& operator<<(std::ostream& out, const NzAxisAlignedBox<T>& box)
{
out << box.ToString();
return out;
}
#undef F
#include <Nazara/Core/DebugOff.hpp>

70
include/Nazara/Math/BoundingBox.hpp Normal file
View File

@ -0,0 +1,70 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Mathematics module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#ifndef NAZARA_BOUNDINGBOX_HPP
#define NAZARA_BOUNDINGBOX_HPP
#include <Nazara/Core/String.hpp>
#include <Nazara/Math/Cube.hpp>
#include <Nazara/Math/Enums.hpp>
#include <Nazara/Math/Matrix4.hpp>
#include <Nazara/Math/OrientedCube.hpp>
#include <Nazara/Math/Vector3.hpp>
template<typename T>
class NzBoundingBox
{
public:
NzBoundingBox();
NzBoundingBox(nzExtend Extend);
NzBoundingBox(T X, T Y, T Z, T Width, T Height, T Depth);
NzBoundingBox(const NzCube<T>& Cube);
NzBoundingBox(const NzVector3<T>& vec1, const NzVector3<T>& vec2);
template<typename U> explicit NzBoundingBox(const NzBoundingBox<U>& box);
NzBoundingBox(const NzBoundingBox& box) = default;
~NzBoundingBox() = default;
bool IsFinite() const;
bool IsInfinite() const;
bool IsNull() const;
NzBoundingBox& MakeInfinite();
NzBoundingBox& MakeNull();
NzBoundingBox& Set(nzExtend Extend);
NzBoundingBox& Set(T X, T Y, T Z, T Width, T Height, T Depth);
NzBoundingBox& Set(const NzBoundingBox<T>& box);
NzBoundingBox& Set(const NzCube<T>& Cube);
NzBoundingBox& Set(const NzVector3<T>& vec1, const NzVector3<T>& vec2);
template<typename U> NzBoundingBox& Set(const NzBoundingBox<U>& box);
NzString ToString() const;
void Update(const NzMatrix4<T>& transformMatrix);
NzBoundingBox operator*(T scalar) const;
NzBoundingBox& operator*=(T scalar);
bool operator==(const NzBoundingBox& box) const;
bool operator!=(const NzBoundingBox& box) const;
static NzBoundingBox Infinite();
static NzBoundingBox Lerp(const NzBoundingBox& from, const NzBoundingBox& to, T interpolation);
static NzBoundingBox Null();
nzExtend extend;
NzCube<T> aabb;
NzOrientedCube<T> obb;
};
template<typename T>
std::ostream& operator<<(std::ostream& out, const NzBoundingBox<T>& box);
typedef NzBoundingBox<double> NzBoundingBoxd;
typedef NzBoundingBox<float> NzBoundingBoxf;
#include <Nazara/Math/BoundingBox.inl>
#endif // NAZARA_BOUNDINGBOX_HPP

295
include/Nazara/Math/BoundingBox.inl Normal file
View File

@ -0,0 +1,295 @@
// Copyright (C) 2012 Jérôme Leclercq
// This file is part of the "Nazara Engine - Mathematics module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Core/StringStream.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Math/Basic.hpp>
#include <algorithm>
#include <cstring>
#include <Nazara/Core/Debug.hpp>
#define F(a) static_cast<T>(a)
template<typename T>
NzBoundingBox<T>::NzBoundingBox() :
extend(nzExtend_Null)
{
}
template<typename T>
NzBoundingBox<T>::NzBoundingBox(nzExtend Extend)
{
Set(Extend);
}
template<typename T>
NzBoundingBox<T>::NzBoundingBox(T X, T Y, T Z, T Width, T Height, T Depth)
{
Set(X, Y, Z, Width, Height, Depth);
}
template<typename T>
NzBoundingBox<T>::NzBoundingBox(const NzCube<T>& Cube)
{
Set(Cube);
}
template<typename T>
NzBoundingBox<T>::NzBoundingBox(const NzVector3<T>& vec1, const NzVector3<T>& vec2)
{
Set(vec1, vec2);
}
template<typename T>
template<typename U>
NzBoundingBox<T>::NzBoundingBox(const NzBoundingBox<U>& box)
{
Set(box);
}
template<typename T>
bool NzBoundingBox<T>::IsFinite() const
{
return extend == nzExtend_Finite;
}
template<typename T>
bool NzBoundingBox<T>::IsInfinite() const
{
return extend == nzExtend_Infinite;
}
template<typename T>
bool NzBoundingBox<T>::IsNull() const
{
return extend == nzExtend_Null;
}
template<typename T>
NzBoundingBox<T>& NzBoundingBox<T>::MakeInfinite()
{
extend = nzExtend_Infinite;
return *this;
}
template<typename T>
NzBoundingBox<T>& NzBoundingBox<T>::MakeNull()
{
extend = nzExtend_Null;
return *this;
}
template<typename T>
NzBoundingBox<T>& NzBoundingBox<T>::Set(nzExtend Extend)
{
extend = Extend;
return *this;
}
template<typename T>
NzBoundingBox<T>& NzBoundingBox<T>::Set(T X, T Y, T Z, T Width, T Height, T Depth)
{
obb.Set(X, Y, Z, Width, Height, Depth);
extend = nzExtend_Finite;
return *this;
}
template<typename T>
NzBoundingBox<T>& NzBoundingBox<T>::Set(const NzBoundingBox<T>& box)
{
obb.Set(box.obb); // Seul l'OBB est importante pour la suite
return *this;
}
template<typename T>
NzBoundingBox<T>& NzBoundingBox<T>::Set(const NzCube<T>& Cube)
{
obb.Set(Cube);
extend = nzExtend_Finite;
return *this;
}
template<typename T>
NzBoundingBox<T>& NzBoundingBox<T>::Set(const NzVector3<T>& vec1, const NzVector3<T>& vec2)
{
obb.Set(vec1, vec2);
extend = nzExtend_Finite;
return *this;
}
template<typename T>
template<typename U>
NzBoundingBox<T>& NzBoundingBox<T>::Set(const NzBoundingBox<U>& box)
{
obb.Set(box.obb);
extend = box.extend;
return *this;
}
template<typename T>
NzString NzBoundingBox<T>::ToString() const
{
switch (extend)
{
case nzExtend_Finite:
return "BoundingBox(localCube=" + obb.localCube.ToString() + ')';
case nzExtend_Infinite:
return "BoundingBox(Infinite)";
case nzExtend_Null:
return "BoundingBox(Null)";
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (0x" + NzString::Number(extend, 16) + ')');
return "BoundingBox(ERROR)";
}
template<typename T>
void NzBoundingBox<T>::Update(const NzMatrix4<T>& transformMatrix)
{
aabb.Set(obb.localCube);
aabb.Transform(transformMatrix);
obb.Update(transformMatrix);
}
template<typename T>
NzBoundingBox<T> NzBoundingBox<T>::operator*(T scalar) const
{
NzBoundingBox box(*this);
box *= scalar;
return box;
}
template<typename T>
NzBoundingBox<T>& NzBoundingBox<T>::operator*=(T scalar)
{
aabb *= scalar;
obb *= scalar;
}
template<typename T>
bool NzBoundingBox<T>::operator==(const NzBoundingBox& box) const
{
if (extend == box.extend)
return obb == box.obb;
else
return false;
}
template<typename T>
bool NzBoundingBox<T>::operator!=(const NzBoundingBox& box) const
{
return !operator==(box);
}
template<typename T>
NzBoundingBox<T> NzBoundingBox<T>::Infinite()
{
NzBoundingBox box;
box.MakeInfinite();
return box;
}
template<typename T>
NzBoundingBox<T> NzBoundingBox<T>::Lerp(const NzBoundingBox& from, const NzBoundingBox& to, T interpolation)
{
#ifdef NAZARA_DEBUG
if (interpolation < 0.f || interpolation > 1.f)
{
NazaraError("Interpolation must be in range [0..1] (Got " + NzString::Number(interpolation) + ')');
return Null();
}
#endif
if (NzNumberEquals(interpolation, 0.f))
return from;
if (NzNumberEquals(interpolation, 1.f))
return to;
switch (to.extend)
{
case nzExtend_Finite:
{
switch (from.extend)
{
case nzExtend_Finite:
{
NzBoundingBox box;
box.Set(NzOrientedCube<T>::Lerp(from.obb, to.obb, interpolation));
return box;
}
case nzExtend_Infinite:
return Infinite();
case nzExtend_Null:
return from.obb * interpolation;
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (From) (0x" + NzString::Number(from.extend, 16) + ')');
return Null();
}
case nzExtend_Infinite:
return Infinite(); // Un petit peu d'infini est infini quand même ;)
case nzExtend_Null:
{
switch (from.extend)
{
case nzExtend_Finite:
return from.obb * (F(1.0) - interpolation);
case nzExtend_Infinite:
return Infinite();
case nzExtend_Null:
return Null();
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (From) (0x" + NzString::Number(from.extend, 16) + ')');
return Null();
}
}
// Si nous arrivons ici c'est que l'extend est invalide
NazaraError("Invalid extend type (To) (0x" + NzString::Number(from.extend, 16) + ')');
return Null();
}
template<typename T>
NzBoundingBox<T> NzBoundingBox<T>::Null()
{
NzBoundingBox box;
box.MakeNull();
return box;
}
template<typename T>
std::ostream& operator<<(std::ostream& out, const NzBoundingBox<T>& box)
{
out << box.ToString();
return out;
}
#undef F
#include <Nazara/Core/DebugOff.hpp>

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

@ -8,9 +8,10 @@
#define NAZARA_FRUSTUM_HPP
#include <Nazara/Core/String.hpp>
#include <Nazara/Math/AxisAlignedBox.hpp>
#include <Nazara/Math/BoundingBox.hpp>
#include <Nazara/Math/Enums.hpp>
#include <Nazara/Math/Matrix4.hpp>
#include <Nazara/Math/OrientedCube.hpp>
#include <Nazara/Math/Plane.hpp>
#include <Nazara/Math/Sphere.hpp>
#include <Nazara/Math/Vector3.hpp>
@ -26,8 +27,9 @@ class NzFrustum
NzFrustum& Build(T angle, T ratio, T zNear, T zFar, const NzVector3<T>& eye, const NzVector3<T>& target, const NzVector3<T>& up = NzVector3<T>::Up());
bool Contains(const NzAxisAlignedBox<T>& box) const;
bool Contains(const NzBoundingBox<T>& box) const;
bool Contains(const NzCube<T>& cube) const;
bool Contains(const NzOrientedCube<T>& orientedCube) const;
bool Contains(const NzSphere<T>& sphere) const;
bool Contains(const NzVector3<T>& point) const;
bool Contains(const NzVector3<T>* points, unsigned int pointCount) const;
@ -38,8 +40,9 @@ class NzFrustum
const NzVector3<T>& GetCorner(nzCorner corner) const;
const NzPlane<T>& GetPlane(nzFrustumPlane plane) const;
nzIntersectionSide Intersect(const NzAxisAlignedBox<T>& box) const;
nzIntersectionSide Intersect(const NzBoundingBox<T>& box) const;
nzIntersectionSide Intersect(const NzCube<T>& cube) const;
nzIntersectionSide Intersect(const NzOrientedCube<T>& orientedCube) const;
nzIntersectionSide Intersect(const NzSphere<T>& sphere) const;
nzIntersectionSide Intersect(const NzVector3<T>* points, unsigned int pointCount) const;

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

@ -66,12 +66,12 @@ NzFrustum<T>& NzFrustum<T>::Build(T angle, T ratio, T zNear, T zFar, const NzVec
}
template<typename T>
bool NzFrustum<T>::Contains(const NzAxisAlignedBox<T>& box) const
bool NzFrustum<T>::Contains(const NzBoundingBox<T>& box) const
{
switch (box.extend)
{
case nzExtend_Finite:
return Contains(box.cube);
return Contains(box.aabb) && Contains(box.obb);
case nzExtend_Infinite:
return true;
@ -97,6 +97,12 @@ bool NzFrustum<T>::Contains(const NzCube<T>& cube) const
return true;
}
template<typename T>
bool NzFrustum<T>::Contains(const NzOrientedCube<T>& orientedCube) const
{
return Contains(&orientedCube[0], 8);
}
template<typename T>
bool NzFrustum<T>::Contains(const NzSphere<T>& sphere) const
{
@ -347,12 +353,12 @@ const NzPlane<T>& NzFrustum<T>::GetPlane(nzFrustumPlane plane) const
}
template<typename T>
nzIntersectionSide NzFrustum<T>::Intersect(const NzAxisAlignedBox<T>& box) const
nzIntersectionSide NzFrustum<T>::Intersect(const NzBoundingBox<T>& box) const
{
switch (box.extend)
{
case nzExtend_Finite:
return Intersect(box.cube);
return Intersect(box.aabb) && Intersect(box.obb); // Test de l'AABB et puis de l'OBB
case nzExtend_Infinite:
return nzIntersectionSide_Intersecting;
@ -382,6 +388,12 @@ nzIntersectionSide NzFrustum<T>::Intersect(const NzCube<T>& cube) const
return side;
}
template<typename T>
nzIntersectionSide NzFrustum<T>::Intersect(const NzOrientedCube<T>& orientedCube) const
{
return Intersect(&orientedCube[0], 8);
}
template<typename T>
nzIntersectionSide NzFrustum<T>::Intersect(const NzSphere<T>& sphere) const
{

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

@ -88,7 +88,7 @@ class NzMatrix4
operator const T*() const;
T& operator()(unsigned int x, unsigned int y);
const T& operator()(unsigned int x, unsigned int y) const;
T operator()(unsigned int x, unsigned int y) const;
NzMatrix4& operator=(const NzMatrix4& matrix) = default;

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

@ -769,7 +769,7 @@ T& NzMatrix4<T>::operator()(unsigned int x, unsigned int y)
}
template<typename T>
const T& NzMatrix4<T>::operator()(unsigned int x, unsigned int y) const
T NzMatrix4<T>::operator()(unsigned int x, unsigned int y) const
{
#if NAZARA_MATH_SAFE
if (x > 3 || y > 3)

6
include/Nazara/Renderer/DebugDrawer.hpp
View File

@ -9,9 +9,10 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/Color.hpp>
#include <Nazara/Math/AxisAlignedBox.hpp>
#include <Nazara/Math/BoundingBox.hpp>
#include <Nazara/Math/Cube.hpp>
#include <Nazara/Math/Frustum.hpp>
#include <Nazara/Math/OrientedCube.hpp>
#include <Nazara/Utility/SubMesh.hpp>
class NzSkeleton;
@ -19,11 +20,12 @@ class NzSkeleton;
class NAZARA_API NzDebugDrawer
{
public:
static void Draw(const NzAxisAlignedBoxf& aabb);
static void Draw(const NzBoundingBoxf& box);
static void Draw(const NzCubef& cube);
static void Draw(const NzCubei& cube);
static void Draw(const NzCubeui& cube);
static void Draw(const NzFrustumf& frustum);
static void Draw(const NzOrientedCubef& orientedCube);
static void Draw(const NzSkeleton* skeleton);
static void DrawNormals(const NzSubMesh* subMesh);
static void DrawTangents(const NzSubMesh* subMesh);

4
include/Nazara/Utility/KeyframeMesh.hpp
View File

@ -28,7 +28,7 @@ class NAZARA_API NzKeyframeMesh final : public NzSubMesh
void GenerateAABBs();
const NzAxisAlignedBoxf& GetAABB() const override;
const NzCubef& GetAABB() const override;
nzAnimationType GetAnimationType() const override;
unsigned int GetFrameCount() const;
const NzIndexBuffer* GetIndexBuffer() const override;
@ -46,7 +46,7 @@ class NAZARA_API NzKeyframeMesh final : public NzSubMesh
bool IsAnimated() const override;
bool IsValid();
void SetAABB(unsigned int frameIndex, const NzAxisAlignedBoxf& aabb);
void SetAABB(unsigned int frameIndex, const NzCubef& aabb);
void SetIndexBuffer(const NzIndexBuffer* indexBuffer);
void SetNormal(unsigned int frameIndex, unsigned int vertexIndex, const NzVector3f& normal);
void SetPosition(unsigned int frameIndex, unsigned int vertexIndex, const NzVector3f& position);

4
include/Nazara/Utility/Mesh.hpp
View File

@ -13,7 +13,7 @@
#include <Nazara/Core/ResourceListener.hpp>
#include <Nazara/Core/ResourceLoader.hpp>
#include <Nazara/Core/String.hpp>
#include <Nazara/Math/AxisAlignedBox.hpp>
#include <Nazara/Math/Cube.hpp>
#include <Nazara/Utility/Skeleton.hpp>
#include <Nazara/Utility/SubMesh.hpp>
#include <Nazara/Utility/VertexStruct.hpp>
@ -59,7 +59,7 @@ class NAZARA_API NzMesh : public NzResource, NzResourceListener
void GenerateNormalsAndTangents();
void GenerateTangents();
const NzAxisAlignedBoxf& GetAABB() const;
const NzCubef& GetAABB() const;
NzString GetAnimation() const;
nzAnimationType GetAnimationType() const;
unsigned int GetJointCount() const;

2
include/Nazara/Utility/SkeletalMesh.hpp
View File

@ -37,7 +37,7 @@ class NAZARA_API NzSkeletalMesh final : public NzSubMesh
void Finish();
const NzAxisAlignedBoxf& GetAABB() const;
const NzCubef& GetAABB() const;
nzAnimationType GetAnimationType() const final;
void* GetBindPoseBuffer();
const void* GetBindPoseBuffer() const;

4
include/Nazara/Utility/Skeleton.hpp
View File

@ -8,7 +8,7 @@
#define NAZARA_SKELETON_HPP
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Math/AxisAlignedBox.hpp>
#include <Nazara/Math/Cube.hpp>
#include <Nazara/Utility/Joint.hpp>
#include <vector>
@ -26,7 +26,7 @@ class NAZARA_API NzSkeleton
bool Create(unsigned int jointCount);
void Destroy();
const NzAxisAlignedBoxf& GetAABB() const;
const NzCubef& GetAABB() const;
NzJoint* GetJoint(const NzString& jointName);
NzJoint* GetJoint(unsigned int index);
const NzJoint* GetJoint(const NzString& jointName) const;

6
include/Nazara/Utility/StaticMesh.hpp
View File

@ -24,7 +24,7 @@ class NAZARA_API NzStaticMesh final : public NzSubMesh, NzResourceListener
bool GenerateAABB();
const NzAxisAlignedBoxf& GetAABB() const override;
const NzCubef& GetAABB() const override;
nzAnimationType GetAnimationType() const final;
const NzIndexBuffer* GetIndexBuffer() const override;
NzVertexBuffer* GetVertexBuffer() override;
@ -33,13 +33,13 @@ class NAZARA_API NzStaticMesh final : public NzSubMesh, NzResourceListener
bool IsAnimated() const final;
bool IsValid() const;
void SetAABB(const NzAxisAlignedBoxf& aabb);
void SetAABB(const NzCubef& aabb);
void SetIndexBuffer(const NzIndexBuffer* indexBuffer);
private:
void OnResourceReleased(const NzResource* resource, int index) override;
NzAxisAlignedBoxf m_aabb;
NzCubef m_aabb;
const NzIndexBuffer* m_indexBuffer = nullptr;
NzVertexBuffer* m_vertexBuffer = nullptr;
};

4
include/Nazara/Utility/SubMesh.hpp
View File

@ -9,7 +9,7 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/Resource.hpp>
#include <Nazara/Math/AxisAlignedBox.hpp>
#include <Nazara/Math/Cube.hpp>
#include <Nazara/Utility/Enums.hpp>
#include <Nazara/Utility/IndexBuffer.hpp>
#include <Nazara/Utility/VertexBuffer.hpp>
@ -27,7 +27,7 @@ class NAZARA_API NzSubMesh : public NzResource
virtual void Finish() = 0; ///DOC: Mets le mesh dans sa position d'origine et calcule son AABB
virtual const NzAxisAlignedBoxf& GetAABB() const = 0;
virtual const NzCubef& GetAABB() const = 0;
virtual nzAnimationType GetAnimationType() const = 0;
virtual const NzIndexBuffer* GetIndexBuffer() const = 0;
unsigned int GetMaterialIndex() const;

116
src/Nazara/Renderer/DebugDrawer.cpp
View File

@ -31,12 +31,19 @@ namespace
static int colorLocation = -1;
}
void NzDebugDrawer::Draw(const NzAxisAlignedBoxf& aabb)
void NzDebugDrawer::Draw(const NzBoundingBoxf& box)
{
if (!aabb.IsFinite())
if (!box.IsFinite())
return;
Draw(aabb.GetCube());
NzColor oldPrimaryColor = primaryColor;
Draw(box.aabb);
primaryColor = secondaryColor;
Draw(box.obb);
primaryColor = oldPrimaryColor;
}
void NzDebugDrawer::Draw(const NzCubei& cube)
@ -259,6 +266,109 @@ void NzDebugDrawer::Draw(const NzFrustumf& frustum)
NazaraWarning("Failed to reset shader");
}
void NzDebugDrawer::Draw(const NzOrientedCubef& orientedCube)
{
if (!initialized)
{
NazaraError("Debug drawer is not initialized");
return;
}
NzBufferMapper<NzVertexBuffer> mapper(vertexBuffer, nzBufferAccess_DiscardAndWrite, 0, 24);
NzVertexStruct_XYZ* vertex = reinterpret_cast<NzVertexStruct_XYZ*>(mapper.GetPointer());
vertex->position.Set(orientedCube.GetCorner(nzCorner_NearLeftBottom));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_NearRightBottom));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_NearLeftBottom));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_NearLeftTop));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_NearLeftBottom));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_FarLeftBottom));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_FarRightTop));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_FarLeftTop));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_FarRightTop));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_FarRightBottom));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_FarRightTop));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_NearRightTop));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_FarLeftBottom));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_FarRightBottom));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_FarLeftBottom));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_FarLeftTop));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_NearLeftTop));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_NearRightTop));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_NearLeftTop));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_FarLeftTop));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_NearRightBottom));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_NearRightTop));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_NearRightBottom));
vertex++;
vertex->position.Set(orientedCube.GetCorner(nzCorner_FarRightBottom));
vertex++;
mapper.Unmap();
const NzShader* oldShader = NzRenderer::GetShader();
if (!NzRenderer::SetShader(shader))
{
NazaraError("Failed to set debug shader");
return;
}
bool depthTestActive = NzRenderer::IsEnabled(nzRendererParameter_DepthTest);
if (depthTestActive != depthTest)
NzRenderer::Enable(nzRendererParameter_DepthTest, depthTest);
float oldLineWidth = NzRenderer::GetLineWidth();
NzRenderer::SetLineWidth(lineWidth);
NzRenderer::SetVertexBuffer(vertexBuffer);
shader->SendColor(colorLocation, primaryColor);
NzRenderer::DrawPrimitives(nzPrimitiveType_LineList, 0, 24);
NzRenderer::SetLineWidth(oldLineWidth);
if (depthTestActive != depthTest)
NzRenderer::Enable(nzRendererParameter_DepthTest, depthTestActive);
if (!NzRenderer::SetShader(oldShader))
NazaraWarning("Failed to reset shader");
}
void NzDebugDrawer::Draw(const NzSkeleton* skeleton)
{
if (!initialized)

27
src/Nazara/Utility/KeyframeMesh.cpp
View File

@ -12,7 +12,7 @@
struct NzKeyframeMeshImpl
{
NzAxisAlignedBoxf* aabb;
NzCubef* aabb;
NzVector2f* uv;
NzVector3f* normals;
NzVector3f* positions;
@ -59,7 +59,7 @@ bool NzKeyframeMesh::Create(NzVertexBuffer* vertexBuffer, unsigned int frameCoun
vertexBuffer->AddResourceReference();
m_impl = new NzKeyframeMeshImpl;
m_impl->aabb = new NzAxisAlignedBoxf[frameCount+1]; // La première case représente l'AABB interpolée
m_impl->aabb = new NzCubef[frameCount+1]; // La première case représente l'AABB interpolée
m_impl->frameCount = frameCount;
m_impl->vertexBuffer = vertexBuffer;
@ -123,25 +123,23 @@ void NzKeyframeMesh::GenerateAABBs()
unsigned int vertexCount = m_impl->vertexBuffer->GetVertexCount();
for (unsigned int i = 0; i < m_impl->frameCount; ++i)
{
NzAxisAlignedBoxf& aabb = m_impl->aabb[i+1]; // l'AABB 0 est celle qui est interpolée
if (aabb.IsNull())
{
// Génération de l'AABB selon la position
unsigned int index = i*vertexCount;
for (unsigned int j = 0; j < vertexCount; ++j)
aabb.ExtendTo(m_impl->positions[index+j]);
}
NzCubef& aabb = m_impl->aabb[i+1]; // l'AABB 0 est celle qui est interpolée
// Génération de l'AABB selon la position
unsigned int index = i*vertexCount;
for (unsigned int j = 0; j < vertexCount; ++j)
aabb.ExtendTo(m_impl->positions[index+j]);
}
}
const NzAxisAlignedBoxf& NzKeyframeMesh::GetAABB() const
const NzCubef& NzKeyframeMesh::GetAABB() const
{
#if NAZARA_UTILITY_SAFE
if (!m_impl)
{
NazaraError("Keyframe mesh not created");
static NzAxisAlignedBoxf dummy(nzExtend_Null);
static NzCubef dummy;
return dummy;
}
#endif
@ -404,7 +402,7 @@ bool NzKeyframeMesh::IsValid()
return m_impl != nullptr;
}
void NzKeyframeMesh::SetAABB(unsigned int frameIndex, const NzAxisAlignedBoxf& aabb)
void NzKeyframeMesh::SetAABB(unsigned int frameIndex, const NzCubef& aabb)
{
#if NAZARA_UTILITY_SAFE
if (!m_impl)
@ -502,7 +500,6 @@ void NzKeyframeMesh::SetPosition(unsigned int frameIndex, unsigned int vertexInd
unsigned int index = frameIndex*vertexCount + vertexIndex;
m_impl->positions[index] = position;
m_impl->aabb[frameIndex+1].MakeNull(); // Invalidation de l'AABB
}
void NzKeyframeMesh::SetTangent(unsigned int frameIndex, unsigned int vertexIndex, const NzVector3f& tangent)
@ -566,7 +563,7 @@ void NzKeyframeMesh::InterpolateImpl(unsigned int frameA, unsigned int frameB, f
#endif
// Interpolation de l'AABB
m_impl->aabb[0] = NzAxisAlignedBoxf::Lerp(m_impl->aabb[frameA+1], m_impl->aabb[frameB+1], interpolation);
m_impl->aabb[0] = NzCubef::Lerp(m_impl->aabb[frameA+1], m_impl->aabb[frameB+1], interpolation);
NzMeshVertex* vertex = reinterpret_cast<NzMeshVertex*>(m_impl->vertexBuffer->Map(nzBufferAccess_DiscardAndWrite));
if (!vertex)

4
src/Nazara/Utility/Loaders/MD5Anim/Parser.hpp
View File

@ -9,7 +9,7 @@
#include <Nazara/Prerequesites.hpp>
#include <Nazara/Core/InputStream.hpp>
#include <Nazara/Math/AxisAlignedBox.hpp>
#include <Nazara/Math/Cube.hpp>
#include <Nazara/Math/Quaternion.hpp>
#include <Nazara/Math/Vector3.hpp>
#include <Nazara/Utility/Animation.hpp>
@ -34,7 +34,7 @@ class NzMD5AnimParser
};
std::vector<Joint> joints;
NzAxisAlignedBoxf aabb;
NzCubef aabb;
};
struct Joint

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

@ -41,9 +41,10 @@ struct NzMeshImpl
std::vector<NzString> materials;
std::vector<NzSubMesh*> subMeshes;
nzAnimationType animationType;
NzAxisAlignedBoxf aabb;
NzCubef aabb;
NzSkeleton skeleton; // Uniquement pour les meshs squelettiques
NzString animationPath;
bool aabbUpdated = false;
unsigned int jointCount; // Uniquement pour les meshs squelettiques
};
@ -77,7 +78,7 @@ bool NzMesh::AddSubMesh(NzSubMesh* subMesh)
subMesh->AddResourceListener(this, m_impl->subMeshes.size());
subMesh->Finish();
m_impl->aabb.MakeNull(); // On invalide l'AABB
m_impl->aabbUpdated = false; // On invalide l'AABB
m_impl->subMeshes.push_back(subMesh);
return true;
@ -123,7 +124,7 @@ bool NzMesh::AddSubMesh(const NzString& identifier, NzSubMesh* subMesh)
subMesh->AddResourceListener(this, index);
subMesh->Finish();
m_impl->aabb.MakeNull(); // On invalide l'AABB
m_impl->aabbUpdated = false; // On invalide l'AABB
m_impl->subMeshes.push_back(subMesh);
m_impl->subMeshMap[identifier] = index;
@ -206,7 +207,7 @@ void NzMesh::Animate(const NzAnimation* animation, unsigned int frameA, unsigned
break;
}
m_impl->aabb.MakeNull(); // On invalide l'AABB
m_impl->aabbUpdated = false; // On invalide l'AABB
}
bool NzMesh::CreateKeyframe()
@ -417,22 +418,24 @@ void NzMesh::GenerateTangents()
}
}
const NzAxisAlignedBoxf& NzMesh::GetAABB() const
const NzCubef& NzMesh::GetAABB() const
{
#if NAZARA_UTILITY_SAFE
if (!m_impl)
{
NazaraError("Mesh not created");
static NzAxisAlignedBoxf dummy(nzExtend_Null);
static NzCubef dummy;
return dummy;
}
#endif
if (m_impl->aabb.IsNull())
if (!m_impl->aabbUpdated)
{
for (NzSubMesh* subMesh : m_impl->subMeshes)
m_impl->aabb.ExtendTo(subMesh->GetAABB());
m_impl->aabbUpdated = true;
}
return m_impl->aabb;
@ -700,7 +703,7 @@ void NzMesh::InvalidateAABB() const
}
#endif
m_impl->aabb.MakeNull();
m_impl->aabbUpdated = false;
}
bool NzMesh::HasSubMesh(const NzString& identifier) const
@ -791,7 +794,7 @@ void NzMesh::RemoveSubMesh(const NzString& identifier)
(*it2)->RemoveResourceListener(this);
m_impl->subMeshes.erase(it2);
m_impl->aabb.MakeNull(); // On invalide l'AABB
m_impl->aabbUpdated = false; // On invalide l'AABB
}
void NzMesh::RemoveSubMesh(unsigned int index)
@ -818,7 +821,7 @@ void NzMesh::RemoveSubMesh(unsigned int index)
(*it)->RemoveResourceListener(this);
m_impl->subMeshes.erase(it);
m_impl->aabb.MakeNull(); // On invalide l'AABB
m_impl->aabbUpdated = false; // On invalide l'AABB
}
void NzMesh::SetAnimation(const NzString& animationPath)

6
src/Nazara/Utility/SkeletalMesh.cpp
View File

@ -132,7 +132,7 @@ struct NzSkeletalMeshImpl
{
std::vector<NzVertexWeight> vertexWeights;
std::vector<NzWeight> weights;
NzAxisAlignedBoxf aabb;
NzCubef aabb;
nzUInt8* bindPoseBuffer;
const NzIndexBuffer* indexBuffer = nullptr;
NzVertexBuffer* vertexBuffer;
@ -208,14 +208,14 @@ void NzSkeletalMesh::Finish()
Skin();
}
const NzAxisAlignedBoxf& NzSkeletalMesh::GetAABB() const
const NzCubef& NzSkeletalMesh::GetAABB() const
{
#if NAZARA_UTILITY_SAFE
if (!m_impl)
{
NazaraError("Skeletal mesh not created");
static NzAxisAlignedBoxf dummy(nzExtend_Null);
static NzCubef dummy;
return dummy;
}
#endif

19
src/Nazara/Utility/Skeleton.cpp
View File

@ -10,7 +10,8 @@ struct NzSkeletonImpl
{
std::map<NzString, unsigned int> jointMap; ///FIXME: unordered_map
std::vector<NzJoint> joints;
NzAxisAlignedBoxf aabb;
NzCubef aabb;
bool aabbUpdated = false;
bool jointMapUpdated = false;
};
@ -50,22 +51,24 @@ void NzSkeleton::Destroy()
}
}
const NzAxisAlignedBoxf& NzSkeleton::GetAABB() const
const NzCubef& NzSkeleton::GetAABB() const
{
#if NAZARA_UTILITY_SAFE
if (!m_impl)
{
NazaraError("Skeleton not created");
static NzAxisAlignedBoxf dummy(nzExtend_Null);
static NzCubef dummy;
return dummy;
}
#endif
if (m_impl->aabb.IsNull())
if (!m_impl->aabbUpdated)
{
for (unsigned int i = 0; i < m_impl->joints.size(); ++i)
m_impl->aabb.ExtendTo(m_impl->joints[i].GetPosition());
m_impl->aabbUpdated = true;
}
return m_impl->aabb;
@ -95,7 +98,7 @@ NzJoint* NzSkeleton::GetJoint(const NzString& jointName)
#endif
// Invalidation de l'AABB
m_impl->aabb.MakeNull();
m_impl->aabbUpdated = false;
return &m_impl->joints[it->second];
}
@ -117,7 +120,7 @@ NzJoint* NzSkeleton::GetJoint(unsigned int index)
#endif
// Invalidation de l'AABB
m_impl->aabb.MakeNull();
m_impl->aabbUpdated = false;
return &m_impl->joints[index];
}
@ -265,7 +268,7 @@ void NzSkeleton::Interpolate(const NzSkeleton& skeletonA, const NzSkeleton& skel
for (unsigned int i = 0; i < m_impl->joints.size(); ++i)
m_impl->joints[i].Interpolate(jointsA[i], jointsB[i], interpolation);
m_impl->aabb.MakeNull();
m_impl->aabbUpdated = false;
}
void NzSkeleton::Interpolate(const NzSkeleton& skeletonA, const NzSkeleton& skeletonB, float interpolation, unsigned int* indices, unsigned int indiceCount)
@ -313,7 +316,7 @@ void NzSkeleton::Interpolate(const NzSkeleton& skeletonA, const NzSkeleton& skel
m_impl->joints[index].Interpolate(jointsA[index], jointsB[index], interpolation);
}
m_impl->aabb.MakeNull();
m_impl->aabbUpdated = false;
}
bool NzSkeleton::IsValid() const

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

@ -39,8 +39,6 @@ bool NzStaticMesh::Create(NzVertexBuffer* vertexBuffer)
void NzStaticMesh::Destroy()
{
m_aabb.MakeNull();
if (m_indexBuffer)
{
m_indexBuffer->RemoveResourceListener(this);
@ -62,9 +60,6 @@ void NzStaticMesh::Finish()
bool NzStaticMesh::GenerateAABB()
{
if (!m_aabb.IsNull())
return true;
// On lock le buffer pour itérer sur toutes les positions et composer notre AABB
NzBufferMapper<NzVertexBuffer> mapper(m_vertexBuffer, nzBufferAccess_ReadOnly);
@ -79,7 +74,7 @@ bool NzStaticMesh::GenerateAABB()
return true;
}
const NzAxisAlignedBoxf& NzStaticMesh::GetAABB() const
const NzCubef& NzStaticMesh::GetAABB() const
{
return m_aabb;
}
@ -114,7 +109,7 @@ bool NzStaticMesh::IsValid() const
return m_vertexBuffer != nullptr;
}
void NzStaticMesh::SetAABB(const NzAxisAlignedBoxf& aabb)
void NzStaticMesh::SetAABB(const NzCubef& aabb)
{
m_aabb = aabb;
}