irr::core Namespace Reference

Basic classes such as vectors, planes, arrays, lists, and so on can be found in this namespace. More...

Namespaces
	unicode

Classes
class	aabbox3d
	Axis aligned bounding box in 3d dimensional space. More...
class	array
	Self reallocating template array (like stl vector) with additional features. More...
class	CMatrix4
	4x4 matrix. Mostly used as transformation matrix for 3d calculations. More...
class	dimension2d
	Specifies a 2 dimensional size. More...
union	FloatIntUnion32
union	inttofloat
class	irrAllocator
	Very simple allocator implementation, containers using it can be used across dll boundaries. More...
class	irrAllocatorFast
	Fast allocator, only to be used in containers inside the same memory heap. More...
class	line2d
	2D line between two points with intersection methods. More...
class	line3d
	3D line between two points with intersection methods. More...
class	list
	Doubly linked list template. More...
class	map
	map template for associative arrays using a red-black tree More...
class	plane3d
	Template plane class with some intersection testing methods. More...
class	quaternion
	Quaternion class for representing rotations. More...
class	rect
	Rectangle template. More...
class	string
	Very simple string class with some useful features. More...
class	triangle3d
	3d triangle template class for doing collision detection and other things. More...
class	ustring16
	UTF-16 string class. More...
class	vector2d
	2d vector template class with lots of operators and methods. More...
class	vector3d
	3d vector template class with lots of operators and methods. More...

Typedefs
typedef aabbox3d< f32 >	aabbox3df
	Typedef for a f32 3d bounding box. More...
typedef aabbox3d< s32 >	aabbox3di
	Typedef for an integer 3d bounding box. More...
typedef dimension2d< f32 >	dimension2df
	Typedef for an f32 dimension. More...
typedef dimension2d< u32 >	dimension2du
	Typedef for an unsigned integer dimension. More...
typedef dimension2d< s32 >	dimension2di
	Typedef for an integer dimension. More...
typedef string< c8 >	stringc
	Typedef for character strings. More...
typedef string< wchar_t >	stringw
	Typedef for wide character strings. More...
typedef line2d< f32 >	line2df
	Typedef for an f32 line. More...
typedef line2d< s32 >	line2di
	Typedef for an integer line. More...
typedef line3d< f32 >	line3df
	Typedef for an f32 line. More...
typedef line3d< s32 >	line3di
	Typedef for an integer line. More...
typedef CMatrix4< f32 >	matrix4
	Typedef for f32 matrix. More...
typedef plane3d< f32 >	plane3df
	Typedef for a f32 3d plane. More...
typedef plane3d< s32 >	plane3di
	Typedef for an integer 3d plane. More...
typedef vector2d< f32 >	position2df
typedef vector2d< s32 >	position2di
typedef rect< f32 >	rectf
	Rectangle with float values. More...
typedef rect< s32 >	recti
	Rectangle with int values. More...
typedef triangle3d< f32 >	triangle3df
	Typedef for a f32 3d triangle. More...
typedef triangle3d< s32 >	triangle3di
	Typedef for an integer 3d triangle. More...
typedef vector2d< f32 >	vector2df
	Typedef for f32 2d vector. More...
typedef vector2d< s32 >	vector2di
	Typedef for integer 2d vector. More...
typedef vector3d< f32 >	vector3df
	Typedef for a f32 3d vector. More...
typedef vector3d< s32 >	vector3di
	Typedef for an integer 3d vector. More...
typedef ustring16< irrAllocator< uchar16_t > >	ustring

Enumerations
enum	eAllocStrategy { ALLOC_STRATEGY_SAFE = 0, ALLOC_STRATEGY_DOUBLE = 1, ALLOC_STRATEGY_SQRT = 2 }
	defines an allocation strategy (used only by irr::array so far) More...
enum	eLocaleID { IRR_LOCALE_ANSI = 0, IRR_LOCALE_GERMAN = 1 }
enum	EIntersectionRelation3D {   ISREL3D_FRONT = 0, ISREL3D_BACK, ISREL3D_PLANAR, ISREL3D_SPANNING,   ISREL3D_CLIPPED }
	Enumeration for intersection relations of 3d objects. More...

Functions
s32	isFileExtension (const io::path &filename, const io::path &ext0, const io::path &ext1, const io::path &ext2)
	search if a filename has a proper extension More...
bool	hasFileExtension (const io::path &filename, const io::path &ext0, const io::path &ext1="", const io::path &ext2="")
	search if a filename has a proper extension More...
io::path &	cutFilenameExtension (io::path &dest, const io::path &source)
	cut the filename extension from a source file path and store it in a dest file path More...
io::path &	getFileNameExtension (io::path &dest, const io::path &source)
	get the filename extension from a file path More...
io::path &	deletePathFromFilename (io::path &filename)
	delete path from filename More...
io::path &	deletePathFromPath (io::path &filename, s32 pathCount)
	trim paths More...
s32	isInSameDirectory (const io::path &path, const io::path &file)
s32	isdigit (s32 c)
	some standard function ( to remove dependencies ) More...
s32	isspace (s32 c)
s32	isupper (s32 c)
u32	strtoul10 (const char *in, const char **out=0)
	Convert a simple string of base 10 digits into an unsigned 32 bit integer. More...
s32	strtol10 (const char *in, const char **out=0)
	Convert a simple string of base 10 digits into a signed 32 bit integer. More...
u32	ctoul16 (char in)
	Convert a hex-encoded character to an unsigned integer. More...
u32	strtoul16 (const char *in, const char **out=0)
	Convert a simple string of base 16 digits into an unsigned 32 bit integer. More...
u32	strtoul8 (const char *in, const char **out=0)
	Convert a simple string of base 8 digits into an unsigned 32 bit integer. More...
u32	strtoul_prefix (const char *in, const char **out=0)
	Convert a C-style prefixed string (hex, oct, integer) into an unsigned 32 bit integer. More...
f32	strtof10 (const char *in, const char **out=0)
	Converts a sequence of digits into a whole positive floating point value. More...
const char *	fast_atof_move (const char *in, f32 &result)
	Provides a fast function for converting a string into a float. More...
float	fast_atof (const char *floatAsString, const char **out=0)
	Convert a string to a floating point number. More...
template<class T >
void	heapsink (T *array, s32 element, s32 max)
	Sinks an element into the heap. More...
template<class T >
void	heapsort (T *array_, s32 size)
	Sorts an array with size 'size' using heapsort. More...
f32	radToDeg (f32 radians)
	Utility function to convert a radian value to degrees. More...
f64	radToDeg (f64 radians)
	Utility function to convert a radian value to degrees. More...
f32	degToRad (f32 degrees)
	Utility function to convert a degrees value to radians. More...
f64	degToRad (f64 degrees)
	Utility function to convert a degrees value to radians. More...
template<class T >
const T &	min_ (const T &a, const T &b)
	returns minimum of two values. Own implementation to get rid of the STL (VS6 problems) More...
template<class T >
const T &	min_ (const T &a, const T &b, const T &c)
	returns minimum of three values. Own implementation to get rid of the STL (VS6 problems) More...
template<class T >
const T &	max_ (const T &a, const T &b)
	returns maximum of two values. Own implementation to get rid of the STL (VS6 problems) More...
template<class T >
const T &	max_ (const T &a, const T &b, const T &c)
	returns maximum of three values. Own implementation to get rid of the STL (VS6 problems) More...
template<class T >
T	abs_ (const T &a)
	returns abs of two values. Own implementation to get rid of STL (VS6 problems) More...
template<class T >
T	lerp (const T &a, const T &b, const f32 t)
template<class T >
const T	clamp (const T &value, const T &low, const T &high)
	clamps a value between low and high More...
template<class T1 , class T2 >
void	swap (T1 &a, T2 &b)
	swaps the content of the passed parameters More...
template<class T >
T	roundingError ()
template<>
f32	roundingError ()
template<>
f64	roundingError ()
template<>
s32	roundingError ()
template<>
u32	roundingError ()
template<>
s64	roundingError ()
template<>
u64	roundingError ()
template<class T >
T	relativeErrorFactor ()
template<>
f32	relativeErrorFactor ()
template<>
f64	relativeErrorFactor ()
template<class T >
bool	equals (const T a, const T b, const T tolerance=roundingError< T >())
	returns if a equals b, taking possible rounding errors into account More...
