1 files changed, 3735 insertions, 0 deletions

diff --git a/sdk/rwsdk/include/d3d8/rpworld.h b/sdk/rwsdk/include/d3d8/rpworld.h
new file mode 100644
index 00000000..21fdc31b
--- /dev/null
+++ b/sdk/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 */