commit x64 compilation from lulu cause the other branch dont seems to compile properly at home
This commit is contained in:
207
include/framework/math/vector.cpp
Normal file
207
include/framework/math/vector.cpp
Normal file
@ -0,0 +1,207 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
GSFramework
|
||||
Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
|
||||
----------------------------------------------------------------------------- */
|
||||
|
||||
|
||||
#include "metafile/nml.h"
|
||||
#include "math/matrix3.h"
|
||||
#include "math/matrix4.h"
|
||||
#include "rand/rand.h"
|
||||
|
||||
using namespace GS;
|
||||
|
||||
|
||||
namespace GS {
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
template <> tVector2 <int> tVector2 <int> ::operator * (const Matrix3 &m) const
|
||||
{
|
||||
return tVector2 <int> ( (float(x) * m.m[0][0] + float(y) * m.m[0][1] + m.m[0][2]),
|
||||
int(float(x) * m.m[1][0] + float(y) * m.m[1][1] + m.m[1][2]) );
|
||||
}
|
||||
template <> tVector2 <float> tVector2 <float> ::operator * (const Matrix3 &m) const
|
||||
{
|
||||
return tVector2 <float> ( x * m.m[0][0] + y * m.m[0][1] + m.m[0][2],
|
||||
x * m.m[1][0] + y * m.m[1][1] + m.m[1][2] );
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
Vector4 Vector4::Floor() const
|
||||
{ return Vector4(Math::Floor(x), Math::Floor(y), Math::Floor(z), Math::Floor(w)); }
|
||||
Vector4 Vector4::Ceil() const
|
||||
{ return Vector4(Math::Ceil(x), Math::Ceil(y), Math::Ceil(z), Math::Ceil(w)); }
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
Vector4 Vector4::Abs() const
|
||||
{ return Vector4(Types::Abs(x), Types::Abs(y), Types::Abs(z)); }
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
Vector4 Vector4::Clamped(float min, float max) const
|
||||
{
|
||||
float _x, _y, _z;
|
||||
if (x < min) _x = min; else if (x > max) _x = max; else _x = x;
|
||||
if (y < min) _y = min; else if (y > max) _y = max; else _y = y;
|
||||
if (z < min) _z = min; else if (z > max) _z = max; else _z = z;
|
||||
return Vector4(_x, _y, _z);
|
||||
}
|
||||
Vector4 Vector4::Clamped(const Vector4 &min, const Vector4 &max) const
|
||||
{
|
||||
float _x, _y, _z;
|
||||
if (x < min.x) _x = min.x; else if (x > max.x) _x = max.x; else _x = x;
|
||||
if (y < min.y) _y = min.y; else if (y > max.y) _y = max.y; else _y = y;
|
||||
if (z < min.z) _z = min.z; else if (z > max.z) _z = max.z; else _z = z;
|
||||
return Vector4(_x, _y, _z);
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
Vector4 Vector4::ClampedMagnitude(float min, float max) const
|
||||
{
|
||||
float l2 = Len2();
|
||||
if ((l2 >= (min * min)) && (l2 <= (max * max)))
|
||||
return Vector4(*this);
|
||||
if (l2 < 0.000001)
|
||||
return Vector4(*this);
|
||||
float l = Math::Sqrt((float)l2);
|
||||
return (*this) * Types::Clamp(l, min, max) / l;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
void Vector4::operator *= (const Matrix4 &m)
|
||||
{
|
||||
float _x = x, _y = y, _z = z;
|
||||
x = _x * m.m[0][0] + _y * m.m[0][1] + _z * m.m[0][2] + m.m[0][3];
|
||||
y = _x * m.m[1][0] + _y * m.m[1][1] + _z * m.m[1][2] + m.m[1][3];
|
||||
z = _x * m.m[2][0] + _y * m.m[2][1] + _z * m.m[2][2] + m.m[2][3];
|
||||
}
|
||||
Vector4 Vector4::operator * (const Matrix4 &m) const
|
||||
{
|
||||
return Vector4( x * m.m[0][0] + y * m.m[0][1] + z * m.m[0][2] + m.m[0][3],
|
||||
x * m.m[1][0] + y * m.m[1][1] + z * m.m[1][2] + m.m[1][3],
|
||||
x * m.m[2][0] + y * m.m[2][1] + z * m.m[2][2] + m.m[2][3] );
|
||||
}
|
||||
void Vector4::operator *= (const Matrix3 &m)
|
||||
{
|
||||
float _x = x, _y = y, _z = z;
|
||||
x = _x * m.m[0][0] + _y * m.m[0][1] + _z * m.m[0][2];
|
||||
y = _x * m.m[1][0] + _y * m.m[1][1] + _z * m.m[1][2];
|
||||
z = _x * m.m[2][0] + _y * m.m[2][1] + _z * m.m[2][2];
|
||||
}
|
||||
Vector4 Vector4::operator * (const Matrix3 &m) const
|
||||
{
|
||||
return Vector4( x * m.m[0][0] + y * m.m[0][1] + z * m.m[0][2],
|
||||
x * m.m[1][0] + y * m.m[1][1] + z * m.m[1][2],
|
||||
x * m.m[2][0] + y * m.m[2][1] + z * m.m[2][2] );
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
Vector4 Vector4::FaceForward(Vector4 &dir)
|
||||
{
|
||||
if (Dot(dir) >= 0)
|
||||
return Reversed();
|
||||
return *this;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
int Vector4::Hash() const
|
||||
{
|
||||
int a = (int)(x * 10.f), b = (int)(y * 10.f), c = (int)(z * 10.f);
|
||||
// From Christer Ericson's Realtime Collision Detection.
|
||||
return a * 0x8da6b343 + b * 0xd8163841 + c * 0xcb1ab31f;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
void Vector4::BaseToEuler(Vector4 &euler, Vector4 &u, Vector4 *v)
|
||||
{
|
||||
float _v = Math::Sqrt(u.x * u.x + u.y * u.y + u.z * u.z);
|
||||
euler.x = -Math::ASin(u.y / _v);
|
||||
|
||||
_v = Math::Sqrt(u.x * u.x + u.z * u.z);
|
||||
if (_v > 0.00001f)
|
||||
euler.y = Math::ASin(u.x / _v);
|
||||
else euler.y = 0;
|
||||
|
||||
if (u.z < 0.f)
|
||||
{
|
||||
if (euler.y < 0.f)
|
||||
euler.y = - (Math::Pi + euler.y);
|
||||
else euler.y = Math::Pi - euler.y;
|
||||
}
|
||||
euler.z = 0;
|
||||
|
||||
if (v)
|
||||
{
|
||||
Matrix3 mx(Matrix3::RotationMatrixXAxis(Units::Rad(euler.x)));
|
||||
Matrix3 my(Matrix3::RotationMatrixYAxis(Units::Rad(euler.y)));
|
||||
Vector4 bv(Vector4(1,0,0) * my * mx), vn(v->Normalized());
|
||||
const float vc = vn.Dot(bv);
|
||||
|
||||
if (vc >= 1.f)
|
||||
euler.z = 0.f;
|
||||
else if (vc <= -1.f)
|
||||
euler.z = Math::Pi;
|
||||
else euler.z = Math::ACos(vc);
|
||||
|
||||
if ((bv.Cross(vn)).Dot(u) <= 0.f)
|
||||
euler.z = (Math::Pi + Math::Pi) - euler.z;
|
||||
}
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
Vector4 Vector4::Random(float min, float max)
|
||||
{ return Vector4(Random::FRRand(min, max), Random::FRRand(min, max), Random::FRRand(min, max)); }
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
NML::Tag *Vector4::AsMetaTag(const char *id, bool fulldump) const
|
||||
{
|
||||
NML::Tag *root = new NML::Tag(id ? id : "Vector");
|
||||
|
||||
if (root)
|
||||
{
|
||||
root->AddChild("X", x);
|
||||
root->AddChild("Y", y);
|
||||
root->AddChild("Z", z);
|
||||
if (fulldump)
|
||||
root->AddChild("W", w);
|
||||
}
|
||||
return root;
|
||||
}
|
||||
bool Vector4::FromMetaTag(NML::Tag &tag)
|
||||
{
|
||||
NML::Tag *t;
|
||||
List <NML::Tag *> ::Iterator i(tag.GetTags().GetRoot());
|
||||
|
||||
t = i.ObjectPtr();
|
||||
if (!t) return false;
|
||||
x = t->GetReal();
|
||||
++i;
|
||||
|
||||
t = i.ObjectPtr();
|
||||
if (!t) return false;
|
||||
y = t->GetReal();
|
||||
++i;
|
||||
|
||||
t = i.ObjectPtr();
|
||||
if (!t) return false;
|
||||
z = t->GetReal();
|
||||
++i;
|
||||
|
||||
t = i.ObjectPtr();
|
||||
if (t)
|
||||
w = t->GetReal();
|
||||
|
||||
return true;
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
Reference in New Issue
Block a user