template<class T >
bool	equalsRelative (const T a, const T b, const T factor=relativeErrorFactor< T >())
bool	equalsByUlp (f32 a, f32 b, int maxUlpDiff)
	We compare the difference in ULP's (spacing between floating-point numbers, aka ULP=1 means there exists no float between). More...
bool	iszero (const f64 a, const f64 tolerance=ROUNDING_ERROR_f64)
	returns if a equals zero, taking rounding errors into account More...
bool	iszero (const f32 a, const f32 tolerance=ROUNDING_ERROR_f32)
	returns if a equals zero, taking rounding errors into account More...
bool	isnotzero (const f32 a, const f32 tolerance=ROUNDING_ERROR_f32)
	returns if a equals not zero, taking rounding errors into account More...
bool	iszero (const s32 a, const s32 tolerance=0)
	returns if a equals zero, taking rounding errors into account More...
bool	iszero (const u32 a, const u32 tolerance=0)
	returns if a equals zero, taking rounding errors into account More...
bool	iszero (const s64 a, const s64 tolerance=0)
	returns if a equals zero, taking rounding errors into account More...
s32	s32_min (s32 a, s32 b)
s32	s32_max (s32 a, s32 b)
s32	s32_clamp (s32 value, s32 low, s32 high)
u32	IR (f32 x)
f32	FR (u32 x)
	Floating-point representation of an integer value. More...
f32	FR (s32 x)
REALINLINE u32	if_c_a_else_b (const s32 condition, const u32 a, const u32 b)
	conditional set based on mask and arithmetic shift More...
REALINLINE u16	if_c_a_else_b (const s16 condition, const u16 a, const u16 b)
	conditional set based on mask and arithmetic shift More...
REALINLINE u32	if_c_a_else_0 (const s32 condition, const u32 a)
	conditional set based on mask and arithmetic shift More...
REALINLINE void	setbit_cond (u32 &state, s32 condition, u32 mask)
f32	round_ (f32 x)
REALINLINE f32	squareroot (const f32 f)
REALINLINE f64	squareroot (const f64 f)
REALINLINE s32	squareroot (const s32 f)
REALINLINE s64	squareroot (const s64 f)
REALINLINE f64	reciprocal_squareroot (const f64 x)
REALINLINE f32	reciprocal_squareroot (const f32 f)
REALINLINE s32	reciprocal_squareroot (const s32 x)
REALINLINE f32	reciprocal (const f32 f)
REALINLINE f64	reciprocal (const f64 f)
REALINLINE f32	reciprocal_approxim (const f32 f)
REALINLINE s32	floor32 (f32 x)
REALINLINE s32	ceil32 (f32 x)
REALINLINE s32	round32 (f32 x)
f32	f32_max3 (const f32 a, const f32 b, const f32 c)
f32	f32_min3 (const f32 a, const f32 b, const f32 c)
f32	fract (f32 x)
IRRLICHT_API void	utf8ToWchar (const char *in, wchar_t *out, const u64 len)
	Convert this utf-8-encoded string to the platform's wchar. More...
IRRLICHT_API void	wcharToUtf8 (const wchar_t *in, char *out, const u64 len)
	Convert this wchar string to utf-8. More...
template<class T >
CMatrix4< T >	operator * (const T scalar, const CMatrix4< T > &mat)
template<class S , class T >
vector2d< T >	operator * (const S scalar, const vector2d< T > &vector)
template<class S , class T >
vector3d< T >	operator * (const S scalar, const vector3d< T > &vector)
	Function multiplying a scalar and a vector component-wise. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const ustring16< TAlloc > &left, const ustring16< TAlloc > &right)
	Appends two ustring16s. More...
template<typename TAlloc , class B >
ustring16< TAlloc >	operator+ (const ustring16< TAlloc > &left, const B *const right)
	Appends a ustring16 and a null-terminated unicode string. More...
template<class B , typename TAlloc >
ustring16< TAlloc >	operator+ (const B *const left, const ustring16< TAlloc > &right)
	Appends a ustring16 and a null-terminated unicode string. More...
template<typename TAlloc , typename B , typename BAlloc >
ustring16< TAlloc >	operator+ (const ustring16< TAlloc > &left, const string< B, BAlloc > &right)
	Appends a ustring16 and an Irrlicht string. More...
template<typename TAlloc , typename B , typename BAlloc >
ustring16< TAlloc >	operator+ (const string< B, BAlloc > &left, const ustring16< TAlloc > &right)
	Appends a ustring16 and an Irrlicht string. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const ustring16< TAlloc > &left, const char right)
	Appends a ustring16 and a char. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const char left, const ustring16< TAlloc > &right)
	Appends a ustring16 and a char. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const ustring16< TAlloc > &left, const short right)
	Appends a ustring16 and a short. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const short left, const ustring16< TAlloc > &right)
	Appends a ustring16 and a short. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const ustring16< TAlloc > &left, const unsigned short right)
	Appends a ustring16 and an unsigned short. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const unsigned short left, const ustring16< TAlloc > &right)
	Appends a ustring16 and an unsigned short. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const ustring16< TAlloc > &left, const int right)
	Appends a ustring16 and an int. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const int left, const ustring16< TAlloc > &right)
	Appends a ustring16 and an int. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const ustring16< TAlloc > &left, const unsigned int right)
	Appends a ustring16 and an unsigned int. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const unsigned int left, const ustring16< TAlloc > &right)
	Appends a ustring16 and an unsigned int. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const ustring16< TAlloc > &left, const long right)
	Appends a ustring16 and a long. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const long left, const ustring16< TAlloc > &right)
	Appends a ustring16 and a long. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const ustring16< TAlloc > &left, const unsigned long right)
	Appends a ustring16 and an unsigned long. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const unsigned long left, const ustring16< TAlloc > &right)
	Appends a ustring16 and an unsigned long. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const ustring16< TAlloc > &left, const float right)
	Appends a ustring16 and a float. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const float left, const ustring16< TAlloc > &right)
	Appends a ustring16 and a float. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const ustring16< TAlloc > &left, const double right)
	Appends a ustring16 and a double. More...
template<typename TAlloc >
ustring16< TAlloc >	operator+ (const double left, const ustring16< TAlloc > &right)
	Appends a ustring16 and a double. More...

Variables
IRRLICHT_API irr::core::stringc	LOCALE_DECIMAL_POINTS
	Selection of characters which count as decimal point in fast_atof. More...
const float	fast_atof_table [17]
const s32	ROUNDING_ERROR_S32 = 0
	Rounding error constant often used when comparing f32 values. More...
const s64	ROUNDING_ERROR_S64 = 0
const f32	ROUNDING_ERROR_f32 = 0.000001f
const f64	ROUNDING_ERROR_f64 = 0.00000001
const f32	PI = 3.14159265359f
	Constant for PI. More...
const f32	RECIPROCAL_PI = 1.0f/PI
	Constant for reciprocal of PI. More...
const f32	HALF_PI = PI/2.0f
	Constant for half of PI. More...
const f64	PI64 = 3.1415926535897932384626433832795028841971693993751
	Constant for 64bit PI. More...
const f64	RECIPROCAL_PI64 = 1.0/PI64
	Constant for 64bit reciprocal of PI. More...
const f32	DEGTORAD = PI / 180.0f
	32bit Constant for converting from degrees to radians More...
const f32	RADTODEG = 180.0f / PI
	32bit constant for converting from radians to degrees (formally known as GRAD_PI) More...
const f64	DEGTORAD64 = PI64 / 180.0
	64bit constant for converting from degrees to radians (formally known as GRAD_PI2) More...
const f64	RADTODEG64 = 180.0 / PI64
	64bit constant for converting from radians to degrees More...
IRRLICHT_API const matrix4	IdentityMatrix
	global const identity matrix More...

Detailed Description

Basic classes such as vectors, planes, arrays, lists, and so on can be found in this namespace.

Typedef Documentation

aabbox3df

typedef aabbox3d<f32> irr::core::aabbox3df

Typedef for a f32 3d bounding box.

Definition at line 361 of file aabbox3d.h.

aabbox3di

typedef aabbox3d<s32> irr::core::aabbox3di

Typedef for an integer 3d bounding box.

Definition at line 363 of file aabbox3d.h.

dimension2df

typedef dimension2d<f32> irr::core::dimension2df

Typedef for an f32 dimension.

Definition at line 210 of file dimension2d.h.

dimension2di

typedef dimension2d<s32> irr::core::dimension2di

Typedef for an integer dimension.

There are few cases where negative dimensions make sense. Please consider using dimension2du instead.

Definition at line 217 of file dimension2d.h.

