index_buffer.h

Go to the documentation of this file.

/* Copyright, 2000 Nevrax Ltd.
 *
 * This file is part of NEVRAX NEL.
 * NEVRAX NEL is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.

 * NEVRAX NEL is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with NEVRAX NEL; see the file COPYING. If not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

#ifndef NL_INDEX_BUFFER_H
#define NL_INDEX_BUFFER_H

#include "nel/misc/types_nl.h"
#include "nel/misc/smart_ptr.h"
#include <vector>

namespace NLMISC
{
    class IStream;
};

namespace NL3D {

using NLMISC::CRefCount;
using NLMISC::CRefPtr;

// List typedef.
class   IIBDrvInfos;
class   CIndexBuffer;
class   IDriver;
class   CIndexBufferReadWrite;
class   CIndexBufferRead;
typedef std::list<IIBDrvInfos*>         TIBDrvInfoPtrList;
typedef TIBDrvInfoPtrList::iterator     ItIBDrvInfoPtrList;


#define NL_NAMED_INDEX_BUFFER
#ifdef NL_NAMED_INDEX_BUFFER
    #define NL_SET_IB_NAME(ib, n) if ((ib).getName().empty()) (ib).setName(n);
#else
    #define NL_SET_IB_NAME(ib, n)
#endif



#define NL_FORCE_INDEX_BUFFER_16

#ifdef NL_FORCE_INDEX_BUFFER_16
    typedef uint16 TIndexType; // default index type
    #define NL_DEFAULT_INDEX_BUFFER_FORMAT CIndexBuffer::Indices16

    #define NL_MESH_INDEX16
    #define NL_MESH_MRM_INDEX16
    #define NL_SKINNED_MESH_MRM_INDEX16
    //#define NL_LANDSCAPE_INDEX16
    #define NL_LOD_CHARACTER_INDEX16
    #define NL_COARSE_MESH_INDEX16
#else
    typedef uint32 TIndexType; // default index type
    #define NL_DEFAULT_INDEX_BUFFER_FORMAT CIndexBuffer::Indices32
#endif



// 16 bit indices for meshs ?
#ifdef NL_MESH_INDEX16
    typedef uint16 TMeshIndexType;
    #define NL_MESH_INDEX_FORMAT CIndexBuffer::Indices16
#else
    typedef uint32 TMeshIndexType;
    #define NL_MESH_INDEX_FORMAT CIndexBuffer::Indices32
#endif

// 16 bit indices for mesh_mrm ?
#ifdef NL_MESH_MRM_INDEX16
    typedef uint16 TMeshMRMIndexType;
    #define NL_MESH_MRM_INDEX_FORMAT CIndexBuffer::Indices16
#else
    typedef uint32 TMeshMRMIndexType;
    #define NL_MESH_MRM_INDEX_FORMAT CIndexBuffer::Indices32
#endif

// 16 bit indices for skinned mesh_mrm ?
#ifdef NL_SKINNED_MESH_MRM_INDEX16
    typedef uint16 TSkinnedMeshMRMIndexType;
    #define NL_SKINNED_MESH_MRM_INDEX_FORMAT CIndexBuffer::Indices16
#else
    typedef uint32 TSkinnedMeshMRMIndexType;
    #define NL_SKINNED_MESH_MRM_INDEX_FORMAT CIndexBuffer::Indices32
#endif


// 16 bit indices for landscape ?
#ifdef NL_LANDSCAPE_INDEX16
    typedef uint16 TLandscapeIndexType;
    #define NL_LANDSCAPE_INDEX_FORMAT CIndexBuffer::Indices16
#else
    typedef uint32 TLandscapeIndexType;
    #define NL_LANDSCAPE_INDEX_FORMAT CIndexBuffer::Indices32
#endif

// 16 bit for lod characters ?
#ifdef NL_LOD_CHARACTER_INDEX16
    typedef uint16 TLodCharacterIndexType;
    #define NL_LOD_CHARACTER_INDEX_FORMAT CIndexBuffer::Indices16
#else
    typedef uint32 TLodCharacterIndexType;
    #define NL_LOD_CHARACTER_INDEX_FORMAT CIndexBuffer::Indices32
#endif

// 16 bit for coarse meshs ?
#ifdef NL_COARSE_MESH_INDEX16
    typedef uint16 TCoarseMeshIndexType;
    #define NL_COARSE_MESH_INDEX_FORMAT CIndexBuffer::Indices16
#else
    typedef uint32 TCoarseMeshIndexType;
    #define NL_COARSE_MESH_INDEX_FORMAT CIndexBuffer::Indices32
#endif



/* *** IMPORTANT ********************
 * *** IF YOU MODIFY THE STRUCTURE OF THIS CLASS, PLEASE INCREMENT IDriver::InterfaceVersion TO INVALIDATE OLD DRIVER DLL
 * **********************************
 */

