42        template<
typename Type>
 
   45        template<
typename Type>
 
   48        template<
typename Type>
 
   51        template<
typename Type>
 
   54        template<
typename Type>
 
   57        template<
typename Type>
 
   60        template<
typename Type>
 
   63        template<
typename Type>
 
   73        template<
typename Type>
 
   79                union { Type 
x; Type 
s; Type 
r; };
 
   80                union { Type 
y; Type 
t; Type 
g; };
 
   81                union { Type 
z; Type 
u; Type 
b; };
 
   82                union { Type 
w; Type 
v; Type 
a; };
 
   85                explicit Vec4(
const Type &scalar) : 
x(scalar), 
y(scalar), 
z(scalar), 
w(scalar) { }
 
   86                explicit Vec4(
const Vec2<Type> ©, 
const Type &p3, 
const Type &p4) { 
x = copy.
x; 
y = copy.
y; 
z = p3; 
w = p4; }
 
   89                explicit Vec4(
const Type &p1, 
const Type &p2, 
const Type &p3, 
const Type &p4) : 
x(p1), 
y(p2), 
z(p3), 
w(p4) { }
 
   90                explicit Vec4(
const Type &p1, 
const Type &p2, 
const Vec2<Type> ©34) : 
x(p1), 
y(p2), 
z(copy34.
x), 
w(copy34.
y) { }
 
   91                explicit Vec4(
const Type *array_xyzw) : 
x(array_xyzw[0]), 
y(array_xyzw[1]), 
z(array_xyzw[2]), 
w(array_xyzw[3]) { }
 
  158                        Type diff_x = second.
x - first.
x; Type diff_y = second.
y - first.
y; Type diff_z = second.
z - first.
z; Type diff_w = second.
w - first.
w;
 
  159                        return (diff_x >= -epsilon && diff_x <= epsilon && diff_y >= -epsilon && diff_y <= epsilon && diff_z >= -epsilon && diff_z <= epsilon && diff_w >= -epsilon && diff_w <= epsilon);
 
 
  296                bool operator < (
const Vec4<Type>& vector)
 const { 
return w < vector.
w || (
w == vector.
w && (
z < vector.
z || (
z == vector.
z && (
y < vector.
y || (
y == vector.
y && 
x < vector.
x))))); }
 
  300        template<
typename Type>
 
  304        template<
typename Type>
 
  308        template<
typename Type>
 
  312        template<
typename Type>
 
  316        template<
typename Type>
 
  320        template<
typename Type>
 
  324        template<
typename Type>
 
  328        template<
typename Type>
 
  332        template<
typename Type>
 
  336        template<
typename Type>
 
  340        template<
typename Type>
 
  344        template<
typename Type>
 
  347        template<
typename Type>
 
  351                        matrix[0 * 4 + 0] * 
v.x + matrix[0 * 4 + 1] * 
v.y + matrix[0 * 4 + 2] * 
v.z + matrix[0 * 4 + 3] * 
v.w,
 
  352                        matrix[1 * 4 + 0] * 
v.x + matrix[1 * 4 + 1] * 
v.y + matrix[1 * 4 + 2] * 
v.z + matrix[1 * 4 + 3] * 
v.w,
 
  353                        matrix[2 * 4 + 0] * 
v.x + matrix[2 * 4 + 1] * 
v.y + matrix[2 * 4 + 2] * 
v.z + matrix[2 * 4 + 3] * 
v.w,
 
  354                        matrix[3 * 4 + 0] * 
v.x + matrix[3 * 4 + 1] * 
v.y + matrix[3 * 4 + 2] * 
v.z + matrix[3 * 4 + 3] * 
v.w);
 
 
  357        template<
typename Type>
 
  361                        matrix[0 * 4 + 0] * 
v.x + matrix[1 * 4 + 0] * 
v.y + matrix[2 * 4 + 0] * 
v.z + matrix[3 * 4 + 0] * 
v.w,
 
  362                        matrix[0 * 4 + 1] * 
v.x + matrix[1 * 4 + 1] * 
v.y + matrix[2 * 4 + 1] * 
v.z + matrix[3 * 4 + 1] * 
v.w,
 
  363                        matrix[0 * 4 + 2] * 
v.x + matrix[1 * 4 + 2] * 
v.y + matrix[2 * 4 + 2] * 
v.z + matrix[3 * 4 + 2] * 
v.w,
 
  364                        matrix[0 * 4 + 3] * 
v.x + matrix[1 * 4 + 3] * 
v.y + matrix[2 * 4 + 3] * 
v.z + matrix[3 * 4 + 3] * 
v.w);
 
 
  367        template<
typename Type>
 
  376        template<