dimension2du

typedef dimension2d<u32> irr::core::dimension2du

Typedef for an unsigned integer dimension.

Definition at line 212 of file dimension2d.h.

line2df

typedef line2d<f32> irr::core::line2df

Typedef for an f32 line.

Definition at line 352 of file line2d.h.

line2di

typedef line2d<s32> irr::core::line2di

Typedef for an integer line.

Definition at line 354 of file line2d.h.

line3df

typedef line3d<f32> irr::core::line3df

Typedef for an f32 line.

Definition at line 136 of file line3d.h.

line3di

typedef line3d<s32> irr::core::line3di

Typedef for an integer line.

Definition at line 138 of file line3d.h.

matrix4

typedef CMatrix4<f32> irr::core::matrix4

Typedef for f32 matrix.

Definition at line 2377 of file matrix4.h.

plane3df

typedef plane3d<f32> irr::core::plane3df

Typedef for a f32 3d plane.

Definition at line 236 of file plane3d.h.

plane3di

typedef plane3d<s32> irr::core::plane3di

Typedef for an integer 3d plane.

Definition at line 239 of file plane3d.h.

position2df

typedef vector2d<f32> irr::core::position2df

Deprecated:

position2d is now a synonym for vector2d, but vector2d should be used directly.

Definition at line 21 of file position2d.h.

position2di

typedef vector2d<s32> irr::core::position2di

Deprecated:

position2d is now a synonym for vector2d, but vector2d should be used directly.

Definition at line 24 of file position2d.h.

rectf

typedef rect<f32> irr::core::rectf

Rectangle with float values.

Definition at line 276 of file rect.h.

recti

typedef rect<s32> irr::core::recti

Rectangle with int values.

Definition at line 278 of file rect.h.

stringc

typedef string<c8> irr::core::stringc

Typedef for character strings.

Definition at line 1458 of file irrString.h.

stringw

typedef string<wchar_t> irr::core::stringw

Typedef for wide character strings.

Definition at line 1461 of file irrString.h.

triangle3df

typedef triangle3d<f32> irr::core::triangle3df

Typedef for a f32 3d triangle.

Definition at line 270 of file triangle3d.h.

triangle3di

typedef triangle3d<s32> irr::core::triangle3di

Typedef for an integer 3d triangle.

Definition at line 273 of file triangle3d.h.

ustring

typedef ustring16<irrAllocator<uchar16_t> > irr::core::ustring

Definition at line 3289 of file irrUString.h.

vector2df

typedef vector2d<f32> irr::core::vector2df

Typedef for f32 2d vector.

Definition at line 403 of file vector2d.h.

vector2di

typedef vector2d<s32> irr::core::vector2di

Typedef for integer 2d vector.

Definition at line 406 of file vector2d.h.

vector3df

typedef vector3d<f32> irr::core::vector3df

Typedef for a f32 3d vector.

Definition at line 461 of file vector3d.h.

vector3di

typedef vector3d<s32> irr::core::vector3di

Typedef for an integer 3d vector.

Definition at line 464 of file vector3d.h.

Enumeration Type Documentation

eAllocStrategy

enum irr::core::eAllocStrategy

defines an allocation strategy (used only by irr::array so far)

Enumerator
ALLOC_STRATEGY_SAFE
ALLOC_STRATEGY_DOUBLE
ALLOC_STRATEGY_SQRT

Definition at line 112 of file irrAllocator.h.

{
        ALLOC_STRATEGY_SAFE    = 0,     // increase size by 1
        ALLOC_STRATEGY_DOUBLE  = 1,     // double size when under 500 elements, beyond that increase by 1/4th size. Plus a small constant.
        ALLOC_STRATEGY_SQRT    = 2      // not implemented
};

EIntersectionRelation3D

enum irr::core::EIntersectionRelation3D

Enumeration for intersection relations of 3d objects.

Enumerator
ISREL3D_FRONT
ISREL3D_BACK
ISREL3D_PLANAR
ISREL3D_SPANNING
ISREL3D_CLIPPED

Definition at line 17 of file plane3d.h.

{
        ISREL3D_FRONT = 0,
        ISREL3D_BACK,
        ISREL3D_PLANAR,
        ISREL3D_SPANNING,
        ISREL3D_CLIPPED
};

eLocaleID

enum irr::core::eLocaleID

Enumerator
IRR_LOCALE_ANSI
IRR_LOCALE_GERMAN

Definition at line 41 of file irrString.h.

{
        IRR_LOCALE_ANSI = 0,
        IRR_LOCALE_GERMAN = 1
};

Function Documentation

abs_()

template<class T >

T irr::core::abs_ ( const T &  a )

inline

returns abs of two values. Own implementation to get rid of STL (VS6 problems)

Definition at line 152 of file irrMath.h.

        {
                return a < (T)0 ? -a : a;
        }

ceil32()

REALINLINE s32 irr::core::ceil32

(

f32

x

)

Definition at line 651 of file irrMath.h.

        {
                return (s32) ceilf ( x );
        }

clamp()

template<class T >

const T irr::core::clamp ( const T &  value, const T &  low, const T &  high  )

inline

clamps a value between low and high

Definition at line 167 of file irrMath.h.

        {
                return min_ (max_(value,low), high);
        }

ctoul16()

u32 irr::core::ctoul16 ( char  in )

inline

Convert a hex-encoded character to an unsigned integer.

Parameters

[in]

in

The digit to convert. Only digits 0 to 9 and chars A-F,a-f will be considered.

Returns

The unsigned integer value of the digit. 0xffffffff if the input is not hex

Definition at line 126 of file fast_atof.h.

{
        if (in >= '0' && in <= '9')
                return in - '0';
        else if (in >= 'a' && in <= 'f')
                return 10u + in - 'a';
        else if (in >= 'A' && in <= 'F')
                return 10u + in - 'A';
        else
                return 0xffffffff;
}

cutFilenameExtension()

io::path& irr::core::cutFilenameExtension ( io::path &  dest, const io::path &  source  )

inline

cut the filename extension from a source file path and store it in a dest file path

Definition at line 48 of file coreutil.h.

{
        s32 endPos = source.findLast ( '.' );
        dest = source.subString ( 0, endPos < 0 ? source.size () : endPos );
        return dest;
}

degToRad() [1/2]

f32 irr::core::degToRad ( f32  degrees )

inline

Utility function to convert a degrees value to radians.

Provided as it can be clearer to write degToRad(X) than DEGTORAD * X

Parameters

degrees

The degrees value to convert to radians.

Definition at line 108 of file irrMath.h.

        {
                return DEGTORAD * degrees;
        }

degToRad() [2/2]

f64 irr::core::degToRad ( f64  degrees )

inline

Utility function to convert a degrees value to radians.

Provided as it can be clearer to write degToRad(X) than DEGTORAD * X

Parameters

degrees

The degrees value to convert to radians.

Definition at line 117 of file irrMath.h.

        {
                return DEGTORAD64 * degrees;
        }

deletePathFromFilename()

io::path& irr::core::deletePathFromFilename ( io::path &  filename )

inline

delete path from filename

Definition at line 67 of file coreutil.h.

{
        // delete path from filename
        const fschar_t* s = filename.c_str();
        const fschar_t* p = s + filename.size();

        // search for path separator or beginning
        while ( *p != '/' && *p != '\\' && p != s )
                p--;

        if ( p != s )
        {
                ++p;
                filename = p;
        }
        return filename;
}

deletePathFromPath()

io::path& irr::core::deletePathFromPath ( io::path &  filename, s32  pathCount  )

inline

trim paths

Definition at line 86 of file coreutil.h.

{
        // delete path from filename
        s32 i = filename.size();

        // search for path separator or beginning
        while ( i>=0 )
        {
                if ( filename[i] == '/' || filename[i] == '\\' )
                {
                        if ( --pathCount <= 0 )
                                break;
                }
                --i;
        }

        if ( i>0 )
        {
                filename [ i + 1 ] = 0;
                filename.validate();
        }
        else
                filename="";
        return filename;
}

equals()

template<class T >

bool irr::core::equals ( const T  a, const T  b, const T  tolerance = roundingError<T>()  )

inline

returns if a equals b, taking possible rounding errors into account

Definition at line 246 of file irrMath.h.

        {
                return (a + tolerance >= b) && (a - tolerance <= b);
        }

equalsByUlp()

bool irr::core::equalsByUlp ( f32  a, f32  b, int  maxUlpDiff  )

inline