// All these flags are similar to DX8
class CIndexBuffer : public CRefCount
{
public:
    friend class CIndexBufferReadWrite;
    friend class CIndexBufferRead;

    enum TPreferredMemory
    {
        RAMPreferred = 0,   // A block of driver RAM memory is allocated for this buffer. The buffer is read/write.
        AGPPreferred,       // A block of driver AGP memory is allocated for this buffer. The buffer is writeonly.
        StaticPreferred,    // The buffer will not be modified. A block of driver AGP or VRAM memory is allocated for this buffer. The buffer is writeonly.
        RAMVolatile,        // A block of temporary driver RAM memory will be returned by lock(). The buffer must be entirely filled after each swapBuffers(). The buffer is writeonly.
        AGPVolatile,        // A block of temporary driver AGP memory will be returned by lock(). The buffer must be entirely filled after each swapBuffers(). The buffer is writeonly.
        PreferredCount,
    };

    enum TLocation
    {
        RAMResident = 0,
        AGPResident,
        VRAMResident,
        NotResident,
        LocationCount,
    };

    enum TFormat
    {
        Indices16 = 0,
        Indices32,
        IndicesUnknownFormat // reserved, for use by driver
    };

    enum
    {
        TouchedIndexFormat      = 1,

        TouchedNumIndexes       = 2,

        TouchedReserve          = 4,

        TouchedAll              = 0xFFFF
    };

public:

    // \name Private. For Driver only.
    // @{
    CRefPtr<IIBDrvInfos>    DrvInfos;
    uint                    getTouchFlags() const { return _InternalFlags&TouchedAll; }

    void                    setLocation (TLocation newLocation);    // The driver implementation must set the location after activeIndexBuffer.

    void                    fillBuffer ();
    // @}

public:
    /* ***********************************************
     *  WARNING: This Class/Method must be thread-safe (ctor/dtor/serial): no static access for instance
     *  It can be loaded/called through CAsyncFileManager for instance
     * ***********************************************/

    CIndexBuffer(void);

    CIndexBuffer(const char *name);

    CIndexBuffer(const CIndexBuffer &vb);

    ~CIndexBuffer(void);

    CIndexBuffer            &operator=(const CIndexBuffer &vb);

    void setPreferredMemory (TPreferredMemory preferredMemory, bool keepLocalMemory);

    TPreferredMemory getPreferredMemory () const { return _PreferredMemory; }

    bool getKeepLocalMemory () const { return _KeepLocalMemory; }

    TLocation getLocation () const { return _Location; }

    bool isResident () const { return (_Location != NotResident) && DrvInfos; }

    void                    setNumIndexes(uint32 n);

    // Set format for indices. This discards previous indices
    void                    setFormat(TFormat format);

    // Get format
    TFormat                 getFormat() const { return _Format; }

    // get number of bytes per index
    uint                    getIndexNumBytes() const { return _Format == Indices16 ? 2 : 4; }

