From 9e496100b7baff8834658f577d3138d9f8fc3765 Mon Sep 17 00:00:00 2001
From: aap <aap@papnet.eu>
Date: Sat, 18 May 2019 12:39:39 +0200
Subject: more work on CPhysical

---
 rwsdk/include/d3d8/rppatch.h | 683 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 683 insertions(+)
 create mode 100644 rwsdk/include/d3d8/rppatch.h

(limited to 'rwsdk/include/d3d8/rppatch.h')

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 */
+
+
-- 
cgit v1.2.3