We compare the difference in ULP's (spacing between floating-point numbers, aka ULP=1 means there exists no float between).

Definition at line 278 of file irrMath.h.

        {
                // Based on the ideas and code from Bruce Dawson on
                // http://www.altdevblogaday.com/2012/02/22/comparing-floating-point-numbers-2012-edition/
                // When floats are interpreted as integers the two nearest possible float numbers differ just
                // by one integer number. Also works the other way round, an integer of 1 interpreted as float
                // is for example the smallest possible float number.

                const FloatIntUnion32 fa(a);
                const FloatIntUnion32 fb(b);

                // Different signs, we could maybe get difference to 0, but so close to 0 using epsilons is better.
                if ( fa.sign() != fb.sign() )
                {
                        // Check for equality to make sure +0==-0
                        if (fa.i == fb.i)
                                return true;
                        return false;
                }

                // Find the difference in ULPs.
                const int ulpsDiff = abs_(fa.i- fb.i);
                if (ulpsDiff <= maxUlpDiff)
                        return true;

                return false;
        }

equalsRelative()

template<class T >

bool irr::core::equalsRelative ( const T  a, const T  b, const T  factor = relativeErrorFactor<T>()  )

inline

returns if a equals b, taking relative error in form of factor this particular function does not involve any division.

Definition at line 255 of file irrMath.h.

        {
                //https://eagergames.wordpress.com/2017/04/01/fast-parallel-lines-and-vectors-test/

                const T maxi = max_( a, b);
                const T mini = min_( a, b);
                const T maxMagnitude = max_( maxi, -mini);

                return  (maxMagnitude*factor + maxi) == (maxMagnitude*factor + mini); // MAD Wise
        }

f32_max3()

f32 irr::core::f32_max3 ( const f32  a, const f32  b, const f32  c  )

inline

Definition at line 662 of file irrMath.h.

        {
                return a > b ? (a > c ? a : c) : (b > c ? b : c);
        }

f32_min3()

f32 irr::core::f32_min3 ( const f32  a, const f32  b, const f32  c  )

inline

Definition at line 667 of file irrMath.h.

        {
                return a < b ? (a < c ? a : c) : (b < c ? b : c);
        }

fast_atof()

float irr::core::fast_atof ( const char *  floatAsString, const char **  out = 0  )

inline

Convert a string to a floating point number.

Parameters

floatAsString	The string to convert.
out	Optional pointer to the first character in the string that wasn't used to create the float value.

Returns

Float value parsed from the input string

Definition at line 360 of file fast_atof.h.

{
        float ret;
        if (out)
                *out=fast_atof_move(floatAsString, ret);
        else
                fast_atof_move(floatAsString, ret);
        return ret;
}

fast_atof_move()

const char* irr::core::fast_atof_move ( const char *  in, f32 &  result  )

inline

Provides a fast function for converting a string into a float.

This is not guaranteed to be as accurate as atof(), but is approximately 6 to 8 times as fast.

Parameters

[in]	in	The string to convert.
[out]	result	The resultant float will be written here.

Returns

Pointer to the first character in the string that wasn't used to create the float value.

Definition at line 310 of file fast_atof.h.

{
        // Please run the regression test when making any modifications to this function.

        result = 0.f;
        if (!in)
                return 0;

        const bool negative = ('-' == *in);
        if (negative || ('+'==*in))
                ++in;

        f32 value = strtof10(in, &in);

        if ( LOCALE_DECIMAL_POINTS.findFirst(*in) >= 0 )
        {
                const char* afterDecimal = ++in;
                const f32 decimal = strtof10(in, &afterDecimal);
                const size_t numDecimals = afterDecimal - in;
                if (numDecimals < IRR_ATOF_TABLE_SIZE)
                {
                        value += decimal * fast_atof_table[numDecimals];
                }
                else
                {
                        value += decimal * (f32)pow(10.f, -(float)numDecimals);
                }
                in = afterDecimal;
        }

        if ('e' == *in || 'E' == *in)
        {
                ++in;
                // Assume that the exponent is a whole number.
                // strtol10() will deal with both + and - signs,
                // but calculate as f32 to prevent overflow at FLT_MAX
                // Using pow with float cast instead of powf as otherwise accuracy decreases.
                value *= (f32)pow(10.f, (f32)strtol10(in, &in));
        }

        result = negative?-value:value;
        return in;
}

floor32()

REALINLINE s32 irr::core::floor32

(

f32

x

)

Definition at line 646 of file irrMath.h.

        {
                return (s32) floorf ( x );
        }

FR() [1/2]

f32 irr::core::FR ( u32  x )

inline

Floating-point representation of an integer value.

Definition at line 400 of file irrMath.h.

{inttofloat tmp; tmp.u=x; return tmp.f;}

FR() [2/2]

f32 irr::core::FR ( s32  x )

inline

Definition at line 401 of file irrMath.h.

{inttofloat tmp; tmp.s=x; return tmp.f;}

fract()

f32 irr::core::fract ( f32  x )

inline

Definition at line 672 of file irrMath.h.

        {
                return x - floorf ( x );
        }

getFileNameExtension()

io::path& irr::core::getFileNameExtension ( io::path &  dest, const io::path &  source  )

inline

get the filename extension from a file path

Definition at line 56 of file coreutil.h.

{
        s32 endPos = source.findLast ( '.' );
        if ( endPos < 0 )
                dest = "";
        else
                dest = source.subString ( endPos, source.size () );
        return dest;
}

hasFileExtension()

bool irr::core::hasFileExtension ( const io::path &  filename, const io::path &  ext0, const io::path &  ext1 = "", const io::path &  ext2 = ""  )

inline

search if a filename has a proper extension

Definition at line 41 of file coreutil.h.

{
        return isFileExtension ( filename, ext0, ext1, ext2 ) > 0;
}

heapsink()

template<class T >

void irr::core::heapsink ( T *  array, s32  element, s32  max  )

inline

Sinks an element into the heap.

Definition at line 17 of file heapsort.h.

{
        while ((element<<1) < max) // there is a left child
        {
                s32 j = (element<<1);

                if (j+1 < max && array[j] < array[j+1])
                        j = j+1; // take right child

                if (array[element] < array[j])
                {
                        T t = array[j]; // swap elements
                        array[j] = array[element];
                        array[element] = t;
                        element = j;
                }
                else
                        return;
        }
}

heapsort()

template<class T >

void irr::core::heapsort ( T *  array_, s32  size  )

inline

Sorts an array with size 'size' using heapsort.

Definition at line 41 of file heapsort.h.

{
        // for heapsink we pretend this is not c++, where
        // arrays start with index 0. So we decrease the array pointer,
        // the maximum always +2 and the element always +1

        T* virtualArray = array_ - 1;
        s32 virtualSize = size + 2;
        s32 i;

        // build heap

        for (i=((size-1)/2); i>=0; --i)
                heapsink(virtualArray, i+1, virtualSize-1);

        // sort array, leave out the last element (0)
        for (i=size-1; i>0; --i)
        {
                T t = array_[0];
                array_[0] = array_[i];
                array_[i] = t;
                heapsink(virtualArray, 1, i + 1);
        }
}

if_c_a_else_0()

REALINLINE u32 irr::core::if_c_a_else_0	(	const s32	condition,
		const u32	a
	)

conditional set based on mask and arithmetic shift

Definition at line 470 of file irrMath.h.

        {
                return ( -condition >> 31 ) & a;
        }

if_c_a_else_b() [1/2]

REALINLINE u32 irr::core::if_c_a_else_b	(	const s32	condition,
		const u32	a,
		const u32	b
	)

conditional set based on mask and arithmetic shift

Definition at line 458 of file irrMath.h.

        {
                return ( ( -condition >> 31 ) & ( a ^ b ) ) ^ b;
        }

if_c_a_else_b() [2/2]

REALINLINE u16 irr::core::if_c_a_else_b	(	const s16	condition,
		const u16	a,
		const u16	b
	)

conditional set based on mask and arithmetic shift

Definition at line 464 of file irrMath.h.

        {
                return ( ( -condition >> 15 ) & ( a ^ b ) ) ^ b;
        }

IR()

u32 irr::core::IR ( f32  x )

inline

code is taken from IceFPU Integer representation of a floating-point value.

Definition at line 390 of file irrMath.h.

{inttofloat tmp; tmp.f=x; return tmp.u;}

isdigit()

s32 irr::core::isdigit ( s32  c )

inline

some standard function ( to remove dependencies )

