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

Merge pull request #27 from Gawaboumga/master 

Merging Gawaboumga pull request (#27), fixes are coming

Former-commit-id: 81079fd052538e15b7e919aea106cfb5a88a87a6
This commit is contained in:
Lynix 2014-07-08 16:24:46 +02:00
parent b3c0168e6a 60d045e139
commit 7103c28d49
14 changed files with 467 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -28,7 +28,7 @@ class NAZARA_API NzHashDigest
NzString ToHex() const;
nzUInt8 operator[](unsigned short pos) const;
nzUInt8 operator[](unsigned int pos) const;
NzHashDigest& operator=(const NzHashDigest& rhs);
NzHashDigest& operator=(NzHashDigest&& rhs) noexcept;
@ -45,7 +45,7 @@ class NAZARA_API NzHashDigest
private:
NzString m_hashName;
nzUInt8* m_digest;
unsigned short m_digestLength;
unsigned int m_digestLength;
};
#endif // NAZARA_HASHDIGEST_HPP

1
include/Nazara/Math.hpp
View File

@ -41,6 +41,7 @@
#include <Nazara/Math/OrientedBox.hpp>
#include <Nazara/Math/Plane.hpp>
#include <Nazara/Math/Quaternion.hpp>
#include <Nazara/Math/Ray.hpp>
#include <Nazara/Math/Rect.hpp>
#include <Nazara/Math/Sphere.hpp>
#include <Nazara/Math/Vector2.hpp>

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

@ -83,9 +83,9 @@ template<typename T>
template<typename U>
void NzEulerAngles<T>::Set(const NzEulerAngles<U>& angles)
{
pitch = static_cast<T>(angles.pitch);
yaw = static_cast<T>(angles.yaw);
roll = static_cast<T>(angles.roll);
pitch = F(angles.pitch);
yaw = F(angles.yaw);
roll = F(angles.roll);
}
template<typename T>

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

@ -1,4 +1,4 @@
// Copyright (C) 2014 Jérôme Leclercq
// Copyright (C) 2014 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
@ -38,6 +38,9 @@ class NzPlane
NzString ToString() const;
static NzPlane Lerp(const NzPlane& from, const NzPlane& to, T interpolation);
static NzPlane XY();
static NzPlane XZ();
static NzPlane YZ();
NzVector3<T> normal;
T distance;

18
include/Nazara/Math/Plane.inl
View File

