TrinityCore: G3D Namespace Reference

TrinityCore

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages

Namespaces
	_internal

	units

Classes
class	_internalGThreadWorker

class	AABox

class	AlignedMemoryManager

class	Any
	Easy loading and saving of human-readable configuration files. More...

class	AnyTableReader

class	AreaMemoryManager
	Allocates memory in large blocks and then frees it as an area. More...

class	Array
	Dynamic 1D array tuned for performance. More...

class	AtomicInt32

class	BinaryInput

class	BinaryOutput

class	Box
	An arbitrary (oriented) 3D box, useful as a bounding box. More...

class	Box2D

class	BufferPool

class	BumpMapPreprocess

class	Capsule

class	CollisionDetection

class	Color1

class	Color3

class	Color4

class	Conduit

class	Cone

struct	ConvertAttributes

class	ConvexPolygon

class	ConvexPolygon2D

class	ConvexPolyhedron

class	CoordinateFrame
	A rigid body RT (rotation-translation) transformation. More...

class	CRTMemoryManager

class	Crypto

class	Cylinder

class	DirectedEdge

class	Dummy

class	FileNotFound

class	FilePath
	Parsing of file system paths. More...

class	FileSystem

class	Frustum

class	G3DSpecification

class	GMutex
	Mutual exclusion lock used for synchronization. More...

class	GMutexLock

class	GThread

class	GUniqueID

class	Image1

class	Image3

class	Image4

class	ImageFormat

class	Intersect

class	KDTree

class	LightweightConduit

class	Line

class	LineSegment

class	LineSegment2D

class	Log

class	Map2D

class	Matrix

class	Matrix2

class	Matrix3

class	Matrix4

class	Matrix4float64

struct	md5_state_s

class	MD5Hash

class	MemoryManager

class	MeshAlg

class	MeshBuilder

class	MeshEdgeTable

class	MirrorQuality

class	NetAddress

class	NetListener

class	NetworkDevice
	Abstraction of network (socket) functionality. More...

class	ParseError

class	PhysicsFrame

class	PhysicsFrameSpline

class	Plane

class	Pointer

class	PointHashGrid
	A sparse 3D grid of point-based data. More...

class	PointKDTree

class	PrecomputedRandom

class	PrimitiveType

class	Quat

class	Queue

class	Random

class	Ray

class	Rect2D

class	ReferenceCountedObject

class	RefractionQuality

class	ReliableConduit

class	Set

class	SmallArray

class	Sphere

class	Spinlock
	A mutual exclusion lock that busy-waits when locking. More...

class	Spline

class	SplineBase

class	SplineExtrapolationMode

class	SplineInterpolationMode

class	Stopwatch
	Accurately measure durations and framerates. More...

class	System
	OS and processor abstraction. More...

class	Table

class	TextInput
	A simple tokenizer for parsing text files. More...

class	TextOutput

class	ThreadSet

class	Token

class	Triangle

class	uint128

class	UprightFrame
	Coordinate frame expressed in Euler angles. Unlike a G3D::Quat, UprightFrame always keeps the reference frame from rolling about its own z axis. Particularly useful for cameras. More...

class	UprightSpline
	Shortest-path linear velocity spline for camera positions. Always keeps the camera from rolling. More...

class	Vector2

class	Vector3

class	Vector4

class	Vector4int8

class	WeakCache

class	Welder

class	WrapMode

class	XML
	Easy loading and saving of XML and HTML files. More...

Typedefs
typedef AreaMemoryManager	CoherentAllocator

typedef class CoordinateFrame	CFrame

typedef class Rect2D	AABox2D

typedef Color3	Biradiance3

typedef Color3	Radiance3

typedef Color3	Radiosity3

typedef Color3	Energy3

typedef Color3	Irradiance3

typedef Color3	Power3

typedef bool(*	AssertionHook )(const char _expression, const std::string &message, const char filename, int lineNumber, bool useGuiPrompt)

typedef void(*	ConsolePrintHook )(const std::string &)

typedef double	GameTime

typedef double	SimTime

typedef double	RealTime

typedef int8_t	int8

typedef uint8_t	uint8

typedef int16_t	int16

typedef uint16_t	uint16

typedef int32_t	int32

typedef uint32_t	uint32

typedef int64_t	int64

typedef uint64_t	uint64

typedef float	float32

typedef double	float64

typedef shared_ptr< class GThread >	GThreadRef

typedef shared_ptr< class Image1 >	Image1Ref

typedef shared_ptr< class Image3 >	Image3Ref

typedef shared_ptr< class Image4 >	Image4Ref

typedef ImageFormat	TextureFormat

typedef shared_ptr< class ReliableConduit >	ReliableConduitRef

typedef shared_ptr< class LightweightConduit >	LightweightConduitRef

typedef shared_ptr< class NetListener >	NetListenerRef

typedef PhysicsFrame	PFrame

typedef Stopwatch	StopWatch

typedef Vector2	Point2

typedef Vector2int16	Point2int16

typedef Vector2int32	Point2int32

typedef Vector2unorm16	Point2unorm16

typedef Vector3	Point3

typedef Vector3int16	Point3int16

typedef Vector3int32	Point3int32

typedef unsigned char	md5_byte_t

typedef unsigned int	md5_word_t

typedef struct G3D::md5_state_s	md5_state_t

