diff options
Diffstat (limited to '')
| -rw-r--r-- | rwsdk/include/d3d8/rpworld.h | 3735 |
1 files changed, 3735 insertions, 0 deletions
diff --git a/rwsdk/include/d3d8/rpworld.h b/rwsdk/include/d3d8/rpworld.h new file mode 100644 index 00000000..21fdc31b --- /dev/null +++ b/rwsdk/include/d3d8/rpworld.h @@ -0,0 +1,3735 @@ +/******************************************/ +/* */ +/* 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/rpworld.h> + * Automatically Generated on: Wed Jul 10 10:45:01 2002 + * + ************************************************************************/ + +#ifndef RPWORLD_H +#define RPWORLD_H + +/*--- Check For Previous Required Includes ---*/ +#ifndef RWCORE_H +#error "Include RWCORE.H before including this file" +#endif /* RWCORE_H */ + +/*--- System Header Files ---*/ +#include <stdarg.h> +#include <stdlib.h> + +/*--- Error enumerations ---*/ +#include "rpworld.rpe" + + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/d3d8/native.h ---*/ + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/d3d8/wrldpipe.h ---*/ + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/d3d8/nodeD3D8WorldSectorAllInOne.h ---*/ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RxNodeDefinition *RxNodeDefinitionGetD3D8WorldSectorAllInOne(void); +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/d3d8/nodeD3D8AtomicAllInOne.h ---*/ +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RxNodeDefinition *RxNodeDefinitionGetD3D8AtomicAllInOne(void); +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/d3d8/D3D8VertexBufferManager.h ---*/ +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodeWorldSectorInstance.h ---*/ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RxNodeDefinition *RxNodeDefinitionGetWorldSectorInstance(void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodeWorldSectorEnumerateLights.h ---*/ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RxNodeDefinition *RxNodeDefinitionGetWorldSectorEnumerateLights(void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodePreLight.h ---*/ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RxNodeDefinition *RxNodeDefinitionGetPreLight(void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodePostLight.h ---*/ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RxNodeDefinition *RxNodeDefinitionGetPostLight(void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodeMaterialScatter.h ---*/ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RxNodeDefinition *RxNodeDefinitionGetMaterialScatter(void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodeLight.h ---*/ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RxNodeDefinition *RxNodeDefinitionGetLight(void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodeFastPathSplitter.h ---*/ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RxNodeDefinition *RxNodeDefinitionGetFastPathSplitter(void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodeAtomicInstance.h ---*/ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RxNodeDefinition *RxNodeDefinitionGetAtomicInstance(void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/nodeAtomicEnumerateLights.h ---*/ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RxNodeDefinition *RxNodeDefinitionGetAtomicEnumerateLights(void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: c:/daily/rwsdk/world/bamateri.h ---*/ + +/* + * Handling surface materials + * Materials describe how things are to appear when rendered + * + * Copyright (c) 1998 Criterion Software Ltd. + */ + +/**************************************************************************** + Global Types + */ + + +typedef struct RpMaterialChunkInfo RpMaterialChunkInfo; +typedef struct RpMaterialChunkInfo _rpMaterial; + +struct RpMaterialChunkInfo +{ + RwInt32 flags; /**< Material flags - unused currently - + for future expansion */ + RwRGBA color; /**< Colour of material. */ + RwInt32 unused; /**< Not used */ + RwBool textured; /**< Are we textured? */ + RwSurfaceProperties surfaceProps; /**< Surface properties */ +}; + +#if (!defined(RwMaterialAssign)) +#define RwMaterialAssign(_target, _source) \ + ( *(_target) = *(_source) ) +#endif /* (!defined(RwMaterialAssign)) */ + +/** + * \ingroup rpworlddatatypes + * \typedef RpMaterial + * Material object. This should be + * considered an opaque type. Use the RpMaterial API functions to access. + */ +typedef struct RpMaterial RpMaterial; + +#if (!defined(DOXYGEN)) +struct RpMaterial +{ + RwTexture *texture; /**< texture */ + RwRGBA color; /**< color */ + RxPipeline *pipeline; /**< pipeline */ + RwSurfaceProperties surfaceProps; /**< surfaceProps */ + RwInt16 refCount; /* C.f. rwsdk/world/bageomet.h:RpGeometry */ + RwInt16 pad; +}; +#endif /* (!defined(DOXYGEN)) */ + +/** + * \ingroup rpworlddatatypes + * \typedef RpMaterialCallBack + \ref RpMaterialCallBack + * represents the function called from \ref RpGeometryForAllMaterials and + * \ref RpWorldForAllMaterials for all materials referenced by polygons in a + * given geometry. This function should return a pointer to the current + * material to indicate success. The callback may return NULL to terminate + * further callbacks on the materials. + * + * \param material Pointer to the current material + * \param data Pointer to developer-defined data structure. + * + * \return Pointer to the current material. + */ +typedef RpMaterial *(*RpMaterialCallBack)(RpMaterial *material, void *data); + +/**************************************************************************** + <macro/inline functionality + */ + +#define RpMaterialAddRefMacro(_material) \ + (((_material)->refCount++), (_material)) + +#define RpMaterialAddRefVoidMacro(_material) \ +MACRO_START \ +{ \ + (_material)->refCount++; \ +} \ +MACRO_STOP + + +#define RpMaterialSetColorMacro(_material, _color) \ + (RwRGBAAssign(&((_material)->color), (_color)), (_material)) + +#define RpMaterialGetColorMacro(_material) \ + (&((_material)->color)) + +#define RpMaterialSetSurfacePropertiesMacro(_material, _surfProps) \ + (RwSurfacePropertiesAssign(&((_material)->surfaceProps), \ + (_surfProps)), (_material)) + +#define RpMaterialSetSurfacePropertiesVoidMacro(_material, _surfProps) \ +MACRO_START \ +{ \ + RwSurfacePropertiesAssign(&((_material)->surfaceProps), \ + (_surfProps)); \ +} \ +MACRO_STOP + +#define RpMaterialGetSurfacePropertiesMacro(_material) \ + (&((_material)->surfaceProps)) + +#define RpMaterialGetTextureMacro(_material) \ + ((_material)->texture) + + +#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) + +#define RpMaterialAddRef(_material) \ + RpMaterialAddRefMacro(_material) + +#define RpMaterialSetColor(_material, _color) \ + RpMaterialSetColorMacro(_material, _color) + +#define RpMaterialGetColor(_material) \ + RpMaterialGetColorMacro(_material) + +#define RpMaterialSetSurfaceProperties(_material, _surfProps) \ + RpMaterialSetSurfacePropertiesMacro(_material, _surfProps) + +#define RpMaterialGetSurfaceProperties(_material) \ + RpMaterialGetSurfacePropertiesMacro(_material) + +#define RpMaterialGetTexture(_material) \ + RpMaterialGetTextureMacro(_material) + +#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + + +/* Creating, destroying and referencing materials */ +extern RpMaterial *RpMaterialCreate(void); +extern RwBool RpMaterialDestroy(RpMaterial *material); +extern RpMaterial *RpMaterialClone(RpMaterial *material); + +/* Textures */ +extern RpMaterial *RpMaterialSetTexture(RpMaterial *material, RwTexture *texture); + + +#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) +extern RpMaterial *RpMaterialAddRef(RpMaterial *material); + +/* Textures */ +extern RwTexture *RpMaterialGetTexture(const RpMaterial *material); + +/* Setting and getting colors */ +extern RpMaterial *RpMaterialSetColor(RpMaterial *material, const RwRGBA *color); +extern const RwRGBA *RpMaterialGetColor(const RpMaterial *material); + +/* Setting and getting surface properties */ +extern RpMaterial * +RpMaterialSetSurfaceProperties(RpMaterial *material, + const RwSurfaceProperties *surfaceProperties); + +extern const RwSurfaceProperties * +RpMaterialGetSurfaceProperties(const RpMaterial *material); + +#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + + +/* Attaching toolkits */ +extern RwInt32 RpMaterialRegisterPlugin(RwInt32 size, RwUInt32 pluginID, + RwPluginObjectConstructor constructCB, + RwPluginObjectDestructor destructCB, + RwPluginObjectCopy copyCB); +extern RwInt32 RpMaterialRegisterPluginStream(RwUInt32 pluginID, + RwPluginDataChunkReadCallBack readCB, + RwPluginDataChunkWriteCallBack writeCB, + RwPluginDataChunkGetSizeCallBack getSizeCB); +extern RwInt32 RpMaterialSetStreamAlwaysCallBack( + RwUInt32 pluginID, + RwPluginDataChunkAlwaysCallBack alwaysCB); +extern RwInt32 RpMaterialGetPluginOffset(RwUInt32 pluginID); +extern RwBool RpMaterialValidatePlugins(const RpMaterial *material); + +/* Binary format */ +extern RwUInt32 RpMaterialStreamGetSize(const RpMaterial *material); +extern RpMaterial *RpMaterialStreamRead(RwStream *stream); +extern const RpMaterial *RpMaterialStreamWrite(const RpMaterial *material, RwStream *stream); +extern RpMaterialChunkInfo * +_rpMaterialChunkInfoRead(RwStream *stream, + RpMaterialChunkInfo *materialChunkInfo, + RwInt32 *bytesRead); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#define RpMaterialChunkInfoRead(stream, materialChunkInfo, bytesRead) \ + _rpMaterialChunkInfoRead(stream, materialChunkInfo, bytesRead) + + +/*--- Automatically derived from: c:/daily/rwsdk/world/bamatlst.h ---*/ +/**************************************************************************** + Global Types + */ + +typedef struct RpMaterialList RpMaterialList; +struct RpMaterialList +{ + RpMaterial **materials; + RwInt32 numMaterials; + RwInt32 space; +}; + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +#define rpMaterialListGetNumMaterials(mlist) ((mlist)->numMaterials) + +/* Setting up and destroying material lists */ +extern RpMaterialList *_rpMaterialListInitialize(RpMaterialList *matList); +extern RpMaterialList *_rpMaterialListDeinitialize(RpMaterialList *matList); + +/* Accessing material lists */ +extern RpMaterial ** _rpMaterialListAlloc(RwUInt32 count); +extern RpMaterial *_rpMaterialListGetMaterial(const RpMaterialList *matList, + RwInt32 matIndex); +extern RpMaterialList * _rpMaterialListSetSize(RpMaterialList * matList, + RwInt32 size); +extern RpMaterialList *_rpMaterialListCopy(RpMaterialList *matListOut, + const RpMaterialList *matListIn); +extern RwInt32 _rpMaterialListAppendMaterial(RpMaterialList *matList, + RpMaterial *material); +extern RwInt32 _rpMaterialListFindMaterialIndex(const RpMaterialList *matList, + const RpMaterial *material); + +/* Binary format */ +extern RwUInt32 _rpMaterialListStreamGetSize(const RpMaterialList *matList); +extern RpMaterialList *_rpMaterialListStreamRead(RwStream *stream, + RpMaterialList *matList); +extern const RpMaterialList *_rpMaterialListStreamWrite(const RpMaterialList *matList, + RwStream *stream); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#define rpMaterialListInitialize(_matList) \ + _rpMaterialListInitialize(_matList) + +#define rpMaterialListDeinitialize(_matList) \ + _rpMaterialListDeinitialize(_matList) + +#define rpMaterialListGetMaterial(_matList, _matIndex) \ + _rpMaterialListGetMaterial(_matList, _matIndex) + +#define rpMaterialListCopy(_matListOut, _matListIn) \ + _rpMaterialListCopy(_matListOut, _matListIn) + +#define rpMaterialListAppendMaterial(_matList, _material) \ + _rpMaterialListAppendMaterial(_matList, _material) + +#define rpMaterialListStreamRead(_stream, _matList) \ + _rpMaterialListStreamRead(_stream, _matList) + +#define rpMaterialListStreamWrite(_matList, _stream) \ + _rpMaterialListStreamWrite(_matList, _stream) + + +/*--- Automatically derived from: c:/daily/rwsdk/world/bamesh.h ---*/ + +/* + * + * Purpose: Provide construction and enumeration facilities for meshes. + * + * Copyright (c) 1998 Criterion Software Ltd. + */ + +#define RPMESHGLOBAL(var) \ + (RWPLUGINOFFSET(rpMeshGlobals, \ + RwEngineInstance, \ + meshModule.globalsOffset)->var) + +#define rwPRIMTYPEOR \ + (rwPRIMTYPELINELIST | \ + rwPRIMTYPEPOLYLINE | \ + rwPRIMTYPETRILIST | \ + rwPRIMTYPETRISTRIP | \ + rwPRIMTYPETRIFAN | \ + rwPRIMTYPEPOINTLIST) + +#define rpMESHHEADERPRIMTYPEOR \ + (0 /* rpMESHHEADERTRILIST*/ | \ + rpMESHHEADERTRISTRIP | \ + rpMESHHEADERTRIFAN | \ + rpMESHHEADERLINELIST | \ + rpMESHHEADERPOLYLINE | \ + rpMESHHEADERPOINTLIST) + +/**************************************************************************** + Global variables + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RwModuleInfo meshModule; + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +/**************************************************************************** + Global types + */ + +/** + * \ingroup rpworlddatatypes + * \typedef RpMeshHeader + * typedef for header structure listing all meshes + * constituting a single RpGeometry or RpWorldSector + */ +typedef struct RpMeshHeader RpMeshHeader; + +/** + * \ingroup rpworlddatatypes + * \ref RpMeshHeaderFlags + * represents the different types of mesh. + * \see RpMeshHeader + */ +enum RpMeshHeaderFlags +{ + /* NOTE: trilists are denoted by absence of any other + * primtype flags, so be careful that you test: + * (triListFlag == flags&triListFlag) + * or: + * (0 == flags&rpMESHHEADERPRIMMASK) + * and not: + * (flags&triListFlag) + */ + rpMESHHEADERTRISTRIP = 0x0001, /**< Render as tristrips */ + rpMESHHEADERTRIFAN = 0x0002, /**< On PS2 these will be converted to trilists */ + rpMESHHEADERLINELIST = 0x0004, /**< Render as linelists */ + rpMESHHEADERPOLYLINE = 0x0008, /**< On PS2 these will be converted to linelists */ + rpMESHHEADERPOINTLIST = 0x0010, /**< Pointlists are supported only if rendered by + * custom pipelines; there is no default RenderWare + * way to render pointlists. */ + + rpMESHHEADERPRIMMASK = 0x00FF, /**< All bits reserved for specifying primitive type */ + rpMESHHEADERUNINDEXED = 0x0100, /**< Topology is defined implicitly by vertex + * order, ergo the mesh contains no indices */ + rpMESHHEADERFLAGSFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; + +/* + * Typedef for RpMeshHeaderFlags enumeration + * representing the different types of mesh + */ +typedef enum RpMeshHeaderFlags RpMeshHeaderFlags; + +typedef struct rpMeshGlobals rpMeshGlobals; +struct rpMeshGlobals +{ + RwInt16 nextSerialNum; + RwFreeList *triStripListEntryFreeList; + RwUInt8 meshFlagsToPrimType[rpMESHHEADERPRIMTYPEOR]; + RwUInt8 primTypeToMeshFlags[rwPRIMTYPEOR]; +}; + +typedef struct RpBuildMeshTriangle RpBuildMeshTriangle; + +/** + * \ingroup rpworlddatatypes + * \struct RpBuildMeshTriangle + * This type represents an array of indices into + * the object vertex array. Used during the construction + * of tristrips. + * + * See API functions + * \see RpBuildMeshGeneratePreprocessTriStrip + * \see RpBuildMeshGenerateExhaustiveTriStrip + * \see RpBuildMeshGenerateTrivialTriStrip + * \see RpBuildMeshGenerateDefaultTriStrip + * and + * \see RpMeshSetTriStripMethod + * \see RpMeshGetTriStripMethod + */ +struct RpBuildMeshTriangle +{ + RwUInt16 vertIndex[3]; /**< indices into object vertex + * array. */ + RpMaterial *material; /**< pointer to material used to + * render the mesh. */ +}; + +typedef struct RpBuildMesh RpBuildMesh; + +/** + * \ingroup rpworlddatatypes + * \struct RpBuildMesh + * This type represents a mesh ready for tri stripping. + * + * See API functions + * \see RpBuildMeshGeneratePreprocessTriStrip + * \see RpBuildMeshGenerateExhaustiveTriStrip + * \see RpBuildMeshGenerateTrivialTriStrip + * \see RpBuildMeshGenerateDefaultTriStrip + * and + * \see RpMeshSetTriStripMethod + * \see RpMeshGetTriStripMethod + */ +struct RpBuildMesh +{ + RwUInt32 triangleBufferSize; /**< number of triangles + * space has been allocated + * for. */ + RwUInt32 numTriangles; /**< number of triangles to be + * tristripped. */ + RpBuildMeshTriangle *meshTriangles; /**< pointer to build mesh + * triangles. */ +}; + +typedef struct RpMesh RpMesh; + +/** + * \ingroup rpworlddatatypes + * \struct RpMesh + * This type represents a single polygon mesh. + * A mesh is defined as a collection of triangles derived from an RpGeometry + * or RpWorldSector which have a common material. + * + * See API functions \see RpGeometryForAllMeshes and + * \see RpWorldSectorForAllMeshes and + * the corresponding function callback types: + */ +struct RpMesh +{ + RxVertexIndex *indices; /**< vertex indices defining the mesh */ + RwUInt32 numIndices; /**< number of vertices in mesh */ + RpMaterial *material; /**< pointer to material used to + * render the mesh. */ +}; + +/** + * \ingroup rpworlddatatypes + * \struct RpMeshHeader + * Header for all meshes that constitute a single RpGeometry or RpWorldSector + */ +struct RpMeshHeader +{ + RwUInt32 flags; /**< \see RpMeshHeaderFlags */ + RwUInt16 numMeshes; /**< Number of meshes in object */ + RwUInt16 serialNum; /**< Determine if mesh has changed + * since last instance */ + RwUInt32 totalIndicesInMesh; /**< Total triangle index + * count in all meshes + */ + RwUInt32 firstMeshOffset; /**< Offset in bytes from end this + * structure RpMeshHeader + * to the first mesh + */ +}; + +/** + * \ingroup rpworlddatatypes + * \typedef RpMeshCallBack + * \ref RpMeshCallBack is the callback + * function supplied to \ref RpGeometryForAllMeshes and + * \ref RpWorldSectorForAllMeshes for all meshes in a given geometry. + * + * This function should return a pointer to the current mesh to indicate + * success. The callback may return NULL to terminate further callbacks + * on the meshes. + * + * \param mesh Pointer to the current mesh, supplied by + * iterator. + * \param meshHeader Pointer to the meshes header + * \param data Pointer to developer-defined data structure. + * + * \return + * Returns a pointer to the current mesh if successful or NULL if an error + * occurred. + */ +typedef RpMesh *(*RpMeshCallBack) (RpMesh * mesh, + RpMeshHeader * meshHeader, + void *pData); + +/**************************************************************************** + Function prototypes + */ + +#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) + +#define RpMeshHeaderGetPrimType(_mshHdr) \ + ( (RwPrimitiveType)RPMESHGLOBAL(meshFlagsToPrimType)[(_mshHdr)->flags & \ + rpMESHHEADERPRIMMASK] ) + +#define RpMeshHeaderSetPrimType(_mshHdr, _prmTyp) \ + ( (_mshHdr)->flags = \ + ((_mshHdr)->flags & ~rpMESHHEADERPRIMMASK) | \ + (rpMESHHEADERPRIMMASK & \ + RPMESHGLOBAL(primTypeToMeshFlags)[(_prmTyp) & \ + rpMESHHEADERPRIMMASK]), \ + (_mshHdr) ) + +#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* Opening and closing module */ +extern void *_rpMeshOpen(void *instance, RwInt32 offset, + RwInt32 size); +extern void *_rpMeshClose(void *instance, RwInt32 offset, + RwInt32 size); + +extern RwInt16 _rpMeshGetNextSerialNumber(void); + +/* Create a build mesh with nothing in */ +extern RpBuildMesh *_rpBuildMeshCreate(RwUInt32 bufferSize); + +/* Destroy a build mesh */ +extern RwBool _rpBuildMeshDestroy(RpBuildMesh * mesh); + +/* Destroy a build mesh */ +extern RwBool _rpMeshDestroy(RpMeshHeader * mesh); + +/* Add a triangle to a mesh */ +extern RpBuildMesh *_rpBuildMeshAddTriangle(RpBuildMesh * mesh, + RpMaterial * material, + RwInt32 vert1, + RwInt32 vert2, + RwInt32 vert3); + +#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) + +/* Get primtype from a mesh header */ +extern RwPrimitiveType RpMeshHeaderGetPrimType(RpMeshHeader * + meshHeader); + +/* Set primtype for a mesh header */ +extern RpMeshHeader *RpMeshHeaderSetPrimType(RpMeshHeader * + meshHeader, + RwPrimitiveType + primType); + +#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + +/* Enumerate meshes within a mesh header */ +extern RpMeshHeader *_rpMeshHeaderForAllMeshes(RpMeshHeader * + meshHeader, + RpMeshCallBack + fpCallBack, + void *pData); + +/* Mesh serialisation functions */ +extern RwStream *_rpMeshWrite(const RpMeshHeader * meshHeader, + const void *object, + RwStream * stream, + const RpMaterialList * matList); +extern RpMeshHeader *_rpMeshRead(RwStream * stream, + const void *object, + const RpMaterialList * matList); +extern RwInt32 _rpMeshSize(const RpMeshHeader *meshHeader, + const void *object); +/* Mesh header create/destroy functions */ +extern void _rpMeshHeaderDestroy(RpMeshHeader * meshHeader); +extern RpMeshHeader * _rpMeshHeaderCreate(RwUInt32 size); + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: c:/daily/rwsdk/world/basector.h ---*/ + +/* + * Handling atomic sectors + * Atomic sectors are use to divide up the world into manageable portions + * + * Copyright (c) 1998 Criterion Software Ltd. +*/ + +/**************************************************************************** + Defines + */ + +/* Type ID */ +#define rpWorldSector 0xff /* Not a true 'type'! */ + +#define rpMINDISTANCEBETWEENVERTICES (RwReal)(0.0001) + +#define RPV3DFROMVERTEXNORMAL(v, n) \ + (v).x = (((RwReal)((n).x)) * ( (RwReal)(1.0/128))); \ + (v).y = (((RwReal)((n).y)) * ( (RwReal)(1.0/128))); \ + (v).z = (((RwReal)((n).z)) * ( (RwReal)(1.0/128))) + +#define RPVERTEXNORMALFROMRWV3D(n, v) \ + { \ + RwFixed naTmp[3]; \ + \ + naTmp[0] = RwRealToFixed((v).x); \ + naTmp[1] = RwRealToFixed((v).y); \ + naTmp[2] = RwRealToFixed((v).z); \ + \ + if (naTmp[0] >= RwFixedCast(1)) \ + { \ + naTmp[0] = RwFixedCast(1)-1; \ + } \ + if (naTmp[0] <= RwFixedCast(-1)) \ + { \ + naTmp[0] = RwFixedCast(-1)+1; \ + } \ + if (naTmp[1] >= RwFixedCast(1)) \ + { \ + naTmp[1] = RwFixedCast(1)-1; \ + } \ + if (naTmp[1] <= RwFixedCast(-1)) \ + { \ + naTmp[1] = RwFixedCast(-1)+1; \ + } \ + if (naTmp[2] >= RwFixedCast(1)) \ + { \ + naTmp[2] = RwFixedCast(1)-1; \ + } \ + if (naTmp[2] <= RwFixedCast(-1)) \ + { \ + naTmp[2] = RwFixedCast(-1)+1; \ + } \ + \ + (n).x = (RwInt8)(naTmp[0]>>9); \ + (n).y = (RwInt8)(naTmp[1]>>9); \ + (n).z = (RwInt8)(naTmp[2]>>9); \ + } + +/* RpCollSector access macros - for pre v304 data */ +#define RWCOLLSECTORGETTYPE(sect) \ + ((sect).cType&0x80) + +#define RWCOLLSECTORGETPLANE(sect) \ + ((((sect).cType)>>3)&0xc) + +#define RWCOLLSECTORGETON(sect) \ + (((sect).cType)&0x1f) + +#define RWCOLLSECTORGETVERTEX(sect) \ + (sect).vertex + +#define RWCOLLSECTORGETSTART(sect) \ + (sect).start + +#define RWCOLLSECTORGETNOPOLYS(sect) \ + (sect).cType + +#define RWCOLLSECTORSETPOLYGONS(sect,no,st) \ + (sect).cType = (RwUInt8)(no); \ + (sect).start = (RwUInt8)(st) + +#define rwMAXCOLLISIONCUTS 7 + +/**************************************************************************** + Global types + */ + +typedef struct RpVertexNormal RpVertexNormal; + +struct RpVertexNormal +{ + RwInt8 x; + RwInt8 y; + RwInt8 z; + RwUInt8 pad; /* pad character to force alignment */ +}; + +typedef struct RpPolygon RpPolygon; + +struct RpPolygon +{ + RwUInt16 matIndex; + RwUInt16 vertIndex[3]; +}; + +/* RpCollSector - for pre v304 data */ +#define RWCOLLSECTORSETPLANE(sect,plane,vert,no,st) \ + (sect).cType = (RwUInt8)(0x80|((plane)<<3)|(no)); \ + (sect).vertex = (RwUInt8)(vert); \ + (sect).start = (RwUInt8)(st) + +typedef struct RpCollSector RpCollSector; + +struct RpCollSector +{ + RwUInt8 cType; /* Bit 7 - 1 plane */ + /* 0 polygons */ + /* Bit 6-5 - plane */ + /* Bit 4-0 - amount ON plane */ + RwUInt8 vertex; /* Vertex index used for the split */ + RwUInt8 start; /* Starting polygon */ +}; + +/** + * \ingroup rpworlddatatypes + * \typedef RpWorldSector + * World Sector object. This should be + * considered an opaque type. Use the RpWorldSector API functions to access. + */ +typedef struct RpWorldSector RpWorldSector; + +#if (!defined(DOXYGEN)) +struct RpWorldSector +{ + RwInt32 type; + + RpPolygon *polygons; /* Polygons themselves */ + + RwV3d *vertices; /* Vertex positions */ + RpVertexNormal *normals; /* Vertex normals */ + + RwTexCoords *texCoords[rwMAXTEXTURECOORDS]; /* Texture coordinates */ + + RwRGBA *preLitLum; /* Pre lit luminances */ + + /* Pointer to memory allocated for vertex and poly pointers */ + RwResEntry *repEntry; + + /* Atomics in this sectors */ + /* The pointers are frigged so they look like they are pointing to + Atomics when they are pointing to here */ + RwLinkList collAtomicsInWorldSector; /* Coll priority */ + RwLinkList noCollAtomicsInWorldSector; /* No Coll priority */ + + /* Lights in an atomic sector */ + RwLinkList lightsInWorldSector; + + /* Outer bounding box of sector based on BSP planes */ + RwBBox boundingBox; + + /* Bounding box tightly enclosing geometry */ + RwBBox tightBoundingBox; + + /* The root of the bsp collision tree for pre v304 data */ + RpCollSector *colSectorRoot; + + /* The mesh which groups same material polygons together */ + RpMeshHeader *mesh; + + /* The WorldSector object pipeline for this WorldSector */ + RxPipeline *pipeline; + + /* Material list window base + * (triangles in a given sector can "see" + * the 256 materials from + * MatList[matListWindowBase] -> MatList[matListWindowBase + 255]) + */ + RwUInt16 matListWindowBase; + + RwUInt16 numVertices; /* Num vertices */ + RwUInt16 numPolygons; /* Num polygons */ + RwUInt16 pad; +}; +#endif /* (!defined(DOXYGEN)) */ + +/** + * \ingroup rpworlddatatypes + * \typedef RpWorldSectorCallBack + \ref RpWorldSectorCallBack + * represents the function called from \ref RpWorldForAllWorldSectors, + * \ref RpAtomicForAllWorldSectors and \ref RpLightForAllWorldSectors for all + * world sectors in a given world or world sectors a given atomic or light lies + * in. This function should return a pointer to the current world sector to + * indicate success. The callback may return NULL to terminate further + * callbacks on the atomic or light. + * + * \return Pointer to the current world sector. + * + * \param sector Pointer to the current world sector + * \param data Pointer to developer-defined data structure. + */ +typedef RpWorldSector *(*RpWorldSectorCallBack)(RpWorldSector *worldSector, void *data); + +typedef struct RpSector RpSector; + +struct RpSector +{ + RwInt32 type; +}; + +/* NOTE: The left and right pointers can point to an RpPlaneSector or + * an RpWorldSector + * This is determined what the type is via the type value + */ + +typedef struct RpPlaneSector RpPlaneSector; + +struct RpPlaneSector +{ + RwInt32 type; + + RwReal value; + RpSector *leftSubTree; /* Sector 'left' (less) of the plane */ + RpSector *rightSubTree; /* Sector 'right' (more) of the plane */ + RwReal leftValue; + RwReal rightValue; +}; + + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RwPluginRegistry sectorTKList; + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#define RpWorldSectorGetBBoxMacro(_sctr) (&((_sctr)->boundingBox)) +#define RpWorldSectorGetTightBBoxMacro(_sctr) (&((_sctr)->tightBoundingBox)) + +#if ((!defined(RWDEBUG)) && (!defined(RWSUPPRESSINLINE))) + +#define RpWorldSectorGetBBox RpWorldSectorGetBBoxMacro +#define RpWorldSectorGetTightBBox RpWorldSectorGetTightBBoxMacro + +#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + + +/* Get info from atomic sectors */ +extern RwInt32 RpWorldSectorGetNumPolygons(const RpWorldSector *Sector); +extern RwInt32 RpWorldSectorGetNumVertices(const RpWorldSector *Sector); + +/* Instancing and deinstancing sectors */ +extern RpWorldSector * RpWorldSectorRender(RpWorldSector *worldSector); + +extern const RpWorldSector *RpWorldSectorForAllMeshes(const RpWorldSector *sector, + RpMeshCallBack fpCallBack, + void *pData); + + +#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) + +extern const RwBBox *RpWorldSectorGetBBox(const RpWorldSector *sector); +extern const RwBBox *RpWorldSectorGetTightBBox(const RpWorldSector *sector); + +#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + +/* Plugins */ +extern RwInt32 RpWorldSectorRegisterPlugin(RwInt32 size, RwUInt32 pluginID, + RwPluginObjectConstructor constructCB, + RwPluginObjectDestructor destructCB, + RwPluginObjectCopy copyCB); +extern RwInt32 RpWorldSectorRegisterPluginStream(RwUInt32 pluginID, + RwPluginDataChunkReadCallBack readCB, + RwPluginDataChunkWriteCallBack writeCB, + RwPluginDataChunkGetSizeCallBack getSizeCB); +extern RwInt32 RpWorldSectorSetStreamAlwaysCallBack( + RwUInt32 pluginID, + RwPluginDataChunkAlwaysCallBack alwaysCB); +extern RwInt32 RpWorldSectorSetStreamRightsCallBack(RwUInt32 pluginID, + RwPluginDataChunkRightsCallBack rightsCB); +extern RwInt32 RpWorldSectorGetPluginOffset(RwUInt32 pluginID); +extern RwBool RpWorldSectorValidatePlugins(const RpWorldSector *sector); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +/*--- Automatically derived from: c:/daily/rwsdk/world/bameshop.h ---*/ + +/**************************************************************************** + Defines + */ + +/** + * \ingroup rpworlddatatypes + * \typedef RpTriStripMeshCallBack + * \ref RpTriStripMeshCallBack is the callback to generate triangle strips + * when the triangle stripped geometries or world sectors are unlocked. + * + * \param buildMesh pointer to the mesh which the triangle strip will be + * generated from. + * \param data pointer to user-supplied data to pass to the callback + * function. + * + * \return a pointer to the constructed mesh header. + * + */ +typedef RpMeshHeader * +(*RpTriStripMeshCallBack) (RpBuildMesh *buildMesh, void *data); + + +/**************************************************************************** + Global types + */ + + +/**************************************************************************** + Global Variables + */ + + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + + +/* Callback mesh generating functions */ +extern RpMeshHeader * +RpBuildMeshGenerateTrivialTriStrip(RpBuildMesh *buildMesh, void *data); + +extern RpMeshHeader * +RpBuildMeshGenerateDefaultTriStrip(RpBuildMesh *buildmesh, void *data); + +extern RpMeshHeader * +RpBuildMeshGeneratePreprocessTriStrip(RpBuildMesh *buildmesh, void *data); + +extern RpMeshHeader * +RpBuildMeshGenerateExhaustiveTriStrip(RpBuildMesh *buildmesh, void *data); + +extern RpMeshHeader * +RpBuildMeshGenerateDefaultIgnoreWindingTriStrip(RpBuildMesh *buildmesh, + void *data); + +extern RpMeshHeader * +RpBuildMeshGeneratePreprocessIgnoreWindingTriStrip(RpBuildMesh *buildmesh, + void *data); + +extern RpMeshHeader * +RpBuildMeshGenerateExhaustiveIgnoreWindingTriStrip(RpBuildMesh *buildmesh, + void *data); + +/* Functions to set and get the global mesh tristrip algorithm */ +extern RwBool +RpMeshSetTriStripMethod(RpTriStripMeshCallBack callback, void *data); + +extern RwBool +RpMeshGetTriStripMethod(RpTriStripMeshCallBack *callback, void **data); + + +extern RpMeshHeader * +_rpTriListMeshGenerate(RpBuildMesh *buildMesh, void *data); + +/* + * Optimise the mesh ordering + * (sort on material and place transparent materials last) + */ +extern RpMeshHeader * +_rpMeshOptimise(RpBuildMesh *buildmesh, RwUInt32 flags); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +#define _rpTriStripMeshTrivialGenerate(_buildMesh, _data) \ + RpBuildMeshGenerateTrivialTriStrip(_buildMesh, _data) + +#define _rpTriStripMeshDefaultGenerate(_buildmesh, _data) \ + RpBuildMeshGenerateDefaultTriStrip(_buildmesh, _data) + +#define _rpTriStripMeshPreprocessGenerate(_buildmesh, _data) \ + RpBuildMeshGeneratePreprocessTriStrip(_buildmesh, _data) + +#define _rpTriStripMeshExhaustiveGenerate(_buildmesh, _data) \ + RpBuildMeshGenerateExhaustiveTriStrip(_buildmesh, _data) + +#define _rpMeshSetTristripMethod(_callback, _data) \ + RpMeshSetTriStripMethod(_callback, _data) + +#define _rpMeshGetTristripMethod(_callback, _data) \ + RpMeshGetTriStripMethod(_callback, _data) + + + +/*--- Automatically derived from: c:/daily/rwsdk/world/balight.h ---*/ + +/* + * Lighting 3D objects. + * Lights are used to illuminate atomics and worlds + * + * Copyright (c) 1998 Criterion Software Ltd. + */ + + +/**************************************************************************** + Defines + */ + +/* Binary Light */ +typedef struct RpLightChunkInfo RpLightChunkInfo; +typedef struct RpLightChunkInfo _rpLight; + +struct RpLightChunkInfo +{ + RwReal radius; /**< radius */ + RwReal red; /**< red */ + RwReal green; /**< green */ + RwReal blue; /**< blue */ + RwReal minusCosAngle; /**< minusCosAngle */ + RwUInt32 typeAndFlags; /**< typeAndFlags */ +}; + +/* Type ID */ +#define rpLIGHT 3 + +/* Beyond this the lights must be positioned */ +#define rpLIGHTPOSITIONINGSTART 0x80 + +/** + * \ingroup rpworlddatatypes + * \ref RpLightType are + * light sub types. This type represents the different + * types of light source that can be created using the API function \ref RpLightCreate. + * Note that lights of types rpLIGHTPOINT, rpLIGHTSPOT and rpLIGHTSPOTSOFT have linear + * intensity fall-off with distance from the source, reducing to zero at the light's radius:*/ +enum RpLightType +{ + rpNALIGHTTYPE = 0, + + /* These don't take part in the tie mechanism (no position) */ + rpLIGHTDIRECTIONAL, /**<Directional Light */ + rpLIGHTAMBIENT, /**<Ambient Light */ + + /* These do take part in the tie mechanism (do have position) */ + rpLIGHTPOINT = rpLIGHTPOSITIONINGSTART, /**<Point Light */ + rpLIGHTSPOT, /**<Spot Light */ + rpLIGHTSPOTSOFT, /**<Soft Spot Light */ + rpLIGHTTYPEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RpLightType RpLightType; + +#define rpLIGHTMINCONEANGLE ((RwReal)0.0f) +#if ((defined(XBOX_DRVMODEL_H)) || (defined(OPENGL_DRVMODEL_H)) || (defined(GCN_DRVMODEL_H))) +/* XBox has Micro$oft-penned drivers, no wonder it crashes... */ +/* OpenGL and GCN clamp to 90 internally, so we mirror that behaviour */ +#define rpLIGHTMAXCONEANGLE ((RwReal)89.9999f) +#else +#define rpLIGHTMAXCONEANGLE ((RwReal)180.0f) +#endif + +/*************/ + +/*** FLAGS ***/ + +/*************/ + +/** + * \ingroup rpworlddatatypes + * \ref RpLightFlag defines what geometry is influenced by the light. + * The bit-field RpLightFlag specifies the options available for controlling the scope + * of a light source (see API function \ref RpLightSetFlags):*/ +enum RpLightFlag +{ + rpLIGHTLIGHTATOMICS = 0x01, /**<The light source illuminates all atomics in a world */ + rpLIGHTLIGHTWORLD = 0x02, /**<The light source illuminates all static geometry in a world */ + rpLIGHTFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RpLightFlag RpLightFlag; + +/* rpLIGHTPRIVATENOCHROMA - turns on optimisations to do with + * lights which are a shade of grey + */ +enum rpLightPrivateFlag +{ + rpLIGHTPRIVATENOCHROMA = 0x01, + rpLIGHTPRIVATEFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum rpLightPrivateFlag rpLightPrivateFlag; + +/*********************/ + + +#define RWMINUSCOSFROMTAN(_minusCosAngle, _tanAngle) \ +MACRO_START \ +{ \ + const RwReal TanAngle2 = (_tanAngle) * (_tanAngle); \ + const RwReal CosAngle2 = ((RwReal)1) / ( ((RwReal)1) + TanAngle2); \ + RwReal CosAngle; \ + rwSqrtMacro(&CosAngle, CosAngle2); \ + (_minusCosAngle) = - CosAngle; \ +} \ +MACRO_STOP + +#define RWTANFROMMINUSCOS(_tanAngle, _minusCosAngle) \ +MACRO_START \ +{ \ + const RwReal CosAngle2 = (_minusCosAngle) * (_minusCosAngle); \ + const RwReal TanAngle2 = (((RwReal)1) - (CosAngle2)) / (CosAngle2); \ + rwSqrtMacro(&_tanAngle, TanAngle2); \ +} \ +MACRO_STOP + + +/** + * \ingroup rpworlddatatypes + * \typedef RpLight + * Light. This should be + * considered an opaque type. User the RpLight API functions to access. + */ +typedef struct RpLight RpLight; + +#if (!defined(DOXYGEN)) +struct RpLight +{ + RwObjectHasFrame object; /**< object */ + RwReal radius; /**< radius */ + RwRGBAReal color; /**< color */ /* Light color */ + RwReal minusCosAngle; /**< minusCosAngle */ + RwLinkList WorldSectorsInLight; /**< WorldSectorsInLight */ + RwLLLink inWorld; /**< inWorld */ + RwUInt16 lightFrame; /**< lightFrame */ + RwUInt16 pad; +}; +#endif /* (!defined(DOXYGEN)) */ + +/** + * \ingroup rpworlddatatypes + * \typedef RpLightCallBack + * \ref RpLightCallBack + * represents the function called from \ref RpWorldForAllLights and + * \ref RpWorld SectorForAllLights for all lights in a given world or world + * sector. This function should return a pointer to the current light to + * indicate success. The callback may return NULL to terminate further + * callbacks on the world sector. + * + * \return Pointer to the current light. + * + * \param light Pointer to the current light in the world + * sector. + * \param data Pointer to developer-defined data structure. + */ +typedef RpLight *(*RpLightCallBack) (RpLight * light, void *data); + +typedef struct RpLightTie RpLightTie; + +struct RpLightTie +{ + /* Information for an atomic sector */ + RwLLLink lightInWorldSector; /* Lights IN this ATOMIC SECTOR */ + RpLight *light; + + /* Information for a atomic */ + RwLLLink WorldSectorInLight; /* Atomic sectors HOLDING this Light */ + RpWorldSector *sect; +}; + + +/**************************************************************************** + <macro/inline functionality + */ + +#define RpLightGetRadiusMacro(_light) \ + ((_light)->radius) + +#define RpLightGetColorMacro(_light) \ + (&((_light)->color)) + +#define RpLightSetFrameMacro(_light, _frame) \ + (rwObjectHasFrameSetFrame((_light), (_frame)), (_light)) + +#define RpLightGetFrameMacro(_light) \ + ((RwFrame *)rwObjectGetParent((_light))) + +#define RpLightGetTypeMacro(_light) \ + ((RpLightType)rwObjectGetSubType((_light))) + +#define RpLightSetFlagsMacro(_light, _flags) \ + ((rwObjectSetFlags((_light), (_flags))), (_light)) + +#define RpLightGetFlagsMacro(_light) \ + (rwObjectGetFlags((_light))) + + +#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) + +#define RpLightGetRadius(_light) \ + RpLightGetRadiusMacro(_light) + +#define RpLightGetColor(_light) \ + RpLightGetColorMacro(_light) + +#define RpLightSetFrame(_light, _frame) \ + RpLightSetFrameMacro(_light, _frame) + +#define RpLightGetFrame(_light) \ + RpLightGetFrameMacro(_light) + +#define RpLightGetType(_light) \ + RpLightGetTypeMacro(_light) + +#define RpLightSetFlags(_light, _flags) \ + RpLightSetFlagsMacro(_light, _flags) + +#define RpLightGetFlags(_light) \ + RpLightGetFlagsMacro(_light) + +#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + + +#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) +extern RwReal RpLightGetRadius(const RpLight *light); +extern const RwRGBAReal *RpLightGetColor(const RpLight *light); +extern RpLight *RpLightSetFrame(RpLight *light, RwFrame *frame); +extern RwFrame *RpLightGetFrame(const RpLight *light); +extern RpLightType RpLightGetType(const RpLight *light); +extern RpLight *RpLightSetFlags(RpLight *light, RwUInt32 flags); +extern RwUInt32 RpLightGetFlags(const RpLight *light); +#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + +/* API Functions */ +extern RpLight *RpLightCreate(RwInt32 type); +extern RwBool RpLightDestroy(RpLight *light); +extern RpLight *RpLightSetRadius(RpLight *light, RwReal radius); +extern RpLight *RpLightSetColor(RpLight *light, const RwRGBAReal *color); +extern RwReal RpLightGetConeAngle(const RpLight *light); +extern RpLight *RpLightSetConeAngle(RpLight * ight, RwReal angle); +extern RwUInt32 RpLightStreamGetSize(const RpLight *light); +extern RpLight *RpLightStreamRead(RwStream *stream); +extern const RpLight *RpLightStreamWrite(const RpLight *light, + RwStream *stream); +extern RpLightChunkInfo *_rpLightChunkInfoRead(RwStream *stream, + RpLightChunkInfo *lightChunkInfo, + RwInt32 *bytesRead); + +/* Attaching toolkits */ +extern RwInt32 RpLightRegisterPlugin(RwInt32 size, + RwUInt32 pluginID, + RwPluginObjectConstructor constructCB, + RwPluginObjectDestructor destructCB, + RwPluginObjectCopy copyCB); +extern RwInt32 RpLightRegisterPluginStream(RwUInt32 pluginID, + RwPluginDataChunkReadCallBack readCB, + RwPluginDataChunkWriteCallBack writeCB, + RwPluginDataChunkGetSizeCallBack getSizeCB); +extern RwInt32 RpLightSetStreamAlwaysCallBack(RwUInt32 pluginID, + RwPluginDataChunkAlwaysCallBack alwaysCB); +extern RwInt32 RpLightGetPluginOffset(RwUInt32 pluginID); +extern RwBool RpLightValidatePlugins(const RpLight * light); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#define RpLightChunkInfoRead(stream, lightChunkInfo, bytesRead) \ + _rpLightChunkInfoRead(stream, lightChunkInfo, bytesRead) + + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/d3d8/D3D8lights.h ---*/ +/** + * \ingroup rplightd3d8 + * \typedef RpD3D8AttenuationParams + * typedef for struct RpD3D8AttenuationParams + */ +typedef struct RpD3D8AttenuationParams RpD3D8AttenuationParams; +/** + * \ingroup rplightd3d8 + * \struct RpD3D8AttenuationParams + * This type represents the attenuation model of a spot or point light. + */ +struct RpD3D8AttenuationParams +{ + RwReal constant; /**< Constant attenuation coefficient */ + RwReal linear; /**< Linear attenuation coefficient */ + RwReal quadratic; /**< Quadratic attenuation coefficient */ +}; + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern void +RpD3D8LightSetAttenuationParams(RpLight *light, + const RpD3D8AttenuationParams *params); + +extern void +RpD3D8LightGetAttenuationParams(const RpLight *light, + RpD3D8AttenuationParams *params); + +extern RwBool +_rwD3D8LightsOpen(void); + +extern RwBool +_rwD3D8LightsGlobalEnable(RpLightFlag flags); + +extern RwBool +_rwD3D8LightDirectionalEnable(RpLight *light); + +extern RwBool +_rwD3D8LightLocalEnable(RpLight *light); + +extern void +_rwD3D8LightsEnable(RwBool enable, RwUInt32 type); + +extern void +_rwD3D8LightsClose(void); + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/p2stdclsw.h ---*/ +typedef RpLight *RxLight; +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RxClusterDefinition RxClLights; /* Uses the RxLight type (see above) */ + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + + +/*--- Automatically derived from: c:/daily/rwsdk/world/bageomet.h ---*/ + +/* + * Handling atomic's geometry + * Geometry describe objects, and are the building blocks for atomics + * + * Copyright (c) 1998 Criterion Software Ltd. +*/ + + +/**************************************************************************** + Defines + */ + +/* Type ID */ +#define rpGEOMETRY 8 + +/** + * \ingroup rpworlddatatypes + * RpGeometryFlag + * Geometry type flags + * + * When creating a geometry, these flags can be OR'ed together to + * specify the format along with the rpGEOMETRYTEXCOORDSETS(n) macro if more + * than two sets of texture coordinates are required. See \ref RpGeometryCreate + * for more details. + * + * \see RpGeometryCreate(). + */ +enum RpGeometryFlag +{ + rpGEOMETRYTRISTRIP = 0x00000001, /**<This geometry's meshes can be + rendered as strips. + \ref RpMeshSetTriStripMethod is + used to change this method.*/ + rpGEOMETRYPOSITIONS = 0x00000002, /**<This geometry has positions */ + rpGEOMETRYTEXTURED = 0x00000004, /**<This geometry has only one set of + texture coordinates. Texture + coordinates are specified on a per + vertex basis */ + rpGEOMETRYPRELIT = 0x00000008, /**<This geometry has pre-light colors */ + rpGEOMETRYNORMALS = 0x00000010, /**<This geometry has vertex normals */ + rpGEOMETRYLIGHT = 0x00000020, /**<This geometry will be lit */ + rpGEOMETRYMODULATEMATERIALCOLOR = 0x00000040, /**<Modulate material color + with vertex colors + (pre-lit + lit) */ + + rpGEOMETRYTEXTURED2 = 0x00000080, /**<This geometry has at least 2 sets of + texture coordinates. */ + + /* + * These above flags were stored in the flags field in an RwObject, they + * are now stored in the flags file of the RpGeometry. + */ + + rpGEOMETRYNATIVE = 0x01000000, + rpGEOMETRYNATIVEINSTANCE = 0x02000000, + + rpGEOMETRYFLAGSMASK = 0x000000FF, + rpGEOMETRYNATIVEFLAGSMASK = 0x0F000000, + + rpGEOMETRYFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RpGeometryFlag RpGeometryFlag; + +/* Multi texture coordinate format specifier for RpGeometryCreate() */ +#define rpGEOMETRYTEXCOORDSETS(_num) ((_num & 0xff) << 16) + +/** + * \ingroup rpworlddatatypes + * RpGeometryLockMode + * Geometry lock flags + */ +enum RpGeometryLockMode +{ + rpGEOMETRYLOCKPOLYGONS = 0x01, /**<Lock the polygons (triangle list) */ + rpGEOMETRYLOCKVERTICES = 0x02, /**<Lock the vertex positional data */ + rpGEOMETRYLOCKNORMALS = 0x04, /**<Lock the vertex normal data */ + rpGEOMETRYLOCKPRELIGHT = 0x08, /**<Lock the pre-light values */ + rpGEOMETRYLOCKTEXCOORDS = 0x10, /**<Lock the texture coordinates set 1*/ + rpGEOMETRYLOCKTEXCOORDS1 = 0x10, /**<Lock the texture coordinates set 1*/ + rpGEOMETRYLOCKTEXCOORDS2 = 0x20, /**<Lock the texture coordinates set 2*/ + rpGEOMETRYLOCKTEXCOORDS3 = 0x40, /**<Lock the texture coordinates set 3*/ + rpGEOMETRYLOCKTEXCOORDS4 = 0x80, /**<Lock the texture coordinates set 4*/ + rpGEOMETRYLOCKTEXCOORDS5 = 0x0100, /**<Lock the texture coordinates set 5*/ + rpGEOMETRYLOCKTEXCOORDS6 = 0x0200, /**<Lock the texture coordinates set 6*/ + rpGEOMETRYLOCKTEXCOORDS7 = 0x0400, /**<Lock the texture coordinates set 7*/ + rpGEOMETRYLOCKTEXCOORDS8 = 0x0800, /**<Lock the texture coordinates set 8*/ + rpGEOMETRYLOCKTEXCOORDSALL = 0x0ff0, /**<Lock all texture coordinate sets*/ + rpGEOMETRYLOCKALL = 0x0fff, /**<Combination of all the above */ + + rpGEOMETRYLOCKMODEFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RpGeometryLockMode RpGeometryLockMode; + +/* Convenience macro for generating a tex coord lock flag */ +#define rpGEOMETRYLOCKTEXCOORDSIDX(_idx) (rpGEOMETRYLOCKTEXCOORDS1 << (_idx)) + + +/**************************************************************************** + Global Types + */ + +typedef struct rpGeometryGlobals rpGeometryGlobals; +struct rpGeometryGlobals +{ + RwFreeList *geomFreeList; +}; + +/** + * \ingroup rpworlddatatypes + * \typedef RpGeometry + * Geometry object. This should be considered an opaque type. + * Use the RpGeometry API functions to access. + */ +typedef struct RpGeometry RpGeometry; + +/** + * \ingroup rpworlddatatypes + * \typedef RpMorphTarget + * Morph target -- vertex positions and normals. + * This should be considered an opaque type. + * Use RpMorphTarget API functions to access. + */ +typedef struct RpMorphTarget RpMorphTarget; + +#if (!defined(DOXYGEN)) +struct RpMorphTarget +{ + RpGeometry *parentGeom; + RwSphere boundingSphere; + RwV3d *verts; + RwV3d *normals; +}; +#endif /* (!defined(DOXYGEN)) */ + +typedef struct RpTriangle RpTriangle; + +/** + * \ingroup rpworlddatatypes + * \struct RpTriangle + * This type represents a triangle in a geometry specified + * by three indices into the geometry's vertex list (vertIndex) + * together with an index in to the geometry's + * material list (matIndex) (see API function \ref RpGeometryGetTriangles) + */ +struct RpTriangle +{ + RwUInt16 vertIndex[3]; /**< vertex indices */ + RwInt16 matIndex; /**< Index into material list */ +}; + +#if (!defined(DOXYGEN)) +struct RpGeometry +{ + RwObject object; /* Generic type */ + + RwUInt32 flags; /* Geometry flags */ + + RwUInt16 lockedSinceLastInst; /* What has been locked since we last instanced - for re-instancing */ + RwInt16 refCount; /* Reference count (for keeping track of atomics referencing geometry) */ + + RwInt32 numTriangles; /* Quantity of various things (polys, verts and morph targets) */ + RwInt32 numVertices; + RwInt32 numMorphTargets; + RwInt32 numTexCoordSets; + + RpMaterialList matList; + + RpTriangle *triangles; /* The triangles */ + + RwRGBA *preLitLum; /* The pre-lighting values */ + + RwTexCoords *texCoords[rwMAXTEXTURECOORDS]; /* Texture coordinates */ + + RwSurfaceProperties ignoredSurfaceProps; /* Not used in pp rendering, but present + * so if pipe1 files are read and written these + * values are not lost + */ + + RpMeshHeader *mesh; /* The mesh - groups polys of the same material */ + + RwResEntry *repEntry; /* Information for an instance */ + + RpMorphTarget *morphTarget; /* The Morph Target */ +}; +#endif /* (!defined(DOXYGEN)) */ + +typedef struct RpGeometryChunkInfo RpGeometryChunkInfo; +typedef struct RpGeometryChunkInfo _rpGeometry; + +struct RpGeometryChunkInfo +{ + RwInt32 format; /* Compression flags and number of texture coord sets */ + + RwInt32 numTriangles; + RwInt32 numVertices; + + RwInt32 numMorphTargets; + + RwSurfaceProperties ignoredSurfaceProps; +}; + +/* Callbacks */ + +/** + * \ingroup rpworlddatatypes + * \typedef RpGeometryCallBack + * \ref RpGeometryCallBack represents the simple callback function for the \ref RpGeometry object. + * The callback may return NULL to terminate further callbacks on + * the geometry. + * + * \param geometry Pointer to the current geometry, supplied by iterator. + * \param data Pointer to developer-defined data structure. + */ +typedef RpGeometry *(*RpGeometryCallBack)(RpGeometry *geometry, void *data); + +/** + * \ingroup rpworlddatatypes + * \typedef RpGeometrySortByMaterialCallBack + * \ref RpGeometrySortByMaterialCallBack is used by + * \ref RpGeometrySortByMaterial in order to preserve the validity of plugin + * data when the vertices in an \ref RpGeometry are sorted (and some possibly + * duplicated). + * + * A vertex map table is provided to the callback - this contains, for each + * vertex in the new geometry, the index of the corresponding vertex in the + * original geometry. + * + * \param oldGeom Pointer to the source geometry. + * \param newGeom Pointer to the new, sorted geometry. + * \param remapTable pointer to the vertex map table + * \param numberOfEntries Number of vertices in the new + * geometry (size of the map table) + */ +typedef void (*RpGeometrySortByMaterialCallBack)(const RpGeometry *oldGeom, + RpGeometry *newGeom, + RwUInt16 *remapTable, + RwUInt16 numberOfEntries); + + +/**************************************************************************** + <macro/inline functionality + */ + +#define RpMorphTargetSetBoundingSphereMacro(_mt, _sphere) \ + (RwSphereAssign(&((_mt)->boundingSphere), (_sphere)), (_mt)) + +#define RpMorphTargetGetBoundingSphereMacro(_mt) \ + (&((_mt)->boundingSphere)) + +#define RpGeometryGetNumMorphTargetsMacro(_geometry) \ + ((_geometry)->numMorphTargets) + +#define RpGeometryGetMorphTargetMacro(_geometry, _index) \ + (&((_geometry)->morphTarget[(_index)])) + +#define RpGeometryGetPreLightColorsMacro(_geometry) \ + ((_geometry)->preLitLum) + +#define RpGeometryGetVertexTexCoordsMacro(_geometry, _uvIndex) \ + ((_geometry)->texCoords[(_uvIndex) - 1]) + +#define RpGeometryGetNumTexCoordSetsMacro(_geometry) \ + ((_geometry)->numTexCoordSets) + +#define RpGeometryGetNumVerticesMacro(_geometry) \ + ((_geometry)->numVertices) + +#define RpMorphTargetGetVerticesMacro(_mt) \ + ((_mt)->verts) + +#define RpMorphTargetGetVertexNormalsMacro(_mt) \ + ((_mt)->normals) + +#define RpGeometryGetTrianglesMacro(_geometry) \ + ((_geometry)->triangles) + +#define RpGeometryGetNumTrianglesMacro(_geometry) \ + ((_geometry)->numTriangles) + +#define RpGeometryGetMaterialMacro(_geometry, _num) \ + (((_geometry)->matList.materials)[(_num)]) + +#define RpGeometryGetNumMaterialsMacro(_geometry) \ + ((_geometry)->matList.numMaterials) + +#define RpGeometryGetFlagsMacro(_geometry) \ + ((_geometry)->flags) + +#define RpGeometrySetFlagsMacro(_geometry, _flags) \ + (((_geometry)->flags = (_flags)), (_geometry)) + + +#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) + +#define RpMorphTargetSetBoundingSphere(_geometry, _sphere) \ + RpMorphTargetSetBoundingSphereMacro(_geometry, _sphere) + +#define RpMorphTargetGetBoundingSphere(_geometry) \ + RpMorphTargetGetBoundingSphereMacro(_geometry) + +#define RpGeometryGetNumMorphTargets(_geometry) \ + RpGeometryGetNumMorphTargetsMacro(_geometry) + +#define RpGeometryGetMorphTarget(_geometry, _index) \ + RpGeometryGetMorphTargetMacro(_geometry, _index) + +#define RpGeometryGetPreLightColors(_geometry) \ + RpGeometryGetPreLightColorsMacro(_geometry) + +#define RpGeometryGetVertexTexCoords(_geometry, _uvIndex) \ + RpGeometryGetVertexTexCoordsMacro(_geometry, _uvIndex) + +#define RpGeometryGetNumTexCoordSets(_geometry) \ + RpGeometryGetNumTexCoordSetsMacro(_geometry) + +#define RpGeometryGetNumVertices(_geometry) \ + RpGeometryGetNumVerticesMacro(_geometry) + +#define RpMorphTargetGetVertices(_mt) \ + RpMorphTargetGetVerticesMacro(_mt) + +#define RpMorphTargetGetVertexNormals(_mt) \ + RpMorphTargetGetVertexNormalsMacro(_mt) + +#define RpGeometryGetTriangles(_geometry) \ + RpGeometryGetTrianglesMacro(_geometry) + +#define RpGeometryGetNumTriangles(_geometry) \ + RpGeometryGetNumTrianglesMacro(_geometry) + +#define RpGeometryGetMaterial(_geometry, _num) \ + RpGeometryGetMaterialMacro(_geometry, _num) + +#define RpGeometryGetNumMaterials(_geometry) \ + RpGeometryGetNumMaterialsMacro(_geometry) + +#define RpGeometryGetFlags(_geometry) \ + RpGeometryGetFlagsMacro(_geometry) + +#define RpGeometrySetFlags(_geometry, _flags) \ + RpGeometrySetFlagsMacro(_geometry, _flags) + +#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + + +/* Transforms geometry morph target vertices */ + +extern RpGeometry * +RpGeometryTransform(RpGeometry *geometry, + const RwMatrix *matrix); + +/* Create geometry for a 'space' marker */ + +extern RpGeometry * +RpGeometryCreateSpace(RwReal radius); + +/* Morph targets - Accessing geometry contents */ + +#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) + +extern RpMorphTarget * +RpMorphTargetSetBoundingSphere(RpMorphTarget *morphTarget, + const RwSphere *boundingSphere); + +extern RwSphere * +RpMorphTargetGetBoundingSphere(RpMorphTarget *morphTarget); + +#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + +extern const RpMorphTarget * +RpMorphTargetCalcBoundingSphere(const RpMorphTarget *morphTarget, + RwSphere *boundingSphere); + +extern RwInt32 +RpGeometryAddMorphTargets(RpGeometry *geometry, + RwInt32 mtcount); + +extern RwInt32 +RpGeometryAddMorphTarget(RpGeometry *geometry); + +extern RpGeometry * +RpGeometryRemoveMorphTarget(RpGeometry *geometry, + RwInt32 morphTarget); + +#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) +extern RwInt32 +RpGeometryGetNumMorphTargets(const RpGeometry *geometry); + +extern RpMorphTarget * +RpGeometryGetMorphTarget(const RpGeometry *geometry, + RwInt32 morphTarget); + +extern RwRGBA * +RpGeometryGetPreLightColors(const RpGeometry *geometry); + +extern RwTexCoords * +RpGeometryGetVertexTexCoords(const RpGeometry *geometry, + RwTextureCoordinateIndex uvIndex); + +extern RwInt32 +RpGeometryGetNumTexCoordSets(const RpGeometry *geometry); + +extern RwInt32 +RpGeometryGetNumVertices (const RpGeometry *geometry); + +extern RwV3d * +RpMorphTargetGetVertices(const RpMorphTarget *morphTarget); + +extern RwV3d * +RpMorphTargetGetVertexNormals(const RpMorphTarget *morphTarget); + +extern RpTriangle * +RpGeometryGetTriangles(const RpGeometry *geometry); + +extern RwInt32 +RpGeometryGetNumTriangles(const RpGeometry *geometry); + +extern RpMaterial * +RpGeometryGetMaterial(const RpGeometry *geometry, + RwInt32 matNum); + +#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + +extern const RpGeometry * +RpGeometryTriangleSetVertexIndices(const RpGeometry *geometry, + RpTriangle *triangle, + RwUInt16 vert1, + RwUInt16 vert2, + RwUInt16 vert3); + +extern RpGeometry * +RpGeometryTriangleSetMaterial(RpGeometry *geometry, + RpTriangle *triangle, + RpMaterial *material); + +extern const RpGeometry * +RpGeometryTriangleGetVertexIndices(const RpGeometry *geometry, + const RpTriangle *triangle, + RwUInt16 *vert1, + RwUInt16 *vert2, + RwUInt16 *vert3); + +extern RpMaterial * +RpGeometryTriangleGetMaterial(const RpGeometry *geometry, + const RpTriangle *triangle); + +#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) +extern RwInt32 +RpGeometryGetNumMaterials(const RpGeometry *geometry); + +#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + +extern RpGeometry * +RpGeometryForAllMaterials(RpGeometry *geometry, + RpMaterialCallBack fpCallBack, + void *pData); + +/* Accessing the inards of geometry */ +extern RpGeometry * +RpGeometryLock(RpGeometry *geometry, + RwInt32 lockMode); + +extern RpGeometry * +RpGeometryUnlock(RpGeometry *geometry); + +extern const RpGeometry * +RpGeometryForAllMeshes(const RpGeometry *geometry, + RpMeshCallBack fpCallBack, + void *pData); + +/* Creation and destruction */ +extern RpGeometry * +RpGeometryCreate(RwInt32 numVert, + RwInt32 numTriangles, + RwUInt32 format); + +extern RwBool +RpGeometryDestroy(RpGeometry *geometry); + +extern RpGeometry * +_rpGeometryAddRef(RpGeometry *geometry); + +/* Attaching toolkits */ +extern RwInt32 +RpGeometryRegisterPlugin(RwInt32 size, + RwUInt32 pluginID, + RwPluginObjectConstructor constructCB, + RwPluginObjectDestructor destructCB, + RwPluginObjectCopy copyCB); + +extern RwInt32 +RpGeometryRegisterPluginStream(RwUInt32 pluginID, + RwPluginDataChunkReadCallBack readCB, + RwPluginDataChunkWriteCallBack writeCB, + RwPluginDataChunkGetSizeCallBack getSizeCB); + +extern RwInt32 +RpGeometrySetStreamAlwaysCallBack(RwUInt32 pluginID, + RwPluginDataChunkAlwaysCallBack alwaysCB); + +extern RwInt32 +RpGeometryGetPluginOffset(RwUInt32 pluginID); + +extern RwBool +RpGeometryValidatePlugins(const RpGeometry *geometry); + +/* Binary format */ +extern RwUInt32 +RpGeometryStreamGetSize(const RpGeometry *geometry); + +extern const RpGeometry * +RpGeometryStreamWrite(const RpGeometry *geometry, + RwStream *stream); + +extern RpGeometry * +RpGeometryStreamRead(RwStream *stream); + +extern RpGeometryChunkInfo * +_rpGeometryChunkInfoRead(RwStream *stream, + RpGeometryChunkInfo *geometryChunkInfo, + RwInt32 *bytesRead); + +#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) +/* Flags */ +extern RwUInt32 +RpGeometryGetFlags(const RpGeometry *geometry); + +extern RpGeometry * +RpGeometrySetFlags(RpGeometry *geometry, + RwUInt32 flags); + +#endif + +/* Lighting characteristics */ + +extern const RwSurfaceProperties * +_rpGeometryGetSurfaceProperties(const RpGeometry *geometry); + +extern RpGeometry * +_rpGeometrySetSurfaceProperties(RpGeometry *geometry, + const RwSurfaceProperties *surfaceProperties); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#define RpGeometryGetSurfaceProperties(_geometry) \ + _rpGeometryGetSurfaceProperties(_geometry) + +#define RpGeometrySetSurfaceProperties(_geometry, _surfaceProperties) \ + _rpGeometrySetSurfaceProperties(_geometry, _surfaceProperties) + +#define rpGeometryAddRef(_geometry) \ + _rpGeometryAddRef(_geometry) + +#define RpGeometryChunkInfoRead(stream, geometryChunkInfo, bytesRead) \ + _rpGeometryChunkInfoRead(stream, geometryChunkInfo, bytesRead) + + +/*--- Automatically derived from: c:/daily/rwsdk/world/baclump.h ---*/ + +/* + * Clump and atomic handling. + * Clumps and atomics are the movable rendered objects in the world + * + * Copyright (c) 1998 Criterion Software Ltd. + */ + + +/**************************************************************************** + Defines + */ + +/****************************** Object type ID ******************************/ + +/* Type IDs */ + +#define rpATOMIC 1 +#define rpCLUMP 2 + +/* Interpolator flags */ +enum RpInterpolatorFlag +{ + rpINTERPOLATORDIRTYINSTANCE = 0x01, + rpINTERPOLATORDIRTYSPHERE = 0x02, + rpINTERPOLATORNOFRAMEDIRTY = 0x04, + rpINTERPOLATORFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RpInterpolatorFlag rpInterpolatorFlag; + +/** + * \ingroup rpworlddatatypes + * The bit-field type RpAtomicFlag specifies the options available for + * controlling the behavior of atomics. See API function \ref RpAtomicSetFlags. + * + * \see RpAtomicSetFlags + * \see RpAtomicGetFlags + * \see RpWorldSectorForAllCollisionAtomics + */ + +enum RpAtomicFlag +{ + rpATOMICCOLLISIONTEST = 0x01, /**<A generic collision flag to indicate + * that the atomic should be considered + * in collision tests. + */ + rpATOMICRENDER = 0x04, /**<The atomic is rendered if it is + * in the view frustum. + */ + + rpATOMICFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RpAtomicFlag RpAtomicFlag; + +/** + * \ingroup rpworlddatatypes + * \ref RpAtomicSetGeomFlag defines how an atomic references a new geometry + * + * \see RpAtomicSetGeometry + */ +enum RpAtomicSetGeomFlag +{ + rpATOMICSAMEBOUNDINGSPHERE = 0x01, /**<The bounding-sphere for the + * new geometry is assumed to be the + * same as the old one, if any, and + * should not be recalculated. + */ + + rpATOMICSETGEOMFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RpAtomicSetGeomFlag RpAtomicSetGeomFlag; + +enum RpAtomicPrivateFlag +{ + rpATOMICPRIVATEWORLDBOUNDDIRTY = 0x01, + rpATOMICPRIVATEFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RpAtomicPrivateFlag rpAtomicPrivateFlag; + + +/** + * \ingroup rpworlddatatypes + * \typedef RpAtomic + * Atomic Geometry object. This should be + * considered an opaque type. Use the RpAtomic API functions to access. + */ +typedef struct RpAtomic RpAtomic; + +/** + * \ingroup rpworlddatatypes + * \typedef RpInterpolator + * Morph Target Interpolator. + * This should be considered an opaque type. + * Use the RpInterpolator API functions to access. + */ +typedef struct RpInterpolator RpInterpolator; + +#if (!defined(DOXYGEN)) +struct RpInterpolator +{ + RwInt32 flags; /**< flags */ + RwInt16 startMorphTarget; /**< startMorphTarget */ + RwInt16 endMorphTarget; /**< endMorphTarget */ + RwReal time; /**< time */ + RwReal recipTime; /**< recipTime */ + RwReal position; /**< position */ +}; +#endif /* (!defined(DOXYGEN)) */ + +/* More callbacks */ + +/** + * \ingroup rpworlddatatypes + * \typedef RpClump + * Clump Geometry object. This should be + * considered an opaque type. Use the RpClump API functions to access. + */ +typedef struct RpClump RpClump; + +/** + * \ingroup rpworlddatatypes + * \typedef RpClumpCallBack + * \ref RpClumpCallBack represents the + * function called from \ref RwCameraForAllClumpsInFrustum and + * \ref RwCameraForAllClumpsNotInFrustum when a clump lies inside the current camera's + * view frustum. It is also called from \ref RpWorldForAllClumps. This function should + * return a pointer to the current clump to indicate success. The callback may return + * NULL to terminate further callbacks on the clumps. + * + * \param clump Pointer to the current clump, supplied by + * iterator. + * \param data Pointer to developer-defined data structure. + * + * \return Pointer to the current clump. + * + * \see RpWorldForAllClumps + * \see RpClumpGetCallBack + * \see RpClumpSetCallBack + * \see RwCameraForAllClumpsInFrustum + * \see RwCameraForAllClumpsNotInFrustum + */ +typedef RpClump *(*RpClumpCallBack) (RpClump * clump, void *data); + +#if (!defined(DOXYGEN)) +struct RpClump +{ + RwObject object; + + /* Information about all the Atomics */ + RwLinkList atomicList; + + /* Lists of lights and cameras */ + RwLinkList lightList; + RwLinkList cameraList; + + /* The clump in the world */ + RwLLLink inWorldLink; + + /* Clump callback */ + RpClumpCallBack callback; + + /* Render frame - used to prevent multiple invocations + * of the clump frustum callback + */ + RwUInt16 renderFrame; + RwUInt16 pad; +}; +#endif /* (!defined(DOXYGEN)) */ + +/** + * \ingroup rpworlddatatypes + * \typedef RpAtomicCallBackRender + * \ref RpAtomicCallBackRender represents the function called from + * \ref RpAtomicRender when the specified atomic + * lies inside the current camera's view frustum. The default callback + * initiates execution of the atomic rendering pipeline. This function should + * return a pointer to the atomic to indicate success. + * + * \param atomic Pointer to the current atomic, supplied by + * iterator. + * + * \see RpAtomicRender + */ +typedef RpAtomic *(*RpAtomicCallBackRender) (RpAtomic * atomic); + +#if (!defined(DOXYGEN)) +struct RpAtomic +{ + RwObjectHasFrame object; + + /* Information for an instance */ + RwResEntry *repEntry; + + /* Triangles making the object */ + RpGeometry *geometry; + + /* Interpolated bounding sphere (in object space and world space) */ + RwSphere boundingSphere; + RwSphere worldBoundingSphere; + + /* Connections to other atomics */ + RpClump *clump; + RwLLLink inClumpLink; + + /* callbacks */ + RpAtomicCallBackRender renderCallBack; + + /* Interpolation animation pointer */ + RpInterpolator interpolator; + + /* Counter for checks of "render has occurred already" */ + RwUInt16 renderFrame; + RwUInt16 pad; + + /* Connections to sectors */ + RwLinkList llWorldSectorsInAtomic; + + /* The Atomic object pipeline for this Atomic */ + RxPipeline *pipeline; +}; +#endif /* (!defined(DOXYGEN)) */ + +/** + * \ingroup rpworlddatatypes + * \typedef RpAtomicCallBack + * \ref RpAtomicCallBack represents the function called from \ref RpWorldSectorForAllAtomics and + * \ref RpClumpForAllAtomics for all atomics in a given world sector or clump. + * This function should return a pointer to the current atomic to indicate + * success. The callback may return NULL to terminate further callbacks on + * the world sector. + * + * \param atomic Pointer to the current atomic, supplied by + * iterator. + * \param data Pointer to developer-defined data structure. + */ +typedef RpAtomic *(*RpAtomicCallBack) (RpAtomic * atomic, void *data); + +typedef struct RpTie RpTie; + +struct RpTie +{ + /* Information for an atomic sector */ + RwLLLink lAtomicInWorldSector; /* Atomics IN this ATOMIC SECTOR */ + RpAtomic *apAtom; + + /* Information for a atomic */ + RwLLLink lWorldSectorInAtomic; /* Atomic sectors HOLDING this atomic */ + RpWorldSector *worldSector; +}; + +typedef struct RpClumpChunkInfo RpClumpChunkInfo; +typedef struct RpClumpChunkInfo _rpClump; +typedef struct RpClumpChunkInfo33000 _rpClump33000; + +struct RpClumpChunkInfo +{ + RwInt32 numAtomics; + RwInt32 numLights; + RwInt32 numCameras; +}; + +struct RpClumpChunkInfo33000 +{ + RwInt32 numAtomics; +}; + +/**************************************************************************** + <macro/inline functionality + + */ + +/* NB "RpAtomicRender(atom++) will break it */ +#define RpAtomicRenderMacro(_atomic) \ + ((_atomic)->renderCallBack(_atomic)) + +#define RpAtomicGetGeometryMacro(_atomic) \ + ((_atomic)->geometry) + +#if (!defined(RpAtomicSetRenderCallBackMacro)) + +/* NB "RpAtomicSetRenderCallBack(atom++, callback)" will break it */ +#define RpAtomicSetRenderCallBackMacro(_atomic, _callback) \ +MACRO_START \ +{ \ + (_atomic)->renderCallBack = (_callback); \ + if (!(_atomic)->renderCallBack) \ + { \ + (_atomic)->renderCallBack = AtomicDefaultRenderCallBack; \ + } \ +} \ +MACRO_STOP + +#endif /* (!defined(RpAtomicSetRenderCallBackMacro)) */ + +#define RpAtomicGetRenderCallBackMacro(_atomic) \ + ((_atomic)->renderCallBack) + +#define RpAtomicGetInterpolatorMacro(_atomic) \ + (&((_atomic)->interpolator)) + +#define RpInterpolatorGetStartMorphTargetMacro(_intrp) \ + ((_intrp)->startMorphTarget) + +#define RpInterpolatorGetEndMorphTargetMacro(_intrp) \ + ((_intrp)->endMorphTarget) + +#define RpInterpolatorGetValueMacro(_intrp) \ + ((_intrp)->position) + +#define RpInterpolatorGetScaleMacro(_intrp) \ + ((_intrp)->time) + +/* NB "RpInterpolatorSetStartMorphTarget(interp++, target)" will break it */ +#define RpInterpolatorSetStartMorphTargetMacro(_intrp, _target, _atomic)\ + ((_intrp)->startMorphTarget = (RwInt16) (_target), \ + (_intrp)->flags |= (RwInt32)(rpINTERPOLATORDIRTYINSTANCE | \ + rpINTERPOLATORDIRTYSPHERE ), \ + ((!((_intrp)->flags & rpINTERPOLATORNOFRAMEDIRTY))? \ + ((RpAtomicGetFrame(_atomic))? \ + (RwFrameUpdateObjects(RpAtomicGetFrame(_atomic))): \ + (0)): \ + (0)), \ + (_intrp)) + +/* NB "RpInterpolatorSetEndMorphTarget(interp++, target)" will break it */ +#define RpInterpolatorSetEndMorphTargetMacro(_intrp, _target, _atomic) \ + ((_intrp)->endMorphTarget = (RwInt16) (_target), \ + (_intrp)->flags |= (RwInt32)(rpINTERPOLATORDIRTYINSTANCE | \ + rpINTERPOLATORDIRTYSPHERE ), \ + ((!((_intrp)->flags & rpINTERPOLATORNOFRAMEDIRTY))? \ + ((RpAtomicGetFrame(_atomic))? \ + (RwFrameUpdateObjects(RpAtomicGetFrame(_atomic))): \ + (0)): \ + (0)), \ + (_intrp)) + +/* NB "RpInterpolatorSetValue(interp++, value)" will break it */ +#define RpInterpolatorSetValueMacro(_intrp, _value, _atomic) \ + ((_intrp)->position = (_value), \ + (_intrp)->flags |= (RwInt32)(rpINTERPOLATORDIRTYINSTANCE | \ + rpINTERPOLATORDIRTYSPHERE ), \ + ((!((_intrp)->flags & rpINTERPOLATORNOFRAMEDIRTY))? \ + ((RpAtomicGetFrame(_atomic))? \ + (RwFrameUpdateObjects(RpAtomicGetFrame(_atomic))): \ + (0)): \ + (0)), \ + (_intrp)) + +/* NB "RpInterpolatorSetScale(interp++, *(scale++))" will break it */ +#define RpInterpolatorSetScaleMacro(_intrp, _scale, _atomic) \ + ((_intrp)->time = (_scale), \ + (_intrp)->recipTime = (RwReal) (1.0) / (_scale), \ + (_intrp)->flags |= (RwInt32)(rpINTERPOLATORDIRTYINSTANCE | \ + rpINTERPOLATORDIRTYSPHERE ), \ + ((!((_intrp)->flags & rpINTERPOLATORNOFRAMEDIRTY))? \ + ((RpAtomicGetFrame(_atomic))? \ + (RwFrameUpdateObjects(RpAtomicGetFrame(_atomic))): \ + (0)): \ + (0)), \ + (_intrp)) + +#define RpAtomicGetClumpMacro(_atomic) \ + ((_atomic)->clump) + +/* NB "RpAtomicGetBoundingSphere(atomic++)" will break it */ +#define RpAtomicGetBoundingSphereMacro(_atomic) \ + ((((_atomic)->interpolator.flags & rpINTERPOLATORDIRTYSPHERE)? \ + _rpAtomicResyncInterpolatedSphere(_atomic), 0: 0), \ + &((_atomic)->boundingSphere)) +#define RpAtomicGetFrameMacro(_atomic) \ + ((RwFrame *) rwObjectGetParent(_atomic)) + +/* NB "RpClumpSetFrame(clump++, frame)" will break it */ +#if (!defined(RpClumpSetFrameMacro)) +#define RpClumpSetFrameMacro(_clump, _frame) \ + (rwObjectSetParent(_clump, _frame), \ + (_clump)) +#endif /* (!defined(RpClumpSetFrameMacro)) */ + +#if (!defined(RpClumpSetFrameVoidMacro)) +#define RpClumpSetFrameVoidMacro(_clump, _frame) \ +MACRO_START \ +{ \ + rwObjectSetParent(_clump, _frame); \ +} \ +MACRO_STOP +#endif /* (!defined(RpClumpSetFrameVoidMacro)) */ + +#define RpClumpGetFrameMacro(_clump) \ + ((RwFrame *) rwObjectGetParent(_clump)) + +/* NB "RpAtomicSetFlags(atomic++, flags)" will break it */ +#if (!defined(RpAtomicSetFlagsMacro)) +#define RpAtomicSetFlagsMacro(_atomic, _flags) \ + (rwObjectSetFlags(_atomic, _flags), \ + (_atomic)) +#endif /* (!defined(RpAtomicSetFlagsMacro)) */ + +#define RpAtomicGetFlagsMacro(_atomic) \ + (rwObjectGetFlags(_atomic)) + +#if (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )) + +#define RpAtomicRender(_atomic) \ + RpAtomicRenderMacro(_atomic) + +#define RpAtomicGetGeometry(_atomic) \ + RpAtomicGetGeometryMacro(_atomic) + +#define RpAtomicSetRenderCallBack(_atomic, _callback) \ + RpAtomicSetRenderCallBackMacro(_atomic, _callback) + +#define RpAtomicGetRenderCallBack(_atomic) \ + RpAtomicGetRenderCallBackMacro(_atomic) + +#define RpAtomicGetInterpolator(_atomic) \ + RpAtomicGetInterpolatorMacro(_atomic) + +#define RpInterpolatorGetStartMorphTarget(_intrp) \ + RpInterpolatorGetStartMorphTargetMacro(_intrp) + +#define RpInterpolatorGetEndMorphTarget(_intrp) \ + RpInterpolatorGetEndMorphTargetMacro(_intrp) + +#define RpInterpolatorGetValue(_intrp) \ + RpInterpolatorGetValueMacro(_intrp) + +#define RpInterpolatorGetScale(_intrp) \ + RpInterpolatorGetScaleMacro(_intrp) + +#define RpInterpolatorSetStartMorphTarget(_intrp, _target, _atomic) \ + RpInterpolatorSetStartMorphTargetMacro(_intrp, _target, _atomic) + +#define RpInterpolatorSetEndMorphTarget(_intrp, _target, _atomic) \ + RpInterpolatorSetEndMorphTargetMacro(_intrp, _target, _atomic) + +#define RpInterpolatorSetValue(_intrp, _value, _atomic) \ + RpInterpolatorSetValueMacro(_intrp, _value, _atomic) + +#define RpInterpolatorSetScale(_intrp, _scale, _atomic) \ + RpInterpolatorSetScaleMacro(_intrp, _scale, _atomic) + +#define RpAtomicGetClump(_atomic) \ + RpAtomicGetClumpMacro(_atomic) + +#define RpAtomicGetBoundingSphere(_atomic) \ + RpAtomicGetBoundingSphereMacro(_atomic) + +#define RpAtomicGetFrame(_atomic) \ + RpAtomicGetFrameMacro(_atomic) + +#define RpClumpSetFrame(_clump, _frame) \ + RpClumpSetFrameMacro(_clump, _frame) + +#define RpClumpGetFrame(_clump) \ + RpClumpGetFrameMacro(_clump) + +#define RpAtomicSetFlags(_atomic, _flags) \ + RpAtomicSetFlagsMacro(_atomic, _flags) + +#define RpAtomicGetFlags(_atomic) \ + RpAtomicGetFlagsMacro(_atomic) + +#endif /* (! ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) )) */ + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + + +/* Macro version of RpAtomicSetRenderCallBack needs this */ +extern RpAtomic * +AtomicDefaultRenderCallBack(RpAtomic * atomic); + +extern void +_rpAtomicResyncInterpolatedSphere(RpAtomic * atomic); + +extern const RwSphere * +RpAtomicGetWorldBoundingSphere(RpAtomic * atomic); + +/* Enumeration */ +extern RpClump * +RpClumpForAllAtomics(RpClump * clump, + RpAtomicCallBack callback, + void *pData); + +extern RpClump * +RpClumpForAllLights(RpClump * clump, + RpLightCallBack callback, + void *pData); + +extern RpClump * +RpClumpForAllCameras(RpClump * clump, + RwCameraCallBack callback, + void *pData); + +/* Frames */ +extern RpAtomic * +RpAtomicSetFrame(RpAtomic * atomic, + RwFrame * frame); + +/* Create a space marking clump */ +extern RpClump * +RpClumpCreateSpace(const RwV3d * position, + RwReal radius); + +/* Instancing and rendering */ +extern RpClump * +RpClumpRender(RpClump * clump); + +extern RpClump * +RpClumpRemoveAtomic(RpClump * clump, + RpAtomic * atomic); + +extern RpClump * +RpClumpAddAtomic(RpClump * clump, + RpAtomic * atomic); + +extern RpClump * +RpClumpRemoveLight(RpClump * clump, + RpLight * light); + +extern RpClump * +RpClumpAddLight(RpClump * clump, + RpLight * light); + +extern RpClump * +RpClumpRemoveCamera(RpClump * clump, + RwCamera * camera); + +extern RpClump * +RpClumpAddCamera(RpClump * clump, + RwCamera * camera); + +/* Creation and destruction of clumps */ +extern RwBool +RpClumpDestroy(RpClump * clump); + +extern RpClump * +RpClumpCreate(void); + +extern RpClump * +RpClumpClone(RpClump * clump); + +/* Creation and destruction of atomics*/ +extern RwBool +RpAtomicDestroy(RpAtomic * atomic); + +extern RpAtomic * +RpAtomicClone(RpAtomic * atomic); + +extern RpAtomic * +RpAtomicCreate(void); + +/* Setting and getting geometry for an atomic */ +extern RpAtomic * +RpAtomicSetGeometry(RpAtomic * atomic, + RpGeometry * geometry, + RwUInt32 flags); + +/* Frustum callbacks */ +extern RpClump * +RpClumpSetCallBack(RpClump * clump, + RpClumpCallBack callback); + +extern RpClumpCallBack +RpClumpGetCallBack(const RpClump * clump); + +/* The number of atomics in a clump */ +extern RwInt32 +RpClumpGetNumAtomics(RpClump * clump); + +extern RwInt32 +RpClumpGetNumLights(RpClump * clump); + +extern RwInt32 +RpClumpGetNumCameras(RpClump * clump); + +/* Light and camera extensions */ +extern RpClump * +RpLightGetClump(const RpLight *light); + +extern RpClump * +RwCameraGetClump(const RwCamera *camera); + +/* Binary format */ +extern RwUInt32 +RpAtomicStreamGetSize(RpAtomic * atomic); + +extern RpAtomic * +RpAtomicStreamRead(RwStream * stream); + +extern RpAtomic * +RpAtomicStreamWrite(RpAtomic * atomic, + RwStream * stream); + +extern RwUInt32 +RpClumpStreamGetSize(RpClump * clump); + +extern RpClump * +RpClumpStreamRead(RwStream * stream); + +extern RpClump * +RpClumpStreamWrite(RpClump * clump, + RwStream * stream); + +extern RpClumpChunkInfo * +_rpClumpChunkInfoRead(RwStream * stream, + RpClumpChunkInfo * clumpChunkInfo, + RwInt32 * bytesRead); + +/* Attaching toolkits */ +extern RwInt32 +RpAtomicRegisterPlugin(RwInt32 size, + RwUInt32 pluginID, + RwPluginObjectConstructor constructCB, + RwPluginObjectDestructor destructCB, + RwPluginObjectCopy copyCB); + +extern RwInt32 +RpClumpRegisterPlugin(RwInt32 size, + RwUInt32 pluginID, + RwPluginObjectConstructor constructCB, + RwPluginObjectDestructor destructCB, + RwPluginObjectCopy copyCB); + +extern RwInt32 +RpAtomicRegisterPluginStream(RwUInt32 pluginID, + RwPluginDataChunkReadCallBack + readCB, + RwPluginDataChunkWriteCallBack + writeCB, + RwPluginDataChunkGetSizeCallBack + getSizeCB); + +extern RwInt32 +RpAtomicSetStreamAlwaysCallBack(RwUInt32 pluginID, + RwPluginDataChunkAlwaysCallBack alwaysCB); + +extern RwInt32 +RpAtomicSetStreamRightsCallBack(RwUInt32 pluginID, + RwPluginDataChunkRightsCallBack rightsCB); + +extern RwInt32 +RpClumpRegisterPluginStream(RwUInt32 pluginID, + RwPluginDataChunkReadCallBack readCB, + RwPluginDataChunkWriteCallBack writeCB, + RwPluginDataChunkGetSizeCallBack getSizeCB); + +extern RwInt32 +RpClumpSetStreamAlwaysCallBack(RwUInt32 pluginID, + RwPluginDataChunkAlwaysCallBack alwaysCB); + +extern RwInt32 +RpAtomicGetPluginOffset(RwUInt32 pluginID); + +extern RwInt32 +RpClumpGetPluginOffset(RwUInt32 pluginID); + +extern RwBool +RpAtomicValidatePlugins(const RpAtomic * atomic); + +extern RwBool +RpClumpValidatePlugins(const RpClump * clump); + +#if ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ) +extern RwFrame * +RpAtomicGetFrame(const RpAtomic * atomic); + +extern RwFrame * +RpClumpGetFrame(const RpClump * clump); + +extern RpClump * +RpClumpSetFrame(RpClump * clump, + RwFrame * frame); + +/* Flags */ +extern RpAtomic * +RpAtomicSetFlags(RpAtomic * atomic, + RwUInt32 flags); + +extern RwUInt32 +RpAtomicGetFlags(const RpAtomic * atomic); + +extern RwSphere * +RpAtomicGetBoundingSphere(RpAtomic * atomic); + +extern RwInt32 +RpInterpolatorGetEndMorphTarget(const RpInterpolator * interpolator); + +extern RwInt32 +RpInterpolatorGetStartMorphTarget(const RpInterpolator * interpolator); + +extern RwReal +RpInterpolatorGetValue(const RpInterpolator * interpolator); + +extern RwReal +RpInterpolatorGetScale(const RpInterpolator * interpolator); + +extern RpInterpolator * +RpInterpolatorSetEndMorphTarget(RpInterpolator * interpolator, + RwInt32 morphTarget, + RpAtomic * atomic); + +extern RpInterpolator * +RpInterpolatorSetStartMorphTarget(RpInterpolator * interpolator, + RwInt32 morphTarget, + RpAtomic * atomic); + +extern RpInterpolator * +RpInterpolatorSetValue(RpInterpolator * interpolator, + RwReal value, + RpAtomic *atomic); + +extern RpInterpolator * +RpInterpolatorSetScale(RpInterpolator * interpolator, + RwReal scale, + RpAtomic *atomic); + +extern RpAtomic * +RpAtomicRender(RpAtomic * atomic); + +/* Building clumps */ +extern RpClump * +RpAtomicGetClump(const RpAtomic * atomic); + +extern RpInterpolator * +RpAtomicGetInterpolator(RpAtomic * atomic); + +extern RpGeometry * +RpAtomicGetGeometry(const RpAtomic * atomic); + +extern void +RpAtomicSetRenderCallBack(RpAtomic * atomic, + RpAtomicCallBackRender callback); + +extern RpAtomicCallBackRender +RpAtomicGetRenderCallBack(const RpAtomic * atomic); + +#endif + +/* ( defined(RWDEBUG) || defined(RWSUPPRESSINLINE) ) */ + +extern RwBool RpAtomicInstance(RpAtomic *atomic); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#define RpClumpChunkInfoRead(stream, clumpChunkInfo, bytesRead) \ + _rpClumpChunkInfoRead(stream, clumpChunkInfo, bytesRead) + + +/*--- Automatically derived from: c:/daily/rwsdk/world/baworld.h ---*/ + +/* + * World handling. + * World give objects scope, and provide a mechanism for + * efficiency static object rendering. + * + * Copyright (c) 1998 Criterion Software Ltd. + * + */ + +/**************************************************************************** + Defines + */ + +/* Type ID */ +#define rpWORLD 7 + +/* RpWorld private flags (in RwObject) */ +enum RpWorldPrivateFlag +{ + rpWORLDSINGLEMALLOC = 0x01, + rpWORLDPRIVATEFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RpWorldPrivateFlag RpWorldPrivateFlag; + +/** + * \ingroup rpworlddatatypes + * The bit-field type \ref RpWorldFlag specifies the options available + * for creating the static geometry component of a world (see API function \ref RpWorldSetFlags): + */ +enum RpWorldFlag +{ + rpWORLDTRISTRIP = 0x01, /**<This world's meshes can be rendered + as tri strips */ + rpWORLDPOSITIONS = 0x02, /**<This world has positions */ + rpWORLDTEXTURED = 0x04, /**<This world has only one set of texture coordinates */ + rpWORLDPRELIT = 0x08, /**<This world has luminance values */ + rpWORLDNORMALS = 0x10, /**<This world has normals */ + rpWORLDLIGHT = 0x20, /**<This world will be lit */ + rpWORLDMODULATEMATERIALCOLOR = 0x40, + /**<Modulate material color with vertex colors + (pre-lit + lit) */ + rpWORLDTEXTURED2 = 0x80, /**<This world has 2 or more sets of texture coordinates */ + + /* + * These above flags were stored in the flags field in an RwObject, they + * are now stored in the flags file of the RpWorld. + */ + + rpWORLDNATIVE = 0x01000000, + rpWORLDNATIVEINSTANCE = 0x02000000, + + rpWORLDFLAGSMASK = 0x000000FF, + rpWORLDNATIVEFLAGSMASK = 0x0F000000, + + rpWORLDSECTORSOVERLAP = 0x40000000, + + rpWORLDFLAGFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RpWorldFlag RpWorldFlag; + +/* Multi texture coordinate format specifier */ +#define rpWORLDTEXCOORDSETS(_num) ((_num & 0xff) << 16) + +/* Maximum depth of BSP tree */ +#define rpWORLDMAXBSPDEPTH 64 + + +/* macro/inline functionality */ +#define RpWorldGetBBoxMacro(_world) \ + (&((_world)->boundingBox)) + +#define RpWorldGetOriginMacro(_world) \ + (&((_world)->worldOrigin)) + +#define RpWorldGetNumMaterialsMacro(_world) \ + ((_world)->matList.numMaterials) + +#define RpWorldGetMaterialMacro(_world, _num) \ + (((_world)->matList.materials)[(_num)]) + +#define RpWorldGetNumClumpsMacro(_world) \ + ((_world)->numClumpsInWorld) + +#define RpWorldSetRenderOrderMacro(_world, _renderOrder) \ + (((_world)->renderOrder = _renderOrder), (_world)) + +#define RpWorldGetRenderOrderMacro(_world) \ + ((_world)->renderOrder) + +#define RpWorldSetFlagsMacro(_world, _flags) \ + (((_world)->flags = (_flags)), (_world)) + +#define RpWorldGetFlagsMacro(_world) \ + ((_world)->flags) + + +#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) + +#define RpWorldGetBBox(_world) \ + RpWorldGetBBoxMacro(_world) + +#define RpWorldGetOrigin(_world) \ + RpWorldGetOriginMacro(_world) + +#define RpWorldGetNumMaterials(_world) \ + RpWorldGetNumMaterialsMacro(_world) + +#define RpWorldGetMaterial(_world, _num) \ + RpWorldGetMaterialMacro(_world, _num) + +#define RpWorldGetNumClumps(_world) \ + RpWorldGetNumClumpsMacro(_world) + +#define RpWorldSetRenderOrder(_world, _renderOrder) \ + RpWorldSetRenderOrderMacro(_world, _renderOrder) + +#define RpWorldGetRenderOrder(_world) \ + RpWorldGetRenderOrderMacro(_world) + +#define RpWorldSetFlags(_world, _flags) \ + RpWorldSetFlagsMacro(_world, _flags) + +#define RpWorldGetFlags(_world) \ + RpWorldGetFlagsMacro(_world) + +#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + + +/**************************************************************************** + Global types + */ + + +/** + * \ingroup rpworlddatatypes + * \ref RpWorldRenderOrder + * represents the options available for + * the rendering order of world sectors in the camera's view frustum (see + * API function \ref RpWorldSetRenderOrder). + */ +enum RpWorldRenderOrder +{ + rpWORLDRENDERNARENDERORDER = 0, + rpWORLDRENDERFRONT2BACK, /**<Renders nearest sectors first */ + rpWORLDRENDERBACK2FRONT, /**<Renders furthest sectors first */ + rpWORLDRENDERORDERFORCEENUMSIZEINT = RWFORCEENUMSIZEINT +}; +typedef enum RpWorldRenderOrder RpWorldRenderOrder; + +/** + * \ingroup rpworlddatatypes + * \typedef RpWorldSectorCallBackRender + * \ref RpWorldSectorCallBackRender represents the function called from + * \ref RpWorldSectorRender when the specified world sector lies inside the + * current camera's view frustum. The default callback initiates execution of + * the world sector rendering pipeline. This function should return a pointer + * to the world sector to indicate success + * + * \return Pointer to the world sector. + * + * \param worldSector Pointer to the world sector to be + * rendered + */ +typedef RpWorldSector *(*RpWorldSectorCallBackRender) (RpWorldSector * + worldSector); + +/** + * \ingroup rpworlddatatypes + * \typedef RpWorld + * World object. This should be considered an opaque type. + * Use the RpWorld API functions to access. + */ +typedef struct RpWorld RpWorld; + +#if (!defined(DOXYGEN)) +struct RpWorld +{ + RwObject object; + + RwUInt32 flags; + + RpWorldRenderOrder renderOrder; + + /* Materials */ + RpMaterialList matList; + + /* The world stored as a BSP tree */ + RpSector *rootSector; + + /* The number of texture coordinate sets in each sector */ + RwInt32 numTexCoordSets; + + /* Render frame used when last rendered */ + RwInt32 numClumpsInWorld; + RwLLLink *currentClumpLink; + + /* All the clumps in the world */ + RwLinkList clumpList; + + /* All of the lights in the world */ + RwLinkList lightList; + + /* Directional lights in the world */ + RwLinkList directionalLightList; + + /* The worlds origin offset */ + RwV3d worldOrigin; + + /* Bounding box around the whole world */ + RwBBox boundingBox; + + /* Surface properties */ + RwSurfaceProperties surfaceProps; + + /* The callbacks functions */ + RpWorldSectorCallBackRender renderCallBack; + + RxPipeline *pipeline; +}; +#endif /* (!defined(DOXYGEN)) */ + +/**************************************************************************** + Global Variables + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RwPluginRegistry worldTKList; + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RwBool _rpWorldFindBBox(RpWorld * world, + RwBBox * boundingBox); + +/* Generate sector bounding boxes from BSP planes (not tight boxes) */ +extern RpWorld *_rpWorldSetupSectorBoundingBoxes(RpWorld *world); + + +/* These stealth-API */ +extern RwBool _rpWorldForAllGlobalLights(RpLightCallBack callBack, + void *pData); +extern RpWorldSector *_rpWorldSectorForAllLocalLights(RpWorldSector * + sector, + RpLightCallBack + callBack, + void *pData); + +extern RpWorldSector *_rpSectorDefaultRenderCallBack(RpWorldSector * + sector); + +/* Accessing worlds geometry */ +extern RpWorld *RpWorldLock(RpWorld * world); +extern RpWorld *RpWorldUnlock(RpWorld * world); + +/* Managing a list of the worlds */ +extern void _rpWorldRegisterWorld(RpWorld * world, + RwUInt32 memorySize); +extern void _rpWorldUnregisterWorld(RpWorld * world); + +/* Hook into world management */ +extern RwBool RpWorldPluginAttach(void); + +/* Enumerating objects in the world */ +extern RpWorld *RpWorldForAllClumps(RpWorld * world, + RpClumpCallBack fpCallBack, + void *pData); +extern RpWorld *RpWorldForAllMaterials(RpWorld * world, + RpMaterialCallBack fpCallBack, + void *pData); +extern RpWorld *RpWorldForAllLights(RpWorld * world, + RpLightCallBack fpCallBack, + void *pData); +extern RpWorld *RpWorldForAllWorldSectors(RpWorld * world, + RpWorldSectorCallBack + fpCallBack, void *pData); + +/* Rendering */ +extern RpWorld *RpWorldRender(RpWorld * world); + +/* Creation/destruction */ +extern RwBool RpWorldDestroy(RpWorld * world); +extern RpWorld *RpWorldCreate(RwBBox * boundingBox); +extern RwBool RpWorldInstance(RpWorld *world); + +/* Getting/setting */ +extern RpWorld *_rpWorldSetSurfaceProperties(RpWorld * world, + const RwSurfaceProperties + * surface); +extern const RwSurfaceProperties * + _rpWorldGetSurfaceProperties(const RpWorld *world); + +/* Sector callbacks */ +extern RpWorld *RpWorldSetSectorRenderCallBack(RpWorld * world, + RpWorldSectorCallBackRender + fpCallBack); +extern RpWorldSectorCallBackRender RpWorldGetSectorRenderCallBack(const + RpWorld + * + world); + +/* Getting world from sector */ +extern RpWorld *RpWorldSectorGetWorld(const RpWorldSector * sector); + +extern RwInt32 RpWorldRegisterPlugin(RwInt32 size, RwUInt32 pluginID, + RwPluginObjectConstructor + constructCB, + RwPluginObjectDestructor + destructCB, + RwPluginObjectCopy copyCB); +extern RwInt32 RpWorldRegisterPluginStream(RwUInt32 pluginID, + RwPluginDataChunkReadCallBack + readCB, + RwPluginDataChunkWriteCallBack + writeCB, + RwPluginDataChunkGetSizeCallBack + getSizeCB); +extern RwInt32 RpWorldSetStreamAlwaysCallBack( + RwUInt32 pluginID, + RwPluginDataChunkAlwaysCallBack alwaysCB); +extern RwInt32 RpWorldSetStreamRightsCallBack(RwUInt32 pluginID, + RwPluginDataChunkRightsCallBack rightsCB); +extern RwInt32 RpWorldGetPluginOffset(RwUInt32 pluginID); +extern RwBool RpWorldValidatePlugins(RpWorld * world); + + +#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) + +/* Getting/setting */ +extern const RwBBox *RpWorldGetBBox(const RpWorld *world); +extern const RwV3d *RpWorldGetOrigin(const RpWorld *world); + +/* Accessing a worlds materials */ +extern RwInt32 RpWorldGetNumMaterials(const RpWorld *world); +extern RpMaterial *RpWorldGetMaterial(const RpWorld *world, RwInt32 matNum); + +/* Clumps */ +extern RwInt32 RpWorldGetNumClumps(RpWorld *world); + +/* Render order */ +extern RpWorld *RpWorldSetRenderOrder(RpWorld *world, + RpWorldRenderOrder renderOrder); +extern RpWorldRenderOrder RpWorldGetRenderOrder(const RpWorld *world); + +/* Flags */ +extern RpWorld *RpWorldSetFlags(RpWorld *world, RwUInt32 flags); +extern RwUInt32 RpWorldGetFlags(const RpWorld *world); + +#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#define RpWorldSetSurfaceProperties(_world, _surface) \ + _rpWorldSetSurfaceProperties(_world, _surface) + +#define RpWorldGetSurfaceProperties(_world) \ + _rpWorldGetSurfaceProperties(_world) + +#define rpWorldFindBBox(_world, _boundingBox) \ + _rpWorldFindBBox(_world, _boundingBox) + +#define rpWorldForAllGlobalLights(_callBack, _pData) \ + _rpWorldForAllGlobalLights(_callBack, _pData) + +#define rpWorldSectorForAllLocalLights(_sector, _callBack, _pData) \ + _rpWorldSectorForAllLocalLights(_sector, _callBack, _pData) + +#define _rpWorldLock(_world) \ + RpWorldLock(_world) + +#define _rpWorldUnlock(_world) \ + RpWorldUnlock(_world) + +#define rpWorldLock(_world) \ + RpWorldLock(_world) + +#define rpWorldUnlock(_world) \ + RpWorldUnlock(_world) + + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/d3d8/D3D8pipe.h ---*/ + +typedef struct RxD3D8ResEntryHeader RxD3D8ResEntryHeader; +/** + * \ingroup rpworldd3d8 + * \struct RxD3D8ResEntryHeader + * This structure contains D3D8 resource specific components. + */ +struct RxD3D8ResEntryHeader +{ + RwUInt16 serialNumber; /**< The mesh headers serial number */ + RwUInt16 numMeshes; /**< The number of meshes */ +}; + +/* This is what I keep in memory as part of the instance data setup */ +typedef struct RxD3D8InstanceData RxD3D8InstanceData; +/** + * \ingroup rpworldd3d8 + * \struct RxD3D8InstanceData + * This structure contains D3D8 resource specific components. + */ +struct RxD3D8InstanceData +{ + RwUInt32 minVert; /**< The vertex index where the + meshes vertices begin. Needed for + reinstancing, not for rendering */ + + RwInt32 stride; /**< Stride of vertex */ + + RwInt32 numVertices; /**< Number of vertices in the vertex buffer */ + RwInt32 numIndices; /**< Number of indices to render the primitive */ + + RpMaterial *material; /**< The material for this instanced data */ + + RwUInt32 vertexShader; /**< Vertex shader or FVF flags */ + + RwUInt32 primType; /**< Primitive type */ + + void *indexBuffer; /**< Index buffer */ + void *vertexBuffer; /**< Vertex buffer */ + + RwUInt32 baseIndex; /**< Needed if we share the vertex buffer */ + + RwUInt8 vertexAlpha; /**< The prelight data contains alpha */ + RwUInt8 managed; /**< Created by the Vertex Buffer Manager */ + RwUInt8 remapped; /**< Vertices where remapped to save VB space */ +}; + +/** + * \ingroup rpworldd3d8 + * \ref RxD3D8AllInOneInstanceCallBack callback function. + * + * \param object Pointer to the object. + * \param instancedData Pointer to \ref RxD3D8InstanceData. + * \param reinstance Boolean whether to reinstance. + * + * \see RxD3D8AllInOneSetInstanceCallBack + * \see RxD3D8AllInOneGetInstanceCallBack + * \see RxNodeDefinitionGetD3D8AtomicAllInOne + * \see RxNodeDefinitionGetD3D8WorldSectorAllInOne + */ +typedef RwBool (*RxD3D8AllInOneInstanceCallBack)(void *object, + RxD3D8InstanceData *instancedData, + RwBool reinstance); + +/** + * \ingroup rpworldd3d8 + * \ref RxD3D8AllInOneReinstanceCallBack callback function. + * + * \param object Pointer to the object. + * \param meshHeader Const pointer to \ref RpMeshHeader. + * \param resEntry Pointer to \ref RxD3D8ResEntryHeader. + * \param instanceCallback Pointer to \ref RxD3D8AllInOneInstanceCallBack. + * + * \see RxD3D8AllInOneSetReinstanceCallBack + * \see RxD3D8AllInOneGetReinstanceCallBack + * \see RxNodeDefinitionGetD3D8AtomicAllInOne + * \see RxNodeDefinitionGetD3D8WorldSectorAllInOne + */ +typedef RwBool (*RxD3D8AllInOneReinstanceCallBack)(void *object, + RwResEntry *resEntry, + const RpMeshHeader *meshHeader, + RxD3D8AllInOneInstanceCallBack instanceCallback); + +/** + * \ingroup rpworldd3d8 + * \ref RxD3D8AllInOneLightingCallBack callback function. + * + * \param object Void pointer to the object. + * + * \see RxD3D8AllInOneSetLightingCallBack + * \see RxD3D8AllInOneGetLightingCallBack + * \see RxNodeDefinitionGetD3D8AtomicAllInOne + * \see RxNodeDefinitionGetD3D8WorldSectorAllInOne + */ +typedef void (*RxD3D8AllInOneLightingCallBack)(void *object); + +/** + * \ingroup rpworldd3d8 + * \ref RxD3D8AllInOneRenderCallBack callback function. + * + * \param repEntry Pointer to a resource entry. + * \param object Pointer to a object that the resource entry belongs to. + * \param type rpATOMIC or rwSECTORATOMIC. + * \param flags \ref RpGeometryFlag's or \ref RpWorldFlag's. + * + * \see RxD3D8AllInOneSetRenderCallBack + * \see RxD3D8AllInOneGetRenderCallBack + * \see RxNodeDefinitionGetD3D8AtomicAllInOne + * \see RxNodeDefinitionGetD3D8WorldSectorAllInOne + */ +typedef void (*RxD3D8AllInOneRenderCallBack)(RwResEntry *repEntry, + void *object, + RwUInt8 type, + RwUInt32 flags); + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ +extern void +RxD3D8AllInOneSetInstanceCallBack(RxPipelineNode *node, + RxD3D8AllInOneInstanceCallBack callback); + +extern RxD3D8AllInOneInstanceCallBack +RxD3D8AllInOneGetInstanceCallBack(RxPipelineNode *node); + +extern void +RxD3D8AllInOneSetReinstanceCallBack(RxPipelineNode *node, + RxD3D8AllInOneReinstanceCallBack callback); + +extern RxD3D8AllInOneReinstanceCallBack +RxD3D8AllInOneGetReinstanceCallBack(RxPipelineNode *node); + +extern void +RxD3D8AllInOneSetLightingCallBack(RxPipelineNode *node, + RxD3D8AllInOneLightingCallBack callback); + +extern RxD3D8AllInOneLightingCallBack +RxD3D8AllInOneGetLightingCallBack(RxPipelineNode *node); + +extern void +RxD3D8AllInOneSetRenderCallBack(RxPipelineNode *node, + RxD3D8AllInOneRenderCallBack callback); + +extern RxD3D8AllInOneRenderCallBack +RxD3D8AllInOneGetRenderCallBack(RxPipelineNode *node); + + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +/*--- Automatically derived from: C:/daily/rwsdk/world/pipe/p2/bapipew.h ---*/ + +#define RpWorldGetGenericSectorPipelineMacro() \ + (RXPIPELINEGLOBAL(genericWorldSectorPipeline)) + +#define RpWorldGetDefaultSectorPipelineMacro() \ + (RXPIPELINEGLOBAL(currentWorldSectorPipeline)) + +#define RpWorldSetSectorPipelineMacro(_world, _pipeline) \ + ( ((_world)->pipeline = _pipeline), _world ) + +#define RpWorldGetSectorPipelineMacro(_world, _pipeline) \ + ( (*(_pipeline) = (_world)->pipeline), _world ) + +#define RpWorldSectorSetPipelineMacro(_sector, _pipeline) \ + ( ((_sector)->pipeline = _pipeline), _sector ) + +#define RpWorldSectorGetPipelineMacro(_sector, _pipeline) \ + ( (*(_pipeline) = (_sector)->pipeline), _sector ) + +#define RpAtomicGetGenericPipelineMacro() \ + (RXPIPELINEGLOBAL(genericAtomicPipeline)) + +#define RpAtomicGetDefaultPipelineMacro() \ + (RXPIPELINEGLOBAL(currentAtomicPipeline)) + +#define RpAtomicSetPipelineMacro(_atomic, _pipeline) \ + ( ((_atomic)->pipeline = _pipeline), _atomic ) + +#define RpAtomicGetPipelineMacro(_atomic, _pipeline) \ + ( (*(_pipeline) = (_atomic)->pipeline), _atomic ) + +#define RpMaterialGetGenericPipelineMacro() \ + (RXPIPELINEGLOBAL(genericMaterialPipeline)) + +#define RpMaterialGetDefaultPipelineMacro() \ + (RXPIPELINEGLOBAL(currentMaterialPipeline)) + +#define RpMaterialSetPipelineMacro(_material, _pipeline) \ + ( ((_material)->pipeline = _pipeline), _material ) + +#define RpMaterialGetPipelineMacro(_material, _pipeline) \ + ( (*(_pipeline) = (_material)->pipeline), _material ) + + +#if !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) + +#define RpWorldGetGenericSectorPipeline RpWorldGetGenericSectorPipelineMacro +#define RpWorldGetDefaultSectorPipeline RpWorldGetDefaultSectorPipelineMacro +#define RpWorldSetSectorPipeline RpWorldSetSectorPipelineMacro +#define RpWorldGetSectorPipeline RpWorldGetSectorPipelineMacro +#define RpWorldSectorSetPipeline RpWorldSectorSetPipelineMacro +#define RpWorldSectorGetPipeline RpWorldSectorGetPipelineMacro + +#define RpAtomicGetGenericPipeline RpAtomicGetGenericPipelineMacro +#define RpAtomicGetDefaultPipeline RpAtomicGetDefaultPipelineMacro +#define RpAtomicSetPipeline RpAtomicSetPipelineMacro +#define RpAtomicGetPipeline RpAtomicGetPipelineMacro + +#define RpMaterialGetGenericPipeline RpMaterialGetGenericPipelineMacro +#define RpMaterialGetDefaultPipeline RpMaterialGetDefaultPipelineMacro +#define RpMaterialSetPipeline RpMaterialSetPipelineMacro +#define RpMaterialGetPipeline RpMaterialGetPipelineMacro + +#endif /* !(defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +extern RxPipeline *RpWorldSetDefaultSectorPipeline(RxPipeline *pipeline); +extern RxPipeline *RpAtomicSetDefaultPipeline(RxPipeline *pipeline); +extern RxPipeline *RpMaterialSetDefaultPipeline(RxPipeline *pipeline); + +#if (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) + +extern RxPipeline *RpWorldGetGenericSectorPipeline(void); +extern RxPipeline *RpWorldGetDefaultSectorPipeline(void); +extern RpWorld *RpWorldSetSectorPipeline(RpWorld *world, + RxPipeline *pipeline); +extern RpWorld *RpWorldGetSectorPipeline(RpWorld *world, + RxPipeline **pipeline); +extern RpWorldSector *RpWorldSectorSetPipeline(RpWorldSector *sector, + RxPipeline *pipeline); +extern RpWorldSector *RpWorldSectorGetPipeline(RpWorldSector *sector, + RxPipeline **pipeline); + +extern RxPipeline *RpAtomicGetGenericPipeline(void); +extern RxPipeline *RpAtomicGetDefaultPipeline(void); +extern RpAtomic *RpAtomicSetPipeline(RpAtomic *atomic, + RxPipeline *pipeline); +extern const RpAtomic *RpAtomicGetPipeline(const RpAtomic *const atomic, + RxPipeline **pipeline); + +extern RxPipeline *RpMaterialGetGenericPipeline(void); +extern RxPipeline *RpMaterialGetDefaultPipeline(void); +extern RpMaterial *RpMaterialSetPipeline(RpMaterial *material, + RxPipeline *pipeline); +extern RpMaterial *RpMaterialGetPipeline(RpMaterial *material, + RxPipeline **pipeline); + +#endif /* (defined(RWDEBUG) || defined(RWSUPPRESSINLINE)) */ + +extern const RpGeometry *RpGeometryIsCorrectlySorted(const RpGeometry * geometry, + RwBool * result); +extern RpGeometry *RpGeometrySortByMaterial(const RpGeometry * geometry, + RpGeometrySortByMaterialCallBack callback); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +/* LEGACY-SUPPORT macros */ +#define RpWorldGetGenericSectorInstancePipeline RpWorldGetGenericSectorPipeline +#define RpWorldSetDefaultSectorInstancePipeline RpWorldSetDefaultSectorPipeline +#define RpWorldGetDefaultSectorInstancePipeline RpWorldGetDefaultSectorPipeline +#define RpWorldSetSectorInstancePipeline RpWorldSetSectorPipeline +#define RpWorldGetSectorInstancePipeline RpWorldGetSectorPipeline +#define RpWorldSectorSetInstancePipeline RpWorldSectorSetPipeline +#define RpWorldSectorGetInstancePipeline RpWorldSectorGetPipeline + +#define RpAtomicGetGenericInstancePipeline RpAtomicGetGenericPipeline +#define RpAtomicGetDefaultInstancePipeline RpAtomicGetDefaultPipeline +#define RpAtomicSetDefaultInstancePipeline RpAtomicSetDefaultPipeline +#define RpAtomicSetInstancePipeline RpAtomicSetPipeline +#define RpAtomicGetInstancePipeline RpAtomicGetPipeline + +#define RpMaterialGetGenericRenderPipeline RpMaterialGetGenericPipeline +#define RpMaterialSetDefaultRenderPipeline RpMaterialSetDefaultPipeline +#define RpMaterialGetDefaultRenderPipeline RpMaterialGetDefaultPipeline +#define RpMaterialSetRenderPipeline RpMaterialSetPipeline +#define RpMaterialGetRenderPipeline RpMaterialGetPipeline + + +/*--- Automatically derived from: c:/daily/rwsdk/world/baworobj.h ---*/ +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* Adding and removing cameras to/from the world */ +extern RpWorld *RpWorldRemoveCamera(RpWorld *world, RwCamera *camera); +extern RpWorld *RpWorldAddCamera(RpWorld *world, RwCamera *camera); +extern RpWorld *RwCameraGetWorld(const RwCamera *camera); + +/* Adding and removing atomics to/from the world */ +extern RpWorld *RpWorldRemoveAtomic(RpWorld *world, RpAtomic *atomic); +extern RpWorld *RpWorldAddAtomic(RpWorld *world, RpAtomic *atomic); +extern RpWorld *RpAtomicGetWorld(const RpAtomic *atomic); + +/* Adding and removing clumps to/from the world */ +extern RpWorld *RpWorldAddClump(RpWorld *world, RpClump *clump); +extern RpWorld *RpWorldRemoveClump(RpWorld *world, RpClump *clump); +extern RpWorld *RpClumpGetWorld(const RpClump *clump); + +/* Adding and removing lights to/from the world */ +extern RpWorld *RpWorldAddLight(RpWorld *world, RpLight *light); +extern RpWorld *RpWorldRemoveLight(RpWorld *world, RpLight *light); +extern RpWorld *RpLightGetWorld(const RpLight *light); + +/* Finding whats in the view frustum */ +extern RwCamera *RwCameraForAllClumpsInFrustum(RwCamera *camera, void *data); +extern RwCamera *RwCameraForAllClumpsNotInFrustum(RwCamera *camera, + RwInt32 numClumps, void *data); +extern RwCamera *RwCameraForAllSectorsInFrustum(RwCamera *camera, + RpWorldSectorCallBack callBack, + void *pData); + +/* Enumeration involving the world sectors */ +extern RpLight *RpLightForAllWorldSectors(RpLight *light, + RpWorldSectorCallBack callback, + void *data); +extern RpAtomic *RpAtomicForAllWorldSectors(RpAtomic *atomic, + RpWorldSectorCallBack callback, + void *data); +extern RpWorldSector *RpWorldSectorForAllAtomics(RpWorldSector *sector, + RpAtomicCallBack callback, + void *data); +extern RpWorldSector *RpWorldSectorForAllCollisionAtomics(RpWorldSector *sector, + RpAtomicCallBack callback, + void *data); +extern RpWorldSector *RpWorldSectorForAllLights(RpWorldSector *sector, + RpLightCallBack callback, + void *data); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + + +/*--- Automatically derived from: c:/daily/rwsdk/world/babinwor.h ---*/ +/**************************************************************************** + Global types + */ + +/* Binary Representation + * + */ +typedef struct RpWorldChunkInfoSector RpWorldSectorChunkInfo; +typedef struct RpWorldChunkInfoSector _rpWorldSector; + +struct RpWorldChunkInfoSector +{ + RwInt32 matListWindowBase; + RwInt32 numPolygons; + RwInt32 numVertices; + RwV3d inf; + RwV3d sup; + RwBool collSectorPresent; + RwBool unused; +}; + +typedef struct RpPlaneSectorChunkInfo RpPlaneSectorChunkInfo; +typedef struct RpPlaneSectorChunkInfo _rpPlaneSector; + +struct RpPlaneSectorChunkInfo +{ + RwInt32 type; + RwReal value; + RwBool leftIsWorldSector; + RwBool rightIsWorldSector; + RwReal leftValue; + RwReal rightValue; +}; + +typedef struct RpWorldChunkInfo RpWorldChunkInfo; +typedef struct RpWorldChunkInfo _rpWorld; + +struct RpWorldChunkInfo +{ + RwBool rootIsWorldSector; + + RwV3d invWorldOrigin; + + RwSurfaceProperties surfaceProps; + + RwInt32 numPolygons; + RwInt32 numVertices; + RwInt32 numPlaneSectors; + RwInt32 numWorldSectors; + RwInt32 colSectorSize; + + RwInt32 format; /* Flags about the world */ +}; + +/**************************************************************************** + Function prototypes + */ + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* Binary format */ +extern RwUInt32 RpWorldStreamGetSize(const RpWorld *world); +extern RpWorld *RpWorldStreamRead(RwStream *stream); +extern const RpWorld *RpWorldStreamWrite(const RpWorld *world, + RwStream *stream); +extern RpWorldSectorChunkInfo * +_rpWorldSectorChunkInfoRead(RwStream *stream, + RpWorldSectorChunkInfo *worldSectorChunkInfo, + RwInt32 *bytesRead); +extern RpPlaneSectorChunkInfo * +_rpPlaneSectorChunkInfoRead(RwStream *stream, + RpPlaneSectorChunkInfo *planeSectorChunkInfo, + RwInt32 *bytesRead); +extern RpWorldChunkInfo * +_rpWorldChunkInfoRead(RwStream *stream, + RpWorldChunkInfo *worldChunkInfo, + RwInt32 *bytesRead); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#define RpWorldSectorChunkInfoRead(stream, worldSectorChunkInfo, bytesRead) \ + _rpWorldSectorChunkInfoRead(stream, worldSectorChunkInfo, bytesRead) + +#define RpPlaneSectorChunkInfoRead(stream, planeSectorChunkInfo, bytesRead) \ + _rpPlaneSectorChunkInfoRead(stream, planeSectorChunkInfo, bytesRead) + +#define RpWorldChunkInfoRead(stream, worldChunkInfo, bytesRead) \ + _rpWorldChunkInfoRead(stream, worldChunkInfo, bytesRead) + +#endif /* RPWORLD_H */ |