    uint32                  getNumIndexes(void) const  { return(_NbIndexes); }

    void                    deleteAllIndexes();

    void                    reserve(uint32 nIndexes);

    uint32                  capacity() { return _Capacity; }

    void                    serial(NLMISC::IStream &f);

    inline void lock (CIndexBufferReadWrite &accessor, uint first=0, uint last=0);

    inline void lock (CIndexBufferRead &accessor, uint first=0, uint last=0) const;

    // Return true if the vetx buffer is locked
    bool        isLocked () const {return _LockCounter!=0;}

    // debug name
    void        setName (const std::string &name) { _Name = name; };
    const std::string &getName () const { return _Name; };

private:

    // Check locked buffers
    bool checkLockedBuffer () const { return _LockedBuffer || (!isResident() && _NonResidentIndexes.empty()); }

    inline void unlock (uint first, uint last);

    inline void unlock () const;

    // Reset the touch flags
    void        resetTouchFlags() {_InternalFlags &= (uint16)(~TouchedAll);}

    // Force non resident memory
    void        restaureNonResidentMemory();

    // Convert current index to a serializable vector
    void buildSerialVector(std::vector<uint32> &dest) const;

    // Convert current index from a serialized vector
    void restoreFromSerialVector(const std::vector<uint32> &src);


private:
    // Internal flags
    uint16                  _InternalFlags;     // Offset 18 : aligned

    // Format of indices
    TFormat                 _Format;

    // Index count in the buffer
    uint32                  _NbIndexes;         // Offset 20 : aligned

    // Capacity of the buffer
    uint32                  _Capacity;

    // Index array
    std::vector<uint8>      _NonResidentIndexes;

    // The locked index buffer
    mutable void            *_LockedBuffer;

    // The index buffer is locked n times
    mutable uint            _LockCounter;

    // Location of the buffer
    TLocation               _Location;

    // Prefered memory
    TPreferredMemory        _PreferredMemory;

    // Resident buffer size
    uint32                  _ResidentSize;

    // Keep in local memory
    bool                    _KeepLocalMemory;

    // debug name
    std::string             _Name;
};

// *** IMPORTANT ********************
// *** IF YOU MODIFY THE STRUCTURE OF THIS CLASS, PLEASE INCREMENT IDriver::InterfaceVersion TO INVALIDATE OLD DRIVER DLL
// **********************************
class IIBDrvInfos : public CRefCount
{
protected:
    IDriver             *_Driver;
private:
    ItIBDrvInfoPtrList  _DriverIterator;

public:
    CRefPtr<CIndexBuffer>   IndexBufferPtr;

    IIBDrvInfos(IDriver *drv, ItIBDrvInfoPtrList it, CIndexBuffer *ib) {_Driver= drv; _DriverIterator= it; IndexBufferPtr = ib;}

    virtual void        *lock (uint first, uint last, bool readOnly) =0;

    virtual void    unlock (uint first, uint last) =0;

    /* The virtual dtor is important.
     * The driver implementation must call setLocation (NotResident) if IndexBufferPtr!=NULL.*/
    virtual ~IIBDrvInfos();


    CIndexBuffer::TFormat getFormat() const { nlassert(IndexBufferPtr); return IndexBufferPtr->getFormat(); }
    uint                  getIndexNumBytes() const { nlassert(IndexBufferPtr); return IndexBufferPtr->getIndexNumBytes(); }
};

class CIndexBufferReadWrite
{
public:
    friend class CIndexBuffer;

    CIndexBufferReadWrite()
    {
        _Parent = NULL;
    }
    ~CIndexBufferReadWrite()
    {
        unlock();
    }

    void unlock()
    {
        if (_Parent)
        {
            _Parent->unlock(_First, _Last);
            _Parent = NULL;
        }
    }