typedef void(*	ConvertFunc )(const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

Enumerations
enum	BinaryFormat { FIRST_BINFMT = 1000, BOOL8_BINFMT, UINT8_BINFMT, INT8_BINFMT, UINT16_BINFMT, INT16_BINFMT, UINT32_BINFMT, INT32_BINFMT, UINT64_BINFMT, INT64_BINFMT, UINT128_BINFMT, INT128_BINFMT, FLOAT16_BINFMT, FLOAT32_BINFMT, FLOAT64_BINFMT, VECTOR2_BINFMT, VECTOR2INT16_BINFMT, VECTOR3_BINFMT, VECTOR3INT16_BINFMT, VECTOR4_BINFMT, VECTOR4INT16_BINFMT, COLOR3_BINFMT, COLOR3UINT8_BINFMT, COLOR3INT16_BINFMT, COLOR4_BINFMT, COLOR4UINT8_BINFMT, COLOR4INT16_BINFMT, STRING_BINFMT, STRINGEVEN_BINFMT, STRING8_BINFMT, STRING16_BINFMT, STRING32_BINFMT, CHUNK_BINFMT, CUSTOM_BINFMT, LAST_BINFMT }

enum	AMPM { AM, PM }

enum	{ SECOND =1, MINUTE =60, HOUR = 6060, DAY =246060, SUNRISE =246060/4, SUNSET =2460603/4, MIDNIGHT =0, METER =1, KILOMETER =1000 }

enum	SpawnBehavior { USE_NEW_THREAD, USE_CURRENT_THREAD }

enum	G3DEndian { G3D_BIG_ENDIAN, G3D_LITTLE_ENDIAN }
	The order in which the bytes of an integer are stored on a machine. More...

Functions
template<class T >
bool	contains (const T *array, int len, const T &e)

int32	byteSize (BinaryFormat f)

G3D::Color3	operator* (float s, const G3D::Color3 &c)

G3D::Color3	operator* (G3D::Color1 &s, const G3D::Color3 &c)

G3D::Color3	operator* (const G3D::Color3 &c, G3D::Color1 &s)

G3D::Color3	operator/ (float s, const G3D::Color3 &c)

Color4	operator* (const Color3 &c3, const Color4 &c4)

Color4	operator* (float fScalar, const Color4 &other)

bool	isValidHeapPointer (const void *x)

bool	isValidPointer (const void *x)

void	setAssertionHook (AssertionHook hook)

AssertionHook	assertionHook ()

void	setFailureHook (AssertionHook hook)

AssertionHook	failureHook ()

void	setConsolePrintHook (ConsolePrintHook h)

ConsolePrintHook	consolePrintHook ()

std::string __cdecl	consolePrintf (const char *fmt...) G3D_CHECK_PRINTF_ARGS

std::string	consolePrint (const std::string &)

std::string __cdecl	debugPrintf (const char *fmt...) G3D_CHECK_PRINTF_ARGS

std::string	debugPrint (const std::string &)

template<class EnumClass , class EnumClassValue >
void	enumToJavaScriptDeclaration (TextOutput &t)
	Generates JavaScript source code defining an enum equivalent to EnumClass. More...

std::string	readWholeFile (const std::string &filename)

void	writeWholeFile (const std::string &filename, const std::string &str, bool flush=true)

FILE *	createTempFile ()

bool	zipfileExists (const std::string &filename, std::string &outZipfile, std::string &outInternalFile)

bool	zipfileExists (const std::string &filename)

void	parseFilename (const std::string &filename, std::string &drive, Array< std::string > &path, std::string &base, std::string &ext)

std::string	filenameBaseExt (const std::string &filename)

std::string	filenameExt (const std::string &filename)

std::string	filenameBase (const std::string &filename)

std::string	generateFilenameBase (const std::string &prefix="", const std::string &suffix="")

std::string	filenamePath (const std::string &filename)

bool	filenameContainsWildcards (const std::string &filename)

std::string	pathConcat (const std::string &dirname, const std::string &file)

void	gaussian1D (Array< float > &coeff, int N=5, float std=0.5f)

std::string __cdecl	format (const char *fmt...) G3D_CHECK_PRINTF_ARGS

std::string	vformat (const char *fmt, va_list argPtr) G3D_CHECK_VPRINTF_ARGS

void	initG3D (const G3DSpecification &spec=G3DSpecification())

int	g3dfnmatch (const char pattern, const char string, int flags)

SimTime	toSeconds (int hour, int minute, double seconds, AMPM ap)

SimTime	toSeconds (int hour, int minute, AMPM ap)

double	inf ()

double	nan ()

float	finf ()

float	fnan ()

double	pi ()

float	pif ()

double	halfPi ()

double	twoPi ()

int	iAbs (int iValue)

int	iCeil (double fValue)

int	iClamp (int val, int low, int hi)

int16	iClamp (int16 val, int16 low, int16 hi)

double	clamp (double val, double low, double hi)

float	clamp (float val, float low, float hi)

double	lerp (double a, double b, double f)

float	lerp (float a, float b, float f)

int	iWrap (int val, int hi)

int	iFloor (double fValue)

int	iSign (int iValue)

int	iSign (double fValue)

int	iSign (float f)

double	round (double f)

float	round (float f)

int	iRound (double fValue)

int	iRound (float f)

int	iRandom (int low, int hi)

double	abs (double fValue)

double	aCos (double fValue)

double	aSin (double fValue)

double	aTan (double fValue)

double	aTan2 (double fY, double fX)

double	sign (double fValue)

double	square (double fValue)

bool	isFinite (double x)

bool	isNaN (double x)

bool	isNaN (float x)

bool	isNaN (int x)

bool	isNaN (uint64 x)

int	iMod3 (int x)

float	uniformRandom (float low=0.0f, float hi=1.0f)

float	gaussRandom (float mean=0.0f, float stdev=1.0f)

template<class T >
T	pow5 (T x)

template<class T >
T	min (const T &x, const T &y)

template<class T >
T	min (const T &x, const T &y, const T &z)

template<class T >
T	min (const T &x, const T &y, const T &z, const T &w)

template<class T >
T	max (const T &x, const T &y)

template<class T >
T	max (const T &x, const T &y, const T &z)

template<class T >
T	max (const T &x, const T &y, const T &z, const T &w)

int	iMin (int x, int y)

int	iMax (int x, int y)

double	sumSquares (double x, double y)

double	sumSquares (double x, double y, double z)

double	distance (double x, double y)

double	distance (double x, double y, double z)

int	highestBit (uint32 x)

bool	fuzzyEq (double a, double b)

bool	fuzzyNe (double a, double b)

bool	fuzzyGt (double a, double b)

bool	fuzzyGe (double a, double b)

bool	fuzzyLt (double a, double b)

bool	fuzzyLe (double a, double b)

float	rsq (float x)

int	ceilPow2 (unsigned int in)

int	pow2 (unsigned int x)

double	log2 (double x)

float	log2 (float x)

double	log2 (int x)

bool	isPow2 (int num)

bool	isPow2 (uint64 num)

bool	isOdd (int num)

bool	isEven (int num)

double	toRadians (double deg)

double	toDegrees (double rad)

bool	any (float x)

bool	all (float x)

float	normalize (float v)

float	dot (float a, float b)

float	mul (float a, float b)

double	exp2 (double x)

float	exp2 (float x)

double	rsqrt (double x)

float	rsqrt (float x)

double	sinc (double x)

float	wrap (float t, float lo, float hi)

double	wrap (double t, double lo, double hi)

double	wrap (double t, double hi)

bool	isFinite (float x)

float	acos (float fValue)

float	sign (float fValue)

float	square (float x)

int	square (int x)

float	sumSquares (float x, float y)

float	sumSquares (float x, float y, float z)

float	distance (float x, float y)

float	distance (float x, float y, float z)

bool	isPow2 (uint32 x)

float	toRadians (float deg)

float	toDegrees (float rad)

float	toRadians (int deg)

float	toDegrees (int rad)

double	eps (double a, double b)

float	eps (float a, float b)

bool	fuzzyEq (float a, float b)

uint32	flipEndian32 (const uint32 x)

uint16	flipEndian16 (const uint16 x)

float	smoothstep (float edge0, float edge1, float x)

float	smootherstep (float edge0, float edge1, float x)

float	signedPow (float b, float e)

double	signedPow (double b, double e)

template<class Class >
void	_internal_runConcurrently2DHelper (const Vector2int32 &start, const Vector2int32 &upTo, Class object, void(Class::method1)(int x, int y), void(Class::*method2)(int x, int y, int threadID), int maxThreads)

uint32_t	superFastHash (const void *_data, size_t numBytes)
	A hash function that is faster than CRC32 for arbitrary long strings [From] http://www.azillionmonkeys.com/qed/hash.html by Paul Hsieh. More...

uint32_t	wangHash6432Shift (int64 key)

void	logPrintf (const char *fmt,...)

void	logLazyPrintf (const char *fmt,...)

Vector3	operator* (const Vector3 &rkPoint, const Matrix3 &rkMatrix)

std::ostream &	operator<< (std::ostream &os, const NetAddress &)

bool	operator== (const NetAddress &a, const NetAddress &b)

bool	operator!= (const NetAddress &a, const NetAddress &b)

template<class T >
bool	isNull (const Pointer< T > &p)

template<class T >
bool	notNull (const Pointer< T > &p)

int	prompt (const char windowTitle, const char promptx, const char **choice, int numChoices, bool useGui)

int	prompt (const char windowTitle, const char promptx, const char **choice, int numChoices)

void	msgBox (const std::string &message, const std::string &title="Message")

Quat	exp (const Quat &q)

Quat	log (const Quat &q)

G3D::Quat	operator* (double s, const G3D::Quat &q)

G3D::Quat	operator* (float s, const G3D::Quat &q)

template<class T >
bool	isNull (const ReferenceCountedPointer< T > &ptr)

template<class T >
bool	notNull (const ReferenceCountedPointer< T > &ptr)

template<class T >
bool	isNull (const T *ptr)

template<class T >
bool	notNull (const T *ptr)

void	serialize (const std::string &s, BinaryOutput &b)

void	deserialize (std::string &s, BinaryInput &b)

void	serialize (const int32 &i, BinaryOutput &b)

void	deserialize (int32 &i, BinaryInput &b)

void	serialize (const uint32 &i, BinaryOutput &b)

void	deserialize (uint32 &i, BinaryInput &b)

void	serialize (const bool &i, BinaryOutput &b)

void	deserialize (bool &i, BinaryInput &b)

void	serialize (const float32 &f, BinaryOutput &b)

void	deserialize (float32 &f, BinaryInput &b)

void	serialize (const float64 &f, BinaryOutput &b)

void	deserialize (float64 &f, BinaryInput &b)

template<typename T >
void	serialize (const Array< T > &array, BinaryOutput &b)

template<typename T >
void	deserialize (Array< T > &array, BinaryInput &b)

template<class XType , class YType >
YType	linearSpline (double x, const XType controlX, const YType controlY, int numControl)

template<class YType >
YType	cyclicCatmullRomSpline (double t, const YType *controlY, int numPoints)

template<class YType >
YType	cyclicCatmullRomSpline (double t, const Array< YType > &controlY)

void	parseCommaSeparated (const std::string s, Array< std::string > &array, bool stripQuotes=true)

size_t	findSlash (const std::string &f, size_t start=0)

size_t	maxNotNPOS (size_t i, size_t j)
	Returns the larger string index, ignoring std::string::npos. More...

size_t	findLastSlash (const std::string &f, size_t start=std::string::npos)

std::string	replace (const std::string &s, const std::string &pattern, const std::string &replacement)

bool	isValidIdentifier (const std::string &s)

bool	beginsWith (const std::string &test, const std::string &pattern)
	Returns true if the test string begins with the pattern string. More...

bool	endsWith (const std::string &test, const std::string &pattern)
	Returns true if the test string ends with the pattern string. More...

std::string	wordWrap (const std::string &input, int numCols)
	Produces a new string that is the input string wrapped at a certain number of columns (where the line is broken at the latest space before the column limit.) Platform specific NEWLINEs are inserted to wrap. More...

int	stringCompare (const std::string &s1, const std::string &s2)

int	stringPtrCompare (const std::string s1, const std::string s2)

std::string	toUpper (const std::string &x)

std::string	toLower (const std::string &x)

G3D::Array< std::string >	stringSplit (const std::string &x, char splitChar)

std::string	stringJoin (const G3D::Array< std::string > &a, char joinChar)

std::string	stringJoin (const G3D::Array< std::string > &a, const std::string &joinStr)

std::string	trimWhitespace (const std::string &s)

bool	isWhiteSpace (const unsigned char c)

bool	isNewline (const unsigned char c)

bool	isDigit (const unsigned char c)

bool	isLetter (const unsigned char c)

bool	isSlash (const unsigned char c)

bool	isQuote (const unsigned char c)

int	countNewlines (const std::string &s)

std::string	license ()

void	deserialize (bool &b, TextInput &ti)

void	deserialize (int &b, TextInput &ti)

void	deserialize (uint8 &b, TextInput &ti)

void	deserialize (double &b, TextInput &ti)

void	deserialize (float &b, TextInput &ti)

void	deserialize (std::string &b, TextInput &ti)

void	serialize (const bool &b, TextOutput &to)

void	serialize (const int &b, TextOutput &to)

void	serialize (const uint8 &b, TextOutput &to)

void	serialize (const double &b, TextOutput &to)

void	serialize (const float &b, TextOutput &to)

void	serialize (const std::string &b, TextOutput &to)

void	serialize (const char *b, TextOutput &to)

	unorm16 (uint16 b)

static unorm16	fromBits (uint16 b)

static unorm16	reinterpretFrom (uint16 b)

	unorm16 ()

	unorm16 (const unorm16 &other)

	unorm16 (const class Any &a)

class Any	toAny () const

	unorm16 (float f)

	unorm16 (double f)

	operator float () const

	operator double () const

static unorm16	one ()

static unorm16	zero ()

uint16	bits () const
	Returns the underlying bits in this representation. Equivalent to: More...

uint16	reinterpretAsUInt16 () const
	Returns the underlying bits in this representation. Equivalent to: More...

bool	operator> (const unorm16 other) const

bool	operator< (const unorm16 other) const

bool	operator>= (const unorm16 other) const

bool	operator<= (const unorm16 other) const

bool	operator== (const unorm16 other) const

bool	operator!= (const unorm16 other) const

unorm16	operator+ (const unorm16 other) const

unorm16 &	operator+= (const unorm16 other)

unorm16	operator- (const unorm16 other) const

unorm16 &	operator-= (const unorm16 other)

unorm16	operator* (const int i) const

unorm16 &	operator*= (const int i)

unorm16	operator/ (const int i) const

unorm16 &	operator/= (const int i)

unorm16	operator<< (const int i) const

unorm16 &	operator<<= (const int i)

unorm16	operator>> (const int i) const

unorm16 &	operator>>= (const int i)

	unorm8 (uint8 b)

static unorm8	fromBits (uint8 b)

static unorm8	reinterpretFrom (uint8 b)

	unorm8 ()

	unorm8 (const unorm8 &other)

	unorm8 (float f)

	unorm8 (double f)

static unorm8	one ()

static unorm8	zero ()

uint8	reinterpretAsUInt8 () const
	Returns the underlying bits in this representation. Equivalent to: More...

bool	operator> (const unorm8 other) const

bool	operator< (const unorm8 other) const

bool	operator>= (const unorm8 other) const

bool	operator<= (const unorm8 other) const

bool	operator== (const unorm8 other) const

bool	operator!= (const unorm8 other) const

unorm8	operator+ (const unorm8 other) const

unorm8 &	operator+= (const unorm8 other)

unorm8	operator- (const unorm8 other) const

unorm8 &	operator-= (const unorm8 other)

Vector2	operator* (double s, const Vector2 &v)

Vector2	operator* (float s, const Vector2 &v)

Vector2	operator* (int s, const Vector2 &v)

void	serialize (const Vector2 &v, class BinaryOutput &b)

void	deserialize (Vector2 &v, class BinaryInput &b)

bool	operator> (const Vector2int16 &) const

bool	operator<= (const Vector2int16 &) const

bool	operator>= (const Vector2int16 &) const

	Vector2int16 ()

	Vector2int16 (G3D::int16 _x, G3D::int16 _y)

	Vector2int16 (const class Vector2 &v)

	Vector2int16 (class BinaryInput &bi)

	Vector2int16 (const class Any &a)

	Vector2int16 (const class Vector2int32 &v)

Vector2int16 &	operator= (const Any &a)

G3D::int16 &	operator[] (int i)

Vector2int16	operator+ (const Vector2int16 &other) const

Vector2int16	operator- (const Vector2int16 &other) const

Vector2int16	operator* (const Vector2int16 &other) const

Vector2int16	operator- () const

Vector2int16 &	operator+= (const Vector2int16 &other)

bool	isZero () const

Vector2int16 &	operator-= (const Vector2int16 &other)

Vector2int16 &	operator*= (const Vector2int16 &other)

Vector2int16	clamp (const Vector2int16 &lo, const Vector2int16 &hi)

bool	operator== (const Vector2int16 &rkVector) const

bool	operator!= (const Vector2int16 &rkVector) const

Vector2int16	max (const Vector2int16 &v) const

Vector2int16	min (const Vector2int16 &v) const

void	serialize (class BinaryOutput &bo) const

void	deserialize (class BinaryInput &bi)

bool	operator> (const Vector2int32 &) const

bool	operator<= (const Vector2int32 &) const

bool	operator>= (const Vector2int32 &) const

	Vector2int32 ()

	Vector2int32 (G3D::int32 _x, G3D::int32 _y)

	Vector2int32 (const class Vector2 &v)

	Vector2int32 (class BinaryInput &bi)

	Vector2int32 (const class Vector2int16 &v)

Vector2int32	operator+ (const Vector2int32 &other) const

Vector2int32	operator- (const Vector2int32 &other) const

Vector2int32	operator* (const Vector2int32 &other) const

Vector2int32 &	operator+= (const Vector2int32 &other)

Vector2int32 &	operator-= (const Vector2int32 &other)

Vector2int32 &	operator*= (const Vector2int32 &other)

Vector2int32	clamp (const Vector2int32 &lo, const Vector2int32 &hi)

bool	operator== (const Vector2int32 &other) const

bool	operator!= (const Vector2int32 &other) const

Vector2int32	max (const Vector2int32 &v) const

Vector2int32	min (const Vector2int32 &v) const

bool	operator> (const Vector2unorm16 &) const

bool	operator<= (const Vector2unorm16 &) const

bool	operator>= (const Vector2unorm16 &) const

	Vector2unorm16 ()

	Vector2unorm16 (G3D::unorm16 _x, G3D::unorm16 _y)

	Vector2unorm16 (float _x, float _y)

	Vector2unorm16 (const class Vector2 &v)

	Vector2unorm16 (class BinaryInput &bi)

	Vector2unorm16 (const class Any &a)

bool	operator== (const Vector2unorm16 &rkVector) const

bool	operator!= (const Vector2unorm16 &rkVector) const

size_t	hashCode () const

G3D::Vector3	operator* (float s, const G3D::Vector3 &v)

G3D::Vector3	operator* (double s, const G3D::Vector3 &v)

G3D::Vector3	operator* (int s, const G3D::Vector3 &v)

std::ostream &	operator<< (std::ostream &os, const Vector3 &)

void	serialize (const Vector3::Axis &a, class BinaryOutput &bo)

void	deserialize (Vector3::Axis &a, class BinaryInput &bo)

void	serialize (const Vector3 &v, class BinaryOutput &b)

void	deserialize (Vector3 &v, class BinaryInput &b)

bool	operator> (const Vector3int16 &) const

bool	operator<= (const Vector3int16 &) const

bool	operator>= (const Vector3int16 &) const

	Vector3int16 ()

	Vector3int16 (G3D::int16 _x, G3D::int16 _y, G3D::int16 _z)

	Vector3int16 (const class Vector3 &v)

	Vector3int16 (class BinaryInput &bi)

Vector3int16	operator+ (const Vector3int16 &other) const

Vector3int16	operator- (const Vector3int16 &other) const

Vector3int16	operator* (const Vector3int16 &other) const

Vector3int16 &	operator+= (const Vector3int16 &other)

Vector3int16 &	operator-= (const Vector3int16 &other)

Vector3int16 &	operator*= (const Vector3int16 &other)

static Vector3int16	floor (const Vector3 &v)

static Vector3int16	ceil (const Vector3 &v)

bool	operator== (const Vector3int16 &rkVector) const

bool	operator!= (const Vector3int16 &rkVector) const

int	dot (const Vector3int16 &v) const

Vector3int16	max (const Vector3int16 &v) const

Vector3int16	min (const Vector3int16 &v) const

std::string	toString () const

Vector3int16	operator>> (const Vector3int16 &v) const

Vector3int16	operator<< (const Vector3int16 &v) const

Vector3int16	operator& (int16 i) const

Vector3int16	operator& (const Vector3int16 &v) const

bool	operator> (const Vector3int32 &) const

bool	operator<= (const Vector3int32 &) const

bool	operator>= (const Vector3int32 &) const

	Vector3int32 ()

	Vector3int32 (int _x, int _y, int _z)

	Vector3int32 (const class Vector2int32 &v, int _z)

	Vector3int32 (const class Vector2int16 &v, int _z)

	Vector3int32 (const class Vector3int16 &v)

	Vector3int32 (const Any &any)

	Vector3int32 (const class Vector3 &v)

	Vector3int32 (class BinaryInput &bi)

static Vector3int32	truncate (const class Vector3 &v)

bool	nonZero () const

Vector3int32	operator+ (const Vector3int32 &other) const

Vector3int32	operator- (const Vector3int32 &other) const

Vector3int32	operator* (const Vector3int32 &other) const

Vector3int32	operator/ (const Vector3int32 &other) const

Vector3int32 &	operator+= (const Vector3int32 &other)

Vector3int32 &	operator-= (const Vector3int32 &other)

Vector3int32 &	operator*= (const Vector3int32 &other)

bool	operator== (const Vector3int32 &rkVector) const

bool	operator!= (const Vector3int32 &rkVector) const

Vector3int32	max (const Vector3int32 &v) const

Vector3int32	min (const Vector3int32 &v) const

Vector3int32	operator>> (const Vector3int32 &v) const

Vector3int32	operator<< (const Vector3int32 &v) const

Vector2int32	xx () const

Vector2int32	yx () const

Vector2int32	zx () const

Vector2int32	xy () const

Vector2int32	yy () const

Vector2int32	zy () const

Vector2int32	xz () const

Vector2int32	yz () const

Vector2int32	zz () const

Vector3int32	iFloor (const Vector3 &)

void	serialize (const Vector4 &v, class BinaryOutput &b)

void	deserialize (Vector4 &v, class BinaryInput &b)

Matrix4	mul (const Matrix4 &a, const Matrix4 &b)

Vector4	mul (const Matrix4 &m, const Vector4 &v)

Vector3	mul (const Matrix3 &m, const Vector3 &v)

Matrix3	mul (const Matrix3 &a, const Matrix3 &b)

float	dot (const Vector2 &a, const Vector2 &b)

float	dot (const Vector3 &a, const Vector3 &b)

float	dot (const Vector4 &a, const Vector4 &b)

Vector2	normalize (const Vector2 &v)

Vector3	normalize (const Vector3 &v)

Vector4	normalize (const Vector4 &v)

Vector2	abs (const Vector2 &v)

Vector3	abs (const Vector3 &v)

Vector4	abs (const Vector4 &v)

bool	all (const Vector2 &v)

bool	all (const Vector3 &v)

bool	all (const Vector4 &v)

bool	any (const Vector2 &v)

bool	any (const Vector3 &v)

bool	any (const Vector4 &v)

Vector2	clamp (const Vector2 &v, const Vector2 &a, const Vector2 &b)

Vector3	clamp (const Vector3 &v, const Vector3 &a, const Vector3 &b)

Vector4	clamp (const Vector4 &v, const Vector4 &a, const Vector4 &b)

Vector2	lerp (const Vector2 &v1, const Vector2 &v2, float f)

Vector3	lerp (const Vector3 &v1, const Vector3 &v2, float f)

Vector4	lerp (const Vector4 &v1, const Vector4 &v2, float f)

Color1	lerp (const Color1 &v1, const Color1 &v2, float f)

Color3	lerp (const Color3 &v1, const Color3 &v2, float f)

Color4	lerp (const Color4 &v1, const Color4 &v2, float f)

Vector3	cross (const Vector3 &v1, const Vector3 &v2)

double	determinant (const Matrix3 &m)

double	determinant (const Matrix4 &m)

Vector2	min (const Vector2 &v1, const Vector2 &v2)

Vector3	min (const Vector3 &v1, const Vector3 &v2)

Vector4	min (const Vector4 &v1, const Vector4 &v2)

Color3	min (const Color3 &v1, const Color3 &v2)

Color4	min (const Color4 &v1, const Color4 &v2)

Vector2	max (const Vector2 &v1, const Vector2 &v2)

Vector3	max (const Vector3 &v1, const Vector3 &v2)

Vector4	max (const Vector4 &v1, const Vector4 &v2)

Color3	max (const Color3 &v1, const Color3 &v2)

Color4	max (const Color4 &v1, const Color4 &v2)

Vector2	sign (const Vector2 &v)

Vector3	sign (const Vector3 &v)

Vector4	sign (const Vector4 &v)

float	length (float v)

float	length (const Vector2 &v)

float	length (const Vector3 &v)

float	length (const Vector4 &v)

Color3	log (const Color3 &c)

static bool	isContainerType (Any::Type &t)

static char	toLower (char c)

static void	getDeserializeSettings (TextInput::Settings &settings)

static bool	needsQuotes (const std::string &s)

static bool	isOpen (const char c)

static bool	isClose (const char c)

static bool	isSeparator (char c)

static Any::Type	findType (TextInput &ti, const char closeSymbol)

static uint32	readUInt32FromBuffer (const uint8 *data, bool swapBytes)

static bool	isNewline (char c)

static int	findRayCapsuleIntersectionAux (const Vector3 &rkOrigin, const Vector3 &rkDirection, const Capsule &rkCapsule, double afT[2])

static bool	findRayCapsuleIntersection (const Ray &rkRay, const Capsule &rkCapsule, int &riQuantity, Vector3 akPoint[2])

static bool	planeBoxOverlap (const Vector3 &normal, const Vector3 &vert, const Vector3 &maxbox)

static void	md5_init (md5_state_t *pms)

static void	md5_append (md5_state_t pms, const md5_byte_t data, int nbytes)

static void	md5_finish (md5_state_t *pms, md5_byte_t digest[16])

static void	md5_process (md5_state_t pms, const md5_byte_t data)

static int	fixslash (int c)

std::string	resolveFilename (const std::string &filename)

int64	fileLength (const std::string &filename)

void	createDirectory (const std::string &dir)

void	copyFile (const std::string &source, const std::string &dest)

static void	getFileOrDirListNormal (const std::string &filespec, Array< std::string > &files, bool wantFiles, bool includePath)

static void	getFileOrDirListZip (const std::string &path, const std::string &prefix, Array< std::string > &files, bool wantFiles, bool includePath)

static void	determineFileOrDirList (const std::string &filespec, Array< std::string > &files, bool wantFiles, bool includePath)

void	getFiles (const std::string &filespec, Array< std::string > &files, bool includePath)

void	getDirs (const std::string &filespec, Array< std::string > &files, bool includePath)

bool	isZipfile (const std::string &filename)

bool	isDirectory (const std::string &filename)

bool	fileIsNewer (const std::string &src, const std::string &dst)

std::string __cdecl	format (const char *fmt,...)

	DEFINE_TEXTUREFORMAT_METHOD (L8, 1, UNCOMP_FORMAT, GL_LUMINANCE8, GL_LUMINANCE, 8, 0, 0, 0, 0, 0, 0, 8, 8, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, CODE_L8, COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (L16, 1, UNCOMP_FORMAT, GL_LUMINANCE16, GL_LUMINANCE, 16, 0, 0, 0, 0, 0, 0, 16, 16, GL_UNSIGNED_SHORT, OPAQUE_FORMAT, INTEGER_FORMAT, CODE_L16, COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (L16F, 1, UNCOMP_FORMAT, GL_LUMINANCE16F_ARB, GL_LUMINANCE, 16, 0, 0, 0, 0, 0, 0, 16, 16, GL_HALF_FLOAT, OPAQUE_FORMAT, FLOATING_POINT_FORMAT, CODE_L16F, COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (L32F, 1, UNCOMP_FORMAT, GL_LUMINANCE32F_ARB, GL_LUMINANCE, 32, 0, 0, 0, 0, 0, 0, 32, 32, GL_FLOAT, OPAQUE_FORMAT, FLOATING_POINT_FORMAT, CODE_L32F, COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (A8, 1, UNCOMP_FORMAT, GL_ALPHA8, GL_ALPHA, 0, 8, 0, 0, 0, 0, 0, 8, 8, GL_UNSIGNED_BYTE, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, CODE_A8, COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (A16, 1, UNCOMP_FORMAT, GL_ALPHA16, GL_ALPHA, 0, 16, 0, 0, 0, 0, 0, 16, 16, GL_UNSIGNED_SHORT, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, CODE_A16, COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (A16F, 1, UNCOMP_FORMAT, GL_ALPHA16F_ARB, GL_ALPHA, 0, 16, 0, 0, 0, 0, 0, 16, 16, GL_HALF_FLOAT, CLEAR_FORMAT, FLOATING_POINT_FORMAT, CODE_A16F, COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (A32F, 1, UNCOMP_FORMAT, GL_ALPHA32F_ARB, GL_ALPHA, 0, 32, 0, 0, 0, 0, 0, 32, 32, GL_FLOAT, CLEAR_FORMAT, FLOATING_POINT_FORMAT, CODE_A32F, COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (LA4, 2, UNCOMP_FORMAT, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE_ALPHA, 4, 4, 0, 0, 0, 0, 0, 8, 8, GL_UNSIGNED_BYTE, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, CODE_LA4, COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (LA8, 2, UNCOMP_FORMAT, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE_ALPHA, 8, 8, 0, 0, 0, 0, 0, 16, 16, GL_UNSIGNED_BYTE, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, CODE_LA8, COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (LA16, 2, UNCOMP_FORMAT, GL_LUMINANCE16_ALPHA16, GL_LUMINANCE_ALPHA, 16, 16, 0, 0, 0, 0, 0, 16 2, 16 2, GL_UNSIGNED_SHORT, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, CODE_LA16, COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (LA16F, 2, UNCOMP_FORMAT, GL_LUMINANCE_ALPHA16F_ARB, GL_LUMINANCE_ALPHA, 16, 16, 0, 0, 0, 0, 0, 16 2, 16 2, GL_HALF_FLOAT, CLEAR_FORMAT, FLOATING_POINT_FORMAT, ImageFormat::CODE_LA16F, ImageFormat::COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (LA32F, 2, UNCOMP_FORMAT, GL_LUMINANCE_ALPHA32F_ARB, GL_LUMINANCE_ALPHA, 32, 32, 0, 0, 0, 0, 0, 32 2, 32 2, GL_FLOAT, CLEAR_FORMAT, FLOATING_POINT_FORMAT, ImageFormat::CODE_LA32F, ImageFormat::COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (BGR8, 3, UNCOMP_FORMAT, GL_RGB8, GL_BGR, 0, 0, 8, 8, 8, 0, 0, 32, 24, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_BGR8, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (BGRA8, 4, UNCOMP_FORMAT, GL_RGBA8, GL_BGRA, 0, 8, 8, 8, 8, 0, 0, 32, 32, GL_UNSIGNED_BYTE, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_BGRA8, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (R8, 1, UNCOMP_FORMAT, GL_R8, GL_RED, 0, 0, 8, 0, 0, 0, 0, 8, 8, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_R8, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (R8I, 1, UNCOMP_FORMAT, GL_R8I, GL_RED_INTEGER, 0, 0, 8, 0, 0, 0, 0, 8, 8, GL_BYTE, OPAQUE_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_R8I, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (R8UI, 1, UNCOMP_FORMAT, GL_R8UI, GL_RED_INTEGER, 0, 0, 8, 0, 0, 0, 0, 8, 8, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_R8UI, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (R16, 1, UNCOMP_FORMAT, GL_R16, GL_RED, 0, 0, 16, 0, 0, 0, 0, 16, 16, GL_UNSIGNED_SHORT, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_R16, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (R16I, 1, UNCOMP_FORMAT, GL_R16I, GL_RED_INTEGER, 0, 0, 16, 0, 0, 0, 0, 16, 16, GL_SHORT, OPAQUE_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_R16I, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (R16UI, 1, UNCOMP_FORMAT, GL_R16UI, GL_RED_INTEGER, 0, 0, 16, 0, 0, 0, 0, 16, 16, GL_UNSIGNED_SHORT, OPAQUE_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_R16UI, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (R32I, 1, UNCOMP_FORMAT, GL_R32I, GL_RED_INTEGER, 0, 0, 32, 0, 0, 0, 0, 32, 32, GL_INT, OPAQUE_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_R32I, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (R32UI, 1, UNCOMP_FORMAT, GL_R32UI, GL_RED_INTEGER, 0, 0, 32, 0, 0, 0, 0, 32, 32, GL_UNSIGNED_INT, OPAQUE_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_R32UI, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RG8, 2, UNCOMP_FORMAT, GL_RG8, GL_RG, 0, 0, 8, 8, 0, 0, 0, 16, 16, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_RG8, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RG8I, 2, UNCOMP_FORMAT, GL_RG8I, GL_RG_INTEGER, 0, 0, 8, 8, 0, 0, 0, 16, 16, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_RG8I, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RG8UI, 2, UNCOMP_FORMAT, GL_RG8UI, GL_RG_INTEGER, 0, 0, 8, 8, 0, 0, 0, 16, 16, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_RG8UI, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RG16, 2, UNCOMP_FORMAT, GL_RG16, GL_RG, 0, 0, 16, 16, 0, 0, 0, 16 2, 16 2, GL_UNSIGNED_SHORT, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_RG16, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RG16I, 2, UNCOMP_FORMAT, GL_RG16I, GL_RG_INTEGER, 0, 0, 16, 16, 0, 0, 0, 16 2, 16 2, GL_SHORT, OPAQUE_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_RG16I, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RG16UI, 2, UNCOMP_FORMAT, GL_RG16UI, GL_RG_INTEGER, 0, 0, 16, 16, 0, 0, 0, 16 2, 16 2, GL_UNSIGNED_SHORT, OPAQUE_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_RG16UI, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (R16F, 1, UNCOMP_FORMAT, GL_R16F, GL_RED, 0, 0, 16, 0, 0, 0, 0, 16, 16, GL_HALF_FLOAT, OPAQUE_FORMAT, FLOATING_POINT_FORMAT, ImageFormat::CODE_R16F, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RG16F, 2, UNCOMP_FORMAT, GL_RG16F, GL_RG, 0, 0, 16, 16, 0, 0, 0, 32, 32, GL_HALF_FLOAT, OPAQUE_FORMAT, FLOATING_POINT_FORMAT, ImageFormat::CODE_RG16F, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RG32I, 2, UNCOMP_FORMAT, GL_RG32I, GL_RG_INTEGER, 0, 0, 32, 32, 0, 0, 0, 32 2, 32 2, GL_INT, OPAQUE_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_RG32I, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RG32UI, 2, UNCOMP_FORMAT, GL_RG32UI, GL_RG_INTEGER, 0, 0, 32, 32, 0, 0, 0, 32 2, 32 2, GL_UNSIGNED_INT, OPAQUE_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_RG32UI, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (R32F, 1, UNCOMP_FORMAT, GL_R32F, GL_RED, 0, 0, 32, 0, 0, 0, 0, 32, 32, GL_FLOAT, OPAQUE_FORMAT, FLOATING_POINT_FORMAT, ImageFormat::CODE_R32F, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RG32F, 2, UNCOMP_FORMAT, GL_RG32F, GL_RG, 0, 0, 32, 32, 0, 0, 0, 64, 64, GL_FLOAT, OPAQUE_FORMAT, FLOATING_POINT_FORMAT, ImageFormat::CODE_RG32F, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGB5, 3, UNCOMP_FORMAT, GL_RGB5, GL_RGBA, 0, 0, 5, 5, 5, 0, 0, 16, 16, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_RGB5, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGB5A1, 4, UNCOMP_FORMAT, GL_RGB5_A1, GL_RGBA, 0, 1, 5, 5, 5, 0, 0, 16, 16, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_RGB5A1, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGB8, 3, UNCOMP_FORMAT, GL_RGB8, GL_RGB, 0, 0, 8, 8, 8, 0, 0, 32, 24, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_RGB8, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGB10, 3, UNCOMP_FORMAT, GL_RGB10, GL_RGB, 0, 0, 10, 10, 10, 0, 0, 32, 10 *3, GL_UNSIGNED_SHORT, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_RGB10, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGB10A2, 4, UNCOMP_FORMAT, GL_RGB10_A2, GL_RGBA, 0, 2, 10, 10, 10, 0, 0, 32, 32, GL_UNSIGNED_INT_10_10_10_2, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_RGB10A2, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGB16, 3, UNCOMP_FORMAT, GL_RGB16, GL_RGB, 0, 0, 16, 16, 16, 0, 0, 16 3, 16 3, GL_UNSIGNED_SHORT, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_RGB16, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGB16F, 3, UNCOMP_FORMAT, GL_RGB16F_ARB, GL_RGB, 0, 0, 16, 16, 16, 0, 0, 16 3, 16 3, GL_HALF_FLOAT, OPAQUE_FORMAT, FLOATING_POINT_FORMAT, ImageFormat::CODE_RGB16F, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGB32F, 3, UNCOMP_FORMAT, GL_RGB32F_ARB, GL_RGB, 0, 0, 32, 32, 32, 0, 0, 32 3, 32 3, GL_FLOAT, OPAQUE_FORMAT, FLOATING_POINT_FORMAT, ImageFormat::CODE_RGB32F, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGBA8, 4, UNCOMP_FORMAT, GL_RGBA8, GL_RGBA, 0, 8, 8, 8, 8, 0, 0, 32, 32, GL_UNSIGNED_BYTE, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_RGBA8, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGBA16, 4, UNCOMP_FORMAT, GL_RGBA16, GL_RGBA, 0, 16, 16, 16, 16, 0, 0, 16 4, 16 4, GL_UNSIGNED_SHORT, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_RGBA16, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGBA16F, 4, UNCOMP_FORMAT, GL_RGBA16F_ARB, GL_RGBA, 0, 16, 16, 16, 16, 0, 0, 16 4, 16 4, GL_HALF_FLOAT, CLEAR_FORMAT, FLOATING_POINT_FORMAT, ImageFormat::CODE_RGBA16F, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGBA32F, 4, UNCOMP_FORMAT, GL_RGBA32F_ARB, GL_RGBA, 0, 32, 32, 32, 32, 0, 0, 32 4, 32 4, GL_FLOAT, CLEAR_FORMAT, FLOATING_POINT_FORMAT, ImageFormat::CODE_RGBA32F, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGBA16I, 4, UNCOMP_FORMAT, GL_RGBA16I, GL_RGBA_INTEGER, 0, 16, 16, 16, 16, 0, 0, 16 4, 16 4, GL_SHORT, CLEAR_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_RGBA16I, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGBA16UI, 4, UNCOMP_FORMAT, GL_RGBA16UI, GL_RGBA_INTEGER, 0, 16, 16, 16, 16, 0, 0, 16 4, 16 4, GL_UNSIGNED_SHORT, CLEAR_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_RGBA16UI, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGB32I, 3, UNCOMP_FORMAT, GL_RGB32I, GL_RGBA_INTEGER, 0, 32, 32, 32, 0, 0, 0, 32 3, 32 3, GL_INT, OPAQUE_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_RGB32I, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGB32UI, 3, UNCOMP_FORMAT, GL_RGB32UI, GL_RGBA_INTEGER, 0, 32, 32, 32, 0, 0, 0, 32 3, 32 3, GL_UNSIGNED_INT, OPAQUE_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_RGB32UI, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGBA32I, 4, UNCOMP_FORMAT, GL_RGBA32I, GL_RGBA_INTEGER, 0, 32, 32, 32, 32, 0, 0, 32 4, 32 4, GL_INT, CLEAR_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_RGBA32I, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGBA32UI, 4, UNCOMP_FORMAT, GL_RGBA32UI, GL_RGBA_INTEGER, 0, 32, 32, 32, 32, 0, 0, 32 4, 32 4, GL_UNSIGNED_INT, CLEAR_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_RGBA32UI, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (R11G11B10F, 3, UNCOMP_FORMAT, GL_R11F_G11F_B10F_EXT, GL_RGB, 0, 0, 11, 11, 10, 0, 0, 32, 32, GL_FLOAT, OPAQUE_FORMAT, FLOATING_POINT_FORMAT, ImageFormat::CODE_R11G11B10F, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGB9E5F, 3, UNCOMP_FORMAT, GL_RGB9_E5_EXT, GL_RGB, 0, 0, 14, 14, 14, 0, 0, 32, 32, GL_FLOAT, OPAQUE_FORMAT, FLOATING_POINT_FORMAT, ImageFormat::CODE_RGB9E5F, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGB8I, 3, UNCOMP_FORMAT, GL_RGB8I_EXT, GL_RGB_INTEGER, 0, 0, 8, 8, 8, 0, 0, 32, 24, GL_BYTE, OPAQUE_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_RGB8I, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGB8UI, 3, UNCOMP_FORMAT, GL_RGB8UI_EXT, GL_RGB_INTEGER, 0, 0, 8, 8, 8, 0, 0, 32, 24, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_RGB8UI, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGBA8I, 4, UNCOMP_FORMAT, GL_RGBA8I_EXT, GL_RGBA_INTEGER, 0, 8, 8, 8, 8, 0, 0, 32, 32, GL_BYTE, CLEAR_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_RGBA8I, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGBA8UI, 4, UNCOMP_FORMAT, GL_RGBA8UI_EXT, GL_RGBA_INTEGER, 0, 8, 8, 8, 8, 0, 0, 32, 32, GL_UNSIGNED_BYTE, CLEAR_FORMAT, INTEGER_FORMAT, ImageFormat::CODE_RGBA8UI, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGB8_SNORM, 3, UNCOMP_FORMAT, GL_RGB8_SNORM, GL_RGB, 0, 0, 8, 8, 8, 0, 0, 32, 32, GL_BYTE, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_RGB8_SNORM, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGBA8_SNORM, 4, UNCOMP_FORMAT, GL_RGBA8_SNORM, GL_RGBA, 0, 8, 8, 8, 8, 0, 0, 32, 32, GL_BYTE, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_RGBA8_SNORM, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGB16_SNORM, 3, UNCOMP_FORMAT, GL_RGB16_SNORM, GL_RGB, 0, 0, 16, 16, 16, 0, 0, 64, 64, GL_SHORT, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_RGB16_SNORM, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGBA16_SNORM, 4, UNCOMP_FORMAT, GL_RGBA16_SNORM, GL_RGB, 0, 16, 16, 16, 16, 0, 0, 64, 64, GL_SHORT, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_RGBA16_SNORM, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGB_DXT1, 3, COMP_FORMAT, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_RGB, 0, 0, 0, 0, 0, 0, 0, 64, 64, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, OTHER, ImageFormat::CODE_RGB_DXT1, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGBA_DXT1, 4, COMP_FORMAT, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_RGBA, 0, 0, 0, 0, 0, 0, 0, 64, 64, GL_UNSIGNED_BYTE, CLEAR_FORMAT, OTHER, ImageFormat::CODE_RGBA_DXT1, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGBA_DXT3, 4, COMP_FORMAT, GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_RGBA, 0, 0, 0, 0, 0, 0, 0, 128, 128, GL_UNSIGNED_BYTE, CLEAR_FORMAT, OTHER, ImageFormat::CODE_RGBA_DXT3, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (RGBA_DXT5, 4, COMP_FORMAT, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_RGBA, 0, 0, 0, 0, 0, 0, 0, 128, 128, GL_UNSIGNED_BYTE, CLEAR_FORMAT, OTHER, ImageFormat::CODE_RGBA_DXT5, ImageFormat::COLOR_SPACE_RGB)

	DEFINE_TEXTUREFORMAT_METHOD (SRGB8, 3, UNCOMP_FORMAT, GL_SRGB8, GL_RGB, 0, 0, 8, 8, 8, 0, 0, 32, 24, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_SRGB8, ImageFormat::COLOR_SPACE_SRGB)

	DEFINE_TEXTUREFORMAT_METHOD (SRGBA8, 4, UNCOMP_FORMAT, GL_SRGB8_ALPHA8, GL_RGBA, 0, 8, 8, 8, 8, 0, 0, 32, 24, GL_UNSIGNED_BYTE, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_SRGBA8, ImageFormat::COLOR_SPACE_SRGB)

	DEFINE_TEXTUREFORMAT_METHOD (SL8, 1, UNCOMP_FORMAT, GL_SLUMINANCE8, GL_LUMINANCE, 8, 0, 0, 0, 0, 0, 0, 8, 8, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_SL8, ImageFormat::COLOR_SPACE_SRGB)

	DEFINE_TEXTUREFORMAT_METHOD (SLA8, 2, UNCOMP_FORMAT, GL_SLUMINANCE8_ALPHA8, GL_LUMINANCE_ALPHA, 8, 8, 0, 0, 0, 0, 0, 16, 16, GL_UNSIGNED_BYTE, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_SLA8, ImageFormat::COLOR_SPACE_SRGB)

	DEFINE_TEXTUREFORMAT_METHOD (SRGB_DXT1, 3, COMP_FORMAT, GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, GL_RGB, 0, 0, 0, 0, 0, 0, 0, 64, 64, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, OTHER, ImageFormat::CODE_SRGB_DXT1, ImageFormat::COLOR_SPACE_SRGB)

	DEFINE_TEXTUREFORMAT_METHOD (SRGBA_DXT1, 4, COMP_FORMAT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, GL_RGBA, 0, 0, 0, 0, 0, 0, 0, 64, 64, GL_UNSIGNED_BYTE, CLEAR_FORMAT, OTHER, ImageFormat::CODE_SRGBA_DXT1, ImageFormat::COLOR_SPACE_SRGB)

	DEFINE_TEXTUREFORMAT_METHOD (SRGBA_DXT3, 4, COMP_FORMAT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, GL_RGBA, 0, 0, 0, 0, 0, 0, 0, 128, 128, GL_UNSIGNED_BYTE, CLEAR_FORMAT, OTHER, ImageFormat::CODE_SRGBA_DXT3, ImageFormat::COLOR_SPACE_SRGB)

	DEFINE_TEXTUREFORMAT_METHOD (SRGBA_DXT5, 4, COMP_FORMAT, GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_RGBA, 0, 0, 0, 0, 0, 0, 0, 128, 128, GL_UNSIGNED_BYTE, CLEAR_FORMAT, OTHER, ImageFormat::CODE_SRGBA_DXT5, ImageFormat::COLOR_SPACE_SRGB)

	DEFINE_TEXTUREFORMAT_METHOD (DEPTH16, 1, UNCOMP_FORMAT, GL_DEPTH_COMPONENT16_ARB, GL_DEPTH_COMPONENT, 0, 0, 0, 0, 0, 16, 0, 16, 16, GL_UNSIGNED_SHORT, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_DEPTH16, ImageFormat::COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (DEPTH24, 1, UNCOMP_FORMAT, GL_DEPTH_COMPONENT24_ARB, GL_DEPTH_COMPONENT, 0, 0, 0, 0, 0, 24, 0, 32, 24, GL_UNSIGNED_INT, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_DEPTH24, ImageFormat::COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (DEPTH32, 1, UNCOMP_FORMAT, GL_DEPTH_COMPONENT32_ARB, GL_DEPTH_COMPONENT, 0, 0, 0, 0, 0, 32, 0, 32, 32, GL_UNSIGNED_INT, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_DEPTH32, ImageFormat::COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (DEPTH32F, 1, UNCOMP_FORMAT, GL_DEPTH_COMPONENT32_ARB, GL_DEPTH_COMPONENT, 0, 0, 0, 0, 0, 32, 0, 32, 32, GL_FLOAT, CLEAR_FORMAT, FLOATING_POINT_FORMAT, ImageFormat::CODE_DEPTH32F, ImageFormat::COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (STENCIL1, 1, UNCOMP_FORMAT, GL_STENCIL_INDEX1_EXT, GL_STENCIL_INDEX, 0, 0, 0, 0, 0, 0, 1, 1, 1, GL_UNSIGNED_BYTE, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_STENCIL1, ImageFormat::COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (STENCIL4, 1, UNCOMP_FORMAT, GL_STENCIL_INDEX4_EXT, GL_STENCIL_INDEX, 0, 0, 0, 0, 0, 0, 4, 4, 4, GL_UNSIGNED_BYTE, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_STENCIL4, ImageFormat::COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (STENCIL8, 1, UNCOMP_FORMAT, GL_STENCIL_INDEX8_EXT, GL_STENCIL_INDEX, 0, 0, 0, 0, 0, 0, 8, 8, 8, GL_UNSIGNED_BYTE, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_STENCIL8, ImageFormat::COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (STENCIL16, 1, UNCOMP_FORMAT, GL_STENCIL_INDEX16_EXT, GL_STENCIL_INDEX, 0, 0, 0, 0, 0, 0, 16, 16, 16, GL_UNSIGNED_SHORT, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_STENCIL16, ImageFormat::COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (DEPTH24_STENCIL8, 2, UNCOMP_FORMAT, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH_STENCIL_EXT, 0, 0, 0, 0, 0, 24, 8, 32, 32, GL_UNSIGNED_INT_24_8, CLEAR_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_DEPTH24_STENCIL8, ImageFormat::COLOR_SPACE_NONE)

	DEFINE_TEXTUREFORMAT_METHOD (YUV420_PLANAR, 3, UNCOMP_FORMAT, GL_NONE, GL_NONE, 0, 0, 0, 0, 0, 0, 0, 12, 12, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_YUV420_PLANAR, ImageFormat::COLOR_SPACE_YUV)

	DEFINE_TEXTUREFORMAT_METHOD (YUV422, 3, UNCOMP_FORMAT, GL_NONE, GL_NONE, 0, 0, 0, 0, 0, 0, 0, 16, 16, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_YUV422, ImageFormat::COLOR_SPACE_YUV)

	DEFINE_TEXTUREFORMAT_METHOD (YUV444, 3, UNCOMP_FORMAT, GL_NONE, GL_NONE, 0, 0, 0, 0, 0, 0, 0, 24, 24, GL_UNSIGNED_BYTE, OPAQUE_FORMAT, NORMALIZED_FIXED_POINT_FORMAT, ImageFormat::CODE_YUV444, ImageFormat::COLOR_SPACE_YUV)

	DECLARE_CONVERT_FUNC (l8_to_rgb8)

	DECLARE_CONVERT_FUNC (l32f_to_rgb8)

	DECLARE_CONVERT_FUNC (rgb8_to_rgba8)

	DECLARE_CONVERT_FUNC (rgb8_to_bgr8)

	DECLARE_CONVERT_FUNC (rgb8_to_rgba32f)

	DECLARE_CONVERT_FUNC (bgr8_to_rgb8)

	DECLARE_CONVERT_FUNC (bgr8_to_rgba8)

	DECLARE_CONVERT_FUNC (bgr8_to_rgba32f)

	DECLARE_CONVERT_FUNC (rgba8_to_rgb8)

	DECLARE_CONVERT_FUNC (rgba8_to_bgr8)

	DECLARE_CONVERT_FUNC (rgba8_to_rgba32f)

	DECLARE_CONVERT_FUNC (rgb32f_to_rgba32f)

	DECLARE_CONVERT_FUNC (rgba32f_to_rgb8)

	DECLARE_CONVERT_FUNC (rgba32f_to_rgba8)

	DECLARE_CONVERT_FUNC (rgba32f_to_bgr8)

	DECLARE_CONVERT_FUNC (rgba32f_to_rgb32f)

	DECLARE_CONVERT_FUNC (rgba32f_to_bayer_rggb8)

	DECLARE_CONVERT_FUNC (rgba32f_to_bayer_gbrg8)

	DECLARE_CONVERT_FUNC (rgba32f_to_bayer_grbg8)

	DECLARE_CONVERT_FUNC (rgba32f_to_bayer_bggr8)

	DECLARE_CONVERT_FUNC (bayer_rggb8_to_rgba32f)

	DECLARE_CONVERT_FUNC (bayer_gbrg8_to_rgba32f)

	DECLARE_CONVERT_FUNC (bayer_grbg8_to_rgba32f)

	DECLARE_CONVERT_FUNC (bayer_bggr8_to_rgba32f)

	DECLARE_CONVERT_FUNC (rgb8_to_yuv420p)

	DECLARE_CONVERT_FUNC (rgb8_to_yuv422)

	DECLARE_CONVERT_FUNC (rgb8_to_yuv444)

	DECLARE_CONVERT_FUNC (yuv420p_to_rgb8)

	DECLARE_CONVERT_FUNC (yuv422_to_rgb8)

	DECLARE_CONVERT_FUNC (yuv444_to_rgb8)

static ConvertFunc	findConverter (TextureFormat::Code sourceCode, TextureFormat::Code destCode, bool needsSourcePadding, bool needsDestPadding, bool needsInvertY)

bool	conversionAvailable (const ImageFormat srcFormat, int srcRowPadBits, const ImageFormat dstFormat, int dstRowPadBits, bool invertY=false)

static void	l8_to_rgb8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	l32f_to_rgb8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	rgb8_to_rgba8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	rgb8_to_bgr8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	rgb8_to_rgba32f (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	bgr8_to_rgb8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	bgr8_to_rgba8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	bgr8_to_rgba32f (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	rgba8_to_rgb8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	rgba8_to_bgr8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	rgba8_to_rgba32f (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	rgb32f_to_rgba32f (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	rgba32f_to_rgb8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	rgba32f_to_rgba8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	rgba32f_to_bgr8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	rgba32f_to_rgb32f (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static uint32	blendPixels (uint32 pixel1, uint32 pixel2)

static void	rgb8_to_yuv420p (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	rgb8_to_yuv422 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	rgb8_to_yuv444 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	yuv420p_to_rgb8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	yuv422_to_rgb8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	yuv444_to_rgb8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static unorm8	applyFilter (const unorm8 *I, int x, int y, int w, int h, const float filter[5][5])

static void	swapRedAndBlue (int N, Color3unorm8 *out)

static void	rgb8_to_bayer_rggb8 (const int w, const int h, const unorm8 src, unorm8 dst)

static void	rgb8_to_bayer_grbg8 (const int w, const int h, const unorm8 src, unorm8 dst)

static void	rgb8_to_bayer_bggr8 (const int w, const int h, const unorm8 src, unorm8 dst)

static void	rgb8_to_bayer_gbrg8 (const int w, const int h, const unorm8 src, unorm8 dst)

static void	rgba32f_to_bayer_rggb8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	rgba32f_to_bayer_gbrg8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	rgba32f_to_bayer_grbg8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	rgba32f_to_bayer_bggr8 (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	bayer_rggb8_to_rgb8_mhc (int w, int h, const unorm8 in, unorm8 _out)

static void	bayer_gbrg8_to_rgb8_mhc (int w, int h, const unorm8 in, unorm8 _out)

static void	bayer_grbg8_to_rgb8_mhc (int w, int h, const unorm8 in, unorm8 _out)

static void	bayer_bggr8_to_rgb8_mhc (int w, int h, const unorm8 in, unorm8 _out)

static void	bayer_rggb8_to_rgba32f (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	bayer_gbrg8_to_rgba32f (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	bayer_grbg8_to_rgba32f (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static void	bayer_bggr8_to_rgba32f (const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat srcFormat, int srcRowPadBits, const Array< void > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

static double	pythag (double a, double b)

Matrix3	operator* (double fScalar, const Matrix3 &rkMatrix)

Matrix3	operator* (float fScalar, const Matrix3 &rkMatrix)

Matrix3	operator* (int fScalar, const Matrix3 &rkMatrix)

static void	assignEdgeIndex (MeshAlg::Face &face, int e)

static void	logSocketInfo (const SOCKET &sock)

static int	selectOneReadSocket (const SOCKET &sock)

static bool	readWaiting (const SOCKET &sock)

static int	selectOneWriteSocket (const SOCKET &sock)

const char *	errnoToString ()

static void	increaseBufferSize (SOCKET sock)

static int	textPrompt (const char windowTitle, const char prompt, const char **choice, int numChoices)

static bool	iswspace (int ch)

static bool	checkForCPUID ()

static void	getG3DVersion (std::string &s)

static G3DEndian	checkEndian ()

static std::string	computeAppName (const std::string &start)

void	initMem ()

static void	var (TextOutput &t, const std::string &name, const std::string &val)

static void	var (TextOutput &t, const std::string &name, const bool val)

static void	var (TextOutput &t, const std::string &name, const int val)

static void	toUpper (Set< std::string > &set)

static const char *	tokenTypeToString (Token::Type t)

static std::string	escape (const std::string &string)

static void	addAndCarry (const uint64 &_a, const uint64 &_b, uint64 &carry, uint64 &result)

void	multiplyAndCarry (const uint64 &_a, const uint64 &_b, uint64 &carry, uint64 &result)

double	frand ()

static bool	atClose (TextInput &t, const std::string name)

Variables
const bool	DONT_SHRINK_UNDERLYING_ARRAY = false

const int	SORT_INCREASING = 1

const int	SORT_DECREASING = -1

const char *	NEWLINE = "\n"

	unorm16

	unorm8

	Vector2int16

G3D::int16	x

G3D::int16	y

	Vector2int32

	Vector2unorm16

	Vector3int16

G3D::int16	z

	Vector3int32

static FileSystem *	common = NULL

static Set< std::string >	_filesUsed

static const std::string	nameArray [ImageFormat::CODE_NUM]

static const bool	OPAQUE_FORMAT = true

static const bool	CLEAR_FORMAT = false

static const bool	COMP_FORMAT = true

static const bool	UNCOMP_FORMAT = false

static const int	NUM_CONVERT_IMAGE_FORMATS = 5

static const ConvertAttributes	sConvertMappings []

static const float	G_GRR [5][5]

static const float	G_BGB [5][5]

static const float	R_GRG [5][5]

static const float	R_BGG [5][5]

static const float	R_BGB [5][5]

static Table< std::string, std::string >	lastFound

static Array< std::string >	directoryArray

static BufferPool *	bufferpool = NULL

Detailed Description

This is the main Class to manage loading and unloading of maps, line of sight, height calculation and so on. For each map or map tile to load it reads a directory file that contains the ModelContainer files used by this map or map tile. Each global map or instance has its own dynamic BSP-Tree. The loaded ModelContainers are included in one of these BSP-Trees. Additionally a table to match map ids and map names is used.

Typedef Documentation

typedef Rect2D G3D::AABox2D

typedef bool(* G3D::AssertionHook)(const char *_expression, const std::string &message, const char *filename, int lineNumber, bool useGuiPrompt)

typedef Color3 G3D::Biradiance3

Radiance * measure(Solid Angle) between two points, measured at the receiver orthogonal to the axis between them; W/m^2

typedef CoordinateFrame G3D::CFrame

typedef AreaMemoryManager G3D::CoherentAllocator

typedef void(* G3D::ConsolePrintHook)(const std::string &)

typedef void(* G3D::ConvertFunc)(const Array< const void * > &srcBytes, int srcWidth, int srcHeight, const ImageFormat *srcFormat, int srcRowPadBits, const Array< void * > &dstBytes, const ImageFormat *dstFormat, int dstRowPadBits, bool invertY, ImageFormat::BayerAlgorithm bayerAlg)

typedef Color3 G3D::Energy3

Force * distance; J

typedef float G3D::float32

typedef double G3D::float64

typedef double G3D::GameTime

Deprecated:: use SimTime

typedef shared_ptr<class GThread> G3D::GThreadRef

typedef shared_ptr<class Image1> G3D::Image1Ref

typedef shared_ptr<class Image3> G3D::Image3Ref

typedef shared_ptr<class Image4> G3D::Image4Ref

typedef int16_t G3D::int16

typedef int32_t G3D::int32

typedef int64_t G3D::int64

typedef int8_t G3D::int8

typedef Color3 G3D::Irradiance3

Incident power per area; W/m^2

typedef shared_ptr<class LightweightConduit> G3D::LightweightConduitRef

typedef unsigned char G3D::md5_byte_t

typedef struct G3D::md5_state_s G3D::md5_state_t

typedef unsigned int G3D::md5_word_t

typedef shared_ptr<class NetListener> G3D::NetListenerRef

typedef PhysicsFrame G3D::PFrame

typedef Vector2 G3D::Point2

typedef Vector2int16 G3D::Point2int16

typedef Vector2int32 G3D::Point2int32

typedef Vector2unorm16 G3D::Point2unorm16

typedef Vector3 G3D::Point3

Points are technically distinct mathematical entities from vectors. Actually distinguishing them at the class level tends to add lots of boilerplate (e.g., (P - Point3::zero()).direction() vs. P.direction()), so many programmers prefer use a single class, as GLSL does.

G3D provides this typedef as a way of documenting arguments that are locations in space and not directions. Beware that points and vectors are interchangable from the compiler's point of view, and that the programmer must track which is really which.

typedef Vector3int16 G3D::Point3int16

typedef Vector3int32 G3D::Point3int32

typedef Color3 G3D::Power3

Energy per time; W

typedef Color3 G3D::Radiance3

Power per (measure(SolidAngle) * measure(Area)); W / (m^2 sr)

typedef Color3 G3D::Radiosity3

Power per area; J / m^2

typedef double G3D::RealTime

Actual wall clock time in seconds (Unix time).

typedef shared_ptr<class ReliableConduit> G3D::ReliableConduitRef

typedef double G3D::SimTime

Time, in seconds.

typedef Stopwatch G3D::StopWatch

Because it is hard to remember the proper capitalization.

typedef ImageFormat G3D::TextureFormat

typedef uint16_t G3D::uint16

typedef uint32_t G3D::uint32

typedef uint64_t G3D::uint64

typedef uint8_t G3D::uint8

Enumeration Type Documentation

anonymous enum

Deprecated:

Enumerator
SECOND
MINUTE
HOUR
DAY
SUNRISE
SUNSET
MIDNIGHT
METER
KILOMETER

32 {SECOND=1, MINUTE=60, HOUR = 60*60, DAY=24*60*60, SUNRISE=24*60*60/4, SUNSET=24*60*60*3/4, MIDNIGHT=0, METER=1, KILOMETER=1000};

Definition: G3DGameUnits.h:32

Definition: G3DGameUnits.h:32

Definition: Common.h:98

Definition: G3DGameUnits.h:32

Definition: Common.h:97

Definition: G3DGameUnits.h:32

Definition: Common.h:99

Definition: G3DGameUnits.h:32

Definition: G3DGameUnits.h:32

Enumerator
AM
PM

29 {AM, PM};

Definition: G3DGameUnits.h:29

Definition: G3DGameUnits.h:29

enum G3D::BinaryFormat

Some values like float16 and int128 have no current CPU data structure that implements them but are useful for file formats and for GPUs.

CHUNK_BINFMT data follows the protocol.

Enumerator
FIRST_BINFMT
BOOL8_BINFMT
UINT8_BINFMT
INT8_BINFMT
UINT16_BINFMT
INT16_BINFMT
UINT32_BINFMT
INT32_BINFMT
UINT64_BINFMT
INT64_BINFMT
UINT128_BINFMT
INT128_BINFMT
FLOAT16_BINFMT
FLOAT32_BINFMT
FLOAT64_BINFMT
VECTOR2_BINFMT
VECTOR2INT16_BINFMT
VECTOR3_BINFMT
VECTOR3INT16_BINFMT
VECTOR4_BINFMT
VECTOR4INT16_BINFMT
COLOR3_BINFMT
COLOR3UINT8_BINFMT
COLOR3INT16_BINFMT
COLOR4_BINFMT
COLOR4UINT8_BINFMT
COLOR4INT16_BINFMT
STRING_BINFMT
STRINGEVEN_BINFMT
STRING8_BINFMT
STRING16_BINFMT
STRING32_BINFMT
CHUNK_BINFMT
CUSTOM_BINFMT
LAST_BINFMT

                   {
     FIRST_BINFMT = 1000,
 
     BOOL8_BINFMT,
     UINT8_BINFMT, INT8_BINFMT, UINT16_BINFMT, INT16_BINFMT, UINT32_BINFMT, INT32_BINFMT, UINT64_BINFMT, INT64_BINFMT, UINT128_BINFMT, INT128_BINFMT,
     FLOAT16_BINFMT, FLOAT32_BINFMT, FLOAT64_BINFMT,
     VECTOR2_BINFMT, VECTOR2INT16_BINFMT,
     VECTOR3_BINFMT, VECTOR3INT16_BINFMT,
     VECTOR4_BINFMT, VECTOR4INT16_BINFMT,
     COLOR3_BINFMT, COLOR3UINT8_BINFMT, COLOR3INT16_BINFMT,
     COLOR4_BINFMT, COLOR4UINT8_BINFMT, COLOR4INT16_BINFMT,
     STRING_BINFMT, STRINGEVEN_BINFMT, STRING8_BINFMT, STRING16_BINFMT, STRING32_BINFMT,
 
     CHUNK_BINFMT,
 
     CUSTOM_BINFMT,
 
     LAST_BINFMT
 };

enum G3D::G3DEndian

The order in which the bytes of an integer are stored on a machine.

Intel/AMD chips tend to be G3D_LITTLE_ENDIAN, Mac PPC's and Suns are G3D_BIG_ENDIAN. However, this is primarily used to specify the byte order of file formats, which are fixed.

Enumerator
G3D_BIG_ENDIAN
G3D_LITTLE_ENDIAN

                {
     G3D_BIG_ENDIAN, 
     G3D_LITTLE_ENDIAN
 };

enum G3D::SpawnBehavior

Enumerator
USE_NEW_THREAD
USE_CURRENT_THREAD

4 {USE_NEW_THREAD, USE_CURRENT_THREAD};

G3D::USE_NEW_THREAD

Definition: SpawnBehavior.h:4

G3D::USE_CURRENT_THREAD

Definition: SpawnBehavior.h:4

Function Documentation

template<class Class >

void G3D::_internal_runConcurrently2DHelper	(	const Vector2int32 &	start,
		const Vector2int32 &	upTo,
		Class *	object,
		void(Class::*)(int x, int y)	method1,
		void(Class::*)(int x, int y, int threadID)	method2,
		int	maxThreads
	)

                                      {
         
         // Create a group of threads
         if (maxThreads == GThread::NUM_CORES) {
             maxThreads = GThread::numCores();
         }
 
         const int numRows = upTo.y - start.y;
         const int numThreads = min(maxThreads, numRows);
         const Vector2int32 stride(1, numThreads);
         ThreadSet threadSet;
         for (int t = 0; t < numThreads; ++t) {
             threadSet.insert(shared_ptr<_internalGThreadWorker<Class> >(new _internalGThreadWorker<Class>(t, start + Vector2int32(0, t), upTo, object, method1, method2, stride)));
         }
 
         // Run the threads, reusing the current thread and blocking until
         // all complete
         threadSet.start(USE_CURRENT_THREAD);
         threadSet.waitForCompletion();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector2 G3D::abs ( const Vector2 & v )

inline

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

Vector3 G3D::abs ( const Vector3 & v )

inline

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

Vector4 G3D::abs ( const Vector4 & v )

inline

                                      {
     return Vector4(::fabsf(v.x), ::fabsf(v.y), ::fabsf(v.z), ::fabsf(v.w));
 }

double G3D::abs ( double fValue )

inline

                                   {
     return double(::fabs(fValue));
 }

Here is the caller graph for this function:

double G3D::aCos ( double fValue )

inline

                                    {
     if ( -1.0 < fValue ) {
         if ( fValue < 1.0 )
             return double(::acos(fValue));
         else
             return 0.0;
     } else {
         return pi();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::acos ( float fValue )

inline

                                  {
     if ( -1.0f < fValue ) {
         if ( fValue < 1.0f ) {
             return ::acos(fValue);
         } else {
             return 0.0f;
         }
     } else {
         return pif();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void G3D::addAndCarry	(	const uint64 &	_a,
		const uint64 &	_b,
		uint64 &	carry,
		uint64 &	result
	)

static

Adds two 64-bit integers, placing the result and the overflow into 64-bit integers.

                                                                                            {
         
     // Break each number into 4 32-bit chunks. Since we are using uints, right-shifting will fill with zeros.
     // This eliminates the need to and with 0xFFFFFFFF.
     uint32 a [2] = {static_cast<uint32>(_a & 0xFFFFFFFF), static_cast<uint32>(_a >> 32)};
     uint32 b [2] = {static_cast<uint32>(_b & 0xFFFFFFFF), static_cast<uint32>(_b >> 32)};
 
     uint64 tmp = uint64(a[0]) + b[0];
 
     result = tmp & 0xFFFFFFFF;
     uint32 c = tmp >> 32;
 
     tmp = uint64(c) + a[1] + b[1];
     result += tmp << 32;
     carry = (tmp >> 32);
 }

Here is the caller graph for this function:

bool G3D::all ( const Vector2 & v )

inline

                                   {
     return (v.x != 0) && (v.y != 0);
 }

bool G3D::all ( const Vector3 & v )

inline

                                   {
     return (v.x != 0) && (v.y != 0) && (v.z != 0);
 }

bool G3D::all ( const Vector4 & v )

inline

                                   {
     return (v.x != 0) && (v.y != 0) && (v.z != 0) && (v.w != 0);
 }

bool G3D::all ( float x )

inline

Returns true if x is not exactly equal to 0.0f.

                          {
     return x != 0;
 }

Here is the caller graph for this function:

bool G3D::any ( const Vector2 & v )

inline

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

bool G3D::any ( const Vector3 & v )

inline

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

bool G3D::any ( const Vector4 & v )

inline

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

bool G3D::any ( float x )

inline

Returns true if x is not exactly equal to 0.0f.

                          {
     return x != 0;
 }

Here is the caller graph for this function:

static unorm8 G3D::applyFilter	(	const unorm8 *	I,
		int	x,
		int	y,
		int	w,
		int	h,
		const float	filter[5][5]
	)

static

Applies a 5x5 filter to monochrome image I (wrapping at the boundaries)

                                            {
     
     debugAssert(isEven(w));
     debugAssert(isEven(h));
     
     float sum = 0.0f;
     float denom = 0.0f;
     
     for (int dy = 0; dy < 5; ++dy) {
     int offset = ((y + dy + h - 2) % h) * w;
     
     for (int dx = 0; dx < 5; ++dx) {
         float f = filter[dy][dx];
         sum += f * (float)I[((x + dx + w - 2) % w) + offset];
         denom += f;
     }
     }
     
     return unorm8(sum / denom);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double G3D::aSin ( double fValue )

inline

                                    {
     if ( -1.0 < fValue ) {
         if ( fValue < 1.0 ) {
             return double(::asin(fValue));
         } else {
             return -halfPi();
         }
     } else {
         return halfPi();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

AssertionHook G3D::assertionHook ( )

                               {
     return     G3D::_internal::_debugHook;
 }

static void G3D::assignEdgeIndex	(	MeshAlg::Face &	face,
		int	e
	)

static

Assigns the edge index into the next unassigned edge index. The edge index may be negative, indicating a reverse edge.

                                                       {
     for (int i = 0; i < 3; ++i) {
         if (face.edgeIndex[i] == MeshAlg::Face::NONE) {
             face.edgeIndex[i] = e;
             return;
         }
     }
 
     debugAssertM(false, "Face has already been assigned 3 edges");
 }

Here is the caller graph for this function:

double G3D::aTan ( double fValue )

inline

                                    {
     return double(::atan(fValue));
 }

double G3D::aTan2	(	double	fY,
		double	fX
	)

inline

                                            {
     return double(::atan2(fY, fX));
 }

Here is the caller graph for this function:

static bool G3D::atClose	(	TextInput &	t,
		const std::string	name
	)

static

True if the next token begins the close tag

                                                         {
     if ((t.peek().type() == Token::SYMBOL) && (t.peek().string() == "<")) {
         // Need to keep looking ahead
         Token p0 = t.read();
         if ((t.peek().type() == Token::SYMBOL) && (t.peek().string() == "/")) {
             // Check the name on the close tag.  It *must* match if
             // this is a well-formed document, but there might be a
             // tag error.
             Token p1 = t.read();
             Token p2 = t.peek();
             std::string s = p2.string();
             debugAssertM(beginsWith(name, s), "Mismatched close tag");
 
             // Put the tokens back
             t.push(p1);
             t.push(p0);
             return true;
         } else {
             // Put the read token back
             t.push(p0);
             return false;
         }
     } else {
         return false;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void G3D::bayer_bggr8_to_rgb8_mhc	(	int	w,
		int	h,
		const unorm8 *	in,
		unorm8 *	_out
	)

static

                                                     {
     // Run the equivalent function for red
     bayer_rggb8_to_rgb8_mhc(w, h, in, _out);
 
     // Now swap red and blue
     swapRedAndBlue(w * h, (Color3unorm8*)_out);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void G3D::bayer_bggr8_to_rgba32f	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                       {
     Array<void*> tmp;
     tmp.append(System::malloc(srcWidth * srcHeight * sizeof(Color3unorm8)));
 
     bayer_bggr8_to_rgb8_mhc(srcWidth, srcHeight, static_cast<const unorm8*>(srcBytes[0]), static_cast<unorm8*>(tmp[0]));
     rgb8_to_rgba32f(reinterpret_cast<Array<const void*>&>(tmp), srcWidth, srcHeight, ImageFormat::RGB8(), 0, dstBytes, ImageFormat::RGBA32F(), 0, invertY, bayerAlg);
 
     System::free(tmp[0]);
 }

Here is the call graph for this function:

static void G3D::bayer_gbrg8_to_rgb8_mhc	(	int	w,
		int	h,
		const unorm8 *	in,
		unorm8 *	_out
	)

static

                                                     {
 
     debugAssert(in != _out);
 
     Color3unorm8* out = (Color3unorm8*)_out;
 
     for (int y = 0; y < h; ++y) {
 
     // Row beginning in the input array.
     int offset = y * w;
 
     // GB row
     for (int x = 0; x < w; ++x, ++out) {
         // G pixel
         {
         out->r = applyFilter(in, x, y, w, h, R_BGG);
         out->g = in[x + offset];
         out->b = applyFilter(in, x, y, w, h, B_BGG);
         }
         ++x; ++out;
 
         // B pixel
         {
         out->r = applyFilter(in, x, y, w, h, R_BGB);
         out->g = applyFilter(in, x, y, w, h, G_BGB);
         out->b = in[x + offset];
         }
     }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void G3D::bayer_gbrg8_to_rgba32f	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                       {
     Array<void*> tmp;
     tmp.append(System::malloc(srcWidth * srcHeight * sizeof(Color3unorm8)));
 
     bayer_grbg8_to_rgb8_mhc(srcWidth, srcHeight, static_cast<const unorm8*>(srcBytes[0]), static_cast<unorm8*>(tmp[0]));
     rgb8_to_rgba32f(reinterpret_cast<Array<const void*>&>(tmp), srcWidth, srcHeight, ImageFormat::RGB8(), 0, dstBytes, ImageFormat::RGBA32F(), 0, invertY, bayerAlg);
 
     System::free(tmp[0]);
 }

Here is the call graph for this function:

static void G3D::bayer_grbg8_to_rgb8_mhc	(	int	w,
		int	h,
		const unorm8 *	in,
		unorm8 *	_out
	)

static

                                                     {
     // Run the equivalent function for red
     bayer_gbrg8_to_rgb8_mhc(w, h, in, _out);
 
     // Now swap red and blue
     swapRedAndBlue(w * h, (Color3unorm8*)_out);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void G3D::bayer_grbg8_to_rgba32f	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                       {
     Array<void*> tmp;
     tmp.append(System::malloc(srcWidth * srcHeight * sizeof(Color3unorm8)));
 
     bayer_gbrg8_to_rgb8_mhc(srcWidth, srcHeight, static_cast<const unorm8*>(srcBytes[0]), static_cast<unorm8*>(tmp[0]));
     rgb8_to_rgba32f(reinterpret_cast<Array<const void*>&>(tmp), srcWidth, srcHeight, ImageFormat::RGB8(), 0, dstBytes, ImageFormat::RGBA32F(), 0, invertY, bayerAlg);
 
     System::free(tmp[0]);
 }

Here is the call graph for this function:

static void G3D::bayer_rggb8_to_rgb8_mhc	(	int	w,
		int	h,
		const unorm8 *	in,
		unorm8 *	_out
	)

static

                                                     {
     debugAssert(in != _out);
 
     Color3unorm8* out = (Color3unorm8*)_out;
 
     for (int y = 0; y < h; ++y) {
 
     // Row beginning in the input array.
     int offset = y * w;
 
     // RG row
     for (int x = 0; x < w; ++x, ++out) {
         // R pixel
         {
         out->r = in[x + offset];
         out->g = applyFilter(in, x, y, w, h, G_GRR);
         out->b = applyFilter(in, x, y, w, h, B_GRR);
         }
         ++x; ++out;
 
         // G pixel
         {
         out->r = applyFilter(in, x, y, w, h, R_GRG);
         out->g = in[x + offset];
         out->b = applyFilter(in, x, y, w, h, B_GRG);
         }
     }
 
     ++y;
     offset += w;
 
     // GB row
     for (int x = 0; x < w; ++x, ++out) {
         // G pixel
         {
         out->r = applyFilter(in, x, y, w, h, R_BGG);
         out->g = in[x + offset];
         out->b = applyFilter(in, x, y, w, h, B_BGG);
         }
         ++x; ++out;
 
         // B pixel
         {
         out->r = applyFilter(in, x, y, w, h, R_BGB);
         out->g = applyFilter(in, x, y, w, h, G_BGB);
         out->b = in[x + offset];
         }
     }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void G3D::bayer_rggb8_to_rgba32f	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                       {
     Array<void*> tmp;
     tmp.append(System::malloc(srcWidth * srcHeight * sizeof(Color3unorm8)));
 
     bayer_rggb8_to_rgb8_mhc(srcWidth, srcHeight, static_cast<const unorm8*>(srcBytes[0]), static_cast<unorm8*>(tmp[0]));
     rgb8_to_rgba32f(reinterpret_cast<Array<const void*>&>(tmp), srcWidth, srcHeight, ImageFormat::RGB8(), 0, dstBytes, ImageFormat::RGBA32F(), 0, invertY, bayerAlg);
 
     System::free(tmp[0]);
 }

Here is the call graph for this function:

bool G3D::beginsWith	(	const std::string &	test,
		const std::string &	pattern
	)

Returns true if the test string begins with the pattern string.

                               {
 
     if (test.size() >= pattern.size()) {
         for (int i = 0; i < (int)pattern.size(); ++i) {
             if (pattern[i] != test[i]) {
                 return false;
             }
         }
         return true;
     } else {
         return false;
     }
 }

Here is the caller graph for this function:

static void G3D::bgr8_to_rgb8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                             {
     unorm8* dst = static_cast<unorm8*>(dstBytes[0]);
     const unorm8* src = static_cast<const unorm8*>(srcBytes[0]);
     for (int y = 0; y < srcHeight; ++y) {
         for (int x = 0; x < srcWidth; ++x) {
             int i = (invertY) ? ((srcHeight-1-y) * srcWidth +x) : (y * srcWidth + x);
             int i3 = i * 3;
             dst[i3 + 0] = src[i3 + 2];
             dst[i3 + 1] = src[i3 + 1];
             dst[i3 + 2] = src[i3 + 0];
         }
     }
 }

static void G3D::bgr8_to_rgba32f	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                {
     debugAssertM(srcRowPadBits % 8 == 0, "Source row padding must be a multiple of 8 bits for this format");
 
     int dstIndex = 0;
     int srcByteOffset = 0;
     int srcRowPadBytes = srcRowPadBits / 8;
     Color4* dst = static_cast<Color4*>(dstBytes[0]);
     const unorm8* src = static_cast<const unorm8*>(srcBytes[0]);
 
     for (int y = 0; y < srcHeight; ++y) {
         if (invertY) {
             dstIndex = srcWidth * (srcHeight - 1 - y);
         }
 
         for (int x = 0; x < srcWidth; ++x, ++dstIndex, srcByteOffset += 3) {
             const Color3unorm8& s = *reinterpret_cast<const Color3unorm8*>(src + srcByteOffset);
             dst[dstIndex] = Color4(Color3(s).bgr(), 1.0f);
         }
         srcByteOffset += srcRowPadBytes;
     }
 }

static void G3D::bgr8_to_rgba8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                              {
     unorm8* dst = static_cast<unorm8*>(dstBytes[0]);
     const unorm8* src = static_cast<const unorm8*>(srcBytes[0]);
     for (int y = 0; y < srcHeight; ++y) {
         for (int x = 0; x < srcWidth; ++x) {
             int i = (invertY) ? ((srcHeight-1-y) * srcWidth +x) : (y * srcWidth + x);
             int i3 = i * 3;
             int i4 = i3 + i; 
 
             dst[i4 + 0] = src[i3 + 2]; 
             dst[i4 + 1] = src[i3 + 1]; 
             dst[i4 + 2] = src[i3 + 0]; 
             dst[i4 + 3] = unorm8::one(); 
         }
     }
 }

Here is the call graph for this function:

uint8 G3D::bits ( ) const

Returns the underlying bits in this representation. Equivalent to:

uint16 i = reinterpret_cast<const uint16&>(u);

uint8 i = reinterpret_cast<const uint8&>(u);

                         {
         return m_bits;
     }

Here is the caller graph for this function:

static uint32 G3D::blendPixels	(	uint32	pixel1,
		uint32	pixel2
	)

static

                                                         {
     static const uint32 rbMask = 0x00FF00FF;
     static const uint32 agMask = 0xFF00FF00;
 
     // Compute two color channels at a time.  Use >> 1 for fast division by two
     // Using alternating color channels prevents overflow
     const uint32 rb = ((pixel1 & rbMask) + (pixel2 & rbMask)) >> 1;
 
     // Shift first to avoid overflow in alpha channel
     const uint32 ag = (((pixel1 & agMask) >> 1) + ((pixel2 & agMask) >> 1));
 
     return ((rb & rbMask) | (ag & agMask));
 }

Here is the caller graph for this function:

int32 G3D::byteSize ( BinaryFormat f )

Returns -1 if the format is custom, otherwise the byte size of a single element in this format.

                                {
     switch (f) {
     case BOOL8_BINFMT:
     case UINT8_BINFMT:
     case INT8_BINFMT:
         return 1;
 
     case UINT16_BINFMT:
     case INT16_BINFMT:
         return 2;
 
     case FLOAT16_BINFMT:
         return 2;
 
     case UINT32_BINFMT:
     case INT32_BINFMT:
     case FLOAT32_BINFMT:
         return 4;
 
     case FLOAT64_BINFMT:
     case UINT64_BINFMT:
     case INT64_BINFMT:
         return 8;
 
     case INT128_BINFMT:
     case UINT128_BINFMT:
         return 16;
 
     case VECTOR2_BINFMT:
         return 2 * 4;
 
     case VECTOR2INT16_BINFMT:
         return 2 * 2;
 
     case VECTOR3_BINFMT:
         return 3 * 4;
 
     case VECTOR3INT16_BINFMT:
         return 3 * 2;
 
     case VECTOR4_BINFMT:
         return 4 * 4;
 
     case VECTOR4INT16_BINFMT:
         return 4 * 4;
 
     case COLOR3_BINFMT:
         return 3 * 4;
 
     case COLOR3UINT8_BINFMT:
         return 3 * 1;
 
     case COLOR3INT16_BINFMT:
         return 3 * 2;
 
     case COLOR4_BINFMT:
         return 4 * 4;
 
     case COLOR4UINT8_BINFMT:
         return 4 * 1;
 
     case COLOR4INT16_BINFMT:
         return 4 * 2;
 
     default:
         return -1;
     }
 }

Vector3int16 Vector3int16::ceil ( const Vector3 & v )

static

                                                 {
     return Vector3int16(iCeil(v.x), iCeil(v.y), iCeil(v.z));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int G3D::ceilPow2 ( unsigned int in )

inline

Return the next power of 2 higher than the input If the input is already a power of 2, the output will be the same as the input.

                                      {
     in -= 1;
 
     in |= in >> 16;
     in |= in >> 8;
     in |= in >> 4;
     in |= in >> 2;
     in |= in >> 1;
 
     return in + 1;
 }

static G3DEndian G3D::checkEndian ( )

static

Called from init

                                {
     int32 a = 1;
     if (*(uint8*)&a == 1) {
         return G3D_LITTLE_ENDIAN;
     } else {
         return G3D_BIG_ENDIAN;
     }
 }

Here is the caller graph for this function:

static bool G3D::checkForCPUID ( )

static

Checks if the CPUID command is available on the processor (called from init)

                             {
     // all known supported architectures have cpuid
     // add cases for incompatible architectures if they are added
     // e.g., if we ever support __powerpc__ being defined again
 
     return true;
 }

Here is the caller graph for this function:

Vector2int32 G3D::clamp	(	const Vector2int32 &	lo,
		const Vector2int32 &	hi
	)

Vector2 G3D::clamp	(	const Vector2 &	v,
		const Vector2 &	a,
		const Vector2 &	b
	)

inline

                                                                            {
     return v.clamp(a, b);
 }

Here is the call graph for this function:

Vector3 G3D::clamp	(	const Vector3 &	v,
		const Vector3 &	a,
		const Vector3 &	b
	)

inline

                                                                            {
     return v.clamp(a, b);
 }

Here is the call graph for this function:

Vector2int16 G3D::clamp	(	const Vector2int16 &	lo,
		const Vector2int16 &	hi
	)

Vector4 G3D::clamp	(	const Vector4 &	v,
		const Vector4 &	a,
		const Vector4 &	b
	)

inline

                                                                            {
     return v.clamp(a, b);
 }

Here is the call graph for this function:

double G3D::clamp	(	double	val,
		double	low,
		double	hi
	)

inline

                                                        {
     debugAssert(low <= hi);
     if (val <= low) {
         return low;
     } else if (val >= hi) {
         return hi;
     } else {
         return val;
     }
 }

Here is the caller graph for this function:

float G3D::clamp	(	float	val,
		float	low,
		float	hi
	)

inline

                                                    {
     debugAssert(low <= hi);
     if (val <= low) {
         return low;
     } else if (val >= hi) {
         return hi;
     } else {
         return val;
     }
 }

static std::string G3D::computeAppName ( const std::string & start )

static

Removes the 'd' that icompile / Morgan's VC convention appends.

                                                         {
     if (start.size() < 2) {
         return start;
     }
 
     if (start[start.size() - 1] == 'd') {
         // Maybe remove the 'd'; see if ../ or ../../ has the same name
         char tmp[1024];
         (void)getcwd(tmp, sizeof(tmp));
         std::string drive, base, ext;
         Array<std::string> path;
         parseFilename(tmp, drive, path, base, ext);
 
         std::string shortName = start.substr(0, start.size() - 1);
 
         if ((path.size() > 1) && (toLower(path.last()) == toLower(shortName))) {
             return shortName;
         }
 
         if ((path.size() > 2) && (toLower(path[path.size() - 2]) == toLower(shortName))) {
             return shortName;
         }
     }
 
     return start;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::consolePrint ( const std::string & s )

                                            {
     FILE* L = Log::common()->getFile();
     fprintf(L, "%s", s.c_str());
 
     if (consolePrintHook()) {
         consolePrintHook()(s);
     }
 
     fflush(L);
     return s;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string __cdecl G3D::consolePrintf ( const char * fmt... )

Sends output to the log and to the last GConsole instantiated.

Guarantees that the output has been flushed by the time the routine returns.

See also: G3D::logPrintf, G3D::screenPrintf

Returns: The string that was printed

                                                      {
     va_list argList;
     va_start(argList, fmt);
     std::string s = G3D::vformat(fmt, argList);
     va_end(argList);
 
     return consolePrint(s);
 }

Here is the call graph for this function:

ConsolePrintHook G3D::consolePrintHook ( )

                                     {
     return G3D::_internal::_consolePrintHook;
 }

Here is the caller graph for this function:

template<class T >

bool G3D::contains	(	const T *	array,
		int	len,
		const T &	e
	)

Array::contains for C-arrays

                                                                      {
     for (int i = len - 1; i >= 0; --i) {
         if (array[i] == e) {
             return true;
         }
     }
     return false;
 }

Here is the caller graph for this function:

bool G3D::conversionAvailable	(	const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY = `false`
	)

                                                                                                                                                  {
     bool conversionAvailable = false;
 
     // check if a conversion is available
     if ( (srcFormat->code == dstFormat->code) && (srcRowPadBits == dstRowPadBits) && !invertY) {
         conversionAvailable = true;
     } else {
         ConvertFunc directConverter = findConverter(srcFormat->code, dstFormat->code, srcRowPadBits > 0, dstRowPadBits > 0, invertY);
 
         conversionAvailable = (directConverter != NULL);
     }
 
     return conversionAvailable;
 }

Here is the call graph for this function:

void G3D::copyFile	(	const std::string &	source,
		const std::string &	dest
	)

                                     {
 
     #ifdef G3D_WINDOWS
         CopyFileA(source.c_str(), dest.c_str(), FALSE);
     #else
         // TODO: don't use BinaryInput and BinaryOutput
         // Read it all in, then dump it out
         BinaryInput  in(source, G3D_LITTLE_ENDIAN);
         BinaryOutput out(dest, G3D_LITTLE_ENDIAN);
         out.writeBytes(in.getCArray(), in.size());
         out.commit(false);
     #endif
 }

Here is the call graph for this function:

int G3D::countNewlines ( const std::string & s )

inline

Number of new lines in the given string

                                              {
     int c = 0;
     for (int i = 0; i < (int)s.size(); ++i) {
         if (s[i] == '\n') {
             ++c;
         }
     }
     return c;
 }

void G3D::createDirectory ( const std::string & dir )

Creates the directory (which may optionally end in a /) and any parents needed to reach it.

                            {
     
     if (dir == "") {
         return;
     }
 
     std::string d;
 
     // Add a trailing / if there isn't one.
     switch (dir[dir.size() - 1]) {
     case '/':
     case '\\':
         d = dir;
         break;
 
     default:
         d = dir + "/";
     }
 
     // If it already exists, do nothing
     if (FileSystem::exists(d.substr(0, d.size() - 1))) {
         return;
     }
 
     // Parse the name apart
     std::string root, base, ext;
     Array<std::string> path;
 
     std::string lead;
     parseFilename(d, root, path, base, ext);
     debugAssert(base == "");
     debugAssert(ext == "");
 
     // Begin with an extra period so "c:\" becomes "c:\.\" after
     // appending a path and "c:" becomes "c:.\", not root: "c:\"
     std::string p = root + ".";
 
     // Create any intermediate that doesn't exist
     for (int i = 0; i < path.size(); ++i) {
         p += "/" + path[i];
         if (! FileSystem::exists(p)) {
             // Windows only requires one argument to mkdir,
             // where as unix also requires the permissions.
 #           ifndef G3D_WINDOWS
                 mkdir(p.c_str(), 0777);
 #            else
                 _mkdir(p.c_str());
 #            endif
         }
     }
 }

Here is the call graph for this function:

FILE* G3D::createTempFile ( )

Returns a temporary file that is open for read/write access. This tries harder than the ANSI tmpfile, so it may succeed when that fails.

Vector3 G3D::cross	(	const Vector3 &	v1,
		const Vector3 &	v2
	)

inline

                                                            {
     return v1.cross(v2);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class YType >

YType G3D::cyclicCatmullRomSpline	(	double	t,
		const YType *	controlY,
		int	numPoints
	)

See also G3D::Spline

                             {
 
     debugAssert(numPoints >= 3);
 
     t = wrap(t, numPoints);
 
     // Find the indices of adjacent control points    
     int i = iFloor(t);
     
     // Compute the distance from the control point
     t = t - i;
 
     // Shift back one point for correct indexing
     i += numPoints - 1;
 
     // Pick up four control points
     const YType& P0 = controlY[(i + 0) % numPoints];
     const YType& P1 = controlY[(i + 1) % numPoints];
     const YType& P2 = controlY[(i + 2) % numPoints];
     const YType& P3 = controlY[(i + 3) % numPoints];
 
     return 0.5 * ((2 * P1) + 
                   (-P0 + P2) * t +
                   (2*P0 - 5*P1 + 4*P2 - P3) * t*t +
                   (-P0 + 3*P1- 3*P2 + P3) * t*t*t);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

template<class YType >

YType G3D::cyclicCatmullRomSpline	(	double	t,
		const Array< YType > &	controlY
	)

A cubic spline with regularly spaced control points. The spline interpolates the control points. The spline will wrap from the last point back to the first.

The t parameter is on the range [0, controlY.size()], where integers correspond to control points exactly.

See also G3D::Spline

[http://www.mvps.org/directx/articles/catmull/]

                                    {
 
     int numPoints = controlY.size();
     return cyclicCatmullRomSpline(t, controlY.getCArray(), numPoints);
 }

Here is the call graph for this function:

std::string __cdecl G3D::debugPrint ( const std::string & s )

                                                  {
 #   ifdef G3D_WINDOWS
         const int MAX_STRING_LEN = 1024;
     
         // Windows can't handle really long strings sent to
         // the console, so we break the string.
         if (s.size() < MAX_STRING_LEN) {
             OutputDebugStringA(s.c_str());
         } else {
             for (unsigned int i = 0; i < s.size(); i += MAX_STRING_LEN) {
                 std::string sub = s.substr(i, MAX_STRING_LEN);
                 OutputDebugStringA(sub.c_str());
             }
         }
 #    else
         fprintf(stderr, "%s", s.c_str());
         fflush(stderr);
 #    endif
 
      return s;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string __cdecl G3D::debugPrintf ( const char * fmt... )

Under visual studio, appears in the VS debug pane. On unix-based operating systems the output is sent to stderr.

Also sends output to the console (G3D::consolePrintf) if there is a consolePrintHook, and log (G3D::logPrintf), and flushes before returning.

Returns: The string that was printed

                                                    {
     va_list argList;
     va_start(argList, fmt);
     std::string s = G3D::vformat(fmt, argList);
     va_end(argList);
 
     return debugPrint(s);
 //    return debugPrint(consolePrint(s));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G3D::DECLARE_CONVERT_FUNC ( l8_to_rgb8 )

G3D::DECLARE_CONVERT_FUNC ( l32f_to_rgb8 )

G3D::DECLARE_CONVERT_FUNC ( rgb8_to_rgba8 )

G3D::DECLARE_CONVERT_FUNC ( rgb8_to_bgr8 )

G3D::DECLARE_CONVERT_FUNC ( rgb8_to_rgba32f )

G3D::DECLARE_CONVERT_FUNC ( bgr8_to_rgb8 )

G3D::DECLARE_CONVERT_FUNC ( bgr8_to_rgba8 )

G3D::DECLARE_CONVERT_FUNC ( bgr8_to_rgba32f )

G3D::DECLARE_CONVERT_FUNC ( rgba8_to_rgb8 )

G3D::DECLARE_CONVERT_FUNC ( rgba8_to_bgr8 )

G3D::DECLARE_CONVERT_FUNC ( rgba8_to_rgba32f )

G3D::DECLARE_CONVERT_FUNC ( rgb32f_to_rgba32f )

G3D::DECLARE_CONVERT_FUNC ( rgba32f_to_rgb8 )

G3D::DECLARE_CONVERT_FUNC ( rgba32f_to_rgba8 )

G3D::DECLARE_CONVERT_FUNC ( rgba32f_to_bgr8 )

G3D::DECLARE_CONVERT_FUNC ( rgba32f_to_rgb32f )

G3D::DECLARE_CONVERT_FUNC ( rgba32f_to_bayer_rggb8 )

G3D::DECLARE_CONVERT_FUNC ( rgba32f_to_bayer_gbrg8 )

G3D::DECLARE_CONVERT_FUNC ( rgba32f_to_bayer_grbg8 )

G3D::DECLARE_CONVERT_FUNC ( rgba32f_to_bayer_bggr8 )

G3D::DECLARE_CONVERT_FUNC ( bayer_rggb8_to_rgba32f )

G3D::DECLARE_CONVERT_FUNC ( bayer_gbrg8_to_rgba32f )

G3D::DECLARE_CONVERT_FUNC ( bayer_grbg8_to_rgba32f )

G3D::DECLARE_CONVERT_FUNC ( bayer_bggr8_to_rgba32f )

G3D::DECLARE_CONVERT_FUNC ( rgb8_to_yuv420p )

G3D::DECLARE_CONVERT_FUNC ( rgb8_to_yuv422 )

G3D::DECLARE_CONVERT_FUNC ( rgb8_to_yuv444 )

G3D::DECLARE_CONVERT_FUNC ( yuv420p_to_rgb8 )

G3D::DECLARE_CONVERT_FUNC ( yuv422_to_rgb8 )

G3D::DECLARE_CONVERT_FUNC ( yuv444_to_rgb8 )

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	L8	,
		1	,
		UNCOMP_FORMAT	,
		GL_LUMINANCE8	,
		GL_LUMINANCE	,
		8	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		8	,
		8	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		CODE_L8	,
		COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	L16	,
		1	,
		UNCOMP_FORMAT	,
		GL_LUMINANCE16	,
		GL_LUMINANCE	,
		16	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		16	,
		16	,
		GL_UNSIGNED_SHORT	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		CODE_L16	,
		COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	L16F	,
		1	,
		UNCOMP_FORMAT	,
		GL_LUMINANCE16F_ARB	,
		GL_LUMINANCE	,
		16	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		16	,
		16	,
		GL_HALF_FLOAT	,
		OPAQUE_FORMAT	,
		FLOATING_POINT_FORMAT	,
		CODE_L16F	,
		COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	L32F	,
		1	,
		UNCOMP_FORMAT	,
		GL_LUMINANCE32F_ARB	,
		GL_LUMINANCE	,
		32	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		32	,
		32	,
		GL_FLOAT	,
		OPAQUE_FORMAT	,
		FLOATING_POINT_FORMAT	,
		CODE_L32F	,
		COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	A8	,
		1	,
		UNCOMP_FORMAT	,
		GL_ALPHA8	,
		GL_ALPHA	,
		0	,
		8	,
		0	,
		0	,
		0	,
		0	,
		0	,
		8	,
		8	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		CODE_A8	,
		COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	A16	,
		1	,
		UNCOMP_FORMAT	,
		GL_ALPHA16	,
		GL_ALPHA	,
		0	,
		16	,
		0	,
		0	,
		0	,
		0	,
		0	,
		16	,
		16	,
		GL_UNSIGNED_SHORT	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		CODE_A16	,
		COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	A16F	,
		1	,
		UNCOMP_FORMAT	,
		GL_ALPHA16F_ARB	,
		GL_ALPHA	,
		0	,
		16	,
		0	,
		0	,
		0	,
		0	,
		0	,
		16	,
		16	,
		GL_HALF_FLOAT	,
		CLEAR_FORMAT	,
		FLOATING_POINT_FORMAT	,
		CODE_A16F	,
		COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	A32F	,
		1	,
		UNCOMP_FORMAT	,
		GL_ALPHA32F_ARB	,
		GL_ALPHA	,
		0	,
		32	,
		0	,
		0	,
		0	,
		0	,
		0	,
		32	,
		32	,
		GL_FLOAT	,
		CLEAR_FORMAT	,
		FLOATING_POINT_FORMAT	,
		CODE_A32F	,
		COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	LA4	,
		2	,
		UNCOMP_FORMAT	,
		GL_LUMINANCE4_ALPHA4	,
		GL_LUMINANCE_ALPHA	,
		4	,
		4	,
		0	,
		0	,
		0	,
		0	,
		0	,
		8	,
		8	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		CODE_LA4	,
		COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	LA8	,
		2	,
		UNCOMP_FORMAT	,
		GL_LUMINANCE8_ALPHA8	,
		GL_LUMINANCE_ALPHA	,
		8	,
		8	,
		0	,
		0	,
		0	,
		0	,
		0	,
		16	,
		16	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		CODE_LA8	,
		COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	LA16	,
		2	,
		UNCOMP_FORMAT	,
		GL_LUMINANCE16_ALPHA16	,
		GL_LUMINANCE_ALPHA	,
		16	,
		16	,
		0	,
		0	,
		0	,
		0	,
		0	,
		16 *	2,
		16 *	2,
		GL_UNSIGNED_SHORT	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		CODE_LA16	,
		COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	LA16F	,
		2	,
		UNCOMP_FORMAT	,
		GL_LUMINANCE_ALPHA16F_ARB	,
		GL_LUMINANCE_ALPHA	,
		16	,
		16	,
		0	,
		0	,
		0	,
		0	,
		0	,
		16 *	2,
		16 *	2,
		GL_HALF_FLOAT	,
		CLEAR_FORMAT	,
		FLOATING_POINT_FORMAT	,
		ImageFormat::CODE_LA16F	,
		ImageFormat::COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	LA32F	,
		2	,
		UNCOMP_FORMAT	,
		GL_LUMINANCE_ALPHA32F_ARB	,
		GL_LUMINANCE_ALPHA	,
		32	,
		32	,
		0	,
		0	,
		0	,
		0	,
		0	,
		32 *	2,
		32 *	2,
		GL_FLOAT	,
		CLEAR_FORMAT	,
		FLOATING_POINT_FORMAT	,
		ImageFormat::CODE_LA32F	,
		ImageFormat::COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	BGR8	,
		3	,
		UNCOMP_FORMAT	,
		GL_RGB8	,
		GL_BGR	,
		0	,
		0	,
		8	,
		8	,
		8	,
		0	,
		0	,
		32	,
		24	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_BGR8	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	BGRA8	,
		4	,
		UNCOMP_FORMAT	,
		GL_RGBA8	,
		GL_BGRA	,
		0	,
		8	,
		8	,
		8	,
		8	,
		0	,
		0	,
		32	,
		32	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_BGRA8	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	R8	,
		1	,
		UNCOMP_FORMAT	,
		GL_R8	,
		GL_RED	,
		0	,
		0	,
		8	,
		0	,
		0	,
		0	,
		0	,
		8	,
		8	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_R8	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	R8I	,
		1	,
		UNCOMP_FORMAT	,
		GL_R8I	,
		GL_RED_INTEGER	,
		0	,
		0	,
		8	,
		0	,
		0	,
		0	,
		0	,
		8	,
		8	,
		GL_BYTE	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_R8I	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	R8UI	,
		1	,
		UNCOMP_FORMAT	,
		GL_R8UI	,
		GL_RED_INTEGER	,
		0	,
		0	,
		8	,
		0	,
		0	,
		0	,
		0	,
		8	,
		8	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_R8UI	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	R16	,
		1	,
		UNCOMP_FORMAT	,
		GL_R16	,
		GL_RED	,
		0	,
		0	,
		16	,
		0	,
		0	,
		0	,
		0	,
		16	,
		16	,
		GL_UNSIGNED_SHORT	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_R16	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	R16I	,
		1	,
		UNCOMP_FORMAT	,
		GL_R16I	,
		GL_RED_INTEGER	,
		0	,
		0	,
		16	,
		0	,
		0	,
		0	,
		0	,
		16	,
		16	,
		GL_SHORT	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_R16I	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	R16UI	,
		1	,
		UNCOMP_FORMAT	,
		GL_R16UI	,
		GL_RED_INTEGER	,
		0	,
		0	,
		16	,
		0	,
		0	,
		0	,
		0	,
		16	,
		16	,
		GL_UNSIGNED_SHORT	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_R16UI	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	R32I	,
		1	,
		UNCOMP_FORMAT	,
		GL_R32I	,
		GL_RED_INTEGER	,
		0	,
		0	,
		32	,
		0	,
		0	,
		0	,
		0	,
		32	,
		32	,
		GL_INT	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_R32I	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	R32UI	,
		1	,
		UNCOMP_FORMAT	,
		GL_R32UI	,
		GL_RED_INTEGER	,
		0	,
		0	,
		32	,
		0	,
		0	,
		0	,
		0	,
		32	,
		32	,
		GL_UNSIGNED_INT	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_R32UI	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RG8	,
		2	,
		UNCOMP_FORMAT	,
		GL_RG8	,
		GL_RG	,
		0	,
		0	,
		8	,
		8	,
		0	,
		0	,
		0	,
		16	,
		16	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_RG8	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RG8I	,
		2	,
		UNCOMP_FORMAT	,
		GL_RG8I	,
		GL_RG_INTEGER	,
		0	,
		0	,
		8	,
		8	,
		0	,
		0	,
		0	,
		16	,
		16	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_RG8I	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RG8UI	,
		2	,
		UNCOMP_FORMAT	,
		GL_RG8UI	,
		GL_RG_INTEGER	,
		0	,
		0	,
		8	,
		8	,
		0	,
		0	,
		0	,
		16	,
		16	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_RG8UI	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RG16	,
		2	,
		UNCOMP_FORMAT	,
		GL_RG16	,
		GL_RG	,
		0	,
		0	,
		16	,
		16	,
		0	,
		0	,
		0	,
		16 *	2,
		16 *	2,
		GL_UNSIGNED_SHORT	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_RG16	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RG16I	,
		2	,
		UNCOMP_FORMAT	,
		GL_RG16I	,
		GL_RG_INTEGER	,
		0	,
		0	,
		16	,
		16	,
		0	,
		0	,
		0	,
		16 *	2,
		16 *	2,
		GL_SHORT	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_RG16I	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RG16UI	,
		2	,
		UNCOMP_FORMAT	,
		GL_RG16UI	,
		GL_RG_INTEGER	,
		0	,
		0	,
		16	,
		16	,
		0	,
		0	,
		0	,
		16 *	2,
		16 *	2,
		GL_UNSIGNED_SHORT	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_RG16UI	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	R16F	,
		1	,
		UNCOMP_FORMAT	,
		GL_R16F	,
		GL_RED	,
		0	,
		0	,
		16	,
		0	,
		0	,
		0	,
		0	,
		16	,
		16	,
		GL_HALF_FLOAT	,
		OPAQUE_FORMAT	,
		FLOATING_POINT_FORMAT	,
		ImageFormat::CODE_R16F	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RG16F	,
		2	,
		UNCOMP_FORMAT	,
		GL_RG16F	,
		GL_RG	,
		0	,
		0	,
		16	,
		16	,
		0	,
		0	,
		0	,
		32	,
		32	,
		GL_HALF_FLOAT	,
		OPAQUE_FORMAT	,
		FLOATING_POINT_FORMAT	,
		ImageFormat::CODE_RG16F	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RG32I	,
		2	,
		UNCOMP_FORMAT	,
		GL_RG32I	,
		GL_RG_INTEGER	,
		0	,
		0	,
		32	,
		32	,
		0	,
		0	,
		0	,
		32 *	2,
		32 *	2,
		GL_INT	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_RG32I	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RG32UI	,
		2	,
		UNCOMP_FORMAT	,
		GL_RG32UI	,
		GL_RG_INTEGER	,
		0	,
		0	,
		32	,
		32	,
		0	,
		0	,
		0	,
		32 *	2,
		32 *	2,
		GL_UNSIGNED_INT	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_RG32UI	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	R32F	,
		1	,
		UNCOMP_FORMAT	,
		GL_R32F	,
		GL_RED	,
		0	,
		0	,
		32	,
		0	,
		0	,
		0	,
		0	,
		32	,
		32	,
		GL_FLOAT	,
		OPAQUE_FORMAT	,
		FLOATING_POINT_FORMAT	,
		ImageFormat::CODE_R32F	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RG32F	,
		2	,
		UNCOMP_FORMAT	,
		GL_RG32F	,
		GL_RG	,
		0	,
		0	,
		32	,
		32	,
		0	,
		0	,
		0	,
		64	,
		64	,
		GL_FLOAT	,
		OPAQUE_FORMAT	,
		FLOATING_POINT_FORMAT	,
		ImageFormat::CODE_RG32F	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGB5	,
		3	,
		UNCOMP_FORMAT	,
		GL_RGB5	,
		GL_RGBA	,
		0	,
		0	,
		5	,
		5	,
		5	,
		0	,
		0	,
		16	,
		16	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_RGB5	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGB5A1	,
		4	,
		UNCOMP_FORMAT	,
		GL_RGB5_A1	,
		GL_RGBA	,
		0	,
		1	,
		5	,
		5	,
		5	,
		0	,
		0	,
		16	,
		16	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_RGB5A1	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGB8	,
		3	,
		UNCOMP_FORMAT	,
		GL_RGB8	,
		GL_RGB	,
		0	,
		0	,
		8	,
		8	,
		8	,
		0	,
		0	,
		32	,
		24	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_RGB8	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGB10	,
		3	,
		UNCOMP_FORMAT	,
		GL_RGB10	,
		GL_RGB	,
		0	,
		0	,
		10	,
		10	,
		10	,
		0	,
		0	,
		32	,
		10 *	3,
		GL_UNSIGNED_SHORT	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_RGB10	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGB10A2	,
		4	,
		UNCOMP_FORMAT	,
		GL_RGB10_A2	,
		GL_RGBA	,
		0	,
		2	,
		10	,
		10	,
		10	,
		0	,
		0	,
		32	,
		32	,
		GL_UNSIGNED_INT_10_10_10_2	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_RGB10A2	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGB16	,
		3	,
		UNCOMP_FORMAT	,
		GL_RGB16	,
		GL_RGB	,
		0	,
		0	,
		16	,
		16	,
		16	,
		0	,
		0	,
		16 *	3,
		16 *	3,
		GL_UNSIGNED_SHORT	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_RGB16	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGB16F	,
		3	,
		UNCOMP_FORMAT	,
		GL_RGB16F_ARB	,
		GL_RGB	,
		0	,
		0	,
		16	,
		16	,
		16	,
		0	,
		0	,
		16 *	3,
		16 *	3,
		GL_HALF_FLOAT	,
		OPAQUE_FORMAT	,
		FLOATING_POINT_FORMAT	,
		ImageFormat::CODE_RGB16F	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGB32F	,
		3	,
		UNCOMP_FORMAT	,
		GL_RGB32F_ARB	,
		GL_RGB	,
		0	,
		0	,
		32	,
		32	,
		32	,
		0	,
		0	,
		32 *	3,
		32 *	3,
		GL_FLOAT	,
		OPAQUE_FORMAT	,
		FLOATING_POINT_FORMAT	,
		ImageFormat::CODE_RGB32F	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGBA8	,
		4	,
		UNCOMP_FORMAT	,
		GL_RGBA8	,
		GL_RGBA	,
		0	,
		8	,
		8	,
		8	,
		8	,
		0	,
		0	,
		32	,
		32	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_RGBA8	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGBA16	,
		4	,
		UNCOMP_FORMAT	,
		GL_RGBA16	,
		GL_RGBA	,
		0	,
		16	,
		16	,
		16	,
		16	,
		0	,
		0	,
		16 *	4,
		16 *	4,
		GL_UNSIGNED_SHORT	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_RGBA16	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGBA16F	,
		4	,
		UNCOMP_FORMAT	,
		GL_RGBA16F_ARB	,
		GL_RGBA	,
		0	,
		16	,
		16	,
		16	,
		16	,
		0	,
		0	,
		16 *	4,
		16 *	4,
		GL_HALF_FLOAT	,
		CLEAR_FORMAT	,
		FLOATING_POINT_FORMAT	,
		ImageFormat::CODE_RGBA16F	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGBA32F	,
		4	,
		UNCOMP_FORMAT	,
		GL_RGBA32F_ARB	,
		GL_RGBA	,
		0	,
		32	,
		32	,
		32	,
		32	,
		0	,
		0	,
		32 *	4,
		32 *	4,
		GL_FLOAT	,
		CLEAR_FORMAT	,
		FLOATING_POINT_FORMAT	,
		ImageFormat::CODE_RGBA32F	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGBA16I	,
		4	,
		UNCOMP_FORMAT	,
		GL_RGBA16I	,
		GL_RGBA_INTEGER	,
		0	,
		16	,
		16	,
		16	,
		16	,
		0	,
		0	,
		16 *	4,
		16 *	4,
		GL_SHORT	,
		CLEAR_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_RGBA16I	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGBA16UI	,
		4	,
		UNCOMP_FORMAT	,
		GL_RGBA16UI	,
		GL_RGBA_INTEGER	,
		0	,
		16	,
		16	,
		16	,
		16	,
		0	,
		0	,
		16 *	4,
		16 *	4,
		GL_UNSIGNED_SHORT	,
		CLEAR_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_RGBA16UI	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGB32I	,
		3	,
		UNCOMP_FORMAT	,
		GL_RGB32I	,
		GL_RGBA_INTEGER	,
		0	,
		32	,
		32	,
		32	,
		0	,
		0	,
		0	,
		32 *	3,
		32 *	3,
		GL_INT	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_RGB32I	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGB32UI	,
		3	,
		UNCOMP_FORMAT	,
		GL_RGB32UI	,
		GL_RGBA_INTEGER	,
		0	,
		32	,
		32	,
		32	,
		0	,
		0	,
		0	,
		32 *	3,
		32 *	3,
		GL_UNSIGNED_INT	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_RGB32UI	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGBA32I	,
		4	,
		UNCOMP_FORMAT	,
		GL_RGBA32I	,
		GL_RGBA_INTEGER	,
		0	,
		32	,
		32	,
		32	,
		32	,
		0	,
		0	,
		32 *	4,
		32 *	4,
		GL_INT	,
		CLEAR_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_RGBA32I	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGBA32UI	,
		4	,
		UNCOMP_FORMAT	,
		GL_RGBA32UI	,
		GL_RGBA_INTEGER	,
		0	,
		32	,
		32	,
		32	,
		32	,
		0	,
		0	,
		32 *	4,
		32 *	4,
		GL_UNSIGNED_INT	,
		CLEAR_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_RGBA32UI	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	R11G11B10F	,
		3	,
		UNCOMP_FORMAT	,
		GL_R11F_G11F_B10F_EXT	,
		GL_RGB	,
		0	,
		0	,
		11	,
		11	,
		10	,
		0	,
		0	,
		32	,
		32	,
		GL_FLOAT	,
		OPAQUE_FORMAT	,
		FLOATING_POINT_FORMAT	,
		ImageFormat::CODE_R11G11B10F	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGB9E5F	,
		3	,
		UNCOMP_FORMAT	,
		GL_RGB9_E5_EXT	,
		GL_RGB	,
		0	,
		0	,
		14	,
		14	,
		14	,
		0	,
		0	,
		32	,
		32	,
		GL_FLOAT	,
		OPAQUE_FORMAT	,
		FLOATING_POINT_FORMAT	,
		ImageFormat::CODE_RGB9E5F	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGB8I	,
		3	,
		UNCOMP_FORMAT	,
		GL_RGB8I_EXT	,
		GL_RGB_INTEGER	,
		0	,
		0	,
		8	,
		8	,
		8	,
		0	,
		0	,
		32	,
		24	,
		GL_BYTE	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_RGB8I	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGB8UI	,
		3	,
		UNCOMP_FORMAT	,
		GL_RGB8UI_EXT	,
		GL_RGB_INTEGER	,
		0	,
		0	,
		8	,
		8	,
		8	,
		0	,
		0	,
		32	,
		24	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_RGB8UI	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGBA8I	,
		4	,
		UNCOMP_FORMAT	,
		GL_RGBA8I_EXT	,
		GL_RGBA_INTEGER	,
		0	,
		8	,
		8	,
		8	,
		8	,
		0	,
		0	,
		32	,
		32	,
		GL_BYTE	,
		CLEAR_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_RGBA8I	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGBA8UI	,
		4	,
		UNCOMP_FORMAT	,
		GL_RGBA8UI_EXT	,
		GL_RGBA_INTEGER	,
		0	,
		8	,
		8	,
		8	,
		8	,
		0	,
		0	,
		32	,
		32	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		INTEGER_FORMAT	,
		ImageFormat::CODE_RGBA8UI	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGB8_SNORM	,
		3	,
		UNCOMP_FORMAT	,
		GL_RGB8_SNORM	,
		GL_RGB	,
		0	,
		0	,
		8	,
		8	,
		8	,
		0	,
		0	,
		32	,
		32	,
		GL_BYTE	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_RGB8_SNORM	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGBA8_SNORM	,
		4	,
		UNCOMP_FORMAT	,
		GL_RGBA8_SNORM	,
		GL_RGBA	,
		0	,
		8	,
		8	,
		8	,
		8	,
		0	,
		0	,
		32	,
		32	,
		GL_BYTE	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_RGBA8_SNORM	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGB16_SNORM	,
		3	,
		UNCOMP_FORMAT	,
		GL_RGB16_SNORM	,
		GL_RGB	,
		0	,
		0	,
		16	,
		16	,
		16	,
		0	,
		0	,
		64	,
		64	,
		GL_SHORT	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_RGB16_SNORM	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGBA16_SNORM	,
		4	,
		UNCOMP_FORMAT	,
		GL_RGBA16_SNORM	,
		GL_RGB	,
		0	,
		16	,
		16	,
		16	,
		16	,
		0	,
		0	,
		64	,
		64	,
		GL_SHORT	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_RGBA16_SNORM	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGB_DXT1	,
		3	,
		COMP_FORMAT	,
		GL_COMPRESSED_RGB_S3TC_DXT1_EXT	,
		GL_RGB	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		64	,
		64	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		OTHER	,
		ImageFormat::CODE_RGB_DXT1	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGBA_DXT1	,
		4	,
		COMP_FORMAT	,
		GL_COMPRESSED_RGBA_S3TC_DXT1_EXT	,
		GL_RGBA	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		64	,
		64	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		OTHER	,
		ImageFormat::CODE_RGBA_DXT1	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGBA_DXT3	,
		4	,
		COMP_FORMAT	,
		GL_COMPRESSED_RGBA_S3TC_DXT3_EXT	,
		GL_RGBA	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		128	,
		128	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		OTHER	,
		ImageFormat::CODE_RGBA_DXT3	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	RGBA_DXT5	,
		4	,
		COMP_FORMAT	,
		GL_COMPRESSED_RGBA_S3TC_DXT5_EXT	,
		GL_RGBA	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		128	,
		128	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		OTHER	,
		ImageFormat::CODE_RGBA_DXT5	,
		ImageFormat::COLOR_SPACE_RGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	SRGB8	,
		3	,
		UNCOMP_FORMAT	,
		GL_SRGB8	,
		GL_RGB	,
		0	,
		0	,
		8	,
		8	,
		8	,
		0	,
		0	,
		32	,
		24	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_SRGB8	,
		ImageFormat::COLOR_SPACE_SRGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	SRGBA8	,
		4	,
		UNCOMP_FORMAT	,
		GL_SRGB8_ALPHA8	,
		GL_RGBA	,
		0	,
		8	,
		8	,
		8	,
		8	,
		0	,
		0	,
		32	,
		24	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_SRGBA8	,
		ImageFormat::COLOR_SPACE_SRGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	SL8	,
		1	,
		UNCOMP_FORMAT	,
		GL_SLUMINANCE8	,
		GL_LUMINANCE	,
		8	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		8	,
		8	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_SL8	,
		ImageFormat::COLOR_SPACE_SRGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	SLA8	,
		2	,
		UNCOMP_FORMAT	,
		GL_SLUMINANCE8_ALPHA8	,
		GL_LUMINANCE_ALPHA	,
		8	,
		8	,
		0	,
		0	,
		0	,
		0	,
		0	,
		16	,
		16	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_SLA8	,
		ImageFormat::COLOR_SPACE_SRGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	SRGB_DXT1	,
		3	,
		COMP_FORMAT	,
		GL_COMPRESSED_SRGB_S3TC_DXT1_EXT	,
		GL_RGB	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		64	,
		64	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		OTHER	,
		ImageFormat::CODE_SRGB_DXT1	,
		ImageFormat::COLOR_SPACE_SRGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	SRGBA_DXT1	,
		4	,
		COMP_FORMAT	,
		GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT	,
		GL_RGBA	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		64	,
		64	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		OTHER	,
		ImageFormat::CODE_SRGBA_DXT1	,
		ImageFormat::COLOR_SPACE_SRGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	SRGBA_DXT3	,
		4	,
		COMP_FORMAT	,
		GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT	,
		GL_RGBA	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		128	,
		128	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		OTHER	,
		ImageFormat::CODE_SRGBA_DXT3	,
		ImageFormat::COLOR_SPACE_SRGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	SRGBA_DXT5	,
		4	,
		COMP_FORMAT	,
		GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT	,
		GL_RGBA	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		128	,
		128	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		OTHER	,
		ImageFormat::CODE_SRGBA_DXT5	,
		ImageFormat::COLOR_SPACE_SRGB
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	DEPTH16	,
		1	,
		UNCOMP_FORMAT	,
		GL_DEPTH_COMPONENT16_ARB	,
		GL_DEPTH_COMPONENT	,
		0	,
		0	,
		0	,
		0	,
		0	,
		16	,
		0	,
		16	,
		16	,
		GL_UNSIGNED_SHORT	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_DEPTH16	,
		ImageFormat::COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	DEPTH24	,
		1	,
		UNCOMP_FORMAT	,
		GL_DEPTH_COMPONENT24_ARB	,
		GL_DEPTH_COMPONENT	,
		0	,
		0	,
		0	,
		0	,
		0	,
		24	,
		0	,
		32	,
		24	,
		GL_UNSIGNED_INT	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_DEPTH24	,
		ImageFormat::COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	DEPTH32	,
		1	,
		UNCOMP_FORMAT	,
		GL_DEPTH_COMPONENT32_ARB	,
		GL_DEPTH_COMPONENT	,
		0	,
		0	,
		0	,
		0	,
		0	,
		32	,
		0	,
		32	,
		32	,
		GL_UNSIGNED_INT	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_DEPTH32	,
		ImageFormat::COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	DEPTH32F	,
		1	,
		UNCOMP_FORMAT	,
		GL_DEPTH_COMPONENT32_ARB	,
		GL_DEPTH_COMPONENT	,
		0	,
		0	,
		0	,
		0	,
		0	,
		32	,
		0	,
		32	,
		32	,
		GL_FLOAT	,
		CLEAR_FORMAT	,
		FLOATING_POINT_FORMAT	,
		ImageFormat::CODE_DEPTH32F	,
		ImageFormat::COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	STENCIL1	,
		1	,
		UNCOMP_FORMAT	,
		GL_STENCIL_INDEX1_EXT	,
		GL_STENCIL_INDEX	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		1	,
		1	,
		1	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_STENCIL1	,
		ImageFormat::COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	STENCIL4	,
		1	,
		UNCOMP_FORMAT	,
		GL_STENCIL_INDEX4_EXT	,
		GL_STENCIL_INDEX	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		4	,
		4	,
		4	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_STENCIL4	,
		ImageFormat::COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	STENCIL8	,
		1	,
		UNCOMP_FORMAT	,
		GL_STENCIL_INDEX8_EXT	,
		GL_STENCIL_INDEX	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		8	,
		8	,
		8	,
		GL_UNSIGNED_BYTE	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_STENCIL8	,
		ImageFormat::COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	STENCIL16	,
		1	,
		UNCOMP_FORMAT	,
		GL_STENCIL_INDEX16_EXT	,
		GL_STENCIL_INDEX	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		16	,
		16	,
		16	,
		GL_UNSIGNED_SHORT	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_STENCIL16	,
		ImageFormat::COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	DEPTH24_STENCIL8	,
		2	,
		UNCOMP_FORMAT	,
		GL_DEPTH24_STENCIL8_EXT	,
		GL_DEPTH_STENCIL_EXT	,
		0	,
		0	,
		0	,
		0	,
		0	,
		24	,
		8	,
		32	,
		32	,
		GL_UNSIGNED_INT_24_8	,
		CLEAR_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_DEPTH24_STENCIL8	,
		ImageFormat::COLOR_SPACE_NONE
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	YUV420_PLANAR	,
		3	,
		UNCOMP_FORMAT	,
		GL_NONE	,
		GL_NONE	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		12	,
		12	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_YUV420_PLANAR	,
		ImageFormat::COLOR_SPACE_YUV
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	YUV422	,
		3	,
		UNCOMP_FORMAT	,
		GL_NONE	,
		GL_NONE	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		16	,
		16	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_YUV422	,
		ImageFormat::COLOR_SPACE_YUV
	)

G3D::DEFINE_TEXTUREFORMAT_METHOD	(	YUV444	,
		3	,
		UNCOMP_FORMAT	,
		GL_NONE	,
		GL_NONE	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		0	,
		24	,
		24	,
		GL_UNSIGNED_BYTE	,
		OPAQUE_FORMAT	,
		NORMALIZED_FIXED_POINT_FORMAT	,
		ImageFormat::CODE_YUV444	,
		ImageFormat::COLOR_SPACE_YUV
	)

void G3D::deserialize	(	std::string &	s,
		BinaryInput &	b
	)

inline

                                                       {
     s = b.readString32();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::deserialize	(	int32 &	i,
		BinaryInput &	b
	)

inline

                                                   {
     i = b.readInt32();
 }

Here is the call graph for this function:

void G3D::deserialize	(	uint32 &	i,
		BinaryInput &	b
	)

inline

                                                    {
     i = b.readUInt32();
 }

Here is the call graph for this function:

void G3D::deserialize	(	bool &	i,
		BinaryInput &	b
	)

inline

                                                  {
     i = b.readBool8();
 }

Here is the call graph for this function:

void G3D::deserialize	(	float32 &	f,
		BinaryInput &	b
	)

inline

                                                     {
     f = b.readFloat32();
 }

Here is the call graph for this function:

void G3D::deserialize	(	float64 &	f,
		BinaryInput &	b
	)

inline

                                                     {
     f = b.readFloat64();
 }

Here is the call graph for this function:

template<typename T >

void G3D::deserialize	(	Array< T > &	array,
		BinaryInput &	b
	)

                                                   { 
     int N = b.readInt32();
     array.resize(N);
     for (int i = 0; i < array.size(); ++i) { 
         deserialize(array[i], b); 
     }
 }

Here is the call graph for this function:

void G3D::deserialize ( class BinaryInput & bi )

void G3D::deserialize	(	Vector2 &	v,
		class BinaryInput &	b
	)

                                                    {
     v.deserialize(b);
 }

Here is the call graph for this function:

void G3D::deserialize	(	Vector3::Axis &	a,
		class BinaryInput &	bo
	)

                                                         {
     a = (Vector3::Axis)bi.readUInt8();
 }

Here is the call graph for this function:

void G3D::deserialize	(	Vector4 &	v,
		class BinaryInput &	b
	)

                                                    {
     v.deserialize(b);
 }

Here is the call graph for this function:

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

                                                    {
     v.deserialize(b);
 }

Here is the call graph for this function:

void G3D::deserialize	(	bool &	b,
		TextInput &	ti
	)

                                          {
     b = ti.readSymbol() == "true";
 }

Here is the call graph for this function:

void G3D::deserialize	(	int &	b,
		TextInput &	ti
	)

                                         {
     b = iRound(ti.readNumber());
 }

Here is the call graph for this function:

void G3D::deserialize	(	uint8 &	b,
		TextInput &	ti
	)

                                           {
     b = (uint8)iRound(ti.readNumber());
 }

Here is the call graph for this function:

void G3D::deserialize	(	double &	b,
		TextInput &	ti
	)

                                            {
     b = ti.readNumber();
 }

Here is the call graph for this function:

void G3D::deserialize	(	float &	b,
		TextInput &	ti
	)

                                           {
     b = (float)ti.readNumber();
 }

Here is the call graph for this function:

void G3D::deserialize	(	std::string &	b,
		TextInput &	ti
	)

double G3D::determinant ( const Matrix3 & m )

inline

                                             {
     return m.determinant();
 }

Here is the call graph for this function:

double G3D::determinant ( const Matrix4 & m )

inline

                                             {
     return m.determinant();
 }

Here is the call graph for this function:

static void G3D::determineFileOrDirList	(	const std::string &	filespec,
		Array< std::string > &	files,
		bool	wantFiles,
		bool	includePath
	)

static

                                              {
 
     // if it is a .zip, prefix will specify the folder within
     // whose contents we want to see
     std::string prefix = "";
     std::string path = filenamePath(filespec);
 
     if ((path.size() > 0) && isSlash(path[path.size() - 1])) {
         // Strip the trailing slash
         path = path.substr(0, path.length() -1);
     }
     
     if ((path == "") || FileSystem::exists(path)) {
         if ((path != "") && FileSystem::isZipfile(path)) {
             // .zip should only work if * is specified as the Base + Ext
             // Here, we have been asked for the root's contents
             debugAssertM(filenameBaseExt(filespec) == "*", "Can only call getFiles/getDirs on zipfiles using '*' wildcard");
             getFileOrDirListZip(path, prefix, files, wantFiles, includePath);
         } else {
             // It is a normal directory
             getFileOrDirListNormal(filespec, files, wantFiles, includePath);
         }
     } else if (zipfileExists(filenamePath(filespec), path, prefix)) {
         // .zip should only work if * is specified as the Base + Ext
         // Here, we have been asked for the contents of a folder within the .zip
         debugAssertM(filenameBaseExt(filespec) == "*", "Can only call getFiles/getDirs on zipfiles using '*' wildcard");
         getFileOrDirListZip(path, prefix, files, wantFiles, includePath);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double G3D::distance	(	double	x,
		double	y
	)

inline

                                            {
     return sqrt(sumSquares(x, y));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double G3D::distance	(	double	x,
		double	y,
		double	z
	)

inline

                                                      {
     return sqrt(sumSquares(x, y, z));
 }

Here is the call graph for this function:

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

inline

                                         {
     return sqrt(sumSquares(x, y));
 }

Here is the call graph for this function:

float G3D::distance	(	float	x,
		float	y,
		float	z
	)

inline

                                                  {
     return sqrt(sumSquares(x, y, z));
 }

Here is the call graph for this function:

float G3D::dot	(	const Vector2 &	a,
		const Vector2 &	b
	)

inline

                                                      {
     return a.dot(b);
 }

Here is the call graph for this function:

float G3D::dot	(	const Vector3 &	a,
		const Vector3 &	b
	)

inline

                                                      {
     return a.dot(b);
 }

Here is the call graph for this function:

float G3D::dot	(	const Vector4 &	a,
		const Vector4 &	b
	)

inline

                                                      {
     return a.dot(b);
 }

Here is the call graph for this function:

int G3D::dot ( const Vector3int16 & v ) const

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

float G3D::dot	(	float	a,
		float	b
	)

inline

a * b (for DirectX/Cg support)

                                    {
     return a * b;
 }

Here is the caller graph for this function:

bool G3D::endsWith	(	const std::string &	test,
		const std::string &	pattern
	)

Returns true if the test string ends with the pattern string.

                               {
 
     if (test.size() >= pattern.size()) {
         size_t te = test.size() - 1;
         size_t pe = pattern.size() - 1;
         for (int i = (int)pattern.size() - 1; i >= 0; --i) {
             if (pattern[pe - i] != test[te - i]) {
                 return false;
             }
         }
         return true;
     } else {
         return false;
     }
 }

Here is the caller graph for this function:

template<class EnumClass , class EnumClassValue >

void G3D::enumToJavaScriptDeclaration ( TextOutput & t )

Generates JavaScript source code defining an enum equivalent to EnumClass.

TextOutput t("WrapMode.js");
enumToJavaScriptDeclaration<WrapMode, WrapMode::Value>(t);
t.commit();

                                                 {
     t.printf("/* BEGIN GENERATED CODE. The following was automatically generated by G3D::enumToJavaScriptDeclaration().  Do not edit it manually. */\n\n");
     t.printf("var %s = (function (propList) {", EnumClass::classname()); t.writeNewline();
     t.pushIndent(); {
         t.printf("// Define immutable properties"); t.writeNewline();
         t.printf("var en = {};"); t.writeNewline();
         t.printf("for (var i = 0; i < propList.length; i += 2)"); t.writeNewline();
         t.pushIndent(); {
             t.printf("Object.defineProperty(en, propList[i], {enumerable: true, value: propList[i + 1]});"); t.writeNewline();
         } t.popIndent();
         t.printf("return en;");
         t.writeNewline();
     } t.popIndent();
     t.printf("})([");
     int i = 0;
     EnumClassValue m;
     const char* s = EnumClass::toString(i, m);
     while (notNull(s)) {
         t.printf("\"%s\", %d, ", s, int(m));
         ++i;
         s = EnumClass::toString(i, m);
     }
     // JavaScript allows a trailing comma
     t.printf("]);"); t.writeNewline();
     t.printf("/* END GENERATED CODE */"); t.writeNewline();
 }

Here is the call graph for this function:

double G3D::eps	(	double	a,
		double	b
	)

inline

Computes an appropriate epsilon for comparing a and b.

                                       {
     // For a and b to be nearly equal, they must have nearly
     // the same magnitude.  This means that we can ignore b
     // since it either has the same magnitude or the comparison
     // will fail anyway.
     (void)b;
     const double aa = abs(a) + 1.0;
     if (aa == inf()) {
         return fuzzyEpsilon64;
     } else {
         return fuzzyEpsilon64 * aa;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::eps	(	float	a,
		float	b
	)

inline

                                    {
     // For a and b to be nearly equal, they must have nearly
     // the same magnitude.  This means that we can ignore b
     // since it either has the same magnitude or the comparison
     // will fail anyway.
     (void)b;
     const float aa = (float)abs(a) + 1.0f;
     if (aa == inf()) {
         return fuzzyEpsilon32;
     } else {
         return fuzzyEpsilon32 * aa;
     }
 }

Here is the call graph for this function:

const char* G3D::errnoToString ( )

                             {
     switch (errno) {
     case EBADF:
         return "file descriptor is invalid.";
 
     case EINVAL: 
         return "Request or argp is not valid.";
         
     case ENOTTY:
         return 
             "file descriptor is not associated with a character special device OR "
             "The specified request does not apply to the "
             "kind of object that the descriptor fildes references.";
 
     case EADDRNOTAVAIL:
         return "Address not available.";
 
     default:
         {
             static char buffer[20];
             sprintf(buffer, "Error %d", errno);
             return buffer;
         }
     }
 }

Here is the call graph for this function:

static std::string G3D::escape ( const std::string & string )

static

                                                  {
     std::string result = "";
 
     for (std::string::size_type i = 0; i < string.length(); ++i) {
         char c = string.at(i);
         switch (c) {
         case '\0':
             result += "\\0";
             break;
 
         case '\r':
             result += "\\r";
             break;
 
         case '\n':
             result += "\\n";
             break;
 
         case '\t':
             result += "\\t";
             break;
 
         case '\\':
             result += "\\\\";
             break;
 
         default:
             result += c;
         }
     }
 
     return result;
 }

Here is the caller graph for this function:

Quat G3D::exp ( const Quat & q )

inline

                                {
     return q.exp();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double G3D::exp2 ( double x )

inline

2^x

                              {
     return pow(2.0, x);
 }

Here is the call graph for this function:

float G3D::exp2 ( float x )

inline

                            {
     return powf(2.0f, x);
 }

AssertionHook G3D::failureHook ( )

                             {
     return G3D::_internal::_failureHook;
 }

bool G3D::fileIsNewer	(	const std::string &	src,
		const std::string &	dst
	)

                                                              {
     struct _stat sts;
     bool sexists = _stat(src.c_str(), &sts) != -1;
 
     struct _stat dts;
     bool dexists = _stat(dst.c_str(), &dts) != -1;
 
     return sexists && ((! dexists) || (sts.st_mtime > dts.st_mtime));
 }

int64 G3D::fileLength ( const std::string & filename )

                                             {
     struct _stat st;
     int result = _stat(filename.c_str(), &st);
     
     if (result == -1) {
 #if _HAVE_ZIP /* G3DFIX: Use ZIP-library only if defined */
         std::string zip, contents;
         if(zipfileExists(filename, zip, contents)){
             int64 requiredMem;
 
                         struct zip *z = zip_open( zip.c_str(), ZIP_CHECKCONS, NULL );
                         debugAssertM(z != NULL, zip + ": zip open failed.");
             {
                                 struct zip_stat info;
                                 zip_stat_init( &info );    // TODO: Docs unclear if zip_stat_init is required.
                                 int success = zip_stat( z, contents.c_str(), ZIP_FL_NOCASE, &info );
                 (void)success;
                                 debugAssertM(success == 0, zip + ": " + contents + ": zip stat failed.");
                                 requiredMem = info.size;
             }
                         zip_close( z );
             return requiredMem;
         } else {
         return -1;
         }
 #else
         return -1;
 #endif
     }
 
     return st.st_size;
 }

Here is the call graph for this function:

std::string G3D::filenameBase ( const std::string & filename )

Returns the portion of a filename to the left of the last period and to the right of the last slash or colon.

                                            {
     std::string drive;
     std::string base;
     std::string ext;
     Array<std::string> path;
 
     parseFilename(s, drive, path, base, ext);
     return base;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::filenameBaseExt ( const std::string & filename )

Returns the part of the filename that includes the base and ext from parseFilename (i.e. everything to the right of the path).

                                                      {
     size_t i = filename.rfind("/");
     size_t j = filename.rfind("\\");
 
     if ((j > i) && (j != std::string::npos)) {
         i = j;
     }
 
 #   ifdef G3D_WINDOWS
         j = filename.rfind(":");
         if ((i == std::string::npos) && (j != std::string::npos)) {
             i = j;
         }
 #   endif
 
     if (i == std::string::npos) {
         return filename;
     } else {
         return filename.substr(i + 1, filename.length() - i);
     }
 }

Here is the caller graph for this function:

bool G3D::filenameContainsWildcards ( const std::string & filename )

Returns true if '*' or '?' appears in the string

                                                           {
     return (filename.find('*') != std::string::npos) || (filename.find('?') != std::string::npos);
 }

std::string G3D::filenameExt ( const std::string & filename )

Returns the extension on a filename.

                                                  {
     size_t i = filename.rfind(".");
     if (i != std::string::npos) {
         return filename.substr(i + 1, filename.length() - i);
     } else {
         return "";
     }
 }

std::string G3D::filenamePath ( const std::string & filename )

Returns the drive (if Win32) and path from a filename, including a slash if there was one. filenamePath(f) + filenameBaseExt(f) == f

                                                   {
     size_t i = filename.rfind("/");
     size_t j = filename.rfind("\\");
 
     if ((j > i) && (j != std::string::npos)) {
         i = j;
     }
 
 #   ifdef G3D_WINDOWS
         j = filename.rfind(":");
         if ((i == std::string::npos) && (j != std::string::npos)) {
             i = j;
         }
 #   endif
 
     if (i == std::string::npos) {
         return "";
     } else {
         return filename.substr(0, i+1);
     }
 }

Here is the caller graph for this function:

static ConvertFunc G3D::findConverter	(	TextureFormat::Code	sourceCode,
		TextureFormat::Code	destCode,
		bool	needsSourcePadding,
		bool	needsDestPadding,
		bool	needsInvertY
	)

static

                                                                                                                                                               {
     int numRoutines = sizeof(sConvertMappings) / sizeof(ConvertAttributes);
     for (int routineIndex = 0; routineIndex < numRoutines; ++routineIndex) {
         int sourceIndex = 0;
         ConvertAttributes routine = sConvertMappings[routineIndex];
 
         while (routine.m_sourceFormats[sourceIndex] != ImageFormat::CODE_NONE) {
             // check for matching source
             if (routine.m_sourceFormats[sourceIndex] == sourceCode) {
                 int destIndex = 0;
 
                 // now check for matching dest to see if the routine fits
                 while (routine.m_destFormats[destIndex] != ImageFormat::CODE_NONE) {
 
                     // check if dest format matches and padding + invert rules match
                     if ((routine.m_destFormats[destIndex] == destCode) &&
                         (!needsSourcePadding || (routine.m_handlesSourcePadding == needsSourcePadding)) &&
                         (!needsDestPadding || (routine.m_handlesDestPadding == needsDestPadding)) &&
                         (!needsInvertY || (routine.m_handleInvertY == needsInvertY))) {
 
                         // found compatible converter
                         return routine.m_converter;
                     }
                     ++destIndex;
                 }
             }
             ++sourceIndex;
         }
     }
 
     return NULL;
 }

Here is the caller graph for this function:

size_t G3D::findLastSlash	(	const std::string &	f,
		size_t	start = `std::string::npos`
	)

inline

Finds the index of the first '\' or '/' character, starting at index start (if start is -1, starts at the end of the string).

See also: G3D::findSlash, G3D::isSlash

                                                                               {
     if (start == std::string::npos) {
         start = f.length() - 1;
     }
 
     size_t i = f.rfind('/', start);
     size_t j = f.rfind('\\', start);
     return maxNotNPOS(i, j);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool G3D::findRayCapsuleIntersection	(	const Ray &	rkRay,
		const Capsule &	rkCapsule,
		int &	riQuantity,
		Vector3	akPoint[2]
	)

static

Used by collisionTimeForMovingPointFixedCapsule. [From] magic software http://www.magic-software.com/Source/Intersection3D/MgcIntr3DLinCap.cpp

Parameters

rkRay	The ray
rkCapsule	The capsule
riQuantity	The number of intersections found
akPoint	The intersections found

Returns: True if there is at least one intersection

                                        {
 
     double afT[2];
     riQuantity = findRayCapsuleIntersectionAux(rkRay.origin(), rkRay.direction(), rkCapsule, afT);
 
     // Only return intersections that occur in the future
     int iClipQuantity = 0;
     int i;
     for (i = 0; i < riQuantity; ++i) {
         if (afT[i] >= 0.0f) {
             akPoint[iClipQuantity] = rkRay.origin() + afT[i] * rkRay.direction();
             ++iClipQuantity;
         }
     }
 
     riQuantity = iClipQuantity;
     return (riQuantity > 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static int G3D::findRayCapsuleIntersectionAux	(	const Vector3 &	rkOrigin,
		const Vector3 &	rkDirection,
		const Capsule &	rkCapsule,
		double	afT[2]
	)

static

Used by findRayCapsuleIntersection. [From] magic software http://www.magic-software.com/Source/Intersection3D/MgcIntr3DLinCap.cpp

                                  {
 
     Vector3 capsuleDirection = rkCapsule.point(1) - rkCapsule.point(0);
 
     // set up quadratic Q(t) = a*t^2 + 2*b*t + c
     Vector3 kW = capsuleDirection;
     float fWLength = kW.length();
     kW = kW.direction();
 
     Vector3 kU, kV;
     kW.getTangents(kU, kV);
     Vector3 kD(kU.dot(rkDirection), kV.dot(rkDirection), kW.dot(rkDirection));
 
     float fDLength = kD.length();
     kD = kD.direction();
 
     float fEpsilon = 1e-6f;
 
     float fInvDLength = 1.0f/fDLength;
     Vector3 kDiff = rkOrigin - rkCapsule.point(0);
     Vector3 kP(kU.dot(kDiff),kV.dot(kDiff),kW.dot(kDiff));
     float fRadiusSqr = square(rkCapsule.radius());
 
     float fInv, fA, fB, fC, fDiscr, fRoot, fT, fTmp;
 
     // Is the velocity parallel to the capsule direction? (or zero)
     if ((abs(kD.z) >= 1.0f - fEpsilon) || (fDLength < fEpsilon)) {
 
         float fAxisDir = rkDirection.dot(capsuleDirection);
 
         fDiscr = fRadiusSqr - kP.x*kP.x - kP.y*kP.y;
         if ((fAxisDir < 0) && (fDiscr >= 0.0f)) {
             // Velocity anti-parallel to the capsule direction
             fRoot = sqrt(fDiscr);
             afT[0] = (kP.z + fRoot)*fInvDLength;
             afT[1] = -(fWLength - kP.z + fRoot)*fInvDLength;
             return 2;
         } else if ((fAxisDir > 0) && (fDiscr >= 0.0f)) {
             // Velocity parallel to the capsule direction
             fRoot = sqrt(fDiscr);
             afT[0] = -(kP.z + fRoot)*fInvDLength;
             afT[1] = (fWLength - kP.z + fRoot)*fInvDLength;
             return 2;
         } else {
             // sphere heading wrong direction, or no velocity at all
             return 0;
         }   
     }
 
     // test intersection with infinite cylinder
     fA = kD.x*kD.x + kD.y*kD.y;
     fB = kP.x*kD.x + kP.y*kD.y;
     fC = kP.x*kP.x + kP.y*kP.y - fRadiusSqr;
     fDiscr = fB*fB - fA*fC;
     if (fDiscr < 0.0f) {
         // line does not intersect infinite cylinder
         return 0;
     }
 
     int iQuantity = 0;
 
     if (fDiscr > 0.0f) {
         // line intersects infinite cylinder in two places
         fRoot = sqrt(fDiscr);
         fInv = 1.0f/fA;
         fT = (-fB - fRoot)*fInv;
         fTmp = kP.z + fT*kD.z;
         if ((0.0f <= fTmp) && (fTmp <= fWLength)) {
             afT[iQuantity] = fT * fInvDLength;
             ++iQuantity;
         }
 
         fT = (-fB + fRoot)*fInv;
         fTmp = kP.z + fT*kD.z;
         
         if ((0.0f <= fTmp) && (fTmp <= fWLength)) {
             afT[iQuantity++] = fT*fInvDLength;
         }
 
         if (iQuantity == 2) {
             // line intersects capsule wall in two places
             return 2;
         }
     } else {
         // line is tangent to infinite cylinder
         fT = -fB/fA;
         fTmp = kP.z + fT*kD.z;
         if ((0.0f <= fTmp) && (fTmp <= fWLength)) {
             afT[0] = fT*fInvDLength;
             return 1;
         }
     }
 
     // test intersection with bottom hemisphere
     // fA = 1
     fB += kP.z*kD.z;
     fC += kP.z*kP.z;
     fDiscr = fB*fB - fC;
     if (fDiscr > 0.0f) {
         fRoot = sqrt(fDiscr);
         fT = -fB - fRoot;
         fTmp = kP.z + fT*kD.z;
         if (fTmp <= 0.0f) {
             afT[iQuantity++] = fT*fInvDLength;
             if (iQuantity == 2) {
                 return 2;
             }
         }
 
         fT = -fB + fRoot;
         fTmp = kP.z + fT*kD.z;
         if (fTmp <= 0.0f) {
             afT[iQuantity++] = fT*fInvDLength;
             if (iQuantity == 2) {
                 return 2;
             }
         }
     } else if (fDiscr == 0.0f) {
         fT = -fB;
         fTmp = kP.z + fT*kD.z;
         if (fTmp <= 0.0f) {
             afT[iQuantity++] = fT*fInvDLength;
             if (iQuantity == 2) {
                 return 2;
             }
         }
     }
 
     // test intersection with top hemisphere
     // fA = 1
     fB -= kD.z*fWLength;
     fC += fWLength*(fWLength - 2.0f*kP.z);
 
     fDiscr = fB*fB - fC;
     if (fDiscr > 0.0f) {
         fRoot = sqrt(fDiscr);
         fT = -fB - fRoot;
         fTmp = kP.z + fT*kD.z;
         if (fTmp >= fWLength) {
             afT[iQuantity++] = fT*fInvDLength;
             if (iQuantity == 2) {
                 return 2;
             }
         }
 
         fT = -fB + fRoot;
         fTmp = kP.z + fT*kD.z;
         if (fTmp >= fWLength) {
             afT[iQuantity++] = fT*fInvDLength;
             if (iQuantity == 2) {
                 return 2;
             }
         }
     } else if (fDiscr == 0.0f) {
         fT = -fB;
         fTmp = kP.z + fT*kD.z;
         if (fTmp >= fWLength) {
             afT[iQuantity++] = fT*fInvDLength;
             if (iQuantity == 2) {
                 return 2;
             }
         }
     }
 
     return iQuantity;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

size_t G3D::findSlash	(	const std::string &	f,
		size_t	start = `0`
	)

inline

Finds the index of the first '\' or '/' character, starting at index start.

See also: G3D::findLastSlash, G3D::isSlash

                                                               {
     size_t i = f.find('/', start);
     size_t j = f.find('\\', start);
     if ((i != std::string::npos) && (i < j)) {
         return i;
     } else {
         return j;
     }
 }

Here is the caller graph for this function:

static Any::Type G3D::findType	(	TextInput &	ti,
		const char	closeSymbol
	)

static

Determines the type [TABLE, ARRAY, or EMPTY_CONTAINER] from the given TextInput TextInput is the same at the end as it was beofr

                                                                {
     Any::Type type = Any::NIL;
     std::vector<Token> tokens;
     // consumes the open symbol
     Token token = ti.read();
     tokens.push_back(token);
 
     bool hasAnElement = false;
     while (type == Any::NIL) {
         if (token.type() == Token::COMMENT) {
             // consumes tokens and prepares to push them back onto the TextInput
             token = ti.read();
             tokens.push_back(token);
         } else if ((token.type() == Token::SYMBOL) && ((token.string() == "=") || (token.string() == ":"))) {
             // an '=' indicates a key = value pairing, and thus a table
             type = Any::TABLE;
         } else if (hasAnElement) {
             // any non-comment, non-'=' token after any element indicates an array
             type = Any::ARRAY;
         } else if ((token.type() == Token::SYMBOL) && (token.string()[0] == closeSymbol)) {
             // catches no previous element and a closing symbol (e.g [])
             type = Any::EMPTY_CONTAINER;
         } else {
             // consumes elements, indicating one has been seen, and prepares to push them back onto TextInput
             hasAnElement = true;
             token = ti.read();
             tokens.push_back(token);
         }
     }
     // pushes everything back to the TextInput
     while (!tokens.empty()) {
         token = tokens.back();
         ti.push(token);
         tokens.pop_back();
     }
     return type;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::finf ( )

This value should not be tested against directly, instead G3D::isNan() and G3D::isFinite() will return reliable results.

              {
     return std::numeric_limits<float>::infinity();
 }

Here is the caller graph for this function:

static int G3D::fixslash ( int c )

static

                            {
     return (c == '\\') ? '/' : c;
 }

Here is the caller graph for this function:

uint16 G3D::flipEndian16 ( const uint16 x )

inline

Given a 16-bit integer, returns the integer with the bytes in the opposite order.

                                            {
     return (x << 8) | ((x & 0xFF00) >> 8);
 }

uint32 G3D::flipEndian32 ( const uint32 x )

inline

Given a 32-bit integer, returns the integer with the bytes in the opposite order.

                                            {
     return (x << 24) | ((x & 0xFF00) << 8) | 
            ((x & 0xFF0000) >> 8) | ((x & 0xFF000000) >> 24);
 }

static Vector3int16 G3D::floor ( const Vector3 & v )

static

Here is the caller graph for this function:

float G3D::fnan ( )

              {
     // double is a standard type and should have quiet NaN
     return std::numeric_limits<float>::quiet_NaN();
 }

Here is the caller graph for this function:

std::string __cdecl G3D::format	(	const char *	fmt,
			...
	)

                                               {
     va_list argList;
     va_start(argList,fmt);
     std::string result = vformat(fmt, argList);
     va_end(argList);
 
     return result;
 }

Here is the call graph for this function:

std::string __cdecl G3D::format ( const char * fmt... )

Produces a string from arguments of the style of printf. This avoids problems with buffer overflows when using sprintf and makes it easy to use the result functionally. This function is fast when the resulting string is under 160 characters (not including terminator) and slower when the string is longer.

Here is the caller graph for this function:

double G3D::frand ( )

                {
     return rand() / (double) RAND_MAX;
 }

Here is the caller graph for this function:

static unorm16 G3D::fromBits ( uint16 b )

static

Equivalent to:

unorm16 u = reinterpret_cast<const unorm16&>(255);

                                       {
         return unorm16(b);
     }

Here is the caller graph for this function:

static unorm8 G3D::fromBits ( uint8 b )

static

Equivalent to:

unorm8 u = reinterpret_cast<const unorm8&>(255);

                                     {
         return unorm8(b);
     }

bool G3D::fuzzyEq	(	double	a,
		double	b
	)

inline

Note that fuzzyEq(a, b) && fuzzyEq(b, c) does not imply fuzzyEq(a, c), although that will be the case on some occasions.

                                         {
     return (a == b) || (abs(a - b) <= eps(a, b));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::fuzzyEq	(	float	a,
		float	b
	)

inline

                                       {
     return (a == b) || (abs(a - b) <= eps(a, b));
 }

Here is the call graph for this function:

bool G3D::fuzzyGe	(	double	a,
		double	b
	)

inline

Is a near or greater than b?

                                         {
     return a > b - eps(a, b);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::fuzzyGt	(	double	a,
		double	b
	)

inline

Is a strictly greater than b? (Guaranteed false if a <= b). (Possibly false if a > b)

                                         {
     return a > b + eps(a, b);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::fuzzyLe	(	double	a,
		double	b
	)

inline

Is a near or less than b?

                                         {
     return a < b + eps(a, b);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::fuzzyLt	(	double	a,
		double	b
	)

inline

Is a strictly less than b? (Guaranteed false if a >= b)

                                         {
     return a < b - eps(a, b);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::fuzzyNe	(	double	a,
		double	b
	)

inline

True if a is definitely not equal to b. Guaranteed false if a == b. Possibly false when a != b.

                                         {
     return ! fuzzyEq(a, b);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int G3D::g3dfnmatch	(	const char *	pattern,
		const char *	string,
		int	flags
	)

Function fnmatch() as specified in POSIX 1003.2-1992, section B.6. Compares a filename or pathname to a pattern.

The fnmatch() function checks whether the string argument matches the pattern argument, which is a shell wildcard pattern. The flags argument modifies the behaviour; it is the bitwise OR of zero or more of the following flags:

FNM_NOESCAPE If this flag is set, treat backslash as an ordinary character, instead of an escape character.
FNM_PATHNAME If this flag is set, match a slash in string only with a slash in pattern and not by an asterisk (*) or a question mark (?) metacharacter, nor by a bracket expression ([]) containing a slash.
FNM_PERIOD If this flag is set, a leading period in string has to be matched exactly by a period in pattern. A period is considered to be leading if it is the first character in string, or if both FNM_PATHNAME is set and the period immediately follows a slash.
FNM_FILE_NAME This is a GNU synonym for FNM_PATHNAME.
FNM_LEADING_DIR If this flag (a GNU extension) is set, the pattern is considered to be matched if it matches an initial segment of string which is followed by a slash. This flag is mainly for the internal use of glibc and is only implemented in certain cases.
FNM_CASEFOLD If this flag (a GNU extension) is set, the pattern is matched case-insensitively.

Returns: Zero if string matches pattern, FNM_NOMATCH if there is no match or another non-zero value if there is an error

                                                      {
     return fnmatch(a, b, c);
 }

Here is the caller graph for this function:

void G3D::gaussian1D	(	Array< float > &	coeff,
		int	N = `5`,
		float	std = `0.5f`
	)

Generates a set of 1D gaussian filter coefficients of size N. The coefficients are centered on element (N-1)/2 and have standard deviation given by std. The coefficients are normalized such that the sum across coeff is 1.0.

Matches the results returned by Matlab fspecial('gaussian', [1, N], std)

                                                        {
     coeff.resize(N);
     float sum = 0.0f;
     for (int i = 0; i < N; ++i) {
         float x = i - (N - 1) / 2.0f;
         float p = -square(x / std) / 2.0f;
         float y = exp(p);
         coeff[i] = y;
         sum += y;
     }
 
     for (int i = 0; i < N; ++i) {
         coeff[i] /= sum;
     }   
 }

Here is the call graph for this function:

float G3D::gaussRandom	(	float	mean = `0.0f`,
		float	stdev = `1.0f`
	)

Normally distributed random number.

Deprecated:

See also: Random::gaussian

                                            {
 
     // Using Box-Mueller method from http://www.taygeta.com/random/gaussian.html
     // Modified to specify standard deviation and mean of distribution
     float w, x1, x2;
 
     // Loop until w is less than 1 so that log(w) is negative
     do {
         x1 = uniformRandom(-1.0, 1.0);
         x2 = uniformRandom(-1.0, 1.0);
 
         w = float(square(x1) + square(x2));
     } while (w > 1.0f);
 
     // Transform to gassian distribution
     // Multiply by sigma (stdev ^ 2) and add mean.
     return x2 * (float)square(stdev) * sqrtf((-2.0f * logf(w) ) / w) + mean; 
 }

Here is the call graph for this function:

std::string G3D::generateFilenameBase	(	const std::string &	prefix = `""`,
		const std::string &	suffix = `""`
	)

Creates a unique filename base in the current directory using the specified prefix and suffix.

                                                                                  {
     Array<std::string> exist;
 
     // Note "template" is a reserved word in C++
     std::string templat = prefix + System::currentDateString() + "_";
     FileSystem::getFiles(templat + "*", exist, true);
     
     // Remove extensions
     for (int i = 0; i < exist.size(); ++i) {
         const std::string ext = FilePath::ext(exist[i]);
         if (ext.length() > 0) {
             exist[i] = exist[i].substr(0, exist[i].length() - ext.length() - 1);
         }
     }
 
     int num = 0;
     std::string result;
     templat += "%03d" + suffix;
     do {
         result = format(templat.c_str(), num);
         ++num;
     } while (exist.contains(result));
 
     return result;
 }

Here is the call graph for this function:

static void G3D::getDeserializeSettings ( TextInput::Settings & settings )

static

                                                                 {
     settings.cppBlockComments = true;
     settings.cppLineComments = true;
     settings.otherLineComments = false;
     settings.generateCommentTokens = true;
     settings.singleQuotedStrings = false;
     settings.msvcFloatSpecials = true;
     settings.caseSensitive = false;
 }

Here is the caller graph for this function:

void G3D::getDirs	(	const std::string &	filespec,
		Array< std::string > &	files,
		bool	includePath
	)

                                              {
 
     determineFileOrDirList(filespec, files, false, includePath);
 }

Here is the call graph for this function:

static void G3D::getFileOrDirListNormal	(	const std::string &	filespec,
		Array< std::string > &	files,
		bool	wantFiles,
		bool	includePath
	)

static

Helper for getFileList and getDirectoryList.

Parameters

wantFiles	If false, returns the directories, otherwise returns the files.
includePath	If true, the names include paths

                                      {
     
     bool test = wantFiles ? true : false;
     
     std::string path = "";
 
     // Find the place where the path ends and the file-spec begins
     size_t i = filespec.rfind('/');
     size_t j = filespec.rfind('\\');
     
     // Drive letters on Windows can separate a path
     size_t k = filespec.rfind(':');
     
     if (((j != std::string::npos) && (j > i)) ||
         (i == std::string::npos)) {
         i = j;
     }
     
     if (((k != std::string::npos) && (k > i)) ||
         (i == std::string::npos)) {
         i = k;
     }
     
     // If there is a path, pull it off
     if (i != std::string::npos) {
         path = filespec.substr(0, i + 1);
     }
    
     std::string prefix = path;
 
     if (path.size() > 0) {
         // Strip the trailing character
         path = path.substr(0, path.size() - 1);
     }
 
 #   ifdef G3D_WINDOWS
     {
        struct _finddata_t fileinfo;
 
         long handle = (long)_findfirst(filespec.c_str(), &fileinfo);
         int result = handle;
 
         while (result != -1) {
             if ((((fileinfo.attrib & _A_SUBDIR) == 0) == test) && 
                 strcmp(fileinfo.name, ".") &&
                 strcmp(fileinfo.name, "..")) {
                 
                 if (includePath) {
                     files.append(prefix + fileinfo.name);
                 } else {
                     files.append(fileinfo.name);
                 }
             }
             
             result = _findnext(handle, &fileinfo);
         }
     }
 #   else
     {
         if (path == "") {
             // Empty paths don't work on Unix
             path = ".";
         }
 
         // Unix implementation
         DIR* dir = opendir(path.c_str());
 
         if (dir != NULL) {
             struct dirent* entry = readdir(dir);
 
             while (entry != NULL) {
 
                 // Exclude '.' and '..'
                 if ((strcmp(entry->d_name, ".") != 0) &&
                     (strcmp(entry->d_name, "..") != 0)) {
                     
                     // Form a name with a path
                     std::string filename = prefix + entry->d_name;
                     // See if this is a file or a directory
                     struct _stat st;
                     bool exists = _stat(filename.c_str(), &st) != -1;
 
                     if (exists &&
 
                         // Make sure it has the correct type
                         (((st.st_mode & S_IFDIR) == 0) == test) &&
 
                         // Make sure it matches the wildcard
                         (fnmatch(filespec.c_str(),
                                  filename.c_str(),
                                  FNM_PATHNAME) == 0)) {
                         
                         if (includePath) {
                             files.append(filename);
                         } else {
                             files.append(entry->d_name);
                         }
                     }
                 }
 
                 entry = readdir(dir);
             }
             closedir(dir);
         }
     }
 #   endif
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void G3D::getFileOrDirListZip	(	const std::string &	path,
		const std::string &	prefix,
		Array< std::string > &	files,
		bool	wantFiles,
		bool	includePath
	)

static

                                                  {
 #if _HAVE_ZIP /* G3DFIX: Use ZIP-library only if defined */
     struct zip *z = zip_open( path.c_str(), ZIP_CHECKCONS, NULL );
 
     Set<std::string> fileSet;
 
     int count = zip_get_num_files( z );
     for( int i = 0; i < count; ++i ) {
         struct zip_stat info;
         zip_stat_init( &info );    // TODO: Docs unclear if zip_stat_init is required.
         zip_stat_index( z, i, ZIP_FL_NOCASE, &info );
         _zip_addEntry(path, prefix, info.name, fileSet, wantFiles, includePath);
     }
     
     zip_close( z );
     
     fileSet.getMembers(files);
 #else
     (void)path;
     (void)prefix;
     (void)files;
     (void)wantFiles;
     (void)includePath;
 #endif
 }

Here is the caller graph for this function:

void G3D::getFiles	(	const std::string &	filespec,
		Array< std::string > &	files,
		bool	includePath
	)

                                                    {
     
     determineFileOrDirList(filespec, files, true, includePath);
 }

Here is the call graph for this function:

void G3D::getG3DVersion ( std::string & s )

static

Called from init

                                  {
 
     const char* build = 
 #       ifdef G3D_64BIT
             "64-bit";
 #       else
             "32-bit";
 #       endif
 
     const char* debug =
 #       ifdef G3D_DEBUG
             " (Debug)";
 #       else
             "";
 #       endif
 
     char cstr[100];
     if ((G3D_VER % 100) != 0) {
         sprintf(cstr, "G3D Innovation Engine %d.%02d beta %d, %s%s",
                 G3D_VER / 10000,
                 (G3D_VER / 100) % 100,
                 G3D_VER % 100,
                 build,
                 debug);
     } else {
         sprintf(cstr, "G3D Innovation Engine %d.%02d, %s%s",
                 G3D_VER / 10000,
                 (G3D_VER / 100) % 100,
                 build,
                 debug);
     }
 
     s = cstr;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double G3D::halfPi ( )

inline

                        {
     return 1.57079633;
 }

Here is the caller graph for this function:

size_t G3D::hashCode ( ) const

                             {
         return static_cast<size_t>(x.bits() + ((int)y.bits() << 16));
     }

Here is the caller graph for this function:

int G3D::highestBit ( uint32 x )

Returnes the 0-based index of the highest 1 bit from the left. -1 means the number was 0.

[Based] on code by jukka.nosp@m.@lii.nosp@m.matta.nosp@m..org

                          {
     // Binary search.
     int base = 0;
 
     if (x & 0xffff0000)    {
         base = 16;
         x >>= 16;
     }
     if (x & 0x0000ff00) {
         base += 8;
         x >>= 8;
     }
     if (x & 0x000000f0) {
         base += 4;
         x >>= 4;
     }
     
     static const int lut[] = {-1,0,1,1,2,2,2,2,3,3,3,3,3,3,3,3};
     return base + lut[x];
 }

int G3D::iAbs ( int iValue )

inline

                              {
     return ( iValue >= 0 ? iValue : -iValue );
 }

int G3D::iCeil ( double fValue )

inline

                                  {
     return int(::ceil(fValue));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int G3D::iClamp	(	int	val,
		int	low,
		int	hi
	)

inline

Clamps the value to the range [low, hi] (inclusive)

                                             {
     debugAssert(low <= hi);
     if (val <= low) {
         return low;
     } else if (val >= hi) {
         return hi;
     } else {
         return val;
     }
 }

Here is the caller graph for this function:

int16 G3D::iClamp	(	int16	val,
		int16	low,
		int16	hi
	)

inline

                                                     {
     debugAssert(low <= hi);
     if (val <= low) {
         return low;
     } else if (val >= hi) {
         return hi;
     } else {
         return val;
     }
 }

Vector3int32 G3D::iFloor ( const Vector3 & v )

                                       {
     return Vector3int32(iFloor(v.x), iFloor(v.y), iFloor(v.z));
 }

Here is the call graph for this function:

int G3D::iFloor ( double fValue )

inline

                                   {
     return int(::floor(fValue));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int G3D::iMax	(	int	x,
		int	y
	)

inline

Deprecated:: use G3D::min

                               {
     return (x >= y) ? x : y;
 }

Here is the caller graph for this function:

int G3D::iMin	(	int	x,
		int	y
	)

inline

Deprecated:: use G3D::min

                               {
     return (x >= y) ? y : x;
 }

Here is the caller graph for this function:

int G3D::iMod3 ( int x )

inline

Computes x % 3.

                         {
     return x % 3;
 }

static void G3D::increaseBufferSize ( SOCKET sock )

static

Increases the send and receive sizes of a socket to 2 MB from 8k

                                             {
 
     // Increase the buffer size; the default (8192) is too easy to
     // overflow when the network latency is high.
     {
         uint32 val = 1024 * 1024 * 2;
         if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, 
                        (char*)&val, sizeof(val)) == SOCKET_ERROR) {
             Log::common()->printf("WARNING: Increasing socket "
                                  "receive buffer to %d failed.\n", val);
             Log::common()->println(socketErrorCode());
         }
 
         if (setsockopt(sock, SOL_SOCKET, SO_SNDBUF, 
                        (char*)&val, sizeof(val)) == SOCKET_ERROR) {
             Log::common()->printf("WARNING: Increasing socket "
                                  "send buffer to %d failed.\n", val);
             Log::common()->println(socketErrorCode());
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double G3D::inf ( )

This value should not be tested against directly, instead G3D::isNan() and G3D::isFinite() will return reliable results.

              {
     return std::numeric_limits<double>::infinity();
 }

Here is the caller graph for this function:

void G3D::initG3D ( const G3DSpecification & spec = G3DSpecification() )

Call from main() to initialize the G3D library state and register shutdown memory managers. This does not initialize OpenGL.

If you invoke initGLG3D, then it will automatically call initG3D. It is safe to call this function more than once–it simply ignores multiple calls.

See also: System, GLCaps, OSWindow, RenderDevice, initGLG3D.

void G3D::initMem ( )

inline

                       {
     // Putting the test here ensures that the system is always
     // initialized, even when globals are being allocated.
     static bool initialized = false;
     if (! initialized) {
         bufferpool = new BufferPool();
         initialized = true;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int G3D::iRandom	(	int	low,
		int	hi
	)

Returns a random number uniformly at random between low and hi (inclusive).

Deprecated:: Use Random::integer

                                {
     int r = iFloor(low + (high - low + 1) * (double)rand() / RAND_MAX);
     
     // There is a *very small* chance of generating
     // a number larger than high.
     if (r > high) {
         return high;
     } else {
         return r;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int G3D::iRound ( double fValue )

inline

Fast round to integer using the lrint routine. Typically 6x faster than casting to integer.

                                  {
     return lrint(fValue);
 }

Here is the caller graph for this function:

int G3D::iRound ( float f )

inline

Fast round to integer using the lrint routine. Typically 6x faster than casting to integer.

                            {
     return lrintf(f);
 }

static bool G3D::isClose ( const char c )

static

True if c is an open paren of some form

                                   {
     return c == ')' || c == ']' || c == '}';
 }

Here is the caller graph for this function:

static bool G3D::isContainerType ( Any::Type & t )

static

                                         {
     return (t == Any::ARRAY) || (t == Any::TABLE) || (t == Any::EMPTY_CONTAINER);
 }

Here is the caller graph for this function:

bool G3D::isDigit ( const unsigned char c )

inline

These standard C functions are renamed for clarity/naming conventions and to return bool, not int.

                                            {
     return isdigit(c) != 0;
 }

Here is the caller graph for this function:

bool G3D::isDirectory ( const std::string & filename )

                                             {
     struct _stat st;
     bool exists = _stat(filename.c_str(), &st) != -1;
     return exists && ((st.st_mode & S_IFDIR) != 0);
 }

Here is the caller graph for this function:

bool G3D::isEven ( int num )

inline

                             {
     return (num & 1) == 0;
 }

Here is the caller graph for this function:

bool G3D::isFinite ( double x )

inline

Returns true if the argument is a finite real number.

                                {
     return ! isNaN(x) && (x < G3D::inf()) && (x > -G3D::inf());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::isFinite ( float x )

inline

                               {
     return ! isNaN(x) && (x < G3D::finf()) && (x > -G3D::finf());
 }

Here is the call graph for this function:

int G3D::iSign ( int iValue )

inline

                               {
     return ( iValue > 0 ? + 1 : ( iValue < 0 ? -1 : 0 ) );
 }

Here is the caller graph for this function:

int G3D::iSign ( double fValue )

inline

                                  {
     return ( fValue > 0.0 ? + 1 : ( fValue < 0.0 ? -1 : 0 ) );
 }

int G3D::iSign ( float f )

inline

                           {
     return iSign((double)f);
 }

Here is the call graph for this function:

bool G3D::isLetter ( const unsigned char c )

inline

These standard C functions are renamed for clarity/naming conventions and to return bool, not int.

                                             {
     return isalpha(c) != 0;
 }

Here is the caller graph for this function:

bool G3D::isNaN ( double x )

Returns true if the argument is NaN (not a number). You can't use x == nan to test this because all comparisons against nan return false.

                      {
     // Wipe out the sign bit
     const uint64 y = *(uint64*)(&x) &
         ((uint64(BIN32(01111111,11111111,11111111,11111111)) << 32) +
          0xFFFFFFFF);
 
     // If the remaining number has all of the exponent bits set and atleast one
     // fraction bit set, then it is NaN
     return (y > (uint64(BIN32(01111111,11110000,00000000,00000000)) << 32));
 }

Here is the caller graph for this function:

bool G3D::isNaN ( float x )

                     {
     // Wipe out the sign bit
     const uint32 y = *(uint32*)(&x) & BIN32(01111111,11111111,11111111,11111111);
 
     // If the remaining number has all of the exponent bits set and atleast one
     // fraction bit set, then it is NaN
     return (y > 0x7F800000);
 }

bool G3D::isNaN ( int x )

inline

                          {
     (void)x;
     return false;
 }

bool G3D::isNaN ( uint64 x )

inline

                             {
     (void)x;
     return false;
 }

bool G3D::isNewline ( const unsigned char c )

inline

These standard C functions are renamed for clarity/naming conventions and to return bool, not int.

                                              {
     return (c == '\n') || (c == '\r');
 }

Here is the caller graph for this function:

static bool G3D::isNewline ( char c )

static

                               {
     return c == '\n' || c == '\r';
 }

template<class T >

bool G3D::isNull ( const ReferenceCountedPointer< T > & ptr )

                                                    {
     return ! ptr;
 }

template<class T >

bool G3D::isNull ( const T * ptr )

                           {
     return ptr == NULL;
 }

template<class T >

bool G3D::isNull ( const Pointer< T > & p )

                                  {
     return p.isNull();
 }

Here is the call graph for this function:

bool G3D::isOdd ( int num )

inline

                            {
     return (num & 1) == 1;
 }

Here is the caller graph for this function:

static bool G3D::isOpen ( const char c )

static

True if c is an open paren of some form

                                  {
     return c == '(' || c == '[' || c == '{';
 }

Here is the caller graph for this function:

bool G3D::isPow2 ( int num )

inline

True if num is a power of two.

                             {
     return ((num & -num) == num);
 }

Here is the caller graph for this function:

bool G3D::isPow2 ( uint64 num )

inline

                              {
     // See http://www.exploringbinary.com/ten-ways-to-check-if-an-integer-is-a-power-of-two-in-c/, method #9
     return ((x != 0) && !(x & (x - 1)));
 }

bool G3D::isPow2 ( uint32 x )

inline

                              {
     // See http://www.exploringbinary.com/ten-ways-to-check-if-an-integer-is-a-power-of-two-in-c/, method #9
     return ((x != 0) && !(x & (x - 1)));
 }

bool G3D::isQuote ( const unsigned char c )

inline

                                            {
     return (c == '\'') || (c == '\"');
 }

static bool G3D::isSeparator ( char c )

static

                                 {
     return c == ',' || c == ';';
 }

Here is the caller graph for this function:

bool G3D::isSlash ( const unsigned char c )

inline

                                            {
     return (c == '\\') || (c == '/');
 }

Here is the caller graph for this function:

bool G3D::isValidHeapPointer ( const void * x )

inline

Useful for debugging purposes.

                                               {
     #ifdef _MSC_VER
         return 
             (x != NULL) &&
             (x != (void*)0xcccccccc) && (x != (void*)0xdeadbeef) && (x != (void*)0xfeeefeee) &&
             (x != (void*)0xcdcdcdcd) && (x != (void*)0xabababab) && (x != (void*)0xfdfdfdfd);
     #else
         return x != NULL;
     #endif
 }

Here is the caller graph for this function:

bool G3D::isValidIdentifier ( const std::string & s )

Returns true if s is a valid C++ identifier

                                            {
     if (s.length() > 0 && (isLetter(s[0]) || s[0] == '_')) {   
         for (size_t i = 1; i < s.length() ; ++i) {
             if (!( isLetter(s[i]) || (s[i] == '_') || isDigit(s[i]) )) {
                 return false;
             }
         }
         return true;
     }
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::isValidPointer ( const void * x )

inline

Returns true if the pointer is likely to be a valid pointer (instead of an arbitrary number). Useful for debugging purposes.

                                           {
     #ifdef _MSC_VER
         return (x != NULL) &&
             (x != (void*)0xcccccccc) && (x != (void*)0xdeadbeef) && (x != (void*)0xfeeefeee) &&
             (x != (void*)0xcdcdcdcd) && (x != (void*)0xabababab) && (x != (void*)0xfdfdfdfd);
     #else
         return x != NULL;
     #endif
 }

Here is the caller graph for this function:

bool G3D::isWhiteSpace ( const unsigned char c )

inline

These standard C functions are renamed for clarity/naming conventions and to return bool, not int.

                                                 {
     return isspace(c) != 0;
 }

Here is the caller graph for this function:

static bool G3D::iswspace ( int ch )

static

34 { return (ch==' ' || ch=='\t' || ch=='\n' || ch=='\r'); }

Here is the caller graph for this function:

bool G3D::isZero ( ) const

                         {
         return (x == 0) && (y == 0);
     }

bool G3D::isZipfile ( const std::string & filename )

                                           {
 
     FILE* f = fopen(filename.c_str(), "r");
     if (f == NULL) {
         return false;
     }
     uint8 header[4];
     (void)fread(header, 4, 1, f);
     
     const uint8 zipHeader[4] = {0x50, 0x4b, 0x03, 0x04};
     for (int i = 0; i < 4; ++i) {
         if (header[i] != zipHeader[i]) {
             fclose(f);
             return false;
         }
     }
 
     fclose(f);
     return true;
 }

int G3D::iWrap	(	int	val,
		int	hi
	)

inline

Wraps the value to the range [0, hi) (exclusive on the high end). This is like the clock arithmetic produced by % (modulo) except the result is guaranteed to be positive.

                                   {
     if (val < 0) {
         return ((val % hi) + hi) % hi;
     } else {
         return val % hi;
     }
 }

Here is the caller graph for this function:

static void G3D::l32f_to_rgb8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                             {
     int srcIndex = 0;
     int dstByteOffset = 0;
     unorm8* dst = static_cast<unorm8*>(dstBytes[0]);
     const float* src = static_cast<const float*>(srcBytes[0]);
 
     for (int y = 0; y < srcHeight; ++y) {
         if (invertY) {
             srcIndex = srcWidth * (srcHeight - y - 1);
         }
         
         for (int x = 0; x < srcWidth; ++x, ++srcIndex, dstByteOffset += 3) {
             Color3unorm8&  d = *reinterpret_cast<Color3unorm8*>(dst + dstByteOffset);
             const float s = src[srcIndex];
             const unorm8 c(s);
             d = Color3unorm8(c, c, c);
         }
     } 
 }

static void G3D::l8_to_rgb8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                           {
     (void)bayerAlg;
     (void)dstRowPadBits;
     unorm8* dst = static_cast<unorm8*>(dstBytes[0]);
     const unorm8* src = static_cast<const unorm8*>(srcBytes[0]);
     for (int y = 0; y < srcHeight; ++y) {
         for (int x = 0; x < srcWidth; ++x) {
             int i = (invertY) ? ((srcHeight-1-y) * srcWidth +x) : (y * srcWidth + x);
             int i3 = i * 3;
 
             dst[i3 + 0] = src[i]; 
             dst[i3 + 1] = src[i]; 
             dst[i3 + 2] = src[i]; 
         }
     }
 }

float G3D::length ( float v )

inline

                              {
     return ::fabsf(v);
 }

Here is the caller graph for this function:

float G3D::length ( const Vector2 & v )

inline

                                       {
     return v.length();
 }

Here is the call graph for this function:

float G3D::length ( const Vector3 & v )

inline

                                       {
     return v.magnitude();
 }

Here is the call graph for this function:

float G3D::length ( const Vector4 & v )

inline

                                       {
     return v.length();
 }

Here is the call graph for this function:

Vector2 G3D::lerp	(	const Vector2 &	v1,
		const Vector2 &	v2,
		float	f
	)

inline

                                                                    {
     return v1.lerp(v2, f);
 }

Here is the call graph for this function:

Vector3 G3D::lerp	(	const Vector3 &	v1,
		const Vector3 &	v2,
		float	f
	)

inline

                                                                    {
     return v1.lerp(v2, f);
 }

Here is the call graph for this function:

Vector4 G3D::lerp	(	const Vector4 &	v1,
		const Vector4 &	v2,
		float	f
	)

inline

                                                                    {
     return v1.lerp(v2, f);
 }

Here is the call graph for this function:

Color1 G3D::lerp	(	const Color1 &	v1,
		const Color1 &	v2,
		float	f
	)

inline

                                                                 {
     return v1.lerp(v2, f);
 }

Here is the call graph for this function:

Color3 G3D::lerp	(	const Color3 &	v1,
		const Color3 &	v2,
		float	f
	)

inline

                                                                 {
     return v1.lerp(v2, f);
 }

Here is the call graph for this function:

Color4 G3D::lerp	(	const Color4 &	v1,
		const Color4 &	v2,
		float	f
	)

inline

                                                                 {
     return v1.lerp(v2, f);
 }

Here is the call graph for this function:

double G3D::lerp	(	double	a,
		double	b,
		double	f
	)

inline

Returns a + (b - a) * f;

                                                  {
     return a + (b - a) * f;
 }

Here is the caller graph for this function:

float G3D::lerp	(	float	a,
		float	b,
		float	f
	)

inline

                                              {
     return a + (b - a) * f;
 }

std::string G3D::license ( )

G3D, SDL, and IJG libraries require license documentation to be distributed with your program. This generates the string that must appear in your documentation. Your program can be commercial, closed-source under any license you want.

Deprecated:: Use System::license

                     {
     return format(
 
 "This software is based in part on the PNG Reference Library which is\n"
 "Copyright (c) 2004 Glenn Randers-Pehrson\n\n"
 "This software is based in part on the work of the Independent JPEG Group.\n\n"
 "This software is based on part on the FFmpeg libavformat and libavcodec libraries\n" 
 "(\"FFmpeg\", http://ffmpeg.mplayerhq.hu), which are included under the terms of the\n" 
 "GNU Lesser General Public License (LGPL), (http://www.gnu.org/copyleft/lesser.html).\n\n"
 "%s"
 "This program uses the G3D Library (http://g3d.sf.net), which\n"
 "is licensed under the \"Modified BSD\" Open Source license.  The G3D library\n"
 "source code is Copyright � 2000-2011, Morgan McGuire, All rights reserved.\n"
 "This program uses The OpenGL Extension Wrangler Library, which \n"
 "is licensed under the \"Modified BSD\" Open Source license.  \n"
 "The OpenGL Extension Wrangler Library source code is\n"
 "Copyright (C) 2002-2008, Milan Ikits <milan ikits[]ieee org>\n"
 "Copyright (C) 2002-2008, Marcelo E. Magallon <mmagallo[]debian org>\n"
 "Copyright (C) 2002, Lev Povalahev\n"
 "All rights reserved.\n\n"
 "The Modified BSD license is below, and requires the following statement:\n"
 "\n"
 "Redistribution and use in source and binary forms, with or without \n"
 "modification, are permitted provided that the following conditions are met:\n"
 "\n"
 "* Redistributions of source code must retain the above copyright notice, \n"
 "  this list of conditions and the following disclaimer.\n"
 "* Redistributions in binary form must reproduce the above copyright notice, \n"
 "  this list of conditions and the following disclaimer in the documentation \n"
 "  and/or other materials provided with the distribution.\n"
 "* The name of the author may be used to endorse or promote products \n"
 "  derived from this software without specific prior written permission.\n"
 "\n"
 "THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" \n"
 "AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE \n"
 "IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n"
 "ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE \n"
 "LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR \n"
 "CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF \n"
 "SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n"
 "INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n"
 "CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n"
 "ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF\n"
 "THE POSSIBILITY OF SUCH DAMAGE.\n"
 "\n\n"
 "G3D VERSION %d\n", 
 
 #ifdef G3D_WINDOWS
     "" // Win32 doesn't use SDL
 #else
     "This software uses the Simple DirectMedia Layer library (\"SDL\",\n"
     "http://www.libsdl.org), which is included under the terms of the\n"
     "GNU Lesser General Public License, (http://www.gnu.org/copyleft/lesser.html).\n\n"
 #endif
 ,
 G3D_VER);
 }

Here is the call graph for this function:

template<class XType , class YType >

YType G3D::linearSpline	(	double	x,
		const XType *	controlX,
		const YType *	controlY,
		int	numControl
	)

Interpolates a property according to a piecewise linear spline. This provides C0 continuity but the derivatives are not smooth.

Example: const double times[] = {MIDNIGHT, SUNRISE - HOUR, SUNRISE, SUNRISE + sunRiseAndSetTime / 4, SUNRISE + sunRiseAndSetTime, SUNSET - sunRiseAndSetTime, SUNSET - sunRiseAndSetTime / 2, SUNSET, SUNSET + HOUR/2, DAY}; const Color3 color[] = {Color3(0, .0, .1), Color3(0, .0, .1), Color3::black(), Color3::black(), Color3::white() * .25, Color3::white() * .25, Color3(.5, .2, .2), Color3(.05, .05, .1), Color3(0, .0, .1), Color3(0, .0, .1)}; ambient = linearSpline(time, times, color, 10);

See also G3D::Spline

Parameters

x	The spline is a function of x; this is the sample to choose.
controlX	controlX[i], controlY[i] is a control points. It is assumed that controlX are strictly increasing. XType must support the "<" operator and a subtraction operator that returns a number.
controlY	YType must support multiplication and addition.
numControl	The number of control points.

                                                                                            {
     debugAssert(numControl >= 1);
 
     // Off the beginning
     if ((numControl == 1) || (x < controlX[0])) {
         return controlY[0];
     }
 
     for (int i = 1; i < numControl; ++i) {
         if (x < controlX[i]) {
             const double alpha = (double)(controlX[i] - x) / (controlX[i] - controlX[i - 1]);
             return controlY[i] * (1 - alpha) + controlY[i - 1] * alpha;
         }
     }
 
     // Off the end
     return controlY[numControl - 1];
 }

Color3 G3D::log ( const Color3 & c )

inline

Computes the log of each component. Useful for inverting the monitor gamma function or simulating perceptual response.

                                    {
     return Color3(::logf(c.r), ::logf(c.g), ::logf(c.b));
 }

Quat G3D::log ( const Quat & q )

inline

                                {
     return q.log();
 }

Here is the call graph for this function:

double G3D::log2 ( double x )

inline

                              {
     return ::log(x) * 1.442695;
 }

Here is the caller graph for this function:

float G3D::log2 ( float x )

inline

                            {
     return ::logf(x) * 1.442695f;
 }

double G3D::log2 ( int x )

inline

                           {
     return log2((double)x);
 }

Here is the call graph for this function:

void G3D::logLazyPrintf	(	const char *	fmt,
			...
	)

Does not flush the buffer; follow up with a logPrintf to force the flush.

                                          {
     va_list arg_list;
     va_start(arg_list, fmt);
     Log::common()->lazyvprintf(fmt, arg_list);
     va_end(arg_list);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::logPrintf	(	const char *	fmt,
			...
	)

Prints to the common system log, log.txt, which is usually in the working directory of the program. If your disk is not writable or is slow, it will attempt to write to "c:/tmp/log.txt" or "c:/temp/log.txt" on Windows systems instead.

Unlike printf or debugPrintf, this function guarantees that all output is committed before it returns. This is very useful for debugging a crash, which might hide the last few buffered print statements otherwise.

Many G3D routines write useful warnings and debugging information to the system log, which makes it a good first place to go when tracking down a problem.

                                      {
     va_list arg_list;
     va_start(arg_list, fmt);
     Log::common()->vprintf(fmt, arg_list);
     va_end(arg_list);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void G3D::logSocketInfo ( const SOCKET & sock )

static

                                               {
     uint32 val;
     socklen_t sz = 4;
 
     getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char*)&val, (socklen_t*)&sz);
     logPrintf("SOL_SOCKET/SO_RCVBUF = %d\n", val);
 
     getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char*)&val, (socklen_t*)&sz);
     logPrintf("SOL_SOCKET/SO_SNDBUF = %d\n", val);
 
     // Note: timeout = 0 means no timeout
     getsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char*)&val, (socklen_t*)&sz);
     logPrintf("SOL_SOCKET/SO_RCVTIMEO = %d\n", val);
 
     getsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (char*)&val, (socklen_t*)&sz);
     logPrintf("SOL_SOCKET/SO_SNDTIMEO = %d\n", val);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

                                                   {
         return Vector2int32(iMax(x, v.x), iMax(y, v.y));
     }

Here is the call graph for this function:

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

                                                   {
         return Vector3int16(std::max(x, v.x), std::max(y, v.y), std::max(z, v.z));
     }

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

                                                   {
         return Vector2int16(iMax(x, v.x), iMax(y, v.y));
     }

Here is the call graph for this function:

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

                                                   {
         return Vector3int32(iMax(x, v.x), iMax(y, v.y), iMax(z, v.z));
     }

Here is the call graph for this function:

Vector2 G3D::max	(	const Vector2 &	v1,
		const Vector2 &	v2
	)

inline

                                                          {
     return v1.max(v2);
 }

Here is the call graph for this function:

Vector3 G3D::max	(	const Vector3 &	v1,
		const Vector3 &	v2
	)

inline

                                                          {
     return v1.max(v2);
 }

Here is the call graph for this function:

Vector4 G3D::max	(	const Vector4 &	v1,
		const Vector4 &	v2
	)

inline

                                                          {
     return v1.max(v2);
 }

Here is the call graph for this function:

Color3 G3D::max	(	const Color3 &	v1,
		const Color3 &	v2
	)

inline

                                                       {
     return v1.max(v2);
 }

Here is the call graph for this function:

Color4 G3D::max	(	const Color4 &	v1,
		const Color4 &	v2
	)

inline

                                                       {
     return v1.max(v2);
 }

Here is the call graph for this function:

template<class T >

T G3D::max	(	const T &	x,
		const T &	y
	)

inline

                                      {
     return std::max<T>(x, y);
 }

template<class T >

T G3D::max	(	const T &	x,
		const T &	y,
		const T &	z
	)

inline

                                                  {
     return std::max<T>(std::max<T>(x, y), z);
 }

template<class T >

T G3D::max	(	const T &	x,
		const T &	y,
		const T &	z,
		const T &	w
	)

inline

                                                              {
     return std::max<T>(std::max<T>(x, y), std::max<T>(z, w));
 }

size_t G3D::maxNotNPOS	(	size_t	i,
		size_t	j
	)

inline

Returns the larger string index, ignoring std::string::npos.

                                              {
     if (i == std::string::npos) {
         return j;
     } else if (j == std::string::npos) {
         return i;
     } else {
         return max(i, j);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::md5_append	(	md5_state_t *	pms,
		const md5_byte_t *	data,
		int	nbytes
	)

static

 {
     const md5_byte_t *p = data;
     int left = nbytes;
     int offset = (pms->count[0] >> 3) & 63;
     md5_word_t nbits = (md5_word_t)(nbytes << 3);
 
     if (nbytes <= 0)
     return;
 
     /* Update the message length. */
     pms->count[1] += nbytes >> 29;
     pms->count[0] += nbits;
     if (pms->count[0] < nbits)
     pms->count[1]++;
 
     /* Process an initial partial block. */
     if (offset) {
     int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
 
     memcpy(pms->buf + offset, p, copy);
     if (offset + copy < 64)
         return;
     p += copy;
     left -= copy;
     md5_process(pms, pms->buf);
     }
 
     /* Process full blocks. */
     for (; left >= 64; p += 64, left -= 64)
     md5_process(pms, p);
 
     /* Process a final partial block. */
     if (left)
     memcpy(pms->buf, p, left);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::md5_finish	(	md5_state_t *	pms,
		md5_byte_t	digest[16]
	)

static

 {
     static const md5_byte_t pad[64] = {
     0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
     };
     md5_byte_t data[8];
     int i;
 
     /* Save the length before padding. */
     for (i = 0; i < 8; ++i)
     data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
     /* Pad to 56 bytes mod 64. */
     md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
     /* Append the length. */
     md5_append(pms, data, 8);
     for (i = 0; i < 16; ++i)
     digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::md5_init ( md5_state_t * pms )

static

 {
     pms->count[0] = pms->count[1] = 0;
     pms->abcd[0] = 0x67452301;
     pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
     pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
     pms->abcd[3] = 0x10325476;
 }

Here is the caller graph for this function:

static void G3D::md5_process	(	md5_state_t *	pms,
		const md5_byte_t *	data
	)

static

 {
     md5_word_t
     a = pms->abcd[0], b = pms->abcd[1],
     c = pms->abcd[2], d = pms->abcd[3];
     md5_word_t t;
 #if BYTE_ORDER > 0
     /* Define storage only for big-endian CPUs. */
     md5_word_t X[16];
 #else
     /* Define storage for little-endian or both types of CPUs. */
     md5_word_t xbuf[16];
     const md5_word_t *X;
 #endif
 
     {
 #if BYTE_ORDER == 0
     /*
      * Determine dynamically whether this is a big-endian or
      * little-endian machine, since we can use a more efficient
      * algorithm on the latter.
      */
     static const int w = 1;
 
     if (*((const md5_byte_t *)&w)) /* dynamic little-endian */
 #endif
 #if BYTE_ORDER <= 0        /* little-endian */
     {
         /*
          * On little-endian machines, we can process properly aligned
          * data without copying it.
          */
         if (!((data - (const md5_byte_t *)0) & 3)) {
         /* data are properly aligned */
         X = (const md5_word_t *)data;
         } else {
         /* not aligned */
         memcpy(xbuf, data, 64);
         X = xbuf;
         }
     }
 #endif
 #if BYTE_ORDER == 0
     else            /* dynamic big-endian */
 #endif
 #if BYTE_ORDER >= 0        /* big-endian */
     {
         /*
          * On big-endian machines, we must arrange the bytes in the
          * right order.
          */
         const md5_byte_t *xp = data;
         int i;
 
 #  if BYTE_ORDER == 0
         X = xbuf;        /* (dynamic only) */
 #  else
 #    define xbuf X        /* (static only) */
 #  endif
         for (i = 0; i < 16; ++i, xp += 4)
         xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
     }
 #endif
     }
 
 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
 
     /* Round 1. */
     /* Let [abcd k s i] denote the operation
        a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
 #define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
 #define SET(a, b, c, d, k, s, Ti)\
   t = a + F(b,c,d) + X[k] + Ti;\
   a = ROTATE_LEFT(t, s) + b
     /* Do the following 16 operations. */
     SET(a, b, c, d,  0,  7,  T1);
     SET(d, a, b, c,  1, 12,  T2);
     SET(c, d, a, b,  2, 17,  T3);
     SET(b, c, d, a,  3, 22,  T4);
     SET(a, b, c, d,  4,  7,  T5);
     SET(d, a, b, c,  5, 12,  T6);
     SET(c, d, a, b,  6, 17,  T7);
     SET(b, c, d, a,  7, 22,  T8);
     SET(a, b, c, d,  8,  7,  T9);
     SET(d, a, b, c,  9, 12, T10);
     SET(c, d, a, b, 10, 17, T11);
     SET(b, c, d, a, 11, 22, T12);
     SET(a, b, c, d, 12,  7, T13);
     SET(d, a, b, c, 13, 12, T14);
     SET(c, d, a, b, 14, 17, T15);
     SET(b, c, d, a, 15, 22, T16);
 #undef SET
 
      /* Round 2. */
      /* Let [abcd k s i] denote the operation
           a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
 #define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
 #define SET(a, b, c, d, k, s, Ti)\
   t = a + G(b,c,d) + X[k] + Ti;\
   a = ROTATE_LEFT(t, s) + b
      /* Do the following 16 operations. */
     SET(a, b, c, d,  1,  5, T17);
     SET(d, a, b, c,  6,  9, T18);
     SET(c, d, a, b, 11, 14, T19);
     SET(b, c, d, a,  0, 20, T20);
     SET(a, b, c, d,  5,  5, T21);
     SET(d, a, b, c, 10,  9, T22);
     SET(c, d, a, b, 15, 14, T23);
     SET(b, c, d, a,  4, 20, T24);
     SET(a, b, c, d,  9,  5, T25);
     SET(d, a, b, c, 14,  9, T26);
     SET(c, d, a, b,  3, 14, T27);
     SET(b, c, d, a,  8, 20, T28);
     SET(a, b, c, d, 13,  5, T29);
     SET(d, a, b, c,  2,  9, T30);
     SET(c, d, a, b,  7, 14, T31);
     SET(b, c, d, a, 12, 20, T32);
 #undef SET
 
      /* Round 3. */
      /* Let [abcd k s t] denote the operation
           a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
 #define H(x, y, z) ((x) ^ (y) ^ (z))
 #define SET(a, b, c, d, k, s, Ti)\
   t = a + H(b,c,d) + X[k] + Ti;\
   a = ROTATE_LEFT(t, s) + b
      /* Do the following 16 operations. */
     SET(a, b, c, d,  5,  4, T33);
     SET(d, a, b, c,  8, 11, T34);
     SET(c, d, a, b, 11, 16, T35);
     SET(b, c, d, a, 14, 23, T36);
     SET(a, b, c, d,  1,  4, T37);
     SET(d, a, b, c,  4, 11, T38);
     SET(c, d, a, b,  7, 16, T39);
     SET(b, c, d, a, 10, 23, T40);
     SET(a, b, c, d, 13,  4, T41);
     SET(d, a, b, c,  0, 11, T42);
     SET(c, d, a, b,  3, 16, T43);
     SET(b, c, d, a,  6, 23, T44);
     SET(a, b, c, d,  9,  4, T45);
     SET(d, a, b, c, 12, 11, T46);
     SET(c, d, a, b, 15, 16, T47);
     SET(b, c, d, a,  2, 23, T48);
 #undef SET
 
      /* Round 4. */
      /* Let [abcd k s t] denote the operation
           a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
 #define SET(a, b, c, d, k, s, Ti)\
   t = a + I(b,c,d) + X[k] + Ti;\
   a = ROTATE_LEFT(t, s) + b
      /* Do the following 16 operations. */
     SET(a, b, c, d,  0,  6, T49);
     SET(d, a, b, c,  7, 10, T50);
     SET(c, d, a, b, 14, 15, T51);
     SET(b, c, d, a,  5, 21, T52);
     SET(a, b, c, d, 12,  6, T53);
     SET(d, a, b, c,  3, 10, T54);
     SET(c, d, a, b, 10, 15, T55);
     SET(b, c, d, a,  1, 21, T56);
     SET(a, b, c, d,  8,  6, T57);
     SET(d, a, b, c, 15, 10, T58);
     SET(c, d, a, b,  6, 15, T59);
     SET(b, c, d, a, 13, 21, T60);
     SET(a, b, c, d,  4,  6, T61);
     SET(d, a, b, c, 11, 10, T62);
     SET(c, d, a, b,  2, 15, T63);
     SET(b, c, d, a,  9, 21, T64);
 #undef SET
 
      /* Then perform the following additions. (That is increment each
         of the four registers by the value it had before this block
         was started.) */
     pms->abcd[0] += a;
     pms->abcd[1] += b;
     pms->abcd[2] += c;
     pms->abcd[3] += d;
 }

Here is the caller graph for this function:

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

                                                   {
         return Vector2int32(iMin(x, v.x), iMin(y, v.y));
     }

Here is the call graph for this function:

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

                                                   {
         return Vector3int16(std::min(x, v.x), std::min(y, v.y), std::min(z, v.z));
     }

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

                                                   {
         return Vector2int16(iMin(x, v.x), iMin(y, v.y));
     }

Here is the call graph for this function:

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

                                                   {
         return Vector3int32(iMin(x, v.x), iMin(y, v.y), iMin(z, v.z));
     }

Here is the call graph for this function:

Vector2 G3D::min	(	const Vector2 &	v1,
		const Vector2 &	v2
	)

inline

                                                          {
     return v1.min(v2);
 }

Here is the call graph for this function:

Vector3 G3D::min	(	const Vector3 &	v1,
		const Vector3 &	v2
	)

inline

                                                          {
     return v1.min(v2);
 }

Here is the call graph for this function:

Vector4 G3D::min	(	const Vector4 &	v1,
		const Vector4 &	v2
	)

inline

                                                          {
     return v1.min(v2);
 }

Here is the call graph for this function:

Color3 G3D::min	(	const Color3 &	v1,
		const Color3 &	v2
	)

inline

                                                       {
     return v1.min(v2);
 }

Here is the call graph for this function:

Color4 G3D::min	(	const Color4 &	v1,
		const Color4 &	v2
	)

inline

                                                       {
     return v1.min(v2);
 }

Here is the call graph for this function:

template<class T >

T G3D::min	(	const T &	x,
		const T &	y
	)

inline

                                      {
     return std::min<T>(x, y);
 }

template<class T >

T G3D::min	(	const T &	x,
		const T &	y,
		const T &	z
	)

inline

                                                  {
     return std::min<T>(std::min<T>(x, y), z);
 }

template<class T >

T G3D::min	(	const T &	x,
		const T &	y,
		const T &	z,
		const T &	w
	)

inline

                                                              {
     return std::min<T>(std::min<T>(x, y), std::min<T>(z, w));
 }

void G3D::msgBox	(	const std::string &	message,
		const std::string &	title = `"Message"`
	)

Displays a GUI prompt with "Ok" as the only choice.

                             {
 
     const char *choice[] = {"Ok"};
     prompt(title.c_str(), message.c_str(), choice, 1, true); 
 }

Here is the call graph for this function:

Matrix4 G3D::mul	(	const Matrix4 &	a,
		const Matrix4 &	b
	)

inline

                                                        {
     return a * b;
 }

Vector4 G3D::mul	(	const Matrix4 &	m,
		const Vector4 &	v
	)

inline

                                                        {
     return m * v;
 }

Vector3 G3D::mul	(	const Matrix3 &	m,
		const Vector3 &	v
	)

inline

                                                        {
     return m * v;
 }

Matrix3 G3D::mul	(	const Matrix3 &	a,
		const Matrix3 &	b
	)

inline

                                                        {
     return a * b;
 }

float G3D::mul	(	float	a,
		float	b
	)

inline

a * b (for DirectX/Cg support)

                                    {
     return a * b;
 }

Here is the caller graph for this function:

void G3D::multiplyAndCarry	(	const uint64 &	_a,
		const uint64 &	_b,
		uint64 &	carry,
		uint64 &	result
	)

Multiplies two unsigned 64-bit integers, placing the result into one 64-bit int and the overflow into another.

                                                                                          {
 
     // Break each number into 4 32-bit chunks. Since we are using uints, right-shifting will fill with zeros.
     // This eliminates the need to and with 0xFFFFFFFF.
     uint32 a [2] = {static_cast<uint32>(_a & 0xFFFFFFFF), static_cast<uint32>(_a >> 32)};
     uint32 b [2] = {static_cast<uint32>(_b & 0xFFFFFFFF), static_cast<uint32>(_b >> 32)};
 
     uint64 prod [2][2];
     for(int i = 0; i < 2; ++i) {
         for(int j = 0; j < 2; ++j) {
             prod[i][j] = uint64(a[i]) * b[j];
         }
     }
 
     // The product of the low bits of a and b will always fit into the result
     result = prod[0][0];
 
     // The product of the high bits of a and b will never fit into the result
     carry = prod[1][1];
 
     // The high 32 bits of prod[0][1] and prod[1][0] will never fit into the result
     carry += prod[0][1] >> 32;
     carry += prod[1][0] >> 32;
 
     uint64 tmp;
     addAndCarry(result, (prod[0][1] << 32), tmp, result);
     carry += tmp;
     addAndCarry(result, (prod[1][0] << 32), tmp, result);
     carry += tmp;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double G3D::nan ( )

This value should not be tested against directly, instead G3D::isNan() and G3D::isFinite() will return reliable results.

              {
     // double is a standard type and should have quiet NaN
     return std::numeric_limits<double>::quiet_NaN();
 }

Here is the caller graph for this function:

static bool G3D::needsQuotes ( const std::string & s )

static

                                             {
     if (! isLetter(s[0]) && (s[0] != '_')) {
         return true;
     }
 
     for (int i = 0; i < (int)s.length(); ++i) {
         char c = s[i];
         
         // peek character
         char p = (i == (int)s.length() - 1) ? '_' : s[i + 1];
 
         // Identify separators
         if ((c == '-' && p == '>') ||
             (c == ':' && p == ':')) {            
             // Skip over this symbol
             ++i;
             continue;
         }
 
         if (! isDigit(c) && ! isLetter(c) & (c != '.')) {
             // This is an illegal character for an identifier, so we need quotes
             return true;
         }
     }
 
     return false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::nonZero ( ) const

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

Vector2 G3D::normalize ( const Vector2 & v )

inline

                                            {
     return v / v.length();
 }

Here is the call graph for this function:

Vector3 G3D::normalize ( const Vector3 & v )

inline

                                            {
     return v / v.magnitude();
 }

Here is the call graph for this function:

Vector4 G3D::normalize ( const Vector4 & v )

inline

                                            {
     return v / v.length();
 }

Here is the call graph for this function:

float G3D::normalize ( float v )

inline

v / v (for DirectX/Cg support)

                                 {
     return v / v;
 }

template<class T >

bool G3D::notNull ( const ReferenceCountedPointer< T > & ptr )

                                                     {
     return (bool)ptr;
 }

template<class T >

bool G3D::notNull ( const T * ptr )

                            {
     return ptr != NULL;
 }

template<class T >

bool G3D::notNull ( const Pointer< T > & p )

                                   {
     return ! p.isNull();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static unorm8 G3D::one ( )

static

                         {
         return fromBits(255);
     }

Here is the call graph for this function:

static unorm16 G3D::one ( )

static

                          {
         return fromBits(65535);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

G3D::operator double ( ) const

                             {
         return double(m_bits) * (1.0 / 65535.0);
     }

G3D::operator float ( ) const

Returns a number on [0.0f, 1.0f]

                            {
         return float(m_bits) * (1.0f / 65535.0f);
     }

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

inline

                                                                   {
         return ((int32*)this)[0] != ((int32*)&rkVector)[0];
     }

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

inline

                                                              {
         return !(*this == other);
     }

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

inline

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

bool G3D::operator!= ( const unorm8 other ) const

                                               {
         return m_bits != other.m_bits;
     }

bool G3D::operator!= ( const unorm16 other ) const

                                                {
         return m_bits != other.m_bits;
     }

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

inline

                                                                 {
         return ((int32*)this)[0] != ((int32*)&rkVector)[0];
     }

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

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

bool G3D::operator!=	(	const NetAddress &	a,
		const NetAddress &	b
	)

inline

                                                                  {
     return !(a == b);
 }

Vector3int32 G3D::operator& ( int16 i ) const

                                           {
         return Vector3int16(x & i, y & i, z & i);
     }

Vector3int16 G3D::operator& ( const Vector3int16 & v ) const

                                                         {
         return Vector3int16(x & v.x, y & v.y, z & v.z);
     }

Vector2int32 G3D::operator* ( const Vector2int32 & other ) const

inline

                                                                    {
         return Vector2int32(x * other.x, y * other.y);
     }

Vector2int16 G3D::operator* ( const Vector2int16 & other ) const

inline

                                                                    {
         return Vector2int16(x * other.x, y * other.y);
     }

Vector3int16 G3D::operator* ( const Vector3int16 & other ) const

inline

                                                                    {
         return Vector3int16(x * other.x, y * other.y, z * other.z);
     }

Vector3int32 G3D::operator* ( const Vector3int32 & other ) const

inline

                                                                    {
         return Vector3int32(x * other.x, y * other.y, z * other.z);
     }

Vector3int32 G3D::operator* ( const int i ) const

inline

                                          {
         return unorm16(uint16(m_bits * i));
     }

Color4 G3D::operator*	(	const Color3 &	c3,
		const Color4 &	c4
	)

inline

Extends the c3 with alpha = 1.0

                                                             {
     return Color4(c3.r * c4.r, c3.g * c4.g, c3.b * c4.b, c4.a);
 }

Vector2 G3D::operator*	(	double	s,
		const Vector2 &	v
	)

inline

                                                      {
     return v * (float)s;
 }

Vector2 G3D::operator*	(	float	s,
		const Vector2 &	v
	)

inline

                                                     {
     return v * s;
 }

G3D::Color3 G3D::operator*	(	float	s,
		const G3D::Color3 &	c
	)

inline

                                                          {
     return c * s;
 }

Vector2 G3D::operator*	(	int	s,
		const Vector2 &	v
	)

inline

                                                   {
     return v * (float)s;
 }

G3D::Color3 G3D::operator*	(	G3D::Color1 &	s,
		const G3D::Color3 &	c
	)

inline

                                                               {
     return c * s.value;
 }

G3D::Color3 G3D::operator*	(	const G3D::Color3 &	c,
		G3D::Color1 &	s
	)

inline

                                                               {
     return c * s.value;
 }

Color4 G3D::operator*	(	float	fScalar,
		const Color4 &	other
	)

inline

                                                              {
     return Color4(fScalar * other.r, fScalar * other.g,
                   fScalar * other.b, fScalar * other.a);
 }

Matrix3 G3D::operator*	(	double	fScalar,
		const Matrix3 &	rkMatrix
	)

scalar * matrix

                                                             {
     Matrix3 kProd;
 
     for (int iRow = 0; iRow < 3; ++iRow) {
         for (int iCol = 0; iCol < 3; ++iCol) {
             kProd[iRow][iCol] = (float)fScalar * rkMatrix.elt[iRow][iCol];
         }
     }
 
     return kProd;
 }

Matrix3 G3D::operator*	(	float	fScalar,
		const Matrix3 &	rkMatrix
	)

                                                            {
     return (double)fScalar * rkMatrix;
 }

Vector3 G3D::operator*	(	const Vector3 &	rkPoint,
		const Matrix3 &	rkMatrix
	)

inline

v * M == M.transpose() * v

                                                                            {
     Vector3 kProd;
 
     for (int r = 0; r < 3; ++r) {
         kProd[r] =
             rkPoint[0] * rkMatrix.elt[0][r] +
             rkPoint[1] * rkMatrix.elt[1][r] +
             rkPoint[2] * rkMatrix.elt[2][r];
     }
 
     return kProd;
 }

Matrix3 G3D::operator*	(	int	fScalar,
		const Matrix3 &	rkMatrix
	)

                                                          {
     return (double)fScalar * rkMatrix;
 }

G3D::Vector3 G3D::operator*	(	float	s,
		const G3D::Vector3 &	v
	)

inline

                                                           {
     return v * s;
 }

G3D::Vector3 G3D::operator*	(	double	s,
		const G3D::Vector3 &	v
	)

inline

                                                            {
     return v * (float)s;
 }

G3D::Vector3 G3D::operator*	(	int	s,
		const G3D::Vector3 &	v
	)

inline

                                                         {
     return v * (float)s;
 }

G3D::Quat G3D::operator*	(	double	s,
		const G3D::Quat &	q
	)

inline

                                                      {
     return q * (float)s;
 }

G3D::Quat G3D::operator*	(	float	s,
		const G3D::Quat &	q
	)

inline

[Based] on Watt & Watt, page 360

                                                     {
     return q * s;
 }

Vector3int16& G3D::operator*= ( const Vector3int16 & other )

inline

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

Vector2int32& G3D::operator*= ( const Vector2int32 & other )

inline

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

Vector2int16& G3D::operator*= ( const Vector2int16 & other )

inline

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

Vector3int32& G3D::operator*= ( const Vector3int32 & other )

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

unorm8 & G3D::operator*= ( const int i )

                                      {
         m_bits *= i;
         return *this;
     }

Vector2int32 G3D::operator+ ( const Vector2int32 & other ) const

inline

                                                                    {
         return Vector2int32(x + other.x, y + other.y);
     }

Vector2int16 G3D::operator+ ( const Vector2int16 & other ) const

inline

                                                                    {
         return Vector2int16(x + other.x, y + other.y);
     }

Vector3int16 G3D::operator+ ( const Vector3int16 & other ) const

inline

                                                                    {
         return Vector3int16(x + other.x, y + other.y, z + other.z);
     }

Vector3int32 G3D::operator+ ( const Vector3int32 & other ) const

inline

                                                                    {
         return Vector3int32(x + other.x, y + other.y, z + other.z);
     }

unorm8 G3D::operator+ ( const unorm8 other ) const

                                                {
         return unorm8(uint8(m_bits + other.m_bits));
     }

unorm16 G3D::operator+ ( const unorm16 other ) const

                                                  {
         return unorm16(uint16(m_bits + other.m_bits));
     }

Vector2int32& G3D::operator+= ( const Vector2int32 & other )

inline

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

Vector2int16& G3D::operator+= ( const Vector2int16 & other )

inline

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

Vector3int16& G3D::operator+= ( const Vector3int16 & other )

inline

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

Vector3int32& G3D::operator+= ( const Vector3int32 & other )

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

unorm8& G3D::operator+= ( const unorm8 other )

                                            {
         m_bits += other.m_bits;
         return *this;
     }

unorm16& G3D::operator+= ( const unorm16 other )

                                              {
         m_bits += other.m_bits;
         return *this;
     }

Vector2int32 G3D::operator- ( const Vector2int32 & other ) const

inline

                                                                    {
         return Vector2int32(x - other.x, y - other.y);
     }

Vector2int16 G3D::operator- ( const Vector2int16 & other ) const

inline

                                                                    {
         return Vector2int16(x - other.x, y - other.y);
     }

Vector3int16 G3D::operator- ( const Vector3int16 & other ) const

inline

                                                                    {
         return Vector3int16(x - other.x, y - other.y, z - other.z);
     }

Vector3int32 G3D::operator- ( ) const

inline

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

Vector3int32 G3D::operator- ( const Vector3int32 & other ) const

inline

                                                                    {
         return Vector3int32(x - other.x, y - other.y, z - other.z);
     }

unorm8 G3D::operator- ( const unorm8 other ) const

                                                {
         return unorm8(uint8(m_bits - other.m_bits));
     }

unorm16 G3D::operator- ( const unorm16 other ) const

                                                  {
         return unorm16(uint16(m_bits - other.m_bits));
     }

Vector3int16& G3D::operator-= ( const Vector3int16 & other )

inline

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

Vector2int32& G3D::operator-= ( const Vector2int32 & other )

inline

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

Vector2int16& G3D::operator-= ( const Vector2int16 & other )

inline

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

Vector3int32& G3D::operator-= ( const Vector3int32 & other )

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

unorm8& G3D::operator-= ( const unorm8 other )

                                            {
         m_bits -= other.m_bits;
         return *this;
     }

unorm16& G3D::operator-= ( const unorm16 other )

                                              {
         m_bits -= other.m_bits;
         return *this;
     }

Vector3int32 G3D::operator/ ( const Vector3int32 & other ) const

inline

Integer division

                                                                    {
         return Vector3int32(x / other.x, y / other.y, z / other.z);
     }

Vector3int32 G3D::operator/ ( const int s ) const

inline

Integer division

                                          {
         return unorm16(uint16(m_bits / i));
     }

G3D::Color3 G3D::operator/	(	float	s,
		const G3D::Color3 &	c
	)

inline

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

unorm8 & G3D::operator/= ( const int i )

                                      {
         m_bits /= i;
         return *this;
     }

bool G3D::operator< ( const unorm8 other ) const

                                              {
         return m_bits < other.m_bits;
     }

bool G3D::operator< ( const unorm16 other ) const

                                               {
         return m_bits < other.m_bits;
     }

std::ostream & G3D::operator<<	(	std::ostream &	os,
		const NetAddress &	a
	)

                                                             {
     return os << a.toString();
 }

Here is the call graph for this function:

Vector3int16 G3D::operator<< ( const Vector3int16 & v ) const

                                                          {
         return Vector3int16(x << v.x, y << v.y, z << v.z);
     }

Vector3int32 G3D::operator<< ( const Vector3int32 & v ) const

                                                          {
         return Vector3int32(x << v.x, y << v.y, z << v.z);
     }

Vector3int32 G3D::operator<< ( const int s ) const

inline

Shifts both x and y

                                           {
         return unorm16((uint16)(m_bits << i));
     }

std::ostream & G3D::operator<<	(	std::ostream &	os,
		const Vector3 &	v
	)

                                                          {
     return os << v.toString();
 }

Here is the call graph for this function:

unorm8 & G3D::operator<<= ( const int i )

                                       {
         m_bits <<= i;
         return *this;
     }

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

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

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

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

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

bool G3D::operator<= ( const unorm8 other ) const

                                               {
         return m_bits <= other.m_bits;
     }

bool G3D::operator<= ( const unorm16 other ) const

                                                {
         return m_bits <= other.m_bits;
     }

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

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

inline

                                                                   {
         return ((int32*)this)[0] == ((int32*)&rkVector)[0];
     }

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

inline

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

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

inline

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

bool G3D::operator== ( const unorm8 other ) const

                                               {
         return m_bits <= other.m_bits;
     }

bool G3D::operator== ( const unorm16 other ) const

                                                {
         return m_bits <= other.m_bits;
     }

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

inline

                                                                 {
         return ((int32*)this)[0] == ((int32*)&rkVector)[0];
     }

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

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

bool G3D::operator==	(	const NetAddress &	a,
		const NetAddress &	b
	)

inline

Two addresses may point to the same computer but be != because they have different IP's.

                                                                  {
     return (a.ip() == b.ip()) && (a.port() == b.port());
 }

Here is the call graph for this function:

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

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

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

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

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

bool G3D::operator> ( const unorm8 other ) const

                                              {
         return m_bits > other.m_bits;
     }

bool G3D::operator> ( const unorm16 other ) const

                                               {
         return m_bits > other.m_bits;
     }

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

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

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

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

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

bool G3D::operator>= ( const unorm8 other ) const

                                               {
         return m_bits >= other.m_bits;
     }

bool G3D::operator>= ( const unorm16 other ) const

                                                {
         return m_bits >= other.m_bits;
     }

Vector3int16 G3D::operator>> ( const Vector3int16 & v ) const

                                                          {
         return Vector3int16(x >> v.x, y >> v.y, z >> v.z);
     }

Vector3int32 G3D::operator>> ( const Vector3int32 & v ) const

                                                          {
         return Vector3int32(x >> v.x, y >> v.y, z >> v.z);
     }

Vector3int32 G3D::operator>> ( const int s ) const

inline

Shifts both x and y

                                           {
         return unorm16(uint16(m_bits >> i));
     }

unorm8 & G3D::operator>>= ( const int i )

                                       {
         m_bits >>= i;
         return *this;
     }

const G3D::int32 & G3D::operator[] ( int i )

inline

                                         {
         debugAssert(((unsigned int)i) <= 1);
         return ((G3D::int16*)this)[i];
     }

void G3D::parseCommaSeparated	(	const std::string	s,
		Array< std::string > &	array,
		bool	stripQuotes = `true`
	)

Separates a comma-separated line, properly escaping commas within double quotes (") and super quotes ("""). This matches Microsoft Excel's CSV output.

Parameters

stripQuotes If true, strips leading and trailing " and """

See also: G3D::stringSplit, G3D::TextInput, G3D::readWholeFile

                                                                                        {
     array.fastClear();
     if (s == "") {
         return;
     }
 
     size_t begin = 0;
     const char delimiter = ',';
     const char quote = '\"';
     do {
         size_t end = begin;
         // Find the next comma, or the end of the string
         bool inQuotes = false;
         while ((end < s.length()) && (inQuotes || (s[end] != delimiter))) {
             if (s[end] == quote) {
                 if ((end < s.length() - 2) && (s[end + 1] == quote) && (s[end + 2]) == quote) {
                     // Skip over the superquote
                     end += 2;
                 }
                 inQuotes = ! inQuotes;
             }
             ++end;
         }
         array.append(s.substr(begin, end - begin));
         begin = end + 1;
     } while (begin < s.length());
 
     if (stripQuotes) {
         for (int i = 0; i < array.length(); ++i) {
             std::string& t = array[i];
             size_t L = t.length();
             if ((L > 1) && (t[0] == quote) && (t[L - 1] == quote)) {
                 if ((L > 6)  && (t[1] == quote) && (t[2] == quote) && (t[L - 3] == quote) && (t[L - 2] == quote)) {
                     // Triple-quote
                     t = t.substr(3, L - 6);
                 } else {
                     // Double-quote
                     t = t.substr(1, L - 2);
                 }
             }
         }
     }
 }

Here is the call graph for this function:

void G3D::parseFilename	(	const std::string &	filename,
		std::string &	drive,
		Array< std::string > &	path,
		std::string &	base,
		std::string &	ext
	)

Parses a filename into four useful pieces.

Examples:

c:\a\b\d.e root = "c:\\" path = "a" "b" base = "d" ext = "e"

/a/b/d.e root = "/" path = "a" "b" base = "d" ext = "e"

/a/b root = "/" path = "a" base = "b" ext = "e"

                            {
 
     std::string f = filename;
 
     root = "";
     path.clear();
     base = "";
     ext = "";
 
     if (f == "") {
         // Empty filename
         return;
     }
 
     // See if there is a root/drive spec.
     if ((f.size() >= 2) && (f[1] == ':')) {
         
         if ((f.size() > 2) && isSlash(f[2])) {
         
             // e.g.  c:\foo
             root = f.substr(0, 3);
             f = f.substr(3, f.size() - 3);
         
         } else {
         
             // e.g.  c:foo
             root = f.substr(2);
             f = f.substr(2, f.size() - 2);
 
         }
 
     } else if ((f.size() >= 2) & isSlash(f[0]) && isSlash(f[1])) {
         
         // e.g. //foo
         root = f.substr(0, 2);
         f = f.substr(2, f.size() - 2);
 
     } else if (isSlash(f[0])) {
         
         root = f.substr(0, 1);
         f = f.substr(1, f.size() - 1);
 
     }
 
     // Pull the extension off
     {
         // Find the period
         size_t i = f.rfind('.');
 
         if (i != std::string::npos) {
             // Make sure it is after the last slash!
             size_t j = maxNotNPOS(f.rfind('/'), f.rfind('\\'));
             if ((j == std::string::npos) || (i > j)) {
                 ext = f.substr(i + 1, f.size() - i - 1);
                 f = f.substr(0, i);
             }
         }
     }
 
     // Pull the basename off
     {
         // Find the last slash
         size_t i = maxNotNPOS(f.rfind('/'), f.rfind('\\'));
         
         if (i == std::string::npos) {
             
             // There is no slash; the basename is the whole thing
             base = f;
             f    = "";
 
         } else if ((i != std::string::npos) && (i < f.size() - 1)) {
             
             base = f.substr(i + 1, f.size() - i - 1);
             f    = f.substr(0, i);
 
         }
     }
 
     // Parse what remains into path.
     size_t prev, cur = 0;
 
     while (cur < f.size()) {
         prev = cur;
         
         // Allow either slash
         size_t i = f.find('/', prev + 1);
         size_t j = f.find('\\', prev + 1);
         if (i == std::string::npos) {
             i = f.size();
         }
 
         if (j == std::string::npos) {
             j = f.size();
         }
 
         cur = min(i, j);
 
         if (cur == std::string::npos) {
             cur = f.size();
         }
 
         path.append(f.substr(prev, cur - prev));
         ++cur;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::pathConcat	(	const std::string &	dirname,
		const std::string &	file
	)

Appends file onto dirname, ensuring a / if needed.

Deprecated:: Use FilePath::concat

                                                                       {
     // Ensure that the directory ends in a slash
     if ((dirname.size() != 0) && 
         (dirname[dirname.size() - 1] != '/') &&
         (dirname[dirname.size() - 1] != '\\') &&
         (dirname[dirname.size() - 1] != ':')) {
         return dirname + '/' + file;
     } else {
         return dirname + file;
     }
 }

Here is the caller graph for this function:

double G3D::pi ( )

inline

                    {
     return 3.1415926535898;
 }

Here is the caller graph for this function:

float G3D::pif ( )

inline

                    {
     return 3.1415926535898f;
 }

Here is the caller graph for this function:

static bool G3D::planeBoxOverlap	(	const Vector3 &	normal,
		const Vector3 &	vert,
		const Vector3 &	maxbox
	)

static

                                                                                                 {
     Vector3 vmin, vmax;
     float v;
     
     // for each axis
     for(int a = 0; a < 3; ++a) {
         v = vert[a];
         
         if (normal[a] > 0.0f) {
             vmin[a] = -maxbox[a] - v;
             vmax[a] =  maxbox[a] - v;
         } else {
             vmin[a] =  maxbox[a] - v;
             vmax[a] = -maxbox[a] - v;
         }
     }
     
     if (normal.dot(vmin) > 0.0f) {
         return false;
     } else if (normal.dot(vmax) >= 0.0f) {
         return true;
     } else {
         return false;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int G3D::pow2 ( unsigned int x )

inline

Returns 2^x

                                 {
     return 1 << x;
 }

template<class T >

T G3D::pow5 ( T x )

inline

Returns x⁵

                    {
     const T y = x * x;
     return y * y * x;
 }

int G3D::prompt	(	const char *	windowTitle,
		const char *	promptx,
		const char **	choice,
		int	numChoices,
		bool	useGui
	)

Prints a prompt to stdout and waits for user input. The return value is the number of the user's choice (the first is 0, if there are no choices, returns 0).

Parameters

useGui	Under Win32, use a GUI, not stdout prompt.
windowTitle	The title for the prompt window
promptx	The text string to prompt the user with
choice	An array of strings that are the choices the user may make
numChoices	The length of choice.

[Windows] dialog interface by Max McGuire, mmcgu.nosp@m.ire@.nosp@m.ironl.nosp@m.ore..nosp@m.com [Font] setting code by Kurt Miller, kurt@.nosp@m.flip.nosp@m.code..nosp@m.com

                              {
 #if 0 /* G3DFIX: exclude GUI prompt code */
     #ifdef G3D_WINDOWS
         if (useGui) {
             // Build the message box
             return guiPrompt(windowTitle, prompt, choice, numChoices);
         }
     #endif
     
         #ifdef G3D_OSX
                 if (useGui){
                     //Will default to text prompt if numChoices > 4
           int result = guiPrompt(windowTitle, prompt, choice, numChoices);
           fprintf(stderr, "%d\n", result);
           return result;
                 }
         #endif
 #else
     (void)useGui;
 #endif /* G3DFIX: exclude GUI prompt code */
     return textPrompt(windowTitle, prompt, choice, numChoices);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int G3D::prompt	(	const char *	windowTitle,
		const char *	promptx,
		const char **	choice,
		int	numChoices
	)

inline

Prints a prompt and waits for user input. The return value is the number of the user's choice (the first is 0, if there are no choices, returns 0).

Uses GUI under Win32, stdout prompt otherwise.

                                 {
 
     return prompt(windowTitle, promptx, choice, numChoices, true);
 }

Here is the call graph for this function:

static double G3D::pythag	(	double	a,
		double	b
	)

static

Helper for svdCore

                                          {
     
     double at = fabs(a), bt = fabs(b), ct, result;
 
     if (at > bt) { 
         ct = bt / at; 
         result = at * sqrt(1.0 + square(ct)); 
     } else if (bt > 0.0) { 
         ct = at / bt; 
         result = bt * sqrt(1.0 + square(ct)); 
     } else {
         result = 0.0;
     }
 
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static uint32 G3D::readUInt32FromBuffer	(	const uint8 *	data,
		bool	swapBytes
	)

static

Helper used by the constructors for decompression

                                                                       {
     if (swapBytes) {
         uint8 out[4];
         out[0] = data[3];
         out[1] = data[2];
         out[2] = data[1];
         out[3] = data[0];
         return *((uint32*)out);
     } else {
         return *((uint32*)data);
     }
 }

Here is the caller graph for this function:

static bool G3D::readWaiting ( const SOCKET & sock )

static

Returns true if the socket has a read pending

                                             {
     int ret = selectOneReadSocket(sock);
 
     switch (ret) {
     case SOCKET_ERROR:
         logPrintf("ERROR: selectOneReadSocket returned "
                   "SOCKET_ERROR in readWaiting(). %s", socketErrorCode().c_str());
         // Return true so that we'll force an error on read and close
         // the socket.
         return true;
 
     case 0:
         return false;
 
     default:
         return true;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::readWholeFile ( const std::string & filename )

Returns the contents of a text file as a single string

                                                    {
 
     std::string s;
 
     debugAssert(filename != "");
     if (!  FileSystem::exists(filename)) {
         throw (filename + " not found");
     }
     FileSystem::markFileUsed(filename);
     std::string zipfile;
 
     if (! FileSystem::inZipfile(filename, zipfile)) {
         // Not in zipfile
         if (! FileSystem::exists(filename)) {
             throw FileNotFound(filename, std::string("File not found in readWholeFile: ") + filename);
         }
 
         int64 length = FileSystem::size(filename);
 
         char* buffer = (char*)System::alignedMalloc(length + 1, 16);
         debugAssert(buffer);
         FILE* f = FileSystem::fopen(filename.c_str(), "rb");
         debugAssert(f);
         int64 ret = fread(buffer, 1, length, f);
         debugAssert(ret == length);(void)ret;
         FileSystem::fclose(f);
 
         buffer[length] = '\0';    
         s = std::string(buffer);
 
         System::alignedFree(buffer);
 
     } else {
 
         // In zipfile
         FileSystem::markFileUsed(zipfile);
 
 #if _HAVE_ZIP /* G3DFIX: Use ZIP-library only if defined */    
         // Zipfiles require Unix-style slashes
         std::string internalFile = FilePath::canonicalize(filename.substr(zipfile.length() + 1));
         struct zip* z = zip_open(zipfile.c_str(), ZIP_CHECKCONS, NULL);
         {
             struct zip_stat info;
             zip_stat_init( &info );    // TODO: Docs unclear if zip_stat_init is required.
             zip_stat(z, internalFile.c_str(), ZIP_FL_NOCASE, &info);
 
             // Add NULL termination
             char* buffer = reinterpret_cast<char*>(System::alignedMalloc(info.size + 1, 16));
             buffer[info.size] = '\0';
 
             struct zip_file* zf = zip_fopen( z, internalFile.c_str(), ZIP_FL_NOCASE );
             if (zf == NULL) {
                 throw std::string("\"") + internalFile + "\" inside \"" + zipfile + "\" could not be opened.";
             } else {
                 const int64 bytesRead = zip_fread( zf, buffer, (info.size));
                 debugAssertM((int64)bytesRead == (int64)info.size,
                              internalFile + " was corrupt because it unzipped to the wrong size.");
                 (void)bytesRead;
                 zip_fclose( zf );
             }
             // Copy the string
             s = buffer;
             System::alignedFree(buffer);
         }
         zip_close( z );
 #endif
     }
 
     return s;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint16 G3D::reinterpretAsUInt16 ( ) const

Returns the underlying bits in this representation. Equivalent to:

uint16 i = reinterpret_cast<const uint16&>(u);

uint8 i = reinterpret_cast<const uint8&>(u);

                                        {
         return m_bits;
     }

uint8 G3D::reinterpretAsUInt8 ( ) const

Returns the underlying bits in this representation. Equivalent to:

uint16 i = reinterpret_cast<const uint16&>(u);

uint8 i = reinterpret_cast<const uint8&>(u);

                                      {
         return m_bits;
     }

static unorm16 G3D::reinterpretFrom ( uint16 b )

static

Equivalent to:

unorm16 u = reinterpret_cast<const unorm16&>(255);

                                              {
         return unorm16(b);
     }

static unorm8 G3D::reinterpretFrom ( uint8 b )

static

Equivalent to:

unorm16 u = reinterpret_cast<const unorm16&>(255);

                                            {
         return unorm8(b);
     }

std::string G3D::replace	(	const std::string &	s,
		const std::string &	pattern,
		const std::string &	replacement
	)

Returns a string which is s, with all instances of pattern replaced

                                                                                               {
     if (pattern.length() == 0) {
         return s;
     }
     std::string temp = "";
     size_t lastindex = 0;
     size_t nextindex = 0;
     do {
         nextindex = s.find(pattern, lastindex);
         if (nextindex == std::string::npos) {
             break;
         }
         temp += s.substr(lastindex, nextindex - lastindex) + replacement;
         lastindex = nextindex + pattern.length();
     } while (lastindex + pattern.length() <= s.length());
     return temp + (lastindex < s.length() ? s.substr(lastindex) : "");
 }

Here is the caller graph for this function:

std::string G3D::resolveFilename ( const std::string & filename )

                                                      {
     if (filename.size() >= 1) {
         if ((filename[0] == '/') || (filename[0] == '\\')) {
             // Already resolved
             return filename;
         } else {
 
             #ifdef G3D_WINDOWS
                 if ((filename.size() >= 2) && (filename[1] == ':')) {
                     // There is a drive spec on the front.
                     if ((filename.size() >= 3) && ((filename[2] == '\\') || 
                                                    (filename[2] == '/'))) {
                         // Already fully qualified
                         return filename;
                     } else {
                         // The drive spec is relative to the
                         // working directory on that drive.
                         debugAssertM(false, "Files of the form d:path are"
                                      " not supported (use a fully qualified"
                                      " name).");
                         return filename;
                     }
                 }
             #endif
         }
     }
 
     char buffer[1024];
 
     // Prepend the working directory.
     (void)_getcwd(buffer, 1024);
 
     return format("%s/%s", buffer, filename.c_str());
 }

Here is the call graph for this function:

static void G3D::rgb32f_to_rgba32f	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                  {
     debugAssertM(srcRowPadBits % 8 == 0, "Source row padding must be a multiple of 8 bits for this format");
 
     int dstIndex = 0;
     int srcByteOffset = 0;
     int srcRowPadBytes = srcRowPadBits / 8;
     Color4* dst = static_cast<Color4*>(dstBytes[0]);
     const unorm8* src = static_cast<const unorm8*>(srcBytes[0]);
 
     for (int y = 0; y < srcHeight; ++y) {
         if (invertY) {
             dstIndex = srcWidth * (srcHeight - 1 - y);
         }
 
         for (int x = 0; x < srcWidth; ++x, ++dstIndex, srcByteOffset += 3 * sizeof(float)) {
             const Color3& s = *reinterpret_cast<const Color3*>(src + srcByteOffset);
             dst[dstIndex] = Color4(Color3(s), 1.0f);
         }
         srcByteOffset += srcRowPadBytes;
     }
 }

static void G3D::rgb8_to_bayer_bggr8	(	const int	w,
		const int	h,
		const unorm8 *	src,
		unorm8 *	dst
	)

static

                                                 {
     Color3unorm8* srcColor = (Color3unorm8*)src;
     Color1unorm8* dstColor = (Color1unorm8*)dst;
 
     // Top row pixels
     for (int y = 0; y < h - 1; y += 2) {
     int offset = y * w;
 
     // Top left pixels
     for (int x = 0; x < w - 1; x += 2) {
         dstColor[x + offset] = Color1unorm8(srcColor[x + offset].b);
     }
 
     // Top right pixels
     for (int x = 1; x < w - 1; x += 2) {
         dstColor[x + offset] = Color1unorm8(srcColor[x + offset].g);
     }
     }
 
     // Bottom row pixels
     for (int y = 1; y < h - 1; y += 2) {
     int offset = y * w;
 
     // Bottom left pixels
     for(int x = 0; x < w - 1; x += 2) {
         dstColor[x + offset] = Color1unorm8(srcColor[x + offset].g);
     }
 
     // Bottom right pixels
     for(int x = 1; x < w - 1; x += 2) {
         dstColor[x + offset] = Color1unorm8(srcColor[x + offset].r);
     }
     }
 }

Here is the caller graph for this function:

static void G3D::rgb8_to_bayer_gbrg8	(	const int	w,
		const int	h,
		const unorm8 *	src,
		unorm8 *	dst
	)

static

                                                 {
     Color3unorm8* srcColor = (Color3unorm8*)src;
     Color1unorm8* dstColor = (Color1unorm8*)dst;
 
     // Top row pixels
     for(int y = 0; y < h - 1; y += 2) {
     int offset = y * w;
 
     // Top left pixels
     for(int x = 0; x < w - 1; x += 2) {
         dstColor[x + offset] = Color1unorm8(srcColor[x + offset].g);
     }
 
     // Top right pixels
     for(int x = 1; x < w - 1; x += 2) {
         dstColor[x + offset] = Color1unorm8(srcColor[x + offset].b);
     }
     }
 
     // Bottom row pixels
     for(int y = 1; y < h - 1; y += 2) {
     int offset = y * w;
 
     // Bottom left pixels
     for(int x = 0; x < w - 1; x += 2) {
         dstColor[x + offset] = Color1unorm8(srcColor[x + offset].r);
     }
 
     // Bottom right pixels
     for(int x = 1; x < w - 1; x += 2) {
         dstColor[x + offset] = Color1unorm8(srcColor[x + offset].g);
     }
     }
 }

Here is the caller graph for this function:

static void G3D::rgb8_to_bayer_grbg8	(	const int	w,
		const int	h,
		const unorm8 *	src,
		unorm8 *	dst
	)

static

                                                 {
     Color3unorm8* srcColor = (Color3unorm8*)src;
     Color1unorm8* dstColor = (Color1unorm8*)dst;
 
     // Top row pixels
     for (int y = 0; y < h - 1; y += 2) {
     int offset = y * w;
 
     // Top left pixels
     for (int x = 0; x < w - 1; x += 2) {
         dstColor[x + offset] = Color1unorm8(srcColor[x + offset].g);
     }
 
     // Top right pixels
     for (int x = 1; x < w - 1; x += 2) {
         dstColor[x + offset] = Color1unorm8(srcColor[x + offset].r);
     }
     }
 
     // Bottom row pixels
     for (int y = 1; y < h - 1; y += 2) {
     int offset = y * w;
 
     // Bottom left pixels
     for (int x = 0; x < w - 1; x += 2) {
         dstColor[x + offset] = Color1unorm8(srcColor[x + offset].b);
     }
 
     // Bottom right pixels
     for (int x = 1; x < w - 1; x += 2) {
         dstColor[x + offset] = Color1unorm8(srcColor[x + offset].g);
     }
     }
 }

Here is the caller graph for this function:

static void G3D::rgb8_to_bayer_rggb8	(	const int	w,
		const int	h,
		const unorm8 *	src,
		unorm8 *	dst
	)

static

                                                 {
     Color3unorm8* srcColor = (Color3unorm8*)src;
     Color1unorm8* dstColor = (Color1unorm8*)dst;
 
     // Top row pixels
     for (int y = 0; y < h - 1; y += 2) {
         int offset = y * w;
 
         // Top left pixels
         for(int x = 0; x < w - 1; x += 2) {
             dstColor[x + offset] = Color1unorm8(srcColor[x + offset].r);
         }
 
         // Top right pixels
         for(int x = 1; x < w - 1; x += 2) {
             dstColor[x + offset] = Color1unorm8(srcColor[x + offset].g);
         }
         }
 
         // Bottom row pixels
         for (int y = 1; y < h - 1; y += 2) {
         int offset = y * w;
 
         // Bottom left pixels
         for (int x = 0; x < w - 1; x += 2) {
             dstColor[x + offset] = Color1unorm8(srcColor[x + offset].g);
         }
 
         // Bottom right pixels
         for (int x = 1; x < w - 1; x += 2) {
             dstColor[x + offset] = Color1unorm8(srcColor[x + offset].b);
         }
     }
 }

Here is the caller graph for this function:

static void G3D::rgb8_to_bgr8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                             {
     unorm8* dst = static_cast<unorm8*>(dstBytes[0]);
     const unorm8* src = static_cast<const unorm8*>(srcBytes[0]);
     for (int y = 0; y < srcHeight; ++y) {
         for (int x = 0; x < srcWidth; ++x) {
             int i = (invertY) ? ((srcHeight-1-y) * srcWidth +x) : (y * srcWidth + x);
             int i3 = i * 3;
             dst[i3 + 0] = src[i3 + 2];
             dst[i3 + 1] = src[i3 + 1];
             dst[i3 + 2] = src[i3 + 0];
         }
     }
 }

static void G3D::rgb8_to_rgba32f	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                {
     debugAssertM(srcRowPadBits % 8 == 0, "Source row padding must be a multiple of 8 bits for this format");
 
     int dstIndex = 0;
     int srcByteOffset = 0;
     int srcRowPadBytes = srcRowPadBits / 8;
     Color4* dst = static_cast<Color4*>(dstBytes[0]);
     const unorm8* src = static_cast<const unorm8*>(srcBytes[0]);
 
     for (int y = 0; y < srcHeight; ++y) {
         if (invertY) {
             dstIndex = srcWidth * (srcHeight - 1 - y);
         }
         for (int x = 0; x < srcWidth; ++x, ++dstIndex, srcByteOffset += 3) {
             const Color3unorm8& s = *reinterpret_cast<const Color3unorm8*>(src + srcByteOffset);
             dst[dstIndex] = Color4(Color3(s), 1.0f);
         }
         srcByteOffset += srcRowPadBytes;
     }
 }

Here is the caller graph for this function:

static void G3D::rgb8_to_rgba8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                              {
     unorm8* dst = static_cast<unorm8*>(dstBytes[0]);
     const unorm8* src = static_cast<const unorm8*>(srcBytes[0]);
     for (int y = 0; y < srcHeight; ++y) {
         for (int x = 0; x < srcWidth; ++x) {
             int i = (invertY) ? ((srcHeight-1-y) * srcWidth +x) : (y * srcWidth + x);
             int i3 = i * 3;
             int i4 = i3 + i; 
 
             dst[i4 + 0] = src[i3 + 0]; 
             dst[i4 + 1] = src[i3 + 1]; 
             dst[i4 + 2] = src[i3 + 2]; 
             dst[i4 + 3] = unorm8::one(); 
         }
     }
 }

Here is the call graph for this function:

static void G3D::rgb8_to_yuv420p	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                {
     debugAssertM(srcRowPadBits == 0, "Source row padding must be 0 for this format");
     debugAssertM((srcWidth % 2 == 0) && (srcHeight % 2 == 0), "Source width and height must be a multiple of two");
 
     const Color3unorm8* src = static_cast<const Color3unorm8*>(srcBytes[0]);
 
     unorm8* dstY = static_cast<unorm8*>(dstBytes[0]);
     unorm8* dstU = static_cast<unorm8*>(dstBytes[1]);
     unorm8* dstV = static_cast<unorm8*>(dstBytes[2]);
 
     for (int y = 0; y < srcHeight; y += 2) {
         for (int x = 0; x < srcWidth; x += 2) {
 
             // convert 4-pixel block at a time
             int srcPixelOffset0 = y * srcWidth + x;
             int srcPixelOffset1 = srcPixelOffset0 + 1;
             int srcPixelOffset2 = srcPixelOffset0 + srcWidth;
             int srcPixelOffset3 = srcPixelOffset2 + 1;
 
             int yIndex = y * srcWidth + x;
 
             dstY[yIndex] =     PIXEL_RGB8_TO_YUV_Y(src[srcPixelOffset0].r, src[srcPixelOffset0].g, src[srcPixelOffset0].b);
             dstY[yIndex + 1] = PIXEL_RGB8_TO_YUV_Y(src[srcPixelOffset1].r, src[srcPixelOffset1].g, src[srcPixelOffset1].b);
 
             yIndex += srcWidth;
             dstY[yIndex] =     PIXEL_RGB8_TO_YUV_Y(src[srcPixelOffset2].r, src[srcPixelOffset2].g, src[srcPixelOffset2].b);
             dstY[yIndex + 1] = PIXEL_RGB8_TO_YUV_Y(src[srcPixelOffset3].r, src[srcPixelOffset3].g, src[srcPixelOffset3].b);
 
             uint32 blendedPixel = blendPixels(src[srcPixelOffset0].asUInt32(), src[srcPixelOffset2].asUInt32());
             Color3unorm8 uvSrcColor = Color3unorm8::fromARGB(blendedPixel);
 
             int uvIndex = y / 2 * srcWidth / 2 + x / 2;
             dstU[uvIndex] =    PIXEL_RGB8_TO_YUV_U(uvSrcColor.r, uvSrcColor.g, uvSrcColor.b);
             dstV[uvIndex] =    PIXEL_RGB8_TO_YUV_V(uvSrcColor.r, uvSrcColor.g, uvSrcColor.b);
         }
     }
 }

Here is the call graph for this function:

static void G3D::rgb8_to_yuv422	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                               {
     debugAssertM(srcRowPadBits == 0, "Source row padding must be 0 for this format");
     debugAssertM((srcWidth % 2 == 0), "Source width must be a multiple of two");
 
     const Color3unorm8* src = static_cast<const Color3unorm8*>(srcBytes[0]);
 
     unorm8* dst = static_cast<unorm8*>(dstBytes[0]);
 
     for (int y = 0; y < srcHeight; ++y) {
         for (int x = 0; x < srcWidth; x += 2) {
 
             // convert 2-pixel horizontal block at a time
             int srcIndex = y * srcWidth + x;
             int dstIndex = srcIndex * 2;
 
             uint32 blendedPixel = blendPixels(src[srcIndex].asUInt32(), src[srcIndex + 1].asUInt32());
             Color3unorm8 uvSrcColor = Color3unorm8::fromARGB(blendedPixel);
 
             dst[dstIndex]     = PIXEL_RGB8_TO_YUV_Y(src[srcIndex].r, src[srcIndex].g, src[srcIndex].b);
 
             dst[dstIndex + 1] = PIXEL_RGB8_TO_YUV_U(uvSrcColor.r, uvSrcColor.g, uvSrcColor.b);
 
             dst[dstIndex + 2] = PIXEL_RGB8_TO_YUV_Y(src[srcIndex + 1].r, src[srcIndex + 1].g, src[srcIndex + 1].b);
 
             dst[dstIndex + 3] = PIXEL_RGB8_TO_YUV_V(uvSrcColor.r, uvSrcColor.g, uvSrcColor.b);
 
         }
     }
 }

Here is the call graph for this function:

static void G3D::rgb8_to_yuv444	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                               {
     debugAssertM(srcRowPadBits == 0, "Source row padding must be 0 for this format");
 
     const Color3unorm8* src = static_cast<const Color3unorm8*>(srcBytes[0]);
 
     Color3unorm8* dst = static_cast<Color3unorm8*>(dstBytes[0]);
 
     for (int y = 0; y < srcHeight; ++y) {
         for (int x = 0; x < srcWidth; ++x) {
 
             // convert 1-pixels at a time
             int index = y * srcWidth + x;
             unorm8 y = PIXEL_RGB8_TO_YUV_Y(src[index].r, src[index].g, src[index].b);
             unorm8 u = PIXEL_RGB8_TO_YUV_U(src[index].r, src[index].g, src[index].b);
             unorm8 v = PIXEL_RGB8_TO_YUV_V(src[index].r, src[index].g, src[index].b);
 
             dst[index].r = y;
             dst[index].g = u;
             dst[index].b = v;
         }
     }
 }

static void G3D::rgba32f_to_bayer_bggr8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                       {
     Array<void*> tmp;
     tmp.append(System::malloc(srcWidth * srcHeight * sizeof(Color3unorm8)));
 
     rgba32f_to_rgb8(srcBytes, srcWidth, srcHeight, ImageFormat::RGBA32F(), 0, tmp, ImageFormat::RGB8(), 0, invertY, bayerAlg);
     rgb8_to_bayer_bggr8(srcWidth, srcHeight, static_cast<unorm8*>(tmp[0]), static_cast<unorm8*>(dstBytes[0]));
 
     System::free(tmp[0]);
 }

Here is the call graph for this function:

static void G3D::rgba32f_to_bayer_gbrg8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                       {
     Array<void*> tmp;
     tmp.append(System::malloc(srcWidth * srcHeight * sizeof(Color3unorm8)));
 
     rgba32f_to_rgb8(srcBytes, srcWidth, srcHeight, ImageFormat::RGBA32F(), 0, tmp, ImageFormat::RGB8(), 0, invertY, bayerAlg);
     rgb8_to_bayer_grbg8(srcWidth, srcHeight, static_cast<unorm8*>(tmp[0]), static_cast<unorm8*>(dstBytes[0]));
 
     System::free(tmp[0]);
 }

Here is the call graph for this function:

static void G3D::rgba32f_to_bayer_grbg8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                       {
     Array<void*> tmp;
     tmp.append(System::malloc(srcWidth * srcHeight * sizeof(Color3unorm8)));
 
     rgba32f_to_rgb8(srcBytes, srcWidth, srcHeight, ImageFormat::RGBA32F(), 0, tmp, ImageFormat::RGB8(), 0, invertY, bayerAlg);
     rgb8_to_bayer_gbrg8(srcWidth, srcHeight, static_cast<unorm8*>(tmp[0]), static_cast<unorm8*>(dstBytes[0]));
 
     System::free(tmp[0]);
 }

Here is the call graph for this function:

static void G3D::rgba32f_to_bayer_rggb8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                       {
     Array<void*> tmp;
     tmp.append(System::malloc(srcWidth * srcHeight * sizeof(Color3unorm8)));
 
     rgba32f_to_rgb8(srcBytes, srcWidth, srcHeight, ImageFormat::RGBA32F(), 0, tmp, ImageFormat::RGB8(), 0, invertY, bayerAlg);
     rgb8_to_bayer_rggb8(srcWidth, srcHeight, static_cast<unorm8*>(tmp[0]), static_cast<unorm8*>(dstBytes[0]));
 
     System::free(tmp[0]);
 }

Here is the call graph for this function:

static void G3D::rgba32f_to_bgr8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                {
     debugAssertM(dstRowPadBits % 8 == 0, "Destination row padding must be a multiple of 8 bits for this format");
 
     int srcIndex = 0;
     int dstByteOffset = 0;
     int dstRowPadBytes = dstRowPadBits / 8;
     unorm8* dst = static_cast<unorm8*>(dstBytes[0]);
     const Color4* src = static_cast<const Color4*>(srcBytes[0]);
 
     for (int y = 0; y < srcHeight; ++y) {
         if (invertY) {
             srcIndex = srcWidth * (srcHeight - y - 1);
         }
         
         for (int x = 0; x < srcWidth; ++x, ++srcIndex, dstByteOffset += 3) {
             Color3unorm8&  d = *reinterpret_cast<Color3unorm8*>(dst + dstByteOffset);
             const Color4& s = src[srcIndex];
 
             d = Color3unorm8(s.rgb()).bgr();
         }
         dstByteOffset += dstRowPadBytes;
     } 
 }

Here is the call graph for this function:

static void G3D::rgba32f_to_rgb32f	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                  {
     debugAssertM(dstRowPadBits % 8 == 0, "Destination row padding must be a multiple of 8 bits for this format");
 
     int srcIndex = 0;
     int dstByteOffset = 0;
     int dstRowPadBytes = dstRowPadBits / 8;
     unorm8* dst = static_cast<unorm8*>(dstBytes[0]);
     const Color4* src = static_cast<const Color4*>(srcBytes[0]);
 
     for (int y = 0; y < srcHeight; ++y) {
         if (invertY) {
             srcIndex = srcWidth * (srcHeight - 1 - y);
         }
         for (int x = 0; x < srcWidth; ++x, ++srcIndex, dstByteOffset += 3 * sizeof(float)) {
             Color3& d = *reinterpret_cast<Color3*>(dst + dstByteOffset);
             const Color4& s = src[srcIndex];        
             d = s.rgb();
         }
         dstByteOffset += dstRowPadBytes;
     } 
 }

Here is the call graph for this function:

static void G3D::rgba32f_to_rgb8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                {
     debugAssertM(dstRowPadBits % 8 == 0, "Destination row padding must be a multiple of 8 bits for this format");
 
     int srcIndex = 0;
     int dstByteOffset = 0;
     int dstRowPadBytes = dstRowPadBits / 8;
     unorm8* dst = static_cast<unorm8*>(dstBytes[0]);
     const Color4* src = static_cast<const Color4*>(srcBytes[0]);
 
     for (int y = 0; y < srcHeight; ++y) {
         if (invertY) {
             srcIndex = srcWidth * (srcHeight - y - 1);
         }
         
         for (int x = 0; x < srcWidth; ++x, ++srcIndex, dstByteOffset += 3) {
             Color3unorm8&  d = *reinterpret_cast<Color3unorm8*>(dst + dstByteOffset);
             const Color4& s = src[srcIndex];
 
             d = Color3unorm8(s.rgb());
         }
         dstByteOffset += dstRowPadBytes;
     } 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void G3D::rgba32f_to_rgba8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                 {
     debugAssertM(dstRowPadBits % 8 == 0, "Destination row padding must be a multiple of 8 bits for this format");
 
     int srcIndex = 0;
     int dstByteOffset = 0;
     int dstRowPadBytes = dstRowPadBits / 8;
     unorm8* dst = static_cast<unorm8*>(dstBytes[0]);
     const Color4* src = static_cast<const Color4*>(srcBytes[0]);
 
     for (int y = 0; y < srcHeight; ++y) {
         if (invertY) {
             srcIndex = srcWidth * (srcHeight - 1 - y);
         }
         for (int x = 0; x < srcWidth; ++x, ++srcIndex, dstByteOffset += 4) {
             Color4unorm8&  d = *reinterpret_cast<Color4unorm8*>(dst + dstByteOffset);
             const Color4& s = src[srcIndex];
 
             d = Color4unorm8(s);
         }
         dstByteOffset += dstRowPadBytes;
     } 
 }

static void G3D::rgba8_to_bgr8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                              {
     unorm8* dst = static_cast<unorm8*>(dstBytes[0]);
     const unorm8* src = static_cast<const unorm8*>(srcBytes[0]);
     for (int y = 0; y < srcHeight; ++y) {
         for (int x = 0; x < srcWidth; ++x) {
             int i = (invertY) ? ((srcHeight-1-y) * srcWidth +x) : (y * srcWidth + x);
             int i3 = i * 3;
             int i4 = i3 + i;
 
             dst[i3 + 0] = src[i4 + 2]; 
             dst[i3 + 1] = src[i4 + 1]; 
             dst[i3 + 2] = src[i4 + 0]; 
         }
     }
 }

static void G3D::rgba8_to_rgb8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                              {
     unorm8* dst = static_cast<unorm8*>(dstBytes[0]);
     const unorm8* src = static_cast<const unorm8*>(srcBytes[0]);
     for (int y = 0; y < srcHeight; ++y) {
         for (int x = 0; x < srcWidth; ++x) {
             int i = (invertY) ? ((srcHeight-1-y) * srcWidth +x) : (y * srcWidth + x);
             int i3 = i * 3;
             int i4 = i3 + i;
 
             dst[i3 + 0] = src[i4 + 0]; 
             dst[i3 + 1] = src[i4 + 1]; 
             dst[i3 + 2] = src[i4 + 2]; 
         }
     }
 }

static void G3D::rgba8_to_rgba32f	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                 {
     debugAssertM(srcRowPadBits % 8 == 0, "Source row padding must be a multiple of 8 bits for this format");
 
     int dstIndex = 0;
     int srcByteOffset = 0;
     int srcRowPadBytes = srcRowPadBits / 8;
     Color4* dst = static_cast<Color4*>(dstBytes[0]);
     const unorm8* src = static_cast<const unorm8*>(srcBytes[0]);
 
     for (int y = 0; y < srcHeight; ++y) {
         if (invertY) {
             dstIndex = srcWidth * (srcHeight - 1 - y);
         }
 
         for (int x = 0; x < srcWidth; ++x, ++dstIndex, srcByteOffset += 4) {
             const Color4unorm8& s = *reinterpret_cast<const Color4unorm8*>(src + srcByteOffset);
             dst[dstIndex] = Color4(s);
         }
         srcByteOffset += srcRowPadBytes;
     }
 }

double G3D::round ( double f )

inline

                               {
     return floor(f + 0.5f);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::round ( float f )

inline

                             {
     return floor(f + 0.5f);
 }

Here is the call graph for this function:

float G3D::rsq ( float x )

inline

Computes 1 / sqrt(x).

                           {
     return 1.0f / sqrtf(x);
 }

Here is the caller graph for this function:

double G3D::rsqrt ( double x )

inline

Deprecated:: Use rsq

                               {
     return 1.0 / sqrt(x);
 }

Here is the caller graph for this function:

float G3D::rsqrt ( float x )

inline

Deprecated:: Use rsq

                             {
     // TODO: default this to using the SSE2 instruction
     return 1.0f / sqrtf(x);
 }

static int G3D::selectOneReadSocket ( const SOCKET & sock )

static

Invokes select on one socket. Returns SOCKET_ERROR on error, 0 if there is no read pending, sock if there a read pending.

                                                    {
     // 0 time timeout is specified to poll and return immediately
     struct timeval timeout;
     timeout.tv_sec  = 0;
     timeout.tv_usec = 0;
 
     // Create a set that contains just this one socket
     fd_set socketSet;
     FD_ZERO(&socketSet); 
     FD_SET(sock, &socketSet);
 
     int ret = select((int)sock + 1, &socketSet, NULL, NULL, &timeout);
 
     return ret;
 }

Here is the caller graph for this function:

static int G3D::selectOneWriteSocket ( const SOCKET & sock )

static

Invokes select on one socket.

                                                     {
     // 0 time timeout is specified to poll and return immediately
     struct timeval timeout;
     timeout.tv_sec  = 0;
     timeout.tv_usec = 0;
 
     // Create a set that contains just this one socket
     fd_set socketSet;
     FD_ZERO(&socketSet); 
     FD_SET(sock, &socketSet);
 
     return select((int)sock + 1, NULL, &socketSet, NULL, &timeout);
 }

Here is the caller graph for this function:

void G3D::serialize	(	const std::string &	s,
		BinaryOutput &	b
	)

inline

                                                            {
     b.writeString32(s);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::serialize	(	const int32 &	i,
		BinaryOutput &	b
	)

inline

                                                        {
     b.writeInt32(i);
 }

Here is the call graph for this function:

void G3D::serialize	(	const uint32 &	i,
		BinaryOutput &	b
	)

inline

                                                         {
     b.writeUInt32(i);
 }

Here is the call graph for this function:

void G3D::serialize	(	const bool &	i,
		BinaryOutput &	b
	)

inline

                                                       {
     b.writeBool8(i);
 }

Here is the call graph for this function:

void G3D::serialize	(	const float32 &	f,
		BinaryOutput &	b
	)

inline

                                                          {
     b.writeFloat32(f);
 }

Here is the call graph for this function:

void G3D::serialize	(	const float64 &	f,
		BinaryOutput &	b
	)

inline

                                                          {
     b.writeFloat64(f);
 }

Here is the call graph for this function:

template<typename T >

void G3D::serialize	(	const Array< T > &	array,
		BinaryOutput &	b
	)

serialize(const T&, BinaryOutput&) must have been overridden as well

                                                        { 
     b.writeInt32(array.size()); 
     for (int i = 0; i < array.size(); ++i) { 
         serialize(array[i], b); 
     } 
 }

Here is the call graph for this function:

void G3D::serialize ( class BinaryOutput & bo ) const

void G3D::serialize	(	const bool &	b,
		TextOutput &	to
	)

                                               {
     to.writeSymbol(b ? "true" : "false");
 }

Here is the call graph for this function:

void G3D::serialize	(	const int &	b,
		TextOutput &	to
	)

                                              {
     to.writeNumber(b);
 }

Here is the call graph for this function:

void G3D::serialize	(	const uint8 &	b,
		TextOutput &	to
	)

                                                {
     to.writeNumber(b);
 }

Here is the call graph for this function:

void G3D::serialize	(	const double &	b,
		TextOutput &	to
	)

                                                 {
     to.writeNumber(b);
 }

Here is the call graph for this function:

void G3D::serialize	(	const float &	b,
		TextOutput &	to
	)

                                                {
     to.writeNumber(b);
 }

Here is the call graph for this function:

void G3D::serialize	(	const std::string &	b,
		TextOutput &	to
	)

void G3D::serialize	(	const char *	b,
		TextOutput &	to
	)

void G3D::serialize	(	const Vector2 &	v,
		class BinaryOutput &	b
	)

                                                         {
     v.serialize(b);
 }

Here is the call graph for this function:

void G3D::serialize	(	const Vector3::Axis &	a,
		class BinaryOutput &	bo
	)

                                                              {
     bo.writeUInt8((uint8)a);
 }

Here is the call graph for this function:

void G3D::serialize	(	const Vector4 &	v,
		class BinaryOutput &	b
	)

                                                         {
     v.serialize(b);
 }

Here is the call graph for this function:

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

                                                         {
     v.serialize(b);
 }

Here is the call graph for this function:

void G3D::setAssertionHook ( AssertionHook hook )

Allows customization of the global function invoked when a debugAssert fails. The initial value is G3D::internal::_handleDebugAssert. G3D will invoke rawBreak if the hook returns true. If NULL, assertions are not handled.

                                           {
     G3D::_internal::_debugHook = hook;
 }

void G3D::setConsolePrintHook ( ConsolePrintHook h )

Called by consolePrintf after the log and terminal have been written to. Used by GConsole to intercept printing routines.

                                              {
     G3D::_internal::_consolePrintHook = h;
 }

void G3D::setFailureHook ( AssertionHook hook )

Called by alwaysAssertM in case of failure in release mode. If returns true then the program exits with -1 (you can replace this with your own version that throws an exception or has other failure modes).

                                         {
     G3D::_internal::_failureHook = hook;
 }

Vector2 G3D::sign ( const Vector2 & v )

inline

                                       {
     return Vector2((float)sign(v.x), (float)sign(v.y));
 }

Here is the call graph for this function:

Vector3 G3D::sign ( const Vector3 & v )

inline

                                       {
     return Vector3((float)sign(v.x), (float)sign(v.y), (float)sign(v.z));
 }

Here is the call graph for this function:

Vector4 G3D::sign ( const Vector4 & v )

inline

                                       {
     return Vector4((float)sign(v.x), (float)sign(v.y), (float)sign(v.z), (float)sign(v.w));
 }

Here is the call graph for this function:

double G3D::sign ( double fValue )

inline

                                    {
     if (fValue > 0.0) {
         return 1.0;
     }
 
     if (fValue < 0.0) {
         return -1.0;
     }
 
     return 0.0;
 }

Here is the caller graph for this function:

float G3D::sign ( float fValue )

inline

                                  {
     if (fValue > 0.0f) {
         return 1.0f;
     }
 
     if (fValue < 0.0f) {
         return -1.0f;
     }
 
     return 0.0f;
 }

float G3D::signedPow	(	float	b,
		float	e
	)

inline

Computes |b|^e * sign(b)

                                          {
     return sign(b) * powf(fabsf(b), e);
 }

Here is the call graph for this function:

double G3D::signedPow	(	double	b,
		double	e
	)

inline

Computes |b|^e * sign(b)

                                             {
     return sign(b) * pow(abs(b), e);
 }

Here is the call graph for this function:

double G3D::sinc ( double x )

inline

sin(x)/x

                              {
     double r = sin(x) / x;
 
     if (isNaN(r)) {
         return 1.0;
     } else {
         return r;
     }
 }

Here is the call graph for this function:

float G3D::smootherstep	(	float	edge0,
		float	edge1,
		float	x
	)

inline

Perlin's C2 continous variation on smoothstep()

                                                              {
 
     // Scale, and saturate x to 0..1 range
     x = clamp((x - edge0) / (edge1 - edge0), 0.0f, 1.0f);
 
     // Evaluate polynomial
     return x * x * x * (x * (x * 6 - 15) + 10);
 }

Here is the call graph for this function:

float G3D::smoothstep	(	float	edge0,
		float	edge1,
		float	x
	)

inline

The GLSL smoothstep function

                                                            {
     // Scale, bias and saturate x to 0..1 range
     x = clamp((x - edge0) / (edge1 - edge0), 0.0f, 1.0f);
 
     // Evaluate polynomial
     return x * x * (3 - 2 * x);
 }

Here is the call graph for this function:

double G3D::square ( double fValue )

inline

                                {
     return x * x;
 }

Here is the caller graph for this function:

float G3D::square ( float x )

inline

                              {
     return x * x;
 }

int G3D::square ( int x )

inline

                          {
     return x * x;
 }

int G3D::stringCompare	(	const std::string &	s1,
		const std::string &	s2
	)

A comparison function for passing to Array::sort.

                               {
 
     return stringPtrCompare(&s1, &s2);
 }

Here is the call graph for this function:

std::string G3D::stringJoin	(	const G3D::Array< std::string > &	a,
		char	joinChar
	)

joinChar is not inserted at the beginning or end, just in between elements.

                                           {
 
     std::string out;
 
     for (int i = 0; i < (int)a.size() - 1; ++i) {
         out += a[i] + joinChar;
     }
 
     if (a.size() > 0) {
         return out + a.last();
     } else {
         return out;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::stringJoin	(	const G3D::Array< std::string > &	a,
		const std::string &	joinStr
	)

                                        {
 
     std::string out;
 
     for (int i = 0; i < (int)a.size() - 1; ++i) {
         out += a[i] + joinStr;
     }
 
     if (a.size() > 0) {
         return out + a.last();
     } else {
         return out;
     }
 }

Here is the call graph for this function:

int G3D::stringPtrCompare	(	const std::string *	s1,
		const std::string *	s2
	)

                               {
 
     return s1->compare(*s2);
 }

Here is the caller graph for this function:

Array< std::string > G3D::stringSplit	(	const std::string &	x,
		char	splitChar
	)

Splits x at each occurance of splitChar.

                                            {
 
     Array<std::string> out;
     
     // Pointers to the beginning and end of the substring
     const char* start = x.c_str();
     const char* stop = start;
     
     while ((stop = strchr(start, splitChar))) {
         out.append(std::string(start, stop - start));
         start = stop + 1;
     }
 
     // Append the last one
     out.append(std::string(start));
     
     return out;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double G3D::sumSquares	(	double	x,
		double	y
	)

inline

                                              {
     return x*x + y*y;
 }

Here is the caller graph for this function:

double G3D::sumSquares	(	double	x,
		double	y,
		double	z
	)

inline

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

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

inline

                                           {
     return x*x + y*y;
 }

float G3D::sumSquares	(	float	x,
		float	y,
		float	z
	)

inline

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

uint32_t G3D::superFastHash	(	const void *	_data,
		size_t	numBytes
	)

inline

A hash function that is faster than CRC32 for arbitrary long strings [From] http://www.azillionmonkeys.com/qed/hash.html by Paul Hsieh.

                                                                    {
     const char* data = (const char*)_data;
     uint32_t hash = (uint32_t)numBytes;
     uint32_t tmp;
     int rem;
 
     if ((numBytes <= 0) || (data == NULL)) {
         return 0;
     }
 
     rem = numBytes & 3;
     numBytes >>= 2;
 
     /* Main loop */
     for (;numBytes > 0; --numBytes) {
         hash  += get16bits (data);
         tmp    = (get16bits (data+2) << 11) ^ hash;
         hash   = (hash << 16) ^ tmp;
         data  += 2*sizeof (uint16_t);
         hash  += hash >> 11;
     }
 
     /* Handle end cases */
     switch (rem) {
     case 3: hash += get16bits (data);
         hash ^= hash << 16;
         hash ^= data[sizeof (uint16_t)] << 18;
         hash += hash >> 11;
         break;
     case 2: hash += get16bits (data);
         hash ^= hash << 11;
         hash += hash >> 17;
         break;
     case 1: hash += *data;
         hash ^= hash << 10;
         hash += hash >> 1;
     }
 
     /* Force "avalanching" of final 127 bits */
     hash ^= hash << 3;
     hash += hash >> 5;
     hash ^= hash << 4;
     hash += hash >> 17;
     hash ^= hash << 25;
     hash += hash >> 6;
 
     return hash;
 }

Here is the caller graph for this function:

static void G3D::swapRedAndBlue	(	int	N,
		Color3unorm8 *	out
	)

static

Helper method for Bayer grbg and bggr –> rgb8

                                                      {
     for (int i = N - 1; i >= 0; --i) {
     unorm8 tmp = out[i].r;
     out[i].r = out[i].b;
     out[i].b = tmp;
     }
 }

Here is the caller graph for this function:

static int G3D::textPrompt	(	const char *	windowTitle,
		const char *	prompt,
		const char **	choice,
		int	numChoices
	)

static

Show a prompt on stdout

                                     {
 
     printf("\n___________________________________________________\n");
     printf("%s\n", windowTitle);
     printf("%s", prompt);
 
     if (numChoices > 10) {
         numChoices = 10;
     }
 
     int c = -1;
     if (numChoices > 1) {
         printf("\n");
         printf("Choose an option by number:");
 
         while ((c < 0) || (c >= numChoices)) { 
             printf("\n");
 
             for (int i = 0; i < numChoices; ++i) {
                 if (numChoices <= 3) {
                     printf("  (%d) %s ", i, choice[i]);
                 } else {
                     printf("  (%d) %s\n", i, choice[i]);
                 }
             }
 
             printf("\n> ");
             c = _getch() - '0';
 
             if ((c < 0) || (c >= numChoices)) {
                 printf("'%d' is not a valid choice.", c);
             } else {
                 printf("%d", c);
             }
         }
     
     } else if (numChoices == 1) {
         
         printf("\nPress any key for '%s'...", choice[0]);
         _getch();
         c = 0;
 
     } else {
 
         printf("\nPress any key...");
         _getch();
         c = 0;
     }
 
     printf("\n___________________________________________________\n");
     return c;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Any G3D::toAny ( ) const

double G3D::toDegrees ( double rad )

inline

                                     {
     return rad * 180.0 / pi();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::toDegrees ( float rad )

inline

                                   {
     return rad * 180.0f / (float)pi();
 }

Here is the call graph for this function:

float G3D::toDegrees ( int rad )

inline

                                 {
     return rad * 180.0f / (float)pi();
 }

Here is the call graph for this function:

static const char* G3D::tokenTypeToString ( Token::Type t )

static

                                                   {
     switch (t) {
     case Token::SYMBOL:
         return "Token::SYMBOL";
     case Token::STRING:
         return "Token::STRING";
     case Token::NUMBER:
         return "Token::NUMBER";
     case Token::END:
         return "Token::END";
     case Token::NEWLINE:
         return "Token::NEWLINE";
     default:
         debugAssertM(false, "Fell through switch");
         return "?";
     }
 }

Here is the caller graph for this function:

std::string G3D::toLower ( const std::string & x )

                                       {
     std::string result = x;
     std::transform(result.begin(), result.end(), result.begin(), tolower);
     return result;
 }

Here is the caller graph for this function:

static char G3D::toLower ( char c )

inlinestatic

                                    {
     return ((c >= 'A') && (c <= 'Z')) ? (c - 'A' + 'a') : c;
 }

double G3D::toRadians ( double deg )

inline

                                     {
     return deg * pi() / 180.0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

float G3D::toRadians ( float deg )

inline

                                   {
     return deg * (float)pi() / 180.0f;
 }

Here is the call graph for this function:

float G3D::toRadians ( int deg )

inline

                                 {
     return deg * (float)pi() / 180.0f;
 }

Here is the call graph for this function:

SimTime G3D::toSeconds	(	int	hour,
		int	minute,
		double	seconds,
		AMPM	ap
	)

Converts a 12 hour clock time into the number of seconds since midnight. Note that 12:00 PM is noon and 12:00 AM is midnight.

Example: toSeconds(10, 00, AM)

SimTime G3D::toSeconds	(	int	hour,
		int	minute,
		AMPM	ap
	)

std::string G3D::toString ( ) const

Here is the caller graph for this function:

std::string G3D::toUpper ( const std::string & x )

Returns a new string that is an uppercase version of x.

                                       {
     std::string result = x;
     std::transform(result.begin(), result.end(), result.begin(), toupper);
     return result;
 }

Here is the caller graph for this function:

static void G3D::toUpper ( Set< std::string > & set )

static

                                          {
     Array<std::string> symbols;
     set.getMembers(symbols);
     set.clear();
     for (int i = 0; i < symbols.size(); ++i) {
         set.insert(toUpper(symbols[i]));
     }
 }

Here is the call graph for this function:

std::string G3D::trimWhitespace ( const std::string & s )

Strips whitespace from both ends of the string.

                                              {
 
     if (s.length() == 0) {
         return s;
     }
     size_t left = 0;
     
     // Trim from left
     while ((left < s.length()) && iswspace(s[left])) {
         ++left;
     }
 
     size_t right = s.length() - 1;
     // Trim from right
     while ((right > left) && iswspace(s[right])) {
         --right;
     }
     
     return s.substr(left, right - left + 1);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

static

                                                           {
     return Vector3int32(int32(v.x), int32(v.y), int32(v.z));
 }

double G3D::twoPi ( )

inline

                       {
     return 6.28318531;
 }

Here is the caller graph for this function:

float G3D::uniformRandom	(	float	low = `0.0f`,
		float	hi = `1.0f`
	)

inline

Uniform random number between low and hi, inclusive. [low, hi]

Deprecated:

See also: Random::uniform

                                                 {
     return (hi - low) * float(::rand()) / float(RAND_MAX) + low;
 }

Here is the caller graph for this function:

G3D::unorm16 ( uint16 b )

explicit

Private to prevent illogical conversions without explicitly stating that the input should be treated as bits; see fromBits.

38 : m_bits(b) {}

G3D::unorm16 ( )

52 : m_bits(0) {}

G3D::unorm16 ( const unorm16 & other )

54 : m_bits(other.m_bits) {}

G3D::unorm16 ( const class Any & a )

explicit

G3D::unorm16 ( float f )

explicit

Maps f to round(f * 65535).

                               {
         m_bits = uint16(clamp(f, 0.0f, 1.0f) * 65535.0f + 0.5f);
     }

Here is the call graph for this function:

G3D::unorm16 ( double f )

explicit

                                {
         m_bits = uint16(clamp(f, 0.0, 1.0) * 65535.0 + 0.5);
     }

Here is the call graph for this function:

G3D::unorm8 ( uint8 b )

explicit

Private to prevent illogical conversions without explicitly stating that the input should be treated as bits; see fromBits.

39 : m_bits(b) {}

G3D::unorm8 ( )

53 : m_bits(0) {}

G3D::unorm8 ( const unorm8 & other )

55 : m_bits(other.m_bits) {}

G3D::unorm8 ( float f )

explicit

Maps f to round(f * 255).

                              {
         m_bits = (uint8)(clamp(f, 0.0f, 1.0f) * 255.0f + 0.5f);
     }

Here is the call graph for this function:

G3D::unorm8 ( double f )

explicit

                               {
         m_bits = iClamp(int(f * 255.0f + 0.5f), 0, 255);
     }

Here is the call graph for this function:

static void G3D::var	(	TextOutput &	t,
		const std::string &	name,
		const std::string &	val
	)

static

                                                                             {
     t.writeSymbols(name,"=");
     t.writeString(val);
     t.writeNewline();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void G3D::var	(	TextOutput &	t,
		const std::string &	name,
		const bool	val
	)

static

                                                                       {
     t.writeSymbols(name, "=", val ? "Yes" : "No");
     t.writeNewline();
 }

Here is the call graph for this function:

static void G3D::var	(	TextOutput &	t,
		const std::string &	name,
		const int	val
	)

static

                                                                      {
     t.writeSymbols(name,"=");
     t.writeNumber(val);
     t.writeNewline();
 }

Here is the call graph for this function:

G3D::Vector2int16 ( )

40 : x(0), y(0) {}

G3D::int16 y

Definition: Vector2int16.h:38

G3D::int16 x

Definition: Vector2int16.h:37

G3D::Vector2int16	(	G3D::int16	_x,
		G3D::int16	_y
	)

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

G3D::int16 y

Definition: Vector2int16.h:38

G3D::int16 x

Definition: Vector2int16.h:37

G3D::Vector2int16 ( const class Vector2 & v )

explicit

G3D::Vector2int16 ( class BinaryInput & bi )

explicit

G3D::Vector2int16 ( const class Any & a )

explicit

G3D::Vector2int16 ( const class Vector2int32 & v )

explicit

G3D::Vector2int32 ( )

39 : x(0), y(0) {}

G3D::int16 y

Definition: Vector2int16.h:38

G3D::int16 x

Definition: Vector2int16.h:37

G3D::Vector2int32	(	G3D::int32	_x,
		G3D::int32	_y
	)

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

G3D::int16 y

Definition: Vector2int16.h:38

G3D::int16 x

Definition: Vector2int16.h:37

G3D::Vector2int32 ( const class Vector2 & v )

explicit

G3D::Vector2int32 ( class BinaryInput & bi )

explicit

G3D::Vector2int32 ( const class Vector2int16 & v )

G3D::Vector2unorm16 ( )

45 {}

G3D::Vector2unorm16	(	G3D::unorm16	_x,
		G3D::unorm16	_y
	)

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

G3D::int16 y

Definition: Vector2int16.h:38

G3D::int16 x

Definition: Vector2int16.h:37

G3D::Vector2unorm16	(	float	_x,
		float	_y
	)

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

G3D::int16 y

Definition: Vector2int16.h:38

G3D::int16 x

Definition: Vector2int16.h:37

G3D::Vector2unorm16 ( const class Vector2 & v )

explicit

G3D::Vector2unorm16 ( class BinaryInput & bi )

explicit

G3D::Vector2unorm16 ( const class Any & a )

explicit

G3D::Vector3int16 ( )

48 : x(0), y(0), z(0) {}

G3D::int16 z

Definition: Vector3int16.h:46

G3D::int16 y

Definition: Vector2int16.h:38

G3D::int16 x

Definition: Vector2int16.h:37

G3D::Vector3int16	(	G3D::int16	_x,
		G3D::int16	_y,
		G3D::int16	_z
	)

49 : x(_x), y(_y), z(_z) {}

G3D::int16 z

Definition: Vector3int16.h:46

G3D::int16 y

Definition: Vector2int16.h:38

G3D::int16 x

Definition: Vector2int16.h:37

G3D::Vector3int16 ( const class Vector3 & v )

explicit

G3D::Vector3int16 ( class BinaryInput & bi )

explicit

G3D::Vector3int32 ( )

42 : x(0), y(0), z(0) {}

G3D::int16 z

Definition: Vector3int16.h:46

G3D::int16 y

Definition: Vector2int16.h:38

G3D::int16 x

Definition: Vector2int16.h:37

G3D::Vector3int32	(	int	_x,
		int	_y,
		int	_z
	)

43 : x(_x), y(_y), z(_z) {}

G3D::int16 z

Definition: Vector3int16.h:46

G3D::int16 y

Definition: Vector2int16.h:38

G3D::int16 x

Definition: Vector2int16.h:37

G3D::Vector3int32	(	const class Vector2int32 &	v,
		int	_z
	)

G3D::Vector3int32	(	const class Vector2int16 &	v,
		int	_z
	)

G3D::Vector3int32 ( const class Vector3int16 & v )

G3D::Vector3int32 ( const Any & any )

G3D::Vector3int32 ( const class Vector3 & v )

explicit

Rounds to the nearest int

G3D::Vector3int32 ( class BinaryInput & bi )

explicit

std::string G3D::vformat	(	const char *	fmt,
		va_list	argPtr
	)

Like format, but can be called with the argument list from a ... function.

                                                    {
     // If the string is less than 161 characters,
     // allocate it on the stack because this saves
     // the malloc/free time.  The number 161 is chosen
     // to support two lines of text on an 80 character
     // console (plus the null terminator).
     const int bufSize = 161;
     char stackBuffer[bufSize];
 
     va_list argPtrCopy;
     va_copy(argPtrCopy, argPtr);
     int numChars = vsnprintf(stackBuffer, bufSize, fmt, argPtrCopy);
     va_end(argPtrCopy);
 
     if (numChars >= bufSize) {
       // We didn't allocate a big enough string.
       char* heapBuffer = (char*)System::malloc((numChars + 1) * sizeof(char));
 
       debugAssert(heapBuffer);
       int numChars2 = vsnprintf(heapBuffer, numChars + 1, fmt, argPtr);
       debugAssert(numChars2 == numChars);
       (void)numChars2;
 
       std::string result(heapBuffer);
       
       System::free(heapBuffer);
 
       return result;
 
     } else {
 
       return std::string(stackBuffer);
 
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint32_t G3D::wangHash6432Shift ( int64 key )

inline

Thomas Wang's 64-to-32-bit mix hash based on Robert Jenkin's hash http://www.concentric.net/~ttwang/tech/inthash.htm

Found by Morgan to produce the best net performance for building tables from Vector4int16

                                              {
     key = (~key) + (key << 18); // key = (key << 18) - key - 1;
     key = key ^ (key >> 31);
     key = key * 21; // key = (key + (key << 2)) + (key << 4);
     key = key ^ (key >> 11);
     key = key + (key << 6);
     return uint32_t(key) ^ uint32_t(key >> 22);
 }

std::string G3D::wordWrap	(	const std::string &	input,
		int	numCols
	)

Produces a new string that is the input string wrapped at a certain number of columns (where the line is broken at the latest space before the column limit.) Platform specific NEWLINEs are inserted to wrap.

See also: G3D::GFont::wordWrapCut, G3D::TextOutput::Settings::WordWrapMode

                                      {
 
     std::string output;
     size_t      c = 0;
     int         len;
 
     // Don't make lines less than this length
     int         minLength = numCols / 4;
     size_t      inLen = input.size();
 
     bool first = true;
     while (c < inLen) {
         if (first) {
             first = false;
         } else {
             output += NEWLINE;
         }
 
         if ((int)inLen - (int)c - 1 < numCols) {
             // The end
             output += input.substr(c, inLen - c);
             break;
         }
 
         len = numCols;
 
         // Look at character c + numCols, see if it is a space.
         while ((len > minLength) &&
                (input[c + len] != ' ')) {
             len--;
         }
 
         if (len == minLength) {
             // Just crop
             len = numCols;
 
         }
 
         output += input.substr(c, len);
         c += len;
         if (c < input.size()) {
             // Collapse multiple spaces.
             while ((input[c] == ' ') && (c < input.size())) {
                 ++c;
             }
         }
     }
 
     return output;
 }

float G3D::wrap	(	float	t,
		float	lo,
		float	hi
	)

inline

Computes a floating point modulo; the result is t wrapped to the range [lo, hi).

                                                {
     if ((t >= lo) && (t < hi)) {
         return t;
     }
 
     debugAssert(hi > lo);
 
     float interval = hi - lo;
 
     return t - interval * iFloor((t - lo) / interval);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double G3D::wrap	(	double	t,
		double	lo,
		double	hi
	)

inline

                                                    {
     if ((t >= lo) && (t < hi)) {
         return t;
     }
 
     debugAssert(hi > lo);
 
     double interval = hi - lo;
 
     return t - interval * iFloor((t - lo) / interval);
 }

Here is the call graph for this function:

double G3D::wrap	(	double	t,
		double	hi
	)

inline

                                         {
     return wrap(t, 0.0, hi);
 }

Here is the call graph for this function:

void G3D::writeWholeFile	(	const std::string &	filename,
		const std::string &	str,
		bool	flush = `true`
	)

Parameters

flush If true (default), the file is ready for reading as soon as the function returns. If false, the function returns immediately and writes the file in the background.

                                        {
 
     // Make sure the directory exists.
     std::string root, base, ext, path;
     Array<std::string> pathArray;
     parseFilename(filename, root, pathArray, base, ext); 
 
     path = root + stringJoin(pathArray, '/');
     if (! FileSystem::exists(path, false)) {
         FileSystem::createDirectory(path);
     }
 
     FILE* file = FileSystem::fopen(filename.c_str(), "wb");
 
     debugAssert(file);
 
     fwrite(str.c_str(), str.size(), 1, file);
 
     if (flush) {
         fflush(file);
     }
 
     FileSystem::fclose(file);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Vector2int32 G3D::xx ( ) const

Vector2int32 G3D::xy ( ) const

Vector2int32 G3D::xz ( ) const

static void G3D::yuv420p_to_rgb8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                                {
     debugAssertM(srcRowPadBits == 0, "Source row padding must be 0 for this format");
     debugAssertM((srcWidth % 2 == 0) && (srcHeight % 2 == 0), "Source width and height must be a multiple of two");
 
     const unorm8* srcY = static_cast<const unorm8*>(srcBytes[0]);
     const unorm8* srcU = static_cast<const unorm8*>(srcBytes[1]);
     const unorm8* srcV = static_cast<const unorm8*>(srcBytes[2]);
 
     Color3unorm8* dst = static_cast<Color3unorm8*>(dstBytes[0]);
 
     for (int y = 0; y < srcHeight; ++y) {
         for (int x = 0; x < srcWidth; x += 2) {
 
             // convert to two rgb pixels in a row
             Color3unorm8* rgb = &dst[y * srcWidth + x];
 
             int yOffset = y * srcWidth + x;
             int uvOffset = y / 2 * srcWidth / 2 + x / 2;
 
             rgb->r = PIXEL_YUV_TO_RGB8_R(srcY[yOffset], srcU[uvOffset], srcV[uvOffset]);
             rgb->g = PIXEL_YUV_TO_RGB8_G(srcY[yOffset], srcU[uvOffset], srcV[uvOffset]);
             rgb->b = PIXEL_YUV_TO_RGB8_B(srcY[yOffset], srcU[uvOffset], srcV[uvOffset]);
 
             rgb += 1;
             rgb->r = PIXEL_YUV_TO_RGB8_R(srcY[yOffset + 1], srcU[uvOffset], srcV[uvOffset]);
             rgb->g = PIXEL_YUV_TO_RGB8_G(srcY[yOffset + 1], srcU[uvOffset], srcV[uvOffset]);
             rgb->b = PIXEL_YUV_TO_RGB8_B(srcY[yOffset + 1], srcU[uvOffset], srcV[uvOffset]);
         }
     }
 }

static void G3D::yuv422_to_rgb8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                               {
     debugAssertM(srcRowPadBits == 0, "Source row padding must be 0 for this format");
     debugAssertM((srcWidth % 2 == 0), "Source width must be a multiple of two");
 
     const unorm8* src = static_cast<const unorm8*>(srcBytes[0]);
 
     Color3unorm8* dst = static_cast<Color3unorm8*>(dstBytes[0]);
 
     for (int y = 0; y < srcHeight; ++y) {
         for (int x = 0; x < srcWidth; x += 2) {
 
             // convert to two rgb pixels in a row
             Color3unorm8* rgb = &dst[y * srcWidth + x];
             
             const int srcIndex = (y * srcWidth + x) * 2;
             const unorm8 y  = src[srcIndex];
             const unorm8 u  = src[srcIndex + 1];
             const unorm8 y2 = src[srcIndex + 2];
             const unorm8 v  = src[srcIndex + 3];
 
             rgb->r = PIXEL_YUV_TO_RGB8_R(y, u, v);
             rgb->g = PIXEL_YUV_TO_RGB8_G(y, u, v);
             rgb->b = PIXEL_YUV_TO_RGB8_B(y, u, v);
 
             rgb += 1;
             rgb->r = PIXEL_YUV_TO_RGB8_R(y2, u, v);
             rgb->g = PIXEL_YUV_TO_RGB8_G(y2, u, v);
             rgb->b = PIXEL_YUV_TO_RGB8_B(y2, u, v);
         }
     }
 }

static void G3D::yuv444_to_rgb8	(	const Array< const void * > &	srcBytes,
		int	srcWidth,
		int	srcHeight,
		const ImageFormat *	srcFormat,
		int	srcRowPadBits,
		const Array< void * > &	dstBytes,
		const ImageFormat *	dstFormat,
		int	dstRowPadBits,
		bool	invertY,
		ImageFormat::BayerAlgorithm	bayerAlg
	)

static

                                                                                                                                                                                                                                                                               {
     debugAssertM(srcRowPadBits == 0, "Source row padding must be 0 for this format");
 
     const Color3unorm8* src = static_cast<const Color3unorm8*>(srcBytes[0]);
 
     Color3unorm8* dst = static_cast<Color3unorm8*>(dstBytes[0]);
 
     for (int y = 0; y < srcHeight; ++y) {
         for (int x = 0; x < srcWidth; ++x) {
 
             // convert to one rgb pixels at a time
             const int index = y * srcWidth + x;
             const Color3unorm8 s = src[index];
 
             Color3unorm8& rgb = dst[index];
             rgb.r = PIXEL_YUV_TO_RGB8_R(s.r, s.g, s.b);
             rgb.g = PIXEL_YUV_TO_RGB8_G(s.r, s.g, s.b);
             rgb.b = PIXEL_YUV_TO_RGB8_B(s.r, s.g, s.b);
         }
     }
 }

Vector2int32 G3D::yx ( ) const

Vector2int32 G3D::yy ( ) const

Vector2int32 G3D::yz ( ) const

static unorm8 G3D::zero ( )

static

                          {
         return fromBits(0);
     }

Here is the call graph for this function:

static unorm16 G3D::zero ( )

static

                           {
         return fromBits(0);
     }

Here is the call graph for this function:

bool G3D::zipfileExists	(	const std::string &	filename,
		std::string &	outZipfile,
		std::string &	outInternalFile
	)

Returns true if the given file (or directory) exists within a zipfile. Called if fileExists initially returns false and the lookInZipfiles flag has been set. Must not end in a trailing slash. Does not work for recursive zipfiles (.zips within another .zip)

Parameters

filename	the path to test
outZipfile	the path to the .zip file
outInternalFile	the path (within the .zip) where the desired file is located, if valid

If no zipfile exists, outZipfile and outInternalFile are unchanged

                                               {
 #if _HAVE_ZIP /* G3DFIX: Use ZIP-library only if defined */
     Array<std::string> path;
     std::string drive, base, ext, zipfile, infile;
     parseFilename(filename, drive, path, base, ext);
     
     // Put the filename back together
     if ((base != "") && (ext != "")) {
         infile = base + "." + ext;
     } else {
         infile = base + ext;
     }
     
     // Remove all standalone single dots (".") from path
     for (int i = 0; i < path.length(); ++i) {
         if (path[i] == ".") {
             path.remove(i);
             --i;
         }
     }
     
     // Remove non-leading ".." from path
     for (int i = 1; i < path.length(); ++i) {
         if ((path[i] == "..") && (i > 0) && (path[i - 1] != "..")) {
             // Remove both i and i - 1
             path.remove(i - 1, 2);
             i -= 2;
         }
     }
     
     // Walk the path backwards, accumulating pieces onto the infile until
     // we find a zipfile that contains it
     for (int t = 0; t < path.length(); ++t){
         _zip_resolveDirectory(zipfile, drive, path,  path.length() - t);
         if (t > 0) {
             infile = path[path.length() - t] + "/" + infile;
         }
 
         if (endsWith(zipfile, "..")) {
             return false;
         }
         
         if (FileSystem::exists(zipfile)) {
             // test if it actually is a zipfile
             // if not, return false, a bad
             // directory structure has been given,
             // not a .zip
             if (FileSystem::isZipfile(zipfile)){
                 
                 if (_zip_zipContains(zipfile, infile)){
                     outZipfile = zipfile;
                     outInternalFile = infile;
                     return true;
                 } else {
                     return false;
                 }
             } else {
                 // the directory structure was valid but did not point to a .zip
                 return false;
             }
         }
         
     }
 #else
     (void)filename;
     (void)outZipfile;
     (void)outInternalFile;
 #endif
     // not a valid directory structure ever, 
     // obviously no .zip was found within the path 
     return false;
 }    

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::zipfileExists ( const std::string & filename )

                                               {
     std::string    outZipfile;
     std::string    outInternalFile;
     return zipfileExists(filename, outZipfile, outInternalFile);
 }

Here is the call graph for this function:

Vector2int32 G3D::zx ( ) const

Vector2int32 G3D::zy ( ) const

Vector2int32 G3D::zz ( ) const

Variable Documentation

Set<std::string> G3D::_filesUsed

static

BufferPool* G3D::bufferpool = NULL

static

const bool G3D::CLEAR_FORMAT = false

static

FileSystem* G3D::common = NULL

static

const bool G3D::COMP_FORMAT = true

static

Array<std::string> G3D::directoryArray

static

const bool G3D::DONT_SHRINK_UNDERLYING_ARRAY = false

Constant for passing to Array::resize

const float G3D::G_BGB[5][5]

static

Initial value:

=
    {{     0.0f,      0.0f,     -1.0f,      0.0f,      0.0f},
     {     0.0f,      0.0f,      2.0f,      0.0f,      0.0f},
     {    -1.0f,      2.0f,      4.0f,      2.0f,     -1.0f},
     {     0.0f,      0.0f,      2.0f,      0.0f,      0.0f},
     {     0.0f,      0.0f,     -1.0f,      0.0f,      0.0f}}

const float G3D::G_GRR[5][5]

static

Initial value:

=
    {{     0.0f,      0.0f,     -1.0f,      0.0f,      0.0f},
     {     0.0f,      0.0f,      2.0f,      0.0f,      0.0f},
     {    -1.0f,      2.0f,      4.0f,      2.0f,     -1.0f},
     {     0.0f,      0.0f,      2.0f,      0.0f,      0.0f},
     {     0.0f,      0.0f,     -1.0f,      0.0f,      0.0f}}

Table<std::string, std::string> G3D::lastFound

static

const std::string G3D::nameArray[ImageFormat::CODE_NUM]

static

const char * G3D::NEWLINE = "\n"

const int G3D::NUM_CONVERT_IMAGE_FORMATS = 5

static

const bool G3D::OPAQUE_FORMAT = true

static

const float G3D::R_BGB[5][5]

static

Initial value:

=
    {{     0.0f,      0.0f, -3.0f/2.0f,      0.0f,      0.0f},
     {     0.0f,      2.0f,      0.0f,      2.0f,      0.0f},
     {-3.0f/2.0f,      0.0f,      6.0f,      0.0f, -3.0f/2.0f},
     {     0.0f,      2.0f,      0.0f,      2.0f,      0.0f},
     {     0.0f,      0.0f, -3.0f/2.0f,      0.0f,      0.0f}}

const float G3D::R_BGG[5][5]

static

Initial value:

=
    {{     0.0f,      0.0f,     -1.0f,      0.0f,      0.0f},
     {     0.0f,     -1.0f,      4.0f,     -1.0f,      0.0f},
     {     0.5f,      0.0f,      5.0f,      0.0f,      0.5f},
     {     0.0f,     -1.0f,      4.0f,     -1.0f,      0.0f},
     {     0.0f,      0.0f,     -1.0f,      0.0f,      0.0f}}

const float G3D::R_GRG[5][5]

static

Initial value:

=
    {{     0.0f,      0.0f,      0.5f,      0.0f,      0.0f},
     {     0.0f,     -1.0f,      0.0f,     -1.0f,      0.0f},
     {    -1.0f,      4.0f,      5.0f,      4.0f,     -1.0f},
     {     0.0f,     -1.0f,      0.0f,     -1.0f,      0.0f},
     {     0.0f,      0.0f,      0.5f,      0.0f,      0.0f}}

const ConvertAttributes G3D::sConvertMappings[]

static

const int G3D::SORT_DECREASING = -1

Constant for Array::sort

const int G3D::SORT_INCREASING = 1

Constant for Array::sort

const bool G3D::UNCOMP_FORMAT = false

static

G3D::unorm16

Initial value:

{
private:
    uint16    m_bits

Represents numbers on [0, 1] in 16 bits as an unsigned normalized 0.8 fixed-point value using the same encoding scheme as OpenGL.

Note that arithmetic operations may over and under-flow, just like uint16 arithmetic.

OpenGL specifications can be found here: http://www.opengl.org/registry/specs/ARB/shading_language_packing.txt

G3D::unorm8

Initial value:

{
private:
    uint8    m_bits

Represents numbers on [0, 1] in 8 bits as an unsigned normalized 0.8 fixed-point value using the same encoding scheme as OpenGL.

OpenGL specifications can be found here: <www.opengl.org/registry/specs/ARB/shading_language_packing.txt>

Note that arithmetic operations may over and under-flow, just like uint8 arithmetic.

Vector2int16::Vector2int16

Initial value:

{
private:
    
    bool operator<(const Vector2int16&) const

G3D::Vector2int32

Initial value:

{
private:
    
    bool operator<(const Vector2int32&) const

G3D::Vector2unorm16

Initial value:

{
private:
    
    bool operator<(const Vector2unorm16&) const

Vector3int16::Vector3int16

Initial value:

{
private:
    
    bool operator<(const Vector3int16&) const

G3D::Vector3int32::Vector3int32

Initial value:

{
private:
    
    bool operator<(const Vector3int32&) const

\ Vector3int32 A Vector3 that packs its fields into uint32s.

G3D::int32 G3D::x

G3D::int32 G3D::y

G3D::int32 G3D::z