diff options
Diffstat (limited to 'rwsdk/include/d3d8/rppatch.h')
| -rw-r--r-- | rwsdk/include/d3d8/rppatch.h | 683 |
1 files changed, 683 insertions, 0 deletions
diff --git a/rwsdk/include/d3d8/rppatch.h b/rwsdk/include/d3d8/rppatch.h new file mode 100644 index 00000000..eb80663f --- /dev/null +++ b/rwsdk/include/d3d8/rppatch.h @@ -0,0 +1,683 @@ + +#ifndef RPPATCH_H +#define RPPATCH_H + +/** + * \defgroup rppatch RpPatch + * \ingroup rpplugin + * + * Bezier patch library + * + * This library provides efficient evaluation of patches. + */ + +/*===========================================================================* + *--- Include files ---------------------------------------------------------* + *===========================================================================*/ +#include "rwcore.h" +#include "rpworld.h" + +#include "rpcriter.h" +#include "rppatch.rpe" + +/*===========================================================================* + *--- Defines ---------------------------------------------------------------* + *===========================================================================*/ + +/** + * \ingroup rppatch + * \def rpQUADPATCHNUMCONTROLPOINTS defines the number of control points in + * a quadrilateral patch. + * + * \see RpQuadPatch + * \see rpQUADPATCHNUMCONTROLINDICES + * \see RpPatchMeshSetQuadPatch + */ +#define rpQUADPATCHNUMCONTROLPOINTS (16) + +/** + * \ingroup rppatch + * \def rpTRIPATCHNUMCONTROLPOINTS defines the number of control points in + * a triangular patch. + * + * \see RpTriPatch + * \see rpTRIPATCHNUMCONTROLINDICES + * \see RpPatchMeshSetTriPatch + */ +#define rpTRIPATCHNUMCONTROLPOINTS (10) + +/** + * \ingroup rppatch + * \def rpQUADPATCHNUMCONTROLINDICES defines the number of control point + * indices in a \ref RpQuadPatch quadrilateral patch. + * + * \see rpQUADPATCHNUMCONTROLPOINTS + * \see RpPatchMeshSetQuadPatch + */ +#define rpQUADPATCHNUMCONTROLINDICES rpQUADPATCHNUMCONTROLPOINTS + +/** + * \ingroup rppatch + * \def rpTRIPATCHNUMCONTROLINDICES defines the number of control points + * indices in a \ref RpTriPatch triangular patch. + * + * \see rpTRIPATCHNUMCONTROLPOINTS + * \see RpPatchMeshSetTriPatch + */ +#define rpTRIPATCHNUMCONTROLINDICES rpTRIPATCHNUMCONTROLPOINTS + +/** + * \ingroup rppatch + * \def rpPATCHLODMAXVALUE defines the maximum value that can be returned for + * the patch evaluation LOD. + * + * \see rpPATCHSKINLODMAXVALUE + * \see rpPATCHLODMINVALUE + * \see RpPatchLODCallBack + */ +#define rpPATCHLODMAXVALUE (20) + +/** + * \ingroup rppatch + * \def rpPATCHSKINLODMAXVALUE defines the maximum value that can be returned + * for the skinned patch evaluation LOD. + * + * \see rpPATCHLODMAXVALUE + * \see rpPATCHLODMINVALUE + * \see RpPatchLODCallBack + */ +#define rpPATCHSKINLODMAXVALUE (18) + +/** + * \ingroup rppatch + * \def rpPATCHLODMINVALUE defines the minimum value that can be returned for + * the patch evaluation LOD. + * + * \see rpPATCHSKINLODMAXVALUE + * \see rpPATCHLODMAXVALUE + * \see RpPatchLODCallBack + */ +#define rpPATCHLODMINVALUE (4) + +/** + * \ingroup rppatch + * \def rpPATCHMESHTEXCOORDSETS Multi texture coordinate format specifier + * for \ref RpPatchMeshCreate(). This should be OR'd into the + * \ref RpPatchMeshFlag . + */ +#define rpPATCHMESHTEXCOORDSETS(_num) \ + ((_num & 0xff) << 16) + +/** + * \ingroup rppatch + * \def rpPATCHMESHLOCKTEXCOORDSIDX + * Convenience macro for generating a texture coordinate lock flag. + */ +#define rpPATCHMESHLOCKTEXCOORDSIDX(_idx) \ + (rpPATCHMESHLOCKTEXCOORDS1 << (_idx)) + +/*===========================================================================* + *--- Global Types ----------------------------------------------------------* + *===========================================================================*/ + +/** + * \ingroup rppatch + * \ref RpPatchMeshFlag + * When creating a \ref RpPatchMesh, these flags can be OR'ed together to + * specify the format along with the \ref rpPATCHMESHTEXCOORDSETS (n) macro + * to specify the number of texture coordinate sets required. + * + * \see RpPatchMeshCreate + */ +enum RpPatchMeshFlag +{ + rpNAPATCHMESHFLAG = 0, + rpPATCHMESHPOSITIONS = 0x01, /**<Patch mesh contains control point + positions. */ + rpPATCHMESHNORMALS = 0x02, /**<Patch mesh contains control point + normals. */ + rpPATCHMESHPRELIGHTS = 0x04, /**<Patch mesh contains control point + pre-light color values. */ + rpPATCHMESHTEXTURED = 0x08, /**<Patch mesh is textured. The number + of texture sets must also be + defined. */ + rpPATCHMESHLIGHT = 0x10, /**<Patch mesh will be lit. */ + rpPATCHMESHMODULATEMATERIALCOLOR = 0x20, + /**<Control point color will be + modulated with the material color. */ + rpPATCHMESHSMOOTHNORMALS = 0x40, + /**<Patch mesh normals will be + smoothed automatically. */ + rpPATCHMESHFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RpPatchMeshFlag RpPatchMeshFlag; + +/** + * \ingroup rppatch + * \ref RpPatchMeshLockMode patch mesh lock flags. + * + * \see rpPATCHMESHLOCKTEXCOORDSIDX + */ +enum RpPatchMeshLockMode +{ + rpNAPATCHMESHLOCKMODE = 0, + rpPATCHMESHLOCKPATCHES = 0x0001, /**<Lock the mesh patches. */ + rpPATCHMESHLOCKPOSITIONS = 0x0002, /**<Lock the control point + positions. */ + rpPATCHMESHLOCKNORMALS = 0x0004, /**<Lock the control point + normals. */ + rpPATCHMESHLOCKPRELIGHTS = 0x0008, /**<Lock the control point + pre-light color values. */ + rpPATCHMESHLOCKTEXCOORDS1 = 0x0100, /**<Lock the texture coordinates + set 1. */ + rpPATCHMESHLOCKTEXCOORDS2 = 0x0200, /**<Lock the texture coordinates + set 2. */ + rpPATCHMESHLOCKTEXCOORDS3 = 0x0400, /**<Lock the texture coordinates + set 3. */ + rpPATCHMESHLOCKTEXCOORDS4 = 0x0800, /**<Lock the texture coordinates + set 4. */ + rpPATCHMESHLOCKTEXCOORDS5 = 0x1000, /**<Lock the texture coordinates + set 5. */ + rpPATCHMESHLOCKTEXCOORDS6 = 0x2000, /**<Lock the texture coordinates + set 6. */ + rpPATCHMESHLOCKTEXCOORDS7 = 0x4000, /**<Lock the texture coordinates + set 7. */ + rpPATCHMESHLOCKTEXCOORDS8 = 0x8000, /**<Lock the texture coordinates + set 8. */ + rpPATCHMESHLOCKTEXCOORDSALL = 0xff00, /**<Lock all texture coordinate + sets. */ + rpPATCHMESHLOCKALL = 0xffff, /**<Combination of all the + above. */ + rpPATCHMESHLOCKMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RpPatchMeshLockMode RpPatchMeshLockMode; + +typedef struct RpPatchMeshDefinition RpPatchMeshDefinition; +/** + * \ingroup rppatch + * \struct RpPatchMeshDefinition + * holds the definition sizes of the patch mesh. This data should be considered + * read only. + */ +struct RpPatchMeshDefinition +{ + RwUInt32 flag; /**<Patch mesh definition flag. */ + RwUInt32 numControlPoints; /**<Number of control points. */ + RwUInt32 numTriPatches; /**<Number of tri patches. */ + RwUInt32 numQuadPatches; /**<Number of quad patches. */ + RwUInt32 numTexCoordSets; /**<Number of sets of texture coordinates. */ +}; + +typedef struct RpPatchMesh RpPatchMesh; +/** + * \ingroup rppatch + * \struct RpPatchMesh + * holds the control point data for a patch mesh. The patch mesh should be + * created with \ref RpPatchMeshCreate. The patch mesh should be locked with + * \ref RpPatchMeshLock before the data is edited. Quadrilateral and triangle + * patches can be defined from the control points with + * \ref RpPatchMeshSetQuadPatch and \ref RpPatchMeshSetTriPatch respectively. + * The patch mesh should be unlocked with \ref RpPatchMeshUnlock before it is + * added to an \ref RpAtomic with \ref RpPatchAtomicSetPatchMesh. + * + * \see RpPatchMesDefinition + */ +struct RpPatchMesh +{ + RwV3d *positions; /**<Control point positions. */ + RwV3d *normals; /**<Control point normals. */ + RwRGBA *preLightColors; /**<Control point pre-light colors. */ + RwTexCoords *texCoords[rwMAXTEXTURECOORDS]; + /**<Control point texture coordinates. */ + RpPatchMeshDefinition definition; /**<Patch mesh definition data. */ +}; + +typedef struct RpQuadPatch RpQuadPatch; +/** + * \ingroup rppatch + * \struct RpQuadPatch + * holds the control point indices for a quadrilateral patch. There are + * \ref rpQUADPATCHNUMCONTROLINDICES indices for a quadrilateral patch. + * + * \see RpPatchMeshSetQuadPatch + */ +struct RpQuadPatch +{ + RwUInt32 cpIndices[rpQUADPATCHNUMCONTROLINDICES]; /**<Control point + indices. */ +}; + +typedef struct RpTriPatch RpTriPatch; +/** + * \ingroup rppatch + * \struct RpTriPatch + * holds the control point indices for a triangle patch. There are + * \ref rpTRIPATCHNUMCONTROLINDICES indices for a triangular patch. + * + * \see RpPatchMeshSetTriPatch + */ +struct RpTriPatch +{ + RwUInt32 cpIndices[rpTRIPATCHNUMCONTROLINDICES]; /**<Control point + indices. */ +}; + +typedef struct RpPatchLODRange RpPatchLODRange; +/** + * \ingroup rppatch + * \struct RpPatchLODRange + * holds the variables used by the default atomic LOD call back function. + */ +struct RpPatchLODRange +{ + RwUInt32 minLod; /**<Minimum LOD value. */ + RwUInt32 maxLod; /**<Maximum LOD value. */ + RwReal minRange; /**<Minimum LOD range. */ + RwReal maxRange; /**<Maximum LOD range. */ +}; + +/** + * \ingroup rppatch + * \typedef RpPatchLODUserData + * typedef for the user data passed to the \ref RpPatchLODCallBack + * function which calculates the atomics' LOD. + * + * \see RpPatchAtomicSetPatchLODCallBack + * \see RpPatchAtomicGetPatchLODCallBack + */ +typedef void *RpPatchLODUserData; + +/** + * \ingroup rppatch + * \typedef RpPatchLODCallBack + * typedef for the patch atomic LOD calculation function. + * + * \see RpPatchAtomicSetPatchLODCallBack + * \see RpPatchAtomicGetPatchLODCallBack + */ +typedef RwUInt32 (* RpPatchLODCallBack)( RpAtomic *atomic, + RpPatchLODUserData userData ); + +/*===========================================================================* + *--- Plugin API Functions --------------------------------------------------* + *===========================================================================*/ +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/*---------------------------------------------------------------------------* + *- Plugin functions -* + *---------------------------------------------------------------------------*/ +extern RwBool +RpPatchPluginAttach(void); + +/*---------------------------------------------------------------------------* + *- Patch Mesh functions -* + *---------------------------------------------------------------------------*/ +extern RpPatchMesh * +RpPatchMeshCreate( RwUInt32 numQuadPatches, + RwUInt32 numTriPatches, + RwUInt32 numControlPoints, + RwUInt32 definitionFlag ); + +extern RwBool +RpPatchMeshDestroy( RpPatchMesh *patchMesh ); + +extern RpPatchMesh * +RpPatchMeshLock( RpPatchMesh *patchMesh, + RwUInt32 lockMode ); + +extern RpPatchMesh * +RpPatchMeshUnlock( RpPatchMesh *patchMesh ); + +/*---------------------------------------------------------------------------* + *- Patch mesh helper functions -* + *---------------------------------------------------------------------------*/ + +extern RpPatchMesh * +RpPatchMeshTransform( RpPatchMesh *patchMesh, + const RwMatrix *matrix ); + +/*---------------------------------------------------------------------------*/ +#define RpPatchMeshGetFlagsMacro(patchMesh) \ + (patchMesh->definition.flag) + +#define RpPatchMeshSetFlagsMacro(patchMesh, flags) \ + (patchMesh->definition.flag = flags) + +#define RpPatchMeshGetNumControlPointsMacro(patchMesh) \ + (patchMesh->definition.numControlPoints) + +#define RpPatchMeshGetNumTriPatchesMacro(patchMesh) \ + (patchMesh->definition.numTriPatches) + +#define RpPatchMeshGetNumQuadPatchesMacro(patchMesh) \ + (patchMesh->definition.numQuadPatches) + +#define RpPatchMeshGetNumTexCoordSetsMacro(patchMesh) \ + (patchMesh->definition.numTexCoordSets) + +#define RpPatchMeshGetPositionsMacro(patchMesh) \ + (patchMesh->positions) + +#define RpPatchMeshGetNormalsMacro(patchMesh) \ + (patchMesh->normals) + +#define RpPatchMeshGetPreLightColorsMacro(patchMesh) \ + (patchMesh->preLightColors) + +#define RpPatchMeshGetTexCoordsMacro(patchMesh, index) \ + (patchMesh->texCoords[index - 1]) +/*---------------------------------------------------------------------------*/ + +#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) + +/*---------------------------------------------------------------------------*/ +extern RwUInt32 +RpPatchMeshGetFlags( const RpPatchMesh *patchMesh ); + +extern RpPatchMesh * +RpPatchMeshSetFlags( RpPatchMesh *patchMesh, + RwUInt32 flags ); + +extern RwUInt32 +RpPatchMeshGetNumControlPoints( const RpPatchMesh *patchMesh ); + +extern RwUInt32 +RpPatchMeshGetNumTriPatches( const RpPatchMesh *patchMesh ); + +extern RwUInt32 +RpPatchMeshGetNumQuadPatches( const RpPatchMesh *patchMesh ); + +extern RwUInt32 +RpPatchMeshGetNumTexCoordSets( const RpPatchMesh *patchMesh ); + +extern RwV3d * +RpPatchMeshGetPositions( const RpPatchMesh *patchMesh ); + +extern RwV3d * +RpPatchMeshGetNormals( const RpPatchMesh *patchMesh ); + +extern RwRGBA * +RpPatchMeshGetPreLightColors( const RpPatchMesh *patchMesh ); + +extern RwTexCoords * +RpPatchMeshGetTexCoords( const RpPatchMesh *patchMesh, + RwTextureCoordinateIndex index ); +/*---------------------------------------------------------------------------*/ + +#else /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + +/*---------------------------------------------------------------------------*/ +#define RpPatchMeshGetFlags(patchMesh) \ + RpPatchMeshGetFlagsMacro(patchMesh) + +#define RpPatchMeshSetFlags(patchMesh, flags) \ + RpPatchMeshSetFlagsMacro(patchMesh, flags) + +#define RpPatchMeshGetNumControlPoints(patchMesh) \ + RpPatchMeshGetNumControlPointsMacro(patchMesh) + +#define RpPatchMeshGetNumTriPatches(patchMesh) \ + RpPatchMeshGetNumTriPatchesMacro(patchMesh) + +#define RpPatchMeshGetNumQuadPatches(patchMesh) \ + RpPatchMeshGetNumQuadPatchesMacro(patchMesh) + +#define RpPatchMeshGetNumTexCoordSets(patchMesh) \ + RpPatchMeshGetNumTexCoordSetsMacro(patchMesh) + +#define RpPatchMeshGetPositions(patchMesh) \ + RpPatchMeshGetPositionsMacro(patchMesh) + +#define RpPatchMeshGetNormals(patchMesh) \ + RpPatchMeshGetNormalsMacro(patchMesh) + +#define RpPatchMeshGetPreLightColors(patchMesh) \ + RpPatchMeshGetPreLightColorsMacro(patchMesh) + +#define RpPatchMeshGetTexCoords(patchMesh, index) \ + RpPatchMeshGetTexCoordsMacro(patchMesh, index) +/*---------------------------------------------------------------------------*/ + +#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + +/*---------------------------------------------------------------------------* + *- Patch streaming functions -* + *---------------------------------------------------------------------------*/ +extern RwUInt32 +RpPatchMeshStreamGetSize( const RpPatchMesh *patchMesh ); + +extern RpPatchMesh * +RpPatchMeshStreamRead( RwStream *stream ); + +extern const RpPatchMesh * +RpPatchMeshStreamWrite( const RpPatchMesh *patchMesh, + RwStream *stream ); + +/*---------------------------------------------------------------------------* + *- Patch Mesh patch functions -* + *---------------------------------------------------------------------------*/ +extern RpPatchMesh * +RpPatchMeshSetQuadPatch( RpPatchMesh *patchMesh, + RwUInt32 quadIndex, + RpQuadPatch *quadPatch ); + +extern RpPatchMesh * +RpPatchMeshSetTriPatch( RpPatchMesh *patchMesh, + RwUInt32 triIndex, + RpTriPatch *triPatch ); + +extern const RpQuadPatch * +RpPatchMeshGetQuadPatch( const RpPatchMesh *patchMesh, + RwUInt32 quadIndex ); + +extern const RpTriPatch * +RpPatchMeshGetTriPatch( const RpPatchMesh *patchMesh, + RwUInt32 triIndex ); + +/*---------------------------------------------------------------------------* + *- Patch Mesh material functions -* + *---------------------------------------------------------------------------*/ +extern RpPatchMesh * +RpPatchMeshSetQuadPatchMaterial( RpPatchMesh *patchMesh, + RwUInt32 quadIndex, + RpMaterial *material ); + +extern RpPatchMesh * +RpPatchMeshSetTriPatchMaterial( RpPatchMesh *patchMesh, + RwUInt32 triIndex, + RpMaterial *material ); + +extern RpMaterial * +RpPatchMeshGetQuadPatchMaterial( const RpPatchMesh *patchMesh, + RwUInt32 quadIndex ); + +extern RpMaterial * +RpPatchMeshGetTriPatchMaterial( const RpPatchMesh *patchMesh, + RwUInt32 triIndex ); + +extern const RpPatchMesh * +RpPatchMeshForAllMaterials( const RpPatchMesh *patchMesh, + RpMaterialCallBack callBack, + void *userData ); + +extern RwUInt32 +RpPatchMeshGetNumMaterials( const RpPatchMesh *patchMesh ); + +extern RpMaterial * +RpPatchMeshGetMaterial( const RpPatchMesh *patchMesh, + RwUInt32 materialIndex ); + +/*---------------------------------------------------------------------------* + *- Patch Skin functions -* + *---------------------------------------------------------------------------*/ +#if (defined(RPSKIN_H)) + +extern RpSkin * +RpPatchMeshGetSkin( RpPatchMesh *patchMesh ); + +extern RpPatchMesh * +RpPatchMeshSetSkin( RpPatchMesh *patchMesh, + RpSkin *skin ); + +#endif /* (defined(RPSKIN_H)) */ + +/*---------------------------------------------------------------------------* + *- Patch Atomic functions -* + *---------------------------------------------------------------------------*/ +extern RpAtomic * +RpPatchAtomicSetPatchMesh( RpAtomic *atomic, + RpPatchMesh *patchMesh ); + +extern RpPatchMesh * +RpPatchAtomicGetPatchMesh( const RpAtomic *atomic ); + +/*---------------------------------------------------------------------------* + *- Patch Atomic LOD functions -* + *---------------------------------------------------------------------------*/ +extern RwBool +RpPatchAtomicSetPatchLODCallBack( RpAtomic *atomic, + RpPatchLODCallBack callback, + RpPatchLODUserData userData ); + +extern RwBool +RpPatchAtomicGetPatchLODCallBack( const RpAtomic *atomic, + RpPatchLODCallBack *callback, + RpPatchLODUserData *userData ); + +/*---------------------------------------------------------------------------* + *- Patch default LOD range -* + *---------------------------------------------------------------------------*/ +extern RwBool +RpPatchSetDefaultLODCallBackRange( RpPatchLODRange *lodRange ); + +extern RwBool +RpPatchGetDefaultLODCallBackRange( RpPatchLODRange *lodRange ); + +/*---------------------------------------------------------------------------* + *- Patch pipeline -* + *---------------------------------------------------------------------------*/ + +/** + * \ingroup rppatch + * \ref RpPatchType defines the different ways a patch atomic can be rendered. + * Once a \ref RpPatchMesh has been attached to an \ref RpAtomic with + * \ref RpPatchAtomicSetPatchMesh the atomic must be setup with the correct + * rendering pipeline with \ref RpPatchAtomicSetType . + * + * The patch plugin makes no assumptions about how to render the + * patch atomics. Once an \ref RpPatchMesh has been attached to an + * \ref RpAtomic it is necessary to attach a suitable patch + * rendering pipeline. The patch plugin supports four different + * rendering types, these are defined in the \ref RpPatchType + * enumeration:- + * \li \ref rpPATCHTYPEGENERIC + * The patch \ref RpAtomic will be rendered with the + * default generic patch rendering pipeline. + * \li \ref rpPATCHTYPESKIN + * The patch \ref RpAtomic will be rendered with a + * custom pipeline for rendering skinning patches. Make sure + * an \ref RpSkin has been attached to the \ref RpPatchMesh + * and an \ref RpHAnimHierarchy has been attached to the + * \ref RpAtomic. + * \li \ref rpPATCHTYPEMATFX + * The patch \ref RpAtomic will be rendered with a + * custom pipeline for rendering the material effects + * of patches. The + * patch matfx pipeline supports all the material effects + * defined in the \ref rpmatfx plugin. The patches + * materials should be setup as usual. + * \li \ref rpPATCHTYPESKINMATFX + * The patch \ref RpAtomic will be rendered with a + * custom skinned material effects patch rendering pipeline. + * The \ref RpPatchMesh, \ref RpAtomic and the patches' + * \ref RpMaterial's must be setup correctly. + */ +enum RpPatchType +{ + rpNAPATCHTYPE = 0, /**<Invalid patch pipeline. */ + rpPATCHTYPEGENERIC = 1, /**<Generic patch rendering. */ + rpPATCHTYPESKIN = 2, /**<Skinned patch rendering. */ + rpPATCHTYPEMATFX = 3, /**<Material effects patch rendering. */ + rpPATCHTYPESKINMATFX = 4, /**<Skinned material effects patch rendering. */ + rpPATCHTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RpPatchType RpPatchType; + +extern RpAtomic * +RpPatchAtomicSetType( RpAtomic *atomic, + RpPatchType type ); + +extern RpPatchType +RpPatchAtomicGetType( const RpAtomic *atomic ); + +/*---------------------------------------------------------------------------*/ +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +/*---- start: ./d3d8/patchplatform.h----*/ + +/** + * \defgroup rppatchd3d8 D3D8 + * \ingroup rppatch + * + * D3D8 patch pipeline extension. + */ + + +/*===========================================================================* + *--- D3D8 Defines -----------------------------------------------------------* + *===========================================================================*/ + +/*===========================================================================* + *--- D3D8 Global Types ------------------------------------------------------* + *===========================================================================*/ + +/** + * \ingroup rppatchd3d8 + * \ref RpPatchD3D8Pipeline rendering pipelines available within the + * \ref rppatch plugin. Use \ref RpPatchGetD3D8Pipeline to retrieve + * the \ref RxPipeline s. + */ +enum RpPatchD3D8Pipeline +{ + rpPATCHD3D8PIPELINEGENERIC = 0, /**<D3D8 generic + patch rendering pipeline. */ + rpPATCHD3D8PIPELINEMATFX = 1, /**<D3D8 material effect + (single set of texture coordinates) + patch rendering pipeline. */ + rpPATCHD3D8PIPELINESKINNED = 2, /**<D3D8 skinned + patch rendering pipeline. */ + rpPATCHD3D8PIPELINESKINMATFX = 3, /**<D3D8 skinned material effect + (single set of texture coordinates) + patch rendering pipeline. */ + rpPATCHD3D8PIPELINEMAX, + rpPATCHD3D8PIPELINEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RpPatchD3D8Pipeline RpPatchD3D8Pipeline; + +/*===========================================================================* + *--- D3D8 Plugin API Functions ----------------------------------------------* + *===========================================================================*/ +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ +/*---------------------------------------------------------------------------*/ + +extern RxPipeline * +RpPatchGetD3D8Pipeline( RpPatchD3D8Pipeline d3d8Pipeline ); + +/*---------------------------------------------------------------------------*/ +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +/*---- end: ./d3d8/patchplatform.h----*/ + +#endif /* RPPATCH_H */ + + |