    // Set a line index at index idx.
    inline void             setLine(uint idx, uint32 i0, uint32 i1)
    {
        nlassert (_Parent->checkLockedBuffer());
        #ifdef NL_DEBUG
            nlassert(idx < _Parent->getNumIndexes());
            nlassert(idx + 1 < _Parent->getNumIndexes());
        #endif
        if (_Parent->getFormat() == CIndexBuffer::Indices16)
        {
            #ifdef NL_DEBUG
                nlassert(i0 <= 65535);
                nlassert(i1 <= 65535);
            #endif
            ((uint16 *) _Parent->_LockedBuffer)[idx] = (uint16) i0;
            ((uint16 *) _Parent->_LockedBuffer)[idx+1] = (uint16) i1;
        }
        else if (_Parent->getFormat() == CIndexBuffer::Indices32)
        {
            ((uint32 *) _Parent->_LockedBuffer)[idx] = i0;
            ((uint32 *) _Parent->_LockedBuffer)[idx+1] = i1;
        }
        else
        {
            nlassert(0);
        }
    }

    // Set a line index at index idx.
    inline void             setTri(uint idx, uint32 i0, uint32 i1, uint32 i2)
    {
        nlassert (_Parent->checkLockedBuffer());
        #ifdef NL_DEBUG
            nlassert(idx < _Parent->getNumIndexes());
            nlassert(idx + 1 < _Parent->getNumIndexes());
            nlassert(idx + 2 < _Parent->getNumIndexes());
        #endif
        if (_Parent->getFormat() == CIndexBuffer::Indices16)
        {
            #ifdef NL_DEBUG
                nlassert(i0 <= 65535);
                nlassert(i1 <= 65535);
                nlassert(i2 <= 65535);
            #endif
            ((uint16 *) _Parent->_LockedBuffer)[idx] = (uint16) i0;
            ((uint16 *) _Parent->_LockedBuffer)[idx+1] = (uint16) i1;
            ((uint16 *) _Parent->_LockedBuffer)[idx+2] = (uint16) i2;
        }
        else if (_Parent->getFormat() == CIndexBuffer::Indices32)
        {
            ((uint32 *) _Parent->_LockedBuffer)[idx] = i0;
            ((uint32 *) _Parent->_LockedBuffer)[idx+1] = i1;
            ((uint32 *) _Parent->_LockedBuffer)[idx+2] = i2;
        }
        else
        {
            nlassert(0);
        }
    }

    // Get a pointer on an index.
    void *getPtr (uint idx=0)
    {
        nlassert (_Parent->checkLockedBuffer());
        if (_Parent->getFormat() == CIndexBuffer::Indices16)
        {
            return &(((uint16 *) _Parent->_LockedBuffer)[idx]);
        }
        else if (_Parent->getFormat() == CIndexBuffer::Indices32)
        {
            return &(((uint32 *) _Parent->_LockedBuffer)[idx]);
        }
        else
        {
            nlassert(0);
        }
        return NULL;
    }

    void                    touchIndexes (uint first, uint last);

    const CIndexBuffer *getParent() const { return _Parent; }

    CIndexBuffer::TFormat getFormat() const { nlassert(_Parent); return _Parent->getFormat(); }
    uint getIndexNumBytes() const { nlassert(_Parent); return _Parent->getIndexNumBytes(); }

private:

    // No copy operators available
    void        operator=(const CIndexBufferReadWrite& /* other */) {}
    CIndexBufferReadWrite(const CIndexBufferReadWrite& /* other */) {}

    CIndexBuffer        *_Parent;
    uint                _First, _Last;
};

class CIndexBufferRead
{
public:
    friend class CIndexBuffer;

    CIndexBufferRead()
    {
        _Parent = NULL;
    }
    ~CIndexBufferRead()
    {
        unlock();
    }

    void unlock()
    {
        if (_Parent)
        {
            _Parent->unlock();
            _Parent = NULL;
        }
    }

