Vec4.h源代码如下：
#ifndef MATH_VEC4_H
#define MATH_VEC4_H
#define MATH_FLOAT_SMALL 1.0e-37f
#define MATH_TOLERANCE 2e-37f
#ifndef CCASSERT
#if COCOS2D_DEBUG > 0
// todo: minggo
// #if CC_ENABLE_SCRIPT_BINDING
// extern bool CC_DLL cc_assert_script_compatible(const char *msg);
// #define CCASSERT(cond, msg) do { \
// if (!(cond)) { \
// if (!cc_assert_script_compatible(msg) && strlen(msg)) \
// cocos2d::log("Assert failed: %s", msg); \
// CC_ASSERT(cond); \
// } \
// } while (0)
// #else
#define CCASSERT(cond, msg) CC_ASSERT(cond)
// #endif
#else
#define CCASSERT(cond, msg)
#endif
#define GP_ASSERT(cond) CCASSERT(cond, "")
#endif // CCASSERT
class Mat4;
/**
* Defines 4-element floating point vector.
*/
class Vec4
{
public:
#ifdef __SSE__
union {
struct {
float x;
float y;
float z;
float w;
};
__m128 v;
};
#else
/**
* The x-coordinate.
*/
float x;
/**
* The y-coordinate.
*/
float y;
/**
* The z-coordinate.
*/
float z;
/**
* The w-coordinate.
*/
float w;
#endif
/**
* Constructs a new vector initialized to all zeros.
*/
Vec4();
/**
* Constructs a new vector initialized to the specified values.
*
* @param xx The x coordinate.
* @param yy The y coordinate.
* @param zz The z coordinate.
* @param ww The w coordinate.
*/
Vec4(float xx, float yy, float zz, float ww);
/**
* Constructs a new vector from the values in the specified array.
*
* @param array An array containing the elements of the vector in the order x, y, z, w.
*/
Vec4(const float* array);
/**
* Constructs a vector that describes the direction between the specified points.
*
* @param p1 The first point.
* @param p2 The second point.
*/
Vec4(const Vec4& p1, const Vec4& p2);
/**
* Constructor.
*
* Creates a new vector that is a copy of the specified vector.
*
* @param copy The vector to copy.
*/
Vec4(const Vec4& copy);
/**
* Creates a new vector from an integer interpreted as an RGBA value.
* E.g. 0xff0000ff represents opaque red or the vector (1, 0, 0, 1).
*
* @param color The integer to interpret as an RGBA value.
*
* @return A vector corresponding to the interpreted RGBA color.
*/
static Vec4 fromColor(unsigned int color);
/**
* Destructor.
*/
~Vec4();
/**
* Indicates whether this vector contains all zeros.
*
* @return true if this vector contains all zeros, false otherwise.
*/
bool isZero() const;
/**
* Indicates whether this vector contains all ones.
*
* @return true if this vector contains all ones, false otherwise.
*/
bool isOne() const;
/**
* Returns the angle (in radians) between the specified vectors.
*
* @param v1 The first vector.
* @param v2 The second vector.
*
* @return The angle between the two vectors (in radians).
*/
static float angle(const Vec4& v1, const Vec4& v2);
/**
* Adds the elements of the specified vector to this one.
*
* @param v The vector to add.
*/
void add(const Vec4& v);
/**
* Adds the specified vectors and stores the result in dst.
*
* @param v1 The first vector.
* @param v2 The second vector.
* @param dst A vector to store the result in.
*/
static void add(const Vec4& v1, const Vec4& v2, Vec4* dst);
/**
* Clamps this vector within the specified range.
*
* @param min The minimum value.
* @param max The maximum value.
*/
void clamp(const Vec4& min, const Vec4& max);
/**
* Clamps the specified vector within the specified range and returns it in dst.
*
* @param v The vector to clamp.
* @param min The minimum value.
* @param max The maximum value.
* @param dst A vector to store the result in.
*/
static void clamp(const Vec4& v, const Vec4& min, const Vec4& max, Vec4* dst);
/**
* Returns the distance between this vector and v.
*
* @param v The other vector.
*
* @return The distance between this vector and v.
*
* @see distanceSquared
*/
float distance(const Vec4& v) const;
/**
* Returns the squared distance between this vector and v.
*
* When it is not necessary to get the exact distance between
* two vectors (for example, when simply comparing the
* distance between different vectors), it is advised to use
* this method instead of distance.
*
* @param v The other vector.
*
* @return The squared distance between this vector and v.
*
* @see distance
*/
float distanceSquared(const Vec4& v) const;
/**
* Returns the dot product of this vector and the specified vector.
*
* @param v The vector to compute the dot product with.
*
* @return The dot product.
*/
float dot(const Vec4& v) const;
/**
* Returns the dot product between the specified vectors.
*
* @param v1 The first vector.
* @param v2 The second vector.
*
* @return The dot product between the vectors.
*/
static float dot(const Vec4& v1, const Vec4& v2);
/**
* Computes the length of this vector.
*
* @return The length of the vector.
*
* @see lengthSquared
*/
float length() const;
/**
* Returns the squared length of this vector.
*
* When it is not necessary to get the exact length of a
* vector (for example, when simply comparing the lengths of
* different vectors), it is advised to use this method
* instead of length.
*
* @return The squared length of the vector.
*
* @see length
*/
float lengthSquared() const;
/**
* Negates this vector.
*/
void negate();
/**
* Normalizes this vector.
*
* This method normalizes this Vec4 so that it is of
* unit length (in other words, the length of the vector
* after calling this method will be 1.0f). If the vector
* already has unit length or if the length of the vector
* is zero, this method does nothing.
*
* @return This vector, after the normalization occurs.
*/
void normalize();
/**
* Get the normalized vector.
*/
Vec4 getNormalized() const;
/**
* Scales all elements of this vector by the specified value.
*
* @param scalar The scalar value.
*/
void scale(float scalar);
/**
* Sets the elements of this vector to the specified values.
*
* @param xx The new x coordinate.
* @param yy The new y coordinate.
* @param zz The new z coordinate.
* @param ww The new w coordinate.
*/
void set(float xx, float yy, float zz, float ww);
/**
* Sets the elements of this vector from the values in the specified array.
*
* @param array An array containing the elements of the vector in the order x, y, z, w.
*/
void set(const float* array);
/**
* Sets the elements of this vector to those in the specified vector.
*
* @param v The vector to copy.
*/
void set(const Vec4& v);
/**
* Sets this vector to the directional vector between the specified points.
*
* @param p1 The first point.
* @param p2 The second point.
*/
void set(const Vec4& p1, const Vec4& p2);
/**
* Subtracts this vector and the specified vector as (this - v)
* and stores the result in this vector.
*
* @param v The vector to subtract.
*/
void subtract(const Vec4& v);
/**
* Subtracts the specified vectors and stores the result in dst.
* The resulting vector is computed as (v1 - v2).
*
* @param v1 The first vector.
* @param v2 The second vector.
* @param dst The destination vector.
*/
static void subtract(const Vec4& v1, const Vec4& v2, Vec4* dst);
/**
* Calculates the sum of this vector with the given vector.
*
* Note: this does not modify this vector.
*
* @param v The vector to add.
* @return The vector sum.
*/
inline const Vec4 operator+(const Vec4& v) const;
/**
* Adds the given vector to this vector.
*
* @param v The vector to add.
* @return This vector, after the addition occurs.
*/
inline Vec4& operator+=(const Vec4& v);
/**
* Calculates the sum of this vector with the given vector.
*
* Note: this does not modify this vector.
*
* @param v The vector to add.
* @return The vector sum.
*/
inline const Vec4 operator-(const Vec4& v) const;
/**
* Subtracts the given vector from this vector.
*
* @param v The vector to subtract.
* @return This vector, after the subtraction occurs.
*/
inline Vec4& operator-=(const Vec4& v);
/**
* Calculates the negation of this vector.
*
* Note: this does not modify this vector.
*
* @return The negation of this vector.
*/
inline const Vec4 operator-() const;
/**
* Calculates the scalar product of this vector with the given value.
*
* Note: this does not modify this vector.
*
* @param s The value to scale by.
* @return The scaled vector.
*/
inline const Vec4 operator*(float s) const;
/**
* Scales this vector by the given value.
*
* @param s The value to scale by.
* @return This vector, after the scale occurs.
*/
inline Vec4& operator*=(float s);
/**
* Returns the components of this vector divided by the given constant
*
* Note: this does not modify this vector.
*
* @param s the constant to divide this vector with
* @return a smaller vector
*/
inline const Vec4 operator/(float s) const;
/**
* Determines if this vector is less than the given vector.
*
* @param v The vector to compare against.
*
* @return True if this vector is less than the given vector, false otherwise.
*/
inline bool operator<(const Vec4& v) const;
/**
* Determines if this vector is equal to the given vector.
*
* @param v The vector to compare against.
*
* @return True if this vector is equal to the given vector, false otherwise.
*/
inline bool operator==(const Vec4& v) const;
/**
* Determines if this vector is not equal to the given vector.
*
* @param v The vector to compare against.
*
* @return True if this vector is not equal to the given vector, false otherwise.
*/
inline bool operator!=(const Vec4& v) const;
/** equals to Vec4(0,0,0,0) */
static const Vec4 ZERO;
/** equals to Vec4(1,1,1,1) */
static const Vec4 ONE;
/** equals to Vec4(1,0,0,0) */
static const Vec4 UNIT_X;
/** equals to Vec4(0,1,0,0) */
static const Vec4 UNIT_Y;
/** equals to Vec4(0,0,1,0) */
static const Vec4 UNIT_Z;
/** equals to Vec4(0,0,0,1) */
static const Vec4 UNIT_W;
};
/**
* Calculates the scalar product of the given vector with the given value.
*
* @param x The value to scale by.
* @param v The vector to scale.
* @return The scaled vector.
*/
inline const Vec4 operator*(float x, const Vec4& v);
#include "Vec4.inl"
#endif // MATH_VEC4_H
Vec4.inl源代码如下：
#include "Vec4.h"
inline const Vec4 Vec4::operator+(const Vec4& v) const
{
Vec4 result(*this);
result.add(v);
return result;
}
inline Vec4& Vec4::operator+=(const Vec4& v)
{
add(v);
return *this;
}
inline const Vec4 Vec4::operator-(const Vec4& v) const
{
Vec4 result(*this);
result.subtract(v);
return result;
}
inline Vec4& Vec4::operator-=(const Vec4& v)
{
subtract(v);
return *this;
}
inline const Vec4 Vec4::operator-() const
{
Vec4 result(*this);
result.negate();
return result;
}
inline const Vec4 Vec4::operator*(float s) const
{
Vec4 result(*this);
result.scale(s);
return result;
}
inline Vec4& Vec4::operator*=(float s)
{
scale(s);
return *this;
}
inline const Vec4 Vec4::operator/(const float s) const
{
return Vec4(this->x / s, this->y / s, this->z / s, this->w / s);
}
inline bool Vec4::operator<(const Vec4& v) const
{
if (x == v.x)
{
if (y == v.y)
{
if (z < v.z)
{
if (w < v.w)
{
return w < v.w;
}
}
return z < v.z;
}
return y < v.y;
}
return x < v.x;
}
inline bool Vec4::operator==(const Vec4& v) const
{
return x == v.x && y == v.y && z == v.z && w == v.w;
}
inline bool Vec4::operator!=(const Vec4& v) const
{
return x != v.x || y != v.y || z != v.z || w != v.w;
}
inline const Vec4 operator*(float x, const Vec4& v)
{
Vec4 result(v);
result.scale(x);
return result;
}
vec4.cpp代码如下：
#include "Vec4.h"
#include <cmath>
Vec4::Vec4()
: x(0.0f), y(0.0f), z(0.0f), w(0.0f)
{
}
Vec4::Vec4(float xx, float yy, float zz, float ww)
: x(xx), y(yy), z(zz), w(ww)
{
}
Vec4::Vec4(const float* src)
{
set(src);
}
Vec4::Vec4(const Vec4& p1, const Vec4& p2)
{
set(p1, p2);
}
Vec4::Vec4(const Vec4& copy)
{
set(copy);
}
Vec4 Vec4::fromColor(unsigned int color)
{
float components[4];
int componentIndex = 0;
for (int i = 3; i >= 0; --i)
{
int component = (color >> i * 8) & 0x000000ff;
components[componentIndex++] = static_cast<float>(component) / 255.0f;
}
Vec4 value(components);
return value;
}
Vec4::~Vec4()
{
}
bool Vec4::isZero() const
{
return x == 0.0f && y == 0.0f && z == 0.0f && w == 0.0f;
}
bool Vec4::isOne() const
{
return x == 1.0f && y == 1.0f && z == 1.0f && w == 1.0f;
}
float Vec4::angle(const Vec4& v1, const Vec4& v2)
{
float dx = v1.w * v2.x - v1.x * v2.w - v1.y * v2.z + v1.z * v2.y;
float dy = v1.w * v2.y - v1.y * v2.w - v1.z * v2.x + v1.x * v2.z;
float dz = v1.w * v2.z - v1.z * v2.w - v1.x * v2.y + v1.y * v2.x;
return std::atan2(std::sqrt(dx * dx + dy * dy + dz * dz) + MATH_FLOAT_SMALL, dot(v1, v2));
}
void Vec4::add(const Vec4& v)
{
x += v.x;
y += v.y;
z += v.z;
w += v.w;
}
void Vec4::add(const Vec4& v1, const Vec4& v2, Vec4* dst)
{
GP_ASSERT(dst);
dst->x = v1.x + v2.x;
dst->y = v1.y + v2.y;
dst->z = v1.z + v2.z;
dst->w = v1.w + v2.w;
}
void Vec4::clamp(const Vec4& min, const Vec4& max)
{
GP_ASSERT(!(min.x > max.x || min.y > max.y || min.z > max.z || min.w > max.w));
// Clamp the x value.
if (x < min.x)
x = min.x;
if (x > max.x)
x = max.x;
// Clamp the y value.
if (y < min.y)
y = min.y;
if (y > max.y)
y = max.y;
// Clamp the z value.
if (z < min.z)
z = min.z;
if (z > max.z)
z = max.z;
// Clamp the z value.
if (w < min.w)
w = min.w;
if (w > max.w)
w = max.w;
}
void Vec4::clamp(const Vec4& v, const Vec4& min, const Vec4& max, Vec4* dst)
{
GP_ASSERT(dst);
GP_ASSERT(!(min.x > max.x || min.y > max.y || min.z > max.z || min.w > max.w));
// Clamp the x value.
dst->x = v.x;
if (dst->x < min.x)
dst->x = min.x;
if (dst->x > max.x)
dst->x = max.x;
// Clamp the y value.
dst->y = v.y;
if (dst->y < min.y)
dst->y = min.y;
if (dst->y > max.y)
dst->y = max.y;
// Clamp the z value.
dst->z = v.z;
if (dst->z < min.z)
dst->z = min.z;
if (dst->z > max.z)
dst->z = max.z;
// Clamp the w value.
dst->w = v.w;
if (dst->w < min.w)
dst->w = min.w;
if (dst->w > max.w)
dst->w = max.w;
}
float Vec4::distance(const Vec4& v) const
{
float dx = v.x - x;
float dy = v.y - y;
float dz = v.z - z;
float dw = v.w - w;
return std::sqrt(dx * dx + dy * dy + dz * dz + dw * dw);
}
float Vec4::distanceSquared(const Vec4& v) const
{
float dx = v.x - x;
float dy = v.y - y;
float dz = v.z - z;
float dw = v.w - w;
return (dx * dx + dy * dy + dz * dz + dw * dw);
}
float Vec4::dot(const Vec4& v) const
{
return (x * v.x + y * v.y + z * v.z + w * v.w);
}
float Vec4::dot(const Vec4& v1, const Vec4& v2)
{
return (v1.x * v2.x + v1.y * v2.y + v1.z * v2.z + v1.w * v2.w);
}
float Vec4::length() const
{
return std::sqrt(x * x + y * y + z * z + w * w);
}
float Vec4::lengthSquared() const
{
return (x * x + y * y + z * z + w * w);
}
void Vec4::negate()
{
x = -x;
y = -y;
z = -z;
w = -w;
}
void Vec4::normalize()
{
float n = x * x + y * y + z * z + w * w;
// Already normalized.
if (n == 1.0f)
return;
n = std::sqrt(n);
// Too close to zero.
if (n < MATH_TOLERANCE)
return;
n = 1.0f / n;
x *= n;
y *= n;
z *= n;
w *= n;
}
Vec4 Vec4::getNormalized() const
{
Vec4 v(*this);
v.normalize();
return v;
}
void Vec4::scale(float scalar)
{
x *= scalar;
y *= scalar;
z *= scalar;
w *= scalar;
}
void Vec4::set(float xx, float yy, float zz, float ww)
{
this->x = xx;
this->y = yy;
this->z = zz;
this->w = ww;
}
void Vec4::set(const float* array)
{
GP_ASSERT(array);
x = array[0];
y = array[1];
z = array[2];
w = array[3];
}
void Vec4::set(const Vec4& v)
{
this->x = v.x;
this->y = v.y;
this->z = v.z;
this->w = v.w;
}
void Vec4::set(const Vec4& p1, const Vec4& p2)
{
x = p2.x - p1.x;
y = p2.y - p1.y;
z = p2.z - p1.z;
w = p2.w - p1.w;
}
void Vec4::subtract(const Vec4& v)
{
x -= v.x;
y -= v.y;
z -= v.z;
w -= v.w;
}
void Vec4::subtract(const Vec4& v1, const Vec4& v2, Vec4* dst)
{
GP_ASSERT(dst);
dst->x = v1.x - v2.x;
dst->y = v1.y - v2.y;
dst->z = v1.z - v2.z;
dst->w = v1.w - v2.w;
}
const Vec4 Vec4::ZERO = Vec4(0.0f, 0.0f, 0.0f, 0.0f);
const Vec4 Vec4::ONE = Vec4(1.0f, 1.0f, 1.0f, 1.0f);
const Vec4 Vec4::UNIT_X = Vec4(1.0f, 0.0f, 0.0f, 0.0f);
const Vec4 Vec4::UNIT_Y = Vec4(0.0f, 1.0f, 0.0f, 0.0f);
const Vec4 Vec4::UNIT_Z = Vec4(0.0f, 0.0f, 1.0f, 0.0f);
const Vec4 Vec4::UNIT_W = Vec4(0.0f, 0.0f, 0.0f, 1.0f);