@ -152,6 +152,24 @@ NzPlane<T> NzPlane<T>::Lerp(const NzPlane& from, const NzPlane& to, T interpolat
return plane;
}
template<typename T>
NzPlane<T> NzPlane<T>::XY()
{
return NzPlane<T>(F(0.0), F(0.0), F(1.0), F(0.0));
}
template<typename T>
NzPlane<T> NzPlane<T>::XZ()
{
return NzPlane<T>(F(0.0), F(1.0), F(0.0), F(0.0));
}
template<typename T>
NzPlane<T> NzPlane<T>::YZ()
{
return NzPlane<T>(F(1.0), F(0.0), F(0.0), F(0.0));
}
template<typename T>
std::ostream& operator<<(std::ostream& out, const NzPlane<T>& plane)
{

69
include/Nazara/Math/Ray.hpp Normal file
View File

@ -0,0 +1,69 @@
// Copyright (C) 2014 Rémi Bèges - 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
#pragma once
#ifndef NAZARA_RAY_HPP
#define NAZARA_RAY_HPP
#include <Nazara/Core/String.hpp>
#include <Nazara/Math/Box.hpp>
#include <Nazara/Math/Frustum.hpp>
#include <Nazara/Math/OrientedBox.hpp>
#include <Nazara/Math/Plane.hpp>
#include <Nazara/Math/Sphere.hpp>
#include <Nazara/Math/Vector3.hpp>
template<typename T> class NzRay
{
public:
NzRay() = default;
NzRay(T X, T Y, T Z, T directionX, T directionY, T directionZ);
NzRay(const T origin[3], const T direction[3]);
NzRay(const NzVector3<T>& origin, const NzVector3<T>& direction);
NzRay(const NzPlane<T>& planeOne, const NzPlane<T>& planeTwo);
template<typename U> explicit NzRay(const NzVector3<U>& origin, const NzVector3<U>& direction);
template<typename U> explicit NzRay(const NzRay<U>& ray);
NzRay(const NzRay<T>& ray) = default;
~NzRay() = default;
NzVector3<T> GetClosestPoint(const NzVector3<T>& point) const;
NzVector3<T> GetPoint(T lambda) const;
bool Intersect(const NzBox<T>& box, NzVector3<T> * hitPoint = nullptr, NzVector3<T> * hitSecondPoint = nullptr) const;
bool Intersect(const NzOrientedBox<T>& orientedBox, NzVector3<T> * hitPoint = nullptr, NzVector3<T> * hitSecondPoint = nullptr) const;
bool Intersect(const NzPlane<T>& plane, NzVector3<T> * hitPoint = nullptr) const;
bool Intersect(const NzSphere<T>& sphere, NzVector3<T> * hitPoint = nullptr, NzVector3<T> * hitSecondPoint = nullptr) const;
NzVector3<T> operator*(T lambda) const;
NzRay& Set(T X, T Y, T Z, T directionX, T directionY, T directionZ);
NzRay& Set(const T origin[3], const T direction[3]);
NzRay& Set(const NzVector3<T>& origin, const NzVector3<T>& direction);
NzRay& Set(const NzPlane<T>& planeOne, const NzPlane<T>& planeTwo);
template<typename U> NzRay& Set(const NzVector3<U>& origin, const NzVector3<U>& direction);
template<typename U> NzRay& Set(const NzRay<U>& ray);
NzRay& Set(const NzRay& ray);
NzRay& SetDirection(const NzVector3<T>& direction);
NzRay& SetOrigin(const NzVector3<T>& origin);
NzString ToString() const;
static NzRay Lerp(const NzRay& from, const NzRay& to, T interpolation);
static NzRay UnitX();
static NzRay UnitY();
static NzRay UnitZ();
NzVector3<T> direction, origin;
};
template<typename T> std::ostream& operator<<(std::ostream& out, const NzRay<T>& vec);
typedef NzRay<double> NzRayd;
typedef NzRay<float> NzRayf;
#include <Nazara/Math/Ray.inl>
#endif // NAZARA_RAY_HPP

328
include/Nazara/Math/Ray.inl Normal file
View File

@ -0,0 +1,328 @@
// Copyright (C) 2014 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/Debug.hpp>
#define F(a) static_cast<T>(a)
template<typename T>
NzRay<T>::NzRay(T X, T Y, T Z, T DirectionX, T DirectionY, T DirectionZ)
{
Set(X, Y, Z, DirectionX, DirectionY, DirectionZ);
}
template<typename T>
NzRay<T>::NzRay(const T Origin[3], const T Direction[3])
{
Set(Origin, Direction);
}
template<typename T>
NzRay<T>::NzRay(const NzVector3<T>& Origin, const NzVector3<T>& Direction)
{
Set(Origin, Direction);
}
template<typename T>
NzRay<T>::NzRay(const NzPlane<T>& planeOne, const NzPlane<T>& planeTwo)
{
Set(planeOne, planeTwo);
}
template<typename T>
template<typename U>
NzRay<T>::NzRay(const NzVector3<U>& Origin, const NzVector3<U>& Direction)
{
Set(Origin, Direction);
}
template<typename T>
template<typename U>
NzRay<T>::NzRay(const NzRay<U>& ray)
{
Set(ray);
}
template<typename T>
NzVector3<T> NzRay<T>::GetClosestPoint(const NzVector3<T>& point) const
{
NzVector3<T> delta = point - origin;
T vsq = direction.GetSquaredLength();
T proj = delta.DotProduct(direction);
return GetPoint(proj/vsq);
}
template<typename T>
NzVector3<T> NzRay<T>::GetPoint(T lambda) const
{
return NzVector3<T>(origin + direction * lambda);
}
template<typename T>
bool NzRay<T>::Intersect(const NzBox<T>& box, NzVector3<T> * hitPoint, NzVector3<T> * hitSecondPoint) const
{
// Slab method
#if NAZARA_MATH_SAFE
if (NzNumberEquals(direction.x, F(0.0)) || NzNumberEquals(direction.y, F(0.0)) || NzNumberEquals(direction.z, F(0.0)))
{
NazaraWarning("Division by zero !"); // The algorithm is still correct.
}
#endif
T tx1 = (box.x - origin.x) / direction.x;
T tx2 = (box.x + box.width - origin.x) / direction.x;
T tmin = std::min(tx1, tx2);
T tmax = std::max(tx1, tx2);
T ty1 = (box.y - origin.y) / direction.y;
T ty2 = (box.y + box.height - origin.y) / direction.y;
tmin = std::max(tmin, std::min(ty1, ty2));
tmax = std::min(tmax, std::max(ty1, ty2));
T tz1 = (box.z - origin.z) / direction.z;
T tz2 = (box.z + box.depth - origin.z) / direction.z;
tmin = std::max(tmin, std::min(tz1, tz2));
tmax = std::min(tmax, std::max(tz1, tz2));
if (hitPoint)
hitPoint->Set(GetPoint(tmin));
if (hitSecondPoint)
hitSecondPoint->Set(GetPoint(tmax));
return tmax >= std::max(F(0.0), tmin) && tmin < INFINITY;
}
template<typename T>
bool NzRay<T>::Intersect(const NzOrientedBox<T>& orientedBox, NzVector3<T> * hitPoint, NzVector3<T> * hitSecondPoint) const
{
NzVector3<T> width = (orientedBox.GetCorner(nzCorner_NearLeftBottom) - orientedBox.GetCorner(nzCorner_FarLeftBottom)).Normalize();
NzVector3<T> height = (orientedBox.GetCorner(nzCorner_FarLeftTop) - orientedBox.GetCorner(nzCorner_FarLeftBottom)).Normalize();
NzVector3<T> depth = (orientedBox.GetCorner(nzCorner_FarRightBottom) - orientedBox.GetCorner(nzCorner_FarLeftBottom)).Normalize();
// Construction of the inverse of the matrix who did the rotation -> orthogonal matrix.
NzMatrix4<T> transformation(width.x, height.x, depth.x, F(0.0),
width.y, height.y, depth.y, F(0.0),
width.z, height.z, depth.z, F(0.0),
F(0.0), F(0.0), F(0.0), F(1.0));
// Reduction to aabb problem
NzVector3<T> newOrigin = transformation.Transform(origin);
NzVector3<T> newDirection = transformation.Transform(direction);
NzVector3<T> tmp, tmp2;
if (NzRay<T>(newOrigin, newDirection).Intersect(NzBox<T>(orientedBox.GetCorner(nzCorner_NearRightTop), orientedBox.GetCorner(nzCorner_FarLeftBottom)), &tmp, &tmp2))
{
if (hitPoint)
{
transformation.Transpose();
hitPoint->Set(transformation.Transform(tmp));
if (hitSecondPoint)
hitSecondPoint->Set(transformation.Transform(tmp2));
}
return true;
}
return false;
}
template<typename T>
bool NzRay<T>::Intersect(const NzPlane<T>& plane, NzVector3<T> * hitPoint) const
{
T divisor = plane.normal.DotProduct(direction);
if (NzNumberEquals(divisor, F(0.0)))
return false; // perpendicular
if (!hitPoint)
return true;
T lambda = - (plane.normal.DotProduct(origin) - plane.distance) / divisor; // The plane is ax+by+cz=d
hitPoint->Set(GetPoint(lambda));
return true;
}
template<typename T>
bool NzRay<T>::Intersect(const NzSphere<T>& sphere, NzVector3<T> * hitPoint, NzVector3<T> * hitSecondPoint) const
{
NzVector3<T> distanceCenterOrigin = sphere.GetPosition() - origin;
T length = distanceCenterOrigin.DotProduct(direction);
if (length < F(0.0))
return false; // ray is perpendicular to the vector origin - center
T squaredDistance = distanceCenterOrigin.GetSquaredLength() - length * length;
T squaredRadius = sphere.GetRadius() * sphere.GetRadius();
if (squaredDistance > squaredRadius)
return false; // if the ray is further than the radius
if (!hitPoint)
return true;
T deltaLambda = std::sqrt(squaredRadius - squaredDistance);
if (hitPoint)
hitPoint->Set(GetPoint(length - deltaLambda));
if (hitSecondPoint)
hitSecondPoint->Set(GetPoint(length + deltaLambda));
return true;
}
template<typename T>
NzVector3<T> NzRay<T>::operator*(T lambda) const
{
return GetPoint(lambda);
}
template<typename T>
NzRay<T>& NzRay<T>::Set(T X, T Y, T Z, T directionX, T directionY, T directionZ)
{
direction = NzVector3<T>(directionX, directionY, directionZ);
origin = NzVector3<T>(X, Y, Z);
return *this;
}
template<typename T>
NzRay<T>& NzRay<T>::Set(const T Origin[3], const T Direction[3])
{
direction = NzVector3<T>(Direction);
origin = NzVector3<T>(Origin);
return *this;
}
template<typename T>
NzRay<T>& NzRay<T>::Set(const NzVector3<T>& Origin, const NzVector3<T>& Direction)
{
direction = Direction;
origin = Origin;
return *this;
}
template<typename T>
NzRay<T>& NzRay<T>::Set(const NzPlane<T>& planeOne, const NzPlane<T>& planeTwo)
{
T termOne = planeOne.normal.GetLength();
T termTwo = planeOne.normal.DotProduct(planeTwo.normal);
T termFour = planeTwo.normal.GetLength();
T det = termOne * termFour - termTwo * termTwo;
#if NAZARA_MATH_SAFE
if (NzNumberEquals(det, F(0.0)))
{
NzString error("Planes are parallel.");
NazaraError(error);
throw std::domain_error(error);
}
#endif
T invdet = F(1.0) / det;
T fc0 = (termFour * -planeOne.distance + termTwo * planeTwo.distance) * invdet;
T fc1 = (termOne * -planeTwo.distance + termTwo * planeOne.distance) * invdet;
direction = planeOne.normal.CrossProduct(planeTwo.normal);
origin = planeOne.normal * fc0 + planeTwo.normal * fc1;
return *this;
}
template<typename T>
template<typename U>
NzRay<T>& NzRay<T>::Set(const NzVector3<U>& Origin, const NzVector3<U>& Direction)
{
direction = NzVector3<T>(Direction);
origin = NzVector3<T>(Origin);
return *this;
}
template<typename T>
template<typename U>
NzRay<T>& NzRay<T>::Set(const NzRay<U>& ray)
{
direction = NzVector3<T>(ray.direction);
origin = NzVector3<T>(ray.origin);
return *this;
}
template<typename T>
NzRay<T>& NzRay<T>::Set(const NzRay& ray)
{
std::memcpy(this, &ray, sizeof(NzRay));
return *this;
}
template<typename T>
NzRay<T>& NzRay<T>::SetDirection(const NzVector3<T>& Direction)
{
direction = Direction;
return *this;
}
template<typename T>
NzRay<T>& NzRay<T>::SetOrigin(const NzVector3<T>& Origin)
{
origin = Origin;
return *this;
}
template<typename T>
NzString NzRay<T>::ToString() const
{
NzStringStream ss;
return ss << "Ray(origin: " << origin.ToString() << ", direction: " << direction.ToString() << ")";
}
template<typename T>
NzRay<T> NzRay<T>::Lerp(const NzRay& from, const NzRay& to, T interpolation)
{
return NzRay<T>(from.origin.Lerp(to.origin, interpolation), from.direction.Lerp(to.direction, interpolation));
}
template<typename T>
NzRay<T> NzRay<T>::UnitX()
{
return NzRay(NzVector3<T>::Zero(), NzVector3<T>::UnitX());
}
template<typename T>
NzRay<T> NzRay<T>::UnitY()
{
return NzRay(NzVector3<T>::Zero(), NzVector3<T>::UnitY());
}
template<typename T>
NzRay<T> NzRay<T>::UnitZ()
{
return NzRay(NzVector3<T>::Zero(), NzVector3<T>::UnitZ());
}
template<typename T>
std::ostream& operator<<(std::ostream& out, const NzRay<T>& ray)
{
return out << ray.ToString();
}
#undef F
#include <Nazara/Core/DebugOff.hpp>

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

@ -117,6 +117,7 @@ NzVector3<T> NzSphere<T>::GetPositiveVertex(const NzVector3<T>& normal) const
return pos;
}
template<typename T>
bool NzSphere<T>::Intersect(const NzBox<T>& box) const
{

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

@ -23,6 +23,8 @@ class NzVector2
T AbsDotProduct(const NzVector2& vec) const;
T AngleBetween(const NzVector2& vec, bool toDegree = true) const;
T Distance(const NzVector2& vec) const;
float Distancef(const NzVector2& vec) const;

9
include/Nazara/Math/Vector2.inl
View File

@ -54,6 +54,15 @@ inline unsigned int NzVector2<unsigned int>::AbsDotProduct(const NzVector2<unsig
return std::labs(x * vec.x) + std::labs(y * vec.y);
}
template<typename T>
T NzVector2<T>::AngleBetween(const NzVector2& vec, bool toDegree) const
{
if (toDegree)
return NzRadianToDegree(std::atan2(vec.y, vec.x) - std::atan2(y, x));
else
return std::atan2(vec.y, vec.x) - std::atan2(y, x);
}
template<typename T>
T NzVector2<T>::Distance(const NzVector2& vec) const
{

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

@ -24,6 +24,8 @@ template<typename T> class NzVector3
T AbsDotProduct(const NzVector3& vec) const;
T AngleBetween(const NzVector3& vec, bool toDegree = true) const;
NzVector3 CrossProduct(const NzVector3& vec) const;
T Distance(const NzVector3& vec) const;

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

@ -60,6 +60,30 @@ inline unsigned int NzVector3<unsigned int>::AbsDotProduct(const NzVector3<unsig
return std::labs(x * vec.x) + std::labs(y * vec.y) + std::labs(z * vec.z);
}
template<typename T>
T NzVector3<T>::AngleBetween(const NzVector3& vec, bool toDegree) const
{
T alpha = DotProduct(vec);
T divisor = (GetLength() * vec.GetLength());
#if NAZARA_MATH_SAFE
if (NzNumberEquals(divisor, F(0.0)))
{
NzString error("Division by zero");
NazaraError(error);
throw std::domain_error(error);
}
#endif
alpha /= divisor;
if (toDegree)
return NzRadianToDegree(std::acos(NzClamp(alpha, F(-1.0), F(1.0))));
else
return std::acos(NzClamp(alpha, F(-1.0), F(1.0)));
}
template<typename T>
NzVector3<T> NzVector3<T>::CrossProduct(const NzVector3& vec) const
{

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

@ -89,7 +89,7 @@ NzString NzHashDigest::ToHex() const
return NzString(new NzString::SharedString(1, length, length, hexOutput));
}
nzUInt8 NzHashDigest::operator[](unsigned short pos) const
nzUInt8 NzHashDigest::operator[](unsigned int pos) const
{
#if NAZARA_CORE_SAFE
if (pos >= m_digestLength)

3
src/Nazara/Physics/Geom.cpp
View File

@ -17,6 +17,9 @@ namespace
case nzPrimitiveType_Box:
return new NzBoxGeom(physWorld, primitive.box.lengths, primitive.matrix);
case nzPrimitiveType_Cone:
return new NzConeGeom(physWorld, primitive.cone.length, primitive.cone.radius, primitive.matrix);
case nzPrimitiveType_Plane:
return new NzBoxGeom(physWorld, NzVector3f(primitive.plane.size.x, 0.01f, primitive.plane.size.y), primitive.matrix);
///TODO: PlaneGeom?