source: GTP/trunk/App/Games/Jungle_Rumble/src/physic/physics/include/fluids/NxMeshData.h @ 1378

#ifndef NX_FLUIDS_NXMESHDATA
#define NX_FLUIDS_NXMESHDATA
/** \addtogroup fluids
  @{
*/
/*----------------------------------------------------------------------------*\
|
|                                               Public Interface to NovodeX Technology
|
|                                                            www.novodex.com
|
\*----------------------------------------------------------------------------*/

/**
\brief Very similar to #NxMeshFlags used for the #NxSimpleTriangleMesh type.

\warning <b>Preliminary API, subject to change</b>
*/
enum NxMeshDataFlags
        {
        /**
        \brief Denotes the use of 16-bit vertex indices.
        */
        NX_MDF_16_BIT_INDICES                           =       1 << 0, 

        /**
        \brief Specifies that all floats are written compressed to 16 bit.
        */
        NX_MDF_16_BIT_COMPRESSED_FLOATS         =       1 << 1, 

        /**
        \brief Specifies that triangle indices are generated and adjacent triangles share common vertices.

        If this flag is not set, all triangles are described as vertex triplets in the vertex array.
        */
        NX_MDF_INDEXED_MESH                                     =       1 << 2,

        };

/**
\brief Descriptor-like user-side class for describing fluid mesh data.

This data type is used for specifying how the SDK is supposed to pass generated mesh data. This is used for 
implicit mesh generation (see NxImplicitMesh) which is used to render a fluid simulated 
by the NxFluid instance.

The usual way to render a fluid is to create a vertex buffer containing 
data for vertex positions and normals, then defining where this data is supposed to be written to 
in memory by creating an NxMeshData object and using this instance to create an NxImplicitMesh
from a fluid. After each simulation step, the user can send the buffer data to the graphics card. 
Vertex data elements (positions and normals) can be specified as being written to an interleaved 
vertex buffer or into separate buffers.

This class is very similar to NxSimpleTriangleMesh, with the difference that this user buffer 
wrapper is used to let the SDK write to user buffers instead of reading from them.

\warning <b>Preliminary API, subject to change</b>
*/
class NxMeshData
        {
        public:

        /**
        \brief  The pointer to the user specified buffer for vertex positions.

        A vertex position consists of three consequent 32 or 16 bit floats, 
        depending on whether NX_MDF_16_BIT_COMPRESSED_FLOATS has been set.

        \warning <b>Preliminary API, subject to change</b>
        */
        void*                                   verticesPosBegin;

        /**
        \brief  The pointer to the user specified buffer for vertex normals. 

        A vertex normal consists of three consequent 32/16 bit floats.

        \warning <b>Preliminary API, subject to change</b>
        */
        void*                                   verticesNormalBegin;

        /**
        \brief Specifies the distance of two vertex position start addresses in bytes.

        \warning <b>Preliminary API, subject to change</b>
        */
        NxI32                                   verticesPosByteStride;
        
        /**
        \brief Same as veticesPosByteStride for vertex normals.

        \warning <b>Preliminary API, subject to change</b>
        */
        NxI32                                   verticesNormalByteStride;

        /**
        \brief The maximal number of vertices which can be stored in the user vertex buffers.

        \warning <b>Preliminary API, subject to change</b>
        */
        NxU32                                   maxVertices;

        /**
        \brief Must point to the user allocated memory holding the number of vertices stored in the user vertex 
        buffers.
        
        If the SDK writes to a given vertex buffer, it also sets the numbers of elements written.

        \warning <b>Preliminary API, subject to change</b>
        */
        NxU32*                                  numVerticesPtr;

        /**
        \brief The pointer to the user specified buffer for vertex indices.
        
        An index consist of one 32 or 16 bit integer, depending on whether NX_MDF_16_BIT_INDICES has been set.
        
        This is only used when the flag NX_MDF_INDEXED_MESH has been set.

        \warning <b>Preliminary API, subject to change</b>
        */
        void*                                   indicesBegin;

        /**
        \brief Specifies the distance of two vertex indices start addresses in bytes.
        
        This is only used when the flag NX_MDF_INDEXED_MESH has been set.

        \warning <b>Preliminary API, subject to change</b>
        */
        NxI32                                   indicesByteStride;

        /**
        \brief The maximal number of indices which can be stored in the user index buffer.
        
        This is only used when the flag NX_MDF_INDEXED_MESH has been set.

        \warning <b>Preliminary API, subject to change</b>
        */
        NxU32                                   maxIndices;

        /**
        \brief Must point to the user allocated memory holding the number of vertex triplets used to define 
        triangles.
        
        If the SDK writes to a given triangle index buffer, it also sets the number of
        triangles written. If the flag NX_MDF_INDEXED_MESH has not been set, the triangle number is
        equal to the number of vertices divided by 3.

        \warning <b>Preliminary API, subject to change</b>
        */
        NxU32*                                  numTrianglesPtr;

        /**
        \brief Flags of type NxMeshDataFlags

        \warning <b>Preliminary API, subject to change</b>
        */
        NxU32                                   flags;




        const char*                             name;                   //!< Possible debug name. The string is not copied by the SDK, only the pointer is stored.

        NX_INLINE ~NxMeshData();
        /**
        \brief (Re)sets the structure to the default.   

        \warning <b>Preliminary API, subject to change</b>
        */

        NX_INLINE void setToDefault();
        /**
        \brief Returns true if the current settings are valid

        \warning <b>Preliminary API, subject to change</b>
        */
        NX_INLINE bool isValid() const;

        /**
        \brief Constructor sets to default.

        \warning <b>Preliminary API, subject to change</b>
        */
        NX_INLINE       NxMeshData();
        };

NX_INLINE NxMeshData::NxMeshData()
        {
        setToDefault();
        }

NX_INLINE NxMeshData::~NxMeshData()
        {
        }

NX_INLINE void NxMeshData::setToDefault()
        {
        verticesPosBegin                                = NULL;
        verticesNormalBegin                             = NULL;
        verticesPosByteStride                   = 0;
        verticesNormalByteStride                = 0;
        maxVertices                                             = 0;
        numVerticesPtr                                  = NULL;
        indicesBegin                                    = NULL;
        indicesByteStride                               = 0;
        maxIndices                                              = 0;
        numTrianglesPtr                                 = NULL;
        flags                                                   = NX_MDF_INDEXED_MESH;

        name                                                    = NULL;
        }

NX_INLINE bool NxMeshData::isValid() const
        {
        if (numVerticesPtr && !(verticesPosBegin && verticesNormalBegin)) return false;
        if (!numVerticesPtr && (verticesPosBegin || verticesNormalBegin)) return false;

        if (verticesPosBegin && !verticesPosByteStride) return false;
        if (verticesNormalBegin && !verticesNormalByteStride) return false;

        if (!numVerticesPtr && numTrianglesPtr) return false;
        if (numVerticesPtr && flags & NX_MDF_INDEXED_MESH && !numTrianglesPtr) return false;
        if (numVerticesPtr && !(flags & NX_MDF_INDEXED_MESH) && numTrianglesPtr) return false;

        if (!numTrianglesPtr && indicesBegin) return false;
        if (numTrianglesPtr && !indicesBegin) return false;

        if (indicesBegin && !indicesByteStride) return false;
                                
        return true;
        }

/** @} */
#endif


//AGCOPYRIGHTBEGIN
///////////////////////////////////////////////////////////////////////////
// Copyright © 2005 AGEIA Technologies.
// All rights reserved. www.ageia.com
///////////////////////////////////////////////////////////////////////////
//AGCOPYRIGHTEND