/*************************************************************************** * * * Module : rtimport.h * * * * Purpose : World handling functions. * * * **************************************************************************/ #ifndef RTIMPORT_H #define RTIMPORT_H /** * \defgroup rtimport RtWorldImport * \ingroup rttool * * World Import Toolkit for Renderware. */ /** * \defgroup selectors RtWorldImportPartitionSelectors * \ingroup rtimport * * The set of provided RtWorldImportPartitionSelectors: * Selects a good partition by calling one of the * \ref iterators and then * one of the \ref evaluators to * see which is best. */ /** * \defgroup iterators RtWorldImportPartitionIterators * \ingroup rtimport * * The set of provided RtWorldImportPartitionIterators: * Iterates through a set of candidate partitions, possibly * using the geometric information in the build sector, or perhaps * using some other criteria. */ /** * \defgroup evaluators RtWorldImportPartitionEvaluators * \ingroup rtimport * * The set of provided RtWorldImportPartitionEvaluators: * Uses a combination of statistics, build sector, build status, and * possibly other criteria to evaluate a partition. While the value * returned can be any real value, all provided evaluators are return * lower values for better partitioners, and are in the range [0..1] * where appropriate */ /** * \defgroup terminators RtWorldImportPartitionTerminators * \ingroup rtimport * * The set of provided RtWorldImportPartitionTerminators: * Checks given criteria about the statistics, build sector, build status, and * possibly other criteria to see whether the building process should be * allowed to terminate, or whether more parititoning is necessary. */ /** * \defgroup kd RtWorldImportGuideKD * \ingroup rtimport * * Tools to manipulate the \ref RtWorldImportGuideKDTree that is used to * manually build the sectors of a world. */ /** * \defgroup hints RtWorldImportHints * \ingroup rtimport * * Tools to aid the build process by giving hints as to what geometry should * not be split, and what geometry makes for a good partitioning guide. */ /**************************************************************************** Includes */ #include "rwcore.h" #include "rpworld.h" #include "rtimport.rpe" /* automatically generated header file */ /**************************************************************************** Defines */ /* Progress callback message types */ #define rtWORLDIMPORTPROGRESSBSPBUILDSTART 0 #define rtWORLDIMPORTPROGRESSBSPBUILDUPDATE 1 #define rtWORLDIMPORTPROGRESSBSPBUILDEND 2 #define rtWORLDIMPORTPROGRESSBSPCOMPRESSSTART 3 #define rtWORLDIMPORTPROGRESSBSPCOMPRESSUPDATE 4 #define rtWORLDIMPORTPROGRESSBSPCOMPRESSEND 5 /** * \ingroup rtimport * \def rtWORLDIMPORTINVALIDPARTITION * * This value means that no partition was found, or that the partition was * invalid or impractical. The value represents infinity. */ #define rtWORLDIMPORTINVALIDPARTITION RwRealMAXVAL /**************************************************************************** Global types */ /** * Internal use only */ typedef union RtWorldImportVertexState RtWorldImportVertexState; /** * \ingroup rtimport * \typedef RtWorldImportVertex * * typedef for struct \ref RtWorldImportVertex */ typedef struct RtWorldImportVertex RtWorldImportVertex; /** * \ingroup rtimport * \typedef RtWorldImportWeldVertex * * typedef for struct \ref RtWorldImportWeldVertex */ typedef struct RtWorldImportWeldVertex RtWorldImportWeldVertex; /** * \ingroup rtimport * \typedef RtWorldImportBuildVertex * * typedef for struct \ref RtWorldImportBuildVertex */ typedef struct RtWorldImportBuildVertex RtWorldImportBuildVertex; /** * \ingroup rtimport * \typedef RtWorldImportBuildPolyInfo * * typedef for struct \ref RtWorldImportBuildPolyInfo */ typedef struct RtWorldImportBuildPolyInfo RtWorldImportBuildPolyInfo; /** * \ingroup rtimport * \struct RtWorldImportBuildPolyInfo * * Information about a polygon */ struct RtWorldImportBuildPolyInfo { RwInt16 matIndex; /**< The material index */ RwUInt8 clipFlags; /**< Clipping flags */ RwUInt8 hasAlpha; /**< Alpha status */ void *pUserdata; /**< Userdata */ }; typedef union RtWorldImportBuildVertexMode RtWorldImportBuildVertexMode; /** * \ingroup rtimport * \struct RtWorldImportBuildVertexMode * * Mode of the vertex. * */ union RtWorldImportBuildVertexMode { RtWorldImportVertex *vpVert; /**< The vertex */ RwInt32 index; /**< The index */ }; /** * \ingroup rtimport * \struct RtWorldImportBuildVertex * * A list of polygons as a list of vertices where the end of poly boundary * is marked by mode.vpVert == NULL. * */ struct RtWorldImportBuildVertex { RtWorldImportBuildVertexMode mode; /**< The mode of the element */ RtWorldImportBuildPolyInfo pinfo; /**< we store some poly info in the end marker of a boundary */ }; /** * \ingroup rtimport * \typedef RtWorldImportGuideKDTree * * typedef for struct \ref RtWorldImportGuideKDTree */ typedef struct RtWorldImportGuideKDTree RtWorldImportGuideKDTree; /* NB Merged RtWorldImportPartition with RtWorldImportBuildClipStatistics because * there was a unique one-to-one relationship between them, and it made things easier * just updating one stucture, without having to update both in sequence... */ /** * \ingroup rtimport * \typedef RtWorldImportBuildClipStatistics * * typedef for struct \ref RtWorldImportBuildClipStatistics */ typedef struct RtWorldImportBuildClipStatistics RtWorldImportBuildClipStatistics; /** * \ingroup rtimport * \struct RtWorldImportBuildClipStatistics * * Holds statistics about a partition or candidate partition during * the build process. */ struct RtWorldImportBuildClipStatistics { RwInt32 numPotentialSplit; /**< The number of polygons split by the partition, * disgregarding overlaps */ RwInt32 numPotentialLeft; /**< The number of potential polygons and fragments on the * left of the partition, disgregarding overlaps */ RwInt32 numPotentialRight; /**< The number of potential polygons and fragments on the * right of the partition, disgregarding overlaps */ RwInt32 numActualSplit; /**< The number of polygons split by the partition */ RwInt32 numActualLeft; /**< The number of polygons and fragments on the * left of the partition */ RwInt32 numActualRight; /**< The number of polygons and fragments on the * right of the partition */ RwInt32 numMaterialLeft; /**< The number of materials on the left of the partition */ RwInt32 numMaterialRight; /**< The number of materials on the right of the partition */ RwInt32 numMaterialSplits; /**< The number of materials split by the partition */ RwInt32 numMaterialSector; /**< The total number of materials in the sector containing * the partition */ RwReal overlapLeft; /**< The actual, relative size of the overlap on the left of the partition */ RwReal overlapRight; /**< The actual, relative size of the overlap on the right of the partition */ }; /** * \ingroup rtimport * \typedef RtWorldImportPartition * * typedef for struct \ref RtWorldImportPartition */ typedef struct RtWorldImportPartition RtWorldImportPartition; /** * \ingroup rtimport * \struct RtWorldImportPartition * * A partitioning plane. */ struct RtWorldImportPartition { RwInt32 type; /**< Plane type, i.e. 0,4,8 for being normal to the x,y,z axes respectively. */ RwReal value; /**< The distance of the plane from the origin */ RwReal maxLeftValue; /**< The maximum value of the left face of the overlap. This is derived * from the maxOverlapPercent value in \ref RtWorldImportParameters */ RwReal maxRightValue; /**< The maximum value of the right face of the overlap. This is derived * from the maxOverlapPercent value in \ref RtWorldImportParameters */ RtWorldImportBuildClipStatistics buildStats; /**< The statistics for the partition */ }; /** * \ingroup rtimport * \struct RtWorldImportGuideKDTree * Represents the structure of a binary tree with * no contents per se. It is used to build a BSP in a user specified * manner instead of using any heuristic. * */ struct RtWorldImportGuideKDTree { RtWorldImportPartition partition; /**< A partitioning plane */ RwBBox bbox; /**< Bounding box of the sector or super-sector */ RtWorldImportGuideKDTree *parent; /**< Pointer to its parent */ RwInt32 order; /**< Relationship information - 0 for left child, 1 for right child */ RtWorldImportGuideKDTree *left; /**< Left child */ RtWorldImportGuideKDTree *right; /**< Right child */ }; typedef struct _rtWorldImportGuideKDStackElement _rtWorldImportGuideKDStackElement; struct _rtWorldImportGuideKDStackElement { RwBool terminal; RtWorldImportGuideKDTree *node; _rtWorldImportGuideKDStackElement *next; }; typedef struct _rtWorldImportGuideKDStack _rtWorldImportGuideKDStack; struct _rtWorldImportGuideKDStack { _rtWorldImportGuideKDStackElement *top; _rtWorldImportGuideKDStackElement *current; _rtWorldImportGuideKDStackElement *bottom; }; /** * \ingroup rtimport * \typedef RtWorldImportBuildSector * * typedef for struct \ref RtWorldImportBuildSector */ typedef struct RtWorldImportBuildSector RtWorldImportBuildSector; /** * \ingroup rtimport * \struct RtWorldImportBuildSector * * Holds information about the sector that is being subdivided */ struct RtWorldImportBuildSector { RwInt32 type; /**< Sector type (so can handle in an RpWorld) */ RtWorldImportVertex *vertices; /**< A pointer to the list of vertices */ RwInt32 numVertices; /**< The number of vertices */ RtWorldImportBuildVertex *boundaries; /**< A list of boundaries \see RtWorldImportBuildVertex */ RwInt32 numBoundaries; /**< The number of boundaries */ RwInt32 numPolygons; /**< The number of polygons (triangles) */ RwBBox boundingBox; /**< Sector's bounding box */ RwReal overlap; /**< The percentage that the sector overlaps with its neighbour */ RwUInt32 maxNumMaterials; /**< Maximum number of materials in the in the world */ }; /** * \ingroup rtimport * \typedef RtWorldImportBuildStatus * * typedef for struct \ref RtWorldImportBuildStatus */ typedef struct RtWorldImportBuildStatus RtWorldImportBuildStatus; /** * \ingroup rtimport * \struct RtWorldImportBuildStatus * World Import Build Status Structure * Used to store the current tree's build status */ struct RtWorldImportBuildStatus { RwInt32 depth; /**< current depth in the tree */ }; /** * Internal use only */ union RtWorldImportVertexState { /* clipFlags, two types, first is based on partition only, 2nd is * also based on partition, but takes overlaps into consideration. i.e. * number splits is usually higher in clipFlags[0] than [1] */ RwInt32 clipFlags[2]; /**< Internal use only */ RwInt32 forwardingAddress; /**< Internal use only */ RtWorldImportVertex *vpVert; /**< Internal use only */ RtWorldImportWeldVertex *vpWeldVert; /**< Internal use only */ RtWorldImportBuildVertex *vpBuildVert; /**< Internal use only */ RwSList *slist; /**< Internal use only */ }; /** * \ingroup rtimport * \struct RtWorldImportVertex * Holds data for each vertex in the import world. * */ struct RtWorldImportVertex { RwV3d OC; /**< World space vertex position */ RwV3d normal; /**< World space vertex normal */ RwRGBA preLitCol; /**< Vertex Prelight color */ RwTexCoords texCoords[rwMAXTEXTURECOORDS]; /**< Vertex texture coordinates */ RtWorldImportVertexState state; /**< Internal use only */ RwInt32 matIndex; /**< Vertex material index */ void *pUserdata; /**< Pointer to unspecified per vertex user data */ }; /** * \ingroup rtimport * \typedef RtWorldImportTriangle * Holds data for each triangle in the import world. * * \see RtWorldImportTriangle */ typedef struct RtWorldImportTriangle RtWorldImportTriangle; /** * \ingroup rtimport * \struct RtWorldImportTriangle * Holds data for each triangle in the import world. * * \see RtWorldImportTriangle */ struct RtWorldImportTriangle { RwInt32 matIndex; /**< Index into material list */ RwInt32 vertIndex[3]; /**< Indices into vertex list */ void *pUserdata; /**< Pointer to unspecified per triangle user data */ }; /** * \ingroup rtimport * \typedef RtWorldImportHints * * typedef for struct \ref RtWorldImportHints */ typedef struct RtWorldImportHints RtWorldImportHints; /** * \ingroup rtimport * \struct RtWorldImportHints * Bounding box hints used to control the world sectorization process. * \see RtWorldImportHintsSet */ struct RtWorldImportHints { /** The bounding box hints */ RwBBox *boundingBoxes; /** The number of bounding box hints */ RwInt32 numBoundingBoxes; }; /** * \ingroup rtimport * \typedef RtWorldImportParameters * * typedef for struct \ref RtWorldImportParameters */ typedef struct RtWorldImportParameters RtWorldImportParameters; /** * \ingroup rtimport * \struct RtWorldImportParameters * Parameters used with \ref RtWorldImportCreateWorld. * They are initialized to default values using \ref RtWorldImportParametersInit. * */ struct RtWorldImportParameters { RwReal worldSectorMaxSize; /**< The maximum world sector size. */ RwInt32 maxWorldSectorPolygons; /**< The maximum number of polygons in a world sector. */ RwReal maxOverlapPercent; /**< Total fraction of world sector overlap allowed. */ RwReal weldThreshold; /**< Threshold for welding vertices. */ RwReal angularThreshold; /**< Angular threshold for welding vertex normals */ RwBool calcNormals; /**< If TRUE then importer creates normals. */ RwBool conditionGeometry; /**< If TRUE perform vertex welding and degenerate triangle removal.*/ RwBool userSpecifiedBBox; /**< If TRUE allows user to specify minimum bounding-box for the * world using the userBBox parameter. */ RwBBox userBBox; /**< User specified world bounding-box if userSpecifiedBBox is TRUE.*/ RwReal uvLimit; /**< If conditionGeometry is TRUE limit texture coordinates to this * value. */ RwBool retainCreases; /**< If TRUE then duplicate vertices with differing normals will not * be merged. */ RwBool fixTJunctions; /**< If TRUE then T-junctions are fixed in the geometry (slow). */ RwBool weldPolygons; /**< If TRUE then polygons are welded where possible to reduce the * polygon count. */ RwInt32 flags; /**< Conversion flags (see RpWorldFlag). */ RwTextureAddressMode mode; /**< If \ref rwTEXTUREADDRESSWRAP than weld vertices according to * mod(1) congruent texture coordinates */ RwBool sortPolygons; /**< If TRUE then polygons are sorted by their centroid */ RwBool cullZeroAreaPolygons; /**< If TRUE then zero-area polygons are culled */ RwInt32 numTexCoordSets; /**< The number of texture coordinate sets to use. If set to zero, then * the number is taken from the flags parameter which, for backward * compatibility, can include the \ref rpWORLDTEXTURED or \ref rpWORLDTEXTURED2 * flags. These specify one or two sets respectively. */ RwBool terminatorCheck; /**< If TRUE the world will be checked for validity during the build process. */ }; /** * \ingroup rtimport * \typedef RtWorldImport * * typedef for struct \ref RtWorldImport */ typedef struct RtWorldImport RtWorldImport; /** * \ingroup rtimport * \struct RtWorldImport * World Import State Structure */ struct RtWorldImport { RpMaterialList matList; /**< Material list */ RtWorldImportVertex *vertices; /**< Vertex array */ RwInt32 numVertices; /**< Vertex count */ RtWorldImportTriangle *polygons; /**< Triangle array */ RwInt32 numPolygons; /**< Triangle count */ RwSurfaceProperties surfaceProps; /**< The world's surface lighting properties */ }; /** * \ingroup rtimport * \ref RtWorldImportProgressCallBack is the type for the callback function supplied to * \ref RtWorldImportSetProgressCallBack. * * \param msg Message type corresponding to one of the following: * \li rtWORLDIMPORTPROGRESSBSPBUILDSTART - * The BSP creation process is about to start. * The argument value is equal to 0.0. * \li rtWORLDIMPORTPROGRESSBSPBUILDUPDATE - * The BSP creation process has finished processing a subsection of * the world. The argument value is equal to the percentage of the * world processed up to this point. * \li rtWORLDIMPORTPROGRESSBSPBUILDEND - * The BSP creation process has ended. * The argument value is equal to 100.0. * \li rtWORLDIMPORTPROGRESSBSPCOMPRESSSTART - * The BSP compression process is about to start. The argument value * is equal to 0.0. * \li rtWORLDIMPORTPROGRESSBSPCOMPRESSUPDATE - * The BSP compression has finished processing a subsection of the * world. The argument value is equal to the percentage of the world * processed up to this point. * \li rtWORLDIMPORTPROGRESSBSPCOMPRESSEND - * The BSP compression process has ended. The argument value is equal * to 100.0. * * \param value The percentage of the progress made in either BSP * building or BSP compression. * * \return TRUE to continue BSP processing, FALSE to abort. * * \see RtWorldImportSetProgressCallBack */ typedef RwBool (*RtWorldImportProgressCallBack)(RwInt32 msg, RwReal value); /** * \ingroup rtimport * \typedef RtWorldImportDestroyVertexUserdataCallBack * * A pointer to the CallBack function that will be called during * vertex destruction. */ typedef RwBool (*RtWorldImportDestroyVertexUserdataCallBack)(void **pUserdata); /** * \ingroup rtimport * \typedef RtWorldImportCloneVertexUserdataCallBack * * A pointer to the CallBack function that will be called during * vertex cloning. */ typedef RwBool (*RtWorldImportCloneVertexUserdataCallBack)(void **pUserdataDst, void **pUserdataSrc); /** * \ingroup rtimport * \typedef RtWorldImportInterpVertexUserdataCallBack * * A pointer to the CallBack function that will be called during * vertex interpolation. */ typedef RwBool (*RtWorldImportInterpVertexUserdataCallBack)(void **pUserdataDst, void **pUserdata1, void **pUserdata2, RwReal delta); /** * \ingroup rtimport * \typedef RtWorldImportDestroyPolygonUserdataCallBack * * A pointer to the CallBack function that will be called during * polygon destruction. */ typedef RwBool (*RtWorldImportDestroyPolygonUserdataCallBack)(void **pUserdata); /** * \ingroup rtimport * \typedef RtWorldImportSplitPolygonUserdataCallBack * * A pointer to the CallBack function that will be called during * polygon division. */ typedef RwBool (*RtWorldImportSplitPolygonUserdataCallBack)(void **pUserdataDst, void **pUserdataSrc); /** * \ingroup rtimport * \typedef RtWorldImportSectorSetVertexUserdataCallBack * * A pointer to the CallBack function that will be called during * the setting of the vertex user data. */ typedef RwBool (*RtWorldImportSectorSetVertexUserdataCallBack)(void **pUserdata, RpWorldSector *sector, RwInt32 index); /** * \ingroup rtimport * \typedef RtWorldImportSectorSetPolygonUserdataCallBack * * A pointer to the CallBack function that will be called during * the setting of the polygon user data. */ typedef RwBool (*RtWorldImportSectorSetPolygonUserdataCallBack)(void **pUserdata, RpWorldSector *sector, RwInt32 index); /** * \ingroup rtimport * \typedef RtWorldImportTerminationBuildCallBack * * A pointer to the function that will be called during the * build process to determine whether the current sector should * be subdivided further, or terminated. */ typedef RwBool (*RtWorldImportTerminationBuildCallBack) (RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, void *pData); /** * \ingroup rtimport * \typedef RtWorldImportPartitionBuildCallBack * * A pointer to the function that will be called during the * build process to select a suitable sector partition. */ typedef RwReal (*RtWorldImportPartitionBuildCallBack) (RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void *pData); /** * \ingroup rtimport * \typedef RtWorldImportBuildCallBacks * * typedef for struct \ref RtWorldImportBuildCallBacks */ typedef struct RtWorldImportBuildCallBacks RtWorldImportBuildCallBacks; /* MAYBE: rename to SectorCallBacks ?*/ /** * \ingroup rtimport * \struct RtWorldImportBuildCallBacks * Sectorization callbacks */ struct RtWorldImportBuildCallBacks { RtWorldImportPartitionBuildCallBack partitionBuild; /**< Callback for choosing partition */ void *partitionUserData; /**< Partition callback user data */ RtWorldImportTerminationBuildCallBack terminationBuild; /**< Callback for termination of further partitioning */ void *terminationUserData; /**< Termination callback user data */ }; /** * \ingroup rtimport * \typedef RtWorldImportUserdataCallBacks * * typedef for struct \ref RtWorldImportUserdataCallBacks */ typedef struct RtWorldImportUserdataCallBacks RtWorldImportUserdataCallBacks; /** * \ingroup rtimport * \struct RtWorldImportUserdataCallBacks * Bundle of callbacks */ struct RtWorldImportUserdataCallBacks { RtWorldImportDestroyVertexUserdataCallBack destroyVertexUserdata; /**< Callback on vertex destruction */ RtWorldImportCloneVertexUserdataCallBack cloneVertexUserdata; /**< Callback on vertex cloning */ RtWorldImportInterpVertexUserdataCallBack interpVertexUserdata; /**< Callback on vertex interpolation */ RtWorldImportDestroyPolygonUserdataCallBack destroyPolygonUserdata; /**< Callback on polygon destruction */ RtWorldImportSplitPolygonUserdataCallBack splitPolygonUserdata; /**< Callback on polygon division */ RtWorldImportSectorSetVertexUserdataCallBack sectorSetVertexUserdata; /**< Callback on setting vertex user data */ RtWorldImportSectorSetPolygonUserdataCallBack sectorSetPolygonUserdata; /**< Callback on setting polygon user data */ }; /** * \ingroup rtimport * \typedef RtWorldImportBuildPartitionSelector * * An enumeration that can be passed to * \ref RtWorldImportSetStandardBuildPartitionSelector to determine * whether partitioning will be achieved automatically, using the * default partition selected, or manually using the \ref RtWorldImportGuideKDTree */ typedef enum { rwBUILDPARTITIONSELECTOR_DEFAULT, /**< Sets the default automated process */ rwBUILDPARTITIONSELECTOR_GUIDED /**< Sets the guided manual process */ } RtWorldImportBuildPartitionSelector; /* Builds overlaps from plane and conversion params */ #define BuildSectorSetOverlapsMacro(_boundingBox, _partition, _conversionParams) \ MACRO_START \ { \ RwReal sup = GETCOORD((_boundingBox).sup, (_partition).type); \ RwReal inf = GETCOORD((_boundingBox).inf, (_partition).type); \ \ (_partition).maxLeftValue = \ (_partition).value + \ ((sup - (_partition).value) * (_conversionParams).maxOverlapPercent); \ \ (_partition).maxRightValue = \ (_partition).value - \ ((((_partition).value) - inf) * (_conversionParams).maxOverlapPercent); \ } \ MACRO_STOP /***************************************************************************** * Function prototypes */ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ extern RwBool _rtImportBuildSectorFindBBox(RtWorldImportBuildSector *buildSector, RwBBox *bbpOut); /* TODO: decide where these scheme functions are going and which ones are public and whether _rt or RT should be used */ extern void _rtWorldImportGuideKDCopy(RtWorldImportGuideKDTree *KD, RpSector *spSector, RwInt32 depth); extern void _rtWorldImportGuideKDStackDestroy(_rtWorldImportGuideKDStack *stack); extern void _rtWorldImportGuideKDEncodeAsStack(RtWorldImportGuideKDTree *tree, _rtWorldImportGuideKDStack *stack); extern RtWorldImportGuideKDTree *RtWorldImportGuideKDCreate(RwBBox *bbox); extern RtWorldImportGuideKDTree *RtWorldImportGuideKDAddPartition (RtWorldImportGuideKDTree *KD, RwInt32 type, RwReal value); extern void RtWorldImportGuideKDDeletePartition(RtWorldImportGuideKDTree *KD); extern void RtWorldImportGuideKDDestroy(RtWorldImportGuideKDTree *KD); extern RtWorldImportGuideKDTree *RtWorldImportGuideKDWrite( RtWorldImportGuideKDTree *guideKD, const RwChar *filename); extern RtWorldImportGuideKDTree * RtWorldImportGuideKDRead( const RwChar *filename, const RwBBox *bbox); /***************************************************************************** * PARTITION SELECTORS - These callbacks for used to select a partition * from a sector. */ extern RwReal RtWorldImportBalancedCullPartitionSelector(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void *userData); extern RwReal RtWorldImportMaterialCountPartitionSelector(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void *userData); extern RwReal RtWorldImportMaterialSeparatePartitionSelector(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void *userData); extern RwReal RtWorldImportMaximumOccluderPartitionSelector(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData); extern RwReal RtWorldImportDisjointOccluderPartitionSelector(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData); extern RwReal RtWorldImportLeastCutAndBalancedPartitionSelector(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData); extern RwReal RtWorldImportMaximumExtentPartitionSelector(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData); extern RwReal RtWorldImportCullMiddleSpacePartitionSelector(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void *userData); extern RwReal RtWorldImportCullEndSpacePartitionSelector(RtWorldImportBuildSector * buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void *userData); extern RwReal RtWorldImportCullSpacePartitionSelector(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void *userData); extern RwReal RtWorldImportHintBBoxPartitionSelector(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void *userData); extern RwReal RtWorldImportGeneralOccluderPartitionSelector(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData); extern RwReal RtWorldImportBalancedTreePartitionSelector(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData); /***************************************************************************** * PARTITION ITERATORS - These callbacks iterate though a set of partitions */ extern RwBool RtWorldImportOrthogonalAutoPartitionIterator(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData, RwInt32* loopCounter); extern RwBool RtWorldImportRegularIntervalPartitionIterator(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData, RwInt32* loopCounter); extern RwBool RtWorldImportMiddleAxisPartitionIterator(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData, RwInt32 * loopCounter); extern RwBool RtWorldImportMedianPercentagePartitionIterator(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void *userData, RwInt32 *loopCounter); extern RwBool RtWorldImportHintBBoxPartitionIterator(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData, RwInt32* loopCounter); extern RwBool RtWorldImportHighestVertexAccommodatingPlanePartitionIterator(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus * buildStatus, RtWorldImportPartition *partition, void * userData, RwInt32* loopCounter); extern RwBool RtWorldImportMaterialBoundsPartitionIterator(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus * buildStatus, RtWorldImportPartition *partition, void *userData, RwInt32 *loopCounter); /***************************************************************************** * PARTITION EVALUATORS - These callbacks iterate though a set of partitions */ extern RwReal RtWorldImportFuzzyBalancedPartitionEvaluator(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void *userData); extern RwReal RtWorldImportPotentialSplitPartitionEvaluator(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData); extern RwReal RtWorldImportBalancedPartitionEvaluator(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData); extern RwReal RtWorldImportExtentPartitionEvaluator(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData); extern RwReal RtWorldImportOccluderPartitionEvaluator(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData); extern RwReal RtWorldImportWeightedOccluderPartitionEvaluator(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData); extern RwReal RtWorldImportHintBBoxPartitionEvaluator(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void *userData); extern RwReal RtWorldImportVolumeBalancedPartitionEvaluator(RtWorldImportBuildSector * buildSector, RtWorldImportBuildStatus * buildStatus, RtWorldImportPartition *partition, void * userData); extern RwReal RtWorldImportWeightedDisjointOccluderPartitionEvaluator(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData); extern RwReal RtWorldImportMaterialCutsPartitionEvaluator(RtWorldImportBuildSector * buildSector, RtWorldImportBuildStatus * buildStatus, RtWorldImportPartition *partition, void * userData); extern RwReal RtWorldImportMaterialBalancedPartitionEvaluator(RtWorldImportBuildSector * buildSector, RtWorldImportBuildStatus *buildStatus, RtWorldImportPartition *partition, void * userData); extern RwReal RtWorldImportAspectPartitionEvaluator(RtWorldImportBuildSector *buildSector, RtWorldImportBuildStatus * buildStatus, RtWorldImportPartition *partition, void * userData); extern RwReal RtWorldImportMaterialSeparatorPartitionEvaluator(RtWorldImportBuildSector * buildSector, RtWorldImportBuildStatus * buildStatus, RtWorldImportPartition *partition, void * userData); /***************************************************************************** * PARTITION TERMINATORS - These callbacks are used to decide when * partitioning of a sector should stop */ extern RwBool RtWorldImportNeverPartitionTerminator(RtWorldImportBuildSector * buildSector, RtWorldImportBuildStatus * buildStatus, void * userData); extern RwBool RtWorldImportMaximumLegalPartitionTerminator(RtWorldImportBuildSector * buildSector, RtWorldImportBuildStatus * __RWUNUSED__ buildStatus, void * __RWUNUSED__ userData); extern RwBool RtWorldImportDefaultPartitionTerminator(RtWorldImportBuildSector * buildSector, RtWorldImportBuildStatus * buildStatus, void * pData); extern RwBool RtWorldImportDepthPartitionTerminator(RtWorldImportBuildSector * buildSector, RtWorldImportBuildStatus * buildStatus, void * userData); extern RwBool RtWorldImportSectorHeightPartitionTerminator(RtWorldImportBuildSector * buildSector, RtWorldImportBuildStatus * buildStatus, void * userData); extern RwBool RtWorldImportSizePartitionTerminator(RtWorldImportBuildSector * buildSector, RtWorldImportBuildStatus * buildStatus, void * userData); extern RwBool RtWorldImportSectorAspectSizePartitionTerminator(RtWorldImportBuildSector * buildSector, RtWorldImportBuildStatus * buildStatus, void * userData); /* END TODO */ /* WorldImport hints */ extern void RtWorldImportHintsSet(RtWorldImportHints *hints); extern RtWorldImportHints * RtWorldImportHintsGet(void); extern RtWorldImportHints * RtWorldImportHintsCreate(void); extern RwBool RtWorldImportHintsDestroy(RtWorldImportHints *hints); extern RtWorldImportHints * RtWorldImportHintsAddBoundingBoxes(RtWorldImportHints *hints, RwInt32 numBoundingBoxes); extern void RtWorldImportMaterialGroupHintGenerator(RtWorldImportBuildSector *buildSector, RtWorldImportHints *materialGroupHints); /* Initializing the conversion structure */ extern RtWorldImportParameters *RtWorldImportParametersInit(void); extern void RtWorldImportParametersSet(RtWorldImportParameters *params); extern RtWorldImportParameters *RtWorldImportParametersGet(void); extern RpWorld *RtWorldImportCreateWorld(RtWorldImport * nohsworld, RtWorldImportParameters * conversionParams); extern RpGeometry *RtWorldImportCreateGeometry(RtWorldImport * nohsworld, RtWorldImportParameters * conversionParams); extern RtWorldImport *RtWorldImportCreate(void); extern RwBool RtWorldImportDestroy(RtWorldImport * nohsworld); extern RtWorldImport *RtWorldImportAddNumVertices(RtWorldImport * nohsworld, RwInt32 numNewVertices); extern RtWorldImport *RtWorldImportAddNumTriangles(RtWorldImport * nohsworld, RwInt32 numNewTriangles); extern RpMaterial *RtWorldImportGetMaterial(RtWorldImport * nohsworld, RwInt32 matInd); extern RwInt32 RtWorldImportGetNumVertices(RtWorldImport * nohsworld); extern RtWorldImportVertex *RtWorldImportGetVertices(RtWorldImport * nohsworld); extern RwInt32 RtWorldImportGetNumTriangles(RtWorldImport * nohsworld); extern RtWorldImportTriangle * RtWorldImportGetTriangles(RtWorldImport * nohsworld); /* Surface lighting characteristics */ extern RtWorldImport * RtWorldImportSetSurfaceProperties(RtWorldImport * world, RwSurfaceProperties * surface); extern RwSurfaceProperties * RtWorldImportGetSurfaceProperties(RtWorldImport * world); /* Progress callbacks */ extern void RtWorldImportSetProgressCallBack(RtWorldImportProgressCallBack CB); extern RpWorldSector * RtWorldImportGetNumMaterials(RpWorldSector *worldSector, void *data); extern void _rtImportWorldSendProgressMessage(RwInt32 msgtype, RwReal value); /* Reading and Writing */ extern RtWorldImport *RtWorldImportWrite(RtWorldImport * world, RwChar * filename); extern RtWorldImport *RtWorldImportRead(RwChar * filename); extern RwInt32 RtWorldImportAddMaterial(RtWorldImport * nohsworld, RpMaterial * material); extern RwInt32 RtWorldImportGetMaterialIndex(RtWorldImport * nohsworld, RpMaterial * material); extern RtWorldImport *RtWorldImportForAllMaterials(RtWorldImport * nohsworld, RpMaterialCallBack fpCallBack, void *pData); extern void RtWorldImportSetUserdataCallBacks(RtWorldImportDestroyVertexUserdataCallBack destroyVertexUserdataCB, RtWorldImportCloneVertexUserdataCallBack cloneVertexUserdataCB, RtWorldImportInterpVertexUserdataCallBack interpVertexUserdataCB, RtWorldImportSectorSetVertexUserdataCallBack sectorSetVertexUserdata, RtWorldImportDestroyPolygonUserdataCallBack destroyPolygonUserdataCB, RtWorldImportSplitPolygonUserdataCallBack splitPolygonUserdataCB, RtWorldImportSectorSetPolygonUserdataCallBack sectorSetPolygonUserdata); extern void RtWorldImportSetBuildCallBacks(RtWorldImportPartitionBuildCallBack partitionBuildCB, RtWorldImportTerminationBuildCallBack terminationBuildCB); extern void RtWorldImportSetPartitionStatistics(RtWorldImportBuildSector * buildSector, RtWorldImportPartition * partition); extern void RtWorldImportSetBuildCallBacksUserData(void *partitionUserData, void *terminateUserData); extern void RtWorldImportSetStandardBuildPartitionSelector(RtWorldImportBuildPartitionSelector partitionSelector, void* userData); #ifdef __cplusplus } #endif /* __cplusplus */ #define RtWorldImportParametersInitialize(_paramsPtr) \ *(_paramsPtr) = *RtWorldImportParametersInit(); #endif /* RTIMPORT_H */