#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 */