Definition at line 197 of file coreutil.h.

{ return c >= '0' && c <= '9'; }

isFileExtension()

s32 irr::core::isFileExtension ( const io::path &  filename, const io::path &  ext0, const io::path &  ext1, const io::path &  ext2  )

inline

search if a filename has a proper extension

Definition at line 23 of file coreutil.h.

{
        s32 extPos = filename.findLast ( '.' );
        if ( extPos < 0 )
                return 0;

        extPos += 1;
        if ( filename.equals_substring_ignore_case ( ext0, extPos ) )
                return 1;
        if ( filename.equals_substring_ignore_case ( ext1, extPos ) )
                return 2;
        if ( filename.equals_substring_ignore_case ( ext2, extPos ) )
                return 3;
        return 0;
}

isInSameDirectory()

s32 irr::core::isInSameDirectory ( const io::path &  path, const io::path &  file  )

inline

looks if file is in the same directory of path. returns offset of directory. 0 means in same directory. 1 means file is direct child of path

Definition at line 114 of file coreutil.h.

{
        if ( path.size() && !path.equalsn ( file, path.size() ) )
                return -1;

        s32 subA = 0;
        s32 subB = 0;
        s32 pos = 0;
        while ( (pos = path.findNext ( '/', pos )) >= 0 )
        {
                subA += 1;
                pos += 1;
        }

        pos = 0;
        while ( (pos = file.findNext ( '/', pos )) >= 0 )
        {
                subB += 1;
                pos += 1;
        }

        return subB - subA;
}

isnotzero()

bool irr::core::isnotzero ( const f32  a, const f32  tolerance = ROUNDING_ERROR_f32  )

inline

returns if a equals not zero, taking rounding errors into account

Definition at line 319 of file irrMath.h.

        {
                return fabsf(a) > tolerance;
        }

isspace()

s32 irr::core::isspace ( s32  c )

inline

Definition at line 198 of file coreutil.h.

{ return c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' || c == '\v'; }

isupper()

s32 irr::core::isupper ( s32  c )

inline

Definition at line 199 of file coreutil.h.

{ return c >= 'A' && c <= 'Z'; }

iszero() [1/5]

bool irr::core::iszero ( const f64  a, const f64  tolerance = ROUNDING_ERROR_f64  )

inline

returns if a equals zero, taking rounding errors into account

Definition at line 307 of file irrMath.h.

        {
                return fabs(a) <= tolerance;
        }

iszero() [2/5]

bool irr::core::iszero ( const f32  a, const f32  tolerance = ROUNDING_ERROR_f32  )

inline

returns if a equals zero, taking rounding errors into account

Definition at line 313 of file irrMath.h.

        {
                return fabsf(a) <= tolerance;
        }

iszero() [3/5]

bool irr::core::iszero ( const s32  a, const s32  tolerance = 0  )

inline

returns if a equals zero, taking rounding errors into account

Definition at line 325 of file irrMath.h.

        {
                return ( a & 0x7ffffff ) <= tolerance;
        }

iszero() [4/5]

bool irr::core::iszero ( const u32  a, const u32  tolerance = 0  )

inline

returns if a equals zero, taking rounding errors into account

Definition at line 331 of file irrMath.h.

        {
                return a <= tolerance;
        }

iszero() [5/5]

bool irr::core::iszero ( const s64  a, const s64  tolerance = 0  )

inline

returns if a equals zero, taking rounding errors into account

Definition at line 338 of file irrMath.h.

        {
                return abs_(a) <= tolerance;
        }

lerp()

template<class T >

T irr::core::lerp ( const T &  a, const T &  b, const f32  t  )

inline

returns linear interpolation of a and b with ratio t

Returns

: a if t==0, b if t==1, and the linear interpolation else

Definition at line 160 of file irrMath.h.

        {
                return (T)(a*(1.f-t)) + (b*t);
        }

max_() [1/2]

template<class T >

const T& irr::core::max_ ( const T &  a, const T &  b  )

inline

returns maximum of two values. Own implementation to get rid of the STL (VS6 problems)

Definition at line 138 of file irrMath.h.

        {
                return a < b ? b : a;
        }

max_() [2/2]

template<class T >

const T& irr::core::max_ ( const T &  a, const T &  b, const T &  c  )

inline

returns maximum of three values. Own implementation to get rid of the STL (VS6 problems)

Definition at line 145 of file irrMath.h.

        {
                return a < b ? max_(b, c) : max_(a, c);
        }

min_() [1/2]

template<class T >

const T& irr::core::min_ ( const T &  a, const T &  b  )

inline

returns minimum of two values. Own implementation to get rid of the STL (VS6 problems)

Definition at line 124 of file irrMath.h.

        {
                return a < b ? a : b;
        }

min_() [2/2]

template<class T >

const T& irr::core::min_ ( const T &  a, const T &  b, const T &  c  )

inline

returns minimum of three values. Own implementation to get rid of the STL (VS6 problems)

Definition at line 131 of file irrMath.h.

        {
                return a < b ? min_(a, c) : min_(b, c);
        }

operator *() [1/3]

template<class S , class T >

vector2d<T> irr::core::operator *	(	const S	scalar,
		const vector2d< T > &	vector
	)

Definition at line 409 of file vector2d.h.

{ return vector*scalar; }

operator *() [2/3]

template<class S , class T >

vector3d<T> irr::core::operator *	(	const S	scalar,
		const vector3d< T > &	vector
	)

Function multiplying a scalar and a vector component-wise.

Definition at line 468 of file vector3d.h.

{ return vector*scalar; }

operator *() [3/3]

template<class T >

CMatrix4<T> irr::core::operator * ( const T  scalar, const CMatrix4< T > &  mat  )

inline

Definition at line 2370 of file matrix4.h.

        {
                return mat*scalar;
        }

operator+() [1/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const ustring16< TAlloc > &  left, const ustring16< TAlloc > &  right  )

inline

Appends two ustring16s.

Definition at line 3294 of file irrUString.h.

{
        ustring16<TAlloc> ret(left);
        ret += right;
        return ret;
}

operator+() [2/23]

template<typename TAlloc , class B >

ustring16<TAlloc> irr::core::operator+ ( const ustring16< TAlloc > &  left, const B *const  right  )

inline

Appends a ustring16 and a null-terminated unicode string.

Definition at line 3304 of file irrUString.h.

{
        ustring16<TAlloc> ret(left);
        ret += right;
        return ret;
}

operator+() [3/23]

template<class B , typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const B *const  left, const ustring16< TAlloc > &  right  )

inline

Appends a ustring16 and a null-terminated unicode string.

Definition at line 3314 of file irrUString.h.

{
        ustring16<TAlloc> ret(left);
        ret += right;
        return ret;
}

operator+() [4/23]

template<typename TAlloc , typename B , typename BAlloc >

ustring16<TAlloc> irr::core::operator+ ( const ustring16< TAlloc > &  left, const string< B, BAlloc > &  right  )

inline

Appends a ustring16 and an Irrlicht string.

Definition at line 3324 of file irrUString.h.

{
        ustring16<TAlloc> ret(left);
        ret += right;
        return ret;
}

operator+() [5/23]

template<typename TAlloc , typename B , typename BAlloc >

ustring16<TAlloc> irr::core::operator+ ( const string< B, BAlloc > &  left, const ustring16< TAlloc > &  right  )

inline

Appends a ustring16 and an Irrlicht string.

Definition at line 3334 of file irrUString.h.

{
        ustring16<TAlloc> ret(left);
        ret += right;
        return ret;
}

operator+() [6/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const ustring16< TAlloc > &  left, const char  right  )

inline

Appends a ustring16 and a char.

Definition at line 3364 of file irrUString.h.

{
        ustring16<TAlloc> ret(left);
        ret += right;
        return ret;
}

operator+() [7/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const char  left, const ustring16< TAlloc > &  right  )

inline

Appends a ustring16 and a char.

Definition at line 3374 of file irrUString.h.

{
        ustring16<TAlloc> ret(left);
        ret += right;
        return ret;
}

operator+() [8/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const ustring16< TAlloc > &  left, const short  right  )

inline

Appends a ustring16 and a short.

Definition at line 3406 of file irrUString.h.

{
        ustring16<TAlloc> ret(left);
        ret += core::stringc(right);
        return ret;
}

operator+() [9/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const short  left, const ustring16< TAlloc > &  right  )

inline

Appends a ustring16 and a short.

Definition at line 3416 of file irrUString.h.

