728 lines
18 KiB
C++
728 lines
18 KiB
C++
/****************************************************************************
|
|
Copyright (c) 2007, Radon Labs GmbH
|
|
Copyright (c) 2011-2013,WebJet Business Division,CYOU
|
|
|
|
http://www.genesis-3d.com.cn
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
****************************************************************************/
|
|
#pragma once
|
|
#include "core/types.h"
|
|
#include "math/scalar.h"
|
|
#include "math/OgreMath/OgreVector4.h"
|
|
|
|
//------------------------------------------------------------------------------
|
|
namespace Math
|
|
{
|
|
class matrix44;
|
|
class float4;
|
|
|
|
// win32 VC++ does not support passing aligned objects as value so far
|
|
// here is a bug-report at microsoft saying so:
|
|
// http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=334581
|
|
typedef const float4& __Float4Arg;
|
|
|
|
|
|
class float4
|
|
{
|
|
public:
|
|
/// default constructor, NOTE: does NOT setup components!
|
|
float4();
|
|
/// construct from values
|
|
float4(scalar x, scalar y, scalar z, scalar w);
|
|
/// !!!! copy constructor forbidden, otherwise passing float4's to a function
|
|
/// !!!! via Registers doesnt work
|
|
//float4(const float4& rhs);
|
|
/// construct from Ogre::Vector4
|
|
float4(Ogre::Vector4 rhs);
|
|
|
|
/// assignment operator
|
|
void operator=(const float4 &rhs);
|
|
/// assign an Ogre::Vector4
|
|
void operator=(Ogre::Vector4 rhs);
|
|
/// flip sign
|
|
float4 operator-() const;
|
|
/// inplace add
|
|
void operator+=(const float4 &rhs);
|
|
/// inplace sub
|
|
void operator-=(const float4 &rhs);
|
|
/// inplace scalar multiply
|
|
void operator*=(scalar s);
|
|
/// muliply by a vector component-wise
|
|
void operator*=(const float4& rhs);
|
|
/// add 2 vectors
|
|
float4 operator+(const float4 &rhs) const;
|
|
/// subtract 2 vectors
|
|
float4 operator-(const float4 &rhs) const;
|
|
/// multiply with scalar
|
|
float4 operator*(scalar s) const;
|
|
/// equality operator
|
|
bool operator==(const float4 &rhs) const;
|
|
/// inequality operator
|
|
bool operator!=(const float4 &rhs) const;
|
|
/// [] operator
|
|
scalar& operator[](const IndexT &index);
|
|
|
|
/// write content to unaligned memory through the write cache
|
|
void storeu(scalar* ptr) const;
|
|
/// load content from unaligned memory
|
|
void loadu(const scalar* ptr);
|
|
/// stream content to 16-byte-aligned memory circumventing the write-cache
|
|
void stream(scalar* ptr) const;
|
|
|
|
/// set content
|
|
void set(scalar x, scalar y, scalar z, scalar w);
|
|
/// set the x component
|
|
void set_x(scalar x);
|
|
/// set the y component
|
|
void set_y(scalar y);
|
|
/// set the z component
|
|
void set_z(scalar z);
|
|
/// set the w component
|
|
void set_w(scalar w);
|
|
|
|
/// read/write access to x component
|
|
scalar& x();
|
|
/// read/write access to y component
|
|
scalar& y();
|
|
/// read/write access to z component
|
|
scalar& z();
|
|
/// read/write access to w component
|
|
scalar& w();
|
|
/// read-only access to x component
|
|
scalar x() const;
|
|
/// read-only access to y component
|
|
scalar y() const;
|
|
/// read-only access to z component
|
|
scalar z() const;
|
|
/// read-only access to w component
|
|
scalar w() const;
|
|
|
|
/// return length of vector
|
|
scalar length() const;
|
|
/// return squared length of vector
|
|
scalar lengthsq() const;
|
|
/// return compononent-wise absolute
|
|
float4 abs() const;
|
|
|
|
/// return 1.0 / vec
|
|
static float4 reciprocal(const float4 &v);
|
|
/// component-wise multiplication
|
|
static float4 multiply(const float4 &v0, const float4 &v1);
|
|
/// return 3-dimensional cross product
|
|
static float4 cross3(const float4 &v0, const float4 &v1);
|
|
/// return 3d dot product of vectors
|
|
static scalar dot3(const float4 &v0, const float4 &v1);
|
|
/// return 4d dot product of vectors
|
|
static scalar dot4(const float4 &v0, const float4 &v1);
|
|
/// perform linear interpolation between 2 4d vectors
|
|
static float4 lerp(const float4 &v0, const float4 &v1, scalar s);
|
|
/// return 4d vector made up of largest components of 2 vectors
|
|
static float4 maximize(const float4 &v0, const float4 &v1);
|
|
/// return 4d vector made up of smallest components of 2 vectors
|
|
static float4 minimize(const float4 &v0, const float4 &v1);
|
|
/// return normalized version of 4d vector
|
|
static float4 normalize(const float4 &v);
|
|
/// return floor of every vec elements
|
|
static float4 floor(const float4 &v);
|
|
|
|
/// transform 4d vector by matrix44
|
|
#ifdef __VC__
|
|
static __declspec(deprecated) float4 transform(const matrix44 &m, __Float4Arg v);
|
|
#else
|
|
static float4 transform(const matrix44 &m, __Float4Arg v);
|
|
#endif
|
|
|
|
|
|
/// return true if any XYZ component is less-then
|
|
static bool less3_any(const float4 &v0, const float4 &v1);
|
|
/// return true if all XYZ components are less-then
|
|
static bool less3_all(const float4 &v0, const float4 &v1);
|
|
/// return true if any XYZ component is greater
|
|
static bool greater3_any(const float4 &v0, const float4 &v1);
|
|
/// return true if any XYZ component is greater-or-equal
|
|
static bool greaterequal3_any(const float4 &v0, const float4 &v1);
|
|
/// return true if all XYZ components are greater-or-equal
|
|
static bool greaterequal3_all(const float4 &v0, const float4 &v1);
|
|
/// return true if any XYZ component is equal
|
|
static bool equal3_any(const float4 &v0, const float4 &v1);
|
|
/// return true if all XYZ components are equal
|
|
static bool equal3_all(const float4 &v0, const float4 &v1);
|
|
|
|
/// return true if any XYZW component is less-then
|
|
static bool less4_any(const float4 &v0, const float4 &v1);
|
|
/// unpack the first element from a Ogre::Vector4
|
|
static float unpack_x(Ogre::Vector4 v);
|
|
/// unpack the second element from a Ogre::Vector4
|
|
static float unpack_y(Ogre::Vector4 v);
|
|
/// unpack the third element from a Ogre::Vector4
|
|
static float unpack_z(Ogre::Vector4 v);
|
|
/// unpack the fourth element from a Ogre::Vector4
|
|
static float unpack_w(Ogre::Vector4 v);
|
|
|
|
Ogre::Vector4 vec;
|
|
};
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline
|
|
float4::float4()
|
|
: vec(0.0f,0.0f,0.0f,0.0f)
|
|
{
|
|
// empty
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline
|
|
float4::float4(scalar x, scalar y, scalar z, scalar w)
|
|
{
|
|
this->vec = Ogre::Vector4(x, y, z, w);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline
|
|
float4::float4(Ogre::Vector4 rhs) :
|
|
vec(rhs)
|
|
{
|
|
// empty
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline void
|
|
float4::operator=(const float4 &rhs)
|
|
{
|
|
this->vec = rhs.vec;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline void
|
|
float4::operator=(Ogre::Vector4 rhs)
|
|
{
|
|
this->vec = rhs;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline bool
|
|
float4::operator==(const float4 &rhs) const
|
|
{
|
|
return this->vec == rhs.vec;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline bool
|
|
float4::operator!=(const float4 &rhs) const
|
|
{
|
|
return this->vec != rhs.vec;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline scalar&
|
|
float4::operator[](const IndexT &index)
|
|
{
|
|
#if NEBULA3_BOUNDSCHECKS
|
|
n_assert((index>=0) && (index<=3));
|
|
#endif
|
|
return this->vec[index];
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
Store to non-aligned float pointer.
|
|
*/
|
|
__forceinline void
|
|
float4::storeu(scalar* ptr) const
|
|
{
|
|
memcpy(ptr,(void*)this->vec.ptr(),sizeof(float4));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
Load 4 floats from unaligned memory.
|
|
*/
|
|
__forceinline void
|
|
float4::loadu(const scalar* ptr)
|
|
{
|
|
memcpy((void*)this->vec.ptr(),ptr,sizeof(float4));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline void
|
|
float4::stream(scalar* ptr) const
|
|
{
|
|
memcpy(ptr,(void*)this->vec.ptr(),sizeof(float4));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline float4
|
|
float4::operator-() const
|
|
{
|
|
return -this->vec;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline float4
|
|
float4::operator*(scalar t) const
|
|
{
|
|
return this->vec * t;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline void
|
|
float4::operator*=(const float4& rhs)
|
|
{
|
|
this->vec *= rhs.vec;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline void
|
|
float4::operator+=(const float4 &rhs)
|
|
{
|
|
this->vec += rhs.vec;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline void
|
|
float4::operator-=(const float4 &rhs)
|
|
{
|
|
this->vec = this->vec - rhs.vec;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline void
|
|
float4::operator*=(scalar s)
|
|
{
|
|
this->vec *= s;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline float4
|
|
float4::operator+(const float4 &rhs) const
|
|
{
|
|
return this->vec + rhs.vec;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline float4
|
|
float4::operator-(const float4 &rhs) const
|
|
{
|
|
return this->vec - rhs.vec;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline void
|
|
float4::set(scalar x, scalar y, scalar z, scalar w)
|
|
{
|
|
this->vec = Ogre::Vector4(x,y,z,w);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline scalar&
|
|
float4::x()
|
|
{
|
|
return this->vec.x;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline scalar
|
|
float4::x() const
|
|
{
|
|
return float4::unpack_x(this->vec);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline scalar&
|
|
float4::y()
|
|
{
|
|
return this->vec.y;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline scalar
|
|
float4::y() const
|
|
{
|
|
return float4::unpack_y(this->vec);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline scalar&
|
|
float4::z()
|
|
{
|
|
return this->vec.z;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline scalar
|
|
float4::z() const
|
|
{
|
|
return float4::unpack_z(this->vec);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline scalar&
|
|
float4::w()
|
|
{
|
|
return this->vec.w;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline scalar
|
|
float4::w() const
|
|
{
|
|
return float4::unpack_w(this->vec);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline void
|
|
float4::set_x(scalar x)
|
|
{
|
|
this->vec.x = x;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline void
|
|
float4::set_y(scalar y)
|
|
{
|
|
this->vec.y = y;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline void
|
|
float4::set_z(scalar z)
|
|
{
|
|
this->vec.z = z;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline void
|
|
float4::set_w(scalar w)
|
|
{
|
|
this->vec.w = w;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline scalar
|
|
float4::length() const
|
|
{
|
|
return Ogre::Vector3(this->vec.x,this->vec.y,this->vec.z).length();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline scalar
|
|
float4::lengthsq() const
|
|
{
|
|
return Ogre::Vector3(this->vec.x,this->vec.y,this->vec.z).squaredLength();
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline float4
|
|
float4::reciprocal(const float4 &v)
|
|
{
|
|
return 1/v.vec;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline float4
|
|
float4::multiply(const float4 &v0, const float4 &v1)
|
|
{
|
|
return float4(v0.vec * v1.vec);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline float4
|
|
float4::abs() const
|
|
{
|
|
return float4(fabsf(this->vec.x),fabsf(this->vec.y),fabsf(this->vec.z),fabsf(this->vec.w));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline float4
|
|
float4::cross3(const float4 &v0, const float4 &v1)
|
|
{
|
|
return float4(Ogre::Vector4(Ogre::Vector3(v0.vec.x,v0.vec.y,v0.vec.z).crossProduct(Ogre::Vector3(v1.vec.x,v1.vec.y,v1.vec.z))));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline scalar
|
|
float4::dot3(const float4 &v0, const float4 &v1)
|
|
{
|
|
return Ogre::Vector3(v0.vec.x,v0.vec.y,v0.vec.z).dotProduct(Ogre::Vector3(v1.vec.x,v1.vec.y,v1.vec.z));
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline scalar
|
|
float4::dot4(const float4 &v0, const float4 &v1)
|
|
{
|
|
return v0.vec.x * v1.vec.x + v0.vec.y * v1.vec.y + v0.vec.z * v1.vec.z + v0.vec.w * v1.vec.w;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline float4
|
|
float4::lerp(const float4 &v0, const float4 &v1, scalar s)
|
|
{
|
|
float4 Result;
|
|
|
|
Result.set_x(v0.vec.x + s * (v1.vec.x - v0.vec.x));
|
|
Result.set_y(v0.vec.y + s * (v1.vec.y - v0.vec.y));
|
|
Result.set_z(v0.vec.z + s * (v1.vec.z - v0.vec.z));
|
|
Result.set_w(v0.vec.w + s * (v1.vec.w - v0.vec.w));
|
|
|
|
return Result;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline float4
|
|
float4::maximize(const float4 &v0, const float4 &v1)
|
|
{
|
|
float4 result;
|
|
result.set_x(v0.vec.x > v1.vec.x ? v0.vec.x : v1.vec.x);
|
|
result.set_y(v0.vec.y > v1.vec.y ? v0.vec.y : v1.vec.y);
|
|
result.set_z(v0.vec.z > v1.vec.z ? v0.vec.z : v1.vec.z);
|
|
result.set_w(v0.vec.w > v1.vec.w ? v0.vec.w : v1.vec.w);
|
|
return result;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline float4
|
|
float4::minimize(const float4 &v0, const float4 &v1)
|
|
{
|
|
float4 result;
|
|
result.set_x(v0.vec.x < v1.vec.x ? v0.vec.x : v1.vec.x);
|
|
result.set_y(v0.vec.y < v1.vec.y ? v0.vec.y : v1.vec.y);
|
|
result.set_z(v0.vec.z < v1.vec.z ? v0.vec.z : v1.vec.z);
|
|
result.set_w(v0.vec.w < v1.vec.w ? v0.vec.w : v1.vec.w);
|
|
return result;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline float4
|
|
float4::normalize(const float4 &v)
|
|
{
|
|
if (float4::equal3_all(v, float4(0,0,0,0))) return v;
|
|
else
|
|
{
|
|
scalar fLength = Ogre::Math::Sqrt( v.vec.x * v.vec.x + v.vec.y * v.vec.y + v.vec.z * v.vec.z + v.vec.w + v.vec.w );
|
|
// Will also work for zero-sized vectors, but will change nothing
|
|
if ( fLength > 1e-08 )
|
|
{
|
|
float4 retv = v;
|
|
scalar fInvLength = 1.0f / fLength;
|
|
retv.vec.x *= fInvLength;
|
|
retv.vec.y *= fInvLength;
|
|
retv.vec.z *= fInvLength;
|
|
retv.vec.w *= fInvLength;
|
|
return retv;
|
|
}
|
|
return v;
|
|
}
|
|
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline bool
|
|
float4::less4_any(const float4 &v0, const float4 &v1)
|
|
{
|
|
return (v0.vec.x < v1.vec.x || v0.vec.y < v1.vec.y || v0.vec.z < v1.vec.z || v0.vec.w < v1.vec.w);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline bool
|
|
float4::less3_any(const float4 &v0, const float4 &v1)
|
|
{
|
|
return (v0.vec.x < v1.vec.x || v0.vec.y < v1.vec.y || v0.vec.z < v1.vec.z);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline bool
|
|
float4::less3_all(const float4 &v0, const float4 &v1)
|
|
{
|
|
return (v0.vec.x < v1.vec.x && v0.vec.y < v1.vec.y && v0.vec.z < v1.vec.z);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline bool
|
|
float4::greater3_any(const float4 &v0, const float4 &v1)
|
|
{
|
|
return (v0.vec.x > v1.vec.x || v0.vec.y > v1.vec.y || v0.vec.z > v1.vec.z);
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline bool
|
|
float4::greaterequal3_all(const float4 &v0, const float4 &v1)
|
|
{
|
|
return (v0.vec.x >= v1.vec.x && v0.vec.y >= v1.vec.y && v0.vec.z >= v1.vec.z);
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline bool
|
|
float4::equal3_all(const float4 &v0, const float4 &v1)
|
|
{
|
|
return (v0.vec.x == v1.vec.x && v0.vec.y == v1.vec.y && v0.vec.z == v1.vec.z);
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline float
|
|
float4::unpack_x(Ogre::Vector4 v)
|
|
{
|
|
return v.x;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline float
|
|
float4::unpack_y(Ogre::Vector4 v)
|
|
{
|
|
return v.y;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline float
|
|
float4::unpack_z(Ogre::Vector4 v)
|
|
{
|
|
return v.z;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
__forceinline float
|
|
float4::unpack_w(Ogre::Vector4 v)
|
|
{
|
|
return v.w;
|
|
}
|
|
|
|
__forceinline float4
|
|
float4::floor(const float4 &v)
|
|
{
|
|
float4 result;
|
|
result.set(floorf(v.x()),floorf(v.y()),floorf(v.z()),floorf(v.w()));
|
|
return result;
|
|
}
|
|
|
|
} // namespace Math
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|