TrinityCore: G3D::Vector3 Class Reference

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Here is the caller graph for this function:

G3D::Vector3::Vector3 ( const Any & any )

explicit

Parameters

any	Must either Vector3(#, #, #) or Vector3 {x = #, y = #, z = #}. Because Point3 is a typedef for Vector3 in the current implementation, this constructor accepts Point3(#, #, #), etc. as well.

  {
  if (any.name() == "Vector3::inf" || any.name() == "Point3::inf") {
  *this = inf();
  return;
  } else if (any.name() == "Vector3::zero" || any.name() == "Point3::zero") {
  *this = zero();
  return;
  } else if (any.name() == "Vector3::nan" || any.name() == "Point3::nan") {
  *this = nan();
  return;
  }
 
  any.verifyName("Vector3", "Point3");
  any.verifyType(Any::TABLE, Any::ARRAY);
  any.verifySize(3);
 
  if (any.type() == Any::ARRAY) {
  x = any[0];
  y = any[1];
  z = any[2];
  } else {
  // Table
  x = any["x"];
  y = any["y"];
  z = any["z"];
  }
 }

Here is the call graph for this function:

G3D::Vector3::Vector3 ( const Vector4int8 & v )

Divides by 127

109 : x(v.x / 127.0f), y(v.y / 127.0f), z(v.z / 127.0f) {}

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

G3D::Vector3::Vector3	(	const class Vector2 &	v,
		float	z
	)

111 : x(v.x), y(v.y), z(_z) {

112 }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

G3D::Vector3::Vector3 ( const class Vector3int32 & v )

107 : x((float)v.x), y((float)v.y), z((float)v.z) {}

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

G3D::Vector3::Vector3 ( class BinaryInput & b )

explicit

  {
  deserialize(b);
 }

Here is the call graph for this function:

G3D::Vector3::Vector3	(	float	_x,
		float	_y,
		float	_z
	)

inline

609 : x(fX), y(fY), z(fZ) {

610 }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

G3D::Vector3::Vector3 ( float coordinate[3] )

inlineexplicit

613 : x(V[0]), y(V[1]), z(V[2]){

614 }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

G3D::Vector3::Vector3 ( double coordinate[3] )

inlineexplicit

617 : x((float)V[0]), y((float)V[1]), z((float)V[2]){

618 }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

G3D::Vector3::Vector3 ( const class Vector3int16 & v )

  {
  x = v.x;
  y = v.y;
  z = v.z;
 }

G3D::Vector3::Vector3 ( class TextInput & t )

explicit

  {
  deserialize(t);
 }

Here is the call graph for this function:

G3D::Vector3::Vector3 ( const class Color3 & c )

explicit

105 : x(v.r), y(v.g), z(v.b) {}

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Member Function Documentation

float G3D::Vector3::average ( ) const

inline

  {
  return sum() / 3.0f;
  }

Here is the call graph for this function:

Vector3 G3D::Vector3::clamp	(	const Vector3 &	low,
		const Vector3 &	high
	)		const

inline

  {
  return Vector3(
  G3D::clamp(x, low.x, high.x),
  G3D::clamp(y, low.y, high.y),
  G3D::clamp(z, low.z, high.z));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector3 G3D::Vector3::clamp	(	float	low,
		float	high
	)		const

inline

  {
  return Vector3(
  G3D::clamp(x, low, high),
  G3D::clamp(y, low, high),
  G3D::clamp(z, low, high));
  }

Here is the call graph for this function:

Vector3 G3D::Vector3::cosHemiRandom	(	const Vector3 &	n,
		Random &	r = `Random::common()`
	)

static

Random unit vector, distributed according to $\max(\cos \theta,0)$ .

That is, so that the probability of $\vec{V}$ is proportional to $\max(\vec{v} \cdot \vec{n}, 0)$ . Useful in photon mapping for Lambertian scattering.

Distribution rendered by G3D::DirectionHistogram:

Parameters

n	Unit vector at the center of the distribution.

[Henrik] Wann Jensen, Realistic Image Synthesis using Photon Mapping eqn 2.24

  {
  debugAssertM(G3D::fuzzyEq(normal.length(), 1.0f), 
  "cosHemiRandom requires its argument to have unit length");
 
  float x, y, z;
  r.cosHemi(x, y, z);
 
  // Make a coordinate system
  const Vector3& Z = normal;
 
  Vector3 X, Y;
  normal.getTangents(X, Y);
 
  return 
  x * X +
  y * Y +
  z * Z;
 }

Here is the call graph for this function:

Vector3 G3D::Vector3::cosPowHemiRandom	(	const Vector3 &	n,
		const float	k,
		Random &	r = `Random::common()`
	)

static

Random unit vector, distributed according to $\max(\cos^k \theta,0)$ .

That is, so that the probability of $\vec{V}$ is proportional to $\max((\vec{v} \cdot \vec{n})^k, 0)$ . Useful in photon mapping for glossy scattering.

Distribution rendered by G3D::DirectionHistogram:

Parameters

n	Unit vector at the center of the distribution.

[Ashikhmin] and Shirley, An anisotropic Phong BRDF model, Journal of Graphics Tools, 2002

  {
  debugAssertM(G3D::fuzzyEq(normal.length(), 1.0f), 
  "cosPowHemiRandom requires its argument to have unit length");
 
  float x, y, z;
  r.cosPowHemi(k, x, y, z);
 
  // Make a coordinate system
  const Vector3& Z = normal;
 
  Vector3 X, Y;
  normal.getTangents(X, Y);
 
  return 
  x * X +
  y * Y +
  z * Z;
 }

Here is the call graph for this function:

Vector3 G3D::Vector3::cosSphereRandom	(	const Vector3 &	n,
		Random &	r = `Random::common()`
	)

static

  {
  debugAssertM(G3D::fuzzyEq(normal.length(), 1.0f), 
  "cosSphereRandom requires its argument to have unit length");
 
  float x, y, z;
  r.cosSphere(x, y, z);
 
  // Make a coordinate system
  const Vector3& Z = normal;
 
  Vector3 X, Y;
  normal.getTangents(X, Y);
 
  return 
  x * X +
  y * Y +
  z * Z;
 }

Here is the call graph for this function:

Vector3 G3D::Vector3::cross ( const Vector3 & rkVector ) const

inline

Cross product. Note that two cross products in a row can be computed more cheaply: v1 x (v2 x v3) = (v1 dot v3) v2 - (v1 dot v2) v3.

  {
  return Vector3(y*rkVector.z - z*rkVector.y, z*rkVector.x - x*rkVector.z,
  x*rkVector.y - y*rkVector.x);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Matrix3 G3D::Vector3::cross ( ) const

Returns a matrix such that v.cross() * w = v.cross(w).

[ 0  -v.z  v.y ]
[ v.z  0  -v.x ]
[ -v.y v.x  0  ]

  {
  return Matrix3( 0, -z, y,
  z, 0, -x,
  -y, x, 0);
 }

Here is the caller graph for this function:

void G3D::Vector3::deserialize ( class BinaryInput & b )

  {
  x = b.readFloat32();
  y = b.readFloat32();
  z = b.readFloat32();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Vector3::deserialize ( class TextInput & t )

  {
  t.readSymbol("(");
  x = (float)t.readNumber();
  t.readSymbol(",");
  y = (float)t.readNumber();
  t.readSymbol(",");
  z = (float)t.readNumber();
  t.readSymbol(")");
 }

Here is the call graph for this function:

Vector3 G3D::Vector3::direction ( ) const

inline

Returns a unit-length version of this vector. Returns nan if length is almost zero.

  {
  const float lenSquared = squaredMagnitude();
  const float invSqrt = 1.0f / sqrtf(lenSquared);
  return Vector3(x * invSqrt, y * invSqrt, z * invSqrt);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector3 G3D::Vector3::directionOrZero ( ) const

inline

Returns Vector3::zero() if the length is nearly zero, otherwise returns a unit vector.

  {
  float mag = magnitude();
  if (mag < 0.0000001f) {
  return Vector3::zero();
  } else if (mag < 1.00001f && mag > 0.99999f) {
  return *this;
  } else {
  return *this * (1.0f / mag);
  }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::Vector3::dot ( const Vector3 & rkVector ) const

inline

  {
  return x*rkVector.x + y*rkVector.y + z*rkVector.z;
 }

Here is the caller graph for this function:

Vector3 G3D::Vector3::fastDirection ( ) const

inline

Potentially less accurate but faster than direction(). Only works if System::hasSSE is true.

  {
  float lenSquared = x * x + y * y + z * z;
  float invSqrt = rsq(lenSquared);
  return Vector3(x * invSqrt, y * invSqrt, z * invSqrt);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector3 G3D::Vector3::fastUnit ( ) const

inline

Returns a normalized vector. May be computed with lower precision than unit

  {
  return fastDirection();
  }

Here is the call graph for this function:

Vector3 G3D::Vector3::floor ( ) const

inline

  {
  return G3D::Vector3(::floor(x), ::floor(y), ::floor(z));
  }

bool G3D::Vector3::fuzzyEq ( const Vector3 & other ) const

inline

  {
  return G3D::fuzzyEq((*this - other).squaredMagnitude(), 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Vector3::fuzzyNe ( const Vector3 & other ) const

inline

  {
  return G3D::fuzzyNe((*this - other).squaredMagnitude(), 0);
 }

Here is the call graph for this function:

void G3D::Vector3::getTangents	(	Vector3 &	X,
		Vector3 &	Y
	)		const

inline

Creates two orthonormal tangent vectors X and Y such that if Z = this, X x Y = Z.

  {
  debugAssertM(G3D::fuzzyEq(length(), 1.0f), 
  "makeAxes requires Z to have unit length");
  
  // Choose another vector not perpendicular
  X = (abs(x) < 0.9f) ? Vector3::unitX() : Vector3::unitY();
  
  // Remove the part that is parallel to Z
  X -= *this * this->dot(X);
  X /= X.length();
  
  Y = this->cross(X);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t G3D::Vector3::hashCode ( ) const

  {
  const uint32* u = (const uint32*)this;
  return 
  HashTrait<uint32>::hashCode(u[0]) ^ 
  HashTrait<uint32>::hashCode(~u[1]) ^
  HashTrait<uint32>::hashCode((u[2] << 16) | ~(u[2] >> 16));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector3 G3D::Vector3::hemiRandom	(	const Vector3 &	normal,
		Random &	r = `Random::common()`
	)

static

Random vector distributed over the hemisphere about normal.

Distribution rendered by G3D::DirectionHistogram:

  {
  const Vector3& V = Vector3::random(r);
 
  if (V.dot(normal) < 0) {
  return -V;
  } else {
  return V;
  }
 }

Here is the call graph for this function:

Vector3 & G3D::Vector3::ignore ( )

static

Can be passed to ignore a vector3 parameter

                          {
     static Vector3 v;
     return v;
 }

const Vector3 & G3D::Vector3::inf ( )

static

124 { static const Vector3 v((float)G3D::finf(), (float)G3D::finf(), (float)G3D::finf()); return v; }

G3D::finf

float finf()

Definition: g3dmath.cpp:71

Vector3()

Definition: Vector3.h:604

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Vector3::isFinite ( ) const

inline

Returns true if this vector has finite length.

                                     {
     return G3D::isFinite(x) && G3D::isFinite(y) && G3D::isFinite(z);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Vector3::isNaN ( ) const

True if any field is nan

                           {
     return G3D::isNaN(x) || G3D::isNaN(y) || G3D::isNaN(z);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Vector3::isUnit ( ) const

inline

Returns true if this vector has length ~= 1

                                   {
     return G3D::fuzzyEq(squaredMagnitude(), 1.0f);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Vector3::isZero ( ) const

inline

Returns true if this vector has length ~= 0

                                   {
     return G3D::fuzzyEq(fabsf(x) + fabsf(y) + fabsf(z), 0.0f);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::Vector3::length ( ) const

inline

Same as magnitude

                                    {
     return magnitude();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector3 G3D::Vector3::lerp	(	const Vector3 &	v,
		float	alpha
	)		const

inline

Linear interpolation

                                                              {
         return (*this) + (v - *this) * alpha; 
     }

Here is the caller graph for this function:

float G3D::Vector3::magnitude ( ) const

inline

                                       {
     return ::sqrtf(x*x + y*y + z*z);
 }

Here is the caller graph for this function:

Vector3 G3D::Vector3::max ( const Vector3 & v ) const

inline

                                                   {
     return Vector3(G3D::max(v.x, x), G3D::max(v.y, y), G3D::max(v.z, z));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::Vector3::max ( ) const

inline

Largest element

                              {
         return G3D::max(G3D::max(x, y), z);
     }

Here is the call graph for this function:

const Vector3 & G3D::Vector3::maxFinite ( )

static

Largest representable vector

127 { static const Vector3 v(FLT_MAX, FLT_MAX, FLT_MAX); return v; }

Vector3()

Definition: Vector3.h:604

Here is the caller graph for this function:

Vector3 G3D::Vector3::min ( const Vector3 & v ) const

inline

                                                   {
     return Vector3(G3D::min(v.x, x), G3D::min(v.y, y), G3D::min(v.z, z));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::Vector3::min ( ) const

inline

Smallest element

                              {
         return G3D::min(G3D::min(x, y), z);
     }

Here is the call graph for this function:

const Vector3 & G3D::Vector3::minFinite ( )

static

Smallest (most negative) representable vector

126 { static const Vector3 v(-FLT_MAX, -FLT_MAX, -FLT_MAX); return v; }

Vector3()

Definition: Vector3.h:604

Here is the caller graph for this function:

Vector3 G3D::Vector3::movedTowards	(	const Vector3 &	goal,
		float	maxTranslation
	)		const

Returns a vector that is this translated towards goal with a maximum translation of maxTranslation.

                                                                              {
     Vector3 t = *this;
     t.moveTowards(goal, maxTranslation);
     return t;
 }

Here is the call graph for this function:

void G3D::Vector3::moveTowards	(	const Vector3 &	goal,
		float	maxTranslation
	)

                                                                    {
     // Apply clamped translation
     Vector3 dX = goal - *this;
     float length = dX.length();
     if ((length < 0.00001f) || (length < maxTranslation)) {
         *this = goal;
     } else {
         *this += G3D::min(1.0f, maxTranslation / length) * dX;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const Vector3 & G3D::Vector3::nan ( )

static

125 { static const Vector3 v((float)G3D::fnan(), (float)G3D::fnan(), (float)G3D::fnan()); return v; }

G3D::fnan

float fnan()

Definition: g3dmath.cpp:82

Vector3()

Definition: Vector3.h:604

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Vector3::nonZero ( ) const

inline

                          {
         return (x != 0) || (y != 0) || (z != 0);    
     }

const Vector3 & G3D::Vector3::one ( )

static

120 { static const Vector3 v(1, 1, 1); return v; }

Vector3()

Definition: Vector3.h:604

Here is the caller graph for this function:

bool G3D::Vector3::operator!= ( const Vector3 & rkVector ) const

inline

                                                               {
     return ( x != rkVector.x || y != rkVector.y || z != rkVector.z );
 }

Vector3 G3D::Vector3::operator* ( float s ) const

inline

                                                {
     return Vector3(x * f, y * f, z * f);
 }

Here is the call graph for this function:

Vector3 G3D::Vector3::operator* ( const Vector3 & v ) const

inline

                                                                 {
     return Vector3(x * rkVector.x, y * rkVector.y, z * rkVector.z);
 }

Here is the call graph for this function:

Vector3 & G3D::Vector3::operator*= ( float s )

inline

                                                   {
     x *= fScalar;
     y *= fScalar;
     z *= fScalar;
     return *this;
 }

Vector3 & G3D::Vector3::operator*= ( const Vector3 & v )

inline

                                                             {
     x *= rkVector.x;
     y *= rkVector.y;
     z *= rkVector.z;
     return *this;
 }

Vector3 G3D::Vector3::operator+ ( const Vector3 & v ) const

inline

                                                                 {
     return Vector3(x + rkVector.x, y + rkVector.y, z + rkVector.z);
 }

Here is the call graph for this function:

Vector3 & G3D::Vector3::operator+= ( const Vector3 & v )

inline

                                                             {
     x += rkVector.x;
     y += rkVector.y;
     z += rkVector.z;
     return *this;
 }

Vector3 G3D::Vector3::operator- ( const Vector3 & v ) const

inline

                                                                 {
     return Vector3(x - rkVector.x, y - rkVector.y, z - rkVector.z);
 }

Here is the call graph for this function:

Vector3 G3D::Vector3::operator- ( ) const

inline

                                          {
     return Vector3(-x, -y, -z);
 }

Here is the call graph for this function:

Vector3 & G3D::Vector3::operator-= ( const Vector3 & v )

inline

                                                             {
     x -= rkVector.x;
     y -= rkVector.y;
     z -= rkVector.z;
     return *this;
 }

Vector3 __fastcall G3D::Vector3::operator/ ( float s ) const

inline

                                                         {
         return *this * (1.0f / s);
     }

Vector3 G3D::Vector3::operator/ ( const Vector3 & v ) const

inline

                                                                 {
     return Vector3(x / rkVector.x, y / rkVector.y, z / rkVector.z);
 }

Here is the call graph for this function:

Vector3& __fastcall G3D::Vector3::operator/= ( float s )

inline

                                                     {
         return (*this *= (1.0f / s));
     }

Vector3 & G3D::Vector3::operator/= ( const Vector3 & v )

inline

                                                             {
     x /= rkVector.x;
     y /= rkVector.y;
     z /= rkVector.z;
     return *this;
 }

bool G3D::Vector3::operator< ( const Vector3 & ) const

private

bool G3D::Vector3::operator<= ( const Vector3 & ) const

private

Vector3 & G3D::Vector3::operator= ( const Vector3 & rkVector )

inline

                                                            {
     x = rkVector.x;
     y = rkVector.y;
     z = rkVector.z;
     return *this;
 }

Vector3 & G3D::Vector3::operator= ( const Any & a )

                                         {
     *this = Vector3(a);
     return *this;
 }

Here is the call graph for this function:

bool G3D::Vector3::operator== ( const Vector3 & rkVector ) const

inline

                                                               {
     return ( x == rkVector.x && y == rkVector.y && z == rkVector.z );
 }

bool G3D::Vector3::operator> ( const Vector3 & ) const

private

bool G3D::Vector3::operator>= ( const Vector3 & ) const

private

const float & G3D::Vector3::operator[] ( int i ) const

inline

                                                     {
     return ((float*)this)[i];
 }

float & G3D::Vector3::operator[] ( int i )

inline

                                         {
     return ((float*)this)[i];
 }

void G3D::Vector3::orthonormalize ( Vector3 akVector[3] )

static

Gram-Schmidt orthonormalization.

                                                  {
     // If the input vectors are v0, v1, and v2, then the Gram-Schmidt
     // orthonormalization produces vectors u0, u1, and u2 as follows,
     //
     //   u0 = v0/|v0|
     //   u1 = (v1-(u0*v1)u0)/|v1-(u0*v1)u0|
     //   u2 = (v2-(u0*v2)u0-(u1*v2)u1)/|v2-(u0*v2)u0-(u1*v2)u1|
     //
     // where |A| indicates length of vector A and A*B indicates dot
     // product of vectors A and B.
 
     // compute u0
     akVector[0] = akVector[0].direction();
 
     // compute u1
     float fDot0 = akVector[0].dot(akVector[1]);
     akVector[1] -= akVector[0] * fDot0;
     akVector[1] = akVector[1].direction();
 
     // compute u2
     float fDot1 = akVector[1].dot(akVector[2]);
     fDot0 = akVector[0].dot(akVector[2]);
     akVector[2] -= akVector[0] * fDot0 + akVector[1] * fDot1;
     akVector[2] = akVector[2].direction();
 }

Here is the call graph for this function:

Vector3 G3D::Vector3::pow ( float p ) const

inline

Raise each component of this vector to a power

                                {
         return Vector3(powf(x, p), powf(y, p), powf(z, p));
     }

Here is the call graph for this function:

Vector3::Axis G3D::Vector3::primaryAxis ( ) const

Returns the largest dimension. Particularly convenient for determining which plane to project a triangle onto for point-in-polygon tests.

                                        {
     
     Axis a = X_AXIS;
 
     double nx = abs(x);
     double ny = abs(y);
     double nz = abs(z);
 
     if (nx > ny) {
         if (nx > nz) {
             a = X_AXIS;
         } else {
             a = Z_AXIS;
         }
     } else {
         if (ny > nz) {
             a = Y_AXIS;
         } else {
             a = Z_AXIS;
         }
     }
 
     return a;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector3 G3D::Vector3::random ( Random & r = Random::common() )

static

Random unit vector, uniformly distributed on the sphere.

Distribution rendered by G3D::DirectionHistogram:

                                  {
     Vector3 result;
     r.sphere(result.x, result.y, result.z);
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector3 G3D::Vector3::reflectAbout ( const Vector3 & normal ) const

Reflect this vector about the (not necessarily unit) normal. Assumes that both the before and after vectors point away from the base of the normal.

Note that if used for a collision or ray reflection you must negate the resulting vector to get a direction pointing away from the collision.

  V'    N      V

    r   ^   -,
     \  |  /
       |/

See also G3D::Ray::refract.

         N      V

         ^    /
         |  /
         |'-
     __–
V'<–

                                     {
 
     // From pg. 24 of Henrik Wann Jensen. Realistic Image Synthesis
     // Using Photon Mapping.  AK Peters. ISBN: 1568811470. July 2001.
 
     // Invert the directions from Wann Jensen's formulation
     // and normalize the vectors.
     const Vector3 W = -direction();
     Vector3 N = normal.direction();
 
     float h1 = iOutside;
     float h2 = iInside;
 
     if (normal.dot(*this) > 0.0f) {
         h1 = iInside;
         h2 = iOutside;
         N  = -N;
     }
 
     const float hRatio = h1 / h2;
     const float WdotN = W.dot(N);
 
     float det = 1.0f - (float)square(hRatio) * (1.0f - (float)square(WdotN));
 
     if (det < 0) {
         // Total internal reflection
         return Vector3::zero();
     } else {
         return -hRatio * (W - WdotN * N) - N * sqrt(det);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector3 G3D::Vector3::round ( ) const

inline

                                  {
         return Vector3(G3D::round(x), G3D::round(y), G3D::round(z));
     }

Here is the call graph for this function:

void G3D::Vector3::serialize ( class BinaryOutput & b ) const

Format is three float32's

                                              {
     b.writeFloat32(x);
     b.writeFloat32(y);
     b.writeFloat32(z);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Vector3::serialize ( class TextOutput & t ) const

Format is "(%f, %f, %f)"

                                            {
    t.writeSymbol("(");
    t.writeNumber(x);
    t.writeSymbol(",");
    t.writeNumber(y);
    t.writeSymbol(",");
    t.writeNumber(z);
    t.writeSymbol(")");
 }

Here is the call graph for this function:

float G3D::Vector3::squaredLength ( ) const

inline

Same as squaredMagnitude

                                            {
     return squaredMagnitude();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::Vector3::squaredMagnitude ( ) const

inline

                                               {
     return x*x + y*y + z*z;
 }

Here is the caller graph for this function:

float G3D::Vector3::sum ( ) const

inline

                              {
         return x + y + z;
     }

Here is the caller graph for this function:

Any G3D::Vector3::toAny ( const std::string & name ) const

Converts the Vector3 to an Any, using the specified name instead of "Vector3"

                                               {
     Any any(Any::ARRAY, name);
     any.append(x, y, z);
     return any;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Any G3D::Vector3::toAny ( ) const

Converts the Vector3 to an Any.

                          {
     return toAny("Vector3");
 }

std::string G3D::Vector3::toString ( ) const

                                   {
     return G3D::format("(%g, %g, %g)", x, y, z);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector3 G3D::Vector3::unit ( ) const

inline

Synonym for direction

                                 {
         return direction();
     }

Here is the call graph for this function:

Vector3 G3D::Vector3::unitCross ( const Vector3 & rkVector ) const

inline

                                                                 {
     Vector3 kCross(y*rkVector.z - z*rkVector.y, z*rkVector.x - x*rkVector.z,
                    x*rkVector.y - y*rkVector.x);
     return kCross.direction();
 }

Here is the call graph for this function:

const Vector3 & G3D::Vector3::unitX ( )

static

121 { static const Vector3 v(1, 0, 0); return v; }

Vector3()

Definition: Vector3.h:604

Here is the caller graph for this function:

const Vector3 & G3D::Vector3::unitY ( )

static

122 { static const Vector3 v(0, 1, 0); return v; }

Vector3()

Definition: Vector3.h:604

Here is the caller graph for this function:

const Vector3 & G3D::Vector3::unitZ ( )

static

123 { static const Vector3 v(0, 0, 1); return v; }

Vector3()

Definition: Vector3.h:604

Here is the caller graph for this function:

Vector2 G3D::Vector3::xx ( ) const

411 { return Vector2 (x, x); }

float x

Definition: Vector3.h:62

Vector3 G3D::Vector3::xxx ( ) const

423 { return Vector3 (x, x, x); }

float x

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

Here is the call graph for this function:

Vector4 G3D::Vector3::xxxx ( ) const

453 { return Vector4 (x, x, x, x); }

float x

Definition: Vector3.h:62

Vector4 G3D::Vector3::xxxy ( ) const

480 { return Vector4 (x, x, x, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector4 G3D::Vector3::xxxz ( ) const

507 { return Vector4 (x, x, x, z); }

float x

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::xxy ( ) const

432 { return Vector3 (x, x, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

Here is the call graph for this function:

Vector4 G3D::Vector3::xxyx ( ) const

462 { return Vector4 (x, x, y, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector4 G3D::Vector3::xxyy ( ) const

489 { return Vector4 (x, x, y, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector4 G3D::Vector3::xxyz ( ) const

516 { return Vector4 (x, x, y, z); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::xxz ( ) const

441 { return Vector3 (x, x, z); }

float x

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::xxzx ( ) const

471 { return Vector4 (x, x, z, x); }

float x

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::xxzy ( ) const

498 { return Vector4 (x, x, z, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::xxzz ( ) const

525 { return Vector4 (x, x, z, z); }

float x

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector2 G3D::Vector3::xy ( ) const

414 { return Vector2 (x, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector3 G3D::Vector3::xyx ( ) const

426 { return Vector3 (x, y, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

Here is the call graph for this function:

Vector4 G3D::Vector3::xyxx ( ) const

456 { return Vector4 (x, y, x, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector4 G3D::Vector3::xyxy ( ) const

483 { return Vector4 (x, y, x, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector4 G3D::Vector3::xyxz ( ) const

510 { return Vector4 (x, y, x, z); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::xyy ( ) const

435 { return Vector3 (x, y, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

Here is the call graph for this function:

Vector4 G3D::Vector3::xyyx ( ) const

465 { return Vector4 (x, y, y, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector4 G3D::Vector3::xyyy ( ) const

492 { return Vector4 (x, y, y, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector4 G3D::Vector3::xyyz ( ) const

519 { return Vector4 (x, y, y, z); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::xyz ( ) const

444 { return Vector3 (x, y, z); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Here is the caller graph for this function:

Vector4 G3D::Vector3::xyzx ( ) const

474 { return Vector4 (x, y, z, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::xyzy ( ) const

501 { return Vector4 (x, y, z, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::xyzz ( ) const

528 { return Vector4 (x, y, z, z); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector2 G3D::Vector3::xz ( ) const

417 { return Vector2 (x, z); }

float x

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Here is the caller graph for this function:

Vector3 G3D::Vector3::xzx ( ) const

429 { return Vector3 (x, z, x); }

float x

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::xzxx ( ) const

459 { return Vector4 (x, z, x, x); }

float x

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::xzxy ( ) const

486 { return Vector4 (x, z, x, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::xzxz ( ) const

513 { return Vector4 (x, z, x, z); }

float x

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::xzy ( ) const

438 { return Vector3 (x, z, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::xzyx ( ) const

468 { return Vector4 (x, z, y, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::xzyy ( ) const

495 { return Vector4 (x, z, y, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::xzyz ( ) const

522 { return Vector4 (x, z, y, z); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::xzz ( ) const

447 { return Vector3 (x, z, z); }

float x

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::xzzx ( ) const

477 { return Vector4 (x, z, z, x); }

float x

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::xzzy ( ) const

504 { return Vector4 (x, z, z, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::xzzz ( ) const

531 { return Vector4 (x, z, z, z); }

float x

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector2 G3D::Vector3::yx ( ) const

412 { return Vector2 (y, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector3 G3D::Vector3::yxx ( ) const

424 { return Vector3 (y, x, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

Here is the call graph for this function:

Vector4 G3D::Vector3::yxxx ( ) const

454 { return Vector4 (y, x, x, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector4 G3D::Vector3::yxxy ( ) const

481 { return Vector4 (y, x, x, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector4 G3D::Vector3::yxxz ( ) const

508 { return Vector4 (y, x, x, z); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::yxy ( ) const

433 { return Vector3 (y, x, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

Here is the call graph for this function:

Vector4 G3D::Vector3::yxyx ( ) const

463 { return Vector4 (y, x, y, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector4 G3D::Vector3::yxyy ( ) const

490 { return Vector4 (y, x, y, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector4 G3D::Vector3::yxyz ( ) const

517 { return Vector4 (y, x, y, z); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::yxz ( ) const

442 { return Vector3 (y, x, z); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::yxzx ( ) const

472 { return Vector4 (y, x, z, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::yxzy ( ) const

499 { return Vector4 (y, x, z, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::yxzz ( ) const

526 { return Vector4 (y, x, z, z); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector2 G3D::Vector3::yy ( ) const

415 { return Vector2 (y, y); }

float y

Definition: Vector3.h:62

Vector3 G3D::Vector3::yyx ( ) const

427 { return Vector3 (y, y, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

Here is the call graph for this function:

Vector4 G3D::Vector3::yyxx ( ) const

457 { return Vector4 (y, y, x, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector4 G3D::Vector3::yyxy ( ) const

484 { return Vector4 (y, y, x, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector4 G3D::Vector3::yyxz ( ) const

511 { return Vector4 (y, y, x, z); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::yyy ( ) const

436 { return Vector3 (y, y, y); }

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

Here is the call graph for this function:

Vector4 G3D::Vector3::yyyx ( ) const

466 { return Vector4 (y, y, y, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector4 G3D::Vector3::yyyy ( ) const

493 { return Vector4 (y, y, y, y); }

float y

Definition: Vector3.h:62

Vector4 G3D::Vector3::yyyz ( ) const

520 { return Vector4 (y, y, y, z); }

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::yyz ( ) const

445 { return Vector3 (y, y, z); }

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::yyzx ( ) const

475 { return Vector4 (y, y, z, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::yyzy ( ) const

502 { return Vector4 (y, y, z, y); }

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::yyzz ( ) const

529 { return Vector4 (y, y, z, z); }

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector2 G3D::Vector3::yz ( ) const

418 { return Vector2 (y, z); }

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::yzx ( ) const

430 { return Vector3 (y, z, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::yzxx ( ) const

460 { return Vector4 (y, z, x, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::yzxy ( ) const

487 { return Vector4 (y, z, x, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::yzxz ( ) const

514 { return Vector4 (y, z, x, z); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::yzy ( ) const

439 { return Vector3 (y, z, y); }

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::yzyx ( ) const

469 { return Vector4 (y, z, y, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::yzyy ( ) const

496 { return Vector4 (y, z, y, y); }

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::yzyz ( ) const

523 { return Vector4 (y, z, y, z); }

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::yzz ( ) const

448 { return Vector3 (y, z, z); }

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::yzzx ( ) const

478 { return Vector4 (y, z, z, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::yzzy ( ) const

505 { return Vector4 (y, z, z, y); }

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::yzzz ( ) const

532 { return Vector4 (y, z, z, z); }

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

const Vector3 & G3D::Vector3::zero ( )

static

119 { static const Vector3 v(0, 0, 0); return v; }

Vector3()

Definition: Vector3.h:604

Here is the caller graph for this function:

Vector2 G3D::Vector3::zx ( ) const

413 { return Vector2 (z, x); }

float x

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::zxx ( ) const

425 { return Vector3 (z, x, x); }

float x

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::zxxx ( ) const

455 { return Vector4 (z, x, x, x); }

float x

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zxxy ( ) const

482 { return Vector4 (z, x, x, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zxxz ( ) const

509 { return Vector4 (z, x, x, z); }

float x

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::zxy ( ) const

434 { return Vector3 (z, x, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::zxyx ( ) const

464 { return Vector4 (z, x, y, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zxyy ( ) const

491 { return Vector4 (z, x, y, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zxyz ( ) const

518 { return Vector4 (z, x, y, z); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::zxz ( ) const

443 { return Vector3 (z, x, z); }

float x

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::zxzx ( ) const

473 { return Vector4 (z, x, z, x); }

float x

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zxzy ( ) const

500 { return Vector4 (z, x, z, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zxzz ( ) const

527 { return Vector4 (z, x, z, z); }

float x

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector2 G3D::Vector3::zy ( ) const

416 { return Vector2 (z, y); }

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::zyx ( ) const

428 { return Vector3 (z, y, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::zyxx ( ) const

458 { return Vector4 (z, y, x, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zyxy ( ) const

485 { return Vector4 (z, y, x, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zyxz ( ) const

512 { return Vector4 (z, y, x, z); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::zyy ( ) const

437 { return Vector3 (z, y, y); }

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::zyyx ( ) const

467 { return Vector4 (z, y, y, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zyyy ( ) const

494 { return Vector4 (z, y, y, y); }

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zyyz ( ) const

521 { return Vector4 (z, y, y, z); }

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::zyz ( ) const

446 { return Vector3 (z, y, z); }

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::zyzx ( ) const

476 { return Vector4 (z, y, z, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zyzy ( ) const

503 { return Vector4 (z, y, z, y); }

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zyzz ( ) const

530 { return Vector4 (z, y, z, z); }

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector2 G3D::Vector3::zz ( ) const

419 { return Vector2 (z, z); }

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::zzx ( ) const

431 { return Vector3 (z, z, x); }

float x

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::zzxx ( ) const

461 { return Vector4 (z, z, x, x); }

float x

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zzxy ( ) const

488 { return Vector4 (z, z, x, y); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zzxz ( ) const

515 { return Vector4 (z, z, x, z); }

float x

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::zzy ( ) const

440 { return Vector3 (z, z, y); }

float y

Definition: Vector3.h:62

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::zzyx ( ) const

470 { return Vector4 (z, z, y, x); }

float x

Definition: Vector3.h:62

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zzyy ( ) const

497 { return Vector4 (z, z, y, y); }

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zzyz ( ) const

524 { return Vector4 (z, z, y, z); }

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector3 G3D::Vector3::zzz ( ) const

449 { return Vector3 (z, z, z); }

Vector3()

Definition: Vector3.h:604

float z

Definition: Vector3.h:62

Here is the call graph for this function:

Vector4 G3D::Vector3::zzzx ( ) const

479 { return Vector4 (z, z, z, x); }

float x

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zzzy ( ) const

506 { return Vector4 (z, z, z, y); }

float y

Definition: Vector3.h:62

float z

Definition: Vector3.h:62

Vector4 G3D::Vector3::zzzz ( ) const

533 { return Vector4 (z, z, z, z); }