{
        ustring16<TAlloc> ret(core::stringc(left));
        ret += right;
        return ret;
}

operator+() [10/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const ustring16< TAlloc > &  left, const unsigned short  right  )

inline

Appends a ustring16 and an unsigned short.

Definition at line 3426 of file irrUString.h.

{
        ustring16<TAlloc> ret(left);
        ret += core::stringc(right);
        return ret;
}

operator+() [11/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const unsigned short  left, const ustring16< TAlloc > &  right  )

inline

Appends a ustring16 and an unsigned short.

Definition at line 3436 of file irrUString.h.

{
        ustring16<TAlloc> ret(core::stringc(left));
        ret += right;
        return ret;
}

operator+() [12/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const ustring16< TAlloc > &  left, const int  right  )

inline

Appends a ustring16 and an int.

Definition at line 3446 of file irrUString.h.

{
        ustring16<TAlloc> ret(left);
        ret += core::stringc(right);
        return ret;
}

operator+() [13/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const int  left, const ustring16< TAlloc > &  right  )

inline

Appends a ustring16 and an int.

Definition at line 3456 of file irrUString.h.

{
        ustring16<TAlloc> ret(core::stringc(left));
        ret += right;
        return ret;
}

operator+() [14/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const ustring16< TAlloc > &  left, const unsigned int  right  )

inline

Appends a ustring16 and an unsigned int.

Definition at line 3466 of file irrUString.h.

{
        ustring16<TAlloc> ret(left);
        ret += core::stringc(right);
        return ret;
}

operator+() [15/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const unsigned int  left, const ustring16< TAlloc > &  right  )

inline

Appends a ustring16 and an unsigned int.

Definition at line 3476 of file irrUString.h.

{
        ustring16<TAlloc> ret(core::stringc(left));
        ret += right;
        return ret;
}

operator+() [16/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const ustring16< TAlloc > &  left, const long  right  )

inline

Appends a ustring16 and a long.

Definition at line 3486 of file irrUString.h.

{
        ustring16<TAlloc> ret(left);
        ret += core::stringc(right);
        return ret;
}

operator+() [17/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const long  left, const ustring16< TAlloc > &  right  )

inline

Appends a ustring16 and a long.

Definition at line 3496 of file irrUString.h.

{
        ustring16<TAlloc> ret(core::stringc(left));
        ret += right;
        return ret;
}

operator+() [18/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const ustring16< TAlloc > &  left, const unsigned long  right  )

inline

Appends a ustring16 and an unsigned long.

Definition at line 3506 of file irrUString.h.

{
        ustring16<TAlloc> ret(left);
        ret += core::stringc(right);
        return ret;
}

operator+() [19/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const unsigned long  left, const ustring16< TAlloc > &  right  )

inline

Appends a ustring16 and an unsigned long.

Definition at line 3516 of file irrUString.h.

{
        ustring16<TAlloc> ret(core::stringc(left));
        ret += right;
        return ret;
}

operator+() [20/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const ustring16< TAlloc > &  left, const float  right  )

inline

Appends a ustring16 and a float.

Definition at line 3526 of file irrUString.h.

{
        ustring16<TAlloc> ret(left);
        ret += core::stringc(right);
        return ret;
}

operator+() [21/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const float  left, const ustring16< TAlloc > &  right  )

inline

Appends a ustring16 and a float.

Definition at line 3536 of file irrUString.h.

{
        ustring16<TAlloc> ret(core::stringc(left));
        ret += right;
        return ret;
}

operator+() [22/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const ustring16< TAlloc > &  left, const double  right  )

inline

Appends a ustring16 and a double.

Definition at line 3546 of file irrUString.h.

{
        ustring16<TAlloc> ret(left);
        ret += core::stringc(right);
        return ret;
}

operator+() [23/23]

template<typename TAlloc >

ustring16<TAlloc> irr::core::operator+ ( const double  left, const ustring16< TAlloc > &  right  )

inline

Appends a ustring16 and a double.

Definition at line 3556 of file irrUString.h.

{
        ustring16<TAlloc> ret(core::stringc(left));
        ret += right;
        return ret;
}

radToDeg() [1/2]

f32 irr::core::radToDeg ( f32  radians )

inline

Utility function to convert a radian value to degrees.

Provided as it can be clearer to write radToDeg(X) than RADTODEG * X

Parameters

radians

The radians value to convert to degrees.

Definition at line 90 of file irrMath.h.

        {
                return RADTODEG * radians;
        }

radToDeg() [2/2]

f64 irr::core::radToDeg ( f64  radians )

inline

Utility function to convert a radian value to degrees.

Provided as it can be clearer to write radToDeg(X) than RADTODEG * X

Parameters

radians

The radians value to convert to degrees.

Definition at line 99 of file irrMath.h.

        {
                return RADTODEG64 * radians;
        }

reciprocal() [1/2]

REALINLINE f32 irr::core::reciprocal

(

const f32

f

)

Definition at line 562 of file irrMath.h.

        {
#if defined (IRRLICHT_FAST_MATH)
                // NOTE: Unlike with 1.f / f the values very close to 0 return -nan instead of inf

                // SSE Newton-Raphson reciprocal estimate, accurate to 23 significant
                // bi ts of the mantissa
                // One Newton-Raphson Iteration:
                // f(i+1) = 2 * rcpss(f) - f * rcpss(f) * rcpss(f)
#if defined(_MSC_VER) && !defined(_WIN64)
                f32 rec;
                __asm rcpss xmm0, f               // xmm0 = rcpss(f)
                __asm movss xmm1, f               // xmm1 = f
                __asm mulss xmm1, xmm0            // xmm1 = f * rcpss(f)
                __asm mulss xmm1, xmm0            // xmm2 = f * rcpss(f) * rcpss(f)
                __asm addss xmm0, xmm0            // xmm0 = 2 * rcpss(f)
                __asm subss xmm0, xmm1            // xmm0 = 2 * rcpss(f)
                                                                                  //        - f * rcpss(f) * rcpss(f)
                __asm movss rec, xmm0             // return xmm0
                return rec;
#else // no support yet for other compilers
                return 1.f / f;
#endif
                // instead set f to a high value to get a return value near zero..
                // -1000000000000.f.. is use minus to stay negative..
                // must test's here (plane.normal dot anything ) checks on <= 0.f
                //u32 x = (-(AIR(f) != 0 ) >> 31 ) & ( IR(f) ^ 0xd368d4a5 ) ^ 0xd368d4a5;
                //return 1.f / FR ( x );

#else // no fast math
                return 1.f / f;
#endif
        }

reciprocal() [2/2]

REALINLINE f64 irr::core::reciprocal

(

const f64

f

)

Definition at line 598 of file irrMath.h.

        {
                return 1.0 / f;
        }

reciprocal_approxim()

REALINLINE f32 irr::core::reciprocal_approxim

(

const f32

f

)

Definition at line 605 of file irrMath.h.

        {
#if defined( IRRLICHT_FAST_MATH)

                // SSE Newton-Raphson reciprocal estimate, accurate to 23 significant
                // bi ts of the mantissa
                // One Newton-Raphson Iteration:
                // f(i+1) = 2 * rcpss(f) - f * rcpss(f) * rcpss(f)
#if defined(_MSC_VER) && !defined(_WIN64)
                f32 rec;
                __asm rcpss xmm0, f               // xmm0 = rcpss(f)
                __asm movss xmm1, f               // xmm1 = f
                __asm mulss xmm1, xmm0            // xmm1 = f * rcpss(f)
                __asm mulss xmm1, xmm0            // xmm2 = f * rcpss(f) * rcpss(f)
                __asm addss xmm0, xmm0            // xmm0 = 2 * rcpss(f)
                __asm subss xmm0, xmm1            // xmm0 = 2 * rcpss(f)
                                                                                  //        - f * rcpss(f) * rcpss(f)
                __asm movss rec, xmm0             // return xmm0
                return rec;
#else // no support yet for other compilers
                return 1.f / f;
#endif

/*
                // SSE reciprocal estimate, accurate to 12 significant bits of
                f32 rec;
                __asm rcpss xmm0, f             // xmm0 = rcpss(f)
                __asm movss rec , xmm0          // return xmm0
                return rec;
*/
/*
                register u32 x = 0x7F000000 - IR ( p );
                const f32 r = FR ( x );
                return r * (2.0f - p * r);
*/
#else // no fast math
                return 1.f / f;
#endif
        }

reciprocal_squareroot() [1/3]

