G3D::Vector2 Class Reference

#include <Vector2.h>

Public Member Functions
	Vector2 (const Any &any)
Any	toAny () const
	Vector2 ()
	Vector2 (class TextInput &t)
	Vector2 (class BinaryInput &b)
	Vector2 (float x, float y)
	Vector2 (float coordinate[2])
	Vector2 (double coordinate[2])
	Vector2 (const Vector2 &other)
	Vector2 (const Vector2int16 &other)
	Vector2 (const Vector2unorm16 &other)
	Vector2 (const Vector2int32 &other)
Vector2 &	operator= (const Any &a)
void	serialize (class BinaryOutput &b) const
void	deserialize (class BinaryInput &b)
void	serialize (class TextOutput &t) const
void	deserialize (class TextInput &t)
float &	operator[] (int i)
const float &	operator[] (int i) const
Vector2 &	operator= (const Vector2 &other)
bool	operator== (const Vector2 &other) const
bool	operator!= (const Vector2 &other) const
size_t	hashCode () const
bool	fuzzyEq (const Vector2 &other) const
bool	fuzzyNe (const Vector2 &other) const
bool	isFinite () const
bool	isNaN () const
bool	isZero () const
bool	isUnit () const
Vector2	operator+ (const Vector2 &v) const
Vector2	operator- (const Vector2 &v) const
Vector2	operator* (float s) const
Vector2	pow (float p) const
Vector2	operator* (const Vector2 &v) const
Vector2	operator/ (const Vector2 &v) const
Vector2	operator/ (float s) const
Vector2	operator- () const
float	sum () const
Vector2	lerp (const Vector2 &v, float alpha) const
Vector2	clamp (const Vector2 &low, const Vector2 &high) const
Vector2	clamp (float low, float high) const
Vector2 &	operator+= (const Vector2 &)
Vector2 &	operator-= (const Vector2 &)
Vector2 &	operator*= (float)
Vector2 &	operator/= (float)
Vector2 &	operator*= (const Vector2 &)
Vector2 &	operator/= (const Vector2 &)
float	length () const
Vector2	direction () const
Vector2	directionOrZero () const
Vector2	fastDirection () const
float	squaredLength () const
float	dot (const Vector2 &s) const
Vector2	abs () const
Vector2	min (const Vector2 &v) const
Vector2	max (const Vector2 &v) const
Vector2	maxAbs (const Vector2 &v) const
Vector2	minAbs (const Vector2 &v) const
std::string	toString () const
Vector2	xx () const
Vector2	yx () const
Vector2	xy () const
Vector2	yy () const
Vector3	xxx () const
Vector3	yxx () const
Vector3	xyx () const
Vector3	yyx () const
Vector3	xxy () const
Vector3	yxy () const
Vector3	xyy () const
Vector3	yyy () const
Vector4	xxxx () const
Vector4	yxxx () const
Vector4	xyxx () const
Vector4	yyxx () const
Vector4	xxyx () const
Vector4	yxyx () const
Vector4	xyyx () const
Vector4	yyyx () const
Vector4	xxxy () const
Vector4	yxxy () const
Vector4	xyxy () const
Vector4	yyxy () const
Vector4	xxyy () const
Vector4	yxyy () const
Vector4	xyyy () const
Vector4	yyyy () const

Static Public Member Functions
static Vector2	random (Random &r=Random::common())
static const Vector2 &	zero ()
static const Vector2 &	one ()
static const Vector2 &	unitX ()
static const Vector2 &	unitY ()
static const Vector2 &	inf ()
static const Vector2 &	nan ()
static const Vector2 &	minFinite ()
static const Vector2 &	maxFinite ()

Public Attributes
float	x
float	y

Private Member Functions
bool	operator< (const Vector2 &) const
bool	operator> (const Vector2 &) const
bool	operator<= (const Vector2 &) const
bool	operator>= (const Vector2 &) const

Detailed Description