typename Type>
 
 
 
 
Angle class.
Definition angle.h:60
2D matrix
Definition vec4.h:52
3D matrix
Definition vec4.h:55
4D matrix
Definition vec4.h:58
2D (x,y) point structure.
Definition vec4.h:64
2D (width,height) size structure.
Definition vec4.h:61
2D vector
Definition vec4.h:43
Type y
Definition vec2.h:81
Type x
Definition vec2.h:80
3D vector
Definition vec4.h:46
Type z
Definition vec3.h:81
Type y
Definition vec3.h:80
Type x
Definition vec3.h:79
4D vector
Definition vec4.h:75
Type u
Definition vec4.h:81
Type s
Definition vec4.h:79
bool operator!=(const Vec4< Type > &vector) const
!= operator.
Definition vec4.h:293
Type a
Definition vec4.h:82
Type r
Definition vec4.h:79
Type z
Definition vec4.h:81
static Vec4< Type > rotate3(const Vec4< Type > &vector, const Angle &angle, const Vec4< Type > &axis)
Rotate a vector around an axis. Same as glRotate[f|d](angle, a);.
Vec4(const Vec2< Type > ©, const Type &p3, const Type &p4)
Definition vec4.h:86
Vec4()
Definition vec4.h:84
void operator*=(const Vec4< Type > &vector)
*= operator.
Definition vec4.h:275
Vec4< Type > & normalize3()
Normalizes this vector (not taking into account the w ordinate)
static bool is_equal(const Vec4< Type > &first, const Vec4< Type > &second, Type epsilon)
Returns true if equal within the bounds of an epsilon.
Definition vec4.h:156
Type dot3(const Vec4< Type > &vector) const
Dot products this vector with an other vector (not taking into account the w ordinate).
Definition vec4.h:197
Type y
Definition vec4.h:80
Vec4(const Type &scalar)
Definition vec4.h:85
bool operator==(const Vec4< Type > &vector) const
== operator.
Definition vec4.h:290
static Vec4< Type > cross3(const Vec4< Type > &vector1, const Vec4< Type > &vector2)
Calculate the cross product between two vectors (not taking into account the w ordinate).
Type x
Definition vec4.h:79
void set_xy(const Vec2< Type > &new_v)
Definition vec4.h:162
Type v
Definition vec4.h:82
Vec4< Type > operator-() const
operator.
Definition vec4.h:272
Angle angle3(const Vec4< Type > &vector) const
Calculate the angle between this vector and an other vector (not taking into account the w ordinate).
Vec4< Type > & normalize4()
Normalizes this vector (taking into account the w ordinate)
static Vec4< Type > round(const Vec4< Type > &vector)
Rounds all components on a vector.
Type distance3(const Vec4< Type > &vector) const
Calculate the distance between this vector and an other vector (not taking into account the w ordinat...
Vec4< Type > & rotate3(const Angle &angle, const Vec4< Type > &axis)
Rotate this vector around an axis. Same as glRotate[f|d](angle, a);.
static Vec4< Type > normalize4(const Vec4< Type > &vector)
Normalizes a vector (taking into account the w ordinate)
void operator+=(const Vec4< Type > &vector)
+= operator.
Definition vec4.h:260
Vec4(const Vec3< Type > ©, const Type &p4)
Definition vec4.h:88
Vec4< Type > & operator=(const Vec4< Type > &vector)
= operator.
Definition vec4.h:287
Vec4(const Type &p1, const Type &p2, const Type &p3, const Type &p4)
Definition vec4.h:89
Type distance4(const Vec4< Type > &vector) const
Calculate the distance between this vector and an other vector (taking into account the w ordinate).
Vec4(const Vec2< Type > ©, const Vec2< Type > ©34)
Definition vec4.h:87
bool operator<(const Vec4< Type > &vector) const
< operator.
Definition vec4.h:296
Type w
Definition vec4.h:82
Vec4< Type > & round()
Rounds all components on this vector.
Type dot4(const Vec4< Type > &vector) const
Dot products this vector with an other vector (taking into account the w ordinate).
Definition vec4.h:205
static Type dot3(const Vec4< Type > &vector1, const Vec4< Type > &vector2)
Dot products between two vectors (not taking into account the w ordinate).
Definition vec4.h:114
bool is_equal(const Vec4< Type > &other, Type epsilon) const
Returns true if equal within the bounds of an epsilon.
Definition vec4.h:257
Vec4(const Type *array_xyzw)
Definition vec4.h:91
void operator/=(const Vec4< Type > &vector)
/= operator.
Definition vec4.h:281
Type datatype
Definition vec4.h:77
void operator-=(const Vec4< Type > &vector)
-= operator.
Definition vec4.h:266
Vec4(const Type &p1, const Type &p2, const Vec2< Type > ©34)
Definition vec4.h:90
static Type dot4(const Vec4< Type > &vector1, const Vec4< Type > &vector2)
Dot products between two vectors (taking into account the w ordinate).
Definition vec4.h:123
Type b
Definition vec4.h:81
Vec4< Type > & cross3(const Vec4< Type > &vector)
Calculate the cross product between this vector and an other vector (not taking into account the w or...
Type g
Definition vec4.h:80
static Vec4< Type > normalize3(const Vec4< Type > &vector)
Normalizes a vector (not taking into account the w ordinate)
void set_zw(const Vec2< Type > &new_v)
Definition vec4.h:163
Type t
Definition vec4.h:80
Vec2< Type > operator/(const Vec2< Type > &v1, const Vec2< Type > &v2)
/ operator.
Definition vec2.h:302
Vec4< unsigned char > Vec4ub
Definition vec4.h:385
Type length4() const
Returns the length (magnitude) of this vector (taking into account the w ordinate).
Definition vec4.h:377
Vec4< unsigned int > Vec4ui
Definition vec4.h:389
Vec4< char > Vec4b
Definition vec4.h:386
Vec4< float > Vec4f
Definition vec4.h:391
Vec2< Type > operator-(const Vec2< Type > &v1, const Vec2< Type > &v2)
operator.
Definition vec2.h:278
Type length3() const
Returns the length (magnitude) of this vector (not taking into account the w ordinate).
Definition vec4.h:368
Vec2< Type > operator+(const Vec2< Type > &v1, const Vec2< Type > &v2)
operator.
Definition vec2.h:266
Vec4< short > Vec4s
Definition vec4.h:388
Vec4< int > Vec4i
Definition vec4.h:390
Vec4< double > Vec4d
Definition vec4.h:392
Vec2< Type > operator*(const Vec2< Type > &v1, const Vec2< Type > &v2)
operator.
Definition vec2.h:290
Vec4< unsigned short > Vec4us
Definition vec4.h:387