REALINLINE f64 irr::core::reciprocal_squareroot

(

const f64

x

)

Definition at line 521 of file irrMath.h.

        {
                return 1.0 / sqrt(x);
        }

reciprocal_squareroot() [2/3]

REALINLINE f32 irr::core::reciprocal_squareroot

(

const f32

f

)

Definition at line 527 of file irrMath.h.

        {
#if defined ( IRRLICHT_FAST_MATH )
                // NOTE: Unlike comment below says I found inaccuracies already at 4'th significant bit.
                // p.E: Input 1, expected 1, got 0.999755859

        #if defined(_MSC_VER) && !defined(_WIN64)
                // SSE reciprocal square root estimate, accurate to 12 significant
                // bits of the mantissa
                f32 recsqrt;
                __asm rsqrtss xmm0, f           // xmm0 = rsqrtss(f)
                __asm movss recsqrt, xmm0       // return xmm0
                return recsqrt;

/*
                // comes from Nvidia
                u32 tmp = (u32(IEEE_1_0 << 1) + IEEE_1_0 - *(u32*)&x) >> 1;
                f32 y = *(f32*)&tmp;
                return y * (1.47f - 0.47f * x * y * y);
*/
        #else
                return 1.f / sqrtf(f);
        #endif
#else // no fast math
                return 1.f / sqrtf(f);
#endif
        }

reciprocal_squareroot() [3/3]

REALINLINE s32 irr::core::reciprocal_squareroot

(

const s32

x

)

Definition at line 556 of file irrMath.h.

        {
                return static_cast<s32>(reciprocal_squareroot(static_cast<f32>(x)));
        }

relativeErrorFactor() [1/3]

template<class T >

T irr::core::relativeErrorFactor ( )

inline

Definition at line 227 of file irrMath.h.

        {
                return 1;
        }

relativeErrorFactor() [2/3]

template<>

f32 irr::core::relativeErrorFactor ( )

inline

Definition at line 233 of file irrMath.h.

        {
                return 4;
        }

relativeErrorFactor() [3/3]

template<>

f64 irr::core::relativeErrorFactor ( )

inline

Definition at line 239 of file irrMath.h.

        {
                return 8;
        }

round32()

REALINLINE s32 irr::core::round32

(

f32

x

)

Definition at line 657 of file irrMath.h.

        {
                return (s32) round_(x);
        }

round_()

f32 irr::core::round_ ( f32  x )

inline

Definition at line 489 of file irrMath.h.

        {
                return floorf( x + 0.5f );
        }

roundingError() [1/7]

template<class T >

T irr::core::roundingError ( )

inline

Definition at line 189 of file irrMath.h.

        {
                return ROUNDING_ERROR_f32;
        }

roundingError() [2/7]

template<>

f32 irr::core::roundingError ( )

inline

Definition at line 189 of file irrMath.h.

        {
                return ROUNDING_ERROR_f32;
        }

roundingError() [3/7]

template<>

f64 irr::core::roundingError ( )

inline

Definition at line 195 of file irrMath.h.

        {
                return ROUNDING_ERROR_f64;
        }

roundingError() [4/7]

template<>

s32 irr::core::roundingError ( )

inline

Definition at line 201 of file irrMath.h.

        {
                return ROUNDING_ERROR_S32;
        }

roundingError() [5/7]

template<>

u32 irr::core::roundingError ( )

inline

Definition at line 207 of file irrMath.h.

        {
                return ROUNDING_ERROR_S32;
        }

roundingError() [6/7]

template<>

s64 irr::core::roundingError ( )

inline

Definition at line 214 of file irrMath.h.

        {
                return ROUNDING_ERROR_S64;
        }

roundingError() [7/7]

template<>

u64 irr::core::roundingError ( )

inline

Definition at line 220 of file irrMath.h.

        {
                return ROUNDING_ERROR_S64;
        }

s32_clamp()

s32 irr::core::s32_clamp ( s32  value, s32  low, s32  high  )

inline

Definition at line 356 of file irrMath.h.

        {
                return s32_min(s32_max(value,low), high);
        }

s32_max()

s32 irr::core::s32_max ( s32  a, s32  b  )

inline

Definition at line 350 of file irrMath.h.

        {
                const s32 mask = (a - b) >> 31;
                return (b & mask) | (a & ~mask);
        }

s32_min()

s32 irr::core::s32_min ( s32  a, s32  b  )

inline

Definition at line 344 of file irrMath.h.

        {
                const s32 mask = (a - b) >> 31;
                return (a & mask) | (b & ~mask);
        }

setbit_cond()

REALINLINE void irr::core::setbit_cond	(	u32 &	state,
		s32	condition,
		u32	mask
	)

Definition at line 479 of file irrMath.h.

        {
                // 0, or any positive to mask
                //s32 conmask = -condition >> 31;
                state ^= ( ( -condition >> 31 ) ^ state ) & mask;
        }

squareroot() [1/4]

REALINLINE f32 irr::core::squareroot

(

const f32

f

)

Definition at line 495 of file irrMath.h.

        {
                return sqrtf(f);
        }

squareroot() [2/4]

REALINLINE f64 irr::core::squareroot

(

const f64

f

)

Definition at line 501 of file irrMath.h.

        {
                return sqrt(f);
        }

squareroot() [3/4]

REALINLINE s32 irr::core::squareroot

(

const s32

f

)

Definition at line 507 of file irrMath.h.

        {
                return static_cast<s32>(squareroot(static_cast<f32>(f)));
        }

squareroot() [4/4]

REALINLINE s64 irr::core::squareroot

(

const s64

f

)

Definition at line 514 of file irrMath.h.

        {
                return static_cast<s64>(squareroot(static_cast<f64>(f)));
        }

strtof10()

f32 irr::core::strtof10 ( const char *  in, const char **  out = 0  )

inline

Converts a sequence of digits into a whole positive floating point value.

Only digits 0 to 9 are parsed. Parsing stops at any other character, including sign characters or a decimal point.

Parameters

in	the sequence of digits to convert.
out	(optional) will be set to point at the first non-converted character.

Returns

The whole positive floating point representation of the digit sequence.

Definition at line 259 of file fast_atof.h.

{
        if (!in)
        {
                if (out)
                        *out = in;
                return 0.f;
        }

        const u32 MAX_SAFE_U32_VALUE = UINT_MAX / 10 - 10;
        u32 intValue = 0;

        // Use integer arithmetic for as long as possible, for speed
        // and precision.
        while ( ( *in >= '0') && ( *in <= '9' ) )
        {
                // If it looks like we're going to overflow, bail out
                // now and start using floating point.
                if (intValue >= MAX_SAFE_U32_VALUE)
                        break;

                intValue = (intValue * 10) + (*in - '0');
                ++in;
        }

        f32 floatValue = (f32)intValue;

        // If there are any digits left to parse, then we need to use
        // floating point arithmetic from here.
        while ( ( *in >= '0') && ( *in <= '9' ) )
        {
                floatValue = (floatValue * 10.f) + (f32)(*in - '0');
                ++in;
                if (floatValue > FLT_MAX) // Just give up.
                        break;
        }

        if (out)
                *out = in;

        return floatValue;
}

strtol10()

s32 irr::core::strtol10 ( const char *  in, const char **  out = 0  )

inline

Convert a simple string of base 10 digits into a signed 32 bit integer.

Parameters

[in]	in	The string of digits to convert. Only a leading - or + followed by digits 0 to 9 will be considered. Parsing stops at the first non-digit.
[out]	out	(optional) If provided, it will be set to point at the first character not used in the calculation.

Returns

The signed integer value of the digits. If the string specifies too many digits to encode in an s32 then +INT_MAX or -INT_MAX will be returned.

Definition at line 90 of file fast_atof.h.

{
        if (!in)
        {
                if (out)
                        *out = in;
                return 0;
        }

        const bool negative = ('-' == *in);
        if (negative || ('+' == *in))
                ++in;

        const u32 unsignedValue = strtoul10(in,out);
        if (unsignedValue > (u32)INT_MAX)
        {
                if (negative)
                        return (s32)INT_MIN;
                else
                        return (s32)INT_MAX;
        }
        else
        {
                if (negative)
                        return -((s32)unsignedValue);
                else
                        return (s32)unsignedValue;
        }
}

strtoul10()

u32 irr::core::strtoul10 ( const char *  in, const char **  out = 0  )

inline

Convert a simple string of base 10 digits into an unsigned 32 bit integer.

Parameters

