diff options
Diffstat (limited to 'rwsdk/include/d3d8/rwcore.h')
| -rw-r--r-- | rwsdk/include/d3d8/rwcore.h | 4791 |
1 files changed, 4791 insertions, 0 deletions
diff --git a/rwsdk/include/d3d8/rwcore.h b/rwsdk/include/d3d8/rwcore.h new file mode 100644 index 00000000..b9214c63 --- /dev/null +++ b/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 */ |