mirror of
https://github.com/GTAmodding/re3.git
synced 2024-12-25 19:05:41 +00:00
6080 lines
228 KiB
C
6080 lines
228 KiB
C
/******************************************/
|
|
/* */
|
|
/* 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 */
|