[in]	in	The string of digits to convert. No leading chars are allowed, only digits 0 to 9. Parsing stops at the first non-digit.
[out]	out	(optional) If provided, it will be set to point at the first character not used in the calculation.

Returns

The unsigned integer value of the digits. If the string specifies too many digits to encode in an u32 then INT_MAX will be returned.

Definition at line 50 of file fast_atof.h.

{
        if (!in)
        {
                if (out)
                        *out = in;
                return 0;
        }

        bool overflow=false;
        u32 unsignedValue = 0;
        while ( ( *in >= '0') && ( *in <= '9' ))
        {
                const u32 tmp = ( unsignedValue * 10 ) + ( *in - '0' );
                if (tmp<unsignedValue)
                {
                        unsignedValue=(u32)0xffffffff;
                        overflow=true;
                }
                if (!overflow)
                        unsignedValue = tmp;
                ++in;
        }

        if (out)
                *out = in;

        return unsignedValue;
}

strtoul16()

u32 irr::core::strtoul16 ( const char *  in, const char **  out = 0  )

inline

Convert a simple string of base 16 digits into an unsigned 32 bit integer.

Parameters

[in]	in	The string of digits to convert. No leading chars are allowed, only digits 0 to 9 and chars A-F,a-f are allowed. Parsing stops at the first illegal char.
[out]	out	(optional) If provided, it will be set to point at the first character not used in the calculation.

Returns

The unsigned integer value of the digits. If the string specifies too many digits to encode in an u32 then INT_MAX will be returned.

Definition at line 147 of file fast_atof.h.

{
        if (!in)
        {
                if (out)
                        *out = in;
                return 0;
        }

        bool overflow=false;
        u32 unsignedValue = 0;
        while (true)
        {
                u32 tmp = 0;
                if ((*in >= '0') && (*in <= '9'))
                        tmp = (unsignedValue << 4u) + (*in - '0');
                else if ((*in >= 'A') && (*in <= 'F'))
                        tmp = (unsignedValue << 4u) + (*in - 'A') + 10;
                else if ((*in >= 'a') && (*in <= 'f'))
                        tmp = (unsignedValue << 4u) + (*in - 'a') + 10;
                else
                        break;
                if (tmp<unsignedValue)
                {
                        unsignedValue=(u32)INT_MAX;
                        overflow=true;
                }
                if (!overflow)
                        unsignedValue = tmp;
                ++in;
        }

        if (out)
                *out = in;

        return unsignedValue;
}

strtoul8()

u32 irr::core::strtoul8 ( const char *  in, const char **  out = 0  )

inline

Convert a simple string of base 8 digits into an unsigned 32 bit integer.

Parameters

[in]	in	The string of digits to convert. No leading chars are allowed, only digits 0 to 7 are allowed. Parsing stops at the first illegal char.
[out]	out	(optional) If provided, it will be set to point at the first character not used in the calculation.

Returns

The unsigned integer value of the digits. If the string specifies too many digits to encode in an u32 then INT_MAX will be returned.

Definition at line 194 of file fast_atof.h.

{
        if (!in)
        {
                if (out)
                        *out = in;
                return 0;
        }

        bool overflow=false;
        u32 unsignedValue = 0;
        while (true)
        {
                u32 tmp = 0;
                if ((*in >= '0') && (*in <= '7'))
                        tmp = (unsignedValue << 3u) + (*in - '0');
                else
                        break;
                if (tmp<unsignedValue)
                {
                        unsignedValue=(u32)INT_MAX;
                        overflow=true;
                }
                if (!overflow)
                        unsignedValue = tmp;
                ++in;
        }

        if (out)
                *out = in;

        return unsignedValue;
}

strtoul_prefix()

u32 irr::core::strtoul_prefix ( const char *  in, const char **  out = 0  )

inline

Convert a C-style prefixed string (hex, oct, integer) into an unsigned 32 bit integer.

Parameters

[in]	in	The string of digits to convert. If string starts with 0x the hex parser is used, if only leading 0 is used, oct parser is used. In all other cases, the usual unsigned parser is used.
[out]	out	(optional) If provided, it will be set to point at the first character not used in the calculation.

Returns

The unsigned integer value of the digits. If the string specifies too many digits to encode in an u32 then INT_MAX will be returned.

Definition at line 237 of file fast_atof.h.

{
        if (!in)
        {
                if (out)
                        *out = in;
                return 0;
        }
        if ('0'==in[0])
                return ('x'==in[1] ? strtoul16(in+2,out) : strtoul8(in+1,out));
        return strtoul10(in,out);
}

swap()

template<class T1 , class T2 >

void irr::core::swap ( T1 &  a, T2 &  b  )

inline

swaps the content of the passed parameters

Definition at line 178 of file irrMath.h.

        {
                T1 c(a);
                a = b;
                b = c;
        }

utf8ToWchar()

IRRLICHT_API void irr::core::utf8ToWchar	(	const char *	in,
		wchar_t *	out,
		const u64	len
	)

Convert this utf-8-encoded string to the platform's wchar.

The resulting string is always NULL-terminated and well-formed.

Parameters

len	The size of the output buffer in bytes.

wcharToUtf8()

IRRLICHT_API void irr::core::wcharToUtf8	(	const wchar_t *	in,
		char *	out,
		const u64	len
	)

Convert this wchar string to utf-8.

The resulting string is always NULL-terminated and well-formed.

Parameters

len	The size of the output buffer in bytes.

Variable Documentation

DEGTORAD

const f32 irr::core::DEGTORAD = PI / 180.0f

32bit Constant for converting from degrees to radians

Definition at line 75 of file irrMath.h.

DEGTORAD64

const f64 irr::core::DEGTORAD64 = PI64 / 180.0

64bit constant for converting from degrees to radians (formally known as GRAD_PI2)

Definition at line 81 of file irrMath.h.

fast_atof_table

const float irr::core::fast_atof_table[17]

Initial value:

= {
        0.f,
        0.1f,
        0.01f,
        0.001f,
        0.0001f,
        0.00001f,
        0.000001f,
        0.0000001f,
        0.00000001f,
        0.000000001f,
        0.0000000001f,
        0.00000000001f,
        0.000000000001f,
        0.0000000000001f,
        0.00000000000001f,
        0.000000000000001f,
        0.0000000000000001f
}

Definition at line 22 of file fast_atof.h.

HALF_PI

const f32 irr::core::HALF_PI = PI/2.0f

Constant for half of PI.

Definition at line 63 of file irrMath.h.

IdentityMatrix

IRRLICHT_API const matrix4 irr::core::IdentityMatrix

global const identity matrix

LOCALE_DECIMAL_POINTS

IRRLICHT_API irr::core::stringc irr::core::LOCALE_DECIMAL_POINTS

Selection of characters which count as decimal point in fast_atof.

PI

const f32 irr::core::PI = 3.14159265359f

Constant for PI.

Definition at line 57 of file irrMath.h.

PI64

const f64 irr::core::PI64 = 3.1415926535897932384626433832795028841971693993751

Constant for 64bit PI.

Definition at line 69 of file irrMath.h.

RADTODEG

const f32 irr::core::RADTODEG = 180.0f / PI

32bit constant for converting from radians to degrees (formally known as GRAD_PI)

Definition at line 78 of file irrMath.h.

RADTODEG64

const f64 irr::core::RADTODEG64 = 180.0 / PI64

64bit constant for converting from radians to degrees

Definition at line 84 of file irrMath.h.

RECIPROCAL_PI

const f32 irr::core::RECIPROCAL_PI = 1.0f/PI

Constant for reciprocal of PI.

Definition at line 60 of file irrMath.h.

RECIPROCAL_PI64

const f64 irr::core::RECIPROCAL_PI64 = 1.0/PI64

Constant for 64bit reciprocal of PI.

Definition at line 72 of file irrMath.h.

ROUNDING_ERROR_f32

const f32 irr::core::ROUNDING_ERROR_f32 = 0.000001f

Definition at line 50 of file irrMath.h.

ROUNDING_ERROR_f64

const f64 irr::core::ROUNDING_ERROR_f64 = 0.00000001

Definition at line 51 of file irrMath.h.

ROUNDING_ERROR_S32

const s32 irr::core::ROUNDING_ERROR_S32 = 0

Rounding error constant often used when comparing f32 values.

Definition at line 45 of file irrMath.h.

ROUNDING_ERROR_S64

const s64 irr::core::ROUNDING_ERROR_S64 = 0

Definition at line 48 of file irrMath.h.