diff options
Diffstat (limited to 'sdk/rwsdk/include/d3d8/rwplcore.h')
| -rw-r--r-- | sdk/rwsdk/include/d3d8/rwplcore.h | 6080 |
1 files changed, 6080 insertions, 0 deletions
diff --git a/sdk/rwsdk/include/d3d8/rwplcore.h b/sdk/rwsdk/include/d3d8/rwplcore.h new file mode 100644 index 00000000..b0ff7dfa --- /dev/null +++ b/sdk/rwsdk/include/d3d8/rwplcore.h @@ -0,0 +1,6080 @@ +/******************************************/ +/* */ +/* RenderWare(TM) Graphics Library */ +/* */ +/******************************************/ + +/* + * This file is a product of Criterion Software Ltd. + * + * This file is provided as is with no warranties of any kind and is + * provided without any obligation on Criterion Software Ltd. + * or Canon Inc. to assist in its use or modification. + * + * Criterion Software Ltd. and Canon Inc. will not, under any + * circumstances, be liable for any lost revenue or other damages + * arising from the use of this file. + * + * Copyright (c) 1999. Criterion Software Ltd. + * All Rights Reserved. + */ + +/************************************************************************* + * + * Filename: <C:/daily/rwsdk/include/d3d8/rwplcore.h> + * Automatically Generated on: Wed Jul 10 10:45:00 2002 + * + ************************************************************************/ + +#ifndef RWPLCORE_H +#define RWPLCORE_H + +/*--- System Header Files ---*/ +#include <stdarg.h> +#include <stddef.h> +#include <stdio.h> +#include <stdlib.h> + + +/*--- Automatically derived from: C:/daily/rwsdk/os/win/ostypes.h ---*/ +#ifndef WIN_OSTYPES_H +#define WIN_OSTYPES_H + +#define rwLITTLEENDIAN /* This is a little endian machine */ + +typedef long RwFixed; +typedef int RwInt32; +typedef unsigned int RwUInt32; +typedef short RwInt16; +typedef unsigned short RwUInt16; +typedef unsigned char RwUInt8; +typedef signed char RwInt8; + +#ifdef RWUNICODE +typedef wchar_t RwChar; +#else /* RWUNICODE */ +typedef char RwChar; +#endif /* RWUNICODE */ +typedef float RwReal; +typedef RwInt32 RwBool; + +#ifdef _MSC_VER +typedef __int64 RwInt64; +typedef unsigned __int64 RwUInt64; +#define RWZERO64 ((RwUInt64)0) +#else /* _MSC_VER */ + +typedef struct _RwUInt64 RwUInt64; +typedef struct _RwInt64 RwInt64; + +/* We'll do it with structures (can't do maths on these, but OK for allocation): */ +#ifdef rwBIGENDIAN +struct _RwUInt64 +{ + RwUInt32 top; + RwUInt32 bottom; +}; + +struct _RwInt64 +{ + RwInt32 top; + RwUInt32 bottom; +}; + +#else /* rwBIGENDIAN */ +#ifdef rwLITTLEENDIAN +struct _RwUInt64 +{ + RwUInt32 bottom; + RwUInt32 top; +}; + +struct _RwInt64 +{ + RwUInt32 bottom; + RwInt32 top; +}; + +#else /* rwLITTLEENDIAN */ +#error "ENDIAN-ness undefined!" +#endif /* rwLITTLEENDIAN */ +#endif /* rwBIGENDIAN */ + +#define RWZERO64 { (RwUInt32)0, (RwUInt32)0 } +#endif /* _MSC_VER */ + +typedef struct _RwUInt128 RwUInt128; +typedef struct _RwInt128 RwInt128; + +/* We'll do it with structures + * (can't do maths on these, but OK for allocation): */ +#ifdef rwBIGENDIAN +struct _RwUInt128 +{ + RwUInt64 top; + RwUInt64 bottom; +}; + +struct _RwInt128 +{ + RwInt64 top; + RwUInt64 bottom; +}; + +#else /* rwBIGENDIAN */ +#ifdef rwLITTLEENDIAN +struct _RwUInt128 +{ + RwUInt64 bottom; + RwUInt64 top; +}; + +struct _RwInt128 +{ + RwUInt64 bottom; + RwInt64 top; +}; + +#else /* rwLITTLEENDIAN */ +#error "ENDIAN-ness undefined!" +#endif /* rwLITTLEENDIAN */ +#endif /* rwBIGENDIAN */ + +#define RWZERO128 { RWZERO64, RWZERO64 } + +/* Limits of types */ +#define RwInt32MAXVAL 0x7FFFFFFF +#define RwInt32MINVAL 0x80000000 +#define RwUInt32MAXVAL 0xFFFFFFFF +#define RwUInt32MINVAL 0x00000000 +#define RwRealMAXVAL (RwReal)(3.40282347e+38) +#define RwRealMINVAL (RwReal)(1.17549435e-38) +#define RwInt16MAXVAL 0x7FFF +#define RwInt16MINVAL 0x8000 +#define RwUInt16MAXVAL 0xFFFF +#define RwUInt16MINVAL 0x0000 + +/* Structure alignment */ +#define RWALIGN(type, x) type /* nothing */ +#define rwMATRIXALIGNMENT sizeof(RwUInt32) +#define rwFRAMEALIGNMENT sizeof(RwUInt32) +#define rwV4DALIGNMENT sizeof(RwUInt32) + +#if (defined(_MSC_VER)) + +#if (defined(RWVERBOSE)) +#include <tchar.h> +#pragma comment (lib , "advapi32.LIB") /* Registry functions */ + +/* + * registry code + */ + +#if (defined(RpWinRegGetDWordValue)) +#undef RpWinRegGetDWordValue +#endif /* (defined(RpWinRegGetDWordValue)) */ + +#define RpWinRegGetDWordValue(_result, _hKey, _name, _val) \ +MACRO_START \ +{ \ + DWORD _size; \ + DWORD _type; \ + LONG _status; \ + \ + _status = \ + RegQueryValueEx((_hKey), (_name), 0, &_type, NULL, &_size); \ + (_result) = ((ERROR_SUCCESS == _status) && (REG_DWORD == _type)); \ + \ + if ((_result)) \ + { \ + _status = \ + RegQueryValueEx((_hKey), (_name), 0, &_type, \ + (BYTE *) (_val), &_size); \ + (_result) = (ERROR_SUCCESS == _status); \ + } \ +} \ +MACRO_STOP + +#if (defined(RpWinRegGetBinaryValue)) +#undef RpWinRegGetBinaryValue +#endif /* (defined(RpWinRegGetBinaryValue)) */ + +#define RpWinRegGetBinaryValue(_result, _hKey, _name, _val) \ +MACRO_START \ +{ \ + DWORD _size; \ + DWORD _type; \ + LONG _status; \ + \ + _status = \ + RegQueryValueEx((_hKey), (_name), 0, &_type, NULL, &_size); \ + (_result) = \ + ((ERROR_SUCCESS == _status) && \ + (REG_BINARY == _type) && (0 < _size)); \ + \ + if ((_result)) \ + { \ + *(_val) = RwMalloc(sizeof(BYTE) * _size); \ + (_result) = (NULL != *(_val)); \ + \ + if ((_result)) \ + { \ + \ + _status = \ + RegQueryValueEx((_hKey), \ + (_name), 0, &_type, \ + (BYTE *) * (_val), &_size); \ + (_result =) (ERROR_SUCCESS == _status); \ + \ + if (!(_result)) \ + { \ + RwFree(*(_val)); \ + *(_val) = NULL; \ + } \ + \ + } \ + \ + } \ +} \ +MACRO_STOP + +#if (defined(RpWinRegGetStringValue)) +#undef RpWinRegGetStringValue +#endif /* (defined(RpWinRegGetStringValue)) */ + +#define RpWinRegGetStringValue(_result, _hKey, _name, _val) \ +MACRO_START \ +{ \ + DWORD _size; \ + DWORD _type; \ + LONG _status; \ + \ + _status = \ + RegQueryValueEx((_hKey), (_name), 0, &_type, NULL, &_size); \ + (_result) = \ + ((ERROR_SUCCESS == _status) && \ + (REG_SZ == _type) && (0 < _size)); \ + \ + if ((_result)) \ + { \ + \ + *(_val) = RwMalloc(sizeof(TCHAR) * _size); \ + (_result) = (NULL != *(_val)); \ + \ + if ((_result)) \ + { \ + _status = \ + RegQueryValueEx((_hKey), (_name), 0, &_type, \ + (BYTE *) * (_val), &_size); \ + (_result) = (ERROR_SUCCESS == _status); \ + \ + if (!(_result)) \ + { \ + RwFree(*(_val)); \ + *(_val) = NULL; \ + } \ + } \ + } \ +} \ +MACRO_STOP + +/* ------------------------------------------------------------------- */ + +#define RpWinRegCloseKey(hKey) \ +MACRO_START \ +{ \ + RegCloseKey(hKey); \ +} \ +MACRO_STOP + +/* ------------------------------------------------------------------- */ + +#define RpWinRegOpenMachineKey(result) \ +MACRO_START \ +{ \ + static const TCHAR RenderWareKey[] = \ + "Software\\Criterion\\RenderWare"; \ + DWORD disposition; \ + LONG status = \ + RegCreateKeyEx(HKEY_LOCAL_MACHINE, RenderWareKey, 0, \ + REG_NONE, REG_OPTION_NON_VOLATILE, \ + KEY_READ | KEY_WRITE, \ + NULL, &result, &disposition); \ + \ + if (status != ERROR_SUCCESS) \ + { \ + result = NULL; \ + } \ +} \ +MACRO_STOP + +/* ------------------------------------------------------------------- */ + +#if (defined(RWGETWINREGDWORD)) +#undef RWGETWINREGDWORD +#endif /* (defined(RWGETWINREGDWORD)) */ + +#define RWGETWINREGDWORD(result, match) \ +MACRO_START \ +{ \ + HKEY hKey; \ + \ + RpWinRegOpenMachineKey(hKey); \ + if (hKey) \ + { \ + RwBool success; \ + \ + RpWinRegGetDWordValue(success, hKey, match, \ + &result); \ + \ + RpWinRegCloseKey(hKey); \ + } \ +} \ +MACRO_STOP + +#if (defined(RWGETWINREGBINARY)) +#undef RWGETWINREGBINARY +#endif /* (defined(RWGETWINREGBINARY)) */ + +#define RWGETWINREGBINARY(result, match) \ +MACRO_START \ +{ \ + HKEY hKey; \ + \ + result = NULL; \ + RpWinRegOpenMachineKey(hKey); \ + if (hKey) \ + { \ + RwBool success; \ + \ + RpWinRegGetBinaryValue(success, hKey, match, \ + &result, NULL); \ + \ + if (!success) \ + result = NULL; \ + \ + RpWinRegCloseKey(hKey); \ + } \ +} \ +MACRO_STOP + +#if (defined(RWGETWINREGSTRING)) +#undef RWGETWINREGSTRING +#endif /* (defined(RWGETWINREGSTRING)) */ + +#define RWGETWINREGSTRING(result, match) \ +MACRO_START \ +{ \ + HKEY hKey; \ + \ + result = NULL; \ + RpWinRegOpenMachineKey(hKey); \ + if (hKey) \ + { \ + RwBool success; \ + \ + RpWinRegGetStringValue(success, hKey, match, \ + &result); \ + \ + if (!success) \ + result = NULL; \ + \ + RpWinRegCloseKey(hKey); \ + } \ +} \ +MACRO_STOP + +#if (defined(_DEBUG)) + +#if (defined(RWREGSETBREAKALLOC)) +#undef RWREGSETBREAKALLOC +#endif /* (defined(RWREGSETBREAKALLOC)) */ + +#define RWREGSETBREAKALLOC(_name) \ +MACRO_START \ +{ \ + char _message[256]; \ + long _lBreakAlloc = -1; \ + \ + RWGETWINREGDWORD(_lBreakAlloc, _name); \ + \ + RWCRTSETBREAKALLOC(_lBreakAlloc); \ + \ + _snprintf(_message, sizeof(_message), \ + "%s(%d): RWCRTSETBREAKALLOC(%ld)\n", \ + __FILE__, __LINE__, \ + _lBreakAlloc); \ + OutputDebugString(_message); \ + \ +} \ +MACRO_STOP + +#if (defined(RWREGSETDEBUGTRACE)) +#undef RWREGSETDEBUGTRACE +#endif /* (defined(RWREGSETDEBUGTRACE)) */ + +#define RWREGSETDEBUGTRACE(_name) \ +MACRO_START \ +{ \ + char _message[256]; \ + long _lDebugtrace = 0; \ + \ + RWGETWINREGDWORD(_lDebugtrace, _name); \ + \ + RwDebugSetTraceState(_lDebugtrace); \ + \ + _snprintf(_message, sizeof(_message), \ + "%s(%d): RwDebugSetTraceState(%ld)\n", \ + __FILE__, __LINE__, \ + _lDebugtrace); \ + OutputDebugString(_message); \ + \ +} \ +MACRO_STOP + +#if (defined(_CRTDBG_FLAGS)) +#undef _CRTDBG_FLAGS +#endif /* (defined(_CRTDBG_FLAGS)) */ + +#define _CRTDBG_FLAGS \ +( _CRTDBG_ALLOC_MEM_DF || /* Turn on the debug heap allocations \ + * and use the memory block identifiers. \ + * This is the only flag that's on by default. */ \ + _CRTDBG_CHECK_ALWAYS_DF || /* Check and validate all memory \ + * on each allocation and deallocation request. \ + * Setting this flag on is what catches the \ + * under and overwrites \ + * so it is very important to \ + * get it turned on. */ \ + _CRTDBG_CHECK_CRT_DF || /* Include _CRT_BLOCK memory allocations \ + * in all leak detection and state differences. */ \ + _CRTDBG_DELAY_FREE_MEM_DF || /* Instead of truly freeing memory, \ + * keep the block allocated and \ + * in the internal heap list. \ + * The blocks are filled with the value0xDD \ + * so you know the memory is freed when \ + * looking at it in the debugger. \ + * By also not freeing the memory, \ + * this can help provide stress \ + * conditions for the program. */ \ + _CRTDBG_LEAK_CHECK_DF) /* Do memory leak checking at \ + * the end of the program. */ + +#endif /* (defined(_DEBUG)) */ +#endif /* (defined(RWVERBOSE)) */ + +#include <math.h> +/* + * Keep true calls to these functions since + * some x86 runtime libraries do not support _CIpow() etc + */ +#pragma function( acos, asin, cosh, fmod, pow, sinh , tanh ) + +#if (!defined(RWINT32FROMFLOAT)) + +static __inline RwInt32 +int32fromreal(RwReal x) +{ + RwInt16 savemode; + RwInt16 workmode; + RwInt32 res; + + _asm + { + fnstcw savemode ; get fpu mode + fld dword ptr[x] ; load rwreal x + + mov ax,savemode ; put fpu mode in register + or ah,0ch ; or-in truncate mode + + mov workmode,ax ; make ready to set fpu mode + fldcw workmode ; set fpu to truncate mode + fistp dword ptr[res]; store the rwint32eger result + fldcw savemode ; restore fpu mode + } + + return res; +} +#define RwInt32FromRealMacro(x) int32fromreal(x) + +#endif /* (!defined(RWINT32FROMFLOAT)) */ + +#if (!defined(NOASM)) +static __inline RwUInt32 +RwFastRealToUInt32(RwReal x) +{ + RwUInt32 res; + + __asm FLD DWord Ptr[x]; + __asm FISTP DWord Ptr[res]; + + return(res); +} +#endif /* (defined(NOASM)) */ + +#endif /* (defined(_MSC_VER)) */ + +#endif /* WIN_OSTYPES_H */ + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/bamath.h ---*/ + +/**************************************************************************** + Defines + */ + +#if (!defined(RwInt32FromRealMacro)) +#define RwInt32FromRealMacro(x) \ + ((RwInt32)(x)) +#endif /* (!defined(RwInt32FromRealMacro)) */ + +#if (!defined(RwFastRealToUInt32)) +#define RwFastRealToUInt32(_x) \ + ((RwUInt32)RwInt32FromRealMacro(((RwReal)(_x)))) +#endif /* (!defined(RwFastRealToUInt32)) */ + +/* + * Ensure inclusion of prototypes for single precison maths functions + * e.g. from + * /usr/local/sce/ee/gcc/ee/include/math.h + * /Program Files/Intel/Compiler4.0/include/mathf.h + */ + +#if (defined(__ICL)) + +#if (defined(RWVERBOSE)) + +/* + * See + * http://www.eskimo.com/~scs/C-faq/q11.17.html + */ + +#define _STRINGIFY(X) #X +#define _STRINGIFY_EXP(X) _STRINGIFY(X) + +#pragma message ("Intel Compiler Version " _STRINGIFY_EXP(__ICL) ":" __FILE__ "(" _STRINGIFY_EXP(__LINE__) ")\n") +#pragma comment ( user, "comment:" "Intel Compiler Version " _STRINGIFY_EXP(__ICL) ":" __FILE__ "(" _STRINGIFY_EXP(__LINE__) ")\n") + +#endif /* (defined(RWVERBOSE)) */ + +#if (400 <= __ICL) +#if (defined(__cplusplus)) +#define _INC_MATH +#endif /* (defined(__cplusplus)) */ +#include <mathf.h> +#else /* (400 < __ICL) */ +#undef RW_USE_SPF +#endif /* (400 < __ICL) */ + +#endif /* (defined(__ICL)) */ + +#include <math.h> + +#define _RW_C1 ( (float) 4.1666667908e-02 ) +#define _RW_C2 ( (float)-1.3888889225e-03 ) +#define _RW_C3 ( (float) 2.4801587642e-05 ) +#define _RW_C4 ( (float)-2.7557314297e-07 ) +#define _RW_C5 ( (float) 2.0875723372e-09 ) +#define _RW_C6 ( (float)-1.1359647598e-11 ) +#define _RW_S1 ( (float)-1.6666667163e-01 ) +#define _RW_S2 ( (float) 8.3333337680e-03 ) +#define _RW_S3 ( (float)-1.9841270114e-04 ) +#define _RW_S4 ( (float) 2.7557314297e-06 ) +#define _RW_S5 ( (float)-2.5050759689e-08 ) +#define _RW_S6 ( (float) 1.5896910177e-10 ) +#define _RW_one ( (float) 1.0000000000e+00 ) +#define _RW_pS0 ( (float) 1.6666667163e-01 ) +#define _RW_pS1 ( (float)-3.2556581497e-01 ) +#define _RW_pS2 ( (float) 2.0121252537e-01 ) +#define _RW_pS3 ( (float)-4.0055535734e-02 ) +#define _RW_pS4 ( (float) 7.9153501429e-04 ) +#define _RW_pS5 ( (float) 3.4793309169e-05 ) +#define _RW_pi ( (float) 3.1415925026e+00 ) +#define _RW_pi_tol ( (float) 0.0312500000e+00 ) +#define _RW_pio2_hi ( (float) 1.5707962513e+00 ) +#define _RW_pio2_lo ( (float) 7.5497894159e-08 ) +#define _RW_qS1 ( (float)-2.4033949375e+00 ) +#define _RW_qS2 ( (float) 2.0209457874e+00 ) +#define _RW_qS3 ( (float)-6.8828397989e-01 ) +#define _RW_qS4 ( (float) 7.7038154006e-02 ) + +#define RwCosMinusPiToPiMacro(result, x) \ +MACRO_START \ +{ \ + const float z = x * x; \ + const float r = ( z * (_RW_C1 + \ + z * (_RW_C2 + \ + z * (_RW_C3 + \ + z * (_RW_C4 + \ + z * (_RW_C5 + \ + z * _RW_C6)))))); \ + result = (_RW_one - ((float) 0.5 * z - (z * r ))); \ +} \ +MACRO_STOP + +#define RwSinMinusPiToPiMacro(result, x) \ +do \ +{ \ + const float z = x * x; \ + const float v = z * x; \ + const float r = ( _RW_S2 + \ + z * (_RW_S3 + \ + z * (_RW_S4 + \ + z * (_RW_S5 + \ + z * _RW_S6))) ); \ + result = x + v * (_RW_S1 + z * r); \ +} \ +while(0) + +typedef union _rwIEEEFloatShapeType _rwIEEEFloatShapeType; +union _rwIEEEFloatShapeType +{ + float value; + unsigned int word; +}; + +#define _RW_GET_FLOAT_WORD(i,d) \ +do { \ + _rwIEEEFloatShapeType gf_u; \ + gf_u.value = (d); \ + (i) = gf_u.word; \ +} while (0) + +/* Set a float from a 32 bit int. */ + +#define _RW_SET_FLOAT_WORD(d,i) \ +do { \ + _rwIEEEFloatShapeType sf_u; \ + sf_u.word = (i); \ + (d) = sf_u.value; \ +} while (0) + +#define RwIEEEACosfMacro(result, x) \ +do \ +{ \ + float z, p, q, r, w, s, c, df; \ + int hx, ix; \ + \ + _RW_GET_FLOAT_WORD(hx, x); \ + ix = hx & 0x7fffffff; \ + if (ix >= 0x3f800000) \ + { /* |x|>=1 */ \ + if (hx > 0) \ + { \ + /* acos(1) = 0 */ \ + result = (0.0); \ + } \ + else \ + { \ + /* acos(-1)= _RW_pi */ \ + result = (_RW_pi + (float) 2.0 * _RW_pio2_lo); \ + } \ + \ + } \ + else if (ix < 0x3f000000) \ + { /* |x| < 0.5 */ \ + if (ix <= 0x23000000) \ + { \ + /*if |x|<2**-57 */ \ + result = (_RW_pio2_hi + _RW_pio2_lo); \ + } \ + else \ + { \ + z = x * x; \ + p = z * (_RW_pS0 + \ + z * (_RW_pS1 + \ + z * (_RW_pS2 + \ + z * (_RW_pS3 + \ + z * (_RW_pS4 + z * _RW_pS5))))); \ + q = _RW_one + z * (_RW_qS1 + \ + z * (_RW_qS2 + \ + z * (_RW_qS3 + z * _RW_qS4))); \ + r = p / q; \ + result = (_RW_pio2_hi - (x - (_RW_pio2_lo - x * r))); \ + } \ + \ + } \ + else if (hx < 0) \ + { /* x < -0.5 */ \ + z = (_RW_one + x) * (float) 0.5; \ + p = z * (_RW_pS0 + \ + z * (_RW_pS1 + \ + z * (_RW_pS2 + \ + z * (_RW_pS3 + \ + z * (_RW_pS4 + z * _RW_pS5))))); \ + q = _RW_one + z * (_RW_qS1 + \ + z * (_RW_qS2 + z * (_RW_qS3 + z * _RW_qS4))); \ + rwSqrtMacro(&s, z); \ + r = p / q; \ + w = r * s - _RW_pio2_lo; \ + result = (_RW_pi - (float) 2.0 * (s + w)); \ + } \ + else \ + { /* x > 0.5 */ \ + int idf; \ + \ + z = (_RW_one - x) * (float) 0.5; \ + rwSqrtMacro(&s, z); \ + df = s; \ + _RW_GET_FLOAT_WORD(idf, df); \ + _RW_SET_FLOAT_WORD(df, idf & 0xfffff000); \ + c = (z - df * df) / (s + df); \ + p = z * (_RW_pS0 + \ + z * (_RW_pS1 + \ + z * (_RW_pS2 + \ + z * (_RW_pS3 + \ + z * (_RW_pS4 + z * _RW_pS5))))); \ + q = _RW_one + z * (_RW_qS1 + \ + z * (_RW_qS2 + z * (_RW_qS3 + z * _RW_qS4))); \ + r = p / q; \ + w = r * s + c; \ + result = ((float) 2.0 * (df + w)); \ + } \ +} \ +while(0) + +#if (defined(RW_USE_SPF)) + +#define RwACos(_x) acosf(_x) +#define RwACosh(_x) acoshf(_x) +#define RwASin(_x) asinf(_x) +#define RwASinh(_x) asinhf(_x) + +#if (!defined(__ICL)) +/* + * No SPF version in + * Program Files/Intel/compilerXXX/include/mathf.h + * of atan2() + */ +#define RwATan2(_x, _y) atan2f(_x, _y) +#endif /* (!defined(__ICL)) */ + +#define RwATan(_x) atanf(_x) +#define RwATanh(_x) atanhf(_x) +#define RwCabs() cabsf() +#define RwCbrt(_x) cbrtf(_x) +#define RwCeil(_x) ceilf(_x) +#define RwCopysign(_x, _y) copysignf(_x, _y) +#define RwCos(_x) cosf(_x) +#define RwCosh(_x) coshf(_x) +#define RwDrem(_x, _y) dremf(_x, _y) +#define RwErfc(_x) erfcf(_x) +#define RwErf(_x) erff(_x) +#define RwExp(_x) expf(_x) +#define RwExpm1(_x) expm1f(_x) +#define RwFinite(_x) finitef(_x) +#define RwIlogb(_x) ilogbf(_x) +#define RwIsinf(_x) isinff(_x) +#define RwIsnan(_x) isnanf(_x) +#define RwFabs(_x) fabsf(_x) +#define RwFloor(_x) floorf(_x) +#define RwFmod(_x, _y) fmodf(_x, _y) +#define RwFrexp(_x, _iptr) frexpf(_x, _iptr) +#define RwGamma(_x) gammaf(_x) +#define RwGammaf_(_x, _iptr) gammaf_r(_x, _iptr) +#define RwHypot(_x, _y) hypotf(_x, _y) +#define RwInfinity() infinityf() +#define RwJ0(_x) j0f(_x) +#define RwJ1(_x) j1f(_x) +#define RwJn(_i, _x) jnf(_i, _x) +#define RwLdexp(_x, _i) ldexpf(_x, _i) +#define RwLgamma(_x) lgammaf(_x) +#define RwLgammaf_(_x, _iptr) lgammaf_r(_x, _iptr) +#define RwLog10(_x) log10f(_x) +#define RwLog1p(_x) log1pf(_x) +#define RwLog(_x) logf(_x) +#define RwModf(_x, _y) modff(_x, _y) +#define RwNan() nanf() +#define RwNextafter(_x, _y) nextafterf(_x, _y) +#define RwPow(_x, _y) powf(_x, _y) +#define RwRemainder(_x, _y) remainderf(_x, _y) +#define RwRint(_x) rintf(_x) +#define RwScalbn(_x, _i) scalbnf(_x, _i) +#define RwSin(_x) sinf(_x) +#define RwSinh(_x) sinhf(_x) +/* rwSqrtMacro/rwInvSqrtMacro are overloaded in drvmodel.h + * (if they are at all) and wrapped as func/macro below */ +#define RwTan(_x) tanf(_x) +#define RwTanh(_x) tanhf(_x) +#define RwY0(_x) y0f(_x) +#define RwY1(_x) y1f(_x) +#define RwYn(_i, _x) ynf(_i, _x) + +#endif /* (defined(RW_USE_SPF)) */ + +#if (!defined(RwACos)) +#define RwACos(_x) acos(_x) +#endif /* (!defined(RwACos)) */ +#if (!defined(RwACosh)) +#define RwACosh(_x) acosh(_x) +#endif /* (!defined(RwACosh)) */ +#if (!defined(RwASin)) +#define RwASin(_x) asin(_x) +#endif /* (!defined(RwASin)) */ +#if (!defined(RwASinh)) +#define RwASinh(_x) asinh(_x) +#endif /* (!defined(RwASinh)) */ +#if (!defined(RwATan2)) +#define RwATan2(_x, _y) atan2(_x, _y) +#endif /* (!defined(RwATan2)) */ +#if (!defined(RwATan)) +#define RwATan(_x) atan(_x) +#endif /* (!defined(RwATan)) */ +#if (!defined(RwATanh)) +#define RwATanh(_x) atanh(_x) +#endif /* (!defined(RwATanh)) */ +#if (!defined(RwCabs)) +#define RwCabs() cabs() +#endif /* (!defined(RwCabs)) */ +#if (!defined(RwCbrt)) +#define RwCbrt(_x) cbrt(_x) +#endif /* (!defined(RwCbrt)) */ +#if (!defined(RwCeil)) +#define RwCeil(_x) ceil(_x) +#endif /* (!defined(RwCeil)) */ +#if (!defined(RwCopysign)) +#define RwCopysign(_x, _y) copysign(_x, _y) +#endif /* (!defined(RwCopysign)) */ +#if (!defined(RwCos)) +#define RwCos(_x) cos(_x) +#endif /* (!defined(RwCos)) */ +#if (!defined(RwCosh)) +#define RwCosh(_x) cosh(_x) +#endif /* (!defined(RwCosh)) */ +#if (!defined(RwDrem)) +#define RwDrem(_x, _y) drem(_x, _y) +#endif /* (!defined(RwDrem)) */ +#if (!defined(RwErfc)) +#define RwErfc(_x) erfc(_x) +#endif /* (!defined(RwErfc)) */ +#if (!defined(RwEr)) +#define RwEr(_x) erf(_x) +#endif /* (!defined(RwEr)) */ +#if (!defined(RwExp)) +#define RwExp(_x) exp(_x) +#endif /* (!defined(RwExp)) */ +#if (!defined(RwExpm1)) +#define RwExpm1(_x) expm1(_x) +#endif /* (!defined(RwExpm1)) */ +#if (!defined(RwFinite)) +#define RwFinite(_x) finite(_x) +#endif /* (!defined(RwFinite)) */ +#if (!defined(RwIlogb)) +#define RwIlogb(_x) ilogb(_x) +#endif /* (!defined(RwIlogb)) */ +#if (!defined(RwIsin)) +#define RwIsin(_x) isinf(_x) +#endif /* (!defined(RwIsin)) */ +#if (!defined(RwIsnan)) +#define RwIsnan(_x) isnan(_x) +#endif /* (!defined(RwIsnan)) */ +#if (!defined(RwFabs)) +#define RwFabs(_x) fabs(_x) +#endif /* (!defined(RwFabs)) */ +#if (!defined(RwFloor)) +#define RwFloor(_x) floor(_x) +#endif /* (!defined(RwFloor)) */ +#if (!defined(RwFmod)) +#define RwFmod(_x, _y) fmod(_x, _y) +#endif /* (!defined(RwFmod)) */ +#if (!defined(RwFrexp)) +#define RwFrexp(_x, _iptr) frexp(_x, _iptr) +#endif /* (!defined(RwFrexp)) */ +#if (!defined(RwGamma)) +#define RwGamma(_x) gamma(_x) +#endif /* (!defined(RwGamma)) */ +#if (!defined(RwGammaf_)) +#define RwGammaf_(_x, _iptr) gammaf_r(_x, _iptr) +#endif /* (!defined(RwGammaf_)) */ +#if (!defined(RwHypot)) +#define RwHypot(_x, _y) hypot(_x, _y) +#endif /* (!defined(RwHypot)) */ +#if (!defined(RwInfinity)) +#define RwInfinity() infinity() +#endif /* (!defined(RwInfinity)) */ +#if (!defined(RwJ0)) +#define RwJ0(_x) j0(_x) +#endif /* (!defined(RwJ0)) */ +#if (!defined(RwJ1)) +#define RwJ1(_x) j1(_x) +#endif /* (!defined(RwJ1)) */ +#if (!defined(RwJn)) +#define RwJn(_i, _x) jn(_i, _x) +#endif /* (!defined(RwJn)) */ +#if (!defined(RwLdexp)) +#define RwLdexp(_x, _i) ldexp(_x, _i) +#endif /* (!defined(RwLdexp)) */ +#if (!defined(RwLgamma)) +#define RwLgamma(_x) lgamma(_x) +#endif /* (!defined(RwLgamma)) */ +#if (!defined(RwLgammaf_)) +#define RwLgammaf_(_x, _iptr) lgammaf_r(_x, _iptr) +#endif /* (!defined(RwLgammaf_)) */ +#if (!defined(RwLog10)) +#define RwLog10(_x) log10(_x) +#endif /* (!defined(RwLog10)) */ +#if (!defined(RwLog1p)) +#define RwLog1p(_x) log1p(_x) +#endif /* (!defined(RwLog1p)) */ +#if (!defined(RwLog)) +#define RwLog(_x) log(_x) +#endif /* (!defined(RwLog)) */ +#if (!defined(RwMod)) +#define RwMod(_x, _y) mod(_x, _y ) +#endif /* (!defined(RwMod)) */ +#if (!defined(RwNan)) +#define RwNan() nan() +#endif /* (!defined(RwNan)) */ +#if (!defined(RwNextafter)) +#define RwNextafter(_x, _y) nextafter(_x, _y) +#endif /* (!defined(RwNextafter)) */ +#if (!defined(RwPow)) +#define RwPow(_x, _y) pow(_x, _y) +#endif /* (!defined(RwPow)) */ +#if (!defined(RwRemainder)) +#define RwRemainder(_x, _y) remainder(_x, _y) +#endif /* (!defined(RwRemainder)) */ +#if (!defined(RwRint)) +#define RwRint(_x) rint(_x) +#endif /* (!defined(RwRint)) */ +#if (!defined(RwScalbn)) +#define RwScalbn(_x, _i) scalbn(_x, _i) +#endif /* (!defined(RwScalbn)) */ +#if (!defined(RwSin)) +#define RwSin(_x) sin(_x) +#endif /* (!defined(RwSin)) */ +#if (!defined(RwSinh)) +#define RwSinh(_x) sinh(_x) +#endif /* (!defined(RwSinh)) */ +#if (!defined(rwSqrt)) +/* NOTE: this is overloaded in drvmodel.h for some targets (SKY2 and XBOX atm) + * [we do in fact do overload w/ sqrtf there, if RW_USE_SPF, + * for D3D7, D3D8, OpenGL and SoftRas] */ +#define rwSqrt(_result, _x) rwSqrtMacro(_result, _x) +#endif /* (!defined(rwSqrt)) */ +#if (!defined(rwInvSqrt)) +/* NOTE: this is overloaded in drvmodel.h for some targets (SKY2 and XBOX atm) + * [we do in fact do overload w/ (1 / sqrtf) there, if RW_USE_SPF, + * for D3D7, D3D8, OpenGL and SoftRas] */ +#define rwInvSqrt(_recip, _x) rwInvSqrtMacro(_recip, _x) +#endif /* (!defined(rwInvSqrt)) */ +#if (!defined(RwTan)) +#define RwTan(_x) tan(_x) +#endif /* (!defined(RwTan)) */ +#if (!defined(RwTanh)) +#define RwTanh(_x) tanh(_x) +#endif /* (!defined(RwTanh)) */ +#if (!defined(RwY0)) +#define RwY0(_x) y0(_x) +#endif /* (!defined(RwY0)) */ +#if (!defined(RwY1)) +#define RwY1(_x) y1(_x) +#endif /* (!defined(RwY1)) */ +#if (!defined(RwYn)) +#define RwYn(_i, _x) yn(_i, _x) +#endif /* (!defined(RwYn)) */ + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/batypes.h ---*/ +#define rwLIBRARYBASEVERSION 0x31000 +#define rwLIBRARYCURRENTVERSION 0x33002 + +/* + * RWBUILDNUMBER + * This 16-bit int will be externally defined in an official build, and + * is used to construct chunk header library ID when streaming out. All + * unofficial builds will be stamped with the following:- + */ +#if !defined(RWBUILDNUMBER) +#define RWBUILDNUMBER 0xffff +#endif + +/* IMPORTANT: + * The following Doxygen comment MUST be copied into RwCore.h, + * so don't move it from here. */ + +/** + * \ingroup rwcore + * \page rwcoreoverview Core Library Overview + * + * LIBRARY: rwcore.lib + * HEADER: rwcore.h + * + * This library provides the fundamental RenderWare features. + * + * When creating a RenderWare application, this library must always be + * linked. + * + * Functionality includes: + * \li Immediate Modes (2D \ref rwim2d and 3D \ref rwim3d ) + * \li Plugin Management + * \li Base Datatypes + * \li Cameras \ref rwcamera + * \li Frames \ref rwframe + * \li the RenderWare Engine \ref rwengine + * + * RenderWare uses an object-oriented design philosophy, so this + * documentation is split across a number of objects. + * + * These objects are implemented in C, so C terminology is generally + * used, rather than C++ -- hence 'functions' instead of 'methods' and + * 'elements' instead of 'members'. + * + * If you are new to RenderWare programming, please read through the + * supplied User Guide. The RenderWare Engine \ref rwengine API is + * usually the starting point for new developers. + */ + + +#if (!defined(RWFORCEENUMSIZEINT)) +#define RWFORCEENUMSIZEINT ((RwInt32)((~((RwUInt32)0))>>1)) +#endif /* (!defined(RWFORCEENUMSIZEINT)) */ + +/* + * See + * http://www.eskimo.com/~scs/C-faq/q11.17.html + */ + +#define RW_STRINGIFY(X) #X +#define RW_STRINGIFY_EXPANDED(X) RW_STRINGIFY(X) + +/**************************************************************************** + Attributes + */ + +#if (defined(__GNUC__)) + +/* See http://www.gnu.org/software/gcc/onlinedocs/gcc_4.html#SEC91 */ + +#if (!(defined(__cplusplus) || defined(__MWERKS__) || defined(__RWUNUSED__))) +#define __RWUNUSED__ __attribute__ ((unused)) +#endif /* (!(defined(__cplusplus) || defined(__MWERKS__) || defined(__RWUNUSED__))) */ + +#if (!(defined(__RWUNUSEDRELEASE__) || defined(RWVALIDATEPARAM))) +#if (!( defined(__cplusplus) || defined(__MWERKS__) || defined(RWDEBUG))) +#define __RWUNUSEDRELEASE__ __attribute__ ((unused)) +#endif /* (!(defined(__cplusplus) || defined(__MWERKS__) || defined(RWDEBUG))) */ +#endif /* (!(defined(__RWUNUSEDRELEASE__) || defined(RWVALIDATEPARAM))) */ + +#if (!defined(__RWFORMAT__)) +#define __RWFORMAT__(_archetype, _string_index, _first_to_check) \ + __attribute__ ((format (_archetype, _string_index, _first_to_check))) +#endif /* (!defined(__RWFORMAT__)) */ + +#endif /* (defined(__GNUC__)) */ + +#if (!defined(__RWUNUSED__)) +#define __RWUNUSED__ /* No op */ +#endif /* (!defined(__RWUNUSED__)) */ + +#if (!defined(__RWUNUSEDRELEASE__)) +#define __RWUNUSEDRELEASE__ /* No op */ +#endif /* (!defined(__RWUNUSEDRELEASE__)) */ + +#if (!defined(__RWFORMAT__)) +#define __RWFORMAT__(_archetype, _string_index, _first_to_check) /* No op */ +#endif /* (!defined(__RWFORMAT__)) */ + +/**************************************************************************** + Calling conventions + */ + +#if (defined(WIN32)) +#define RWASMCALL __cdecl +#define RWASMAPI(TYPE) TYPE RWASMCALL +#endif /* (defined(WIN32)) */ + +#if (!defined(RWASMCALL)) +#define RWASMCALL /* No op */ +#endif /* (!defined(RWASMCALL)) */ + +#if (!defined(RWASMAPI)) +#define RWASMAPI(TYPE) TYPE +#endif /* (!defined(RWASMAPI)) */ + + +/* Maximum number of nested contexts */ +#define rwMAXPIPECONTEXT 10 + + +/**************************************************************************** + Macro wrappers. These are needed everywhere. + */ + +#ifndef MACRO_START +#define MACRO_START do +#endif /* MACRO_START */ + +#ifndef MACRO_STOP +#define MACRO_STOP while(0) +#endif /* MACRO_STOP */ + +/**************************************************************************** + Types needed everywhere + */ + +#ifdef FALSE +#undef FALSE +#endif +#define FALSE 0 + +#ifdef TRUE +#undef TRUE +#endif +#define TRUE !FALSE + +/**************************************************************************** + MS VC/C++ Specific + */ + +#if (defined(_MSC_VER)) +#if (_MSC_VER>=1000) + + +/* + * Check for correct compiler version + */ +#define RW_MSC_VER 1200 + +#if (0 && !defined(RW_NO_COMPILER_CHECK)) +#if (_MSC_VER != RW_MSC_VER ) +# pragma message (__FILE__ "(" RW_STRINGIFY_EXPANDED(__LINE__) "):" "\n This compiler is a different version (" RW_STRINGIFY_EXPANDED(_MSC_VER) ")\n to the compiler used to build the RenderWare product libraries (" RW_STRINGIFY_EXPANDED(RW_MSC_VER) ") \n To turn off this warning please define RW_NO_COMPILER_CHECK " ) +# pragma comment ( user, "comment:" __FILE__ "(" RW_STRINGIFY_EXPANDED(__LINE__) "):" "\n This compiler is a different version (" RW_STRINGIFY_EXPANDED(_MSC_VER) ")\n to the compiler used to build the RenderWare product libraries (" RW_STRINGIFY_EXPANDED(RW_MSC_VER) ") \n To turn off this warning please define RW_NO_COMPILER_CHECK " ) +#endif /* (_MSC_VER != RW_MSC_VER ) */ +#endif /* (0 && !defined(RW_NO_COMPILER_CHECK)) */ + +/* + * Output some compiler messages and object file comments + */ + +#pragma comment ( compiler ) + +#pragma comment ( user, "comment:" __DATE__" " __TIME__ " - " __FILE__ "(" RW_STRINGIFY_EXPANDED(__LINE__) ")") +#pragma comment ( user, "comment:" " _MSC_VER==" RW_STRINGIFY_EXPANDED(_MSC_VER) "; _M_IX86==" RW_STRINGIFY_EXPANDED(_M_IX86)) +#if (defined(rwLIBRARYCURRENTVERSION)) +#pragma comment ( user, "comment:" "rwLIBRARYCURRENTVERSION:" RW_STRINGIFY_EXPANDED(rwLIBRARYCURRENTVERSION) ) +#endif /* (defined(rwLIBRARYCURRENTVERSION)) */ + +#if (defined(RWDEBUG) && defined(RWVERBOSE)) + +/* #include <windows.h> */ +#if (defined(RWMEMDEBUG) && !defined(_CRTDBG_MAP_ALLOC)) +#define _CRTDBG_MAP_ALLOC +#endif /* defined(RWMEMDEBUG) && !defined(_CRTDBG_MAP_ALLOC)) */ +#include <crtdbg.h> + +#pragma message (__DATE__" " __TIME__ " - " __FILE__ "(" RW_STRINGIFY_EXPANDED(__LINE__) ")" ) +#pragma message ("_MSC_VER==" RW_STRINGIFY_EXPANDED(_MSC_VER) "; _M_IX86==" RW_STRINGIFY_EXPANDED(_M_IX86)) + +#if (defined(rwLIBRARYCURRENTVERSION)) +#pragma message ( "rwLIBRARYCURRENTVERSION:" RW_STRINGIFY_EXPANDED(rwLIBRARYCURRENTVERSION) ) +#endif /* (defined(rwLIBRARYCURRENTVERSION)) */ + +#endif /* (defined(RWDEBUG) && defined(RWVERBOSE) ) */ + +#endif /* (_MSC_VER>=1000) */ +#endif /* (defined(_MSC_VER)) */ + +/*******************/ +/* Primitive types */ +/*******************/ + +/* String construction stuff (gets us UNICODE support) */ +#ifdef RWUNICODE +#define _RWSTRING(x) L ## x +#else /* RWUNICODE */ +#define _RWSTRING(x) x +#endif /* RWUNICODE */ +#define RWSTRING(x) _RWSTRING(x) + +/* NB volatile keyword required for VC5.0 to ensure a reload - AMB */ +typedef union RwSplitBits RwSplitBits; +union RwSplitBits +{ + RwReal nReal; + volatile RwInt32 nInt; + volatile RwUInt32 nUInt; +}; + +typedef struct RwSplitFixed RwSplitFixed; + +#ifdef rwBIGENDIAN +struct RwSplitFixed +{ + RwInt16 integral; + RwUInt16 fractional; +}; + +#else /* rwBIGENDIAN */ +#ifdef rwLITTLEENDIAN +struct RwSplitFixed +{ + RwUInt16 fractional; + RwInt16 integral; +}; + +#else /* rwLITTLEENDIAN */ +#error "ENDIAN-ness undefined!" +#endif /* rwLITTLEENDIAN */ +#endif /* rwBIGENDIAN */ + +typedef union RwUnionReal RwUnionReal; +union RwUnionReal /* MSB is sign bit in any circumstance */ +{ + RwReal real; /* 4 bytes interpreted as RwReal */ + float floating; /* 4 bytes interpreted as float */ + RwFixed fixed; /* 4 bytes interpreted as 16:16 fixed */ + RwSplitFixed splitfixed; /* 4 bytes interpreted as 16:16 fixed */ +}; + +/*****************/ + +/* Complex types */ + +/*****************/ + +/** + * \ingroup datatypes + * \typedef RwV2d + * typedef for struct RwV2d + */ +typedef struct RwV2d RwV2d; +/** + * \ingroup datatypes + * \struct RwV2d + * This type represents points in a 2D space, such as device + * space, specified by the (x, y) coordinates of the point. + */ +struct RwV2d +{ + RwReal x; /**< X value*/ + RwReal y; /**< Y vlaue */ +}; + +/** + * \ingroup datatypes + * \typedef RwV3d + * typedef for struct RwV3d + */ +typedef struct RwV3d RwV3d; +/** + * \ingroup datatypes + * \struct RwV3d + * This type represents 3D points and vectors specified by + * the (x, y, z) coordinates of a 3D point or the (x, y, z) components of a + * 3D vector. + */ +struct RwV3d +{ + RwReal x; /**< X value */ + RwReal y; /**< Y value */ + RwReal z; /**< Z value */ +}; + +#define RWV4DALIGNMENT(_v4d) \ + (! (((rwV4DALIGNMENT)-1) & ((RwUInt32)(_v4d)))) + +/** + * \ingroup datatypes + * \struct RwV4d + * This type represents 4D points and vectors specified by + * the (x, y, z, w) coordinates of a 4D point or the (x, y, z, w) components of a + * 4D vector. + */ +struct RwV4d +{ + RwReal x; /**< X value */ + RwReal y; /**< Y value */ + RwReal z; /**< Z value */ + RwReal w; /**< W value */ +}; + +/** + * \ingroup datatypes + * \typedef RwV4d + * typedef for struct RwV4d + */ +typedef struct RwV4d RWALIGN(RwV4d, rwV4DALIGNMENT); + + +/** + * \ingroup datatypes + * \typedef RwRect + * typedef for struct RwRect + */ +typedef struct RwRect RwRect; +/** + * \ingroup datatypes + * \struct RwRect + * This type represents a 2D device space rectangle specified + * by the position of the top-left corner (the offset x, y) and its width (w) + * and height (h). + */ +struct RwRect +{ + RwInt32 x; /**< X value of the top-left corner */ + RwInt32 y; /**< Y value of the top-left corner */ + RwInt32 w; /**< Width of the rectangle */ + RwInt32 h; /**< Height of the rectangle */ +}; + +/** + * \ingroup datatypes + * \typedef RwSphere + * typedef for struct RwSphere + */ +typedef struct RwSphere RwSphere; +/** + * \ingroup datatypes + * \struct RwSphere + * This type represents a sphere specified by the position + * of its center and its radius + */ +struct RwSphere +{ + RwV3d center; /**< Sphere center */ + RwReal radius; /**< Sphere radius */ +}; + +#if (!defined(RwSphereAssign)) +#define RwSphereAssign(_target, _source) \ + ( *(_target) = *(_source) ) +#endif /* (!defined(RwSphereAssign)) */ + +/** + * \ingroup datatypes + * \typedef RwLine + * typedef for struct RwLine + */ +typedef struct RwLine RwLine; +/** + * \ingroup datatypes + * \struct RwLine + * This type represents a 3D line specified by the position + * of its start and end points. + */ +struct RwLine +{ + RwV3d start; /**< Line start */ + RwV3d end; /**< Line end */ +}; + +#if (!defined(RwLineAssign)) +#define RwLineAssign(_target, _source) \ + ( *(_target) = *(_source) ) +#endif /* (!defined(RwLineAssign)) */ + +/* The maximum number of texture coordinates */ +#define rwMAXTEXTURECOORDS 8 + +/** + * \ingroup datatypes + * RwTextureCoordinateIndex + * This type represents the index for texture coordinates. + */ +enum RwTextureCoordinateIndex +{ + rwNARWTEXTURECOORDINATEINDEX = 0, + rwTEXTURECOORDINATEINDEX0, + rwTEXTURECOORDINATEINDEX1, + rwTEXTURECOORDINATEINDEX2, + rwTEXTURECOORDINATEINDEX3, + rwTEXTURECOORDINATEINDEX4, + rwTEXTURECOORDINATEINDEX5, + rwTEXTURECOORDINATEINDEX6, + rwTEXTURECOORDINATEINDEX7, + rwTEXTURECOORDINATEINDEXFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwTextureCoordinateIndex RwTextureCoordinateIndex; + +/** + * \ingroup datatypes + * \typedef RwTexCoords + * typedef for struct RwTexCoords + */ +typedef struct RwTexCoords RwTexCoords; +/** + * \ingroup datatypes + * \struct RwTexCoords + * This type represents the the u and v texture + * coordinates of a particular vertex. + */ +struct RwTexCoords +{ + RwReal u; /**< U value */ + RwReal v; /**< V value */ +}; + + +/* Singley linked list macros. End marked as NULL */ + +typedef struct RwSLLink RwSLLink; /*** RwSLLink ***/ +struct RwSLLink +{ + RwSLLink *next; +}; + +#define rwSLLinkGetData(link,type,entry) \ + ((type *)(((RwUInt8 *)(link))-offsetof(type,entry))) + +#define rwSLLinkGetConstData(link,type,entry) \ + ((const type *)(((const RwUInt8 *)(link))-offsetof(type,entry))) + +#define rwSLLinkInitialize(linkvar) \ + (linkvar)->next = NULL; + +#define rwSLLinkGetNext(linkvar) \ + ((linkvar)->next) + +typedef struct RwSingleList RwSingleList; +struct RwSingleList +{ + RwSLLink link; +}; + +#define rwSingleListInitialize(list) \ + (list)->link.next= NULL; +#define rwSingleListEmpty(list) \ + (((list)->link.next)==NULL) +#define rwSingleListAddSLLink(list,linkvar) \ + ( (linkvar)->next = (list)->link.next, \ + (list)->link.next = (linkvar) ) +#define rwSingleListGetFirstSLLink(list) \ + ((list)->link.next) +#define rwSingleListGetTerminator(list) (NULL) + +/* Doubly linked list. End marked as start (its a ring) */ + +typedef struct RwLLLink RwLLLink; /*** RwLLLink ***/ +struct RwLLLink +{ + RwLLLink *next; + RwLLLink *prev; +}; + +#define rwLLLinkGetData(linkvar,type,entry) \ + ((type *)(((RwUInt8 *)(linkvar))-offsetof(type,entry))) + +#define rwLLLinkGetConstData(linkvar,type,entry) \ + ((const type *)(((const RwUInt8 *)(linkvar))-offsetof(type,entry))) + +#define rwLLLinkGetNext(linkvar) \ + ((linkvar)->next) + +#define rwLLLinkGetPrevious(linkvar) \ + ((linkvar)->prev) + +#define rwLLLinkInitialize(linkvar) \ + ( (linkvar)->prev = (RwLLLink *)NULL, \ + (linkvar)->next = (RwLLLink *)NULL ) + +#define rwLLLinkAttached(linkvar) \ + ((linkvar)->next) + +typedef struct RwLinkList RwLinkList; +struct RwLinkList +{ + RwLLLink link; +}; + +#define rwLinkListInitialize(list) \ + ( (list)->link.next = ((RwLLLink *)(list)), \ + (list)->link.prev = ((RwLLLink *)(list)) ) +#define rwLinkListEmpty(list) \ + (((list)->link.next) == (&(list)->link)) +#define rwLinkListAddLLLink(list, linkvar) \ + ( (linkvar)->next = (list)->link.next, \ + (linkvar)->prev = (&(list)->link), \ + ((list)->link.next)->prev = (linkvar), \ + (list)->link.next = (linkvar) ) +#define rwLinkListRemoveLLLink(linkvar) \ + ( ((linkvar)->prev)->next = (linkvar)->next, \ + ((linkvar)->next)->prev = (linkvar)->prev ) +#define rwLinkListGetFirstLLLink(list) \ + ((list)->link.next) +#define rwLinkListGetLastLLLink(list) \ + ((list)->link.prev) +#define rwLinkListGetTerminator(list) \ + (&((list)->link)) + +/** + * \ingroup datatypes + * \typedef RwSurfaceProperties + * typedef for struct RwSurfaceProperties + */ +typedef struct RwSurfaceProperties RwSurfaceProperties; +/** + * \ingroup datatypes + * \struct RwSurfaceProperties + * This type represents the ambient, diffuse and + * specular reflection coefficients of a particular geometry. Each coefficient + * is specified in the range 0.0 (no reflection) to 1.0 (maximum reflection). + */ +struct RwSurfaceProperties +{ + RwReal ambient; /**< ambient reflection coefficient */ + RwReal specular; /**< specular reflection coefficient */ + RwReal diffuse; /**< reflection coefficient */ +}; + +#if (!defined(RwSurfacePropertiesAssign)) +#define RwSurfacePropertiesAssign(_target, _source) \ + ( *(_target) = *(_source) ) +#endif /* (!defined(RwSurfacePropertiesAssign)) */ + +/********** + * Macros * + **********/ + +/* ANSI C defines the offsetof(type,member) macro; should be in <stddef.h> */ + +/* If not, fall back to this: */ +#ifndef offsetof +#define offsetof(type, member) \ + ((size_t)((RwUInt8 *)&((type *) 0)->member - (RwUInt8 *)((type *) 0))) +#endif /* offsetof */ + +/* + * + * Numeric Macros to handle Fixed/Floating point versions of RenderWare + * + */ +#define RWFIX_MIN (1) +#define RWFIX_MAX (0x7fffffff) +#define RwFixedCast(A) (RwInt32FromRealMacro((A) * 65536.0f)) +#define RwFixedToInt(A) ((A) >> 16) +#define RwFixedToFloat(A) ((float)(((float)(A)) * (1.0f / 65536.0f))) +#define RwFixedToReal(a) ((RwReal)(((RwReal)(a)) * (1.0f / 65536.0f))) +#define RwRealToFixed(a) (RwInt32FromRealMacro((a) * 65536.0f)) +#define RwRealAbs(a) ((RwReal)((a) >= (RwReal)(0.0) ? (a) : (-(a)))) +#define RwRealMin2(a,b) ((RwReal)( ((a) <= (b)) ? (a) : (b))) +#define RwRealMax2(a,b) ((RwReal)( ((a) >= (b)) ? (a) : (b))) +#define RwRealMin3(a,b,c) RwRealMin2(a,RwRealMin2(b,c)) +#define RwRealMax3(a,b,c) RwRealMax2(a,RwRealMax2(b,c)) + +#ifndef NORWREALSHORTCUT +#define RToFixed RwRealToFixed +#define RAbs RwRealAbs +#define FxCast RwFixedCast +#define FxToInt RwFixedToInt +#define FxToFloat RwFixedToFloat +#define FxToReal RwFixedToFloat + +#endif + +#ifndef rwPI +#define rwPI ((RwReal)(3.1415926535f)) +#define rwPIOVER2 (rwPI / (RwReal)(2.0f)) +#endif +#define RWRGBALONG(r,g,b,a) \ + ((RwUInt32) (((a) << 24) | ((r) << 16) | ((g) << 8) | (b))) + +/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + + RwPlane + + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ + + +/* + * typedef for struct RwPlane + */ +typedef struct RwPlane RwPlane; +/* + * This type represents a plane + */ +struct RwPlane +{ + RwV3d normal; /**< Normal to the plane */ + RwReal distance; /**< Distance to plane from origin in normal direction*/ +}; + + +/**************************************************************************** + Defines + */ + +enum RwPlaneType +{ + rwXPLANE = 0, /* These are deliberately multiples of sizeof(RwReal) */ + rwYPLANE = 4, + rwZPLANE = 8, + rwPLANETYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwPlaneType RwPlaneType; + +#define rwSECTORATOMIC -1 +#define rwSECTORBUILD -2 /* Only used when building a world */ + +/* vect is a RwV3d, y is the component */ +#define GETCOORD(vect,y) \ + (*(RwReal *)(((RwUInt8 *)(&((vect).x)))+(RwInt32)(y))) +#define GETCONSTCOORD(vect,y) \ + (*(const RwReal *)(((const RwUInt8 *)(&((vect).x)))+(RwInt32)(y))) +#define SETCOORD(vect,y,value) \ + (((*(RwReal *)(((RwUInt8 *)(&((vect).x)))+(RwInt32)(y))))=(value)) +#define SETCONTCOORD(vect,y,value) \ + (((*(const RwReal *) \ + (((const RwUInt8 *) \ + (&((vect).x)))+(RwInt32)(y))))=(value)) +#define GETCOORDINT(vect,y) \ + (*(RwInt32 *)(((RwUInt8 *)(&((vect).x)))+(y))) +#define GETCONSTCOORDINT(vect,y) \ + (*(const RwInt32 *)(((const RwUInt8 *)(&((vect).x)))+(y))) + + +/** + * \ingroup rwcore + * \page inttypes Integer Types + * + * RenderWare supports a number of integer types: + * + * RwInt8 8-bit signed integer. + * \li RwUInt8 8-bit unsigned integer. + * \li RwChar Character type. + * \li RwInt16 16-bit signed integer. + * \li RwUInt16 16-bit unsigned integer. + * \li RwInt32 32-bit signed integer. + * \li RwUInt32 32-bit unsigned integer. + * \li RwInt64 64-bit signed integer. + * \li RwUInt64 64-bit unsigned integer. + * \li RwInt128 128-bit signed integer. + * \li RwUInt128 128-bit unsigned integer. + * \li RwBool Boolean type (in 32 bits). + * + * These types should be used in applications in preference to the underlying + * native types. + * + * The following constants indicate the maximum and minimum values possible + * for the various RenderWare integer types: + * + * \li RwInt32MAXVAL Maximum RwInt32 value. + * \li RwInt32MINVAL Minimum RwInt32 value. + * \li RwUInt32MAXVAL Maximum RwUInt32 value. + * \li RwUInt32MINVAL Minimum RwUInt32 value. + * \li RwInt16MAXVAL Maximum RwInt16 value. + * \li RwInt16MINVAL Minimum RwInt16 value. + * \li RwUInt16MAXVAL Maximum RwUInt16 value. + * \li RwUInt16MINVAL Minimum RwUInt16 value. + * + * \see RwReal + */ + +/** + * \ingroup datatypes + * \typedef RwReal + * + * RenderWare supports a single RwReal floating-point type to aid portability + * across platforms. This type should be used in applications in preference to + * the underlying native type. + * + * The constants RwRealMAXVAL and RwRealMINVAL are provided for determining + * the maximum and minimum values possible using the RwReal type. + * + * In addition, the following macros are available for operations on RwReal + * types: + * \li RwRealMin2(a, b) Find the minimum of two RwReal values. + * \li RwRealMax2(a, b) Find the maximum of two RwReal values. + * \li RwRealMin3(a, b, c) Find the minimum of three RwReal values. + * \li RwRealMax3(a, b, c) Find the maximum of three RwReal values. + * \li RwRealAbs(x) Find the absolute value of a RwReal value. + * + * \see \ref inttypes + */ + +/** + * \ingroup datatypes + * \typedef RwFixed + * + * RenderWare supports a single RwFixed fixed-point type. + * + * Although popular in the days when integer mathematics was much faster than + * floating point mathematics, fixed-point math is now rarely used. It is + * provided because it is still useful for some processes. + * + * The maximum and minimum size of an RwFixed value are defined by the constants + * RWFIX_MAX and RWFIX_MIN respectively. + * + * The following macros are provided to help you work with RwFixed datatypes: + * \li RwFixedCast(x) Cast the integer portion of an RwFixed to another type. + * \li RwFixedToInt(x) Convert an RwFixed to an integer. (The fractional portion is lost.) + * \li RwFixedToFloat(x) Convert an RwFixed to a float. + * \li RwFixedToReal(x) Convert an RwFixed to an RwReal. + * \li RwRealToFixed(x) Convert an RwReal to an RwFixed. (Some precision may be lost.) + */ + +/** + * \ingroup datatypes + * \typedef RwInt8 + * + * Signed 8 bit integer type. + * \see \ref inttypes + */ + +/** + * \ingroup datatypes + * \typedef RwUInt8 + * + * Unsigned 8bit integer type. + * \see \ref inttypes + */ + +/** + * \ingroup datatypes + * \typedef RwChar + * + * Character type. + * \see \ref inttypes + */ + +/** + * \ingroup datatypes + * \typedef RwInt16 + * + * Signed 16 bit integer type. + * \see \ref inttypes + */ + +/** + * \ingroup datatypes + * \typedef RwUInt16 + * + * Unsigned 16 bit integer type. + * \see \ref inttypes + */ + +/** + * \ingroup datatypes + * \typedef RwInt32 + * + * Signed 32 bit integer type. + * \see \ref inttypes + */ + +/** + * \ingroup datatypes + * \typedef RwUInt32 + * + * Unsigned 32 bit integer type. + * \see \ref inttypes + */ + +/** + * \ingroup datatypes + * \typedef RwInt64 + * + * Signed 64 bit integer type. + * \see \ref inttypes + */ + +/** + * \ingroup datatypes + * \typedef RwUInt64 + * + * Unsigned 64 bit integer type. + * \see \ref inttypes + */ + +/** + * \ingroup datatypes + * \typedef RwInt128 + * + * Signed 128 bit integer type. + * \see \ref inttypes + */ + +/** + * \ingroup datatypes + * \typedef RwUInt128 + * + * Unsigned 128 bit integer type. + * \see \ref inttypes + */ + +/** + * \ingroup datatypes + * \typedef RwBool + * + * Boolean type. + * \see \ref inttypes + */ + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/batype.h ---*/ +/**************************************************************************** + Defines +*/ + +/* + * Object Types - these are used in the binary object + * representations and in the debug library. They must + * be unique. They are the old system. + */ + +#define rwID_DATABASE 0x64617462 /* datb */ + +#define MAKECHUNKID(vendorID, chunkID) (((vendorID & 0xFFFFFF) << 8) | (chunkID & 0xFF)) +#define GETOBJECTID(chunkID) (chunkID & 0xFF) +#define GETVENDORID(chunkID) ((chunkID >> 8) & 0xFFFFFF) + +/*** + *** These are the vendor IDs. A customer must reserve a vendor ID in order + *** to be able to write toolkits (this prevents clashes between toolkits). + *** We reserve some for our own use as shown below. These are all 24 bit. + *** + *** IMPORTANT NOTE: DO NOT UNDER ANY CIRCUMSTANCES CHANGE THESE VALUES. IF + *** YOU ARE ADDING A NEW ONE, APPEND IT! + *** + *** They must all be unique. + ***/ + +enum RwPluginVendor +{ + rwVENDORID_CORE = 0x000000L, + rwVENDORID_CRITERIONTK = 0x000001L, + rwVENDORID_REDLINERACER = 0x000002L, + rwVENDORID_CSLRD = 0x000003L, + rwVENDORID_CRITERIONINT = 0x000004L, + rwVENDORID_CRITERIONWORLD = 0x000005L, + rwVENDORID_BETA = 0x000006L, + rwVENDORID_CRITERIONRM = 0x000007L, + rwVENDORID_CRITERIONRWA = 0x000008L, /* RenderWare Audio */ + rwPLUGINVENDORFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwPluginVendor RwPluginVendor; + +/*** + *** These are the core objects (8 bit IDs). They must all be unique. + *** We can get away without using the MAKECHUNKID macro because the + *** vendor ID in all cases will be zero (rwVENDORID_CORE). + *** + *** IMPORTANT NOTE: DO NOT UNDER ANY CIRCUMSTANCES CHANGE THESE VALUES. IF + *** YOU ARE ADDING A NEW ONE, APPEND IT! + ***/ + +/* These are the internal ones. Because the core ID is 0, we can get away without + * using the MAKECHUNKID macro for the CORE chunks. + */ + +enum RwCorePluginID +{ + rwID_NAOBJECT = 0x00, + rwID_STRUCT = 0x01, + rwID_STRING = 0x02, + rwID_EXTENSION = 0x03, + rwID_CAMERA = 0x05, + rwID_TEXTURE = 0x06, + rwID_MATERIAL = 0x07, + rwID_MATLIST = 0x08, + rwID_ATOMICSECT = 0x09, + rwID_PLANESECT = 0x0A, + rwID_WORLD = 0x0B, + rwID_SPLINE = 0x0C, + rwID_MATRIX = 0x0D, + rwID_FRAMELIST = 0x0E, + rwID_GEOMETRY = 0x0F, + rwID_CLUMP = 0x10, + rwID_LIGHT = 0x12, + rwID_UNICODESTRING = 0x13, + rwID_ATOMIC = 0x14, + rwID_TEXTURENATIVE = 0x15, + rwID_TEXDICTIONARY = 0x16, + rwID_ANIMDATABASE = 0x17, + rwID_IMAGE = 0x18, + rwID_SKINANIMATION = 0x19, + rwID_GEOMETRYLIST = 0x1A, + rwID_HANIMANIMATION = 0x1B, + rwID_TEAM = 0x1C, + rwID_CROWD = 0x1D, + rwID_DMORPHANIMATION = 0x1E, + rwID_RIGHTTORENDER = 0x1f, + rwID_MTEFFECTNATIVE = 0x20, + rwID_MTEFFECTDICT = 0x21, + rwID_TEAMDICTIONARY = 0x22, + rwID_PITEXDICTIONARY = 0x23, + rwID_TOC = 0x24, + rwID_PRTSTDGLOBALDATA = 0x25, + /* Insert before MAX and increment MAX */ + rwID_COREPLUGINIDMAX = 0x26, + rwCOREPLUGINIDFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwCorePluginID RwCorePluginID ; + +/*** + *** These are the Criterion internal plugin extensions. Use with rwVENDORID_CRITERIONINT. + *** + *** IMPORTANT NOTE: DO NOT UNDER ANY CIRCUMSTANCES CHANGE THESE VALUES. IF + *** YOU ARE ADDING A NEW ONE, APPEND IT! + ***/ + +enum RwCriterionPluginID +{ + rwID_COREPLUGIN = 0x01, + rwID_WORLDPLUGIN = 0x02, + rwID_TOOLPLUGIN = 0x03, + rwID_TOOL2PLUGIN = 0x04, + rwCRITERIONPLUGINIDFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwCriterionPluginID RwCriterionPluginID; + + +/*** + *** These are the Criterion internal platform identifies. + *** + *** IMPORTANT NOTE: DO NOT UNDER ANY CIRCUMSTANCES CHANGE THESE VALUES. IF + *** YOU ARE ADDING A NEW ONE, APPEND IT! + ***/ +enum RwPlatformID +{ + rwID_PCD3D7 = 1, + rwID_PCOGL, + rwID_MAC, + rwID_PS2, + rwID_XBOX, + rwID_GAMECUBE, + rwID_SOFTRAS, + rwID_PCD3D8, + rwPLATFROMIDFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwPlatformID RwPlatformID; + + +/**************************************************************************** + Global Types + */ + +typedef struct RwObject RwObject; +/** + * \ingroup datatypes + * \struct RwObject + * This should be considered an opaque type. Use + * the RwObject API functions to access. + */ +struct RwObject +{ + RwUInt8 type; /**< Internal Use */ + RwUInt8 subType; /**< Internal Use */ + RwUInt8 flags; /**< Internal Use */ + RwUInt8 privateFlags; /**< Internal Use */ + void *parent; /**< Internal Use */ + /* Often a Frame */ +}; + +/** + * \ingroup datatypes + * \typedef RwObjectCallBack + * callback function supplied for object callback functions. + * + * \return Pointer to the current object + * + * \param object Pointer to the current object, supplied by + * iterator. + * \param data Pointer to developer-defined data structure. + * + * \see RwFrameForAllObjects + * + */ +typedef RwObject *(*RwObjectCallBack)(RwObject *object, void *data); + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* TYPE METHODS */ + +/* Creation/cloning */ + +#define rwObjectCopy(d,s) \ +MACRO_START \ +{ \ + ((RwObject *)(d))->type = \ + ((const RwObject *)(s))->type; \ + ((RwObject *)(d))->subType = \ + ((const RwObject *)(s))->subType; \ + ((RwObject *)(d))->flags = \ + ((const RwObject *)(s))->flags; \ + ((RwObject *)(d))->privateFlags = \ + ((const RwObject *)(s))->privateFlags; \ + ((RwObject *)(d))->parent = \ + NULL; \ +} \ +MACRO_STOP + +#define rwObjectInitialize(o, t, s) \ +MACRO_START \ +{ \ + ((RwObject *)(o))->type = (RwUInt8)(t); \ + ((RwObject *)(o))->subType = (RwUInt8)(s); \ + ((RwObject *)(o))->flags = 0; \ + ((RwObject *)(o))->privateFlags = 0; \ + ((RwObject *)(o))->parent = NULL; \ +} \ +MACRO_STOP + +/* Debug */ +#define RwObjectGetType(o) (((const RwObject *)(o))->type) + +#define rwObjectSetType(o, t) (((RwObject *)(o))->type) = (RwUInt8)(t) + +/* Sub type */ +#define rwObjectGetSubType(o) (((const RwObject *)(o))->subType) +#define rwObjectSetSubType(o, t) (((RwObject *)(o))->subType) = (RwUInt8)(t) + +/* Flags */ +#define rwObjectGetFlags(o) (((const RwObject *)(o))->flags) +#define rwObjectSetFlags(o, f) (((RwObject *)(o))->flags) = (RwUInt8)(f) +#define rwObjectTestFlags(o, f) ((((const RwObject *)(o))->flags) & (RwUInt8)(f)) + +/* Private flags */ +#define rwObjectGetPrivateFlags(c) (((const RwObject *)(c))->privateFlags) +#define rwObjectSetPrivateFlags(c,f) (((RwObject *)(c))->privateFlags) = (RwUInt8)(f) +#define rwObjectTestPrivateFlags(c,flag) ((((const RwObject *)(c))->privateFlags) & (RwUInt8)(flag)) + +/* Hierarchy */ +#define rwObjectGetParent(object) (((const RwObject *)(object))->parent) +#define rwObjectSetParent(c,p) (((RwObject *)(c))->parent) = (void *)(p) + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/os/win/osintf.h ---*/ + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/rwstring.h ---*/ + +/**************************************************************************** + Defines + */ + +#define rwsprintf RWSRCGLOBAL(stringFuncs).vecSprintf +#define rwvsprintf RWSRCGLOBAL(stringFuncs).vecVsprintf +#define rwstrcpy RWSRCGLOBAL(stringFuncs).vecStrcpy +#define rwstrncpy RWSRCGLOBAL(stringFuncs).vecStrncpy +#define rwstrcat RWSRCGLOBAL(stringFuncs).vecStrcat +#define rwstrncat RWSRCGLOBAL(stringFuncs).vecStrncat +#define rwstrrchr RWSRCGLOBAL(stringFuncs).vecStrrchr +#define rwstrchr RWSRCGLOBAL(stringFuncs).vecStrchr +#define rwstrstr RWSRCGLOBAL(stringFuncs).vecStrstr +#define rwstrcmp RWSRCGLOBAL(stringFuncs).vecStrcmp +#define rwstricmp RWSRCGLOBAL(stringFuncs).vecStricmp +#define rwstrlen RWSRCGLOBAL(stringFuncs).vecStrlen +#define rwstrupr RWSRCGLOBAL(stringFuncs).vecStrupr +#define rwstrlwr RWSRCGLOBAL(stringFuncs).vecStrlwr +#define rwstrtok RWSRCGLOBAL(stringFuncs).vecStrtok +#define rwsscanf RWSRCGLOBAL(stringFuncs).vecSscanf + +#define rwstrdup(_result, _string) \ +do \ +{ \ + _result = ((RwChar*)NULL); \ + \ + if (((RwChar*)NULL) != (_string)) \ + { \ + _result = (RwChar *) \ + RwMalloc( (rwstrlen(_string) + 1) * \ + sizeof (RwChar) ); \ + \ + if (((RwChar*)NULL) != (_result)) \ + { \ + rwstrcpy(_result, _string); \ + } \ + } \ +} \ +while (0) + + +/**************************************************************************** + Global Types + */ + +typedef int (*vecSprintfFunc)(RwChar *buffer, + const RwChar *format, + ...) /* __RWFORMAT__(printf, 2, 3) */; +typedef int (*vecVsprintfFunc)(RwChar *buffer, + const RwChar *format, + va_list argptr); +typedef RwChar *(*vecStrcpyFunc)(RwChar *dest, + const RwChar *srce); +typedef RwChar *(*vecStrncpyFunc)(RwChar *dest, + const RwChar *srce, + size_t size); +typedef RwChar *(*vecStrcatFunc)(RwChar *dest, + const RwChar *srce); +typedef RwChar *(*vecStrncatFunc)(RwChar *dest, + const RwChar *srce, + size_t size); +typedef RwChar *(*vecStrrchrFunc)(const RwChar *string, + int findThis); +typedef RwChar *(*vecStrchrFunc)(const RwChar *string, + int findThis); +typedef RwChar *(*vecStrstrFunc)(const RwChar *string, + const RwChar *findThis); +typedef int (*vecStrcmpFunc)(const RwChar *string1, + const RwChar *string2); +typedef int (*vecStricmpFunc)(const RwChar *string1, + const RwChar *string2); +typedef size_t (*vecStrlenFunc)(const RwChar *string); +typedef RwChar *(*vecStruprFunc)(RwChar *string); +typedef RwChar *(*vecStrlwrFunc)(RwChar *string); +typedef RwChar *(*vecStrtokFunc)(RwChar *string, const RwChar *delimit); +typedef int (*vecSscanfFunc)(const RwChar *buffer, + const RwChar *format, + ...) /* __RWFORMAT__(scanf, 2, 3) */; + +typedef struct RwStringFunctions RwStringFunctions; +struct RwStringFunctions +{ + vecSprintfFunc vecSprintf ; + vecVsprintfFunc vecVsprintf; + vecStrcpyFunc vecStrcpy; + vecStrncpyFunc vecStrncpy; + vecStrcatFunc vecStrcat; + vecStrncatFunc vecStrncat; + vecStrrchrFunc vecStrrchr; + vecStrchrFunc vecStrchr; + vecStrstrFunc vecStrstr; + vecStrcmpFunc vecStrcmp; + vecStricmpFunc vecStricmp; + vecStrlenFunc vecStrlen; + vecStruprFunc vecStrupr; + vecStrlwrFunc vecStrlwr; + vecStrtokFunc vecStrtok; + vecSscanfFunc vecSscanf; +}; + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/rwdbgerr.h ---*/ +#define RWECODE(a,b) a, + +/* Construct an enum type with all the plugin error codes (for the app to use) */ +enum RwErrorCodePlugin_errcore +{ +#include "errcore.def" + rwLASTERROR_errcore = RWFORCEENUMSIZEINT +}; +typedef enum RwErrorCodePlugin_errcore RwErrorCodePlugin_errcore; + + +#undef RWECODE + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/resmem.h ---*/ + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/bamemory.h ---*/ +#if (defined(RWMEMDEBUG)) +#ifdef _XBOX +/* Need OutputDebugString macros */ +#include <xtl.h> +#endif +#endif + +/**************************************************************************** + Defines + */ + +/* + * Debug fill bytes for compatibility with MSVC/C++ debug heap + * See + * \Program Files\Microsoft Visual Studio\VC98\CRT\SRC\DBGHEAP.C: + * static unsigned char _bNoMansLandFill = 0xFD; + * // fill no-man's land with this + * static unsigned char _bDeadLandFill = 0xDD; + * // fill free objects with this + * static unsigned char _bCleanLandFill = 0xCD; + * // fill new objects with this + */ + +#if (!defined(rwFREELISTNOMANSLANDFILL)) +#define rwFREELISTNOMANSLANDFILL 0xFD +#endif /* (!defined(rwFREELISTNOMANSLANDFILL)) */ + +#if (!defined(rwFREELISTDEADLANDFILL)) +#define rwFREELISTDEADLANDFILL 0xDD +#endif /* (!defined(rwFREELISTDEADLANDFILL)) */ + +#if (!defined(rwFREELISTCLEANLANDFILL)) +#define rwFREELISTCLEANLANDFILL 0xCD +#endif /* (!defined(rwFREELISTCLEANLANDFILL)) */ + +#define RWFREELISTALIGNED(_pData, _freelist) \ + (! (((RwUInt32)(_pData)) & ((_freelist)->alignmentMinusOne)) ) + +/***************************** + * REGULAR MEMORY ALLOCATION * + *****************************/ + +/** + * \ingroup rwmem + * \def RwMalloc + * RwMalloc(_s) is a macro for malloc(_s). + */ + +/** + * \ingroup rwmem + * \def RwFree + * RwFree(_p) is a macro for free(_p). + */ + +/** + * \ingroup rwmem + * \def RwCalloc + * RwCalloc(_n, _s) is a macro for calloc(_n, _s). + */ + +/** + * \ingroup rwmem + * \def RwRealloc + * RwRealloc(_p, _s) is a macro for realloc(_p, _s). + */ + +#if ( (defined(RWMEMDEBUG)) && defined(RWDEBUG) ) + +#if (!defined(RWNOFREELISTS)) +#define RWNOFREELISTS +#endif /* (!defined(RWNOFREELISTS)) */ + +#if (defined(rwPLUGIN_ID)) +#define _CLIENT_TAG \ + ( 0xFFFF & (rwPLUGIN_ID) ) +#endif /* (defined(rwPLUGIN_ID)) */ + +#if (!defined(_CLIENT_TAG)) +#define _CLIENT_TAG \ + ( 0xFFFF & (MAKECHUNKID(rwVENDORID_CRITERIONTK, 0x00) ) ) +#endif /* (!defined(_CLIENT_TAG)) */ + +# if (defined(_MSC_VER)) +# if ((_MSC_VER>=1000) && defined(_DEBUG)) + +/* Pick up _ASSERTE() macro */ +/* #include <windows.h> */ +#if (defined(RWMEMDEBUG) && !defined(_CRTDBG_MAP_ALLOC)) +#define _CRTDBG_MAP_ALLOC +#endif /* defined(RWMEMDEBUG) && !defined(_CRTDBG_MAP_ALLOC)) */ +#include <crtdbg.h> + +#define RwMalloc(_s) \ + _malloc_dbg((_s), \ + _CLIENT_BLOCK | ((_CLIENT_TAG)<<16), \ + __FILE__, \ + __LINE__) + +#define RwFree(_p) \ + _free_dbg((_p), \ + _CLIENT_BLOCK | ((_CLIENT_TAG)<<16)) + +#define RwCalloc(_n, _s) \ + _calloc_dbg((_n), (_s), \ + _CLIENT_BLOCK | ((_CLIENT_TAG)<<16), \ + __FILE__, \ + __LINE__) + +#define RwRealloc(_p, _s) \ + _realloc_dbg((_p), \ + (_s), \ + _CLIENT_BLOCK | ((_CLIENT_TAG)<<16), \ + __FILE__, \ + __LINE__) + +#define RWCRTORDBGFLAG(_flag) \ + do \ + { \ + int _DbgFlag; \ + \ + _DbgFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG); \ + _DbgFlag |= (_flag); \ + _CrtSetDbgFlag(_DbgFlag); \ + } while(0) + +#define VALID_HEAP_STR \ + __FILE__##"("##RW_STRINGIFY_EXPANDED(__LINE__)##"): valid heap\n" + +#define RWCRTCHECKMEMORY() \ + do \ + { \ + int valid_heap; \ + \ + valid_heap = _CrtCheckMemory(); \ + _ASSERTE(valid_heap); \ + } while(0) + +/* + * if (valid_heap) \ + * OutputDebugString(VALID_HEAP_STR); \ + */ + +#define NO_LEAKS_FOUND_STR \ + __FILE__##"("##RW_STRINGIFY_EXPANDED(__LINE__)##"): no heap leaks found\n" + +#define RWCRTDUMPMEMORYLEAKS() \ + do \ + { \ + int leaks_found; \ + \ + leaks_found = _CrtDumpMemoryLeaks(); \ + _ASSERTE(!leaks_found); \ + if (!leaks_found) \ + OutputDebugString(NO_LEAKS_FOUND_STR); \ + } while(0) + +#define HEAP_DIFFERENCES_FOUND_STR \ + __FILE__##"("##RW_STRINGIFY_EXPANDED(__LINE__)##"): heap differences found\n" + +#define NO_DIFFERENCES_FOUND_STR \ + __FILE__##"("##RW_STRINGIFY_EXPANDED(__LINE__)##"): no heap differences found\n" + +#define RWCRTHEAPDIFFERENCESINCE(_Then) \ + do \ + { \ + /* only dump differences when \ + * there are in fact differences */ \ + _CrtMemState _Now; \ + _CrtMemState _Delta; \ + const int _DbgFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG); \ + int Differences; \ + \ + _CrtMemCheckpoint(&_Now); \ + _CrtMemDifference(&_Delta, _Then, &_Now); \ + \ + (Differences) = ( ( 0 != _Delta.lCounts[_CLIENT_BLOCK] ) || \ + ( 0 != _Delta.lCounts[_NORMAL_BLOCK] ) || \ + ( (_DbgFlag & _CRTDBG_CHECK_CRT_DF) && \ + ( 0 != _Delta.lCounts[_CRT_BLOCK]) ) ); \ + \ + if ( (Differences) ) \ + { \ + /* difference detected: dump objects since _Then. */ \ + OutputDebugString(HEAP_DIFFERENCES_FOUND_STR); \ + _CrtMemDumpAllObjectsSince(_Then); \ + _CrtMemDumpStatistics(&_Delta); \ + } \ + else \ + { \ + OutputDebugString(NO_DIFFERENCES_FOUND_STR); \ + } \ + } while (0) + +#define RWCRTDBGBREAK() \ + _CrtDbgBreak() + +#define RWCRTDOFORALLCLIENTOBJECTS(_f, _c) \ + _CrtDoForAllClientObjects(_f, _c) + +#define RWCRTISMEMORYBLOCK(_p, _t, _r, _f, _l) \ + _CrtIsMemoryBlock(_p, _t, _r, _f, _l) + +#define RWCRTISVALIDHEAPPOINTER(_p) \ + _CrtIsValidHeapPointer(_p) + +#define RWCRTISVALIDPOINTER(_p, _n, _r) \ + _CrtIsValidPointer(_p, _n, _r) + +#define RWCRTMEMCHECKPOINT(_s) \ + _CrtMemCheckpoint(_s) + +#define RWCRTMEMDIFFERENCE(_s1, _s2, _s3) \ + _CrtMemDifference(_s1, _s2, _s3) + +#define RWCRTMEMDUMPALLOBJECTSSINCE(_s) \ + _CrtMemDumpAllObjectsSince(_s) + +#define RWCRTMEMDUMPSTATISTICS(_s) \ + _CrtMemDumpStatistics(_s) + +#define RWCRTSETALLOCHOOK(_f) \ + _CrtSetAllocHook(_f) + +#define RWCRTSETBREAKALLOC(_a) \ + _CrtSetBreakAlloc(_a) + +#define RWCRTSETDBGFLAG(_f) \ + _CrtSetDbgFlag(_f) + +#define RWCRTSETDUMPCLIENT(_f) \ + _CrtSetDumpClient(_f) + +#define RWCRTSETREPORTFILE(_t, _f) \ + _CrtSetReportFile(_t, _f) + +#define RWCRTSETREPORTHOOK(_f) \ + _CrtSetReportHook(_f) + +#define RWCRTSETREPORTMODE(_t, _f) \ + _CrtSetReportMode(_t, _f) + +#if (!defined(_CRTDBG_FLAGS)) +#define _CRTDBG_FLAGS \ + ( (_CRTDBG_ALLOC_MEM_DF | _CRTDBG_DELAY_FREE_MEM_DF | \ + _CRTDBG_CHECK_CRT_DF | _CRTDBG_LEAK_CHECK_DF) & \ + ~(_CRTDBG_CHECK_ALWAYS_DF |_CRTDBG_RESERVED_DF) ) +#endif /* (!defined(_CRTDBG_FLAGS)) */ + +# endif /* ((_MSC_VER>=1000) && defined(_DEBUG)) */ +# endif /* (defined(_MSC_VER)) */ + + + +#if (!defined(rwDEADPTRFILL)) +#define rwDEADPTRFILL ((void *)0xDDDDDDDD) +#endif /* (!defined(rwDEADPTRFILL)) */ + +#endif /* (defined(RWDEBUG) && (defined(RWMEMDEBUG))) */ + +#if (!defined(rwDEADPTRFILL)) +#define rwDEADPTRFILL (NULL) +#endif /* (!defined(rwDEADPTRFILL)) */ + +#if (!defined(RwMalloc)) +#define RwMalloc(_s) ((RWSRCGLOBAL(memoryFuncs).rwmalloc)((_s))) +#endif /* (!defined(RwMalloc)) */ + +#if (!defined(RwFree)) +#define RwFree(_p) ((RWSRCGLOBAL(memoryFuncs).rwfree)((_p))) +#endif /* (!defined(RwFree)) */ + +#if (!defined(RwCalloc)) +#define RwCalloc(_n, _s) ((RWSRCGLOBAL(memoryFuncs).rwcalloc)((_n), (_s))) +#endif /* (!defined(RwCalloc)) */ + +#if (!defined(RwRealloc)) +#define RwRealloc(_p, _s) ((RWSRCGLOBAL(memoryFuncs).rwrealloc)((_p),(_s))) +#endif /* (!defined(RwRealloc)) */ + +#if (!defined(RWCRTORDBGFLAG)) +#define RWCRTORDBGFLAG(_flag) /* No op */ +#endif /* (!defined(RWCRTORDBGFLAG)) */ + +#if (!defined(RWCRTCHECKMEMORY)) +#define RWCRTCHECKMEMORY() /* No Op */ +#endif /* (!defined(RWCRTCHECKMEMORY)) */ + +#if (!defined(RWCRTDBGBREAK)) +#define RWCRTDBGBREAK() /* No Op */ +#endif /* (!defined(RWCRTDBGBREAK)) */ + +#if (!defined(RWCRTDOFORALLCLIENTOBJECTS)) +#define RWCRTDOFORALLCLIENTOBJECTS(_f, _c) /* No Op */ +#endif /* (!defined(RWCRTDOFORALLCLIENTOBJECTS)) */ + +#if (!defined(RWCRTDUMPMEMORYLEAKS)) +#define RWCRTDUMPMEMORYLEAKS() /* No Op */ +#endif /* (!defined(RWCRTDUMPMEMORYLEAKS)) */ + +#if (!defined(RWCRTHEAPDIFFERENCESINCE)) +#define RWCRTHEAPDIFFERENCESINCE(_Then) /* No Op */ +#endif /* (!defined(RWCRTHEAPDIFFERENCESINCE)) */ + +#if (!defined(RWCRTISMEMORYBLOCK)) +#define RWCRTISMEMORYBLOCK(_p, _t, _r, _f, _l) (NULL != (_p)) +#endif /* (!defined(RWCRTISMEMORYBLOCK)) */ + +#if (!defined(RWCRTISVALIDHEAPPOINTER)) +#define RWCRTISVALIDHEAPPOINTER(_p) (NULL != (_p)) +#endif /* (!defined(RWCRTISVALIDHEAPPOINTER)) */ + +#if (!defined(RWCRTISVALIDPOINTER)) +#define RWCRTISVALIDPOINTER(_p, _n, _r) (NULL != (_p)) +#endif /* (!defined(RWCRTISVALIDPOINTER)) */ + +#if (!defined(RWCRTMEMCHECKPOINT)) +#define RWCRTMEMCHECKPOINT(_s) /* No Op */ +#endif /* (!defined(RWCRTMEMCHECKPOINT)) */ + +#if (!defined(RWCRTMEMDIFFERENCE)) +#define RWCRTMEMDIFFERENCE(_s1, _s2, _s3) /* No Op */ +#endif /* (!defined(RWCRTMEMDIFFERENCE)) */ + +#if (!defined(RWCRTMEMDUMPALLOBJECTSSINCE)) +#define RWCRTMEMDUMPALLOBJECTSSINCE(_s) /* No Op */ +#endif /* (!defined(RWCRTMEMDUMPALLOBJECTSSINCE)) */ + +#if (!defined(RWCRTMEMDUMPSTATISTICS)) +#define RWCRTMEMDUMPSTATISTICS(_s) (NULL) +#endif /* (!defined(RWCRTMEMDUMPSTATISTICS)) */ + +#if (!defined(RWCRTSETALLOCHOOK)) +#define RWCRTSETALLOCHOOK(_f) (NULL) +#endif /* (!defined(RWCRTSETALLOCHOOK)) */ + +#if (!defined(RWCRTSETBREAKALLOC)) +#define RWCRTSETBREAKALLOC(_a) (0) +#endif /* (!defined(RWCRTSETBREAKALLOC)) */ + +#if (!defined(RWCRTSETDBGFLAG)) +#define RWCRTSETDBGFLAG(_f) (0) +#endif /* (!defined(RWCRTSETDBGFLAG)) */ + +#if (!defined(RWCRTSETDUMPCLIENT)) +#define RWCRTSETDUMPCLIENT(_f) (NULL) +#endif /* (!defined(RWCRTSETDUMPCLIENT)) */ + +#if (!defined(RWCRTSETREPORTFILE)) +#define RWCRTSETREPORTFILE(_t, _f) (NULL) +#endif /* (!defined(RWCRTSETREPORTFILE)) */ + +#if (!defined(RWCRTSETREPORTHOOK)) +#define RWCRTSETREPORTHOOK(_f) (NULL) +#endif /* (!defined(RWCRTSETREPORTHOOK)) */ + +#if (!defined(RWCRTSETREPORTMODE)) +#define RWCRTSETREPORTMODE(_t, _f) (0) +#endif /* (!defined(RWCRTSETREPORTMODE)) */ + +#if (!defined(RWREGSETBREAKALLOC)) +#define RWREGSETBREAKALLOC(_name) /* No op */ +#endif /* (!defined(RWREGSETBREAKALLOC)) */ + +#if (!defined(RWREGSETASSERTPRINT)) +#define RWREGSETASSERTPRINT(_name) /* No op */ +#endif /* (!defined(RWREGSETASSERTPRINT)) */ + +#if (!defined(RWGETWINREGDWORD)) +#define RWGETWINREGDWORD(_env_var, _match) /* No op */ +#endif /* (!defined(RWGETWINREGDWORD)) */ + +#if (!defined(RWGETWINREGBINARY)) +#define RWGETWINREGBINARY(_env_var, _match) /* No op */ +#endif /* (!defined(RWGETWINREGBINARY)) */ + +#if (!defined(RWGETWINREGSTRING)) +#define RWGETWINREGSTRING(_env_var, _match) /* No op */ +#endif /* (!defined(RWGETWINREGSTRING)) */ + +#if (!defined(_CRTDBG_FLAGS)) +#define _CRTDBG_FLAGS 0x33 +#endif /* (!defined(_CRTDBG_FLAGS)) */ + +/**************************************************************************** + Global Types + */ + +typedef struct RwMemoryFunctions RwMemoryFunctions; +/** + * \ingroup datatypes + * \struct RwMemoryFunctions + * This type represents the memory functions used + * by RenderWare. By default, the standard ANSI functions are used. The + * application may install an alternative interface providing that it is ANSI + * compliant (see API function \ref RwEngineInit): + */ +struct RwMemoryFunctions +{ + /* c.f. + * Program Files/Microsoft Visual Studio/VC98/Include/MALLOC.H + */ + void *(*rwmalloc)(size_t size); /**< rwmalloc malloc */ + void (*rwfree)(void *mem); /**< rwfree free */ + void *(*rwrealloc)(void *mem, size_t newSize); /**< rwrealloc realloc */ + void *(*rwcalloc)(size_t numObj, size_t sizeObj); /**< calloc calloc */ +}; + +typedef struct RwFreeBlock RwFreeBlock; +/* + * Freelists -- from Page 131 + * Advanced Animation and Rendering Techniques + * Alan Watt and Mark Watt + * Addison-Wesley 1993, + * ISBN 0-201-54412-1: + * + * "Lastly, on a more general note concerning speedups for renderers, the + * implementor should be aware that a lot of suggestions for improving + * efficiency fall into the category of ingenious, but complex, + * algorithms for very specific contexts that may save a few microseconds + * but which make your code unreadable. A more general computer science + * perspective that takes a `global view' of the renderer can be more + * fruitful. For example, the renderer devotes a lot of time to + * allocating and deallocating chunks of memory for storing data. A lot + * of these chunks are always the same size - such as those that are + * continually required to store the data structure for fragment lists. + * Using memory management techniques that recognize this fact can yield + * considerable dividends. One such scheme would be to hold a series of + * empty lists in memory for all the commonly used data structures. An + * empty list for fragments, say, would contain a list of previously + * allocated, but no longer needed, fragment structures. When the + * renderer needs memory for a new fragment, it looks first at this empty + * list. If there is nothing there it allocates space directly, + * otherwise it takes a fragments off the end of the list and uses that. + * Conversely, when the renderer no longer needs a fragment, instead of + * freeing it, it goes onto the end of the empty list. In the authors' + * experience, replacing the naive allocate/deallocate scheme with this + * way of managing memory can result in 100% speedup. " + */ +struct RwFreeBlock +{ + RwFreeBlock *nextBlock; +}; + +typedef struct RwFreeList RwFreeList; +struct RwFreeList +{ + void **freeListStack; /* Stack of unused entries */ + void **freeListStackTop; /* Pointer to the top of the stack */ + + RwFreeBlock *firstBlock; /* Data start */ + + RwInt32 blockSize; /* Size of block in bytes */ + RwInt32 entrySize; /* Entry size */ + RwInt32 alignmentMinusOne; /* Entry alignment minus 1 */ + RwInt32 entriesPerBlock; /* Amount of space in a block */ + + RwInt32 entriesAllocated; /* Total slots allocated + * (but not necessarily being used */ + + /* All freelists */ + RwLLLink lFreeList; + +#if (defined(RWDEBUG) && !defined(DOXYGEN)) + const RwChar *fileCreate; + RwUInt32 lineCreate; +#endif /* (defined(RWDEBUG) && !defined(DOXYGEN)) */ +}; + +/** + * \ingroup datatypes + * \ref RwFreeListCallBack represents + * the function called from \ref RwFreeListForAllUsed for all used entries in a + * given free list. + * + * \param pMem Pointer to the start of the current entries. + * + * \param pData User-defined data pointer. + * + * \see RwFreeListForAllUsed + * + */ +typedef void (*RwFreeListCallBack) (void *pMem, void *pData); +typedef void *(*RwMemoryAllocFn) (RwFreeList * fl); +typedef RwFreeList *(*RwMemoryFreeFn) (RwFreeList * fl, void *pData); + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RwMemoryFunctions *RwOsGetMemoryInterface(void); + +/************* + * FREELISTS * + *************/ + +/* Allocation and freeing */ +#if (defined(RWDEBUG) && !defined(DOXYGEN)) + +extern RwFreeList *_rwFreeListCreate(RwInt32 entrySize, + RwInt32 entriesPerBlock, + RwInt32 alignment, + const RwChar *fileCreate, + RwUInt32 lineCreate ); + +#define RwFreeListCreate(entrySize, entriesPerBlock, alignment) \ + _rwFreeListCreate(entrySize, \ + entriesPerBlock, \ + alignment, \ + __FILE__, \ + __LINE__) +#else /* (defined(RWDEBUG) && !defined(DOXYGEN)) */ + +extern RwFreeList *RwFreeListCreate(RwInt32 entrySize, + RwInt32 entriesPerBlock, + RwInt32 alignment); +#endif /* (defined(RWDEBUG) && !defined(DOXYGEN)) */ + +extern RwBool RwFreeListDestroy(RwFreeList * freelist); +/* Garbage collection/enumeration */ +extern RwInt32 RwFreeListPurge(RwFreeList * freelist); +extern RwFreeList *RwFreeListForAllUsed(RwFreeList * freelist, + RwFreeListCallBack + fpCallBack, void *pData); +extern RwInt32 RwFreeListPurgeAllFreeLists(void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#if (defined(RWDEBUG) && defined(RWNOFREELISTS) && !defined(RWKEEPFREELISTS)) + +#if ((defined(__MWERKS__) || defined(__GNUC__)) && defined(__R5900__)) + +/* + * for more on memalign, see + * http://www.gnu.org/manual/glibc-2.0.6/html_chapter/libc_3.html#SEC28 + */ +#include <rtdbmalloc.h> + +#define RwFreeListAlloc(_f) \ + memalign((1 + (_f)->alignmentMinusOne), (_f)->entrySize) + +#else /* ((defined(__MWERKS__) || defined(__GNUC__)) && defined(__R5900__)) */ + +#define RwFreeListAlloc(_f) \ + RwMalloc((_f)->entrySize) + +#endif /* ((defined(__MWERKS__) || defined(__GNUC__)) && defined(__R5900__)) */ + +#define RwFreeListFree(_f, _p) \ + RwFree((_p)) + +#endif /* (defined(RWDEBUG) && defined(RWNOFREELISTS) && !defined(RWKEEPFREELISTS)) */ + +#if (!defined(RwFreeListAlloc)) +#define RwFreeListAlloc(_f) \ + RWSRCGLOBAL(memoryAlloc)(_f) +#endif /* (!defined(RwFreeListAlloc)) */ + +#if (!defined(RwFreeListFree)) +#define RwFreeListFree(_f, _p) \ + RWSRCGLOBAL(memoryFree)(_f, _p) +#endif /* (!defined(RwFreeListFree)) */ + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/bastream.h ---*/ + +/**************************************************************************** + Defines + */ + +#define rwSTREAMSTACKSIZE 512 + +/**************************************************************************** + Global Types + */ + +/** + * \ingroup datatypes + * \ref RwStreamType + * This type represents the different types of stream that + * can be used. + * See API section \ref rwstream + */ +enum RwStreamType +{ + rwNASTREAM = 0, /**<Invalid stream type */ + rwSTREAMFILE, /**<File */ + rwSTREAMFILENAME, /**<File name */ + rwSTREAMMEMORY, /**<Memory*/ + rwSTREAMCUSTOM, /**<Custom */ + rwSTREAMTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwStreamType RwStreamType; + +/** + * \ingroup datatypes + * \ref RwStreamAccessType + * This type represents the options available for + * accessing a stream when it is opened. + * See API section \ref rwstream */ +enum RwStreamAccessType +{ + rwNASTREAMACCESS = 0, /**<Invalid stream access */ + rwSTREAMREAD, /**<Read */ + rwSTREAMWRITE, /**<Write */ + rwSTREAMAPPEND, /**<Append */ + rwSTREAMACCESSTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwStreamAccessType RwStreamAccessType; + +/* Memory stream */ +/** + * \ingroup datatypes + * \typedef RwStreamMemory + * This should be considered an opaque type. + * Use the RwStream API functions to access. + */ +typedef struct RwStreamMemory RwStreamMemory; +#if (!defined(DOXYGEN)) +struct RwStreamMemory +{ + RwUInt32 position; /* Current 'memory' position 0 is first byte */ + RwUInt32 nSize; /* Space allocated currently */ + RwUInt8 *memBlock; /* Current memory block pointer */ +}; +#endif /* (!defined(DOXYGEN)) */ + + +typedef union RwStreamFile RwStreamFile; +/** + * \ingroup datatypes + * \union RwStreamFile + * This type is used to represent a file pointer for + * accessing data on disk through the stream mechanism. + * See API section \ref rwstream. */ +union RwStreamFile +{ + void *fpFile; /**< file pointer */ + const void *constfpFile; /**< const file pointer */ +}; + + +/* Custom stream function pointer types */ +typedef RwBool(*rwCustomStreamFnClose) (void *data); +typedef RwUInt32(*rwCustomStreamFnRead) (void *data, void *buffer, + RwUInt32 length); +typedef RwBool(*rwCustomStreamFnWrite) (void *data, + const void *buffer, + + RwUInt32 length); +typedef RwBool(*rwCustomStreamFnSkip) (void *data, + + RwUInt32 offset); + +/* Custom stream */ +/** + * \ingroup datatypes + * \typedef RwStreamCustom + * This should be considered an opaque type. + * Use the RwStream API functions to access. + */ +typedef struct RwStreamCustom RwStreamCustom; +#if (!defined(DOXYGEN)) +struct RwStreamCustom +{ + rwCustomStreamFnClose sfnclose; + rwCustomStreamFnRead sfnread; + rwCustomStreamFnWrite sfnwrite; + rwCustomStreamFnSkip sfnskip; + void *data; +}; +#endif /* (!defined(DOXYGEN)) */ + +/* Stream */ + +typedef union RwStreamUnion RwStreamUnion; +/** + * \ingroup datatypes + * \union RwStreamUnion + * The union of all supported stream types + */ +union RwStreamUnion +{ + RwStreamMemory memory; /**< memory */ + RwStreamFile file; /**< file */ + RwStreamCustom custom; /**< custom */ +}; + +/** + * \ingroup datatypes + * \typedef RwStream + * Binary stream for reading or writing object data. + * This should be considered an opaque type. + * Use the RwStream API functions to access. + */ +typedef struct RwStream RwStream; +#if (!defined(DOXYGEN)) +struct RwStream +{ + RwStreamType type; + RwStreamAccessType accessType; + RwInt32 position; + RwStreamUnion Type; + RwBool rwOwned; +}; +#endif /* (!defined(DOXYGEN)) */ + + +typedef struct RwMemory RwMemory; +/** + * \ingroup datatypes + * \struct RwMemory + * This type represents a block of allocated memory. + * It is used to specify an area of memory connected to a stream of type + * rwSTREAMMEMORY. + * See \ref rwstream */ +struct RwMemory +{ + RwUInt8 *start; /**< starting address */ + RwUInt32 length; /**< length in bytes*/ +}; + + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* Open/Close streams */ + +extern RwStream * +_rwStreamInitialize(RwStream *stream, + RwBool rwOwned, + RwStreamType type, + RwStreamAccessType accessType, + const void *pData); + +extern RwStream * +RwStreamOpen(RwStreamType type, + RwStreamAccessType accessType, + const void *pData); + +extern RwBool +RwStreamClose(RwStream * stream, + void *pData); + + +/* Stream read/write */ +extern RwUInt32 +RwStreamRead(RwStream * stream, + void *buffer, + RwUInt32 length); + +extern RwStream * +RwStreamWrite(RwStream * stream, + const void *buffer, + RwUInt32 length); + + +/* Stream skipping */ +extern RwStream * +RwStreamSkip(RwStream * stream, + RwUInt32 offset); + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/batkreg.h ---*/ + +/**************************************************************************** + Global Types + */ + +/** + * \ingroup datatypes + * \ref RwPluginDataChunkWriteCallBack represents the function + * registered by \ref RwCameraRegisterPluginStream, etc. as the function that + * writes extension data to a binary stream. + * + * \param stream Pointer to the binary stream + * + * \param binaryLength A RwInt32 value equal to the binary + * size (in bytes) of the extension data that will be written to the binary + * stream. + * + * \param object Pointer to the object containing the extension + * data. + * + * \param offsetInObject A RwInt32 value equal to the byte + * offset of the extension data in the object. + * + * \param sizeInObject A RwInt32 value equal to the size + * (in bytes) of the extension data. + * + * \return Pointer to the stream + */ +typedef RwStream *(*RwPluginDataChunkWriteCallBack)(RwStream *stream, RwInt32 binaryLength, const void *object, RwInt32 offsetInObject, RwInt32 sizeInObject); + +/** + * \ingroup datatypes + * \ref RwPluginDataChunkReadCallBack represents the function + * registered by \ref RwCameraRegisterPluginStream, etc. as the function that + * reads extension data from a binary stream. + * + * \param stream Pointer to the binary stream + * + * \param binaryLength A RwInt32 value equal to the binary + * size (in bytes) of the extension data that will be read from a binary + * stream. + * + * \param object Pointer to the object containing the extension + * data. + * + * \param offsetInObject A RwInt32 value equal to the byte + * offset of the extension data in the object. + * + * \param sizeInObject A RwInt32 value equal to the size + * (in bytes) of the extension data. + * + * \return Pointer to the stream + */ +typedef RwStream *(*RwPluginDataChunkReadCallBack)(RwStream *stream, RwInt32 binaryLength, void *object, RwInt32 offsetInObject, RwInt32 sizeInObject); + +/** + * \ingroup datatypes + * \ref RwPluginDataChunkGetSizeCallBack represents the callback + * registered by \ref RwCameraRegisterPluginStream, etc. as the function that + * determines the binary size of the extension data. + * + * \param object Pointer to the object containing the extension data. + * + * \param offsetInObject A RwInt32 value equal to the byte + * offset of the extension data in the object. + * + * \param sizeInObject A RwInt32 value equal to the size + * (in bytes) of the extension data. + * + * \return A RwInt32 value equal to the size in bytes of the plugin extension data. + */ +typedef RwInt32(*RwPluginDataChunkGetSizeCallBack)(const void *object, RwInt32 offsetInObject, RwInt32 sizeInObject); + +/** + * \ingroup datatypes + * \ref RwPluginDataChunkAlwaysCallBack represents the callback + * registered by \ref RwCameraSetStreamAlwaysCallBack, etc. as the + * function that is called after the reading of plugin stream data is + * finished (useful to set up plugin data for plugins that found no + * data in the stream, but that cannot set up the data during the + * \ref RwPluginObjectConstructor callback). + * + * \param object Pointer to the object containing the extension data. + * + * \param offsetInObject A RwInt32 value equal to the byte + * offset of the extension data in the object. + * + * \param sizeInObject A RwInt32 value equal to the size + * (in bytes) of the extension data. + */ +typedef RwBool(*RwPluginDataChunkAlwaysCallBack)(void *object, RwInt32 offsetInObject, RwInt32 sizeInObject); + +/** + * \ingroup datatypes + * \ref RwPluginDataChunkRightsCallBack represents the callback + * registered by RwCameraSetStreamRightsCallBack, etc. as the + * function that is called after the reading of plugin stream data is + * finished, and the object finalised, if and only if the object's rights + * id was equal to that of the plugin registering the call. + * For convience the extension data is passed to the callback. + * + * \param object Pointer to the object containing the extension data. + * + * \param offsetInObject A RwInt32 value equal to the byte + * offset of the extension data in the object. + * + * \param sizeInObject A RwInt32 value equal to the size + * (in bytes) of the extension data. + * + * \param extraData An RwUInt32 writen with the plugin id. + */ +typedef RwBool(*RwPluginDataChunkRightsCallBack)(void *object, RwInt32 offsetInObject, RwInt32 sizeInObject, RwUInt32 extraData); + +/** + * \ingroup datatypes + * \ref RwPluginObjectConstructor represents the callback + * registered by \ref RwEngineRegisterPlugin, \ref RwCameraRegisterPlugin, etc. + * as the function that initializes either the global extension data (in the + * case of \ref RwEngineRegisterPlugin) or the object extension data (in all + * other cases). Registered by \ref RwCameraSetStreamAlwaysCallBack, etc. + * + * \param object Pointer to the object (global or otherwise) + * that contains the extension data. + * + * \param offsetInObject A RwInt32 value equal to the + * byte offset of the extension data in the object. + * + * \param sizeInObject A RwInt32 value equal to the size + * (in bytes) of the extension data. + * + * \return Pointer to the object + */ +typedef void *(*RwPluginObjectConstructor)(void *object, RwInt32 offsetInObject, RwInt32 sizeInObject); + +/** + * \ingroup datatypes + * \ref RwPluginObjectCopy represents the callback registered by + * \ref RwCameraRegisterPlugin, etc. as the function that copies the object + * extension data when an object is duplicated. + * + * \param dstObject Pointer to the destination object that will + * receive the extension data. + * + * \param srcObject Pointer to the source object containing + * extension data. + * + * \param offsetInObject A RwInt32 value equal to the byte offset + * of the extension data in the object. + * + * \param sizeInObject A RwInt32 value equal to the size + * (in bytes) of the extension data. + * + * \return Pointer to the object + */ +typedef void *(*RwPluginObjectCopy)(void *dstObject, const void *srcObject, RwInt32 offsetInObject, RwInt32 sizeInObject); + +/** + * \ingroup datatypes + * \ref RwPluginObjectDestructor represents the callback registered + * by \ref RwEngineRegisterPlugin, \ref RwCameraRegisterPlugin, etc. as the + * function that destroys either the global extension data (in the case of + * \ref RwEngineRegisterPlugin) or the object extension data (in all other + * cases). + * + * \param object Pointer to the object (global or otherwise) + * containing the extension data. + * + * \param offsetInObject A RwInt32 value equal to the byte + * offset of the extension data in the object. + * + * \param sizeInObject A RwInt32 value equal to the size + * (in bytes) of the extension data. + * + * \return Pointer to the object. + */ +typedef void *(*RwPluginObjectDestructor)(void *object, RwInt32 offsetInObject, RwInt32 sizeInObject); + +typedef void *(*RwPluginErrorStrCallBack)(void *); + +typedef struct RwPluginRegistry RwPluginRegistry; +typedef struct RwPluginRegEntry RwPluginRegEntry; + +struct RwPluginRegistry +{ + RwInt32 sizeOfStruct; + RwInt32 origSizeOfStruct; + RwInt32 maxSizeOfStruct; + RwInt32 staticAlloc; + RwPluginRegEntry *firstRegEntry; + RwPluginRegEntry *lastRegEntry; +}; + +struct RwPluginRegEntry +{ + RwInt32 offset; + RwInt32 size; + RwUInt32 pluginID; + RwPluginDataChunkReadCallBack readCB; + RwPluginDataChunkWriteCallBack writeCB; + RwPluginDataChunkGetSizeCallBack getSizeCB; + RwPluginDataChunkAlwaysCallBack alwaysCB; + RwPluginDataChunkRightsCallBack rightsCB; + RwPluginObjectConstructor constructCB; + RwPluginObjectDestructor destructCB; + RwPluginObjectCopy copyCB; + RwPluginErrorStrCallBack errStrCB; + RwPluginRegEntry *nextRegEntry; + RwPluginRegEntry *prevRegEntry; + RwPluginRegistry *parentRegistry; +}; + + + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + + +/* Registering toolkits and allocating memory */ +extern RwBool +_rwPluginRegistrySetStaticPluginsSize(RwPluginRegistry * reg, + RwInt32 size); +extern RwInt32 +_rwPluginRegistryAddPlugin(RwPluginRegistry * reg, + RwInt32 size, + RwUInt32 pluginID, + RwPluginObjectConstructor constructCB, + RwPluginObjectDestructor destructCB, + RwPluginObjectCopy copyCB); +extern RwInt32 +_rwPluginRegistryGetPluginOffset(const RwPluginRegistry *reg, + RwUInt32 pluginID); + +/* Initializing/De-initializing instances */ +extern const +RwPluginRegistry *_rwPluginRegistryInitObject(const RwPluginRegistry * reg, + void *object); +extern const +RwPluginRegistry *_rwPluginRegistryDeInitObject(const RwPluginRegistry * reg, + void *object); +extern const +RwPluginRegistry *_rwPluginRegistryCopyObject(const RwPluginRegistry * reg, + void *dstObject, + const void *srcObject); + +#ifdef RWDEBUG +extern RwBool +_rwPluginRegistryValidateObject(const RwPluginRegistry * reg, + const void *object); +#endif /* RWDEBUG */ + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +/* Compatibility macros */ + +#define rwPluginRegistryOpen() \ + _rwPluginRegistryOpen() +#define rwPluginRegistryClose() \ + _rwPluginRegistryClose() +#define rwPluginRegistrySetStaticPluginsSize(reg, size) \ + _rwPluginRegistrySetStaticPluginsSize(reg, size) +#define rwPluginRegistryAddPlugin(reg, size, pluginID, constructCB, destructCB, copyCB) \ + _rwPluginRegistryAddPlugin(reg, size, pluginID, constructCB, destructCB, copyCB) +#define rwPluginRegistryGetPluginOffset(reg, pluginID) \ + _rwPluginRegistryGetPluginOffset(reg, pluginID) +#define rwPluginRegistryInitObject(reg, object) \ + _rwPluginRegistryInitObject(reg, object) +#define rwPluginRegistryDeInitObject(reg, object) \ + _rwPluginRegistryDeInitObject(reg, object) +#define rwPluginRegistryCopyObject(reg, dstObject, srcObject) \ + _rwPluginRegistryCopyObject(reg, dstObject, srcObject) +#define rwPluginRegistryValidateObject(reg, object) \ + _rwPluginRegistryValidateObject(reg, object) + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/batkbin.h ---*/ + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* Plugin binary stream stuff */ +extern RwInt32 _rwPluginRegistryAddPluginStream( + RwPluginRegistry *reg, + RwUInt32 pluginID, + RwPluginDataChunkReadCallBack readCB, + RwPluginDataChunkWriteCallBack writeCB, + RwPluginDataChunkGetSizeCallBack getSizeCB); +extern RwInt32 _rwPluginRegistryAddPlgnStrmlwysCB( + RwPluginRegistry *reg, + RwUInt32 pluginID, + RwPluginDataChunkAlwaysCallBack alwaysCB); +extern RwInt32 _rwPluginRegistryAddPlgnStrmRightsCB( + RwPluginRegistry *reg, + RwUInt32 pluginID, + RwPluginDataChunkRightsCallBack rightsCB); +extern const RwPluginRegistry *_rwPluginRegistryReadDataChunks(const RwPluginRegistry *reg, + RwStream *stream, + void *object); +extern const RwPluginRegistry *_rwPluginRegistryWriteDataChunks(const RwPluginRegistry *reg, + RwStream *stream, + const void *object); +extern const RwPluginRegistry *_rwPluginRegistrySkipDataChunks(const RwPluginRegistry * reg, + RwStream * stream); +extern RwInt32 _rwPluginRegistryGetSize(const RwPluginRegistry *reg, const void *object); +extern const RwPluginRegistry *_rwPluginRegistryInvokeRights(const RwPluginRegistry *reg, + RwUInt32 id, + void *obj, + RwUInt32 extraData); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +/* Compatibility macros */ + +#define rwPluginRegistryAddPluginStream(reg, pluginID, readCB, writeCB, getSizeCB) \ + _rwPluginRegistryAddPluginStream(reg, pluginID, readCB, writeCB, getSizeCB) +#define rwPluginRegistryAddPluginStreamAlwaysCB(reg, pluginID, alwaysCB) \ + _rwPluginRegistryAddPlgnStrmlwysCB(reg, pluginID, alwaysCB) +#define rwPluginRegistryReadDataChunks(reg, stream, object) \ + _rwPluginRegistryReadDataChunks(reg, stream, object) +#define rwPluginRegistryWriteDataChunks(reg, stream, object) \ + _rwPluginRegistryWriteDataChunks(reg, stream, object) +#define rwPluginRegistrySkipDataChunks(reg, stream) \ + _rwPluginRegistrySkipDataChunks(reg, stream) +#define rwPluginRegistryGetSize(reg, object) \ + _rwPluginRegistryGetSize(reg, object) + + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/bamatrix.h ---*/ + +/**************************************************************************** + Defines + */ + +#define RWMATRIXALIGNMENT(_mat) \ + (! (((rwMATRIXALIGNMENT)-1) & ((RwUInt32)(_mat)))) + +#if (defined(RWMATRIXMONITOR)) +# if (defined(_MSC_VER)) +# if ((_MSC_VER>=1000) && defined(_DEBUG)) + +typedef char MatrixString[1024]; + +#define RWMATRIXPRINT(_matrix) \ +MACRO_START \ +{ \ + MatrixString message; \ + MatrixString output; \ + \ + if (NULL != (_matrix)) \ + { \ + const RwV3d * const _x = &(_matrix)->right; \ + const RwV3d * const _y = &(_matrix)->up; \ + const RwV3d * const _z = &(_matrix)->at; \ + const RwV3d * const _w = &(_matrix)->pos; \ + \ + _snprintf(message, sizeof(MatrixString), \ + "[ [ %8.4f, %8.4f, %8.4f, %8.4f ]\n" \ + " [ %8.4f, %8.4f, %8.4f, %8.4f ]\n" \ + " [ %8.4f, %8.4f, %8.4f, %8.4f ]\n" \ + " [ %8.4f, %8.4f, %8.4f, %8.4f ] ]\n" \ + " %08x == flags\n", \ + _x->x, _x->y, _x->z, (RwReal) 0, \ + _y->x, _y->y, _y->z, (RwReal) 0, \ + _z->x, _z->y, _z->z, (RwReal) 0, \ + _w->x, _w->y, _w->z, (RwReal) 1, \ + (_matrix)->flags); \ + } \ + else \ + { \ + _snprintf(message, sizeof(MatrixString), \ + "NULL"); \ + } \ + \ + _snprintf(output, sizeof(MatrixString), \ + "%s(%d): %s [%p] ==\n%s\n", \ + __FILE__, __LINE__, \ + #_matrix, _matrix, message); \ + \ + OutputDebugString(RWSTRING(output)); \ +} \ +MACRO_STOP + +# endif /* ((_MSC_VER>=1000) && defined(_DEBUG)) */ +# endif /* (defined(_MSC_VER)) */ +#endif /* (defined(RWMATRIXMONITOR)) */ + +#if (!(defined(RWMATRIXPRINT))) +#define RWMATRIXPRINT(_matrix) /* No op */ +#endif /* (!(defined(RWMATRIXPRINT))) */ + +/** + * \ingroup datatypes + * enum RwOpCombineType + * This type represents a combination operator which + * can be applied to frames and matrices. + * The operator determines the order + * in which one object is combined with another + */ +enum RwOpCombineType +{ + rwCOMBINEREPLACE = 0, /**<Replace - + all previous transformations are lost */ + rwCOMBINEPRECONCAT, /**<Pre-concatenation - + the given transformation is applied + before all others */ + rwCOMBINEPOSTCONCAT, /**<Post-concatenation - + the given transformation is applied + after all others */ + rwOPCOMBINETYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; + +/** + * \ingroup datatypes + * \typedef RwOpCombineType typedef for enum RwOpCombineType + */ +typedef enum RwOpCombineType RwOpCombineType; + +/* External flags (bits 0-15) */ + +/* Internal flags (bits 16-31) */ +enum RwMatrixType +{ + rwMATRIXTYPENORMAL = 0x00000001, + rwMATRIXTYPEORTHOGANAL = 0x00000002, + rwMATRIXTYPEORTHONORMAL = 0x00000003, + rwMATRIXTYPEMASK = 0x00000003, + rwMATRIXTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwMatrixType RwMatrixType; + +enum RwMatrixFlag +{ + rwMATRIXINTERNALIDENTITY = 0x00020000, + rwMATRIXFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwMatrixFlag RwMatrixFlag; + +/* Flags describing what will optimize for */ +enum RwMatrixOptimizations +{ + rwMATRIXOPTIMIZE_IDENTITY = 0x00020000, + rwMATRIXOPTIMIZATIONSFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwMatrixOptimizations RwMatrixOptimizations; + +/**************************************************************************** + Global Types + */ + +#if (!defined(DOXYGEN)) +struct RwMatrixTag +{ + /* These are padded to be 16 byte quantities per line */ + RwV3d right; + RwUInt32 flags; + RwV3d up; + RwUInt32 pad1; + RwV3d at; + RwUInt32 pad2; + RwV3d pos; + RwUInt32 pad3; +}; + +/* + * RwMatrix & RwMatrixTag must be different otherwise the alignment + * directive is ignored when compiling under C++ on Visual C + */ +typedef struct RwMatrixTag RWALIGN(RwMatrix, rwMATRIXALIGNMENT); + +#else + +/* + * RwMatrix must appear as the struct name & the typedef, + * otherwise Doxygen puts RwMatrixTag in the API ref instead of RwMatrix! + */ + +/** + * \ingroup datatypes + * \typedef RwMatrix + * Matrix to define transformations. + * This should be considered an opaque type. + * Use the RwMatrix API functions to access. + */ +typedef struct RwMatrix RWALIGN(RwMatrix, rwMATRIXALIGNMENT); +#endif /* (!defined(DOXYGEN)) */ + +#if (!defined(RwMatrixCopyMacro)) +#define RwMatrixCopyMacro(_target, _source) \ + ( *(_target) = *(_source) ) +#endif /* (!defined(RwMatrixCopyMacro)) */ + +#if (!defined(RwMatrixSetIdentityMacro)) +#define RwMatrixSetIdentityMacro(m) \ +MACRO_START \ +{ \ + (m)->right.x = (m)->up.y = (m)->at.z = (RwReal)((1.0)); \ + (m)->right.y = (m)->right.z = (m)->up.x = (RwReal)((0.0)); \ + (m)->up.z = (m)->at.x = (m)->at.y = (RwReal)((0.0)); \ + (m)->pos.x = (m)->pos.y = (m)->pos.z = (RwReal)((0.0)); \ + rwMatrixSetFlags((m), \ + rwMatrixGetFlags(m) | \ + (rwMATRIXINTERNALIDENTITY | \ + rwMATRIXTYPEORTHONORMAL)); \ +} \ +MACRO_STOP +#endif /* (!defined(RwMatrixSetIdentityMacro)) */ + +typedef void (RWASMCALL * rwMatrixMultFn) (RwMatrix * dstMat, + const RwMatrix * matA, + const RwMatrix * matB); + +/* + * \ingroup datatypes + * \typedef RwMatrixTolerance + * Typedef for RwMatrixTolerance structure + */ +typedef struct RwMatrixTolerance RwMatrixTolerance; + +/* + * \ingroup datatypes + * \struct RwMatrixTolerance + * Holds tolerances for matrix optimizations with \ref RwMatrixOptimize + */ +struct RwMatrixTolerance +{ + RwReal Normal; + /**< Tolerance within which matrix is deemed to be normal */ + RwReal Orthogonal; + /**< Tolerance within which matrix is deemed to be orthogonal */ + RwReal Identity; + /**< Tolerance within which matrix is deemed to be identity */ +}; + + +/**************************************************************************** + Function prototypes + */ + +/* Matrix operations */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RwBool +RwEngineGetMatrixTolerances(RwMatrixTolerance * const tolerance); + +extern RwBool +RwEngineSetMatrixTolerances(const RwMatrixTolerance * const tolerance); + +/* Update */ +#define rwMatrixSetFlags(m, flagsbit) ((m)->flags = (flagsbit)) +#define rwMatrixGetFlags(m) ((m)->flags) +#define rwMatrixTestFlags(m, flagsbit) ((m)->flags & (RwInt32)(flagsbit)) + +/* Creation/destruction */ +extern RwBool +RwMatrixDestroy(RwMatrix * mpMat); + +extern RwMatrix * +RwMatrixCreate(void); + +#ifdef RWDEBUG + +/* Functions for debug */ +extern void +RwMatrixCopy(RwMatrix * dstMatrix, const RwMatrix * srcMatrix); + +extern void +RwMatrixSetIdentity(RwMatrix * matrix); + +#else /* RWDEBUG */ + +#define RwMatrixCopy(dst, src) RwMatrixCopyMacro(dst, src) +#define RwMatrixSetIdentity(m) RwMatrixSetIdentityMacro(m) + +#endif /* RWDEBUG */ + +/* Matrix multiply */ +extern RwMatrix * +RwMatrixMultiply(RwMatrix * matrixOut, + const RwMatrix * MatrixIn1, + const RwMatrix * matrixIn2); + +extern RwMatrix * +RwMatrixTransform(RwMatrix * matrix, + const RwMatrix * transform, + RwOpCombineType combineOp); + +/* Normalise */ +extern RwMatrix * +RwMatrixOrthoNormalize(RwMatrix * matrixOut, + const RwMatrix * matrixIn); + +/* Inversion */ +extern RwMatrix * +RwMatrixInvert(RwMatrix * matrixOut, + const RwMatrix * matrixIn); + +/* Unary matrix operations */ +extern RwMatrix * +RwMatrixScale(RwMatrix * matrix, + const RwV3d * scale, + RwOpCombineType combineOp); + +extern RwMatrix * +RwMatrixTranslate(RwMatrix * matrix, + const RwV3d * translation, + RwOpCombineType combineOp); + +extern RwMatrix * +RwMatrixRotate(RwMatrix * matrix, + const RwV3d * axis, + RwReal angle, + RwOpCombineType combineOp); + +extern RwMatrix * +RwMatrixRotateOneMinusCosineSine(RwMatrix * matrix, + const RwV3d * unitAxis, + RwReal oneMinusCosine, + RwReal sine, + RwOpCombineType combineOp); + +/* Query what the matrix is */ +extern const RwMatrix *RwMatrixQueryRotate(const RwMatrix * matrix, + RwV3d * unitAxis, + RwReal * angle, + RwV3d * center); + +/* Get components */ +#ifndef RWDEBUG + +#define RwMatrixGetRight(m) (&(m)->right) +#define RwMatrixGetUp(m) (&(m)->up) +#define RwMatrixGetAt(m) (&(m)->at) +#define RwMatrixGetPos(m) (&(m)->pos) + +#else /* RWDEBUG */ + +extern RwV3d * +RwMatrixGetRight(RwMatrix * matrix); + +extern RwV3d * +RwMatrixGetUp(RwMatrix * matrix); + +extern RwV3d * +RwMatrixGetAt(RwMatrix * matrix); + +extern RwV3d * +RwMatrixGetPos(RwMatrix * matrix); + +#endif /* RWDEBUG */ + +/* Update the internal matrix state wrt its elements */ +extern RwMatrix * +RwMatrixUpdate(RwMatrix * matrix); + +/* Update the internal matrix flags wrt its elements */ +extern RwMatrix * +RwMatrixOptimize(RwMatrix * matrix, + const RwMatrixTolerance * + tolerance); + +extern RwReal +_rwMatrixDeterminant(const RwMatrix * matrix); + +extern RwReal +_rwMatrixNormalError(const RwMatrix * matrix); + +extern RwReal +_rwMatrixOrthogonalError(const RwMatrix * matrix); + +extern RwReal +_rwMatrixIdentityError(const RwMatrix * matrix); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +/* Compatibility macros */ + +#define rwMatrixSetOptimizations(optimizeFlags) \ + _rwMatrixSetOptimizations(optimizeFlags) + +#define rwMatrixSetMultFn(multMat) \ + _rwMatrixSetMultFn(multMat) + +#define rwMatrixOpen(instance, offset, size) \ + _rwMatrixOpen(instance, offset, size) + +#define rwMatrixClose(instance, offset, size) \ + _rwMatrixClose(instance, offset, size) + +/* Initialisation/deinitialisation */ +#define rwMatrixInitialize(m, t) \ +MACRO_START \ +{ \ + rwMatrixSetFlags((m), (t)); \ +} \ +MACRO_STOP + +#define rwMatrixIsNormal(_matrix, _epsilon) \ + ( (_epsilon) >= _rwMatrixNormalError(_matrix) ) + +#define rwMatrixIsOrthogonal(_matrix, _epsilon) \ + ( (_epsilon) >= _rwMatrixOrthogonalError(_matrix) ) + +#define rwMatrixIsOrthonormal(_matrix, _epsilon) \ + ( rwMatrixIsNormal(_matrix, _epsilon) && \ + rwMatrixIsOrthogonal(_matrix, _epsilon) ) + +#define rwMatrixIsOrthonormalPositive(_matrix, _epsilon) \ + ( rwMatrixIsOrthonormal(_matrix, _epsilon) && \ +( (((RwReal)1) - (_epsilon)) <= _rwMatrixDeterminant(_matrix) ) ) + +#define rwMatrixIsIdentity(_matrix, _epsilon) \ + ( (_epsilon) >= _rwMatrixIdentityError(_matrix) ) + +#define rwMatrixValidFlags(_matrix, _epsilon) \ + ( (_matrix) && /* valid pointer */ \ + ( ( !( rwMatrixGetFlags(_matrix) & /* not flagged as identity */ \ + rwMATRIXINTERNALIDENTITY) ) || /* .. or actually is */ \ + rwMatrixIsIdentity(_matrix, _epsilon)) && \ + ( ( !( rwMatrixGetFlags(_matrix) & /* not flagged as normal */ \ + rwMATRIXTYPENORMAL) ) || /* ... or actually is */ \ + rwMatrixIsNormal(_matrix, _epsilon)) && \ + ( ( !( rwMatrixGetFlags(_matrix) & /* not flagged as orthogonal */ \ + rwMATRIXTYPEORTHOGANAL) ) || /* ... or actually is */ \ + rwMatrixIsOrthogonal(_matrix, _epsilon)) ) + +#define rwMat01Det(_mAA) \ + ( (_mAA) ) + +#define rwMat02Det(_mAA, _mAB, \ + _mBA, _mBB) \ + ( (_mAA) * rwMat01Det(_mBB) \ + - (_mAB) * rwMat01Det(_mBA) \ + ) + +#define rwMat03Det(_mAA, _mAB, _mAC, \ + _mBA, _mBB, _mBC, \ + _mCA, _mCB, _mCC) \ + ( (_mAA) * rwMat02Det(_mBB, _mBC, \ + _mCB, _mCC) \ + - (_mAB) * rwMat02Det(_mBA, _mBC, \ + _mCA, _mCC) \ + + (_mAC) * rwMat02Det(_mBA, _mBB, \ + _mCA, _mCB) \ + ) + +#define rwMat04Det(_mAA, _mAB, _mAC, _mAD, \ + _mBA, _mBB, _mBC, _mBD, \ + _mCA, _mCB, _mCC, _mCD, \ + _mDA, _mDB, _mDC, _mDD) \ + ( (_mAA) * rwMat03Det(_mBB, _mBC, _mBD, \ + _mCB, _mCC, _mCD, \ + _mDB, _mDC, _mDD) \ + - (_mAB) * rwMat03Det(_mBA, _mBC, _mBD, \ + _mCA, _mCC, _mCD, \ + _mDA, _mDC, _mDD) \ + + (_mAC) * rwMat03Det(_mBA, _mBB, _mBD, \ + _mCA, _mCB, _mCD, \ + _mDA, _mDB, _mDD) \ + - (_mAD) * rwMat03Det(_mBA, _mBB, _mBC, \ + _mCA, _mCB, _mCC, \ + _mDA, _mDB, _mDC) \ + ) + + +#define rwMat02Inv(_rAA, _rAB, \ + _rBA, _rBB) \ + _mAA, _mAB, \ + _mBA, _mBB) \ +MACRO_START \ +{ \ + RwSplitBits determinant; \ + \ + (_rAA) = rwMat01Det(_mBB); \ + (_rAB) = -rwMat01Det(_mAB); \ + \ + determinant.nReal = ( (_rAA) * (_mAA) + \ + (_rAB) * (_mBA) ); \ + \ + \ + { \ + const RwReal normalize = ( (determinant.nInt != 0)? \ + (((RwReal)1)/determinant.nReal): \ + ((RwReal)1) ); \ + \ + (_rAA) *= normalize; \ + (_rAB) *= normalize; \ + \ + (_rBA) = -rwMat01Det(_mBA) * normalize; \ + (_rBB) = rwMat01Det(_mAA) * normalize; \ + } \ +} \ +MACRO_STOP + +#define rwMat03Inv(_rAA, _rAB, _rAC, \ + _rBA, _rBB, _rBC, \ + _rCA, _rCB, _rCC, \ + _mAA, _mAB, _mAC, \ + _mBA, _mBB, _mBC, \ + _mCA, _mCB, _mCC) \ +MACRO_START \ +{ \ + RwSplitBits determinant; \ + \ + (_rAA)= rwMat02Det(_mBB, _mBC, \ + _mCB, _mCC); \ + (_rAB)= -rwMat02Det(_mAB, _mAC, \ + _mCB, _mCC); \ + (_rAC)= rwMat02Det(_mAB, _mAC, \ + _mBB, _mBC); \ + \ + determinant.nReal = ( (_rAA) * (_mAA) + \ + (_rAB) * (_mBA) + \ + (_rAC) * (_mCA) ); \ + \ + { \ + const RwReal normalize = ( (determinant.nInt != 0)? \ + (((RwReal)1)/determinant.nReal): \ + ((RwReal)1) ); \ + (_rAA) *= normalize; \ + (_rAB) *= normalize; \ + (_rAC) *= normalize; \ + \ + (_rBA)= -rwMat02Det(_mBA, _mBC, \ + _mCA, _mCC) * normalize ; \ + (_rBB)= rwMat02Det(_mAA, _mAC, \ + _mCA, _mCC) * normalize ; \ + (_rBC)= -rwMat02Det(_mAA, _mAC, \ + _mBA, _mBC) * normalize ; \ + \ + (_rCA)= rwMat02Det(_mBA, _mBB, \ + _mCA, _mCB) * normalize ; \ + (_rCB)= -rwMat02Det(_mAA, _mAB, \ + _mCA, _mCB) * normalize ; \ + (_rCC)= rwMat02Det(_mAA, _mAB, \ + _mBA, _mBB) * normalize ; \ + } \ + \ +} \ +MACRO_STOP + +#define rwMat04Inv(_rAA, _rAB, _rAC, _rAD, \ + _rBA, _rBB, _rBC, _rBD, \ + _rCA, _rCB, _rCC, _rCD, \ + _rDA, _rDB, _rDC, _rDD, \ + _mAA, _mAB, _mAC, _mAD, \ + _mBA, _mBB, _mBC, _mBD, \ + _mCA, _mCB, _mCC, _mCD, \ + _mDA, _mDB, _mDC, _mDD) \ +MACRO_START \ +{ \ + RwSplitBits determinant; \ + \ + (_rAA)= rwMat03Det(_mBB, _mBC, _mBD, \ + _mCB, _mCC, _mCD, \ + _mDB, _mDC, _mDD); \ + (_rAB)= -rwMat03Det(_mAB, _mAC, _mAD, \ + _mCB, _mCC, _mCD, \ + _mDB, _mDC, _mDD); \ + (_rAC)= rwMat03Det(_mAB, _mAC, _mAD, \ + _mBB, _mBC, _mBD, \ + _mDB, _mDC, _mDD); \ + (_rAD)= -rwMat03Det(_mAB, _mAC, _mAD, \ + _mBB, _mBC, _mBD, \ + _mCB, _mCC, _mCD); \ + \ + determinant.nReal = ( (_rAA) * (_mAA) + \ + (_rAB) * (_mBA) + \ + (_rAC) * (_mCA) + \ + (_rAD) * (_mDA) ); \ + \ + { \ + const RwReal normalize = ( (determinant.nInt != 0)? \ + (((RwReal)1)/determinant.nReal): \ + ((RwReal)1) ); \ + \ + (_rAA) *= normalize; \ + (_rAB) *= normalize; \ + (_rAC) *= normalize; \ + (_rAD) *= normalize; \ + \ + (_rBA)= -rwMat03Det(_mBA, _mBC, _mBD, \ + _mCA, _mCC, _mCD, \ + _mDA, _mDC, _mDD) * normalize ; \ + (_rBB)= rwMat03Det(_mAA, _mAC, _mAD, \ + _mCA, _mCC, _mCD, \ + _mDA, _mDC, _mDD) * normalize ; \ + (_rBC)= -rwMat03Det(_mAA, _mAC, _mAD, \ + _mBA, _mBC, _mBD, \ + _mDA, _mDC, _mDD) * normalize ; \ + (_rBD)= rwMat03Det(_mAA, _mAC, _mAD, \ + _mBA, _mBC, _mBD, \ + _mCA, _mCC, _mCD) * normalize ; \ + \ + (_rCA)= rwMat03Det(_mBA, _mBB, _mBD, \ + _mCA, _mCB, _mCD, \ + _mDA, _mDB, _mDD) * normalize ; \ + (_rCB)= -rwMat03Det(_mAA, _mAB, _mAD, \ + _mCA, _mCB, _mCD, \ + _mDA, _mDB, _mDD) * normalize ; \ + (_rCC)= rwMat03Det(_mAA, _mAB, _mAD, \ + _mBA, _mBB, _mBD, \ + _mDA, _mDB, _mDD) * normalize ; \ + (_rCD)= -rwMat03Det(_mAA, _mAB, _mAD, \ + _mBA, _mBB, _mBD, \ + _mCA, _mCB, _mCD) * normalize ; \ + \ + (_rDA)= -rwMat03Det(_mBA, _mBB, _mBC, \ + _mCA, _mCB, _mCC, \ + _mDA, _mDB, _mDC) * normalize ; \ + (_rDB)= rwMat03Det(_mAA, _mAB, _mAC, \ + _mCA, _mCB, _mCC, \ + _mDA, _mDB, _mDC) * normalize ; \ + (_rDC)= -rwMat03Det(_mAA, _mAB, _mAC, \ + _mBA, _mBB, _mBC, \ + _mDA, _mDB, _mDC) * normalize ; \ + (_rDD)= rwMat03Det(_mAA, _mAB, _mAC, \ + _mBA, _mBB, _mBC, \ + _mCA, _mCB, _mCC) * normalize ; \ + } \ +} \ +MACRO_STOP + + +/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/drvmodel.h ---*/ +#ifndef D3D8_DRVMODEL_H +#define D3D8_DRVMODEL_H + +#if (defined(__ICL)) +/* Avoid voluminous + * 'warning #344: typedef name has already been declared (with same type)' + * warnings from MS include files + */ +#pragma warning( disable : 344 ) +#endif /* (defined(__ICL)) */ + +//nobody needed that - AAP +//#include <windows.h> + +#if (defined(RWDEBUG)) +#if (defined(RWMEMDEBUG) && !defined(_CRTDBG_MAP_ALLOC)) +#define _CRTDBG_MAP_ALLOC +#endif /* defined(RWMEMDEBUG) && !defined(_CRTDBG_MAP_ALLOC)) */ +#include <crtdbg.h> +#define ERR_WRAP(A) (_rwRePrintErrorDDD3D((A), __FILE__, __LINE__)) +#endif /* (defined(RWDEBUG)) */ + +#if (!defined(ERR_WRAP)) +#define ERR_WRAP(A) (A) +#endif /* (!defined(ERR_WRAP)) */ + +/**************************************************************************** + Defines + */ + +/* Set true depth information (for fogging, eg) */ +#define RwIm2DVertexSetCameraX(vert, camx) /* Nothing */ +#define RwIm2DVertexSetCameraY(vert, camy) /* Nothing */ +#define RwIm2DVertexSetCameraZ(vert, camz) /* Nothing */ + +#define RwIm2DVertexSetRecipCameraZ(vert, recipz) ((vert)->rhw = recipz) + +#define RwIm2DVertexGetCameraX(vert) (cause an error) +#define RwIm2DVertexGetCameraY(vert) (cause an error) +#define RwIm2DVertexGetCameraZ(vert) (cause an error) +#define RwIm2DVertexGetRecipCameraZ(vert) ((vert)->rhw) + +/* Set screen space coordinates in a device vertex */ +#define RwIm2DVertexSetScreenX(vert, scrnx) ((vert)->x = (scrnx)) +#define RwIm2DVertexSetScreenY(vert, scrny) ((vert)->y = (scrny)) +#define RwIm2DVertexSetScreenZ(vert, scrnz) ((vert)->z = (scrnz)) +#define RwIm2DVertexGetScreenX(vert) ((vert)->x) +#define RwIm2DVertexGetScreenY(vert) ((vert)->y) +#define RwIm2DVertexGetScreenZ(vert) ((vert)->z) + +/* Set texture coordinates in a device vertex */ +#define RwIm2DVertexSetU(vert, texU, recipz) ((vert)->u = (texU)) +#define RwIm2DVertexSetV(vert, texV, recipz) ((vert)->v = (texV)) +#define RwIm2DVertexGetU(vert) ((vert)->u) +#define RwIm2DVertexGetV(vert) ((vert)->v) + +/* Modify the luminance stuff */ +#define RwIm2DVertexSetRealRGBA(vert, red, green, blue, alpha) \ + ((vert)->emissiveColor = \ + (((RwFastRealToUInt32(alpha)) << 24) | \ + ((RwFastRealToUInt32(red)) << 16) | \ + ((RwFastRealToUInt32(green)) << 8) | \ + ((RwFastRealToUInt32(blue))))) + +#define RwIm2DVertexSetIntRGBA(vert, red, green, blue, alpha) \ + ((vert)->emissiveColor = \ + ((((RwUInt32)(alpha)) << 24) | \ + (((RwUInt32)(red)) << 16) | \ + (((RwUInt32)(green)) << 8) | \ + (((RwUInt32)(blue))))) + +#define RwIm2DVertexGetRed(vert) \ + (((vert)->emissiveColor >> 16) & 0xFF) + +#define RwIm2DVertexGetGreen(vert) \ + (((vert)->emissiveColor >> 8) & 0xFF) + +#define RwIm2DVertexGetBlue(vert) \ + ((vert)->emissiveColor & 0xFF) + +#define RwIm2DVertexGetAlpha(vert) \ + (((vert)->emissiveColor >> 24) & 0xFF) + +#define RwIm2DVertexCopyRGBA(dst, src) \ + ((dst)->emissiveColor = (src)->emissiveColor) + +/* Clipper stuff */ + +#define RwIm2DVertexClipRGBA(o, i, n, f) \ +MACRO_START \ +{ \ + const RwInt32 _factor = \ + (RwFastRealToUInt32(i * (RwReal)(255))) & 255; \ + \ + (o)->emissiveColor = \ + (((((RwIm2DVertexGetAlpha(f) - RwIm2DVertexGetAlpha(n)) * \ + _factor) >> 8) + RwIm2DVertexGetAlpha(n)) << 24) | \ + (((((RwIm2DVertexGetRed(f) - RwIm2DVertexGetRed(n)) * \ + _factor) >> 8) + RwIm2DVertexGetRed(n)) << 16) | \ + (((((RwIm2DVertexGetGreen(f) - RwIm2DVertexGetGreen(n)) * \ + _factor) >> 8) + RwIm2DVertexGetGreen(n)) << 8) | \ + (((((RwIm2DVertexGetBlue(f) - RwIm2DVertexGetBlue(n)) * \ + _factor) >> 8) + RwIm2DVertexGetBlue(n))); \ +} \ +MACRO_STOP + +/* LEGACY-SUPPORT macros */ +#define RWIM2DVERTEXSetCameraX(vert, camx) RwIm2DVertexSetCameraX(vert, camx) +#define RWIM2DVERTEXSetCameraY(vert, camy) RwIm2DVertexSetCameraY(vert, camy) +#define RWIM2DVERTEXSetCameraZ(vert, camz) RwIm2DVertexSetCameraZ(vert, camz) +#define RWIM2DVERTEXSetRecipCameraZ(vert, recipz) \ + RwIm2DVertexSetRecipCameraZ(vert, recipz) +#define RWIM2DVERTEXGetCameraX(vert) RwIm2DVertexGetCameraX(vert) +#define RWIM2DVERTEXGetCameraY(vert) RwIm2DVertexGetCameraY(vert) +#define RWIM2DVERTEXGetCameraZ(vert) RwIm2DVertexGetCameraZ(vert) +#define RWIM2DVERTEXGetRecipCameraZ(vert) RwIm2DVertexGetRecipCameraZ(vert) +#define RWIM2DVERTEXSetScreenX(vert, scrnx) RwIm2DVertexSetScreenX(vert, scrnx) +#define RWIM2DVERTEXSetScreenY(vert, scrny) RwIm2DVertexSetScreenY(vert, scrny) +#define RWIM2DVERTEXSetScreenZ(vert, scrnz) RwIm2DVertexSetScreenZ(vert, scrnz) +#define RWIM2DVERTEXGetScreenX(vert) RwIm2DVertexGetScreenX(vert) +#define RWIM2DVERTEXGetScreenY(vert) RwIm2DVertexGetScreenY(vert) +#define RWIM2DVERTEXGetScreenZ(vert) RwIm2DVertexGetScreenZ(vert) +#define RWIM2DVERTEXSetU(vert, u, recipz) RwIm2DVertexSetU(vert, u, recipz) +#define RWIM2DVERTEXSetV(vert, v, recipz) RwIm2DVertexSetV(vert, v, recipz) +#define RWIM2DVERTEXGetU(vert) RwIm2DVertexGetU(vert) +#define RWIM2DVERTEXGetV(vert) RwIm2DVertexGetV(vert) +#define RWIM2DVERTEXSetRealRGBA(vert, red, green, blue, alpha) \ + RwIm2DVertexSetRealRGBA(vert, red, green, blue, alpha) +#define RWIM2DVERTEXSetIntRGBA(vert, red, green, blue, alpha) \ + RwIm2DVertexSetIntRGBA(vert, red, green, blue, alpha) +#define RWIM2DVERTEXGetRed(vert) RwIm2DVertexGetRed(vert) +#define RWIM2DVERTEXGetGreen(vert) RwIm2DVertexGetGreen(vert) +#define RWIM2DVERTEXGetBlue(vert) RwIm2DVertexGetBlue(vert) +#define RWIM2DVERTEXGetAlpha(vert) RwIm2DVertexGetAlpha(vert) +#define RWIM2DVERTEXCopyRGBA(dst, src) RwIm2DVertexCopyRGBA(dst, src) +#define RWIM2DVERTEXClipRGBA(o, i, n, f) RwIm2DVertexClipRGBA(o, i, n, f) + +/**************************************************************************** + Global Types + */ + +/* We use RwD3D8Vertex to drive the hardware in 2D mode */ + +/** + * \ingroup rwcoredriverd3d8 + * \typedef RwD3D8Vertex + * D3D8 vertex structure definition for 2D geometry + */ +typedef struct RwD3D8Vertex RwD3D8Vertex; +/** + * \ingroup rwcoredriverd3d8 + * \struct RwD3D8Vertex + * D3D8 vertex structure definition for 2D geometry + */ +struct RwD3D8Vertex +{ + RwReal x; /**< Screen X */ + RwReal y; /**< Screen Y */ + RwReal z; /**< Screen Z */ + RwReal rhw; /**< Reciprocal of homogeneous W */ + + RwUInt32 emissiveColor; /**< Vertex color */ + + RwReal u; /**< Texture coordinate U */ + RwReal v; /**< Texture coordinate V */ +}; + +/* Define types used */ + +/** + * \ingroup rwcoredriverd3d8 + * \typedef RwIm2DVertex + * Typedef for a RenderWare Graphics Immediate Mode 2D Vertex + */ +typedef RwD3D8Vertex RwIm2DVertex; + +/* LEGACY-SUPPORT macro */ +/** + * \ingroup rwcoredriverd3d8 + * \def RWIM2DVERTEX + * RWIM2DVERTEX is a legacy macro for RwIm2DVertex + */ +#define RWIM2DVERTEX RwIm2DVertex + +/** + * \ingroup rwcoredriverd3d8 + * \typedef RxVertexIndex + * + * Typedef for a RenderWare Graphics PowerPipe Immediate + * Mode Vertex + */ +typedef RwUInt16 RxVertexIndex; + +/** + * \ingroup rwcoredriverd3d8 + * \typedef RwImVertexIndex + * Typedef for a RenderWare Graphics Immediate Mode Vertex. + */ +typedef RxVertexIndex RwImVertexIndex; + +/* LEGACY-SUPPORT macro */ +/** + * \ingroup rwcoredriverd3d8 + * \def RWIMVERTEXINDEX + * RWIMVERTEXINDEX is a legacy macro for RwImVertexIndex + */ +#define RWIMVERTEXINDEX RwImVertexIndex + +/** + * \ingroup rwcoredriverd3d8 + * \struct RwD3D8Metrics + * Structure containing metrics counters + */ +typedef struct +{ + RwUInt32 numRenderStateChanges; /**< Number of Render States changed */ + RwUInt32 numTextureStageStateChanges; /**< Number of Texture Stage States changed */ + RwUInt32 numMaterialChanges; /**< Number of Material changes */ + RwUInt32 numLightsChanged; /**< Number of Lights changed */ +} +RwD3D8Metrics; + +#endif /* D3D8_DRVMODEL_H */ + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/bavector.h ---*/ + +/* + * Typedef for pointer to Vector multiplication by Matrix function + */ + +typedef RwV3d *(*rwVectorMultFn) (RwV3d * pointsOut, + const RwV3d * pointsIn, + RwInt32 numPoints, + const RwMatrix * matrix); + + +/* If sqrt is overloaded for this platform, we will remove + * all the sqrt table stuff from the build entirely + * currently applies to SKY2 and XBOX - IDBS [2/11/2001] + * [and, if using the intel compiler version 400 or above, + * we will use the single-precision float "sqrtf" under + * D3D7, D3D8, OpenGL or SoftRas] */ +#if (defined(rwSqrtMacro)) +#define RWNOSQRTTABLE +#endif /* (defined(rwSqrtMacro)) */ +#if (defined(rwInvSqrtMacro)) +#define RWNOINVSQRTTABLE +#endif /* (defined(rwSqrtMacro)) */ + +#if (!defined(rwSqrtMacro)) +#define rwSqrtMacro(_root, _input) \ + ( *(_root) = _rwSqrt(_input) ) +#endif /* (!defined(rwSqrtMacro)) */ + +#if (!defined(rwInvSqrtMacro)) +#define rwInvSqrtMacro(_recip, _input) \ + ( *(_recip) = _rwInvSqrt(_input) ) +#endif /* (!defined(rwInvSqrtMacro)) */ + +#if (!defined(rwSqrtInvSqrtMacro)) +#define rwSqrtInvSqrtMacro(_root, _recip, _input) \ +MACRO_START \ +{ \ + RwReal _tmp = _input; \ + rwSqrt((_root), _tmp); \ + rwInvSqrt((_recip), _tmp); \ +} \ +MACRO_STOP +#endif /* (!defined(rwSqrtInvSqrtMacro)) */ + +/* Vector operations Macros */ + +#if (!defined(RwV2dAssignMacro)) +#define RwV2dAssignMacro(_target, _source) \ + ( *(_target) = *(_source) ) +#endif /* (!defined(RwV2dAssignMacro)) */ + +#define RwV2dAddMacro(o, a, b) \ +MACRO_START \ +{ \ + (o)->x = (((a)->x) + ( (b)->x)); \ + (o)->y = (((a)->y) + ( (b)->y)); \ +} \ +MACRO_STOP + +#define RwV2dSubMacro(o, a, b) \ +MACRO_START \ +{ \ + (o)->x = (((a)->x) - ( (b)->x)); \ + (o)->y = (((a)->y) - ( (b)->y)); \ +} \ +MACRO_STOP + +#define RwV2dScaleMacro(o, i, s) \ +MACRO_START \ +{ \ + (o)->x = (((i)->x) * ( (s))); \ + (o)->y = (((i)->y) * ( (s))); \ +} \ +MACRO_STOP + +#define RwV2dDotProductMacro(a,b) \ + (( ((((a)->x) * ( (b)->x))) + \ + ( (((a)->y) * ( (b)->y))))) \ + +#define _rwV2dNormalizeMacro(_result, _out, _in) \ +MACRO_START \ +{ \ + RwReal length2 = RwV2dDotProductMacro((_in), (_in)); \ + rwInvSqrtMacro(&(_result), length2); \ + RwV2dScaleMacro((_out), (_in), (_result)); \ +} \ +MACRO_STOP + +#define RwV2dNormalizeMacro(_result, _out, _in) \ +MACRO_START \ +{ \ + RwReal length2 = RwV2dDotProductMacro((_in), (_in)); \ + RwReal recip; \ + \ + rwSqrtInvSqrtMacro(&(_result), &recip, length2); \ + RwV2dScaleMacro((_out), (_in), recip); \ +} \ +MACRO_STOP + +#define RwV2dLengthMacro(_result, _in) \ +MACRO_START \ +{ \ + (_result) = RwV2dDotProductMacro(_in, _in); \ + rwSqrtMacro(&(_result), (_result)); \ +} \ +MACRO_STOP + +#define RwV2dLineNormalMacro(_o, _a, _b) \ +MACRO_START \ +{ \ + RwReal recip; \ + \ + (_o)->y = (((_b)->x) - ( (_a)->x)); \ + (_o)->x = (((_a)->y) - ( (_b)->y)); \ + _rwV2dNormalizeMacro(recip, _o,_o); \ +} \ +MACRO_STOP + +#define RwV2dPerpMacro(o, a) \ +MACRO_START \ +{ \ + (o)->x = -(a)->y; \ + (o)->y = (a)->x; \ +} \ +MACRO_STOP + +/* RwV3d */ + +#if (!defined(RwV3dAssignMacro)) +#define RwV3dAssignMacro(_target, _source) \ + ( *(_target) = *(_source) ) +#endif /* (!defined(RwV3dAssignMacro)) */ + + +#define RwV3dAddMacro(o, a, b) \ +MACRO_START \ +{ \ + (o)->x = (((a)->x) + ( (b)->x)); \ + (o)->y = (((a)->y) + ( (b)->y)); \ + (o)->z = (((a)->z) + ( (b)->z)); \ +} \ +MACRO_STOP + +#define RwV3dSubMacro(o, a, b) \ +MACRO_START \ +{ \ + (o)->x = (((a)->x) - ( (b)->x)); \ + (o)->y = (((a)->y) - ( (b)->y)); \ + (o)->z = (((a)->z) - ( (b)->z)); \ +} \ +MACRO_STOP + +#define RwV3dScaleMacro(o, a, s) \ +MACRO_START \ +{ \ + (o)->x = (((a)->x) * ( (s))); \ + (o)->y = (((a)->y) * ( (s))); \ + (o)->z = (((a)->z) * ( (s))); \ +} \ +MACRO_STOP + +#define RwV3dIncrementScaledMacro(o, a, s) \ +MACRO_START \ +{ \ + (o)->x += (((a)->x) * ( (s))); \ + (o)->y += (((a)->y) * ( (s))); \ + (o)->z += (((a)->z) * ( (s))); \ +} \ +MACRO_STOP + +#define RwV3dNegateMacro(o, a) \ +MACRO_START \ +{ \ + (o)->x = -(a)->x; \ + (o)->y = -(a)->y; \ + (o)->z = -(a)->z; \ +} \ +MACRO_STOP + +#define RwV3dDotProductMacro(a, b) \ + ((((( (((a)->x) * ((b)->x))) + \ + ( (((a)->y) * ((b)->y))))) + \ + ( (((a)->z) * ((b)->z))))) \ + +#define RwV3dCrossProductMacro(o, a, b) \ +MACRO_START \ +{ \ + (o)->x = \ + (( (((a)->y) * ( (b)->z))) - \ + ( (((a)->z) * ( (b)->y)))); \ + (o)->y = \ + (( (((a)->z) * ( (b)->x))) - \ + ( (((a)->x) * ( (b)->z)))); \ + (o)->z = \ + (( (((a)->x) * ( (b)->y))) - \ + ( (((a)->y) * ( (b)->x)))); \ +} \ +MACRO_STOP + +#define _rwV3dNormalizeMacro(_result, _out, _in) \ +MACRO_START \ +{ \ + RwReal length2 = RwV3dDotProductMacro(_in, _in); \ + rwInvSqrtMacro(&(_result), length2); \ + RwV3dScaleMacro(_out, _in, _result); \ +} \ +MACRO_STOP + +#define RwV3dNormalizeMacro(_result, _out, _in) \ +MACRO_START \ +{ \ + RwReal length2 = RwV3dDotProductMacro((_in), (_in)); \ + RwReal recip; \ + \ + rwSqrtInvSqrtMacro(&(_result), &recip, length2); \ + RwV3dScaleMacro((_out), (_in), recip); \ +} \ +MACRO_STOP + +#define RwV3dLengthMacro(_result, _in) \ +MACRO_START \ +{ \ + (_result) = RwV3dDotProductMacro(_in, _in); \ + rwSqrtMacro(&(_result), _result); \ +} \ +MACRO_STOP + +#if (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )) + +#define RwV2dAssign(o, a) RwV2dAssignMacro(o, a) +#define RwV2dAdd(o, a, b) RwV2dAddMacro(o, a, b) +#define RwV2dSub(o, a, b) RwV2dSubMacro(o, a, b) +#define RwV2dLineNormal(_o, _a, _b) RwV2dLineNormalMacro(_o, _a, _b) +#define RwV2dScale(o, i, s) RwV2dScaleMacro(o, i, s) +#define RwV2dDotProduct(a,b) RwV2dDotProductMacro(a,b) +#define RwV2dPerp(o, a) RwV2dPerpMacro(o, a) +#define RwV3dAssign(o, a) RwV3dAssignMacro(o, a) +#define RwV3dAdd(o, a, b) RwV3dAddMacro(o, a, b) +#define RwV3dSub(o, a, b) RwV3dSubMacro(o, a, b) +#define RwV3dScale(o, a, s) RwV3dScaleMacro(o, a, s) +#define RwV3dIncrementScaled(o, a, s) RwV3dIncrementScaledMacro(o, a, s) +#define RwV3dNegate(o, a) RwV3dNegateMacro(o, a) +#define RwV3dDotProduct(a, b) RwV3dDotProductMacro(a, b) +#define RwV3dCrossProduct(o, a, b) RwV3dCrossProductMacro(o, a, b) + +#endif /* (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )) */ + +#define RWRAD2DEG(_x) ((_x) * (((RwReal)180)/(rwPI))) + +#if (!defined(rw4OVERPISQ)) +#define rw4OVERPISQ ( ((RwReal)4) / ( rwPI * rwPI )) +#endif /* (!defined(rw4OVERPISQ)) */ + +#if (!defined(rwPI3)) +#define rwPI3 (rwPI * (RwReal)3) +#endif /* (!defined(rwPI3)) */ + +#if (!defined(rwPI3OVER2)) +#define rwPI3OVER2 ( rwPI3 / (RwReal)2 ) +#endif /* (!defined(rwPI3OVER2)) */ + +#if (!defined(rwPI3OVER8)) +#define rwPI3OVER8 (rwPI3 / (RwReal)8 ) +#endif /* (!defined(rwPI3OVER8)) */ + +#define RwQuadSin(_x) \ + ( rw4OVERPISQ * \ + ( ( (_x) < 0 ) ? \ + ( ( rwPI + (_x) ) * (_x) ) : \ + ( ( rwPI - (_x) ) * (_x) ) ) ) + +#define RwQuadASin(_result, _s) \ + ( rwPIOVER2 * ( ((_s)<0) ? \ + ( rwSqrtMacro((_result), 1.0f + (_s)) - 1 ) : \ + ( 1 - rwSqrtMacro((_result), 1.0f - (_s)) ) ) ) + +#define RwQuadCos(_x) \ + ( rw4OVERPISQ * \ + ( ( (_x) < -rwPIOVER2 ) ? \ + ( ( -rwPI3OVER2 - (_x) ) * ( -rwPIOVER2 - (_x) ) ) : \ + ( ( (_x) < rwPIOVER2) ? \ + ( ( rwPIOVER2 + (_x) ) * ( rwPIOVER2 - (_x) ) ) : \ + ( ( rwPIOVER2 - (_x) ) * ( rwPI3OVER2 - (_x) ) ) ) ) ) + +#define RwQuadACos(_result, _c) \ + ( rwPIOVER2 * ( ((_c)<0) ? \ + (2.0f - rwSqrtMacro((_result), 1.0f + (_c))): \ + rwSqrtMacro((_result), 1.0f - (_c))) ) + +#define RwQuadTan(_x) \ + ( rwPI3 * (_x) / ( rwPI * rwPI - (_x) * (_x) * 4.0f ) ) + +#define RwQuadATan(_result, _t) \ + ( ( rwSqrtMacro((_result), (rwPI3OVER8 * rwPI3OVER8) + \ + (_t) * (_t) * (rwPIOVER2 * rwPIOVER2) ) - rwPI3OVER8 ) \ + / ( _t) ) + +#define RwQuadATan2(_result, _s, _c) \ + ( ( rwSqrtMacro((_result), (_c) * (_c) * (rwPI3OVER8 * rwPI3OVER8) + \ + (_s) * (_s) * (rwPIOVER2 * rwPIOVER2) ) \ + - (_c) * rwPI3OVER8 ) / ( _s) ) + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* Other useful stuff */ + +extern RwReal RwV3dNormalize(RwV3d * out, const RwV3d * in); +extern RwReal RwV3dLength(const RwV3d * in); + +extern RwReal RwV2dLength(const RwV2d * in); +extern RwReal RwV2dNormalize(RwV2d * out, const RwV2d * in); + +#if ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ) + +extern void RwV2dAssign(RwV2d * out, + const RwV2d * ina); +extern void RwV2dAdd(RwV2d * out, + const RwV2d * ina, const RwV2d * inb); +extern void RwV2dLineNormal(RwV2d * out, + const RwV2d * ina, const RwV2d * inb); +extern void RwV2dSub(RwV2d * out, + const RwV2d * ina, const RwV2d * inb); +extern void RwV2dPerp(RwV2d * out, const RwV2d * in); +extern void RwV2dScale(RwV2d * out, + const RwV2d * in, RwReal scalar); +extern RwReal RwV2dDotProduct(const RwV2d * ina, const RwV2d * inb); + +extern void RwV3dAssign(RwV3d * out, + const RwV3d * ina); +extern void RwV3dAdd(RwV3d * out, + const RwV3d * ina, const RwV3d * inb); +extern void RwV3dSub(RwV3d * out, + const RwV3d * ina, const RwV3d * inb); +extern void RwV3dScale(RwV3d * out, + const RwV3d * in, RwReal scalar); +extern void RwV3dIncrementScaled(RwV3d * out, + const RwV3d * in, RwReal scalar); +extern void RwV3dNegate(RwV3d * out, const RwV3d * in); +extern RwReal RwV3dDotProduct(const RwV3d * ina, const RwV3d * inb); +extern void RwV3dCrossProduct(RwV3d * out, + const RwV3d * ina, const RwV3d * inb); + +#endif /* ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ) */ + +/* Transform points/vectors */ +extern RwV3d *RwV3dTransformPoints(RwV3d * pointsOut, + const RwV3d * pointsIn, + RwInt32 numPoints, + const RwMatrix * matrix); +extern RwV3d *RwV3dTransformVectors(RwV3d * vectorsOut, + const RwV3d * vectorsIn, + RwInt32 numPoints, + const RwMatrix * matrix); + +/* SPI */ + +#if (!defined(RWNOSQRTTABLE)) +extern RwReal _rwSqrt(const RwReal num); +#endif /* (!defined(RWNOSQRTTABLE)) */ +#if (!defined(RWNOINVSQRTTABLE)) +extern RwReal _rwInvSqrt(const RwReal num); +#endif /* (!defined(RWNOINVSQRTTABLE)) */ + +extern RwReal _rwV3dNormalize(RwV3d * out, const RwV3d * in); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#define rwVectorOpen(instance, offset, size) \ + _rwVectorOpen(instance, offset, size) + +#define rwVectorClose(instance, offset, size) \ + _rwVectorClose(instance, offset, size) + +#define rwVectorSetMultFn(multPoint,multVector) \ + _rwVectorSetMultFn(multPoint,multVector) + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/balist.h ---*/ +/**************************************************************************** + Global Types + */ + +typedef struct RwSList RwSList; +struct RwSList +{ + RwUInt8 *listElements; + RwInt32 numElementsFilled; + RwInt32 numElementsAlloced; + RwInt32 entrySize; +}; + + + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* SList functions */ +extern RwSList *_rwSListCreate(RwInt32 size); +extern RwBool _rwSListDestroy(RwSList *sList); +extern RwBool _rwSListDestroyArray(RwUInt8 *array); +extern void _rwSListDestroyEndEntries(RwSList *sList, RwInt32 amount); +extern RwBool _rwSListDestroyEntry(RwSList *sList, RwInt32 entry); +extern void _rwSListEmpty(RwSList *sList); +extern void *_rwSListGetArray(RwSList *sList); +extern void *_rwSListGetEntry(RwSList *sList, RwInt32 entry); +extern void *_rwSListGetNewEntry(RwSList *sList); +extern void *_rwSListGetNewEntries(RwSList *sList, RwInt32 entry); +extern RwInt32 _rwSListGetNumEntries(const RwSList *sList); +extern RwBool _rwSListReleaseArray(RwSList *sList); +extern void *_rwSListToArray(RwSList *sList); + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +/* Comparibility macros */ + +#define rwSListCreate(size) \ + _rwSListCreate(size) +#define rwSListDestroy(sList) \ + _rwSListDestroy(sList) +#define rwSListDestroyArray(array) \ + _rwSListDestroyArray(array) +#define rwSListDestroyEndEntries(sList, amount) \ + _rwSListDestroyEndEntries(sList, amount) +#define rwSListDestroyEntry(sList, entry) \ + _rwSListDestroyEntry(sList, entry) +#define rwSListEmpty(sList) \ + _rwSListEmpty(sList) +#define rwSListGetArray(sList) \ + _rwSListGetArray(sList) +#define rwSListGetEntry(sList, entry) \ + _rwSListGetEntry(sList, entry) +#define rwSListGetNewEntry(sList) \ + _rwSListGetNewEntry(sList) +#define rwSListGetNewEntries(sList, entry) \ + _rwSListGetNewEntries(sList, entry) +#define rwSListGetNumEntries(sList) \ + _rwSListGetNumEntries(sList) +#define rwSListReleaseArray(sList) \ + _rwSListReleaseArray(sList) +#define rwSListToArray(sList) \ + _rwSListToArray(sList) + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/baimmedi.h ---*/ + +/**************************************************************************** + Defines + */ + + +/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + + Immediate mode interface V2.0 + + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ + +/** + * \ingroup datatypes + * RwRenderState + * This type represents the various render states that + * can be set using the API function \ref RwRenderStateSet. This function also + * takes a render state value or pointer to an object depending on the type. + * For render states that are toggles, the value should be TRUE to switch the + * state on and FALSE to turn it off. + * + * Note that many of these render states may not be supported on certain + * platforms. The \ref RwRenderStateSet functions will return FALSE in such cases. + */ +enum RwRenderState +{ + rwRENDERSTATENARENDERSTATE = 0, + rwRENDERSTATETEXTURERASTER, /**<Raster to texture with. \ref RwRenderStateSet + * takes a pointer to an \ref RwRaster */ + rwRENDERSTATETEXTUREADDRESS, /**<\ref RwTextureAddressMode: wrap, clamp, mirror or border */ + rwRENDERSTATETEXTUREADDRESSU, /**<\ref RwTextureAddressMode in u only */ + rwRENDERSTATETEXTUREADDRESSV, /**<\ref RwTextureAddressMode in v only */ + rwRENDERSTATETEXTUREPERSPECTIVE, /**<Perspective correction on/off */ + rwRENDERSTATEZTESTENABLE, /**<Z-buffer test on/off */ + rwRENDERSTATESHADEMODE, /**<\ref RwShadeMode: flat or gouraud shading */ + rwRENDERSTATEZWRITEENABLE, /**<Z-buffer write on/off */ + rwRENDERSTATETEXTUREFILTER, /**<\ref RwTextureFilterMode: point sample, bilinear, trilinear, etc */ + rwRENDERSTATESRCBLEND, /**<Source alpha \ref RwBlendFunction: src alpha, 1-src alpha, etc */ + rwRENDERSTATEDESTBLEND, /**<Destination alpha \ref RwBlendFunction */ + rwRENDERSTATEVERTEXALPHAENABLE, /**<Vertex alpha transparency on/off */ + rwRENDERSTATEBORDERCOLOR, /**<Border color for \ref RwTextureAddressMode rwTEXTUREADDRESSBORDER. + * The value should be a packed RwUInt32 in ARGB form. The macro + * RWRGBALONG(r, g, b, a) may be used to construct this using 8-bit + * color components. */ + rwRENDERSTATEFOGENABLE, /**<Fogging on/off (all polygons will be fogged) */ + rwRENDERSTATEFOGCOLOR, /**<Color used for fogging. The value should be a packed RwUInt32 + * in ARGB form. The macro RWRGBALONG(r, g, b, a) may be used to + * construct this using 8-bit color components */ + rwRENDERSTATEFOGTYPE, /**<Sets \ref RwFogType, the type of fogging to use */ + rwRENDERSTATEFOGDENSITY, /**<Select the fog density for \ref RwFogType of rwFOGTYPEEXPONENTIAL + * or rwFOGTYPEEXPONENTIAL2. The value should be a pointer to + * an RwReal in the range 0 to 1. */ + rwRENDERSTATEFOGTABLE, /**<Install a 256 entry fog table placed between fog distance and far + * clip-plane */ + rwRENDERSTATEALPHAPRIMITIVEBUFFER, /**<Render transparent alpha polygons last - on/off. \e Not \e supported + * \e on \e any \e platform.*/ + rwRENDERSTATECULLMODE, /**<Sets \ref RwCullMode, for selecting face culling. */ + rwRENDERSTATESTENCILENABLE, /**< TRUE to enable stenciling, or FALSE to disable stenciling. + * \e Supported \e on \e Xbox, \e D3D8, \e and \e OpenGL \e only. */ + rwRENDERSTATESTENCILFAIL, /**< Stencil test operator for the fail case. + * \e Supported \e on \e Xbox, \e D3D8, \e and \e OpenGL \e only */ + rwRENDERSTATESTENCILZFAIL, /**< Stencil operation to perform if the stencil test passes + * and the depth test (z-test) fails. + * \e Supported \e on \e Xbox, \e D3D8, \e and \e OpenGL \e only */ + rwRENDERSTATESTENCILPASS, /**< Stencil operation to perform if both the stencil and the + * depth (z) tests pass. + * \e Supported \e on \e Xbox, \e D3D8, \e and \e OpenGL \e only */ + rwRENDERSTATESTENCILFUNCTION, /**< Comparison function for the stencil test. + * \e Supported \e on \e Xbox, \e D3D8, \e and \e OpenGL \e only */ + rwRENDERSTATESTENCILFUNCTIONREF, /**< Integer reference value for the stencil test. + * \e Supported \e on \e Xbox, \e D3D8, \e and \e OpenGL \e only */ + rwRENDERSTATESTENCILFUNCTIONMASK, /**< Mask applied to the reference value and each stencil buffer + * entry to determine the significant bits for the stencil test. + * \e Supported \e on \e Xbox, \e D3D8, \e and \e OpenGL \e only */ + rwRENDERSTATESTENCILFUNCTIONWRITEMASK, /**< Write mask applied to values written into the stencil buffer. + * \e Supported \e on \e Xbox, \e D3D8, \e and \e OpenGL \e only */ + + rwRENDERSTATEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwRenderState RwRenderState; + + +/** + * \ingroup datatypes + * RwShadeMode + * This type represents the options available for setting the + * rwRENDERSTATESHADEMODE render state */ +enum RwShadeMode +{ + rwSHADEMODENASHADEMODE = 0, /**<Invalid shading mode */ + rwSHADEMODEFLAT, /**<Flat shading */ + rwSHADEMODEGOURAUD, /**<Gouraud shading */ + rwSHADEMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwShadeMode RwShadeMode; + + +/** + * \ingroup datatypes + * RwTextureFilterMode + * This type represents the options available for texture + * filtering (see API functions \ref RwTextureSetFilterMode and \ref RwRenderStateSet)*/ +enum RwTextureFilterMode +{ + rwFILTERNAFILTERMODE = 0, /**<Invalid filter mode */ + rwFILTERNEAREST, /**<Point sampled */ + rwFILTERLINEAR, /**<Bilinear */ + rwFILTERMIPNEAREST, /**<Point sampled per pixel mip map */ + rwFILTERMIPLINEAR, /**<Bilinear per pixel mipmap */ + rwFILTERLINEARMIPNEAREST, /**<MipMap interp point sampled */ + rwFILTERLINEARMIPLINEAR, /**<Trilinear */ + rwTEXTUREFILTERMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwTextureFilterMode RwTextureFilterMode; + + +/** + * \ingroup datatypes + * RwFogType + * This type represents the options available to the + * rwRENDERSTATEFOGTYPE render state (see \ref RwRenderState);*/ +enum RwFogType +{ + rwFOGTYPENAFOGTYPE = 0, /**<Invalid fog type */ + rwFOGTYPELINEAR, /**<Linear fog */ + rwFOGTYPEEXPONENTIAL, /**<Exponential fog */ + rwFOGTYPEEXPONENTIAL2, /**<Exponential^2 fog */ + rwFOGTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwFogType RwFogType; + + +/** + * \ingroup datatypes + * RwBlendFunction + * This type represents the options available + * to the rwRENDERSTATESRCBLEND and rwRENDERSTATEDESTBLEND render states + * (see \ref RwRenderState). In the following description, + * a subscript s refers to a source value while subscript d refers to a + * destination value.*/ +enum RwBlendFunction +{ + rwBLENDNABLEND = 0, /**<Invalid blend mode */ + rwBLENDZERO, /**<(0, 0, 0, 0 ) */ + rwBLENDONE, /**<(1, 1, 1, 1 ) */ + rwBLENDSRCCOLOR, /**<(Rs, Gs, Bs, As ) */ + rwBLENDINVSRCCOLOR, /**<(1-Rs, 1-Gs, 1-Bs, 1-As) */ + rwBLENDSRCALPHA, /**<(As, As, As, As ) */ + rwBLENDINVSRCALPHA, /**<(1-As, 1-As, 1-As, 1-As) */ + rwBLENDDESTALPHA, /**<(Ad, Ad, Ad, Ad ) */ + rwBLENDINVDESTALPHA, /**<(1-Ad, 1-Ad, 1-Ad, 1-Ad) */ + rwBLENDDESTCOLOR, /**<(Rd, Gd, Bd, Ad ) */ + rwBLENDINVDESTCOLOR, /**<(1-Rd, 1-Gd, 1-Bd, 1-Ad) */ + rwBLENDSRCALPHASAT, /**<(f, f, f, 1 ) f = min (As, 1-Ad) */ + rwBLENDFUNCTIONFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwBlendFunction RwBlendFunction; + + +/** + * \ingroup datatypes + * RwTextureAddressMode + * This type represents the options available for + * applying textures to polygons (see API functions \ref RwTextureSetAddressing + * and \ref RwRenderStateSet, and the \ref RwRenderState type) */ +enum RwTextureAddressMode +{ + rwTEXTUREADDRESSNATEXTUREADDRESS = 0, /**<Invalid addressing mode */ + rwTEXTUREADDRESSWRAP, /**<UV wraps (tiles) */ + rwTEXTUREADDRESSMIRROR, /**<Alternate UV is flipped */ + rwTEXTUREADDRESSCLAMP, /**<UV is clamped to 0-1 */ + rwTEXTUREADDRESSBORDER, /**<Border colour takes effect outside of 0-1 */ + rwTEXTUREADDRESSMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwTextureAddressMode RwTextureAddressMode; + +/** + * \ingroup datatypes + * RwStencilOperation + * This type represents the stencil operations to perform + * based on the results of the + * \ref rwRENDERSTATESTENCILFAIL, \ref rwRENDERSTATESTENCILZFAIL + * and \ref rwRENDERSTATESTENCILPASS tests. + */ +enum RwStencilOperation +{ + rwSTENCILOPERATIONNASTENCILOPERATION = 0, + rwSTENCILOPERATIONKEEP, /* Do not update the entry in the stencil buffer */ + rwSTENCILOPERATIONZERO, /* Set the stencil-buffer entry to 0 */ + rwSTENCILOPERATIONREPLACE, /* Replace the stencil-buffer entry with reference value */ + rwSTENCILOPERATIONINCRSAT, /* Increment the stencil-buffer entry, clamping to the maximum value */ + rwSTENCILOPERATIONDECRSAT, /* Decrement the stencil-buffer entry, clamping to zero */ + rwSTENCILOPERATIONINVERT, /* Invert the bits in the stencil-buffer entry */ + rwSTENCILOPERATIONINCR, /* Increment the stencil-buffer entry, wrapping to zero if the new value exceeds the maximum value */ + rwSTENCILOPERATIONDECR, /* Decrement the stencil-buffer entry, wrapping to the maximum value if the new value is less than zero */ + rwSTENCILOPERATIONFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwStencilOperation RwStencilOperation; + +/** + * \ingroup datatypes + * RwStencilFunction + * This type represents the options available for + * the comparison function for the stencil test \ref rwRENDERSTATESTENCILFUNCTION. + */ +enum RwStencilFunction +{ + rwSTENCILFUNCTIONNASTENCILFUNCTION = 0, + rwSTENCILFUNCTIONNEVER, /* Always fail the test */ + rwSTENCILFUNCTIONLESS, /* Accept the new pixel if its value is less than the value of the current pixel */ + rwSTENCILFUNCTIONEQUAL, /* Accept the new pixel if its value equals the value of the current pixel */ + rwSTENCILFUNCTIONLESSEQUAL, /* Accept the new pixel if its value is less than or equal to the value of the current pixel */ + rwSTENCILFUNCTIONGREATER, /* Accept the new pixel if its value is greater than the value of the current pixel */ + rwSTENCILFUNCTIONNOTEQUAL, /* Accept the new pixel if its value does not equal the value of the current pixel */ + rwSTENCILFUNCTIONGREATEREQUAL, /* Accept the new pixel if its value is greater than or equal to the value of the current pixel */ + rwSTENCILFUNCTIONALWAYS, /* Always pass the test */ + rwSTENCILFUNCTIONFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwStencilFunction RwStencilFunction; + +/** + * \ingroup datatypes + * RwCullMode + * This type represents the options available for culling polygons during rendering. + * and \ref RwRenderStateSet, and the \ref RwRenderState type) */ +enum RwCullMode +{ + rwCULLMODENACULLMODE = 0, + rwCULLMODECULLNONE, /**< Both front and back-facing triangles are drawn. */ + rwCULLMODECULLBACK, /**< Just front-facing triangles are drawn */ + rwCULLMODECULLFRONT, /**< Just rear-facing triangles are drawn */ + + rwCULLMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwCullMode RwCullMode; + +/** + * \ingroup datatypes + * RwPrimitiveType + * This type represents the different types of indexed + * line and indexed triangle primitives that are available when rendering 2D + * and 3D immediate mode objects (see API functions \ref RwIm2DRenderIndexedPrimitive, + * \ref RwIm2DRenderPrimitive, \ref RwIm3DRenderIndexedPrimitive and \ref RwIm3DRenderPrimitive). + * Indices are into a vertex list and must be defined in a counter-clockwise order + * (as seen from the camera) to be visible.*/ +enum RwPrimitiveType +{ + rwPRIMTYPENAPRIMTYPE = 0, /**<Invalid primative type */ + rwPRIMTYPELINELIST = 1, /**<Unconnected line segments, each line is specified by + * both its start and end index, independently of other lines + * (for example, 3 segments specified as 0-1, 2-3, 4-5) */ + rwPRIMTYPEPOLYLINE = 2, /**<Connected line segments, each line's start index + * (except the first) is specified by the index of the end of + * the previous segment (for example, 3 segments specified as + * 0-1, 1-2, 2-3) */ + rwPRIMTYPETRILIST = 3, /**<Unconnected triangles: each triangle is specified by + * three indices, independently of other triangles (for example, + * 3 triangles specified as 0-1-2, 3-4-5, 6-7-8) */ + rwPRIMTYPETRISTRIP = 4, /**<Connected triangles sharing an edge with, at most, one + * other forming a series (for example, 3 triangles specified + * as 0-2-1, 1-2-3-, 2-4-3) */ + rwPRIMTYPETRIFAN = 5 , /**<Connected triangles sharing an edge with, at most, + * two others forming a fan (for example, 3 triangles specified + * as 0-2-1, 0-3-2, 0-4-3) */ + rwPRIMTYPEPOINTLIST = 6, /**<Points 1, 2, 3, etc. This is not + * supported by the default RenderWare + * immediate or retained-mode pipelines + * (except on PlayStation 2), it is intended + * for use by user-created pipelines */ + rwPRIMITIVETYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwPrimitiveType RwPrimitiveType; + + + + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* Expose Z buffer range */ +extern RwReal RwIm2DGetNearScreenZ(void); +extern RwReal RwIm2DGetFarScreenZ(void); + +extern RwBool RwRenderStateGet(RwRenderState state, void *value); +extern RwBool RwRenderStateSet(RwRenderState state, void *value); + +extern RwBool RwIm2DRenderLine(RwIm2DVertex *vertices, RwInt32 numVertices, RwInt32 vert1, RwInt32 vert2); +extern RwBool RwIm2DRenderTriangle(RwIm2DVertex *vertices, RwInt32 numVertices, + RwInt32 vert1, RwInt32 vert2, RwInt32 vert3 ); +extern RwBool RwIm2DRenderPrimitive(RwPrimitiveType primType, RwIm2DVertex *vertices, RwInt32 numVertices); +extern RwBool RwIm2DRenderIndexedPrimitive(RwPrimitiveType primType, RwIm2DVertex *vertices, RwInt32 numVertices, + RwImVertexIndex *indices, RwInt32 numIndices); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/badevice.h ---*/ +/***************************************************************************/ +/************************* System Requests *********************************/ +/***************************************************************************/ + +/* Device controls: + * + * rwDEVICESYSTEMOPEN(NULL, RwEngineOpenParams *openParams, 0) + * rwDEVICESYSTEMCLOSE(NULL, NULL, 0) + * rwDEVICESYSTEMSTART(NULL, NULL, 0) + * rwDEVICESYSTEMSTOP(NULL, NULL, 0) + * rwDEVICESYSTEMREGISTER(RwDevice *coreDeviceBlock, RwMemoryFunctions *memFuncs, 0) + * rwDEVICESYSTEMGETNUMMODES(RwInt32 *numModes, NULL, 0) + * rwDEVICESYSTEMGETMODEINFO(RwVideoMode *modeinfo, NULL, RwInt32 modeNum) + * rwDEVICESYSTEMUSEMODE(NULL, NULL, RwInt32 modeNum) + * rwDEVICESYSTEMFOCUS(NULL, NULL, RwBool gainFocus) + * rwDEVICESYSTEMINITPIPELINE(NULL, NULL, 0) + * rwDEVICESYSTEMGETMODE(RwInt32 *curMode, NULL, 0) + * rwDEVICESYSTEMSTANDARDS(RwStandardFunc *fnPtrArray, NULL, RwInt32 arraySize) + * rwDEVICESYSTEMGETTEXMEMSIZE(RwInt32 *texMemSizeOut, NULL, 0) + * rwDEVICESYSTEMGETNUMSUBSYSTEMS(RwInt32 *numSubSystemsOut, NULL, 0) + * rwDEVICESYSTEMGETSUBSYSTEMINFO(RwSubSystemInfo *subSystemInfo, NULL, RwInt32 subSystemNum) + * rwDEVICESYSTEMGETCURRENTSUBSYSTEM(RwInt32 *curSubSystem, NULL, 0) + * rwDEVICESYSTEMSETSUBSYSTEM(NULL, NULL, RwInt32 subSystemNum) + * rwDEVICESYSTEMFINALIZESTART(NULL, NULL, 0) + * rwDEVICESYSTEMINITIATESTOP(NULL, NULL, 0) + * rwDEVICESYSTEMRXPIPELINEREQUESTPIPE(RxPipeline **pipelineRef, NULL, RwInt32 pipeType) + * rwDEVICESYSTEMDD - start of device specific controls + */ + +#define rwPIPETYPEMATERIAL 0 +#define rwPIPETYPEWORLDSECTORINSTANCE 1 +#define rwPIPETYPEATOMICINSTANCE 2 + +enum RwCoreDeviceSystemFn +{ + rwDEVICESYSTEMOPEN = 0x00, + rwDEVICESYSTEMCLOSE, + rwDEVICESYSTEMSTART, + rwDEVICESYSTEMSTOP, + rwDEVICESYSTEMREGISTER, + rwDEVICESYSTEMGETNUMMODES, + rwDEVICESYSTEMGETMODEINFO, + rwDEVICESYSTEMUSEMODE, + rwDEVICESYSTEMFOCUS, + rwDEVICESYSTEMINITPIPELINE, + rwDEVICESYSTEMGETMODE, + rwDEVICESYSTEMSTANDARDS, + rwDEVICESYSTEMGETTEXMEMSIZE, + rwDEVICESYSTEMGETNUMSUBSYSTEMS, + rwDEVICESYSTEMGETSUBSYSTEMINFO, + rwDEVICESYSTEMGETCURRENTSUBSYSTEM, + rwDEVICESYSTEMSETSUBSYSTEM, + rwDEVICESYSTEMFINALIZESTART, + rwDEVICESYSTEMINITIATESTOP, + rwDEVICESYSTEMGETMAXTEXTURESIZE, + rwDEVICESYSTEMRXPIPELINEREQUESTPIPE, + rwDEVICESYSTEMGETMETRICBLOCK, + rwDEVICESYSTEMDD = 0x1000, + rwCOREDEVICESYSTEMFNFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwCoreDeviceSystemFn RwCoreDeviceSystemFn; + +/******************************************************************************/ +/********************* Standard functions *************************************/ +/******************************************************************************/ + +#define rwSTANDARDNASTANDARD 0 +#define rwSTANDARDCAMERABEGINUPDATE 1 /* Start 3d camera update */ +#define rwSTANDARDRGBTOPIXEL 2 /* For an RGB value return a pixel value */ +#define rwSTANDARDPIXELTORGB 3 /* For a pixel value returns a RGB value */ +#define rwSTANDARDRASTERCREATE 4 /* Create an raster */ +#define rwSTANDARDRASTERDESTROY 5 /* Raster destroy */ +#define rwSTANDARDIMAGEGETRASTER 6 /* Get image from a raster */ +#define rwSTANDARDRASTERSETIMAGE 7 /* Set raster from an image */ +#define rwSTANDARDTEXTURESETRASTER 8 /* Set texture's raster */ +#define rwSTANDARDIMAGEFINDRASTERFORMAT 9 /* Find a suitable raster format for an image */ +#define rwSTANDARDCAMERAENDUPDATE 10 /* End 3d camera update */ +#define rwSTANDARDSETRASTERCONTEXT 11 /* Start destination of 2d operations */ +#define rwSTANDARDRASTERSUBRASTER 12 /* Make a raster inside another raster */ +#define rwSTANDARDRASTERCLEARRECT 13 /* Clear a rectangle of the current dest raster */ +#define rwSTANDARDRASTERCLEAR 14 /* Clear the current dest raster */ +#define rwSTANDARDRASTERLOCK 15 /* Lock a raster to get it's pixels */ +#define rwSTANDARDRASTERUNLOCK 16 /* Unlock a raster to return it's pixels */ +#define rwSTANDARDRASTERRENDER 17 /* Render a raster (not scaled, but masked) */ +#define rwSTANDARDRASTERRENDERSCALED 18 /* Render a raster (scaled and masked) */ +#define rwSTANDARDRASTERRENDERFAST 19 /* Render a raster (not scaled or masked) */ +#define rwSTANDARDRASTERSHOWRASTER 20 /* Show a camera raster */ +#define rwSTANDARDCAMERACLEAR 21 /* Clear a camera's raster and/or Z raster */ +#define rwSTANDARDHINTRENDERF2B 22 /* Set hint for rendering direction in the world */ +#define rwSTANDARDRASTERLOCKPALETTE 23 /* Lock a raster to get it's palette */ +#define rwSTANDARDRASTERUNLOCKPALETTE 24 /* Unlock a raster to return it's palette */ +#define rwSTANDARDNATIVETEXTUREGETSIZE 25 /* Get size of native texture when written to a stream */ +#define rwSTANDARDNATIVETEXTUREREAD 26 /* Read native texture from the stream */ +#define rwSTANDARDNATIVETEXTUREWRITE 27 /* Write native texture to the stream */ +#define rwSTANDARDRASTERGETMIPLEVELS 28 /* Get the number of mip levels in a raster */ +#define rwSTANDARDNUMOFSTANDARD 29 + +/**************************************************************************** + Global Types + */ + +/* Standard functions */ +typedef RwBool (*RwStandardFunc)(void *pOut,void *pInOut,RwInt32 nI); + +typedef struct RwEngineOpenParams RwEngineOpenParams; + +/** + * \ingroup datatypes + * \struct RwEngineOpenParams + * This type is used to specify device dependent parameters + * for use by the API function \ref RwEngineOpen. + * For a Windows application the displayID field + * should be set to the window's handle (of type HWND). + * For NULL and sky libraries displayID=0: + */ +struct RwEngineOpenParams +{ + void *displayID; /**< Display Identifier */ +}; + +/* nOption is one of a list of possible System defines (see above) */ +typedef RwBool + (*RwSystemFunc)(RwInt32 nOption, + void *pOut, + void *pInOut, + RwInt32 nIn); + +/* Device block */ +typedef RwBool + (*RwRenderStateSetFunction)(RwRenderState nState,void *pParam); + +typedef RwBool + (*RwRenderStateGetFunction)(RwRenderState nState,void *pParam); + +typedef RwBool + (*RwIm2DRenderLineFunction)(RwIm2DVertex *vertices, + RwInt32 numVertices, + RwInt32 vert1, + RwInt32 vert2); + +typedef RwBool + (*RwIm2DRenderTriangleFunction)(RwIm2DVertex *vertices, + RwInt32 numVertices, + RwInt32 vert1, + RwInt32 vert2, + RwInt32 vert3); + +typedef RwBool + (*RwIm2DRenderPrimitiveFunction)(RwPrimitiveType primType, + RwIm2DVertex *vertices, + RwInt32 numVertices); + +typedef RwBool + (*RwIm2DRenderIndexedPrimitiveFunction)(RwPrimitiveType primType, + RwIm2DVertex *vertices, + RwInt32 numVertices, + RwImVertexIndex *indices, + RwInt32 numIndices); + +typedef RwBool + (*RwIm3DRenderLineFunction)(RwInt32 vert1, + RwInt32 vert2); + +typedef RwBool + (*RwIm3DRenderTriangleFunction)(RwInt32 vert1, + RwInt32 vert2, + RwInt32 vert3); + +typedef RwBool + (*RwIm3DRenderPrimitiveFunction)(RwPrimitiveType primType); + +typedef RwBool + (*RwIm3DRenderIndexedPrimitiveFunction)(RwPrimitiveType primtype, + RwImVertexIndex *indices, + RwInt32 numIndices); + + +typedef struct RwDevice RwDevice; +/** + * \ingroup datatypes + * \struct RwDevice + * Structure describing a display device + */ +struct RwDevice +{ + RwReal gammaCorrection; /**<Gamma correction */ + RwSystemFunc fpSystem; /**< System handler */ + RwReal zBufferNear; /**< Near Z buffer value */ + RwReal zBufferFar; /**< Far Z buffer value */ + + /* Immediate mode functions */ + RwRenderStateSetFunction fpRenderStateSet; /**< Internal Use */ + RwRenderStateGetFunction fpRenderStateGet; /**< Internal Use */ + + /* Render functions */ + RwIm2DRenderLineFunction fpIm2DRenderLine; /**< Internal Use */ + RwIm2DRenderTriangleFunction fpIm2DRenderTriangle; /**< Internal Use */ + RwIm2DRenderPrimitiveFunction fpIm2DRenderPrimitive; /**< Internal Use */ + RwIm2DRenderIndexedPrimitiveFunction fpIm2DRenderIndexedPrimitive; /**< Internal Use */ + + RwIm3DRenderLineFunction fpIm3DRenderLine; /**< Internal Use */ + RwIm3DRenderTriangleFunction fpIm3DRenderTriangle; /**< Internal Use */ + RwIm3DRenderPrimitiveFunction fpIm3DRenderPrimitive; /**< Internal Use */ + RwIm3DRenderIndexedPrimitiveFunction fpIm3DRenderIndexedPrimitive; /**< Internal Use */ +}; + +typedef struct RwMetrics RwMetrics; +/** + * \ingroup datatypes + * \struct RwMetrics + * This structure provides information about the performance + * of the application. The metrics are recorded only in the metrics + * libraries. To use metrics you should compile with the RWMETRICS + * preprocessor symbol defines, and link with the metrics libraries + * that ship with the SDK. The metrics are recorded on a per-frame + * basis. Each platform may provide additional information that + * is specific to that platform. Note that either the + * \ref numTextureUploads or \ref numResourceAllocs being non-zero can + * be considered as bad news and will indicate a significantly + * reduced rendering performance. + */ +struct RwMetrics +{ + RwUInt32 numTriangles; /**< Number of triangles processed */ + RwUInt32 numProcTriangles; /**< Number of mesh triangles processed */ + RwUInt32 numVertices; /**< Number of vertices processed */ + RwUInt32 numTextureUploads; /**< Number of textures swapped */ + RwUInt32 sizeTextureUploads; /**< Size of textures swapped */ + RwUInt32 numResourceAllocs; /**< Number of resource blocks swapped */ + void *devSpecificMetrics; /**< Device specific metrics */ +}; + +#define SUBSYSTEMNAME_MAXLEN 80 + +typedef struct RwSubSystemInfo RwSubSystemInfo; +/** + * \ingroup datatypes + * \struct RwSubSystemInfo + * This type is used to represent information about a device. + * The only available field specifies a character string + * which identifies the subsystem + * (see API function \ref RwEngineGetSubSystemInfo). */ +struct RwSubSystemInfo +{ + RwChar name[SUBSYSTEMNAME_MAXLEN]; /**< Sub system string */ +}; + + +/* Video modes */ +/* These are flag bits which may be ORd */ + +/** + * \ingroup datatypes + * RwVideoModeFlag + * These flags specify the type of display that RenderWare + * will use. The flags may be OR'd together to build composite modes. + * Note that not all modes are supported on all platforms. + */ +enum RwVideoModeFlag +{ + rwVIDEOMODEEXCLUSIVE = 0x1, /**<Exclusive (i.e. full-screen) */ + rwVIDEOMODEINTERLACE = 0x2, /**<Interlaced */ + rwVIDEOMODEFFINTERLACE = 0x4, /**<Flicker Free Interlaced */ + rwVIDEOMODEFSAA0 = 0x8, /**< \if sky2 + * Full-screen antialiasing mode 0 + * \endif */ + rwVIDEOMODEFSAA1 = 0x10, /**< \if sky2 + * Full-screen antialiasing mode 1 + * \endif */ + rwVIDEOMODEFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwVideoModeFlag RwVideoModeFlag; + +typedef struct RwVideoMode RwVideoMode; +/** + * \ingroup datatypes + * \struct RwVideoMode + * This type represents a video mode available on a device specified + * by the frame buffer resolution (width and height) and depth, + * and a flag indicating whether the device has exclusive use of + * the mode (see API function \ref RwEngineGetVideoModeInfo): */ +struct RwVideoMode +{ + RwInt32 width; /**< Width */ + RwInt32 height; /**< Height */ + RwInt32 depth; /**< Depth */ + RwVideoModeFlag flags; /**< Flags */ +}; + +/** + * \ingroup datatypes + * RwEngineInitFlag + * Engine initialization flags. An application can use + * these to control the memory manager that RenderWare uses for dynamic + * memory management. By default RenderWare uses FreeLists. This is the + * preferred way of using RenderWare. If the application does not want + * RenderWare to use the memory manager, then the application can pass + * rwENGINEINITNOFREELISTS as the argument to \ref RwEngineInit and + * RenderWare will replace freelist calls to corresponding calls to + * RwMalloc and RwFree. This will result in more memory management + * related calls. + */ +enum RwEngineInitFlag +{ + rwENGINEINITFREELISTS = 0, /**<Use Freelists */ + rwENGINEINITNOFREELISTS = 0x1, /**<Don't use Freelists */ + rwENGINEINITFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwEngineInitFlag RwEngineInitFlag; + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* Get the library binary version */ +extern RwInt32 RwEngineGetVersion(void); + +/* Sequence of events to get RenderWare up and running */ +extern RwBool RwEngineInit(RwMemoryFunctions *memFuncs, RwUInt32 initFlags, RwUInt32 resArenaSize); +extern RwInt32 RwEngineRegisterPlugin(RwInt32 size, RwUInt32 pluginID, + RwPluginObjectConstructor initCB, + RwPluginObjectDestructor termCB); +extern RwInt32 RwEngineGetPluginOffset(RwUInt32 pluginID); +extern RwBool RwEngineOpen(RwEngineOpenParams *initParams); +extern RwBool RwEngineStart(void); +extern RwBool RwEngineStop(void); +extern RwBool RwEngineClose(void); +extern RwBool RwEngineTerm(void); + +/* Finding out about the rendering sub systems available */ +extern RwInt32 RwEngineGetNumSubSystems(void); +extern RwSubSystemInfo *RwEngineGetSubSystemInfo(RwSubSystemInfo *subSystemInfo, RwInt32 subSystemIndex); +extern RwInt32 RwEngineGetCurrentSubSystem(void); +extern RwBool RwEngineSetSubSystem(RwInt32 subSystemIndex); + +/* Finding out about the modes available */ +extern RwInt32 RwEngineGetNumVideoModes(void); +extern RwVideoMode *RwEngineGetVideoModeInfo(RwVideoMode *modeinfo, RwInt32 modeIndex); +extern RwInt32 RwEngineGetCurrentVideoMode(void); +extern RwBool RwEngineSetVideoMode(RwInt32 modeIndex); + +/* Finding out how much texture memory is available */ +extern RwInt32 RwEngineGetTextureMemorySize(void); +extern RwInt32 RwEngineGetMaxTextureSize(void); + +/* Getting/Releasing the focus */ +extern RwBool RwEngineSetFocus(RwBool enable); + +/* Getting metrics */ +extern RwMetrics *RwEngineGetMetrics(void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/bafsys.h ---*/ + +/**************************************************************************** + Global Types + */ + +/* + * \typedef rwFnFexist + * Returns TRUE if file with given name exists, FALSE if it doesn't. + */ +typedef RwBool (*rwFnFexist)(const RwChar *name); + +/* + * \typedef rwFnFopen + * Mimics ANSI C Standard Library fopen. + */ +typedef void *(*rwFnFopen)(const RwChar *name, const RwChar *mode); + +/* + * \typedef rwFnFclose + * Mimics ANSI C Standard Library fclose. + */ +typedef int (*rwFnFclose)(void *fptr); + +/* + * \typedef rwFnFread + * Mimics ANSI C Standard Library fread. + */ +typedef size_t (*rwFnFread)(void *addr, size_t size, size_t count, void *fptr); + +/* + * \typedef rwFnFwrite + * Mimics ANSI C Standard Library fwrite. + */ +typedef size_t (*rwFnFwrite)(const void *addr, size_t size, size_t count, void *fptr); + +/* + * \typedef rwFnFgets + * Mimics ANSI C Standard Library fgets. + */ +typedef RwChar *(*rwFnFgets)(RwChar *buffer, int maxLen, void *fptr); + +/* + * \typedef rwFnFputs + * Mimics ANSI C Standard Library fputs. + */ +typedef int (*rwFnFputs)(const RwChar *buffer, void *fptr); + +/* + * \typedef rwFnFeof + * Mimics ANSI C Standard Library feof. + */ +typedef int (*rwFnFeof)(void *fptr); + +/* + * \typedef rwFnFseek + * Mimics ANSI C Standard Library fseek. + */ +typedef int (*rwFnFseek)(void *fptr, long offset, int origin); + +/* + * \typedef rwFnFflush + * Mimics ANSI C Standard Library fflush. + */ +typedef int (*rwFnFflush)(void *fptr); + +/* + * \typedef rwFnFtell + * Mimics ANSI C Standard Library ftell. + */ +typedef int (*rwFnFtell)(void *fptr); + + +/** + * \ingroup datatypes + * \typedef RwFileFunctions + * typedef for struct RwFileFunctions + */ +typedef struct RwFileFunctions RwFileFunctions; +/** + * \ingroup datatypes + * \struct RwFileFunctions + * This type is used to specify the file access + * functions used by RenderWare. The default file system uses the standard + * ANSI functions. The application may install an alternative file system + * providing it complies with the ANSI interface -- see API + * function \ref RwOsGetFileInterface. + * + * The function types associated with this type are defined as follows + * + * \verbatim + RwBool (*rwFnFexist)(const RwChar *name) + void *(*rwFnFopen)(const RwChar *name, const RwChar *access) + int (*rwFnFclose)(void *fptr) + size_t (*rwFnFread)(void *addr, size_t size, size_t count, void *fptr) + size_t (*rwFnFwrite)(const void *addr, size_t size, size_t count, + void *fptr) + RwChar *(*rwFnFgets)(RwChar *buffer, int maxLen, void *fptr) + int (*rwFnFputs)(const RwChar *buffer, void *fptr) + int (*rwFnFeof)(void *fptr) + int (*rwFnFseek)(void *fptr, long offset, int origin) + int (*rwFnFflush)(void *fptr) + int (*rwFnFtell)(void *fptr) + \endverbatim + * Note the function argument lists are consistent with the ANSI + * standard file access interface: + */ +struct RwFileFunctions +{ + rwFnFexist rwfexist; /**< Pointer to fexist function */ + rwFnFopen rwfopen; /**< Pointer to fopen function */ + rwFnFclose rwfclose; /**< Pointer to fclose function */ + rwFnFread rwfread; /**< Pointer to fread function */ + rwFnFwrite rwfwrite; /**< Pointer to fwrite function */ + rwFnFgets rwfgets; /**< Pointer to fgets function */ + rwFnFputs rwfputs; /**< Pointer to puts function */ + rwFnFeof rwfeof; /**< Pointer to feof function */ + rwFnFseek rwfseek; /**< Pointer to fseek function */ + rwFnFflush rwfflush; /**< Pointer to fflush function */ + rwFnFtell rwftell; /**< Pointer to ftell function */ +}; + + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RwFileFunctions *RwOsGetFileInterface(void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/baerr.h ---*/ +/**************************************************************************** + Global Types + */ + +typedef struct RwError RwError; +/** + * \ingroup datatypes + * \struct RwError + * This type represents a RenderWare error specified by the + * ID of the plugin that the error was issued from (pluginID) and the error + * code itself (errorCode) (see API function \ref RwErrorGet). + * \param pluginID The ID of the plugin that issued the error. + * \param errorCode A value representing the error code. + */ +struct RwError +{ + RwInt32 pluginID; /**< Internal Use */ + RwInt32 errorCode; /**< Internal Use */ +}; + +#define RWECODE(a,b) a, + +/* common errors have the MSB set */ + +enum RwErrorCodeCommon +{ + E_RW_NOERROR = (int)0x80000000L, +#include "errcom.def" + E_RW_LASTERROR = RWFORCEENUMSIZEINT +}; +typedef enum RwErrorCodeCommon RwErrorCodeCommon; + +#undef RWECODE + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RwError *RwErrorGet(RwError *code); +extern RwError *RwErrorSet(RwError *code); +extern RwInt32 _rwerror(RwInt32 code, ...); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/badebug.h ---*/ + +/**************************************************************************** + Global Types + */ + +/** + * \ingroup datatypes + * RwDebugType + * This type represents the different types of debug and + * trace messages that can be sent to the currently installed debug handler + * (see API function \ref RwDebugSendMessage)*/ +enum RwDebugType +{ + rwNADEBUGTYPE = 0, /**<Invalid */ + rwDEBUGASSERT, /**<Send an assert message */ + rwDEBUGERROR, /**<Send an error message */ + rwDEBUGMESSAGE, /**<Send an informational message */ + rwDEBUGTRACE, /**<Send a trace message */ + rwDEBUGTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwDebugType RwDebugType; + +/** + * \ingroup datatypes + * \ref RwDebugHandler + * This type represents the + * function called from \ref RwDebugSendMessage for sending a message to the + * RenderWare debug stream. + * + * \param type Type of debug message (assert, error, etc.). + * + * \param string Pointer to a string containing the error + * message. + * + * \see RwDebugSetHandler + */ +typedef void (*RwDebugHandler) (RwDebugType type, + + const RwChar * string); + +#ifdef RWDEBUG + +#define RwDebugSendMessage(type, funcName, message) \ + _rwDebugSendMessage(type, \ + RWSTRING(__FILE__), \ + __LINE__, \ + funcName, \ + message) + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* Setting the debug message handler */ +extern RwDebugHandler RwDebugSetHandler(RwDebugHandler handler); +extern void RwDebugSetTraceState(RwBool state); + +extern void _rwDebugSendMessage(RwDebugType type, + const RwChar * file, + const RwInt32 line, + const RwChar * funcName, + const RwChar * message); + +/* Sending a message */ +extern RwChar *_rwdberrcommon(RwInt32 code, ...); +extern RwChar *_rwdbsprintf(const RwChar * format, + ...) __RWFORMAT__(printf, 1, 2); + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#else /* RWDEBUG */ + +#define RwDebugSetHandler(handler) +#define RwDebugSetTraceState(state) +#define RwDebugSendMessage(type, funcName, message) + +#if (!defined(RWREGSETDEBUGTRACE)) +#define RWREGSETDEBUGTRACE(_name) /* No op */ +#endif /* (!defined(RWREGSETDEBUGTRACE)) */ + +#endif /* RWDEBUG */ + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/balibtyp.h ---*/ +/* Finding MSBs */ + +#define RWBYTEFINDMSB(a) \ + (_rwMsbBit[(a)]-1) + +#define RWWORDFINDMSB(a) \ + (((a)&0xff00)?RWBYTEFINDMSB((a)>>8)+8: RWBYTEFINDMSB(a)) + +#define RWLONGFINDMSB(a) \ + (((a)&0xffff0000UL)?RWWORDFINDMSB((a)>>16)+16: RWWORDFINDMSB(a)) + +/**************************************************************************** + Defines + */ + +/* macros used to access plugin data in objects */ +#define RWPLUGINOFFSET(_type, _base, _offset) \ + ((_type *)((RwUInt8 *)(_base) + (_offset))) + +#define RWPLUGINOFFSETCONST(_type, _base, _offset) \ + ((const _type *)((const RwUInt8 *)(_base) + (_offset))) + +/* macro used to access global data structure (the root type is RwGlobals) */ +#define RWSRCGLOBAL(variable) \ + (((RwGlobals *)RwEngineInstance)->variable) + +#define RWASSERTISTYPE(_f, _t) \ + RWASSERT((((const RwObject *)(_f))->type)==(_t)) + +/**************************************************************************** + Global Types + */ + +enum RwEngineStatus +{ + rwENGINESTATUSIDLE = 0, /* This needs to be zero */ + rwENGINESTATUSINITED = 1, + rwENGINESTATUSOPENED = 2, + rwENGINESTATUSSTARTED = 3, + rwENGINESTATUSFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RwEngineStatus RwEngineStatus; + +typedef struct RwGlobals RwGlobals; +struct RwGlobals +{ +#ifdef RWDEBUG + RwDebugHandler debugFunction; /* debug string handler */ + void *debugFile; /* debug output file */ + RwInt32 debugStackDepth; /* current depth of function stack */ + RwBool debugTrace; /* is function tracing enabled */ +#endif + + /* Current entities */ + void *curCamera; /* Current camera */ + void *curWorld; /* Current World */ + + /* Checking counters */ + RwUInt16 renderFrame; /* Camera display count */ + RwUInt16 lightFrame; /* Used to ensure each light is applied only once. */ + RwUInt16 pad[2]; /* Longword align it again */ + + /* For the currently accessed device */ + RwDevice dOpenDevice; + + /* Standard renderers and functions */ + RwStandardFunc stdFunc[rwSTANDARDNUMOFSTANDARD]; + + /* All of the frames which have been updated */ + RwLinkList dirtyFrameList; + + /* The file functions */ + RwFileFunctions fileFuncs; + + /* The string functions */ + RwStringFunctions stringFuncs; + + /* The memory allocation functions */ + RwMemoryFunctions memoryFuncs; +#ifdef RWDEBUG + RwBool freeListExtraDebug; +#endif /* RWDEBUG */ + + /* virtual memory alloc/free functions */ + RwMemoryAllocFn memoryAlloc; + RwMemoryFreeFn memoryFree; + + RwMetrics *metrics; + + /* Current engine status */ + RwEngineStatus engineStatus; + + /* Resource arena init size. */ + RwUInt32 resArenaInitSize; +}; + +typedef struct RwModuleInfo RwModuleInfo; +struct RwModuleInfo +{ + RwInt32 globalsOffset; + RwInt32 numInstances; +}; + + + +/**************************************************************************** + Program wide globals + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#ifdef RWGLOBALSIZE +extern RwUInt32 ourGlobals[RWGLOBALSIZE / sizeof(RwUInt32)]; +#define RwEngineInstance ourGlobals +#else /* RWGLOBALSIZE */ +extern void *RwEngineInstance; +#endif /* RWGLOBALSIZE */ + +extern RwInt8 _rwMsbBit[]; + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/baresour.h ---*/ + +#define RWRESOURCESGLOBAL(var) (RWPLUGINOFFSET(rwResourcesGlobals, \ + RwEngineInstance, resourcesModule.globalsOffset)->var) + +/** + * \ingroup datatypes + * \typedef RwResEntry + * RwResEntry object. Instanced data block in resources arena. + * This should be considered an opaque + * type. Use the RwResEntry API functions to access. + */ +typedef struct RwResEntry RwResEntry; + +/** + * \ingroup datatypes + * \typedef RwResEntryDestroyNotify + * This type represents the function + * called from \ref RwResourcesFreeResEntry (and indirectly from + * \ref RwResourcesEmptyArena) immediately before the memory used by the + * specified resources entry is released. + * + * \param resEntry Pointer to the instanced data. + */ +typedef void (*RwResEntryDestroyNotify) (RwResEntry * resEntry); + +#if (!defined(DOXYGEN)) +struct RwResEntry +{ + RwLLLink link; /**< Node in the list of resource elements */ + RwInt32 size; /**< Size of this node */ + void *owner; /**< Owner of this node */ + RwResEntry **ownerRef; /**< Pointer to pointer to this (enables de-alloc) */ + RwResEntryDestroyNotify destroyNotify; /**< This is called right before destruction */ +}; +#endif /* (!defined(DOXYGEN)) */ + +typedef struct rwResources rwResources; +struct rwResources +{ + RwInt32 maxSize; + RwInt32 currentSize; + RwInt32 reusageSize; + + void *memHeap; + + RwLinkList entriesA; + RwLinkList entriesB; + + RwLinkList *freeEntries; + RwLinkList *usedEntries; +}; + +typedef struct rwResourcesGlobals rwResourcesGlobals; +struct rwResourcesGlobals +{ + rwResources res; +}; + + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* Setting the resources arena size */ +extern RwBool RwResourcesSetArenaSize(RwUInt32 size); +extern RwInt32 RwResourcesGetArenaSize(void); +extern RwInt32 RwResourcesGetArenaUsage(void); +extern RwBool RwResourcesEmptyArena(void); + +/* Allocate */ +extern RwResEntry *RwResourcesAllocateResEntry(void *owner, + RwResEntry **ownerRef, + RwInt32 size, + RwResEntryDestroyNotify + destroyNotify); +/* Deallocate */ +extern RwBool RwResourcesFreeResEntry(RwResEntry * entry); +/* Mark all as unused */ +extern void _rwResourcesPurge(void); +#if ((defined(RWDEBUG)) || (defined(RWSUPPRESSINLINE))) +/* Mark as used */ +extern RwResEntry *RwResourcesUseResEntry(RwResEntry * entry); +#endif /* ((defined(RWDEBUG)) || (defined(RWSUPPRESSINLINE))) */ + +extern RwModuleInfo resourcesModule; + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#if ((!defined(RWDEBUG)) && (!defined(RWSUPPRESSINLINE))) +#define RwResourcesUseResEntry(_ntry) \ + ((((_ntry)->link.next)? \ + (rwLinkListRemoveLLLink(&((_ntry)->link)), \ + rwLinkListAddLLLink(RWRESOURCESGLOBAL(res.usedEntries), \ + &((_ntry)->link))): \ + NULL), \ + (_ntry)) +#endif /* ((!defined(RWDEBUG)) && (!defined(RWSUPPRESSINLINE))) */ + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/bacolor.h ---*/ +/**************************************************************************** + Global Types + */ + +typedef struct RwRGBAReal RwRGBAReal; +/** + * \ingroup datatypes + * \struct RwRGBAReal + * This structure represents a RGBA color which has + * components specified as real values. + * + * A color component of an RwRGBA with the value 255 generally corresponds + * to the associated component in an RwRGBAReal with the value 1.0f. + * However, any values can be substituted to denormalize/normalize + * RwRGBAReal and create different effects. For example, while light colors + * are expressed as normalized RGBA, interesting effects can be gained using + * larger values. + * + * It should also be noted that a color component of an RwRGBA with the + * value 0 generally corresponds to the associcated component in an + * RwRGBAReal with the value 0.0. + */ +struct RwRGBAReal +{ + RwReal red; /**< red component */ + RwReal green; /**< green component */ + RwReal blue; /**< blue component */ + RwReal alpha; /**< alpha component */ +}; + +#if (!defined(RwRGBARealAssign)) +#define RwRGBARealAssign(_target, _source) \ + ( *(_target) = *(_source) ) +#endif /* (!defined(RwRGBARealAssign)) */ + +typedef struct RwRGBA RwRGBA; +/** + * \ingroup datatypes + * \struct RwRGBA + * This structure represents a RGBA color + * which has integer components specified in the range 0 to 255. */ +struct RwRGBA +{ + RwUInt8 red; /**< red component */ + RwUInt8 green; /**< green component */ + RwUInt8 blue; /**< blue component */ + RwUInt8 alpha; /**< alpha component */ +}; + +#if (!defined(RwRGBAAssign)) +#define RwRGBAAssign(_target, _source) \ + ( *(_target) = *(_source) ) +#endif /* (!defined(RwRGBAAssign)) */ + +#define RwRGBARealAddMacro(o,a,b) \ +MACRO_START \ +{ \ + (o)->red = (((a)->red) + ( (b)->red)); \ + (o)->green = (((a)->green) + ( (b)->green)); \ + (o)->blue = (((a)->blue) + ( (b)->blue)); \ + (o)->alpha = (((a)->alpha) + ( (b)->alpha)); \ +} \ +MACRO_STOP + +#define RwRGBARealSubMacro(o,a,b) \ +MACRO_START \ +{ \ + (o)->red = (((a)->red) - ( (b)->red)); \ + (o)->green = (((a)->green) - ( (b)->green)); \ + (o)->blue = (((a)->blue) - ( (b)->blue)); \ + (o)->alpha = (((a)->alpha) - ( (b)->alpha)); \ +} \ +MACRO_STOP + +#define RwRGBARealScaleMacro(o,a,scale) \ +MACRO_START \ +{ \ + (o)->red = (((a)->red) * ( scale)); \ + (o)->green = (((a)->green) * ( scale)); \ + (o)->blue = (((a)->blue) * ( scale)); \ + (o)->alpha = (((a)->alpha) * ( scale)); \ +} \ +MACRO_STOP + +/* Conversion macros */ +#define RwRGBAFromRwRGBARealMacro(o, i) \ +MACRO_START \ +{ \ + RwInt32 quantize; \ + \ + quantize = RwInt32FromRealMacro( ((i)->red * (RwReal)255.0) \ + + (RwReal)0.5 ); \ + (o)->red = (RwUInt8) quantize; \ + quantize = RwInt32FromRealMacro( ((i)->green * (RwReal)255.0) \ + + (RwReal)0.5 ); \ + (o)->green = (RwUInt8) quantize; \ + quantize = RwInt32FromRealMacro( ((i)->blue * (RwReal)255.0) \ + + (RwReal)0.5 ); \ + (o)->blue = (RwUInt8) quantize; \ + quantize = RwInt32FromRealMacro( ((i)->alpha * (RwReal)255.0) \ + + (RwReal)0.5 ); \ + (o)->alpha = (RwUInt8) quantize; \ + \ +} \ +MACRO_STOP + +#define RwRGBARealFromRwRGBAMacro(o, i) \ +MACRO_START \ +{ \ + (o)->red = \ + (((RwReal)(((i)->red))) * ( (RwReal)((1.0/255.0)))); \ + (o)->green = \ + (((RwReal)(((i)->green))) * ( (RwReal)((1.0/255.0)))); \ + (o)->blue = \ + (((RwReal)(((i)->blue))) * ( (RwReal)((1.0/255.0)))); \ + (o)->alpha = \ + (((RwReal)(((i)->alpha))) * ( (RwReal)((1.0/255.0)))); \ +} \ +MACRO_STOP + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + + +#if (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )) + +#define RwRGBARealAdd(o,a,b) \ + RwRGBARealAddMacro(o,a,b) + +#define RwRGBARealSub(o,a,b) \ + RwRGBARealSubMacro(o,a,b) + +#define RwRGBARealScale(o,a,scale) \ + RwRGBARealScaleMacro(o,a,scale) + +#define RwRGBAFromRwRGBAReal(o, i) \ + RwRGBAFromRwRGBARealMacro(o, i) + +#define RwRGBARealFromRwRGBA(o, i) \ + RwRGBARealFromRwRGBAMacro(o, i) + +#else /* (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )) */ + +/* Function versions for debug */ +extern void RwRGBARealAdd(RwRGBAReal *result, + const RwRGBAReal *source1, + const RwRGBAReal *source2); + +extern void RwRGBARealSub(RwRGBAReal *result, + const RwRGBAReal *source1, + const RwRGBAReal *source2); + +extern void RwRGBARealScale(RwRGBAReal *result, + const RwRGBAReal *source, + RwReal scalar); + +extern void RwRGBAFromRwRGBAReal(RwRGBA *result, + const RwRGBAReal *source); + +extern void RwRGBARealFromRwRGBA(RwRGBAReal *result, + RwRGBA *source); + +#endif /* (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )) */ + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/babinmtx.h ---*/ + +/**************************************************************************** + Global types + */ + +/* Matrix stream format */ +typedef struct rwStreamMatrix RwMatrixChunkInfo; +typedef struct rwStreamMatrix rwStreamMatrix; +struct rwStreamMatrix +{ + RwV3d right; + RwV3d up; + RwV3d at; + RwV3d pos; + RwInt32 type; +}; + + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* Matrix binary format */ +extern RwUInt32 RwMatrixStreamGetSize(const RwMatrix * matrix); +extern RwMatrix *RwMatrixStreamRead(RwStream * stream, + RwMatrix * matrix); +extern const RwMatrix *RwMatrixStreamWrite(const RwMatrix * matrix, + RwStream * stream); +extern RwMatrixChunkInfo *RwMatrixChunkInfoRead(RwStream * stream, + RwMatrixChunkInfo * + matrixChunkInfo, + RwInt32 * bytesRead); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/src/plcore/babinary.h ---*/ +/**************************************************************************** + Defines + */ + +#ifndef rwCHUNKHEADERSIZE +#define rwCHUNKHEADERSIZE (sizeof(RwUInt32)*3) +#endif /* rwCHUNKHEADERSIZE */ + +/* Compatibility macro */ +#define RwStreamWriteInt(_stream, _ints, _numBytes) \ + RwStreamWriteInt32(_stream, _ints, _numBytes) + +#define RwStreamReadInt(_stream, _ints, _numBytes) \ + RwStreamReadInt32(_stream, _ints, _numBytes) + +#define RwMemLittleEndian(_mem, _size) \ + RwMemLittleEndian32(_mem, _size) + +#define RwMemNative(_mem, _size) \ + RwMemNative32(_mem, _size) + +/**************************************************************************** + Global Types + */ + +typedef struct RwChunkHeaderInfo RwChunkHeaderInfo; +/** + * \ingroup datatypes + * \struct RwChunkHeaderInfo + * Holds data for a chunk header read from a + * stream with \ref RwStreamReadChunkHeaderInfo. */ +struct RwChunkHeaderInfo +{ + RwUInt32 type; /**< chunk ID - see \ref RwStreamFindChunk */ + RwUInt32 length; /**< length of the chunk data in bytes */ + RwUInt32 version; /**< version of the chunk data. + * See \ref RwEngineGetVersion. */ + RwUInt32 buildNum; /**< build number of the RenderWare libraries + * previously used to stream out the data */ + RwBool isComplex; /**< Internal Use */ +}; + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* Chunk header stuff */ +extern RwBool RwStreamFindChunk(RwStream *stream, RwUInt32 type, + RwUInt32 *lengthOut, RwUInt32 *versionOut); + +#define RwStreamWriteChunkHeader(stream, type, size) \ + _rwStreamWriteVersionedChunkHeader( \ + stream, type, size, rwLIBRARYCURRENTVERSION, RWBUILDNUMBER) + +extern RwStream *_rwStreamWriteVersionedChunkHeader(RwStream *stream, + RwInt32 type, + RwInt32 size, + RwUInt32 version, + RwUInt32 buildNum); + +extern RwStream *RwStreamWriteReal(RwStream *stream, const RwReal *reals, + RwUInt32 numBytes); +extern RwStream *RwStreamWriteInt32(RwStream *stream, const RwInt32 *ints, + RwUInt32 numBytes); +extern RwStream *RwStreamWriteInt16(RwStream *stream, const RwInt16 *ints, + RwUInt32 numBytes); + +extern RwStream *RwStreamReadReal(RwStream *stream, RwReal *reals, + RwUInt32 numBytes); +extern RwStream *RwStreamReadInt32(RwStream *stream, RwInt32 *ints, + RwUInt32 numBytes); +extern RwStream *RwStreamReadInt16(RwStream *stream, RwInt16 *ints, + RwUInt32 numBytes); + +/* Binary Portability Functions */ +extern void *RwMemLittleEndian16(void *mem, RwUInt32 size); +extern void *RwMemLittleEndian32(void *mem, RwUInt32 size); +extern void *RwMemNative16(void *mem, RwUInt32 size); +extern void *RwMemNative32(void *mem, RwUInt32 size); +extern void *RwMemRealToFloat32(void *mem, RwUInt32 size); +extern void *RwMemFloat32ToReal(void *mem, RwUInt32 size); + +extern RwStream * +RwStreamReadChunkHeaderInfo(RwStream *stream, RwChunkHeaderInfo *chunkHeaderInfo); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* RWPLCORE_H */ |