    // Get a pointer on an index.
    const void *getPtr (uint idx=0) const
    {
        nlassert (_Parent->checkLockedBuffer());
        if (_Parent->getFormat() == CIndexBuffer::Indices16)
        {
            return &(((const uint16 *) _Parent->_LockedBuffer)[idx]);
        }
        else if (_Parent->getFormat() == CIndexBuffer::Indices32)
        {
            return &(((const uint32 *) _Parent->_LockedBuffer)[idx]);
        }
        else
        {
            nlassert(0);
        }
        return NULL;
    }
    const CIndexBuffer *getParent() const { return _Parent; }
    uint getIndexNumBytes() const { nlassert(_Parent); return _Parent->getIndexNumBytes(); }
    CIndexBuffer::TFormat getFormat() const { nlassert(_Parent); return _Parent->getFormat(); }
private:

    // No copy operators available
    void        operator=(const CIndexBufferRead& /* other */) {}
    CIndexBufferRead(const CIndexBufferRead& /* other */) {}

    const CIndexBuffer      *_Parent;
};

// ***************************************************************************

inline void CIndexBuffer::lock (CIndexBufferReadWrite &accessor, uint first, uint last)
{
    accessor.unlock();
    accessor._Parent = this;
    accessor._First = 0;
    accessor._Last = 0;

    // Already locked ?
    if (_LockCounter == 0)
    {
        nlassert (_LockedBuffer == NULL);

        // No
        if (isResident() && !_KeepLocalMemory)
        {
            if (last == 0)
                last = _NbIndexes;
            _LockedBuffer = DrvInfos->lock (first, last, false);
        }
        else
        {
            if (_NonResidentIndexes.empty())
                _LockedBuffer = NULL;
            else
                _LockedBuffer = &(_NonResidentIndexes[0]);
        }
    }
    else
        nlassert ((first==0)&&(last==0));

    _LockCounter++;
}

// ***************************************************************************

inline void CIndexBuffer::lock (CIndexBufferRead &accessor, uint first, uint last) const
{
    accessor.unlock();
    accessor._Parent = this;

    // Already locked ?
    if (_LockCounter == 0)
    {
        nlassert (_LockedBuffer == NULL);

        // No
        if (isResident() && !_KeepLocalMemory)
        {
            if (last == 0)
                last = _NbIndexes;
            // Can read it ?
            nlassertex (_Location==RAMResident, ("Try to read a write only index buffer"));
            _LockedBuffer = DrvInfos->lock (first, last, true);
        }
        else
        {
            if (_NonResidentIndexes.empty())
                _LockedBuffer = NULL;
            else
                _LockedBuffer = const_cast<void*>((const void *) &(_NonResidentIndexes[0]));
        }
    }
    else
        nlassert ((first==0)&&(last==0));

    _LockCounter++;
}

// ***************************************************************************

inline void CIndexBuffer::unlock (uint first, uint end)
{
    nlassertex (_LockCounter!=0, ("Index buffer not locked"));
    nlassert (_LockedBuffer || (!isResident() && _NonResidentIndexes.empty()));

    if (_LockCounter)
        _LockCounter--;

    if (_LockCounter == 0)
    {
        if (isResident() && !_KeepLocalMemory)
            DrvInfos->unlock (0, 0);

        _LockedBuffer = NULL;
    }
}

// ***************************************************************************

inline void CIndexBuffer::unlock () const
{
    nlassertex (_LockCounter!=0, ("Index buffer not locked"));
    nlassert (_LockedBuffer || (!isResident() && _NonResidentIndexes.empty()));

    if (_LockCounter)
        _LockCounter--;

    if (_LockCounter == 0)
    {
        if (isResident() && !_KeepLocalMemory)
            DrvInfos->unlock (0, 0);

        _LockedBuffer = NULL;
    }
}

// ***************************************************************************
} // NL3D


#endif // NL_INDEX_BUFFER_H

/* End of index_buffer.h */