Do not subclass– this implementation makes assumptions about the memory layout.

Constructor & Destructor Documentation

G3D::Vector2::Vector2

(

const Any &

any

)

Parameters

any	Must either Vector2(#, #) or Vector2 {x = #, y = #}

 {
 any.verifyName("Vector2", "Point2");
 any.verifyType(Any::TABLE, Any::ARRAY);
 any.verifySize(2);

 if (any.type() == Any::ARRAY) {
 x = any[0];
 y = any[1];
 } else {
 // Table
 x = any["x"];
 y = any["y"];
 }
}

Here is the call graph for this function:

G3D::Vector2::Vector2 ( )

inline

Creates the zero vector

 : x(0.0f), y(0.0f) {
}

Here is the caller graph for this function:

G3D::Vector2::Vector2

(

class TextInput &

t

)

G3D::Vector2::Vector2

(

class BinaryInput &

b

)

 {
 deserialize(b);
}

Here is the call graph for this function:

G3D::Vector2::Vector2 ( float  x, float  y  )

inline

 : x(_x), y(_y) {
}

G3D::Vector2::Vector2 ( float  coordinate[2] )

inline

 {
 x = afCoordinate[0];
 y = afCoordinate[1];
}

G3D::Vector2::Vector2 ( double  coordinate[2] )

inline

 {
 x = (float)afCoordinate[0];
 y = (float)afCoordinate[1];
}

G3D::Vector2::Vector2 ( const Vector2 &  other )

inline

 {
 x = rkVector.x;
 y = rkVector.y;
}

G3D::Vector2::Vector2 ( const Vector2int16 &  other )

inline

 : x(v.x), y(v.y) {
}

G3D::Vector2::Vector2 ( const Vector2unorm16 &  other )

inline

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

G3D::Vector2::Vector2 ( const Vector2int32 &  other )

explicit

 : x((float)other.x), y((float)other.y) {
}

Member Function Documentation

Vector2 G3D::Vector2::abs ( ) const

inline

Componentwise absolute value

 {
 return Vector2(fabs(x), fabs(y));
 }

Here is the call graph for this function:

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

inline

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

inline

 {
 return Vector2(
 (float)G3D::clamp(x, low, high),
 (float)G3D::clamp(y, low, high));
 }

Here is the call graph for this function:

void G3D::Vector2::deserialize

(

class BinaryInput &

b

)

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Vector2::deserialize

(

class TextInput &

t

)

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

Here is the call graph for this function:

Vector2 G3D::Vector2::direction ( ) const

inline

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

 {
 float lenSquared = x * x + y * y;

 if (lenSquared != 1.0f) {
 return *this / sqrtf(lenSquared);
 } else {
 return *this;
 }
}

Here is the caller graph for this function:

Vector2 G3D::Vector2::directionOrZero ( ) const

inline

Returns Vector2::zero() is magnitude is almost zero, otherwise returns unit-length vector.

 {
 float mag = length();
 if (mag < 0.0000001f) {
 return Vector2::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:

float G3D::Vector2::dot ( const Vector2 &  s ) const

inline

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

Here is the caller graph for this function:

Vector2 G3D::Vector2::fastDirection ( ) const

inline

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

 {
 return direction();
 }

Here is the call graph for this function:

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

inline

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

Here is the call graph for this function:

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

inline

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

Here is the call graph for this function:

size_t G3D::Vector2::hashCode

(

)

const

 {
 unsigned int xhash = (*(int*)(void*)(&x));
 unsigned int yhash = (*(int*)(void*)(&y));

 return xhash + (yhash * 37);
}

Here is the caller graph for this function:

const Vector2 & G3D::Vector2::inf ( )

static

 { 
 static Vector2 v(G3D::finf(), G3D::finf());
 return v; 
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Vector2::isFinite ( ) const

inline

Returns true if this vector has finite length

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

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Vector2::isNaN ( ) const

inline

True if any field is NaN

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

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::Vector2::isUnit ( ) const

inline

Returns true if this vector has length == 1

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

Here is the call graph for this function:

bool G3D::Vector2::isZero ( ) const

inline

Returns true if this vector has length == 0

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

Here is the call graph for this function:

float G3D::Vector2::length ( ) const

inline

Magnitude of the vector

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

Here is the caller graph for this function:

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

inline

Linear interpolation

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

Here is the caller graph for this function:

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

inline

Component-wise maximum

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

Here is the call graph for this function:

Here is the caller graph for this function:

Vector2 G3D::Vector2::maxAbs ( const Vector2 &  v ) const

inline

Component-wise argmax(abs(), v.abs()).

For the larger magnitude vector, simply use (a.squaredMagnitude() > b.squaredMagnitude) ? a : b.

See also

max

 {
 return Vector2(::fabsf(x) > ::fabsf(v.x) ? x : v.x, ::fabsf(y) > ::fabsf(v.y) ? y : v.y);
 }

Here is the call graph for this function:

const Vector2 & G3D::Vector2::maxFinite ( )

static

Largest representable vector

 {
 static Vector2 v(FLT_MAX, FLT_MAX); 
 return v; 
}

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

inline

Component-wise minimum

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

Here is the call graph for this function:

Here is the caller graph for this function:

Vector2 G3D::Vector2::minAbs ( const Vector2 &  v ) const

inline

Component-wise argmin(abs(), v.abs()).

For the smaller magnitude vector, simply use (a.squaredMagnitude() < b.squaredMagnitude) ? a : b.

See also

max

 {
 return Vector2(::fabsf(x) < ::fabsf(v.x) ? x : v.x, ::fabsf(y) < ::fabsf(v.y) ? y : v.y);
 }

Here is the call graph for this function:

const Vector2 & G3D::Vector2::minFinite ( )

static

smallest (most negative) representable vector

 {
 static Vector2 v(-FLT_MAX, -FLT_MAX); 
 return v; 
}

const Vector2 & G3D::Vector2::nan ( )

static

 { 
 static Vector2 v(G3D::fnan(), G3D::fnan()); 
 return v; 
}

Here is the call graph for this function:

const Vector2 & G3D::Vector2::one ( )

static

 { 
 static const Vector2 v(1, 1); return v; 
}

bool G3D::Vector2::operator!= ( const Vector2 &  other ) const

inline

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

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

inline

 {
 return Vector2(fScalar*x, fScalar*y);
}

Here is the call graph for this function:

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

inline

Array (pointwise) multiplication

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

Here is the call graph for this function:

Vector2 & G3D::Vector2::operator*= ( float  fScalar )

inline

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

Vector2 & G3D::Vector2::operator*= ( const Vector2 &  rkVector )

inline

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

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

inline

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

Here is the call graph for this function:

Vector2 & G3D::Vector2::operator+= ( const Vector2 &  rkVector )

inline

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

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

inline

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

Here is the call graph for this function:

Vector2 G3D::Vector2::operator- ( ) const

inline

Unary minus

 {
 return Vector2( -x, -y);
}

Here is the call graph for this function:

Vector2 & G3D::Vector2::operator-= ( const Vector2 &  rkVector )

inline

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

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

inline

Array division

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

Here is the call graph for this function:

Vector2 G3D::Vector2::operator/

(

float

s

)

const

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

Vector2 & G3D::Vector2::operator/=

(

float

k

)

 {
 this->x /= k;
 this->y /= k;
 return *this;
}

Vector2 & G3D::Vector2::operator/= ( const Vector2 &  rkVector )

inline

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

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

private

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

private

Vector2 & G3D::Vector2::operator=

(

const Any &

a

)

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

Here is the call graph for this function:

Vector2 & G3D::Vector2::operator= ( const Vector2 &  other )

inline

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

bool G3D::Vector2::operator== ( const Vector2 &  other ) const

inline

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

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

private

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

private

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

inline

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

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

inline

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

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

inline

Raise each component of this vector to a power

 {
 return Vector2(powf(x, p), powf(y, p));
 }

Here is the call graph for this function:

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

static

Uniformly distributed random vector on the unit sphere

 {
 Vector2 result;

 do {
 result = Vector2(r.uniform(-1, 1), r.uniform(-1, 1));

 } while (result.squaredLength() >= 1.0f);

 return result.direction();
}

Here is the call graph for this function:

void G3D::Vector2::serialize

(

class BinaryOutput &

b

)

const

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::Vector2::serialize

(

class TextOutput &

t

)

const

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

Here is the call graph for this function:

float G3D::Vector2::squaredLength ( ) const

inline

 {
 return x*x + y*y;
}

Here is the caller graph for this function:

float G3D::Vector2::sum ( ) const

inline

x + y

 {
 return x + y;
 }

Any G3D::Vector2::toAny

(

)

const

Converts the Vector2 to an Any.

 {
 Any any(Any::ARRAY, "Vector2");
 any.append(x, y);
 return any;
}

Here is the call graph for this function:

std::string G3D::Vector2::toString

(

)

const

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

Here is the call graph for this function:

const Vector2 & G3D::Vector2::unitX ( )

static

 {
 static Vector2 v(1, 0);
 return v;
}

const Vector2 & G3D::Vector2::unitY ( )

static

 {
 static Vector2 v(0, 1);
 return v;
}

Vector2 G3D::Vector2::xx

(

)

const

{ return Vector2 (x, x); }

Here is the call graph for this function:

Vector3 G3D::Vector2::xxx

(

)

const

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

Vector4 G3D::Vector2::xxxx

(

)

const

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

Vector4 G3D::Vector2::xxxy

(

)

const

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

Vector3 G3D::Vector2::xxy

(

)

const

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

Vector4 G3D::Vector2::xxyx

(

)

const

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

Vector4 G3D::Vector2::xxyy

(

)

const

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

Vector2 G3D::Vector2::xy

(

)

const

{ return Vector2 (x, y); }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector3 G3D::Vector2::xyx

(

)

const

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

Vector4 G3D::Vector2::xyxx

(

)

const

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

Vector4 G3D::Vector2::xyxy

(

)

const

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

Vector3 G3D::Vector2::xyy

(

)

const

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

Vector4 G3D::Vector2::xyyx

(

)

const

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

Vector4 G3D::Vector2::xyyy

(

)

const

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

Vector2 G3D::Vector2::yx

(

)

const

{ return Vector2 (y, x); }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector3 G3D::Vector2::yxx

(

)

const

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

Vector4 G3D::Vector2::yxxx

(

)

const

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

Vector4 G3D::Vector2::yxxy

(

)

const

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

Vector3 G3D::Vector2::yxy

(

)

const

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

Vector4 G3D::Vector2::yxyx

(

)

const

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

Vector4 G3D::Vector2::yxyy

(

)

const

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

Vector2 G3D::Vector2::yy

(

)

const

{ return Vector2 (y, y); }

Here is the call graph for this function:

Vector3 G3D::Vector2::yyx

(

)

const

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

Vector4 G3D::Vector2::yyxx

(

)

const

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

Vector4 G3D::Vector2::yyxy

(

)

const

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

Vector3 G3D::Vector2::yyy

(

)

const

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

Vector4 G3D::Vector2::yyyx

(

)

const

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

Vector4 G3D::Vector2::yyyy

(

)

const

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

const Vector2 & G3D::Vector2::zero ( )

static

 {
 static Vector2 v(0, 0);
 return v;
}

Here is the caller graph for this function:

Member Data Documentation

float G3D::Vector2::x

float G3D::Vector2::y

---

The documentation for this class was generated from the following files:

• dep/g3dlite/include/G3D/Vector2.h
• dep/g3dlite/source/Vector2.cpp