From a786dd45a4ebc6b91936b5e46d0ef0a9befc05af Mon Sep 17 00:00:00 2001
From: Sergeanur <s.anureev@yandex.ua>
Date: Sun, 2 Aug 2020 19:36:50 +0300
Subject: Move sdk and eax

---
 sdk/rwsdk/include/d3d8/rwcore.h | 4791 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 4791 insertions(+)
 create mode 100644 sdk/rwsdk/include/d3d8/rwcore.h

(limited to 'sdk/rwsdk/include/d3d8/rwcore.h')

diff --git a/sdk/rwsdk/include/d3d8/rwcore.h b/sdk/rwsdk/include/d3d8/rwcore.h
new file mode 100644
index 00000000..b9214c63
--- /dev/null
+++ b/sdk/rwsdk/include/d3d8/rwcore.h
@@ -0,0 +1,4791 @@
+/******************************************/
+/*                                        */
+/*    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/rwcore.h>
+ * Automatically Generated on: Wed Jul 10 10:45:00 2002
+ *
+ ************************************************************************/
+
+#ifndef RWCORE_H
+#define RWCORE_H
+
+/*--- System Header Files ---*/
+#include <rwplcore.h>
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/common/barwasmm.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2resort.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2macros.h ---*/
+
+#define RxClusterDecCursorByStride(_cluster, _stride)                           \
+    ((_cluster)->currentData =                                                  \
+      (void *)(((RwUInt8 *)(_cluster)->currentData) -                           \
+         (_stride)))
+
+#define RxClusterDecCursor(_cluster) \
+    RxClusterDecCursorByStride(_cluster, (_cluster)->stride)
+
+#define RxClusterIncCursorByStride(_cluster, _stride)                           \
+    ((_cluster)->currentData =                                                  \
+     (void *)(((RwUInt8 *)(_cluster)->currentData) +                            \
+              (_stride)))
+
+#define RxClusterIncCursor(_cluster) \
+    RxClusterIncCursorByStride(_cluster, (_cluster)->stride)
+
+#define RxClusterResetCursor(_cluster) \
+    ((_cluster)->currentData = (_cluster)->data)
+
+#define RxClusterGetCursorData(_cluster, _type) \
+    ((_type *)(_cluster)->currentData)
+
+#define RxClusterGetIndexedData(_cluster, _type, _index)                        \
+    ((_type *)(((RwUInt8 *)(_cluster)->data) + (_cluster)->stride*(_index)))
+
+#define RxClusterGetFreeIndex(_cluster) ( (_cluster)->numUsed++ )
+
+#define RxPipelineClusterAssertAttributeSet(_cluster, _attributeSet)    \
+    RWASSERT( (_cluster)->clusterRef->attributeSet != NULL &&           \
+              rwstrcmp((_cluster)->clusterRef->attributeSet,              \
+                     (_attributeSet)) == 0 )
+
+#define RxPipelineNodeParamGetData(_param) \
+    ( (_param)->dataParam )
+
+#define RxPipelineNodeParamGetHeap(_param) \
+    ( (_param)->heap )
+
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2heap.h ---*/
+
+#if (defined(RWDEBUG) && (defined(RWMEMDEBUG)))
+
+#if (!defined(DISABLERWHEAP))
+#define DISABLERWHEAP
+#endif /* (!defined(DISABLERWHEAP)) */
+
+#endif /* (defined(RWDEBUG) && (defined(RWMEMDEBUG))) */
+
+typedef struct rxHeapFreeBlock rxHeapFreeBlock;
+typedef struct rxHeapSuperBlockDescriptor rxHeapSuperBlockDescriptor;
+typedef struct RxHeap RxHeap;
+typedef struct rxHeapBlockHeader rxHeapBlockHeader;
+
+struct rxHeapFreeBlock
+{
+    RwUInt32            size;
+    rxHeapBlockHeader  *ptr;
+};
+
+struct rxHeapSuperBlockDescriptor
+{
+    void *start;
+    RwUInt32 size;
+    rxHeapSuperBlockDescriptor *next;
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxHeap 
+ * structure describing a pipeline execution heap 
+ */
+struct RxHeap
+{
+    RwUInt32            superBlockSize; /**< Granularity of heap growth */
+    rxHeapSuperBlockDescriptor *head;   /**< Internally used superblock pointer */
+    rxHeapBlockHeader  *headBlock;      /**< Internally used block pointer */
+    rxHeapFreeBlock    *freeBlocks;     /**< Internally used free blocks pointer */
+    RwUInt32            entriesAlloced; /**< Number of entries allocated */
+    RwUInt32            entriesUsed;    /**< Number of entries used */
+    RwBool              dirty;          /**< Internally used boolean, flags whether
+                                         *   the heap needs resetting or not. */
+};
+
+struct rxHeapBlockHeader
+{
+    /* present in all blocks (used & unused) */
+    rxHeapBlockHeader  *prev, *next;
+    RwUInt32            size;
+    rxHeapFreeBlock    *freeEntry; /* (or null) */
+    RwUInt32            pad[4]; /* alignment padding to 32 bytes */
+};
+
+/* This wrapper cheaply early-outs when a heap doesn't *need* resetting */
+#define RxHeapReset(heap) \
+    ((FALSE == (heap)->dirty) ? (TRUE) : (_rxHeapReset(heap)))
+
+#ifdef __cplusplus
+extern              "C"
+{
+#endif                          /* __cplusplus */
+
+extern RxHeap      *RxHeapCreate(RwUInt32 size);
+extern void         RxHeapDestroy(RxHeap * heap);
+extern RwBool       _rxHeapReset(RxHeap * heap);
+extern void        *RxHeapAlloc(RxHeap * heap, RwUInt32 size);
+extern void         RxHeapFree(RxHeap * heap, void *block);
+extern void        *RxHeapRealloc(RxHeap * heap, void *block,
+                                  RwUInt32 newSize, RwBool allowCopy);
+
+#ifdef __cplusplus
+}
+#endif                          /* __cplusplus */
+
+#if (defined(DISABLERWHEAP))
+
+typedef struct rxHeapMallocTrace rxHeapMallocTrace;
+struct rxHeapMallocTrace
+{
+    rxHeapMallocTrace *next;
+    rxHeapBlockHeader *block;
+};
+
+#endif                          /* (defined(DISABLERWHEAP)) */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2dep.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2core.h ---*/
+
+extern RwInt32 _rxPipelineMaxNodes;
+extern RwInt32 _rxHeapInitialSize;
+/* LEGACY-SUPPORT MACRO */
+#define _rwRxHeapInitialSize _rxHeapInitialSize
+
+/* Beneficial padding of PowerPipe types is still being worked out... */
+#define PADCLUSTERSx
+
+
+/*************************************************************
+ * Global Defines
+ */
+
+#define RWBOOLTOGGLE(bVar) ((bVar == FALSE)?(bVar = TRUE):(bVar = FALSE))
+
+/* Both these currently limited due to the use of RwUInt32 bit-fields */
+#define RXNODEMAXCLUSTERSOFINTEREST 32
+#define RXNODEMAXOUTPUTS            32
+
+/* Useful (for memory alloc) to limit this during pipeline construction */
+#define RXPIPELINEDEFAULTMAXNODES   64
+
+/*
+ * Cluster flags
+ */
+
+#define rxCLFLAGS_NULL          ((RwUInt16) 0x0000U)
+#define rxCLFLAGS_CLUSTERVALID  ((RwUInt16) 0x0001U)
+#define rxCLFLAGS_EXTERNAL ((RwUInt16) 0x0002U)
+#define rxCLFLAGS_EXTERNALMODIFIABLE ((RwUInt16) 0x0004U | 0x0002U)
+#define rxCLFLAGS_MODIFIED ((RwUInt16) 0x0008U)
+
+/*
+ * Packet flags
+ */
+
+#define rxPKFLAGS_NULL        ((RwUInt16) 0x0000U)
+
+/*
+ * used in input specification
+ */
+
+/**
+ * \ingroup rwcoregeneric
+ * \ref RxClusterValidityReq
+ * Flags specifying the state requirements for
+ * a \ref RxCluster on entry to a node */
+enum RxClusterValidityReq
+{
+    rxCLREQ_DONTWANT = 0, /**<The cluster is required but any data within it is
+                           * not wanted and will be overwritten */
+    rxCLREQ_REQUIRED = 1, /**<The cluster is required and it must contain
+                           * valid data */
+    rxCLREQ_OPTIONAL = 2, /**<The cluster will be used if it is present and
+                           * contains valid data, otherwise the node will
+                           * make do without it. */
+    rxCLUSTERVALIDITYREQFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+
+/**
+ * \ingroup rwcoregeneric
+ * \ref RxClusterValid
+ * Flags specifying the state requirements for
+ * a \ref RxCluster on exit from a node */
+enum RxClusterValid
+{
+    rxCLVALID_NOCHANGE = 0, /**<The cluster and its data will not change in
+                             * validity on passing through this node */
+    rxCLVALID_VALID = 1,    /**<The cluster and its data will be valid on
+                             * exit from this node */
+    rxCLVALID_INVALID = 2,  /**<The cluster's data will be invalid on
+                             * exit from this node */
+    rxCLUSTERVALIDFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+/****************************************************************************
+ Global Types
+ */
+
+typedef struct RxClusterDefinition RxClusterDefinition;
+
+typedef struct rxReq rxReq;
+
+typedef enum RxClusterValidityReq RxClusterValidityReq;
+typedef enum RxClusterValid RxClusterValid;
+typedef struct RxOutputSpec RxOutputSpec;
+typedef struct RxClusterRef RxClusterRef;
+typedef struct RxIoSpec RxIoSpec;
+
+typedef struct RxNodeMethods RxNodeMethods;
+typedef struct RxNodeDefinition RxNodeDefinition;
+
+typedef struct RxCluster RxCluster;
+typedef struct RxPipelineCluster RxPipelineCluster;
+typedef struct RxPacket RxPacket;
+typedef struct RxPipelineNode RxPipelineNode;
+typedef struct RxPipelineNodeTopSortData RxPipelineNodeTopSortData;
+typedef struct RxPipelineNode RxPipelineNodeInstance;
+typedef struct RxPipelineNodeParam RxPipelineNodeParam;
+typedef struct RxExecutionContext RxExecutionContext;
+typedef struct RxPipelineRequiresCluster RxPipelineRequiresCluster;
+typedef struct RxPipeline RxPipeline;
+
+/***************************************************************************
+ *
+ * C L U S T E R   D E F I N I T I O N
+ *
+ ***************************************************************************/
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxClusterDefinition
+ * Structure describing a cluster */
+struct RxClusterDefinition
+{
+    RwChar             *name;                  /**< Name */
+    RwUInt32            defaultStride;         /**< Default stride */
+    RwUInt32            defaultAttributes;     /**< Default attributes */
+    const RwChar         *attributeSet;           /**< Attribute set */
+};
+
+
+/***************************************************************************
+ *
+ * N O D E   D E F I N I T I O N   S T R U C T S
+ *
+ ***************************************************************************/
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxOutputSpec
+ * Structure describing an output specification of a node */
+struct RxOutputSpec
+{
+     RwChar             *name;                  /**< Name */
+     RxClusterValid     *outputClusters;        /**< States of clusters of interest on output */
+     RxClusterValid      allOtherClusters;      /**< States of clusters not of interest on output */
+};
+
+
+
+/**
+ * \ingroup rwcoregeneric
+ * \ref RxClusterForcePresent
+ *  Flags specifying whether an \ref RxCluster
+ * should be forced to be present in an \ref RxPipelineNode */
+enum RxClusterForcePresent
+{
+    rxCLALLOWABSENT = FALSE, /**<The cluster is allowed to be absent if no prior
+                              *  nodes create it and no subsequent nodes require it */
+    rxCLFORCEPRESENT = TRUE, /**<The cluster must be present even if no prior
+                              *  nodes create it and no subsequent nodes require it */
+
+    rxCLUSTERFORCEPRESENTFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RxClusterForcePresent RxClusterForcePresent;
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxClusterRef
+ * Structure describing a cluster reference */
+struct RxClusterRef
+{
+    RxClusterDefinition  *clusterDef;           /**< Cluster definition */
+    RxClusterForcePresent forcePresent;         /**< Specifies whether the cluster should be forced present */
+    RwUInt32              reserved;             /**< Omit or initialize to zero */
+};
+
+#define rxCLRESERVED       ((RwUInt32)0)
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxIoSpec
+ * Structure describing an input/output specification of a node */
+struct RxIoSpec
+{
+    RwUInt32              numClustersOfInterest;/**< Number of Clusters of interest */
+    RxClusterRef         *clustersOfInterest;   /**< Clusters of interest array */
+    RxClusterValidityReq *inputRequirements;    /**< Requirements of the clusters of interest on input to the node */
+    RwUInt32              numOutputs;           /**< Number of outputs from the node */
+    RxOutputSpec         *outputs;              /**< Output specification array */
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxNodeBodyFn
+ * is the callback to be
+ * called during pipeline execution -- and, typically, process
+ * \ref RxPacket's -- for the owning pipeline node.
+ *
+ * \param  self   A pointer to the pipeline node being executed
+ * \param  params   A pointer to a parameter structure
+ *
+ * \return TRUE on success, FALSE otherwise.
+ *
+ * \see RxNodeMethods
+ */
+typedef RwBool (*RxNodeBodyFn) (RxPipelineNode * self,
+                                const RxPipelineNodeParam *params);
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxNodeInitFn
+ * is the callback to be called,
+ * for the owning node definition, the first time an \ref RxPipeline
+ * referencing that node definition is unlocked.
+ *
+ * \param  self   A pointer to the node definition
+ *
+ * \return TRUE on success, FALSE otherwise.
+ *
+ * \see RxNodeMethods
+ */
+typedef RwBool (*RxNodeInitFn) (RxNodeDefinition * self);
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxNodeTermFn
+ * is the callback to be called,
+ * for the owning node definition, the last time an \ref RxPipeline
+ * referencing that node definition is destroyed or locked.
+ *
+ * \param  self   A pointer to the node definition
+ *
+ * \return None
+ *
+ * \see RxNodeMethods
+ */
+typedef void   (*RxNodeTermFn) (RxNodeDefinition * self);
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxPipelineNodeInitFn
+ * is the callback to be called, for the owning pipeline node, whenever a
+ * \ref RxPipeline containing that that pipeline node is unlocked.
+ *
+ * \param  self   A pointer to the pipeline node
+ *
+ * \return TRUE on success, FALSE otherwise.
+ *
+ * \see RxNodeMethods
+ */
+typedef RwBool (*RxPipelineNodeInitFn) (RxPipelineNode * self);
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxPipelineNodeTermFn
+ * is the callback to be called, for the owning pipeline node, whenever a
+ * \ref RxPipeline containing that that pipeline node is locked or
+ * destroyed.
+ *
+ * \param  self   A pointer to the pipeline node
+ *
+ * \return None
+ *
+ * \see RxNodeMethods
+ */
+typedef void   (*RxPipelineNodeTermFn) (RxPipelineNode * self);
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxPipelineNodeConfigFn
+ * is the callback to be called, for the owning pipeline node, whenever a
+ * \ref RxPipeline containing that that pipeline node is unlocked,
+ * *after* all \ref RxPipelineNodeInitFn's have been called for the
+ * pipeline in question. This func is to be used as described in
+ * RxPipelineNodeSendConfigMsg.
+ *
+ * \param  self   A pointer to the pipeline node
+ * \param  pipeline   A pointer to the containing pipeline
+ *
+ * \return TRUE on success, FALSE otherwise.
+ *
+ * \see RxNodeMethods
+ */
+typedef RwBool (*RxPipelineNodeConfigFn) (RxPipelineNode * self,
+                                          RxPipeline * pipeline);
+
+/* - removed from the API Reference  January 2002 -
+   typedef RxConfigMsgHandlerFn
+   is the callback to be called, for the owning pipeline node, whenever
+   a message is sent to it by the ref RxPipelineNodeConfigFn of another
+   pipeline node in the same pipeline. See ref RxPipelineNodeSendConfigMsg.
+  
+   param  self   A pointer to the pipeline node
+   param  msg   Message ID
+   param  intparam   Meaning is message-specific
+   param  ptrparam   Meaning is message-specific
+  
+   return A RwInt32 value, 0: unserviced; -ve: error; +ve: informative success
+  
+   see RxNodeMethods
+  */
+typedef RwUInt32 (*RxConfigMsgHandlerFn) (RxPipelineNode * self,
+                                          RwUInt32 msg,
+                                          RwUInt32 intparam,
+                                          void *ptrparam);
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxNodeMethods
+ * A structure describing a set
+ * of node methods
+ *
+ * \see RxNodeBodyFn
+ * \see RxNodeInitFn
+ * \see RxNodeTermFn
+ * \see RxPipelineNodeInitFn
+ * \see RxPipelineNodeTermFn
+ * \see RxPipelineNodeConfigFn
+ * \see RxConfigMsgHandlerFn
+ */
+struct RxNodeMethods
+{
+    RxNodeBodyFn         nodeBody;              /**< Node body function */
+    RxNodeInitFn         nodeInit;              /**< Node initialization function */
+    RxNodeTermFn         nodeTerm;              /**< Node termination function */
+    RxPipelineNodeInitFn pipelineNodeInit;      /**< Pipeline node initialization function */
+    RxPipelineNodeTermFn pipelineNodeTerm;      /**< Pipeline node termination function */
+    RxPipelineNodeConfigFn pipelineNodeConfig;  /**< Pipleline node configuation function */
+    RxConfigMsgHandlerFn configMsgHandler;      /**< Configuaraton message handler function */
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \ref RxNodeDefEditable
+ * Flags specifying whether an \ref RxNodeDefinition
+ * is editable or not (\ref RxPipelineNodeCloneDefinition,
+ * \ref RxPipelineNodeReplaceCluster and \ref RxPipelineNodeRequestCluster
+ * create editable copies of node definitions as the originals may be
+ * static definitions). */
+enum RxNodeDefEditable
+{
+    /**<This node definition should not be freed */
+    rxNODEDEFCONST = FALSE,
+    /**< This node definition is a temporary,
+     * modified copy of another and can be freed */
+    rxNODEDEFEDITABLE = TRUE,
+    rxNODEDEFEDITABLEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RxNodeDefEditable RxNodeDefEditable;
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxNodeDefinition
+ * A structure describing a node definition */
+struct RxNodeDefinition
+{
+    RwChar             *name;                   /**< Name */
+    RxNodeMethods       nodeMethods;            /**< Node methods */
+    RxIoSpec            io;                     /**< Input/output specification */
+    RwUInt32            pipelineNodePrivateDataSize; /**< Size in bytes of node's private data  */
+    RxNodeDefEditable   editable;               /**< Flags whether a node is editable */
+    RwInt32             InputPipesCnt;          /**< Count of the unlocked pipelines containing this node */
+};
+
+/***************************************************************************
+ *
+ * P I P E L I N E - E X E C U T I O N - T I M E   S T R U C T S
+ *
+ ***************************************************************************/
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPipelineCluster
+ * A structure describing a pipeline cluster;
+ * that is, an \ref RxClusterDefinition in the context of a specific \ref RxPipeline
+ * (in the same way as an \ref RxPipelineNode is an \ref RxNodeDefinition in the
+ * context of a specific \ref RxPipeline). The \ref RxCluster is the structure
+ * representing this and the \ref RxClusterDefinition within \ref RxPacket's at
+ * pipeline-execution-time */
+struct RxPipelineCluster
+{
+    RxClusterDefinition *clusterRef;            /**< Cluster refererence */
+    RwUInt32             creationAttributes;    /**< Creation Attributes */
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxCluster
+ * A structure describing a cluster; this is
+ * the representative of an \ref RxClusterDefinition and \ref RxPipelineCluster
+ * within \ref RxPacket's at pipeline-execution-time. */
+struct RxCluster
+{
+    RwUInt16            flags;                  /**< Bitfield of flags e.g. modification permissions */
+    RwUInt16            stride;                 /**< Stride in bytes of the cluster's data */
+    void               *data;                   /**< The Cluster's data */
+    void               *currentData;            /**< A 'cursor', referencing the current element in the data */
+    RwUInt32            numAlloced;             /**< Allocated count */
+    RwUInt32            numUsed;                /**< Used count */
+    RxPipelineCluster  *clusterRef;             /**< Valid after a cluster has been locked for writing,
+                                                 *   otherwise NULL. Analog of \ref RxPipelineNode and
+                                                 *   its 'nodeDef' member. */
+    RwUInt32            attributes;             /**< Attributes */
+#ifdef PADCLUSTERS
+    RwUInt32 pad[1];                            /**< Alignment padding */
+#endif
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPacket
+ * A structure describing a packet header */
+struct RxPacket
+{
+    RwUInt16            flags;                  /**< Flags to guide pipeline execution */
+    RwUInt16            numClusters;            /**< Maximum number of clusters simultanesouly present in the current pipeline */
+    RxPipeline         *pipeline;               /**< The pipeline in which this packet is embedded (the current pipeline) */
+    RwUInt32           *inputToClusterSlot;     /**< LUT to locate clusters of interest in the packet */
+    RwUInt32           *slotsContinue;          /**< Bitfields specifying clusters persisting to output node */
+    RxPipelineCluster **slotClusterRefs;        /**< Internal Use */
+#ifdef PADCLUSTERS
+    RwUInt32 pad[3];                            /**< Alignment padding */
+#endif
+    RxCluster           clusters[1];            /**< Cluster array large enough for widest part of the pipeline */
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPipelineNode
+ * Structure describing a pipeline Node;
+ * that is an \ref RxNodeDefinition in the context 
+ * of a specific \ref RxPipeline. 
+ */
+struct RxPipelineNode
+{
+    RxNodeDefinition   *nodeDef;            /**< Node definition reference */
+    RwUInt32            numOutputs;         /**< Output count */
+    RwUInt32           *outputs;            /**< Output array, indexing the pipeline's array of pipeline nodes */
+    RxPipelineCluster **slotClusterRefs;    /**< For packets passing through this node, SlotClusterRefs[n]
+                                             * identifies the cluster to be found at index n in the packet's
+                                             * Clusters[] array. These assignments are determined at pipeline
+                                             * Unlock() time and are good for the life of the pipeline. */
+    RwUInt32           *slotsContinue;      /**< Cluster persistence table for the node's outputs */
+    void               *privateData;        /**< Pointer to the pipeline Node's private data */
+    RwUInt32           *inputToClusterSlot; /**< LUT to locate clusters of interest in packets passing through this pipeline Node */
+    RxPipelineNodeTopSortData *topSortData; /**< Internal Use */
+    void               *initializationData; /**< Used by the pipeline node initialisation
+                                             * function in setting up the Private data. */
+    RwUInt32        initializationDataSize; /**< Present so that if the node is cloned
+                                             * we can copy the initialisation data. */
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPipelineNodeTopSortData
+ * Structure describing data used during topological sorting 
+ * during \ref RxLockedPipeUnlock ; 
+ * RenderWare users do not need to understand this */
+struct RxPipelineNodeTopSortData
+{
+    RwUInt32            numIns;                 /**< Input count */
+    RwUInt32            numInsVisited;          /**< Count of inputs visited during dependencies
+                                                 * propagation/cluster slot allocation */
+    rxReq              *req;                    /**< Req used in dependencies propagation/cluster
+                                                 * slot allocation */
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPipelineNodeParam
+ * Structure holding parameters
+ * to pass to node body functions */
+struct RxPipelineNodeParam
+{
+    void   *dataParam;   /**< The data pointer passed in to \ref RxPipelineExecute */
+    RxHeap *heap;        /**< The heap associated with the current pipeline exeuction */
+};
+
+enum rxEmbeddedPacketState
+{
+    rxPKST_PACKETLESS = 0, /* Packet not created */
+    rxPKST_UNUSED     = 1, /* Packet created and then destroyed */
+    rxPKST_INUSE      = 2, /* Packet created but not yet destroyed and fetched but not yet dispatched */
+    rxPKST_PENDING    = 3, /* Packet created but not destroyed and dispatched but not yet fetched */
+    rxEMBEDDEDPACKETSTATEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum rxEmbeddedPacketState rxEmbeddedPacketState;
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxExecutionContext
+ * Structure describing an execution context */
+struct RxExecutionContext
+{
+    RxPipeline           *pipeline;     /**< Currently executing pipeline */
+    RxPipelineNode       *currentNode;  /**< Currently executing node */
+    RwInt32               exitCode;     /**< Used internally for nodes returning error codes on exit */
+    RwUInt32              pad;          /**< Alignment padding */
+    RxPipelineNodeParam   params;       /**< The parameters passed to node bodies */
+    /*RwUInt32              pad[2];*/
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPipelineRequiresCluster
+ * Structure describing a pipeline requirement of a cluster */
+struct RxPipelineRequiresCluster
+{
+    RxClusterDefinition *clusterDef;    /**< Reference to a Cluster definition */
+    RxClusterValidityReq rqdOrOpt;      /**< Cluster validity requirement (rxCLREQ_DONTWANT, rxCLREQ_REQUIRED or rxCLREQ_OPTIONAL) */
+    RwUInt32             slotIndex;     /**< Index into the packet's cluster array within this pipeline */
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPipeline
+ * Structure describing a pipeline */
+struct RxPipeline
+{
+    RwBool                     locked;                /**< Flags whether the pipeline is locked for editing */
+    RwUInt32                   numNodes;              /**< Node count */
+    RxPipelineNode            *nodes;                 /**< Topologically sorted array of pipeline nodes */
+    RwUInt32                   packetNumClusterSlots; /**< Number of slots allocated for clusters */
+    rxEmbeddedPacketState      embeddedPacketState;   /**< The state of this pipeline's embedded packet */
+    RxPacket                  *embeddedPacket;        /**< This pipeline's embedded packet */
+
+    RwUInt32                   numInputRequirements;  /**< Input requirements count */
+    RxPipelineRequiresCluster *inputRequirements;     /**< Input requirements array */
+
+    void                      *superBlock;            /**< Internally used block of memory */
+    RwUInt32                   superBlockSize;        /**< Internally used block of memory */
+
+    RwUInt32                   entryPoint;            /**< The index of the node which is the entry point of this pipeline */
+    RwUInt32                   pluginId;              /**< If required, the Id of the plugin owning this pipeline, or 0 */
+    RwUInt32                   pluginData;            /**< Rights callback extra data */
+};
+
+/****************************************************************************
+ * Global Prototypes
+ */
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxPipelineNodeOutputCallBack 
+ * is the callback function supplied 
+ * to \ref RxPipelineNodeForAllConnectedOutputs.
+ *
+ * The callback will be passed a pointer to the \ref RxPipelineNode whose
+ * outputs are being traversed and a pointer to the current output
+ * \ref RxPipelineNode, as well as a pointer to an optional user-defined
+ * data structure (callbackdata). If no such structure was specified, this
+ * will be NULL.
+ *
+ * \param  node   A pointer to the pipeline node whose outputs
+ * are being traversed
+ * \param  outputnode   A pointer to the current output
+ * pipeline node
+ * \param  callbackdata   A pointer to optional user-supplied data
+ *
+ * \return Returns a pointer to the \ref RxPipelineNode whose outputs are being
+ * traversed, or NULL to terminate traversal
+ */
+typedef RxPipelineNode * (*RxPipelineNodeOutputCallBack) (RxPipelineNode * node,
+                                                  RxPipelineNode * outputnode,
+                                                  void *callbackdata);
+
+#ifdef RWDEBUG
+#define RXCHECKFORUSERTRAMPLING(_pipeline)                       \
+    ( _rwPipelineCheckForTramplingOfNodePrivateSpace(_pipeline) )
+#endif /* RWDEBUG */
+
+#if (!defined(RXCHECKFORUSERTRAMPLING))
+#define RXCHECKFORUSERTRAMPLING(_pipeline) /* No op */
+#endif /* (!defined(RXCHECKFORUSERTRAMPLING)) */
+
+
+#ifdef    __cplusplus
+extern              "C"
+{
+#endif                          /* __cplusplus */
+
+extern RwBool
+_rxPipelineOpen(void);
+
+extern RwBool
+_rxPipelineClose(void);
+
+extern RwBool
+rxPipelinePluginsAttach(void);
+
+extern RxPipeline *
+RxPipelineCreate(void);
+
+
+extern void
+_rxPipelineDestroy(RxPipeline * Pipeline);
+
+#define _RxPipelineDestroy(_ppln)  _rxPipelineDestroy(_ppln)
+#define RxPipelineDestroy(_ppln) (_rxPipelineDestroy(_ppln), TRUE)
+
+extern RxHeap      *
+RxHeapGetGlobalHeap(void);
+
+extern RxPipeline *
+RxPipelineExecute(RxPipeline  * pipeline,
+                  void        * data,
+                  RwBool       heapReset);
+
+extern RxPacket *
+RxPacketCreate(RxPipelineNode * node);
+
+extern RxCluster   *
+RxClusterSetStride(RxCluster * cluster,
+                   RwInt32 stride);
+
+extern RxCluster   *
+RxClusterSetExternalData(RxCluster * cluster,
+                         void *data,
+                         RwInt32 stride,
+                         RwInt32 numElements);
+
+extern RxCluster   *
+RxClusterSetData(RxCluster * cluster,
+                 void *data,
+                 RwInt32 stride,
+                 RwInt32 numElements);
+
+/* underlying PacketDestroy function */
+extern void
+_rxPacketDestroy(RxPacket * Packet);
+
+/* more convenient parameterization */
+#define RxPacketDestroy(pk, self) \
+    ( _rxPacketDestroy(pk) )
+
+#if (defined(RWDEBUG))
+extern RxPacket *RxPacketFetch(RxPipelineNode * Node);
+extern void      RxPacketDispatch(RxPacket * packet,
+                                  RwUInt32 output,
+                                  RxPipelineNode * self);
+extern void      RxPacketDispatchToPipeline(RxPacket * packet,
+                                            RxPipeline * dest,
+                                            RxPipelineNode * self);
+#else /* (defined(RWDEBUG)) */
+#define RxPacketFetch(_self) \
+    rxPacketFetchMacro(_self)
+#define RxPacketDispatch(     _packet, _output, _self) \
+    rxPacketDispatchMacro(_packet, _output, _self)
+#define RxPacketDispatchToPipeline(     _packet, _pipeline, _self) \
+    rxPacketDispatchToPipelineMacro(_packet, _pipeline, _self)
+#endif /* (defined(RWDEBUG)) */
+
+#define RxClusterInitialiseData(_clstr, _nmlmnts, _strd) \
+    ( RxClusterInitializeData((_clstr), (_nmlmnts), (_strd)) )
+extern RxCluster   *
+RxClusterInitializeData(RxCluster *cluster, RwUInt32 numElements, RwUInt16 stride);
+
+extern RxCluster   *
+RxClusterResizeData(RxCluster *CurrentCluster, RwUInt32 NumElements);
+
+extern RxCluster   *
+RxClusterDestroyData(RxCluster *CurrentCluster);
+
+#if (defined(RWDEBUG))
+
+extern RxCluster *RxClusterLockRead(RxPacket * packet, RwUInt32 clusterIndex);
+
+#else  /* !RWDEBUG */
+
+#define RXCLSLOT(PKT, CLIND)             \
+    ((PKT)->inputToClusterSlot[(CLIND)])
+
+#define RxClusterLockRead(PKT, CLIND)                               \
+    ( (((RwInt32)RXCLSLOT(PKT, CLIND)) == -1) ?                     \
+      ((RxCluster *)NULL) :                                         \
+      (RxClusterResetCursor(&PKT->clusters[RXCLSLOT(PKT, CLIND)]),  \
+       &PKT->clusters[RXCLSLOT(PKT, CLIND)]) )
+
+#endif /* !RWDEBUG */
+
+extern RxCluster   *
+RxClusterLockWrite(RxPacket * packet,
+                   RwUInt32 clusterIndex,
+                   RxPipelineNode * node);
+
+extern void
+RxClusterUnlock(RxCluster * cluster);
+
+extern RwUInt32
+RxPipelineNodeSendConfigMsg(RxPipelineNode * dest,
+                            RwUInt32 msg,
+                            RwUInt32 intparam,
+                            void *ptrparam);
+
+extern RxPipelineNode *
+RxPipelineNodeForAllConnectedOutputs(RxPipelineNode * node,
+                                     RxPipeline * pipeline,
+                                     RxPipelineNodeOutputCallBack callbackfn,
+                                     void *callbackdata);
+
+/* Cluster attributes api [pipeline construction time] */
+
+extern RxPipelineCluster *
+RxPipelineNodeGetPipelineCluster(RxPipelineNode *node,
+                                   RwUInt32 clustersOfInterestIndex);
+
+extern RwUInt32
+RxPipelineClusterGetCreationAttributes(RxPipelineCluster *cluster);
+
+extern RxPipelineCluster *
+RxPipelineClusterSetCreationAttributes(RxPipelineCluster *cluster,
+                                         RwUInt32 creationAttributes);
+
+/* Cluster attributes api [pipeline execution time] */
+
+extern RwUInt32
+RxClusterGetAttributes(RxCluster *cluster);
+
+extern RxCluster *
+RxClusterSetAttributes(RxCluster *cluster, RwUInt32 attributes);
+
+
+extern void
+_rxEmbeddedPacketBetweenPipelines(RxPipeline * fromPipeline,
+                                 RxPipeline * toPipeline);
+
+extern RxPipelineNode *
+_rxEmbeddedPacketBetweenNodes(RxPipeline     *pipeline,
+                             RxPipelineNode *nodeFrom,
+                             RwUInt32        whichOutput);
+
+extern RxExecutionContext _rxExecCtxGlobal;
+
+/* Summary of dispatch rules:
+ * o nodes that never fetch are safe to dispatch NULL, whether
+ *   nodes above pass them a packet or not
+ * o if you destroy the packet you can dispatch(NULL,,)
+ * o if you fetch/create and dispatch(NULL), it doesn't really
+ *   matter - the packet'll get passed on anyway */
+
+/* TODO: there's currently no way to prematurely terminate the pipeline
+ *      without doing so as an error condition. You should create an
+ *      enum for the exit code, either RXNODEEXITCONTINUE, RXNODEEXITTERMINATE
+ *      or RXNODEEXTTERMINATEERROR and then test for RXNODEEXITCONTINUE in
+ *      the below macros rather than FALSE. */
+
+/* TODO: _packet redundant here... create a new macro and legacy wrapper */
+#define rxPacketDispatchMacro(_packet, _output, _self)                      \
+MACRO_START                                                                 \
+{                                                                           \
+    RxPipeline *curPipeline = _rxExecCtxGlobal.pipeline;                    \
+                                                                            \
+    /* _packet is now an obsolete parameter */                              \
+                                                                            \
+    if ( FALSE != _rxExecCtxGlobal.exitCode )                               \
+    {                                                                       \
+        RxPipelineNode *nextNode =                                          \
+            _rxEmbeddedPacketBetweenNodes(curPipeline,                      \
+                                         _self,                             \
+                                         (_output));                        \
+        if ( nextNode != NULL )                                             \
+        {                                                                   \
+            RwUInt32 exitCode =                                             \
+                nextNode->nodeDef->nodeMethods.nodeBody(                    \
+                    nextNode, &(_rxExecCtxGlobal.params));                  \
+            /* Don't overwrite 'error' with 'success' */                    \
+            if (FALSE == exitCode) _rxExecCtxGlobal.exitCode = exitCode;    \
+        }                                                                   \
+    }                                                                       \
+    if ( curPipeline->embeddedPacketState > rxPKST_UNUSED                   \
+         /* !UNUSED and !PACKETLESS */ )                                    \
+    {                                                                       \
+        curPipeline->embeddedPacketState = rxPKST_INUSE;                    \
+        _rxPacketDestroy(curPipeline->embeddedPacket);                      \
+    }                                                                       \
+}                                                                           \
+MACRO_STOP
+
+/* TODO: _self redundant here... create a new macro and legacy wrapper */
+#define rxPacketDispatchToPipelineMacro(_packet, _pipeline, _self)          \
+MACRO_START                                                                 \
+{                                                                           \
+    RxPipeline *toPipeline = (_pipeline);                                   \
+                                                                            \
+    /* _packet is now an obsolete parameter */                              \
+                                                                            \
+    if ( FALSE != _rxExecCtxGlobal.exitCode )                               \
+    {                                                                       \
+        RwUInt32 exitCode;                                                  \
+        RxPipeline *fromPipeline = _rxExecCtxGlobal.pipeline; /* save */    \
+        _rxEmbeddedPacketBetweenPipelines(fromPipeline,                     \
+                                         toPipeline);                       \
+        _rxExecCtxGlobal.pipeline = toPipeline; /* modify */                \
+        exitCode =                                                          \
+            toPipeline->nodes[0].nodeDef->nodeMethods.nodeBody(             \
+                &toPipeline->nodes[0], &(_rxExecCtxGlobal.params));         \
+        if ( FALSE == exitCode ) _rxExecCtxGlobal.exitCode = exitCode;      \
+        _rxExecCtxGlobal.pipeline = fromPipeline; /* restore */             \
+    }                                                                       \
+    if ( toPipeline->embeddedPacketState > rxPKST_UNUSED                    \
+         /* !UNUSED and !PACKETLESS */ )                                    \
+    {                                                                       \
+        toPipeline->embeddedPacketState = rxPKST_INUSE;                     \
+        _rxPacketDestroy(toPipeline->embeddedPacket);                       \
+    }                                                                       \
+}                                                                           \
+MACRO_STOP
+
+#define rxPacketFetchMacro(_node)                                           \
+    ( ((_rxExecCtxGlobal.pipeline)->embeddedPacketState == rxPKST_PENDING) ?\
+      ((_rxExecCtxGlobal.pipeline)->embeddedPacketState = rxPKST_INUSE,     \
+       (_rxExecCtxGlobal.pipeline)->embeddedPacket) :                       \
+      (NULL) )
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/d3d8/nodeD3D8SubmitNoLight.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2define.h ---*/
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxNodeOutput 
+ * typedef for a reference to an output of a pipeline node */
+typedef RwUInt32       *RxNodeOutput;
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxNodeInput 
+ *  typedef for a reference to the input of a pipeline node */
+typedef RxPipelineNode *RxNodeInput;
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxLockedPipe
+ * typedef for a reference to a locked pipeline 
+ */
+typedef RxPipeline      RxLockedPipe;
+
+
+#ifdef    __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+
+/* PIPELINENODE API */
+
+extern RxNodeOutput
+RxPipelineNodeFindOutputByName(RxPipelineNode *node,
+                               const RwChar *outputname);
+
+extern RxNodeOutput
+RxPipelineNodeFindOutputByIndex(RxPipelineNode *node,
+                                RwUInt32 outputindex);
+
+extern RxNodeInput
+RxPipelineNodeFindInput(RxPipelineNode *node);
+
+extern RxNodeDefinition *
+RxPipelineNodeCloneDefinition(RxPipelineNode *node,
+                              RxClusterDefinition *cluster2add);
+
+extern RxPipeline *
+RxPipelineNodeRequestCluster(RxPipeline *pipeline,
+                             RxPipelineNode *node,
+                             RxClusterDefinition *clusterDef);
+
+extern RxPipeline *
+RxPipelineNodeReplaceCluster(RxPipeline *pipeline,
+                             RxPipelineNode *node,
+                             RxClusterDefinition *oldClusterDef,
+                             RxClusterDefinition *newClusterDef);
+
+extern void *
+RxPipelineNodeGetInitData(RxPipelineNode *node);
+
+extern void *
+RxPipelineNodeCreateInitData(RxPipelineNode *node,
+                             RwUInt32 size);
+
+/* PIPELINE MANIPULATION API */
+
+extern RxPipeline *
+RxPipelineClone(RxPipeline *pipeline);
+
+extern RxPipelineNode *
+RxPipelineFindNodeByName(RxPipeline *pipeline,
+                         const RwChar *name,
+                         RxPipelineNode *start,
+                         RwInt32 *nodeIndex);
+
+extern RxPipelineNode *
+RxPipelineFindNodeByIndex(RxPipeline *pipeline,
+                          RwUInt32 nodeindex);
+
+extern RxLockedPipe *
+RxPipelineLock(RxPipeline *pipeline);
+
+extern RxPipeline *
+RxLockedPipeUnlock(RxLockedPipe *pipeline);
+
+
+extern RxLockedPipe *
+RxLockedPipeAddFragment(RxLockedPipe *pipeline,
+                        RwUInt32 *firstIndex,
+                        RxNodeDefinition *nodeDef0,
+                        ...);
+
+
+extern RxPipeline *
+RxLockedPipeReplaceNode(RxLockedPipe *pipeline,
+                        RxPipelineNode *node,
+                        RxNodeDefinition *nodeDef);
+
+extern RxPipeline *
+RxLockedPipeDeleteNode(RxLockedPipe *pipeline,
+                       RxPipelineNode *node);
+
+
+extern RxPipeline *
+RxLockedPipeSetEntryPoint(RxLockedPipe *pipeline,
+                          RxNodeInput in);
+
+
+extern RxPipelineNode *
+RxLockedPipeGetEntryPoint(RxLockedPipe *pipeline);
+
+
+extern RxPipeline *
+RxLockedPipeAddPath(RxLockedPipe *pipeline,
+                    RxNodeOutput out,
+                    RxNodeInput in);
+
+extern RxPipeline *
+RxLockedPipeDeletePath(RxLockedPipe *pipeline,
+                       RxNodeOutput out,
+                       RxNodeInput in);
+
+
+extern RxPipeline *
+RxPipelineInsertDebugNode(RxPipeline *pipeline,
+                          RxPipelineNode *before,
+                          RxPipelineNode *after,
+                          RxNodeDefinition *debugNode);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2altmdl.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeTransform.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetTransform(void);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeSubmitTriangle.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition * RxNodeDefinitionGetSubmitTriangle(void);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeSubmitLine.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition * RxNodeDefinitionGetSubmitLine(void);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeScatter.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition * RxNodeDefinitionGetScatter(void);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeClone.h ---*/
+
+typedef struct RxPacketCacheCluster RxPacketCacheCluster;
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPacketCacheCluster
+ * structure containing a cache of an \ref RxCluster's
+ * within an \ref RxPacketCache 
+ */
+struct RxPacketCacheCluster
+{
+    RwUInt32            slot;       /**< A \ref RwUInt32 index into the \ref RxPacketCache's
+                                     * array of RxPacketCacheCluster's */
+    RwUInt16            flags;      /**< A cache of the original cluster's flags */
+    RwUInt16            stride;     /**< A cache of the original cluster's stride */
+    void               *data;       /**< A cache of the original cluster's data */
+    RwUInt32            numAlloced; /**< A cache of the original cluster's numAlloced */
+    RwUInt32            numUsed;    /**< A cache of the original cluster's numUsed */
+    RxPipelineCluster  *clusterRef; /**< A cache of the original cluster's \ref RxPipelineCluster */
+};
+typedef struct RxPacketCache RxPacketCache;
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxPacketCache
+ * structure containing a cache of a \ref RxPacket */
+struct RxPacketCache
+{
+    RwUInt16             packetFlags; /**< A cache of the original packet's flags */
+    RwUInt16             pad[1];      /**< Alignment padding */
+    RwUInt32             numClusters; /**< The number of present clusters in the
+                                       * original packet when it was cloned */
+    RwBool               lastCloneDone;/**< Once the cache has been cloned by \ref RxPacketCacheClone
+                                       * with (lastClone == TRUE), it should not be used again! */
+    RwUInt32             pad2[1];      /**< Alignment padding */
+    RxPacketCacheCluster clusters[1]; /**< An array of \ref RxPacketCacheCluster's,
+                                       * extending beyond 1 element */
+};
+    
+
+typedef struct RxNodeCloneInitData RxNodeCloneInitData;
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxNodeCloneInitData
+ * structure with which to initialize 
+ * clone a \ref RxNodeDefinition, 
+ * through \ref RxNodeDefinitionCloneCreate and
+ * set up cloned \ref RxPipelineNode modes, through
+ * \ref RxPipelineNodeCloneDefineModes */
+struct RxNodeCloneInitData
+{
+    RwUInt32   numModes;   /**< Specifies the number of modes in
+                              which the node should operate */
+    RwUInt32   numOutputs; /**< Specifies the number of outputs of this
+                              Clone node, which is also the maximum
+                              number of outputs to which any one mode
+                              may dispatch packets */
+    RwUInt32  *modeSizes;  /**< Specifies the number of outputs to which
+                              each mode dispatches packets */
+    RwUInt32 **modes;      /**< An array of numModes pointers to arrays
+                              (of length numOutputs) specifying the
+                              outputs, in order, to which each mode
+                              should dispatch packets (output zero is
+                              the first output) */
+};
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxNodeCloneData
+ * structure which is the private
+ * data of Clone nodes \ref RxPipelineNode */
+typedef struct RxNodeCloneData RxNodeCloneData;
+struct RxNodeCloneData
+{
+    RwBool optimized;         /**< \ref RwBool specifying whether \ref RxPipelineNodeCloneOptimize
+                               * has been run on this \ref RxPipelineNode yet */
+    RwUInt32 currentMode;     /**< \ref RwUInt32 The current mode of operation */
+    RxNodeCloneInitData *data;/**< A pointer to \ref RxNodeCloneInitData data
+                               * specifying the modes of operation */
+};
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionCloneCreate(RxNodeCloneInitData *data);
+extern RwBool            RxPipelineNodeCloneDefineModes(
+                             RxPipeline          *pipeline,
+                             RxPipelineNode      *node,
+                             RxNodeCloneInitData   *data);
+extern RwBool            RxNodeDefinitionCloneDestroy(RxNodeDefinition *def);
+extern RwBool            RxPipelineNodeCloneOptimize(RxPipeline     *pipeline,
+                                                     RxPipelineNode *node);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeImmStash.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetImmStash(void);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeImmRenderSetup.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition * RxNodeDefinitionGetImmRenderSetup(void);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeImmMangleTriangleIndices.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetImmMangleTriangleIndices(void);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeImmMangleLineIndices.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition * RxNodeDefinitionGetImmMangleLineIndices(void);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeImmInstance.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition * RxNodeDefinitionGetImmInstance(void);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeCullTriangle.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition * RxNodeDefinitionGetCullTriangle(void);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeClipTriangle.h ---*/
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetClipTriangle(void);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeClipLine.h ---*/
+
+#ifdef __cplusplus
+extern              "C"
+{
+#endif                          /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetClipLine(void);
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/d3d8texdic.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/d3d8rendst.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/d3d8raster.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/d3d8device.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/d3d8convrt.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/d3d82drend.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/common/ssematml.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/common/cpuext.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/common/palquant.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/common/datblkcb.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/baraster.h ---*/
+
+/****************************************************************************
+ Defines
+ */
+
+/**
+ * \ingroup datatypes
+ * \ref RwRasterLockMode represents the options available for locking 
+ * a raster so that it may be modified (see API function \ref RwRasterLock). An 
+ * application may wish to write to the raster, read from the raster or
+ * simultaneously write and read a raster (rwRASTERLOCKWRITE | rwRASTERLOCKREAD).
+ */
+enum RwRasterLockMode
+{
+    rwRASTERLOCKWRITE = 0x01,   /**<Lock for writing */
+    rwRASTERLOCKREAD = 0x02,    /**<Lock for reading */
+    rwRASTERLOCKNOFETCH = 0x04, /**<When used in combination with
+                                 *  rwRASTERLOCKWRITE, asks the driver not to
+                                 *  fetch the pixel data. This is only useful
+                                 *  if it is known that ALL the raster data is
+                                 *  going to be overwritten before the raster
+                                 *  is unlocked, i.e. from an 
+                                 *  \ref RwRasterSetFromImage call. This flag
+                                 *  is not supported by all drivers. */
+    rwRASTERLOCKRAW = 0x08,    /**<When used in combination with
+                                   rwRASTERLOCKWRITE or rwRASTERLOCKREAD
+                                   allows access to the raw platform specific
+                                   pixel format */
+    rwRASTERLOCKMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+
+#define rwRASTERLOCKREADWRITE   (rwRASTERLOCKREAD|rwRASTERLOCKWRITE)
+
+typedef enum RwRasterLockMode RwRasterLockMode;
+
+/**
+ * \ingroup datatypes
+ *  \ref RwRasterFlipMode represents
+ *  raster flip modes */
+enum RwRasterFlipMode
+{
+    rwRASTERFLIPDONTWAIT = 0,   /**<Don't wait for VSync */
+    rwRASTERFLIPWAITVSYNC = 1,  /**<Flip on VSync */
+    rwRASTERFLIPMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwRasterFlipMode RwRasterFlipMode;
+
+/**
+ * \ingroup datatypes
+ *  RwRasterType 
+ *  This type represents the options available for creating a new 
+ * raster (se API function \ref RwRasterCreate)*/
+enum RwRasterType
+{
+    rwRASTERTYPENORMAL = 0x00,          /**<Normal */
+    rwRASTERTYPEZBUFFER = 0x01,         /**<Z Buffer */
+    rwRASTERTYPECAMERA = 0x02,          /**<Camera */
+    rwRASTERTYPETEXTURE = 0x04,         /**<Texture */
+    rwRASTERTYPECAMERATEXTURE = 0x05,   /**<Camera texture */
+    rwRASTERTYPEMASK = 0x07,            /**<Mask for finding type */
+
+    rwRASTERDONTALLOCATE = 0x80,        /**<If set the raster is not allocated */
+    rwRASTERTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwRasterType RwRasterType;
+
+/**
+ * \ingroup datatypes
+ * \ref RwRasterFormat is a set of values and flags which may be combined to
+ * specify a raster format. The format chosen for a particular raster depends
+ * on the hardware device and the raster type specified at creation time
+ * (see API function \ref RwRasterCreate). The format may be retrieved using
+ * API function \ref RwRasterGetFormat.
+ *
+ * The raster format is a packed set of bits which contains the following
+ * four pieces of information (these may be combined with bitwise OR):-
+ *
+ * <ol>
+ * <li> The pixel color format corresponding to one of the following values:-
+ *      <ul>
+ *      <li> rwRASTERFORMAT1555
+ *      <li> rwRASTERFORMAT565
+ *      <li> rwRASTERFORMAT4444
+ *      <li> rwRASTERFORMATLUM8
+ *      <li> rwRASTERFORMAT8888
+ *      <li> rwRASTERFORMAT888
+ *      <li> rwRASTERFORMAT16
+ *      <li> rwRASTERFORMAT24
+ *      <li> rwRASTERFORMAT32
+ *      <li> rwRASTERFORMAT555
+ *      </ul>
+ *      This value may be masked out of the raster format using
+ *      rwRASTERFORMATPIXELFORMATMASK.
+ * <li> The palette depth if the raster is palettized:-
+ *      <ul> 
+ *      <li> rwRASTERFORMATPAL4
+ *      <li> rwRASTERFORMATPAL8
+ *      </ul>
+ *      In these cases, the color format refers to that of the palette.
+ * <li> Flag rwRASTERFORMATMIPMAP. Set if the raster contains mipmap levels.
+ * <li> Flag rwRASTERFORMATAUTOMIPMAP. Set if the mipmap levels were generated
+ *      automatically by RenderWare.
+ * </ol>
+ */
+enum RwRasterFormat
+{
+    rwRASTERFORMATDEFAULT = 0x0000, /* Whatever the hardware likes best */
+
+    rwRASTERFORMAT1555 = 0x0100,    /**<16 bits - 1 bit alpha, 5 bits red, green and blue */
+    rwRASTERFORMAT565 = 0x0200,     /**<16 bits - 5 bits red and blue, 6 bits green */
+    rwRASTERFORMAT4444 = 0x0300,    /**<16 bits - 4 bits per component */
+    rwRASTERFORMATLUM8 = 0x0400,    /**<Gray scale */
+    rwRASTERFORMAT8888 = 0x0500,    /**<32 bits - 8 bits per component */
+    rwRASTERFORMAT888 = 0x0600,     /**<24 bits - 8 bits per component */
+    rwRASTERFORMAT16 = 0x0700,      /**<16 bits - undefined: useful for things like Z buffers */
+    rwRASTERFORMAT24 = 0x0800,      /**<24 bits - undefined: useful for things like Z buffers */
+    rwRASTERFORMAT32 = 0x0900,      /**<32 bits - undefined: useful for things like Z buffers */
+    rwRASTERFORMAT555 = 0x0a00,     /**<16 bits - 5 bits red, green and blue */
+
+    rwRASTERFORMATAUTOMIPMAP = 0x1000, /**<RenderWare generated the mip levels */
+
+    rwRASTERFORMATPAL8 = 0x2000,    /**<8 bit palettised */
+    rwRASTERFORMATPAL4 = 0x4000,    /**<4 bit palettised */
+
+    rwRASTERFORMATMIPMAP = 0x8000,  /**<Mip mapping on */
+
+    rwRASTERFORMATPIXELFORMATMASK = 0x0f00, /**<The pixel color format 
+                                             *  (excluding palettised bits) */
+    rwRASTERFORMATMASK = 0xff00     /**<The whole format */ ,
+    rwRASTERFORMATFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwRasterFormat RwRasterFormat;
+
+enum RwRasterPrivateFlag
+{
+    rwRASTERGAMMACORRECTED = 0x01,
+    rwRASTERPIXELLOCKEDREAD = 0x02, /* pixels are locked for reading */
+    rwRASTERPIXELLOCKEDWRITE = 0x04, /* pixels are locked for writing */
+    rwRASTERPALETTELOCKEDREAD = 0x08, /* palette is locked for reading */
+    rwRASTERPALETTELOCKEDWRITE = 0x10, /* palette is locked for writing */
+    rwRASTERPIXELLOCKEDRAW = 0x20, /* the pixels are in platform specific
+                                      format, used in combination with
+                                      rwRASTERPIXELLOCKEDREAD &
+                                      rwRASTERPIXELLOCKEDWRITE */
+    rwRASTERPRIVATEFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwRasterPrivateFlag RwRasterPrivateFlag;
+
+#define rwRASTERPIXELLOCKED     (rwRASTERPIXELLOCKEDREAD | rwRASTERPIXELLOCKEDWRITE)
+#define rwRASTERPALETTELOCKED   (rwRASTERPALETTELOCKEDREAD | rwRASTERPALETTELOCKEDWRITE)
+#define rwRASTERLOCKED          (rwRASTERPIXELLOCKED|rwRASTERPALETTELOCKED)
+
+/* How big is my stack!!! */
+#define rwRASTERCONTEXTSTACKSIZE 10
+
+/****************************************************************************
+ Global Types
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwRaster 
+ * Raster containing device-dependent pixels. 
+ * This should be considered an opaque type.
+ * Use the RwRaster API functions to access.
+ */
+typedef struct RwRaster RwRaster;
+
+#if (!defined(DOXYGEN))
+struct RwRaster
+{
+    RwRaster           *parent; /* Top level raster if a sub raster */
+    RwUInt8            *cpPixels; /* Pixel pointer when locked */
+    RwUInt8            *palette; /* Raster palette */
+    RwInt32             width, height, depth; /* Dimensions of raster */
+    RwInt32             stride; /* Lines bytes of raster */
+    RwInt16             nOffsetX, nOffsetY; /* Sub raster offset */
+    RwUInt8             cType;  /* Type of raster */
+    RwUInt8             cFlags; /* Raster flags */
+    RwUInt8             privateFlags; /* Raster private flags */
+    RwUInt8             cFormat; /* Raster format */
+
+    RwUInt8            *originalPixels;
+    RwInt32             originalWidth;
+    RwInt32             originalHeight;
+    RwInt32             originalStride;
+};
+#endif /* (!defined(DOXYGEN)) */
+
+
+/****************************************************************************
+ <macro/inline functionality
+ */
+
+#define RwRasterGetWidthMacro(_raster) \
+    ((_raster)->width)
+
+#define RwRasterGetHeightMacro(_raster) \
+    ((_raster)->height)
+
+#define RwRasterGetStrideMacro(_raster) \
+    ((_raster)->stride)
+
+#define RwRasterGetDepthMacro(_raster) \
+    ((_raster)->depth)
+
+#define RwRasterGetFormatMacro(_raster) \
+    ((((_raster)->cFormat) & (rwRASTERFORMATMASK >> 8)) << 8)
+
+#define RwRasterGetTypeMacro(_raster) \
+    (((_raster)->cType) & rwRASTERTYPEMASK)
+
+#define RwRasterGetParentMacro(_raster) \
+    ((_raster)->parent)
+
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define RwRasterGetWidth(_raster)                   \
+    RwRasterGetWidthMacro(_raster)
+
+#define RwRasterGetHeight(_raster)                  \
+    RwRasterGetHeightMacro(_raster)
+
+#define RwRasterGetStride(_raster)                  \
+    RwRasterGetStrideMacro(_raster)
+
+#define RwRasterGetDepth(_raster)                   \
+    RwRasterGetDepthMacro(_raster)
+
+#define RwRasterGetFormat(_raster)                  \
+    RwRasterGetFormatMacro(_raster)
+
+#define RwRasterGetType(_raster)                  \
+    RwRasterGetTypeMacro(_raster)
+
+#define RwRasterGetParent(_raster)                  \
+    RwRasterGetParentMacro(_raster)
+
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef    __cplusplus
+extern              "C"
+{
+#endif                          /* __cplusplus */
+
+/* Creating destroying rasters */
+extern RwRaster    *RwRasterCreate(RwInt32 width, RwInt32 height,
+                                   RwInt32 depth, RwInt32 flags);
+extern RwBool       RwRasterDestroy(RwRaster * raster);
+
+/* Pulling info out of raster structure */
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+extern RwInt32      RwRasterGetWidth(const RwRaster *raster);
+extern RwInt32      RwRasterGetHeight(const RwRaster *raster);
+extern RwInt32      RwRasterGetStride(const RwRaster *raster);
+extern RwInt32      RwRasterGetDepth(const RwRaster *raster);
+extern RwInt32      RwRasterGetFormat(const RwRaster *raster);
+extern RwInt32      RwRasterGetType(const RwRaster *raster);
+extern RwRaster    *RwRasterGetParent(const RwRaster *raster);
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+extern RwRaster    *RwRasterGetOffset(RwRaster *raster, 
+                                      RwInt16 *xOffset, RwInt16 *yOffset);
+
+extern RwInt32      RwRasterGetNumLevels(RwRaster * raster);
+
+extern RwRaster    *RwRasterSubRaster(RwRaster * subRaster,
+                                      RwRaster * raster, RwRect * rect);
+
+extern RwRaster    *RwRasterRenderFast(RwRaster * raster, RwInt32 x,
+                                       RwInt32 y);
+extern RwRaster    *RwRasterRender(RwRaster * raster, RwInt32 x,
+                                       RwInt32 y);
+extern RwRaster    *RwRasterRenderScaled(RwRaster * raster,
+                                         RwRect * rect);
+
+/* Raster rendering context */
+extern RwRaster    *RwRasterPushContext(RwRaster * raster);
+extern RwRaster    *RwRasterPopContext(void);
+extern RwRaster    *RwRasterGetCurrentContext(void);
+
+/* Clearing rasters */
+extern RwBool       RwRasterClear(RwInt32 pixelValue);
+extern RwBool       RwRasterClearRect(RwRect * rpRect,
+                                          RwInt32 pixelValue);
+
+/* Displaying rasters */
+extern RwRaster    *RwRasterShowRaster(RwRaster * raster, void *dev,
+                                       RwUInt32 flags);
+
+/* Locking and releasing */
+extern RwUInt8     *RwRasterLock(RwRaster * raster, RwUInt8 level,
+                                 RwInt32 lockMode);
+extern RwRaster    *RwRasterUnlock(RwRaster * raster);
+extern RwUInt8     *RwRasterLockPalette(RwRaster * raster,
+                                        RwInt32 lockMode);
+extern RwRaster    *RwRasterUnlockPalette(RwRaster * raster);
+
+/* Attaching toolkits */
+extern RwInt32      RwRasterRegisterPlugin(RwInt32 size,
+                                           RwUInt32 pluginID,
+                                           RwPluginObjectConstructor
+                                           constructCB,
+                                           RwPluginObjectDestructor
+                                           destructCB,
+                                           RwPluginObjectCopy copyCB);
+extern RwInt32      RwRasterGetPluginOffset(RwUInt32 pluginID);
+extern RwBool       RwRasterValidatePlugins(const RwRaster * raster);
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+
+/*--- 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)) */
+
+
+#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/pipe/p2/d3d8/pip2model.h ---*/
+
+
+
+
+
+/****************************************************************************
+ Global Defines
+ */
+
+#define RXHEAPPLATFORMDEFAULTSIZE  (1 << 12) /* 4k */
+
+/****************************************************************************
+ Global Types
+ */
+
+/* We use D3D8 formats for the instanced versions, to allow hardware T&L */
+
+/**
+ * \ingroup corep2d3d8
+ * \typedef RxObjSpace3DVertex
+ * Typedef for an RxObjSpace3DVertex.
+ */
+typedef struct RxObjSpace3DVertex RxObjSpace3DVertex;
+
+/**
+ * \ingroup corep2d3d8
+ * \struct RxObjSpace3DVertex
+ * Structure representing object space vertex.
+ */
+struct RxObjSpace3DVertex
+{
+    RwV3d       objVertex;        /**< position */
+    RwV3d       objNormal;        /**< normal */
+    RwUInt32    color;            /**< emissive color*/
+    RwReal      u;                /**< u */
+    RwReal      v;                /**< v */
+};
+
+/* This vertex is non truncatable */
+#define RxObjSpace3DVertexNoUVsNoNormalsSize (sizeof(RxObjSpace3DVertex))
+#define RxObjSpace3DVertexNoUVsSize          (sizeof(RxObjSpace3DVertex))
+#define RxObjSpace3DVertexFullSize           (sizeof(RxObjSpace3DVertex))
+
+/**
+ * \ingroup corep2d3d8
+ * \typedef RxObjSpace3DLitVertex
+ * Typedef for an RxObjSpace3DLitVertex.
+ */
+typedef RxObjSpace3DVertex RxObjSpace3DLitVertex;
+
+/** 
+ * \ingroup corep2d3d8
+ * \typedef RwIm3DVertex
+ * Typedef for an RwIm3DVertex.
+ */
+typedef RxObjSpace3DLitVertex RwIm3DVertex;
+
+/* LEGACY-SUPPORT macro */
+#define RWIM3DVERTEX RwIm3DVertex
+typedef RwIm2DVertex RxScrSpace2DVertex;
+
+/****************************************************************************
+ Object-space 3D unlit vertex macros
+ */
+
+/* Vertex positions */
+#define RxObjSpace3DVertexGetPos(_vert, _pos) \
+    (*(_pos) = (_vert)->objVertex)
+#define RxObjSpace3DVertexSetPos(_vert, _pos) \
+    ((_vert)->objVertex = *(_pos))
+
+/* Pre-lighting colours */
+#define RxObjSpace3DVertexGetPreLitColor(_vert, _col) \
+MACRO_START \
+{ \
+    (_col)->alpha = (RwUInt8)((_vert)->color >> 24) & 0xFF; \
+    (_col)->red   = (RwUInt8)((_vert)->color >> 16) & 0xFF; \
+    (_col)->green = (RwUInt8)((_vert)->color >>  8) & 0xFF; \
+    (_col)->blue  = (RwUInt8)((_vert)->color      ) & 0xFF; \
+} \
+MACRO_STOP
+
+#define RxObjSpace3DVertexSetPreLitColor(_vert, _col) \
+    ((_vert)->color = (((RwUInt32)(_col)->alpha) << 24) | \
+                              (((RwUInt32)(_col)->red)   << 16) | \
+                              (((RwUInt32)(_col)->green) <<  8) | \
+                              (((RwUInt32)(_col)->blue)       ))
+
+/* This uses the same slot as color (they are mutually exclusive) */
+#define RxObjSpace3DVertexGetColor RxObjSpace3DVertexGetPreLitColor
+
+/* Normals */
+#define RxObjSpace3DVertexGetNormal(_vert, _normal)             \
+    (*(_normal) = (_vert)->objNormal)
+#define RxObjSpace3DVertexSetNormal(_vert, _normal)             \
+    ((_vert)->objNormal = *(_normal))
+
+/* Us and Vs */
+#define RxObjSpace3DVertexGetU(_vert)                          \
+    ((_vert)->u)
+#define RxObjSpace3DVertexGetV(_vert)                          \
+    ((_vert)->v)
+#define RxObjSpace3DVertexSetU(_vert, _imu)                     \
+    ((_vert)->u = (_imu))
+#define RxObjSpace3DVertexSetV(_vert, _imv)                     \
+    ((_vert)->v = (_imv))
+
+/****************************************************************************
+ Object-space 3D lit vertex macros
+ */
+
+/* Vertex positions */
+#define RxObjSpace3DLitVertexGetPos(_vert, _pos) \
+    (*(_pos) = (_vert)->objVertex)
+#define RxObjSpace3DLitVertexSetPos(_vert, _pos) \
+    ((_vert)->objVertex = *(_pos))
+
+/* Vertex colours */
+#define RxObjSpace3DLitVertexGetColor(_vert, _col) \
+MACRO_START \
+{ \
+    (_col)->red   = ((_vert)->color >> 16) & 0xFF; \
+    (_col)->green = ((_vert)->color >>  8) & 0xFF; \
+    (_col)->blue  = ((_vert)->color      ) & 0xFF; \
+    (_col)->alpha = ((_vert)->color >> 24) & 0xFF; \
+} \
+MACRO_STOP
+#define RxObjSpace3DLitVertexSetColor(_vert, _col) \
+    ((_vert)->color = (((RwUInt32)(_col)->alpha) << 24) | \
+                              (((RwUInt32)(_col)->red)   << 16) | \
+                              (((RwUInt32)(_col)->green) <<  8) | \
+                              (((RwUInt32)(_col)->blue)       ))
+
+/* Us and Vs */
+#define RxObjSpace3DLitVertexGetU(_vert) \
+    ((_vert)->u)
+#define RxObjSpace3DLitVertexGetV(_vert) \
+    ((_vert)->v)
+#define RxObjSpace3DLitVertexSetU(_vert, _imu) \
+    ((_vert)->u = (_imu))
+#define RxObjSpace3DLitVertexSetV(_vert, _imv) \
+    ((_vert)->v = (_imv))
+
+/* LEGACY-SUPPORT for old objvert names - NB does NOT guarantee the
+ * app will work, because the old IM3DVERTEX macros are NOT correctly
+ * abstracted - 'Get' will return pointers to RwV3ds inside the
+ * ObjVert, but you can't assume there are any RwV3ds inside an
+ * opaque vertex type */
+
+#define RwIm3DVertexSetU   RxObjSpace3DLitVertexSetU
+#define RwIm3DVertexSetV   RxObjSpace3DLitVertexSetV
+#define RwIm3DVertexGetNext(_vert)      ((_vert) + 1)
+
+#define RwIm2DCameraVertexSetU(_devvert, _camvert, _u, _recipz) \
+MACRO_START                                                     \
+{                                                               \
+    RwReal _uTmp = _u;                                          \
+    _camvert->u = _uTmp;                                        \
+    RwIm2DVertexSetU(_devvert, _uTmp, _recipz);                 \
+}                                                               \
+MACRO_STOP
+#define RwIm2DCameraVertexSetV(_devvert, _camvert, _v, _recipz) \
+MACRO_START                                                     \
+{                                                               \
+    RwReal _vTmp = _v;                                          \
+    _camvert->v = _vTmp;                                        \
+    RwIm2DVertexSetV(_devvert, _vTmp, _recipz);                 \
+}                                                               \
+MACRO_STOP
+
+#define RwIm3DVertexSetPos(_vert, _imx, _imy, _imz) \
+MACRO_START \
+{ \
+    (_vert)->objVertex.x = _imx; \
+    (_vert)->objVertex.y = _imy; \
+    (_vert)->objVertex.z = _imz; \
+} \
+MACRO_STOP
+
+#define RwIm3DVertexSetNormal(vert, imx, imy, imz)         \
+MACRO_START                                                \
+{                                                          \
+    RwV3d packed;                                          \
+    packed.x = imx;                                        \
+    packed.y = imy;                                        \
+    packed.z = imz;                                        \
+    RxObjSpace3DVertexSetNormal(vert, &packed);            \
+}                                                          \
+MACRO_STOP
+
+#define RwIm3DVertexSetRGBA(_vert, _r, _g, _b, _a) \
+MACRO_START \
+{ \
+    ((_vert)->color = ((_a) << 24) | \
+                              ((_r) << 16) | \
+                              ((_g) << 8) | \
+                              ((_b))); \
+} \
+MACRO_STOP
+
+#define RwIm3DVertexGetPos(_vert) (&((_vert)->objVertex))
+#define RwIm3DVertexGetNormal(vert) (&((vert)->objNormal))
+
+#define RwIm3DVertexCopyRGBA(_dst, _src) (((_dst)->color) = ((_src)->color))
+
+/* LEGACY-SUPPORT macros */
+#define RWIM2DCAMERAVERTEXSetU(_devvert, _camvert, _u, _recipz) \
+    RwIm2DCameraVertexSetU(_devvert, _camvert, _u, _recipz)
+#define RWIM2DCAMERAVERTEXSetV(_devvert, _camvert, _v, _recipz) \
+    RwIm2DCameraVertexSetV(_devvert, _camvert, _v, _recipz)
+#define RWIM3DVERTEXGetNext(vert)                   RwIm3DVertexGetNext(vert)
+#define RWIM3DVERTEXSetPos(vert, imx, imy, imz)     RwIm3DVertexSetPos(vert, imx, imy, imz)
+#define RWIM3DVERTEXGetPos(vert)                    RwIm3DVertexGetPos(vert)
+#define RWIM3DVERTEXSetU(vert, imu)                 RwIm3DVertexSetU(vert, imu)
+#define RWIM3DVERTEXSetV(vert, imv)                 RwIm3DVertexSetV(vert, imv)
+#define RWIM3DVERTEXSetRGBA(vert, r, g, b, a)       RwIm3DVertexSetRGBA(vert, r, g, b, a)
+#define RWIM3DVERTEXSetNormal(vert, imx, imy, imz)  RwIm3DVertexSetNormal(vert, imx, imy, imz)
+#define RWIM3DVERTEXCopyRGBA(dst,src)               RwIm3DVertexCopyRGBA(dst,src)
+#define RXOBJSPACE3DVERTEXGetPos(_vert, _pos) \
+    RxObjSpace3DVertexGetPos(_vert, _pos)
+#define RXOBJSPACE3DVERTEXSetPos(_vert, _pos) \
+    RxObjSpace3DVertexSetPos(_vert, _pos)
+#define RXOBJSPACE3DVERTEXGetPreLitColor(_vert, _col) \
+    RxObjSpace3DVertexGetPreLitColor(_vert, _col)
+#define RXOBJSPACE3DVERTEXSetPreLitColor(_vert, _col) \
+    RxObjSpace3DVertexSetPreLitColor(_vert, _col)
+#define RXOBJSPACE3DVERTEXGetColor              RxObjSpace3DVertexGetColor
+#define RXOBJSPACE3DVERTEXGetNormal(_vert, _normal) \
+    RxObjSpace3DVertexGetNormal(_vert, _normal)
+#define RXOBJSPACE3DVERTEXSetNormal(_vert, _normal) \
+    RxObjSpace3DVertexSetNormal(_vert, _normal)
+#define RXOBJSPACE3DVERTEXGetU(_vert)           RxObjSpace3DVertexGetU(_vert)
+#define RXOBJSPACE3DVERTEXGetV(_vert)           RxObjSpace3DVertexGetV(_vert)
+#define RXOBJSPACE3DVERTEXSetU(_vert, _imu) \
+    RxObjSpace3DVertexSetU(_vert, _imu)
+#define RXOBJSPACE3DVERTEXSetV(_vert, _imv) \
+    RxObjSpace3DVertexSetV(_vert, _imv)
+#define RXOBJSPACE3DLITVERTEXGetPos(vert, pos)   \
+    RxObjSpace3DLitVertexGetPos(vert, pos)
+#define RXOBJSPACE3DLITVERTEXSetPos(vert, pos)   \
+    RxObjSpace3DLitVertexSetPos(vert, pos)
+#define RXOBJSPACE3DLITVERTEXGetColor(vert, col) \
+    RxObjSpace3DLitVertexGetColor(vert, col)
+#define RXOBJSPACE3DLITVERTEXSetColor(vert, col) \
+    RxObjSpace3DLitVertexSetColor(vert, col)
+#define RXOBJSPACE3DLITVERTEXGetU(vert)          \
+    RxObjSpace3DLitVertexGetU(vert)
+#define RXOBJSPACE3DLITVERTEXGetV(vert)          \
+    RxObjSpace3DLitVertexGetV(vert)
+#define RXOBJSPACE3DLITVERTEXSetU(vert, imu)     \
+    RxObjSpace3DLitVertexSetU(vert, imu)
+#define RXOBJSPACE3DLITVERTEXSetV(vert, imv)     \
+    RxObjSpace3DLitVertexSetV(vert, imv)
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2renderstate.h ---*/
+
+/**
+ * \ingroup rwcoregeneric
+ *  RxRenderStateFlag 
+ *  Flags used in the \ref RxRenderStateVector structure */
+enum RxRenderStateFlag
+{
+    rxRENDERSTATEFLAG_TEXTUREPERSPECTIVE   = 0x00000001, /**<Perspective texturing is to be enabled */
+    rxRENDERSTATEFLAG_ZTESTENABLE          = 0x00000002, /**<Z-Buffer testing is to be performed */
+    rxRENDERSTATEFLAG_ZWRITEENABLE         = 0x00000004, /**<Z-Buffer writing is to be enabled */
+    rxRENDERSTATEFLAG_VERTEXALPHAENABLE    = 0x00000008, /**<Vertex alpha is to be enabled */
+    rxRENDERSTATEFLAG_FOGENABLE            = 0x00000010, /**<Fog is to be enabled */
+    rxRENDERSTATEFLAG_ALPHAPRIMITIVEBUFFER = 0x00000020, /**<Alpha primitive buffering is to be enabled */
+    rxRENDERSTATEFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RxRenderStateFlag RxRenderStateFlag;
+
+typedef struct RxRenderStateVector RxRenderStateVector;
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxRenderStateVector
+ * Structure describing a render-state vector,
+ * used by the RxClRenderState cluster */
+struct RxRenderStateVector
+{
+    RwUInt32             Flags;         /**< A load of the boolean renderstate options */
+    RwShadeMode          ShadeMode;     /**< Flat or Gouraud currently */
+    RwBlendFunction      SrcBlend;      /**< Src  alpha, 1-src  alpha, etc */
+    RwBlendFunction      DestBlend;     /**< Dest alpha, 1-dest alpha, etc */
+    RwRaster            *TextureRaster; /**< texture raster */
+    RwTextureAddressMode AddressModeU;  /**< U addressing mode - WRAP, MIRROR, CLAMP, BORDER */
+    RwTextureAddressMode AddressModeV;  /**< V addressing mode - WRAP, MIRROR, CLAMP, BORDER */
+    RwTextureFilterMode  FilterMode;    /**< filtering mode - combos of NEAREST LINEAR MIP */
+    RwRGBA               BorderColor;   /**< Border color for texturing address mode border */
+    RwFogType            FogType;       /**< Select the type of fogging to use */
+    RwRGBA               FogColor;      /**< Color used for fogging */
+    RwUInt8             *FogTable;      /**< A 256 entry fog table */
+};
+
+#if (!defined(RxRenderStateVectorAssign))
+#define RxRenderStateVectorAssign(_target, _source)            \
+    ( *(_target) = *(_source) )
+#endif /* (!defined(RxRenderStateVectorAssign)) */
+
+
+
+#ifdef    __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern       RxRenderStateVector *RxRenderStateVectorSetDefaultRenderStateVector(RxRenderStateVector *rsvp);
+extern const RxRenderStateVector *RxRenderStateVectorGetDefaultRenderStateVector(void);
+extern       RxRenderStateVector *RxRenderStateVectorCreate(RwBool current);
+extern       void                 RxRenderStateVectorDestroy(RxRenderStateVector *rsvp);
+extern       RxRenderStateVector *RxRenderStateVectorLoadDriverState(RxRenderStateVector *rsvp);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2clpcom.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeRGBAInterp.h ---*/
+
+struct NodeRGBAInterpData
+{
+    RwBool              rgbaInterpOn;
+    RxRenderStateVector state;
+};
+typedef struct NodeRGBAInterpData NodeRGBAInterpData;
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition *RxNodeDefinitionGetRGBAInterp(void);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/nodeUVInterp.h ---*/
+
+typedef struct RxNodeUVInterpSettings RxNodeUVInterpSettings;
+struct RxNodeUVInterpSettings
+{
+    RwBool              uvInterpOn;
+    RxRenderStateVector state;
+};
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RxNodeDefinition * RxNodeDefinitionGetUVInterp(void);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/baimage.h ---*/
+
+/****************************************************************************
+ Defines
+ */
+
+/* If this bit is set then the image has been allocated by the user */
+
+enum RwImageFlag
+{
+    rwNAIMAGEFLAG = 0x00,
+    rwIMAGEALLOCATED = 0x1,
+    rwIMAGEGAMMACORRECTED = 0x2,
+    rwIMAGEFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwImageFlag RwImageFlag;
+
+/****************************************************************************
+ Global Types
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwImage 
+ * Image containing device-independent pixels. 
+ * This should be considered an opaque type.
+ * Use the RwImage API functions to access.
+ */
+typedef struct RwImage RwImage;
+
+#if (!defined(DOXYGEN))
+struct RwImage
+{
+        RwInt32             flags;
+
+        RwInt32             width;  /* Device may have different ideas */
+        RwInt32             height; /* internally !! */
+
+        RwInt32             depth;  /* Of referenced image */
+        RwInt32             stride;
+
+        RwUInt8            *cpPixels;
+        RwRGBA             *palette;
+};
+#endif /* (!defined(DOXYGEN)) */
+
+/**
+ * \ingroup datatypes
+ * \ref RwImageCallBackRead 
+ * is the function registered with \ref RwImageRegisterImageFormat that is used,
+ * for example by \ref RwImageRead and \ref RwImageReadMaskedImage,
+ * to read images of a specific format from a disk file.
+ * 
+ * \param  imageName   Pointer to a string containing the file name of the image.
+ *
+ * \see RwImageRegisterImageFormat
+ *
+ */
+typedef RwImage *(*RwImageCallBackRead)(const RwChar * imageName);
+
+/**
+ * \ingroup datatypes
+ * \ref RwImageCallBackWrite 
+ * is the function registered with \ref RwImageRegisterImageFormat that is used,
+ * for example by \ref RwImageWrite, 
+ * to write images of a specific format to a disk file.
+ * 
+ * \param  image   Pointer to the image.
+ *
+ * \param  imageName   Pointer to a string containing the file name
+ * of the image.
+ *
+ *
+ * \return Pointer to the written image.
+ *
+ * \see RwImageRegisterImageFormat
+ *
+ */
+typedef RwImage *(*RwImageCallBackWrite)(RwImage *image, const RwChar *imageName);
+
+
+/****************************************************************************
+ <macro/inline functionality
+ */
+
+#define RwImageSetStrideMacro(_image, _stride)      \
+    (((_image)->stride = (_stride)), (_image))
+
+#define RwImageSetPixelsMacro(_image, _pixels)      \
+    (((_image)->cpPixels = (_pixels)), (_image))
+
+#define RwImageSetPaletteMacro(_image, _palette)    \
+    (((_image)->palette = (_palette)), (_image))
+
+#define RwImageGetWidthMacro(_image)                \
+    ((_image)->width)
+
+#define RwImageGetHeightMacro(_image)               \
+    ((_image)->height)
+
+#define RwImageGetDepthMacro(_image)                \
+    ((_image)->depth)
+
+#define RwImageGetStrideMacro(_image)               \
+    ((_image)->stride)
+
+#define RwImageGetPixelsMacro(_image)               \
+    ((_image)->cpPixels)
+
+#define RwImageGetPaletteMacro(_image)              \
+    ((_image)->palette)
+
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define RwImageSetStride(_image, _stride)           \
+    RwImageSetStrideMacro(_image, _stride)
+
+#define RwImageSetPixels(_image, _pixels)           \
+    RwImageSetPixelsMacro(_image, _pixels)
+
+#define RwImageSetPalette(_image, _palette)         \
+    RwImageSetPaletteMacro(_image, _palette)
+
+#define RwImageGetWidth(_image)                     \
+    RwImageGetWidthMacro(_image)
+
+#define RwImageGetHeight(_image)                    \
+    RwImageGetHeightMacro(_image)
+
+#define RwImageGetDepth(_image)                     \
+    RwImageGetDepthMacro(_image)
+
+#define RwImageGetStride(_image)                    \
+    RwImageGetStrideMacro(_image)
+
+#define RwImageGetPixels(_image)                    \
+    RwImageGetPixelsMacro(_image)
+
+#define RwImageGetPalette(_image)                   \
+    RwImageGetPaletteMacro(_image)
+
+#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef    __cplusplus
+extern              "C"
+{
+#endif                          /* __cplusplus */
+
+    /* Creating and destroying */
+extern RwImage     *RwImageCreate(RwInt32 width, RwInt32 height,
+                                  RwInt32 depth);
+extern RwBool       RwImageDestroy(RwImage * image);
+
+    /* Allocating */
+extern RwImage     *RwImageAllocatePixels(RwImage * image);
+extern RwImage     *RwImageFreePixels(RwImage * image);
+
+    /* Converting images */
+extern RwImage     *RwImageCopy(RwImage * destImage,
+                                const RwImage * sourceImage);
+
+    /* Resizing images */
+extern RwImage     *RwImageResize(RwImage * image, RwInt32 width,
+                                  RwInt32 height);
+
+    /* Producing masks ! */
+extern RwImage     *RwImageApplyMask(RwImage * image,
+                                     const RwImage * mask);
+extern RwImage     *RwImageMakeMask(RwImage * image);
+
+    /* Helper functions */
+extern RwImage     *RwImageReadMaskedImage(const RwChar * imageName,
+                                           const RwChar * maskname);
+extern RwImage     *RwImageRead(const RwChar * imageName);
+extern RwImage     *RwImageWrite(RwImage * image,
+                                 const RwChar * imageName);
+
+    /* Setting and getting the default path for images */
+extern RwChar      *RwImageGetPath(void);
+extern const RwChar *RwImageSetPath(const RwChar * path);
+
+    /* Setting */
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+extern RwImage     *RwImageSetStride(RwImage * image, RwInt32 stride);
+extern RwImage     *RwImageSetPixels(RwImage * image, RwUInt8 * pixels);
+extern RwImage     *RwImageSetPalette(RwImage * image, RwRGBA * palette);
+
+    /* Getting */
+extern RwInt32      RwImageGetWidth(const RwImage * image);
+extern RwInt32      RwImageGetHeight(const RwImage * image);
+extern RwInt32      RwImageGetDepth(const RwImage * image);
+extern RwInt32      RwImageGetStride(const RwImage * image);
+extern RwUInt8     *RwImageGetPixels(const RwImage * image);
+extern RwRGBA      *RwImageGetPalette(const RwImage * image);
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+    /* Get device dependent pixel value */
+extern RwUInt32     RwRGBAToPixel(RwRGBA * rgbIn, RwInt32 rasterFormat);
+extern RwRGBA      *RwRGBASetFromPixel(RwRGBA * rgbOut,
+                                       RwUInt32 pixelValue,
+                                       RwInt32 rasterFormat);
+
+    /* Gamma correction */
+extern RwBool       RwImageSetGamma(RwReal gammaValue);
+extern RwReal       RwImageGetGamma(void);
+extern RwImage     *RwImageGammaCorrect(RwImage * image);
+
+    /* Adding and removing gamma correction */
+extern RwRGBA      *RwRGBAGammaCorrect(RwRGBA * rgb);
+
+    /* Attaching toolkits */
+extern RwInt32      RwImageRegisterPlugin(RwInt32 size, RwUInt32 pluginID,
+                                          RwPluginObjectConstructor
+                                          constructCB,
+                                          RwPluginObjectDestructor
+                                          destructCB,
+                                          RwPluginObjectCopy copyCB);
+extern RwInt32      RwImageGetPluginOffset(RwUInt32 pluginID);
+extern RwBool       RwImageValidatePlugins(const RwImage * image);
+
+extern RwBool       RwImageRegisterImageFormat(const RwChar * extension,
+                                               RwImageCallBackRead
+                                               imageRead,
+                                               RwImageCallBackWrite
+                                               imageWrite);
+
+    /* Finding an extension for an image to load */
+extern const RwChar *RwImageFindFileType(const RwChar * imageName);
+
+    /* Reading and writing images to streams */
+extern RwInt32      RwImageStreamGetSize(const RwImage * image);
+extern RwImage     *RwImageStreamRead(RwStream * stream);
+extern const RwImage *RwImageStreamWrite(const RwImage * image,
+                                         RwStream * stream);
+
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/batextur.h ---*/
+
+/****************************************************************************
+ Defines
+ */
+
+/* Type ID */
+#define rwTEXDICTIONARY 6
+
+/* Mipmap Name generation - maximum number of RwChar characters which can
+ * be appended to the root name.
+ */
+#define rwTEXTUREMIPMAPNAMECHARS    16
+
+/* We define texture names to be a maximum of 16 ISO chars */
+#define rwTEXTUREBASENAMELENGTH     32
+
+#define rwTEXTUREFILTERMODEMASK     0x000000FF
+#define rwTEXTUREADDRESSINGUMASK    0x00000F00
+#define rwTEXTUREADDRESSINGVMASK    0x0000F000
+#define rwTEXTUREADDRESSINGMASK     (rwTEXTUREADDRESSINGUMASK |  \
+                                     rwTEXTUREADDRESSINGVMASK)
+
+/****************************************************************************
+ Global Types
+ */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwTexDictionary 
+ * is a texture dictionary containing textures. 
+ * This should be considered an opaque type.
+ * Use the RwTexDictionary API functions to access.
+ */
+typedef struct RwTexDictionary RwTexDictionary;
+
+#if (!defined(DOXYGEN))
+struct RwTexDictionary
+{
+    RwObject            object; /* Homogeneous type */
+    RwLinkList          texturesInDict; /* List of textures in dictionary */
+    RwLLLink            lInInstance; /* Link list of all dicts in system */
+};
+/* Information is entirely device dependent */
+#endif /* (!defined(DOXYGEN)) */
+
+
+/* Parent is the dictionary */
+
+/**
+ * \ingroup datatypes
+ * \typedef  RwTexture 
+ * is a texture object. 
+ * This should be considered an opaque type.
+ * Use the RwTexture API functions to access.
+ */
+typedef struct RwTexture RwTexture;
+
+#if (!defined(DOXYGEN))
+struct RwTexture
+{
+    RwRaster           *raster; /** pointer to RwRaster with data */
+    RwTexDictionary    *dict;   /* Dictionary this texture is in */
+    RwLLLink            lInDictionary; /* List of textures in this dictionary */
+
+    RwChar              name[rwTEXTUREBASENAMELENGTH];  /* Name of the texture */
+    RwChar              mask[rwTEXTUREBASENAMELENGTH];  /* Name of the textures mask */
+
+    /* 31 [xxxxxxxx xxxxxxxx vvvvuuuu ffffffff] 0 */
+    RwUInt32            filterAddressing; /* Filtering & addressing mode flags */
+
+    RwInt32             refCount; /* Reference count, surprisingly enough */
+};
+#endif /* (!defined(DOXYGEN)) */
+
+/**
+ * \ingroup datatypes
+ * \ref RwTextureCallBackRead 
+ * represents the function used by \ref RwTextureRead to read the specified
+ * texture from a disk file. This function should return a pointer to the
+ * texture to indicate success.
+ * 
+ * \param  name   Pointer to a string containing the name of
+ * the texture to read.
+ *
+ * \param  maskName   Pointer to a string containing the name
+ * of the mask to read and apply to the texture.
+ *
+ * \return Pointer to the texture
+ *
+ * \see RwTextureSetReadCallBack
+ * \see RwTextureGetReadCallBack
+ */
+typedef RwTexture *(*RwTextureCallBackRead)(const RwChar *name,
+                                            const RwChar *maskName);
+
+/**
+ * \ingroup datatypes
+ * \ref RwTextureCallBack
+ * represents the function called from \ref RwTexDictionaryForAllTextures
+ * for all textures in a given texture dictionary. This function should
+ * return the current texture to indicate success. The callback may return
+ * NULL to terminate further callbacks on the texture dictionary.
+ * 
+ * \param  texture   Pointer to the current texture.
+ *
+ * \param  pData   User-defined data pointer.
+ *
+ * \return Pointer to the current texture
+ *
+ * \see RwTexDictionaryForAllTextures
+ */
+typedef RwTexture *(*RwTextureCallBack)(RwTexture *texture, void *pData);
+
+
+/**
+ * \ingroup datatypes
+ * \ref RwTexDictionaryCallBack
+ * represents the function called from \ref RwTexDictionaryForAllTexDictionaries
+ * for all texture dictionaries that currently exist. This function should
+ * return the current texture dictionary to indicate success. The callback may
+ * return NULL to terminate further callbacks on the texture dictionary. It may
+ * safely destroy the current texture dictionary without adversely affecting
+ * the iteration process.
+ * 
+ * \param  dict   Pointer to the current texture dictionary.
+ *
+ * \param  pData   User-defined data pointer.
+ *
+ * \return Pointer to the current texture dictionary
+ *
+ * \see RwTexDictionaryForAllTexdictionaries
+ */
+typedef RwTexDictionary *(*RwTexDictionaryCallBack)(RwTexDictionary *dict, void *data);
+
+
+/**
+ * \ingroup datatypes
+ * \ref RwTextureCallBackMipmapGeneration 
+ * is the callback function supplied to \ref RwTextureSetMipmapGenerationCallBack 
+ * and returned from \ref RwTextureGetMipmapGenerationCallBack.
+ *
+ * The supplied function will be passed a pointer to a raster and an image.
+ * The raster is the target for the generated mipmap levels and the image 
+ * provides the base for their generation.
+ * 
+ * \param  raster   Pointer to raster, the target for generated mipmap levels
+ * \param  image    Pointer to image, used to generate mipmap levels.
+ * 
+ * \return
+ * Returns a pointer to the raster if successful or NULL if an error occurred.
+ * 
+ * \see RwTextureSetMipmapGenerationCallBack
+ * \see RwTextureGetMipmapGenerationCallBack
+ * \see RwTextureSetAutoMipmapping
+ * \see RwTextureGetAutoMipmapping
+ */
+typedef RwRaster *(*RwTextureCallBackMipmapGeneration)(RwRaster * raster,
+                                                       RwImage * image);
+
+/**
+ * \ingroup datatypes
+ * \ref RwTextureCallBackMipmapName
+ * is the callback function supplied to \ref RwTextureSetMipmapNameCallBack and
+ * returned from \ref RwTextureGetMipmapNameCallBack.
+ *
+ * The supplied function will be passed a pointer to a root name, a maskName, a mipmap
+ * level and a format. The function returns TRUE if successful and the root name will have been 
+ * modified to equal the mipmap name.
+ * 
+ * \param  name       Pointer to a string containing the root name of the texture. The 
+ * mipmap level name is put here.
+ * \param  maskName   Pointer to a string containing the root mask name of the texture or
+ * NULL if no mask name is required.
+ * \param  mipLevel   A value equal to the mipmap level for which the name is required.
+ * \param  format     A value describing the mipmapping mode. A combination of the bit
+ * flags rwRASTERFORMATMIPMAP and rwRASTERFORMATAUTOMIPMAP.
+ * 
+ * \return
+ * Returns TRUE if the name is generated successfully or FALSE if an error occurred.
+ * 
+ * \see RwTextureGenerateMipmapName
+ * \see RwTextureSetMipmapNameCallBack
+ * \see RwTextureGetMipmapNameCallBack
+ * \see RwTextureSetAutoMipmapping
+ * \see RwTextureGetAutoMipmapping
+ */
+typedef RwBool (*RwTextureCallBackMipmapName)(RwChar *name,
+                                              RwChar *maskName,
+                                              RwUInt8 mipLevel,
+                                              RwInt32 format);
+
+/****************************************************************************
+ <macro/inline functionality
+ */
+
+#define RwTextureGetRasterMacro(_tex)                       \
+    ((_tex)->raster)
+
+#define RwTextureAddRefMacro(_tex)                          \
+    (((_tex)->refCount++), (_tex))
+
+#define RwTextureAddRefVoidMacro(_tex)                      \
+MACRO_START                                                 \
+{                                                           \
+    (_tex)->refCount++;                                     \
+}                                                           \
+MACRO_STOP
+
+#define RwTextureGetNameMacro(_tex)                         \
+    ((_tex)->name)
+
+#define RwTextureGetMaskNameMacro(_tex)                     \
+    ((_tex)->mask)
+
+#define RwTextureGetDictionaryMacro(_tex)                   \
+    ((_tex)->dict)
+
+#define RwTextureSetFilterModeMacro(_tex, _filtering)                       \
+    (((_tex)->filterAddressing =                                            \
+      ((_tex)->filterAddressing & ~rwTEXTUREFILTERMODEMASK) |               \
+      (((RwUInt32)(_filtering)) &  rwTEXTUREFILTERMODEMASK)),               \
+     (_tex))
+
+#define RwTextureGetFilterModeMacro(_tex)                                   \
+    ((RwTextureFilterMode)((_tex)->filterAddressing &                       \
+                           rwTEXTUREFILTERMODEMASK))
+
+#define RwTextureSetAddressingMacro(_tex, _addressing)                      \
+    (((_tex)->filterAddressing =                                            \
+      ((_tex)->filterAddressing & ~rwTEXTUREADDRESSINGMASK) |               \
+      (((((RwUInt32)(_addressing)) <<  8) & rwTEXTUREADDRESSINGUMASK) |     \
+       ((((RwUInt32)(_addressing)) << 12) & rwTEXTUREADDRESSINGVMASK))),    \
+     (_tex))
+
+#define RwTextureSetAddressingUMacro(_tex, _addressing)                     \
+    (((_tex)->filterAddressing =                                            \
+      ((_tex)->filterAddressing & ~rwTEXTUREADDRESSINGUMASK) |              \
+      (((RwUInt32)(_addressing) << 8) & rwTEXTUREADDRESSINGUMASK)),         \
+     (_tex))
+
+#define RwTextureSetAddressingVMacro(_tex, _addressing)                     \
+    (((_tex)->filterAddressing =                                            \
+      ((_tex)->filterAddressing & ~rwTEXTUREADDRESSINGVMASK) |              \
+      (((RwUInt32)(_addressing) << 12) & rwTEXTUREADDRESSINGVMASK)),        \
+     (_tex))
+
+#define RwTextureGetAddressingMacro(_tex)                                   \
+    (((((_tex)->filterAddressing & rwTEXTUREADDRESSINGUMASK) >>  8) ==      \
+      (((_tex)->filterAddressing & rwTEXTUREADDRESSINGVMASK) >> 12)) ?      \
+     ((RwTextureAddressMode)(((_tex)->filterAddressing &                    \
+                              rwTEXTUREADDRESSINGVMASK) >> 12)) :           \
+     rwTEXTUREADDRESSNATEXTUREADDRESS)
+
+#define RwTextureGetAddressingUMacro(_tex)                                  \
+    ((RwTextureAddressMode)(((_tex)->filterAddressing &                     \
+                             rwTEXTUREADDRESSINGUMASK) >> 8))
+
+#define RwTextureGetAddressingVMacro(_tex)                                  \
+    ((RwTextureAddressMode)(((_tex)->filterAddressing &                     \
+                             rwTEXTUREADDRESSINGVMASK) >> 12))
+
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define RwTextureGetRaster(_tex)                            \
+    RwTextureGetRasterMacro(_tex)
+
+#define RwTextureAddRef(_tex)                               \
+    RwTextureAddRefMacro(_tex)
+
+#define RwTextureGetName(_tex)                              \
+    RwTextureGetNameMacro(_tex)
+
+#define RwTextureGetMaskName(_tex)                          \
+    RwTextureGetMaskNameMacro(_tex)
+
+#define RwTextureGetDictionary(_tex)                        \
+    RwTextureGetDictionaryMacro(_tex)
+
+#define RwTextureSetFilterMode(_tex, _filtering)            \
+    RwTextureSetFilterModeMacro(_tex, _filtering)
+
+#define RwTextureGetFilterMode(_tex)                        \
+    RwTextureGetFilterModeMacro(_tex)
+
+#define RwTextureSetAddressing(_tex, _addressing)           \
+    RwTextureSetAddressingMacro(_tex, _addressing)
+
+#define RwTextureSetAddressingU(_tex, _addressing)          \
+    RwTextureSetAddressingUMacro(_tex, _addressing)
+
+#define RwTextureSetAddressingV(_tex, _addressing)          \
+    RwTextureSetAddressingVMacro(_tex, _addressing)
+
+#define RwTextureGetAddressing(_tex)                        \
+    RwTextureGetAddressingMacro(_tex)
+
+#define RwTextureGetAddressingU(_tex)                       \
+    RwTextureGetAddressingUMacro(_tex)
+
+#define RwTextureGetAddressingV(_tex)                       \
+    RwTextureGetAddressingVMacro(_tex)
+
+#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef    __cplusplus
+extern              "C"
+{
+#endif                          /* __cplusplus */
+
+    /* Reading mip maps */
+
+    /* Setting mip mapping states */
+extern RwBool       RwTextureSetMipmapping(RwBool enable);
+extern RwBool       RwTextureGetMipmapping(void);
+extern RwBool       RwTextureSetAutoMipmapping(RwBool enable);
+extern RwBool       RwTextureGetAutoMipmapping(void);
+
+    /* Setting and getting the mipmap generation function */
+extern              RwBool
+RwTextureSetMipmapGenerationCallBack(RwTextureCallBackMipmapGeneration
+                                     callback);
+extern              RwTextureCallBackMipmapGeneration
+RwTextureGetMipmapGenerationCallBack(void);
+
+    /* Setting and getting the mipmap file name generation function */
+extern              RwBool
+RwTextureSetMipmapNameCallBack(RwTextureCallBackMipmapName callback);
+extern RwTextureCallBackMipmapName RwTextureGetMipmapNameCallBack(void);
+
+    /* Generating mipmaps for a raster */
+extern RwBool       RwTextureGenerateMipmapName(RwChar * name,
+                                                RwChar * maskName,
+                                                RwUInt8 mipLevel,
+                                                RwInt32 format);
+extern RwBool       RwTextureRasterGenerateMipmaps(RwRaster * raster,
+                                                   RwImage * image);
+
+    /* LEGACY-SUPPORT mip mapping */
+extern RwBool       _rwTextureSetAutoMipMapState(RwBool enable);
+extern RwBool       _rwTextureGetAutoMipMapState(void);
+
+    /* Setting and getting the callback function */
+extern RwTextureCallBackRead RwTextureGetReadCallBack(void);
+extern RwBool       RwTextureSetReadCallBack(RwTextureCallBackRead
+                                             fpCallBack);
+
+    /* Texture and mask names */
+extern RwTexture   *RwTextureSetName(RwTexture * texture,
+                                     const RwChar * name);
+extern RwTexture   *RwTextureSetMaskName(RwTexture * texture,
+                                         const RwChar * maskName);
+
+    /* Creating/destroying dictionaries */
+extern RwTexDictionary *RwTexDictionaryCreate(void);
+extern RwBool       RwTexDictionaryDestroy(RwTexDictionary * dict);
+
+    /* Textures */
+extern RwTexture   *RwTextureCreate(RwRaster * raster);
+extern RwBool       RwTextureDestroy(RwTexture * texture);
+
+    /* Setting and getting texture map rasters */
+extern RwTexture   *RwTextureSetRaster(RwTexture * texture,
+                                       RwRaster * raster);
+
+    /* Dictionary access */
+extern RwTexture   *RwTexDictionaryAddTexture(RwTexDictionary * dict,
+                                              RwTexture * texture);
+extern RwTexture   *RwTexDictionaryRemoveTexture(RwTexture * texture);
+extern RwTexture   *RwTexDictionaryFindNamedTexture(RwTexDictionary *
+                                                    dict,
+                                                    const RwChar * name);
+
+    /* Reading a texture */
+extern RwTexture   *RwTextureRead(const RwChar * name,
+                                  const RwChar * maskName);
+
+    /* Setting the current dictionary */
+extern RwTexDictionary *RwTexDictionaryGetCurrent(void);
+extern RwTexDictionary *RwTexDictionarySetCurrent(RwTexDictionary * dict);
+
+    /* Enumerating textures */
+extern const RwTexDictionary *RwTexDictionaryForAllTextures(const
+                                                            RwTexDictionary
+                                                            * dict,
+                                                            RwTextureCallBack
+                                                            fpCallBack,
+                                                            void *pData);
+
+    /* Enumerating the texture dictionaries currently in the system */
+extern RwBool RwTexDictionaryForAllTexDictionaries(
+    RwTexDictionaryCallBack fpCallBack, void *pData);
+
+
+    /* Attaching toolkits */
+extern RwInt32      RwTextureRegisterPlugin(RwInt32 size,
+                                            RwUInt32 pluginID,
+                                            RwPluginObjectConstructor
+                                            constructCB,
+                                            RwPluginObjectDestructor
+                                            destructCB,
+                                            RwPluginObjectCopy copyCB);
+extern RwInt32      RwTexDictionaryRegisterPlugin(RwInt32 size,
+                                                  RwUInt32 pluginID,
+                                                  RwPluginObjectConstructor
+                                                  constructCB,
+                                                  RwPluginObjectDestructor
+                                                  destructCB,
+                                                  RwPluginObjectCopy
+                                                  copyCB);
+extern RwInt32      RwTextureGetPluginOffset(RwUInt32 pluginID);
+extern RwInt32      RwTexDictionaryGetPluginOffset(RwUInt32 pluginID);
+extern RwBool       RwTextureValidatePlugins(const RwTexture * texture);
+extern RwBool       RwTexDictionaryValidatePlugins(const RwTexDictionary *
+                                                   dict);
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+/* Textures */
+extern RwRaster *RwTextureGetRaster(const RwTexture *texture);
+extern RwTexture *RwTextureAddRef(RwTexture *texture);
+
+/* Texture and mask names */
+extern RwChar *RwTextureGetName(RwTexture *texture);
+extern RwChar *RwTextureGetMaskName(RwTexture *texture);
+
+/* Get owner dictionary */
+extern RwTexDictionary *RwTextureGetDictionary(RwTexture *texture);
+
+/* Filtering */
+extern RwTexture *RwTextureSetFilterMode(RwTexture *texture,
+                                         RwTextureFilterMode filtering);
+
+extern RwTextureFilterMode RwTextureGetFilterMode(const RwTexture *texture);
+
+/* Addressing */
+extern RwTexture *RwTextureSetAddressing(RwTexture *texture,
+                                         RwTextureAddressMode addressing);
+extern RwTexture *RwTextureSetAddressingU(RwTexture *texture,
+                                          RwTextureAddressMode addressing);
+extern RwTexture *RwTextureSetAddressingV(RwTexture *texture,
+                                          RwTextureAddressMode addressing);
+
+extern RwTextureAddressMode RwTextureGetAddressing(const RwTexture *texture);
+extern RwTextureAddressMode RwTextureGetAddressingU(const RwTexture *texture);
+extern RwTextureAddressMode RwTextureGetAddressingV(const RwTexture *texture);
+
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+#define RwTextureSetAutoMipMapState(_enable) \
+    _rwTextureSetAutoMipMapState(_enable)
+
+#define RwTextureGetAutoMipMapState() \
+    _rwTextureGetAutoMipMapState()
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/p2stdcls.h ---*/
+
+/*
+ * Current:
+ *
+ * wait on Simon for instructions to do cluster renaming thing,
+ * or go thru and  change all cluster type names and cluster
+ * names (add CSL?)
+ *
+ */
+
+/* CamVerts.csl */
+
+/* clip flags */
+
+/**
+ * \ingroup rwcoregeneric
+ * \ref RwClipFlag
+ * Flags specifying the clipping status of a vertex
+ */
+enum RwClipFlag
+{
+    rwXLOCLIP   = 0x01, /**<The vertex is outside the low X clip-plane */
+    rwXHICLIP   = 0x02, /**<The vertex is outside the high X clip-plane */
+    rwXCLIP     = 0x03, /**<The vertex is outside an X clip-plane */
+
+    rwYLOCLIP   = 0x04, /**<The vertex is outside the low Y clip-plane */
+    rwYHICLIP   = 0x08, /**<The vertex is outside the high Z clip-plane */
+    rwYCLIP     = 0x0C, /**<The vertex is outside a Y clip-plane */
+
+    rwZLOCLIP   = 0x10, /**<The vertex is outside the low Z clip-plane */
+    rwZHICLIP   = 0x20, /**<The vertex is outside the high Z clip-plane */
+    rwZCLIP     = 0x30, /**<The vertex is outside a Z clip-plane */
+
+    rwCLIPMASK  = 0x3F, /**<Mask covering all used bits in the clip flags
+                         * in case a plugin  wants free ones to use (e.g RpGloss) */
+
+    rwCLIPFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwClipFlag RwClipFlag;
+
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RwClipFlag
+ * Typedef for RwClipFlag enumeration specifying the clipping status of a vertex
+ */
+
+
+typedef struct RxCamSpace3DVertex RxCamSpace3DVertex;
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxCamSpace3DVertex
+ * Structure describing a camera-space 3D vertex.
+ */
+struct RxCamSpace3DVertex
+{
+    /* Position in sheared camera-space (pre-projection) */
+    RwV3d           cameraVertex; /**< \ref RwV3d camera-space position of the vertex */
+    /* Clip flags on this vertex */
+    RwUInt8         clipFlags;    /**< Clip flags for the vertex generated during transformation into camera-space, see \ref RwClipFlag */
+    RwUInt8         pad[3];       /**< Alignment padding */
+    /* Lit colour */
+    RwRGBAReal      col;          /**< Accumulated \ref RwReal light values (initialized to zero or prelight colours) */
+    /* Only used by the clipper */
+    RwReal          u;            /**< Texture U coordinate */
+    RwReal          v;            /**< Texture V coordinate */
+};
+
+/* Supports pipeline1 apps: */
+/**
+ * \ingroup datatypes
+ * \typedef RwCameraVertex
+ * typedef for a structure describing a camera-space 3D vertex.
+ */
+typedef RxCamSpace3DVertex RwCameraVertex;
+
+/* (used during lighting) Doesn't use alpha yet, but it will */
+#define RxCamSpace3DVertexSetRGBA(camvert, r, g, b, a)  \
+MACRO_START                                             \
+{                                                       \
+    ((camvert)->col.red = (r));                         \
+    ((camvert)->col.green = (g));                       \
+    ((camvert)->col.blue = (b));                        \
+    ((camvert)->col.alpha = (a));                       \
+}                                                       \
+MACRO_STOP
+
+#define RxCamSpace3DVertexAddRGBA(camvert, r, g, b, a)  \
+MACRO_START                                             \
+{                                                       \
+    ((camvert)->col.red += (r));                        \
+    ((camvert)->col.green += (g));                      \
+    ((camvert)->col.blue += (b));                       \
+    ((camvert)->col.alpha += (a));                      \
+}                                                       \
+MACRO_STOP
+
+/* LEGACY-SUPPORT macros */
+#define RXCAMSPACE3DVERTEXSetRGBA(camvert, r, g, b, a)  \
+    RxCamSpace3DVertexSetRGBA(camvert, r, g, b, a)
+#define RXCAMSPACE3DVERTEXAddRGBA(camvert, r, g, b, a)  \
+    RxCamSpace3DVertexAddRGBA(camvert, r, g, b, a)
+
+/* MeshState.csl */
+
+
+/**
+ * \ingroup rwcoregeneric
+ * \ref RxGeometryFlag
+ * Flags describing geometry properties
+ */
+enum RxGeometryFlag
+{
+    rxGEOMETRY_TRISTRIP      = 0x01,  /**<This geometry's meshes can be rendered as tri-strips */
+    rxGEOMETRY_POSITIONS     = 0x02,  /**<This geometry has positions */
+    rxGEOMETRY_TEXTURED      = 0x04,  /**<This geometry has textures applied */
+    rxGEOMETRY_PRELIT        = 0x08,  /**<This geometry has luminance values */
+    rxGEOMETRY_NORMALS       = 0x10,  /**<This geometry has normals */
+    rxGEOMETRY_LIGHT         = 0x20,  /**<This geometry will be lit */
+    rxGEOMETRY_MODULATE      = 0x40,  /**<This geometry will modulate the material color with the vertex colors (prelit + lit) */
+    rxGEOMETRY_TEXTURED2     = 0x80,  /**<This geometry has 2 set of texture coordinates */
+
+    rxGEOMETRY_COLORED       = 0x100, /**<This mesh specifies per-vertex colors. NB: ONLY USED IN IM3D */
+
+    rxGEOMETRYFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxGeometryFlag
+ * Typedef for RxGeometryFlag enumeration describing geometry properties
+ */
+typedef enum RxGeometryFlag RxGeometryFlag;
+
+typedef struct RxMeshStateVector RxMeshStateVector;
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxMeshStateVector
+ * Structure describing a mesh-state vector,
+ * used by the RxClMeshState cluster
+ */
+struct RxMeshStateVector
+{
+    RwInt32             Flags;              /**< \ref RxGeometryFlag Flags from the source geometry */
+    void               *SourceObject;       /**< A void pointer. In immediate mode it points to an
+                                             * internal structure and in atomic/world-sector object
+                                             * or material pipelines it points to an \ref RpMaterial. */
+    RwMatrix            Obj2World;          /**< \ref RwMatrix to transform from object-space to world-space */
+    RwMatrix            Obj2Cam;            /**< \ref RwMatrix to transform from object-space to camera-space */
+    RwSurfaceProperties SurfaceProperties;  /**< \ref RwSurfaceProperties */
+    /* We can't necessarily reference an RpMaterial in here (i.e with Im3D),
+     * because RpMaterials are defined in RpWorld not RwCore */
+    RwTexture          *Texture;            /**< A pointer to a \ref RwTexture */
+    RwRGBA              MatCol;             /**< \ref RwRGBA material colour */
+    RxPipeline         *Pipeline;           /**< A pointer to the material pipeline where appropriate */
+    /* rwPRIMTYPETRILIST/TRIFAN/TRISTRIP/LINELIST/POLYLINE */
+    RwPrimitiveType     PrimType;           /**< \ref RwPrimitiveType primitive type */
+    /* Interpretation based on PrimType */
+    RwUInt32            NumElements;        /**< \ref RwUInt32 number of elements (triangles, lines...) */
+    RwUInt32            NumVertices;        /**< \ref RwUInt32 number of vertices */
+    RwInt32             ClipFlagsOr;        /**< Boolean OR of the \ref RwClipFlag clip flags of all vertices in the mesh */
+    RwInt32             ClipFlagsAnd;       /**< Boolean AND of the \ref RwClipFlag clip flags of all vertices in the mesh */
+    void               *SourceMesh;         /**< A void pointer to the source \ref RpMesh */
+    void               *DataObject;         /**< Mirrors the void data pointer of \ref RxPipelineExecute */
+};
+
+/* RxScatter.csl */
+typedef struct RxScatter RxScatter;
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxScatter
+ * Structure used by the RxClScatter cluster
+ */
+struct RxScatter
+{
+    RxPipeline    *pipeline; /**< \ref RxPipeline pointer, causes Scatter.csl
+                              * to spit the packet out to the specified pipeline */
+    RxPipelineNode *node;    /**< \ref RxPipelineNode pointer, causes Scatter.csl
+                              * to send the packet to the specified PipelineNode
+                              * (as long as it is actually one of its outputs!) */
+};
+
+/* RxInterpolants.csl */
+typedef struct RxInterp RxInterp;
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxInterp
+ * Structure used by the RxClInterp cluster
+ */
+struct RxInterp
+{
+    RxVertexIndex originalVert; /**< \ref RxVertexIndex index to the new vertex generated on the clipped edge */
+    RxVertexIndex parentVert1;  /**< \ref RxVertexIndex index to the first vertex of the clipped edge */
+    RxVertexIndex parentVert2;  /**< \ref RxVertexIndex index to the second vertex of the clipped edge */
+    RwReal        interp;       /**< \ref RwReal interpolant along the clipped edge */
+};
+
+/* RxUVs.csl */
+typedef struct RxUV RxUV;
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxUV
+ * Structure used by the RxClUV cluster
+ */
+struct RxUV
+{
+    RwReal u; /**< \ref RwReal U texture coordinate */
+    RwReal v; /**< \ref RwReal V texture coordinate */
+};
+
+/* RxTriPlanes.csl */
+typedef struct RxTriPlane RxTriPlane;
+
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxTriPlane
+ * for the packed plane structure used in RpWorlds and by the RxClTriPlane cluster
+ * NOTE: this is currently not used in any nodes that ship with the SDK
+ */
+struct RxTriPlane
+{
+    /* Packed plane format used in RpWorlds */
+    RwUInt32 N; /**< \ref RwUInt32 Packed normal */
+    RwReal   w; /**< \ref RwReal distance from origin */
+};
+
+/* RxVSteps.csl */
+
+#if (defined(_MSC_VER))
+#  if (_MSC_VER>=1000)
+#    pragma pack(push, 1)
+#  endif /* (_MSC_VER>=1000) */
+#endif /* (defined(_MSC_VER)) */
+
+typedef struct RxVStep RxVStep;
+/**
+ * \ingroup rwcoregeneric
+ * \struct RxVStep
+ * Structure used by the RxClVStep cluster.
+ * To use the step values in the RxClVStep cluster, start at the beginning
+ * of the RxVStep and vertex arrays and proceed as follows: (a) Process one
+ * vertex, (b) Skip 'step' vertices, (c) Increment the cursor of the RxClVStep
+ * cluster. Repeat (a)-(c) until the entire vertex array has been processed.
+ * If the RxVStep array contains valid data, you should not have to bounds-check
+ * its cursor.
+ */
+struct RxVStep
+{
+    RwUInt8 step; /**< \ref RwUInt8 The number of vertices after the current one
+                   * which can be skipped in lighting and other calculations because,
+                   * for example, they belong only to back-facing triangles */
+};
+
+#if (defined(_MSC_VER))
+#  if (_MSC_VER>=1000)
+#    pragma pack(pop)
+#  endif /* (_MSC_VER>=1000) */
+#endif /* (defined(_MSC_VER)) */
+
+/* CamNorms.csl */
+/**
+ * \ingroup rwcoregeneric
+ * \typedef RxCamNorm
+ * typedef for \ref RwV3d used by the RxClVStep cluster */
+typedef RwV3d RxCamNorm;
+
+
+#ifdef    __cplusplus
+extern "C"
+{
+#endif                          /* __cplusplus */
+
+/* Uses the RxObjSpace3DVertex type (see pipmodel.h) */
+extern RxClusterDefinition RxClObjSpace3DVertices;
+/* Uses the RxCamSpace3DVertex type */
+extern RxClusterDefinition RxClCamSpace3DVertices;
+/* Uses the RxScrSpace2DVertex type (see pipmodel.h) */
+extern RxClusterDefinition RxClScrSpace2DVertices;
+/* Uses the RxInterp type */
+extern RxClusterDefinition RxClInterpolants;
+/* Uses the RxMeshStateVector type */
+extern RxClusterDefinition RxClMeshState;
+/* Uses the RxRenderStateVector type (p2renderstate.c/h) */
+extern RxClusterDefinition RxClRenderState;
+/* Uses the RxVertexIndex type */
+extern RxClusterDefinition RxClIndices;
+/* Uses the RxScatter type */
+extern RxClusterDefinition RxClScatter;
+/* Uses the RxUV type */
+extern RxClusterDefinition RxClUVs;
+/* Uses the RxVStep type */
+extern RxClusterDefinition RxClVSteps;
+/* Uses the RwRGBAReal type */
+extern RxClusterDefinition RxClRGBAs;
+/* Uses the RxCamNorm type */
+extern RxClusterDefinition RxClCamNorms;
+
+/* Uses the RxTriPlane type.
+ * NOTE: this is currently not used in any nodes that ship with the SDK */
+extern RxClusterDefinition RxClTriPlanes;
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/baim3d.h ---*/
+
+/**
+ * \ingroup datatypes
+ * RwIm3DTransformFlags
+ *  The bit-field type  RwIm3DTransformFlags
+ * specifies options available for controlling execution of the 3D immediate
+ * mode pipeline (see API function \ref RwIm3DTransform):*/
+enum RwIm3DTransformFlags
+{
+    rwIM3D_VERTEXUV      = 1,   /**<Texture coordinates in source vertices should be used */
+    rwIM3D_ALLOPAQUE     = 2,   /**<All source vertices are opaque (alpha is 255) */
+    rwIM3D_NOCLIP        = 4,   /**<No clipping should be performed on the geometry (the
+                                 * app may know it is all onscreen or within the guard band clipping
+                                 * region for the current hardware, so clipping can be skipped) */
+    rwIM3D_VERTEXXYZ     = 8,   /**<Vertex positions */
+    rwIM3D_VERTEXRGBA    = 16,  /**<Vertex color */
+
+    rwIM3DTRANSFORMFLAGSFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwIm3DTransformFlags RwIm3DTransformFlags;
+
+
+
+typedef struct rwIm3DPool            rwIm3DPool;
+typedef struct rwImmediGlobals       rwImmediGlobals;
+typedef struct rwIm3DRenderPipelines rwIm3DRenderPipelines;
+typedef struct _rwIm3DPoolStash       _rwIm3DPoolStash;
+
+#if (0 && defined(SKY2))
+typedef struct rwIm3DVertexCache     RwIm3DVertexCache;
+#endif /* (0&& defined(SKY2)) */
+
+/* complete information to reconstruct post-transform Im3D "mesh" packet */
+struct _rwIm3DPoolStash
+{
+    RwUInt32                 flags;    /* rwIM3D_VERTEXUV, rwIM3D_ALLOPAQUE, rwIM3D_NOCLIP etc */
+    RwMatrix                *ltm;      /* world-space frame of the vertices, if they have one */
+    RwUInt32                 numVerts;
+    RxObjSpace3DVertex      *objVerts;
+    RxCamSpace3DVertex      *camVerts;
+    RxScrSpace2DVertex      *devVerts;
+    RxMeshStateVector       *meshState;
+    RxRenderStateVector     *renderState;
+    RxPipeline              *pipeline;
+    RwPrimitiveType          primType;
+    RxVertexIndex           *indices;
+    RwUInt32                 numIndices;
+};
+
+/* Used as a cache of transformed vertices */
+struct rwIm3DPool
+{
+    RwUInt16         numElements; /* could become RwUInt32 nowadays */
+    RwUInt16         pad;         /* alignment padding */
+    void            *elements;    /* the original array of verts (or whatever...) - referenced not copied */
+    RwInt32          stride;      /* the stride of the element */
+    _rwIm3DPoolStash  stash;
+};
+
+struct rwIm3DRenderPipelines
+{
+    /* One Im3D render pipeline pointer per rwPRIMTYPE
+     * (several pointers may point to the same pipeline though) */
+    RxPipeline *triList;
+    RxPipeline *triFan;
+    RxPipeline *triStrip;
+    RxPipeline *lineList;
+    RxPipeline *polyLine;
+    RxPipeline *pointList;
+};
+
+struct rwImmediGlobals
+{
+    RxPipeline           *genericIm3DTransformPipeline;
+    rwIm3DRenderPipelines genericIm3DRenderPipelines;
+
+    RxPipeline           *im3DTransformPipeline;
+    rwIm3DRenderPipelines im3DRenderPipelines;
+
+    /* Platforms that have their own non-generic pipelines
+     * (OPENGL, D3D7, SKY2, KAMUI2, DOLPHIN) put them here: */
+    RxPipeline           *platformIm3DTransformPipeline;
+    rwIm3DRenderPipelines platformIm3DRenderPipelines;
+
+#if (defined(SKY2_DRVMODEL_H))
+    /* The triangle PS2All render pipe automatically
+     * calls this PS2AllMat pipeline: */
+    RxPipeline           *ps2AllMatIm3DTrianglePipeline;
+    /* The line PS2All render pipe automatically
+     * calls this PS2AllMat pipeline: */
+    RxPipeline           *ps2AllMatIm3DLinePipeline;
+    /* PS2Manager pipelines */
+    RxPipeline           *ps2ManagerIm3DRenderPipeline;
+#endif /* (defined(SKY2_DRVMODEL_H)) */
+
+    rwIm3DPool   curPool;              /* The current cache of transformed vertices */
+};
+
+
+#ifdef    __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern rwIm3DPool *_rwIm3DGetPool( void );
+
+extern void  *RwIm3DTransform(RwIm3DVertex *pVerts, RwUInt32 numVerts,
+                              RwMatrix *ltm, RwUInt32 flags);
+extern RwBool RwIm3DEnd(void);
+
+extern RwBool RwIm3DRenderLine(RwInt32 vert1, RwInt32 vert2);
+extern RwBool RwIm3DRenderTriangle(RwInt32 vert1, RwInt32 vert2,
+                                   RwInt32 vert3);
+extern RwBool RwIm3DRenderIndexedPrimitive(RwPrimitiveType primType,
+                                           RwImVertexIndex *indices,
+                                           RwInt32 numIndices);
+extern RwBool RwIm3DRenderPrimitive(RwPrimitiveType primType);
+
+extern RxPipeline *RwIm3DGetGenericTransformPipeline(void);
+extern RxPipeline *RwIm3DGetGenericRenderPipeline(RwPrimitiveType primType);
+
+extern RxPipeline *RwIm3DGetTransformPipeline(void);
+extern RxPipeline *RwIm3DGetRenderPipeline(   RwPrimitiveType  primType);
+extern RxPipeline *RwIm3DSetTransformPipeline(RxPipeline *pipeline);
+extern RxPipeline *RwIm3DSetRenderPipeline(   RxPipeline *pipeline,
+                                              RwPrimitiveType primType);
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/d3d8/im3dpipe.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/d3d8dxttex.h ---*/
+#ifdef    __cplusplus
+extern "C"
+{
+#endif                          /* __cplusplus */
+
+extern RwTexture *RwD3D8DDSTextureRead(const RwChar *name, const RwChar *maskname);
+
+extern RwBool RwD3D8RasterIsCompressed(const RwRaster *raster);
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/d3d8/drvfns.h ---*/
+
+#ifdef    __cplusplus
+extern "C"
+{
+#endif                          /* __cplusplus */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+/*******/
+/* API */
+/*******/
+
+/* Reports on whether D3D8 can render S3TC textures */
+extern RwBool 
+RwD3D8DeviceSupportsDXTTexture(void);
+
+/* Get handle to D3D8 device - useful for setting D3D8 renderstate*/
+extern void *
+RwD3D8GetCurrentD3DDevice(void);
+
+/* Get maximun number of multisampling levels */
+extern RwUInt32
+RwD3D8EngineGetMaxMultiSamplingLevels(void);
+
+/* Set number of multisampling levels */
+extern void
+RwD3D8EngineSetMultiSamplingLevels(RwUInt32 numLevels);
+
+/* Set maximun full screen refresh rate */
+extern void
+RwD3D8EngineSetRefreshRate(RwUInt32 refreshRate);
+
+/* Get handle to D3D8 rendering surface - useful for advanced blit ops */
+extern void *
+RwD3D8GetCurrentD3DRenderTarget(void);
+
+/* Atach a window to a camera */
+extern RwBool
+RwD3D8CameraAttachWindow(void *camera, void *hwnd);
+
+/* Immediate mode rendering */
+extern RwBool       RwD3D8SetVertexShader(RwUInt32 handle);
+extern RwBool       RwD3D8SetPixelShader(RwUInt32 handle);
+extern RwBool       RwD3D8SetStreamSource(RwUInt32 streamNumber, void *streamData, RwUInt32 stride);
+extern RwBool       RwD3D8SetIndices(void *indexData, RwUInt32 baseVertexIndex);
+
+extern RwBool       RwD3D8DrawIndexedPrimitiveUP(RwUInt32 primitiveType,
+                                                  RwUInt32 minIndex,
+                                                  RwUInt32 numVertices,
+                                                  RwUInt32 numIndices,
+                                                  const void* indexData,
+                                                  const void* vertexStreamZeroData,
+                                                  RwUInt32 VertexStreamZeroStride);
+
+extern RwBool       RwD3D8DrawPrimitiveUP(RwUInt32 primitiveType,
+                                                  RwUInt32 numVertices,
+                                                  const void* vertexStreamZeroData,
+                                                  RwUInt32 VertexStreamZeroStride);
+
+extern RwBool       RwD3D8DrawIndexedPrimitive(RwUInt32 primitiveType,
+                                                  RwUInt32 minIndex,
+                                                  RwUInt32 numVertices,
+                                                  RwUInt32 startIndex,
+                                                  RwUInt32 numIndices);
+
+extern RwBool       RwD3D8DrawPrimitive(RwUInt32 primitiveType,
+                                                  RwUInt32 startVertex,
+                                                  RwUInt32 numVertices);
+
+extern RwBool       RwD3D8SetTexture(RwTexture *texture, RwUInt32 stage);
+
+extern RwBool       RwD3D8SetRenderState(RwUInt32 state, RwUInt32 value);
+extern RwBool       RwD3D8SetTextureStageState(RwUInt32 stage, RwUInt32 type, RwUInt32 value);
+extern RwBool       RwD3D8SetTransform(RwUInt32 state, const void *matrix);
+extern RwBool       RwD3D8SetMaterial(const void *material);
+extern void         RwD3D8SetStencilClear(RwUInt32 stencilClear);
+
+
+extern void         RwD3D8GetRenderState(RwUInt32 state, void *value);
+extern void         RwD3D8GetTextureStageState(RwUInt32 stage, RwUInt32 type, void *value);
+extern void         RwD3D8GetTransform(RwUInt32 state, void *matrix);
+extern RwUInt32     RwD3D8GetStencilClear(void);
+
+/*
+ * To convert between RwMatrix to D3DMATRIX when setting the
+ * world matrix
+ */
+extern RwBool       RwD3D8SetTransformWorld(const RwMatrix *matrix);
+
+/*
+ * To convert between RpMaterial to D3DMATERIAL8
+ */
+extern RwBool       RwD3D8SetSurfaceProperties(const RwRGBA *color,
+                                                const RwSurfaceProperties *surfaceProps,
+                                                RwBool modulate);
+
+/*
+ * To set on that index the light from the descriptor
+ */
+extern RwBool       RwD3D8SetLight(RwInt32 index, const void *light);
+extern void         RwD3D8GetLight(RwInt32 index, void *light);
+
+extern RwBool       RwD3D8EnableLight(RwInt32 index, RwBool enable);
+
+/*
+ * To get a pointer to a Dynamic vertex buffer
+ * Use both functions, Create and Destroy, not only Create
+ */
+extern RwBool RwD3D8DynamicVertexBufferCreate(RwUInt32 fvf, RwUInt32 size,
+                                               void **vertexBuffer);
+
+extern void RwD3D8DynamicVertexBufferDestroy(void *vertexBuffer);
+
+/*
+ * To get a temporary pointer to a Dynamic vertex buffer memory
+ * Don't use with the previous functions because
+ * it mantains an internal list of dinamic vertex buffers
+ */
+extern RwBool RwD3D8DynamicVertexBufferLock(RwUInt32 vertexSize,
+                                            RwUInt32 numVertex,
+                                            void **vertexBufferOut,
+                                            void **vertexDataOut,
+                                            RwUInt32 *baseIndexOut);
+
+extern RwBool RwD3D8DynamicVertexBufferUnlock(void *vertexBuffer);
+
+/*
+ * To get a pointer to an Index vertex buffer
+ * It's created as WRITEONLY, MANAGED and D3DFMT_INDEX16
+ */
+extern RwBool RwD3D8IndexBufferCreate(RwUInt32 numIndices,
+                                       void **indexBuffer);
+
+/*
+ * To create a vertex shader from the declaration, also the function
+ * for deleting it.
+ */
+extern RwBool RwD3D8CreateVertexShader(const RwUInt32 *declaration,
+                                      const RwUInt32 *function,
+                                      RwUInt32 *handle,
+                                      RwUInt32 usage);
+
+extern void RwD3D8DeleteVertexShader(RwUInt32 handle);
+
+extern RwBool RwD3D8SetVertexShaderConstant(RwUInt32 registerAddress,
+                                          const void *constantData,
+                                          RwUInt32  constantCount);
+
+/*
+ * To create a pixel shader from the function, also the function
+ * for deleting it.
+ */
+extern RwBool RwD3D8CreatePixelShader(const RwUInt32 *function, RwUInt32 *handle);
+
+extern void RwD3D8DeletePixelShader(RwUInt32 handle);
+
+extern RwBool RwD3D8SetPixelShaderConstant(RwUInt32 registerAddress,
+                                          const void *constantData,
+                                          RwUInt32  constantCount);
+
+/*
+ * Get a const pointer to the D3DCAPS8 struct, (you need to do the cast)
+ */
+extern const void *RwD3D8GetCaps(void);
+
+/*
+ * Check if the sphere is fully inside of the frustum
+ */
+extern RwBool RwD3D8CameraIsSphereFullyInsideFrustum(const void *camera, const void *sphere);
+
+/*
+ * Check if the Bounding Box is fully inside of the frustum
+ */
+extern RwBool RwD3D8CameraIsBBoxFullyInsideFrustum(const void *camera, const void *boundingBox);
+
+/*
+ * Cheking the CPU capabilities
+ */
+
+extern RwBool _rwIntelSSEsupported(void);
+extern RwBool _rwIntelMMXsupported(void);
+
+/*
+ * Enabling texture format conversions when loading textures from a texture
+ * dictionary. FALSE by default.
+ */
+extern void
+_rwD3D8TexDictionaryEnableRasterFormatConversion(RwBool enable);
+
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+
+/* LEGACY-MACRO */
+/**
+ * \ingroup rwcoredriverd3d8
+ * \ref RwD3DLoadNativeTexture is a legacy macro for compatability with
+ * RWD3D7 applications that can be used to read a compressed texture from
+ * the specified DDS file on disk.
+ *
+ * It is recommended that applications for RWD3D8 should use the RWD3D8
+ * function \ref RwD3D8DDSTextureRead instead.
+ *
+ * \param name Pointer to a string containing the name of the texture to be read.
+ * \param maskname  Pointer to a string containing the name of the mask or
+ * NULL if not required.
+ *
+ * \return Returns pointer to the new texture if successful or NULL if there
+ * is an error.
+ *
+ * \see RwD3D8DDSTextureRead
+ * \see RwD3D8DeviceSupportsDXTTexture
+ * \see RwImageSetPath
+ * \see RwTextureSetReadCallBack
+ * \see RwTextureSetMipmapping
+ * \see RwTextureSetAutoMipmapping
+ * \see RwTextureDestroy
+ *
+ */
+#define RwD3DLoadNativeTexture RwD3D8DDSTextureRead
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/baresamp.h ---*/
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef    __cplusplus
+extern "C"
+{
+#endif                          /* __cplusplus */
+
+extern RwImage *RwImageResample(RwImage *dstImage, const RwImage *srcImage);
+extern RwImage *RwImageCreateResample(const RwImage *srcImage, RwInt32 width,
+                                                               RwInt32 height);
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/baimras.h ---*/
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef    __cplusplus
+extern "C"
+{
+#endif                          /* __cplusplus */
+
+/* Images from rasters */
+extern RwImage *RwImageSetFromRaster(RwImage *image, RwRaster *raster);
+
+/* Rasters from images */
+extern RwRaster *RwRasterSetFromImage(RwRaster *raster, RwImage *image);
+
+/* Finding raster formats */
+extern RwRGBA *RwRGBAGetRasterPixel(RwRGBA *rgbOut, RwRaster *raster,
+                                   RwInt32 x, RwInt32 y);
+
+/* Read a raster */
+extern RwRaster *RwRasterRead(const RwChar *filename);
+extern RwRaster *RwRasterReadMaskedRaster(const RwChar *filename, const RwChar *maskname);
+
+/* Finding appropriate raster formats */
+extern RwImage *RwImageFindRasterFormat(RwImage *ipImage,RwInt32 nRasterType,
+                                        RwInt32 *npWidth,RwInt32 *npHeight,
+                                        RwInt32 *npDepth,RwInt32 *npFormat);
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/baframe.h ---*/
+
+/****************************************************************************
+ Defines
+ */
+
+#if (!defined(RWFRAMESTATICPLUGINSSIZE))
+#define RWFRAMESTATICPLUGINSSIZE 0
+#endif
+
+#define RWFRAMEALIGNMENT(_frame) \
+   (! (((rwFRAMEALIGNMENT)-1) & ((RwUInt32)(_frame))))
+
+/* Type ID */
+#define rwFRAME 0
+
+/* dirty flag bits */
+#define rwFRAMEPRIVATEHIERARCHYSYNCLTM  0x01
+#define rwFRAMEPRIVATEHIERARCHYSYNCOBJ  0x02
+#define rwFRAMEPRIVATESUBTREESYNCLTM    0x04
+#define rwFRAMEPRIVATESUBTREESYNCOBJ    0x08
+#define rwFRAMEPRIVATESTATIC            0x10
+
+/****************************************************************************
+ Global Types
+ */
+
+#if (!defined(DOXYGEN))
+struct RwFrame
+{
+    RwObject            object;
+
+    RwLLLink            inDirtyListLink;
+
+    /* Put embedded matrices here to ensure they remain 16-byte aligned */
+    RwMatrix            modelling;
+    RwMatrix            ltm;
+
+    RwLinkList          objectList; /* List of objects connected to a frame */
+
+    struct RwFrame      *child;
+    struct RwFrame      *next;
+    struct RwFrame      *root;   /* Root of the tree */
+
+#if (RWFRAMESTATICPLUGINSSIZE)
+    RWALIGN(RwUInt8             pluginData[RWFRAMESTATICPLUGINSSIZE], rwFRAMEALIGNMENT);
+#endif /* defined(RWFRAMESTATICPLUGINSIZE)) */
+};
+#endif /* (!defined(DOXYGEN)) */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwFrame 
+   Frame for defining object position and orientation. 
+ * This should be considered an opaque type.
+ * Use the RwFrame API functions to access.
+ */
+typedef struct RwFrame RWALIGN(RwFrame, rwFRAMEALIGNMENT);
+
+/**
+ * \ingroup datatypes
+ * \typedef RwFrameCallBack
+ * \ref RwFrameCallBack type represents the function 
+ * called from \ref RwFrameForAllChildren for all child frames linked to a given frame.  
+ * This function should return a pointer to the current frame to indicate success.  
+ * The callback may return NULL to terminate further callbacks on the child frames.
+ * 
+ * \param  frame   Pointer to the current frame, supplied by
+ * iterator.
+ * \param  data  Pointer to developer-defined data structure.
+ *
+ * \see RwFrameForAllChildren
+ *
+ */
+typedef RwFrame *(*RwFrameCallBack)(RwFrame *frame, void *data);
+
+
+#define RwFrameGetParentMacro(_f)   ((RwFrame *)rwObjectGetParent(_f))
+#if (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ))
+#define RwFrameGetParent(_f)    RwFrameGetParentMacro(_f)
+#endif
+
+#define RwFrameGetMatrixMacro(_f)   (&(_f)->modelling)
+#if (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ))
+#define RwFrameGetMatrix(_f)    RwFrameGetMatrixMacro(_f)
+#endif
+
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef    __cplusplus
+extern              "C"
+{
+#endif                          /* __cplusplus */
+
+/* Finding what is attached to a frame */
+extern RwFrame *
+RwFrameForAllObjects(RwFrame * frame,
+                     RwObjectCallBack callBack,
+                     void *data);
+
+/* Matrix operations */
+extern RwFrame *
+RwFrameTranslate(RwFrame * frame,
+                 const RwV3d * v,
+                 RwOpCombineType combine);
+
+extern RwFrame *
+RwFrameRotate(RwFrame * frame,
+              const RwV3d * axis,
+              RwReal angle,
+              RwOpCombineType combine);
+
+extern RwFrame *
+RwFrameScale(RwFrame * frame,
+             const RwV3d * v,
+             RwOpCombineType combine);
+
+extern RwFrame *
+RwFrameTransform(RwFrame * frame,
+                 const RwMatrix * m,
+                 RwOpCombineType combine);
+
+extern RwFrame *
+RwFrameOrthoNormalize(RwFrame * frame);
+
+extern RwFrame *
+RwFrameSetIdentity(RwFrame * frame);
+
+/* Cloning */
+extern RwFrame *
+RwFrameCloneHierarchy(RwFrame * root);
+
+/* Destruction */
+extern RwBool
+RwFrameDestroyHierarchy(RwFrame * frame);
+
+/* Building a frame */
+extern RwFrame *
+RwFrameForAllChildren(RwFrame * frame,
+                      RwFrameCallBack callBack,
+                      void *data);
+
+extern RwFrame *
+RwFrameRemoveChild(RwFrame * child);
+
+extern RwFrame *
+RwFrameAddChild(RwFrame * parent,
+                RwFrame * child);
+
+#if ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )
+extern RwFrame *
+RwFrameGetParent(const RwFrame * frame);
+#endif
+
+/* Getting the root */
+extern RwFrame *
+RwFrameGetRoot(const RwFrame * frame);
+
+/* Getting Matrices */
+extern RwMatrix *
+RwFrameGetLTM(RwFrame * frame);
+
+#if ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )
+extern RwMatrix *
+RwFrameGetMatrix(RwFrame * frame);
+#endif
+
+/* Elements */
+extern RwFrame *
+RwFrameUpdateObjects(RwFrame * frame);
+
+/* Creating destroying frames */
+extern RwFrame *
+RwFrameCreate(void);
+
+extern RwBool
+RwFrameInit(RwFrame *frame);
+
+extern RwBool
+RwFrameDeInit(RwFrame *frame);
+
+extern RwBool
+RwFrameDestroy(RwFrame * frame);
+
+/* internal function used by Create and Init */
+extern void
+_rwFrameInit(RwFrame *frame);
+
+/* internal function used by Destroy and DeInit */
+extern void
+_rwFrameDeInit(RwFrame *frame);
+
+/* Finding a frames state */
+extern RwBool
+RwFrameDirty(const RwFrame * frame);
+
+/* Find the amount of frames in a hierarchy */
+extern RwInt32
+RwFrameCount(RwFrame * frame);
+
+/* Plugins */
+extern RwBool
+RwFrameSetStaticPluginsSize(RwInt32 size);
+
+extern RwInt32
+RwFrameRegisterPlugin(RwInt32 size,
+                      RwUInt32 pluginID,
+                      RwPluginObjectConstructor constructCB,
+                      RwPluginObjectDestructor destructCB,
+                      RwPluginObjectCopy copyCB);
+
+extern RwInt32
+RwFrameGetPluginOffset(RwUInt32 pluginID);
+
+extern RwBool
+RwFrameValidatePlugins(const RwFrame * frame);
+
+/* Cloning */
+extern RwFrame *
+_rwFrameCloneAndLinkClones(RwFrame * root);
+
+extern
+RwFrame *
+_rwFramePurgeClone(RwFrame *root);
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+/* Compatibility macros */
+
+#define rwFrameGetParent(frame) \
+       _rwFrameGetParent(frame)
+
+#define rwFrameInit(frame) \
+       _rwFrameInit(frame)
+
+#define rwFrameDeInit(frame) \
+       _rwFrameDeInit(frame)
+
+#define rwFrameCloneAndLinkClones(root) \
+       _rwFrameCloneAndLinkClones(root)
+
+#define rwFramePurgeClone(root) \
+       _rwFramePurgeClone(root)
+
+#define rwFrameClose(instance, offset, size) \
+       _rwFrameClose(instance, offset, size)
+
+#define rwFrameOpen(instance, offset, size) \
+       _rwFrameOpen(instance, offset, size)
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/batypehf.h ---*/
+
+typedef struct RwObjectHasFrame RwObjectHasFrame;
+typedef RwObjectHasFrame * (*RwObjectHasFrameSyncFunction)(RwObjectHasFrame *object);
+struct RwObjectHasFrame
+{
+    RwObject                     object;
+    RwLLLink                     lFrame;
+    RwObjectHasFrameSyncFunction sync;
+};
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef    __cplusplus
+extern "C"
+{
+#endif                          /* __cplusplus */
+
+/* Frames */
+extern void _rwObjectHasFrameSetFrame(void *object, RwFrame *frame);
+extern void _rwObjectHasFrameReleaseFrame(void *object);
+
+/* ObjectHASFRAME METHODS */
+#define rwObjectHasFrameInitialize(o, type, subtype, syncFunc)  \
+MACRO_START                                                     \
+{                                                               \
+    rwObjectInitialize(o, type, subtype);                       \
+    ((RwObjectHasFrame *)o)->sync = syncFunc;                   \
+}                                                               \
+MACRO_STOP
+
+#define rwObjectHasFrameSync(o) \
+    ((RwObjectHasFrame *)(o))->sync(o)
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+/* Compatibility macros */
+
+#define rwObjectHasFrameSetFrame(object, frame) \
+        _rwObjectHasFrameSetFrame(object, frame)
+#define rwObjectHasFrameReleaseFrame(object) \
+        _rwObjectHasFrameReleaseFrame(object)
+
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/basync.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/babintex.h ---*/
+/****************************************************************************
+ Global types
+ */
+typedef struct rpTextureChunkInfo RwTextureChunkInfo;
+struct rpTextureChunkInfo
+{
+    RwTextureFilterMode filtering;
+    RwTextureAddressMode addressingU;
+    RwTextureAddressMode addressingV;
+};
+
+/* Bit flags defining properties of textures when stream */
+enum RwTextureStreamFlags
+{
+    rwNATEXTURESTREAMFLAG = 0x00,
+    rwTEXTURESTREAMFLAGSUSERMIPMAPS = 0x01,
+    rwTEXTURESTREAMFLAGSFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwTextureStreamFlags RwTextureStreamFlags;
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef    __cplusplus
+extern "C"
+{
+#endif                          /* __cplusplus */
+
+/* Texture binary format */
+extern RwInt32
+RwTextureRegisterPluginStream(RwUInt32 pluginID,
+                              RwPluginDataChunkReadCallBack readCB,
+                              RwPluginDataChunkWriteCallBack writeCB,
+                              RwPluginDataChunkGetSizeCallBack getSizeCB);
+
+extern RwInt32
+RwTextureSetStreamAlwaysCallBack(RwUInt32 pluginID,
+                                 RwPluginDataChunkAlwaysCallBack alwaysCB);
+
+extern RwUInt32
+RwTextureStreamGetSize(const RwTexture *texture);
+
+extern RwTexture *
+RwTextureStreamRead(RwStream *stream);
+
+extern const RwTexture *
+RwTextureStreamWrite(const RwTexture *texture,
+                     RwStream *stream);
+
+/* Texture dictionary binary format */
+extern RwInt32
+RwTexDictionaryRegisterPluginStream(RwUInt32 pluginID,
+                                    RwPluginDataChunkReadCallBack readCB,
+                                    RwPluginDataChunkWriteCallBack writeCB,
+                                    RwPluginDataChunkGetSizeCallBack getSizeCB);
+
+extern RwInt32
+RwTexDictionarySetStreamAlwaysCallBack(RwUInt32 pluginID,
+                                       RwPluginDataChunkAlwaysCallBack alwaysCB);
+
+extern RwUInt32
+RwTexDictionaryStreamGetSize(const RwTexDictionary *texDict);
+
+extern RwTexDictionary
+*RwTexDictionaryStreamRead(RwStream *stream);
+
+extern const RwTexDictionary *
+RwTexDictionaryStreamWrite(const RwTexDictionary *texDict,
+                           RwStream *stream);
+
+extern RwTextureChunkInfo *
+_rwTextureChunkInfoRead(RwStream *stream,
+                        RwTextureChunkInfo *textureChunkInfo,
+                        RwInt32 *bytesRead);
+
+/* Compatibility macro */
+
+#define  RwTextureChunkInfoRead(_stream, _textureChunkInfo, _bytesRead) \
+        _rwTextureChunkInfoRead(_stream, _textureChunkInfo, _bytesRead) 
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/babinfrm.h ---*/
+/****************************************************************************
+ Global types
+ */
+
+typedef struct rwFrameList rwFrameList;
+struct rwFrameList
+{
+    RwFrame **frames;
+    RwInt32 numFrames;
+};
+
+/****************************************************************************
+ Global Variables 
+ */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef    __cplusplus
+extern "C"
+{
+#endif                          /* __cplusplus */
+
+/* Frame binary format */
+
+extern RwInt32 
+RwFrameRegisterPluginStream(RwUInt32 pluginID,
+                            RwPluginDataChunkReadCallBack readCB,
+                            RwPluginDataChunkWriteCallBack writeCB,
+                            RwPluginDataChunkGetSizeCallBack getSizeCB);
+
+extern RwInt32 
+RwFrameSetStreamAlwaysCallBack(RwUInt32 pluginID,
+                               RwPluginDataChunkAlwaysCallBack alwaysCB);
+
+
+extern rwFrameList *
+_rwFrameListInitialize(rwFrameList *frameList,
+                      RwFrame *frame);
+
+extern RwBool 
+_rwFrameListFindFrame(const rwFrameList *frameList,
+                     const RwFrame *frame,
+                     RwInt32 *npIndex);
+
+extern rwFrameList *
+_rwFrameListDeinitialize(rwFrameList *frameList);
+
+extern RwUInt32 
+_rwFrameListStreamGetSize(const rwFrameList *frameList);
+
+extern rwFrameList *
+_rwFrameListStreamRead(RwStream *stream,
+                      rwFrameList *fl);
+
+extern const rwFrameList *
+_rwFrameListStreamWrite(const rwFrameList *frameList,
+                       RwStream *stream);
+
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+/* Comparibility macros */
+
+#define rwFrameListInitialize(frameList,frame) \
+       _rwFrameListInitialize(frameList,frame)
+
+#define rwFrameListFindFrame(frameList, frame, index) \
+       _rwFrameListFindFrame(frameList, frame, index)
+
+#define rwFrameListDeinitialize(frameList) \
+       _rwFrameListDeinitialize(frameList)
+
+#define rwFrameListStreamGetSize(frameList) \
+       _rwFrameListStreamGetSize(frameList)
+
+#define rwFrameListStreamRead(stream, fl) \
+       _rwFrameListStreamRead(stream, fl)
+
+#define rwFrameListStreamWrite(frameList, stream) \
+       _rwFrameListStreamWrite(frameList, stream)
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/babbox.h ---*/
+/****************************************************************************
+ Global types
+ */
+
+typedef struct RwBBox RwBBox;
+/**
+ * \ingroup datatypes
+ * \struct RwBBox
+ * This type represents a 3D axis-aligned bounding-box
+ * specified by the positions of two corners which lie on a diagonal.
+ * Typically used to specify a world bounding-box when the world is created
+ * 
+ * \param sup Supremum vertex (contains largest values)
+ * \param inf Infimum vertex (contains smallest values)
+ * 
+ * \see RpWorldCreate
+ */
+struct RwBBox
+{
+    /* Must be in this order */
+    RwV3d sup;   /**< Supremum vertex. */
+    RwV3d inf;   /**< Infimum vertex. */
+};
+
+#if (!defined(RwBBoxAssign))
+#define RwBBoxAssign(_target, _source)            \
+    ( *(_target) = *(_source) )
+#endif /* (!defined(RwBBoxAssign)) */
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef    __cplusplus
+extern "C"
+{
+#endif                          /* __cplusplus */
+
+
+extern RwBBox *RwBBoxCalculate(RwBBox *boundBox,
+                               const RwV3d *verts,
+                               RwInt32 numVerts);
+extern RwBBox *RwBBoxInitialize(RwBBox *boundBox,
+                                const RwV3d *vertex);
+extern RwBBox *RwBBoxAddPoint(RwBBox *boundBox,
+                              const RwV3d *vertex);
+extern RwBool RwBBoxContainsPoint(const RwBBox *boundBox,
+                                  const RwV3d *vertex);
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/bacamera.h ---*/
+
+/****************************************************************************
+ Defines
+ */
+
+/* Type ID */
+#define rwCAMERA 4
+
+
+
+/****************************************************************************
+ <macro/inline functionality
+ */
+
+#define RwCameraGetViewOffsetMacro(_camera)                     \
+    (&((_camera)->viewOffset))
+
+#define RwCameraSetRasterMacro(_camera, _raster)                \
+    (((_camera)->frameBuffer = (_raster)), (_camera))
+
+#define RwCameraSetRasterVoidMacro(_camera, _raster)            \
+MACRO_START                                                     \
+{                                                               \
+    (_camera)->frameBuffer = (_raster);                         \
+}                                                               \
+MACRO_STOP
+
+#define RwCameraGetRasterMacro(_camera)                         \
+    ((_camera)->frameBuffer)
+
+#define RwCameraSetZRasterMacro(_camera, _raster)               \
+    (((_camera)->zBuffer = (_raster)), (_camera))
+
+#define RwCameraSetZRasterVoidMacro(_camera, _raster)           \
+MACRO_START                                                     \
+{                                                               \
+    (_camera)->zBuffer = (_raster);                             \
+}                                                               \
+MACRO_STOP
+
+#define RwCameraGetZRasterMacro(_camera)                        \
+    ((_camera)->zBuffer)
+
+#define RwCameraGetNearClipPlaneMacro(_camera)                  \
+    ((_camera)->nearPlane)
+
+#define RwCameraGetFarClipPlaneMacro(_camera)                   \
+    ((_camera)->farPlane)
+
+#define RwCameraSetFogDistanceMacro(_camera, _distance)         \
+    (((_camera)->fogPlane = (_distance)), (_camera))
+
+#define RwCameraGetFogDistanceMacro(_camera)                    \
+    ((_camera)->fogPlane)
+
+#define RwCameraGetCurrentCameraMacro()                         \
+    ((RwCamera *)RWSRCGLOBAL(curCamera))
+
+#define RwCameraGetProjectionMacro(_camera)                     \
+    ((_camera)->projectionType)
+
+#define RwCameraGetViewWindowMacro(_camera)                     \
+    (&((_camera)->viewWindow))
+
+#define RwCameraGetViewMatrixMacro(_camera)                     \
+    (&((_camera)->viewMatrix))
+
+#define RwCameraSetFrameMacro(_camera, _frame)                  \
+    (_rwObjectHasFrameSetFrame((_camera), (_frame)), (_camera))
+
+#define RwCameraSetFrameVoidMacro(_camera, _frame)      \
+MACRO_START                                             \
+{                                                       \
+    _rwObjectHasFrameSetFrame((_camera), (_frame));     \
+}                                                       \
+MACRO_STOP
+
+
+#define RwCameraGetFrameMacro(_camera)                          \
+    ((RwFrame *)rwObjectGetParent((_camera)))
+
+#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+#define RwCameraGetViewOffset(_camera)                          \
+    RwCameraGetViewOffsetMacro(_camera)
+
+#define RwCameraSetRaster(_camera, _raster)                     \
+    RwCameraSetRasterMacro(_camera, _raster)
+
+#define RwCameraGetRaster(_camera)                              \
+    RwCameraGetRasterMacro(_camera)
+
+#define RwCameraSetZRaster(_camera, _raster)                    \
+    RwCameraSetZRasterMacro(_camera, _raster)
+
+#define RwCameraGetZRaster(_camera)                             \
+    RwCameraGetZRasterMacro(_camera)
+
+#define RwCameraGetNearClipPlane(_camera)                       \
+    RwCameraGetNearClipPlaneMacro(_camera)
+
+#define RwCameraGetFarClipPlane(_camera)                        \
+    RwCameraGetFarClipPlaneMacro(_camera)
+
+#define RwCameraSetFogDistance(_camera, _distance)              \
+    RwCameraSetFogDistanceMacro(_camera, _distance)
+
+#define RwCameraGetFogDistance(_camera)                         \
+    RwCameraGetFogDistanceMacro(_camera)
+
+#define RwCameraGetCurrentCamera()                              \
+    RwCameraGetCurrentCameraMacro()
+
+#define RwCameraGetProjection(_camera)                          \
+    RwCameraGetProjectionMacro(_camera)
+
+#define RwCameraGetViewWindow(_camera)                          \
+    RwCameraGetViewWindowMacro(_camera)
+
+#define RwCameraGetViewMatrix(_camera)                          \
+    RwCameraGetViewMatrixMacro(_camera)
+
+#define RwCameraSetFrame(_camera, _frame)                       \
+    RwCameraSetFrameMacro(_camera, _frame)
+
+#define RwCameraGetFrame(_camera)                               \
+    RwCameraGetFrameMacro(_camera)
+
+#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+
+/****************************************************************************
+ Global Types
+ */
+
+/**
+ * \ingroup datatypes
+ * RwCameraClearMode 
+ * Camera clear flags */
+enum RwCameraClearMode
+{
+    rwCAMERACLEARIMAGE = 0x1,   /**<Clear the frame buffer */
+    rwCAMERACLEARZ = 0x2,       /**<Clear the Z buffer */
+    rwCAMERACLEARSTENCIL = 0x4, /**<\if xbox   Clear the stencil buffer \endif
+                                  * \if d3d8   Clear the stencil buffer \endif
+                                  * \if opengl Clear the stencil buffer \endif
+                                  */
+    rwCAMERACLEARMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwCameraClearMode RwCameraClearMode;
+
+/**
+ * \ingroup datatypes
+ * RwCameraProjection 
+ * This type represents the options available for 
+ * setting the camera projection model, either perspective projection or 
+* parallel projection (see API function \ref RwCameraSetProjection)*/
+enum RwCameraProjection
+{
+    rwNACAMERAPROJECTION = 0,   /**<Invalid projection */
+    rwPERSPECTIVE = 1,          /**<Perspective projection */
+    rwPARALLEL = 2,             /**<Parallel projection */
+    rwCAMERAPROJECTIONFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwCameraProjection RwCameraProjection;
+
+/**
+ * \ingroup datatypes
+ * RwFrustumTestResult 
+ * This type represents the results from a 
+ * camera frustum test on a given sphere (see API function 
+ * \ref RwCameraFrustumTestSphere)*/
+enum RwFrustumTestResult
+{
+    rwSPHEREOUTSIDE = 0,    /**<Outside the frustum */
+    rwSPHEREBOUNDARY = 1,   /**<On the boundary of the frustum */
+    rwSPHEREINSIDE = 2,     /**<Inside the frustum */
+    rwFRUSTUMTESTRESULTFORCEENUMSIZEINT = RWFORCEENUMSIZEINT
+};
+typedef enum RwFrustumTestResult RwFrustumTestResult;
+
+
+/**
+ * \ingroup datatypes
+ * \typedef RwCamera
+ * Camera object for rendering a view. 
+ * This should be considered an opaque type.
+ * Use the RwCamera API functions to access.
+ */
+typedef struct RwCamera RWALIGN(RwCamera, rwMATRIXALIGNMENT);
+
+/* This allows a world to overload functionality */
+typedef RwCamera   *(*RwCameraBeginUpdateFunc) (RwCamera * camera);
+typedef RwCamera   *(*RwCameraEndUpdateFunc) (RwCamera * camera);
+
+typedef struct RwFrustumPlane RwFrustumPlane;
+/*
+ * Structure describing a frustrum plane.
+ */
+struct RwFrustumPlane
+{
+        RwPlane             plane;
+        RwUInt8             closestX;
+        RwUInt8             closestY;
+        RwUInt8             closestZ;
+        RwUInt8             pad;
+};
+
+#if (!defined(DOXYGEN))
+struct RwCamera
+{
+        RwObjectHasFrame    object;
+
+        /* Parallel or perspective projection */
+        RwCameraProjection  projectionType;
+
+        /* Start/end update functions */
+        RwCameraBeginUpdateFunc beginUpdate;
+        RwCameraEndUpdateFunc endUpdate;
+
+        /* The view matrix */
+        RwMatrix            viewMatrix;
+
+        /* The cameras image buffer */
+        RwRaster           *frameBuffer;
+
+        /* The Z buffer */
+        RwRaster           *zBuffer;
+
+        /* Cameras mathmatical characteristics */
+        RwV2d               viewWindow;
+        RwV2d               recipViewWindow;
+        RwV2d               viewOffset;
+        RwReal              nearPlane;
+        RwReal              farPlane;
+        RwReal              fogPlane;
+
+        /* Transformation to turn camera z or 1/z into a Z buffer z */
+        RwReal              zScale, zShift;
+
+        /* Render frame counter -> used for the frustum callback stuff */
+        RwUInt16            renderFrame;
+        RwUInt16            pad;
+
+        /* The clip-planes making up the viewing frustum */
+        RwFrustumPlane      frustumPlanes[6];
+        RwBBox              frustumBoundBox;
+
+        /* Points on the tips of the view frustum */
+        RwV3d               frustumCorners[8];
+};
+#endif /* (!defined(DOXYGEN)) */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwCameraCallBack
+ * \ref RwCameraCallBack type represents a function called from any camera
+ * iterator that may be implemented in plugins. This function should return a
+ * pointer to the current camera to indicate success. The callback may return
+ * NULL to terminate further callbacks on other cameras.
+ * 
+ * \param  camera   Pointer to the current camera, supplied by iterator.
+ * \param  data  Pointer to developer-defined data structure.
+ */
+typedef RwCamera *(*RwCameraCallBack)(RwCamera *camera, void *data);
+
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef    __cplusplus
+extern              "C"
+{
+#endif                          /* __cplusplus */
+
+    /* Rendering */
+extern RwCamera    *RwCameraBeginUpdate(RwCamera * camera);
+extern RwCamera    *RwCameraEndUpdate(RwCamera * camera);
+
+extern RwCamera    *RwCameraClear(RwCamera * camera, RwRGBA * colour,
+                                  RwInt32 clearMode);
+
+/* Displaying results */
+extern RwCamera    *RwCameraShowRaster(RwCamera * camera, void *pDev,
+                                       RwUInt32 flags);
+
+/* Creation and destruction */
+extern RwBool       RwCameraDestroy(RwCamera * camera);
+extern RwCamera    *RwCameraCreate(void);
+extern RwCamera    *RwCameraClone(RwCamera * camera);
+
+/* Offset */
+extern RwCamera    *RwCameraSetViewOffset(RwCamera *camera,
+                                          const RwV2d *offset);
+
+/* View window */
+extern RwCamera    *RwCameraSetViewWindow(RwCamera *camera,
+                                          const RwV2d *viewWindow);
+
+/* Projection */
+extern RwCamera    *RwCameraSetProjection(RwCamera *camera,
+                                          RwCameraProjection projection);
+
+/* Clip planes */
+extern RwCamera    *RwCameraSetNearClipPlane(RwCamera *camera, RwReal nearClip);
+extern RwCamera    *RwCameraSetFarClipPlane(RwCamera *camera, RwReal farClip);
+
+/* Attaching toolkits */
+extern RwInt32      RwCameraRegisterPlugin(RwInt32 size,
+                                           RwUInt32 pluginID,
+                                           RwPluginObjectConstructor
+                                           constructCB,
+                                           RwPluginObjectDestructor
+                                           destructCB,
+                                           RwPluginObjectCopy copyCB);
+extern RwInt32      RwCameraGetPluginOffset(RwUInt32 pluginID);
+extern RwBool       RwCameraValidatePlugins(const RwCamera * camera);
+
+/* Frustum testing */
+extern RwFrustumTestResult RwCameraFrustumTestSphere(const RwCamera *
+                                                     camera,
+                                                     const RwSphere *
+                                                     sphere);
+
+#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE))
+
+/* Offset */
+extern const RwV2d *RwCameraGetViewOffset(const RwCamera *camera);
+
+/* Rasters */
+extern RwCamera    *RwCameraSetRaster(RwCamera *camera, RwRaster *raster);
+extern RwRaster    *RwCameraGetRaster(const RwCamera *camera);
+extern RwCamera    *RwCameraSetZRaster(RwCamera *camera, RwRaster *zRaster);
+extern RwRaster    *RwCameraGetZRaster(const RwCamera *camera);
+
+/* Clip planes */
+extern RwReal       RwCameraGetNearClipPlane(const RwCamera *camera);
+extern RwReal       RwCameraGetFarClipPlane(const RwCamera *camera);
+extern RwCamera    *RwCameraSetFogDistance(RwCamera *camera, RwReal fogDistance);
+extern RwReal       RwCameraGetFogDistance(const RwCamera *camera);
+
+extern RwCamera    *RwCameraGetCurrentCamera(void);
+
+/* Projection */
+extern RwCameraProjection RwCameraGetProjection(const RwCamera *camera);
+
+/* View window */
+extern const RwV2d *RwCameraGetViewWindow(const RwCamera *camera);
+
+extern RwMatrix    *RwCameraGetViewMatrix(RwCamera *camera);
+
+/* Frames */
+extern RwCamera    *RwCameraSetFrame(RwCamera *camera, RwFrame *frame);
+extern RwFrame     *RwCameraGetFrame(const RwCamera *camera);
+#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/common/barwtyp.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/bacamval.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/pipe/p2/bapipe.h ---*/
+
+struct rwPipeGlobals
+{
+    RwFreeList          *pipesFreeList;   /* Save mallocs, use a freelist */
+    RxRenderStateVector  defaultRenderState;
+    RwLinkList           allPipelines;    /* Unused as of yet, meant to be used to keep track of all
+                                           * created pipelines (for CBs and maybe cleanup) */
+    RwUInt32             maxNodesPerPipe; /* Initialised from _rxPipelineMaxNodes at startup. Used to
+                                           * allow conservative, single allocations during pipelock */
+
+    /* NOTE: Rw and RpWorld PowerPipe globals kept together for simplicity */
+
+    /* The current default pipelines (used if pipe == NULL for an object) */
+    RxPipeline          *currentAtomicPipeline;
+    RxPipeline          *currentWorldSectorPipeline;
+    RxPipeline          *currentMaterialPipeline;
+    /* Generic C-based pipes that run on all platforms
+     * - these are set as the current pipes at startup unless
+     *   platform-specific pipes (below) are created */
+    RxPipeline          *genericAtomicPipeline;
+    RxPipeline          *genericWorldSectorPipeline;
+    RxPipeline          *genericMaterialPipeline;
+    /* Platforms that have their own non-generic pipelines
+     * (OPENGL, D3D7, SKY2, KAMUI2, DOLPHIN) put them here: */
+    RxPipeline          *platformAtomicPipeline;
+    RxPipeline          *platformWorldSectorPipeline;
+    RxPipeline          *platformMaterialPipeline;
+#if (defined(SKY2_DRVMODEL_H))
+    /* We have extra flavours of pipe under SKY2.
+     * PS2All and PS2AllMat are the defaults.
+     *  - see RpWorldSectorSkyGetPS2AllPipeline, etc */
+    RxPipeline          *ps2ManagerAtomicPipeline;
+    RxPipeline          *allInOneAtomicPipeline;
+    RxPipeline          *vanillaAtomicPipeline;
+    RxPipeline          *ps2ManagerWorldSectorPipeline;
+    RxPipeline          *allInOneWorldSectorPipeline;
+    RxPipeline          *vanillaWorldSectorPipeline;
+    RxPipeline          *vanillaMaterialPipeline;
+#endif /* (SKY2_DRVMODEL_H) */
+    
+};
+
+typedef struct rwPipeGlobals rwPipeGlobals;
+
+#define RXPIPELINEGLOBAL(var) (RWPLUGINOFFSET(rwPipeGlobals, RwEngineInstance, _rxPipelineGlobalsOffset)->var)
+
+#ifdef    __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+extern RwInt32      _rxPipelineGlobalsOffset;
+
+#ifdef    __cplusplus
+}
+#endif /* __cplusplus */
+
+
+/*--- Automatically derived from: C:/daily/rwsdk/driver/common/imrascnv.h ---*/
+
+/*--- Automatically derived from: C:/daily/rwsdk/src/babincam.h ---*/
+/****************************************************************************
+ Global types
+ */
+
+/* Camera stream format */
+
+/**
+ * \ingroup datatypes
+ * \typedef RwCameraChunkInfo
+ * 
+ * \ref RwCameraChunkInfo is typedef'd to a structure that holds camera
+ * data. This should be considered an opaque type. Use the RwCamera
+ * API functions to access it.
+ */
+
+typedef struct rwStreamCamera RwCameraChunkInfo;
+typedef struct rwStreamCamera rwStreamCamera;
+struct rwStreamCamera
+{
+    RwV2d viewWindow;
+    RwV2d viewOffset;
+    RwReal nearPlane, farPlane;
+    RwReal fogPlane;
+    RwUInt32 projection;
+};
+
+/****************************************************************************
+ Function prototypes
+ */
+
+#ifdef    __cplusplus
+extern "C"
+{
+#endif                          /* __cplusplus */
+
+/* Camera binary format */
+extern RwInt32 RwCameraRegisterPluginStream(RwUInt32 pluginID,
+                                            RwPluginDataChunkReadCallBack readCB,
+                                            RwPluginDataChunkWriteCallBack writeCB,
+                                            RwPluginDataChunkGetSizeCallBack getSizeCB);
+extern RwInt32 RwCameraSetStreamAlwaysCallBack(
+                   RwUInt32 pluginID,
+                   RwPluginDataChunkAlwaysCallBack alwaysCB);
+extern RwUInt32 RwCameraStreamGetSize(const RwCamera *camera);
+extern RwCamera *RwCameraStreamRead(RwStream *stream);
+extern const RwCamera *RwCameraStreamWrite(const RwCamera *camera,
+                                           RwStream *stream);
+extern RwCameraChunkInfo * RwCameraChunkInfoRead(RwStream *stream,
+                                                 RwCameraChunkInfo *cameraChunkInfo,
+                                                 RwInt32 *bytesRead);
+
+#ifdef    __cplusplus
+}
+#endif                          /* __cplusplus */
+
+#endif /* RWCORE_H */
-- 
cgit v1.2.3