vertex_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_VERTEX_BUFFER_H
#define NL_VERTEX_BUFFER_H

#include "nel/misc/types_nl.h"
#include "nel/misc/smart_ptr.h"
#include "nel/misc/rgba.h"
#include "nel/misc/vector.h"
#include "nel/misc/vectord.h"
#include "nel/misc/debug.h"
#include "nel/misc/uv.h"
#include <vector>
#include <list>

namespace NLMISC
{
    class CUV;
}


namespace NL3D
{

using NLMISC::CRefCount;
using NLMISC::CRefPtr;
using NLMISC::CRGBA;
using NLMISC::CBGRA;
using NLMISC::CVector;
using NLMISC::CVectorD;
using NLMISC::CUV;


class   IDriver;
class   CVertexBufferReadWrite;
class   CVertexBufferRead;


// --------------------------------------------------


// List typedef.
class   IVBDrvInfos;
class CVertexBuffer;
typedef std::list<IVBDrvInfos*>         TVBDrvInfoPtrList;
typedef TVBDrvInfoPtrList::iterator     ItVBDrvInfoPtrList;

// ***************************************************************************
struct  CPaletteSkin
{
    uint8   MatrixId[4];

    void    serial(NLMISC::IStream &f);
};

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

/* *** 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 CVertexBuffer : public CRefCount
{
public:
    friend class CVertexBufferReadWrite;
    friend class CVertexBufferRead;

    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 TValue
    {
        Position        =0,
        Normal          =1,
        TexCoord0       =2,
        TexCoord1       =3,
        TexCoord2       =4,
        TexCoord3       =5,
        TexCoord4       =6,
        TexCoord5       =7,
        TexCoord6       =8,
        TexCoord7       =9,
        PrimaryColor    =10,
        SecondaryColor  =11,
        Weight          =12,
        PaletteSkin     =13,
        Fog             =14,
        Empty           =15,
        NumValue        =16
    };

    enum
    {
        FirstTexCoordValue = TexCoord0,
        LastTexCoordValue  = TexCoord7,
    };

    enum
    {
        PositionFlag        =   1<<Position,
        NormalFlag          =   1<<Normal,
        TexCoord0Flag       =   1<<TexCoord0,
        TexCoord1Flag       =   1<<TexCoord1,
        TexCoord2Flag       =   1<<TexCoord2,
        TexCoord3Flag       =   1<<TexCoord3,
        TexCoord4Flag       =   1<<TexCoord4,
        TexCoord5Flag       =   1<<TexCoord5,
        TexCoord6Flag       =   1<<TexCoord6,
        TexCoord7Flag       =   1<<TexCoord7,
        PrimaryColorFlag    =   1<<PrimaryColor,
        SecondaryColorFlag  =   1<<SecondaryColor,
        WeightFlag          =   1<<Weight,
        PaletteSkinFlag     =   (1<<PaletteSkin)|(1<<Weight),
        FogFlag             =   1<<Fog,
        EmptyFlag           =   1<<Empty,
    };



    enum TType
    {
        Double1=0,  // Deprecated
        Float1,
        Short1,     // Deprecated
        Double2,    // Deprecated
        Float2,
        Short2,     // Deprecated
        Double3,    // Deprecated
        Float3,
        Short3,     // Deprecated
        Double4,    // Deprecated
        Float4,
        Short4,     // Deprecated
        UChar4,
        NumType
    };

    enum
    {
        // Max count of texture coordinates
        MaxStage = 8,

        // Max count of skinning weight
        MaxWeight = 4,
    };

    enum TVertexColorType
    {
        TRGBA = 0,
        TBGRA = 1
    };

    static const uint SizeType[NumType];

    static const TType DefaultValueType[NumValue];

    static const uint  NumComponentsType[NumType];

    enum
    {
        TouchedVertexFormat     = 1,

        TouchedNumVertices      = 2,

        TouchedReserve          = 4,

        TouchedAll              = 0xFFFF
    };

public:

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

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

    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
     * ***********************************************/

    CVertexBuffer(void);

    CVertexBuffer(const char *name);

    CVertexBuffer(const CVertexBuffer &vb);

    ~CVertexBuffer(void);

    CVertexBuffer           &operator=(const CVertexBuffer &vb);

    void        copyVertices(CVertexBuffer &dest) const;
    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; }

    // @{

        bool                    setVertexFormat (uint32 Flags);

        uint16                  getVertexFormat (void) const  { return(_Flags); };


        uint                    getNumTexCoordUsed() const;

        // It is an error (assert) to query a vertex offset of a vertex component not setuped in setVertexFormat().
        // NB: The Vertex offset is always 0.
        sint                    getNormalOff() const {nlassert(_Flags & NormalFlag); return _Offset[Normal];}
        sint                    getTexCoordOff(uint8 stage=0) const  {nlassert(_Flags & (TexCoord0Flag<<stage)); return _Offset[TexCoord0+stage]; }

        sint                    getColorOff() const {nlassert(_Flags & PrimaryColorFlag); return _Offset[PrimaryColor];}
        sint                    getSpecularOff() const {nlassert(_Flags & SecondaryColorFlag); return _Offset[SecondaryColor];}

        sint                    getWeightOff(sint wgt) const {nlassert(_Flags & WeightFlag); return _Offset[Weight]+(wgt*sizeof(float));}
        sint                    getPaletteSkinOff() const {nlassert(_Flags & PaletteSkin); return _Offset[PaletteSkin];}
    // @}

    // @{

        static TValue       getValueIdByNumberEx (uint valueNumber);

        void                clearValueEx ();

        void                addValueEx (TValue valueId, TType type);

        bool                hasValueEx(TValue valueId) const;

        void                initEx ();

        sint                getValueOffEx (TValue valueId) const { nlassert(_Flags & (1<<valueId)); return _Offset[valueId]; };

    // @}

    void                    setNumVertices(uint32 n);

    uint32                  getNumVertices(void) const  { return(_NbVerts); }

    void                    deleteAllVertices();

    void                    reserve(uint32 nVerts);

    uint32                  capacity() { return _Capacity; }

    uint16                  getVertexSize (void) const { return(_VertexSize); }

    TType                   getValueType (uint value) const { nlassert (value<NumValue); return((TType)_Type[value]); }

    const uint8             *getValueTypePointer () const { return _Type; }

    uint8                   getNumWeight () const;

    void        serial(NLMISC::IStream &f);

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

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

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

    // @{
    void        serialHeader(NLMISC::IStream &f);
    void        serialSubset(NLMISC::IStream &f, uint vertexStart, uint vertexEnd);
    // @}

    const uint8 *getUVRouting () const { return _UVRouting; }
    void        setUVRouting (uint8 uvChannel, uint newUVRouting) { _UVRouting[uvChannel] = uint8(newUVRouting); }

    bool        setVertexColorFormat (TVertexColorType format);

    TVertexColorType    getVertexColorFormat () const
    {
        return (TVertexColorType)_VertexColorFormat;
    }

    // for debug : dump format of vertex buffer
    void        dumpFormat() const;
    void        setName (const std::string &name) { _Name = name; };
    const std::string &getName () const { return _Name; };

private:

    void construct();

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

    inline void unlock (uint first, uint last);

    inline void unlock () const;

    void        serialOldV1Minus(NLMISC::IStream &f, sint ver);

    uint16      remapV2Flags (uint32 oldFlags, uint& weightCount);

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

    // Force non resident memory
    void        restaureNonResidentMemory();

private:

    // Type of data stored in each value
    uint8                   _Type[NumValue];    // Offset 0 : aligned
    uint8                   _VertexColorFormat; // Offset 13 : aligned

    // Size of the vertex (sum of the size of each value
    uint16                  _VertexSize;        // Offset 14 : aligned

    // Flags: bit #n is 1 if the value #n is used
    uint16                  _Flags;             // Offset 16 : aligned

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

    // Vertex count in the buffer
    uint32                  _NbVerts;           // Offset 20 : aligned

    // Capacity of the buffer
    uint32                  _Capacity;

    // Vertex array
    std::vector<uint8>      _NonResidentVertices;

    // The locked vertex buffer
    mutable uint8*          _LockedBuffer;

    // Offset of each value
    uint16                  _Offset[NumValue];

    // The UV routing table
    uint8                   _UVRouting[MaxStage];

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

    // Prefered memory
    TPreferredMemory        _PreferredMemory;

    // Location of the buffer
    TLocation               _Location;

    // Resident buffer size
    uint32                  _ResidentSize;

    // Debug string
    std::string             _Name;

    // Keep in local memory
    bool                    _KeepLocalMemory;
};

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

public:
    CRefPtr<CVertexBuffer>  VertexBufferPtr;

    IVBDrvInfos(IDriver *drv, ItVBDrvInfoPtrList it, CVertexBuffer *vb) {_Driver= drv; _DriverIterator= it; VertexBufferPtr=vb;}

    virtual uint8   *lock (uint begin, uint end, bool readOnly) =0;

    virtual void    unlock (uint begin, uint end) =0;

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

class CVertexBufferReadWrite
{
public:
    friend class CVertexBuffer;

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

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

    /* Set a value into the vertex buffer. */
    inline void             setVertexCoord(uint idx, float x, float y, float z);
    inline void             setVertexCoord(uint idx, const CVector &v);
    inline void             setNormalCoord(uint idx, const CVector &v);
    inline void             setTexCoord(uint idx, uint8 stage, float u, float v);
    inline void             setTexCoord(uint idx, uint8 stage, const CUV &uv);
    inline void             setColor(uint idx, CRGBA rgba);
    inline void             setSpecular(uint idx, CRGBA rgba);
    inline void             setWeight(uint idx, uint8 wgt, float w);
    inline void             setPaletteSkin(uint idx, CPaletteSkin ps);
    inline void             setValueFloat1Ex (CVertexBuffer::TValue valueId, uint idx, float value);
    inline void             setValueFloat2Ex (CVertexBuffer::TValue valueId, uint idx, float x, float y);
    inline void             setValueFloat3Ex (CVertexBuffer::TValue valueId, uint idx, float x, float y, float z);
    inline void             setValueFloat3Ex (CVertexBuffer::TValue valueId, uint idx, const CVector& vector);
    inline void             setValueFloat4Ex (CVertexBuffer::TValue valueId, uint idx, float x, float y, float z, float w);
    inline void             setValueUChar4Ex (CVertexBuffer::TValue valueId, uint idx, CRGBA rgba);

    NLMISC::CVector*        getVertexCoordPointer(uint idx=0);
    NLMISC::CVector*        getNormalCoordPointer(uint idx=0);
    NLMISC::CUV*            getTexCoordPointer(uint idx=0, uint8 stage=0);
    void*                   getColorPointer(uint idx=0);
    void*                   getSpecularPointer(uint idx=0);
    float*                  getWeightPointer(uint idx=0, uint8 wgt=0);
    CPaletteSkin*           getPaletteSkinPointer(uint idx=0);
    void*                   getValueEx (CVertexBuffer::TValue valueId, uint idx=0) { nlassert (_Parent->checkLockedBuffer()); nlassert (_Parent->_Flags & (1<<valueId));    return (void*)(_Parent->_LockedBuffer+idx*_Parent->_VertexSize+_Parent->getValueOffEx (valueId)); }

    void                    touchVertices (uint first, uint last);

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

private:

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

    CVertexBuffer       *_Parent;
    uint                _First, _Last;
};

class CVertexBufferRead
{
public:
    friend class CVertexBuffer;

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

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

    const NLMISC::CVector*  getVertexCoordPointer(uint idx=0) const;
    const NLMISC::CVector*  getNormalCoordPointer(uint idx=0) const;
    const NLMISC::CUV*      getTexCoordPointer(uint idx=0, uint8 stage=0) const;
    const void*             getColorPointer(uint idx=0) const;
    const void*             getSpecularPointer(uint idx=0) const;
    const float*            getWeightPointer(uint idx=0, uint8 wgt=0) const;
    const CPaletteSkin*     getPaletteSkinPointer(uint idx=0) const;
    const void*             getValueEx (CVertexBuffer::TValue valueId, uint idx=0) const { nlassert (_Parent->_Flags & (1<<valueId));   return (void*)(_Parent->_LockedBuffer+idx*_Parent->_VertexSize+_Parent->getValueOffEx (valueId)); }

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

private:

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

    const CVertexBuffer     *_Parent;
};

// implementation of inline methods //
// --------------------------------------------------

inline void CVertexBufferReadWrite::setVertexCoord(uint idx, float x, float y, float z)
{
    float*  ptr;

    nlassert (_Parent->checkLockedBuffer());
    nlassert (_Parent->_Flags & CVertexBuffer::PositionFlag);
    nlassert (_Parent->_Type[CVertexBuffer::Position]==CVertexBuffer::Float3);

    ptr=(float*)(&_Parent->_LockedBuffer[idx*_Parent->_VertexSize]);
    *ptr=x;
    ptr++;
    *ptr=y;
    ptr++;
    *ptr=z;
}

// --------------------------------------------------

inline void CVertexBufferReadWrite::setVertexCoord(uint idx, const CVector &v)
{
    uint8*  ptr;

    nlassert (_Parent->checkLockedBuffer());
    nlassert (_Parent->_Flags & CVertexBuffer::PositionFlag);
    nlassert (_Parent->_Type[CVertexBuffer::Position]==CVertexBuffer::Float3);

    ptr=&_Parent->_LockedBuffer[idx*_Parent->_VertexSize];
    memcpy(ptr, &(v.x), 3*sizeof(float));
}

// --------------------------------------------------

inline void CVertexBufferReadWrite::setNormalCoord(uint idx, const CVector &v)
{
    uint8*  ptr;

    nlassert (_Parent->checkLockedBuffer());
    nlassert (_Parent->_Flags & CVertexBuffer::NormalFlag);
    nlassert (_Parent->_Type[CVertexBuffer::Normal]==CVertexBuffer::Float3);

    ptr=&_Parent->_LockedBuffer[idx*_Parent->_VertexSize];
    ptr+=_Parent->_Offset[CVertexBuffer::Normal];
    memcpy(ptr, &(v.x), 3*sizeof(float));
}

// --------------------------------------------------

inline void CVertexBufferReadWrite::setColor(uint idx, CRGBA rgba)
{
    uint8*  ptr;

    nlassert (_Parent->checkLockedBuffer());
    nlassert(_Parent->_Flags & CVertexBuffer::PrimaryColorFlag);
    nlassert (_Parent->_Type[CVertexBuffer::PrimaryColor]==CVertexBuffer::UChar4);

    ptr=(uint8*)(&_Parent->_LockedBuffer[idx*_Parent->_VertexSize]);
    ptr+=_Parent->_Offset[CVertexBuffer::PrimaryColor];
    if (_Parent->getVertexColorFormat () == CVertexBuffer::TRGBA)
        *(CRGBA*)ptr = rgba;
    else
        *(CBGRA*)ptr = rgba;
}

// --------------------------------------------------

inline void CVertexBufferReadWrite::setSpecular(uint idx, CRGBA rgba)
{
    uint8*  ptr;

    nlassert (_Parent->checkLockedBuffer());
    nlassert(_Parent->_Flags & CVertexBuffer::SecondaryColorFlag);
    nlassert (_Parent->_Type[CVertexBuffer::SecondaryColor]==CVertexBuffer::UChar4);

    ptr=(uint8*)(&_Parent->_LockedBuffer[idx*_Parent->_VertexSize]);
    ptr+=_Parent->_Offset[CVertexBuffer::SecondaryColor];
    if (_Parent->getVertexColorFormat () == CVertexBuffer::TRGBA)
        *(CRGBA*)ptr = rgba;
    else
        *(CBGRA*)ptr = rgba;
}

// --------------------------------------------------

inline void CVertexBufferReadWrite::setTexCoord(uint idx, uint8 stage, float u, float v)
{
    uint8*  ptr;
    float*  ptrf;

    nlassert (_Parent->checkLockedBuffer());
    nlassert(stage<CVertexBuffer::MaxStage);
    nlassert(_Parent->_Flags & (CVertexBuffer::TexCoord0Flag<<stage));
    nlassert (_Parent->_Type[CVertexBuffer::TexCoord0+stage]==CVertexBuffer::Float2);

    ptr=(uint8*)(&_Parent->_LockedBuffer[idx*_Parent->_VertexSize]);
    ptr+=_Parent->_Offset[CVertexBuffer::TexCoord0+stage];
    ptrf=(float*)ptr;
    *ptrf=u;
    ptrf++;
    *ptrf=v;
}

// --------------------------------------------------

inline void CVertexBufferReadWrite::setTexCoord(uint idx, uint8 stage, const CUV &uv)
{
    uint8*  ptr;
    CUV*    ptruv;

    nlassert (_Parent->checkLockedBuffer());
    nlassert(stage<CVertexBuffer::MaxStage);
    nlassert(_Parent->_Flags & (CVertexBuffer::TexCoord0Flag<<stage));
    nlassert (_Parent->_Type[CVertexBuffer::TexCoord0+stage]==CVertexBuffer::Float2);

    ptr=(uint8*)(&_Parent->_LockedBuffer[idx*_Parent->_VertexSize]);
    ptr+=_Parent->_Offset[CVertexBuffer::TexCoord0+stage];
    ptruv=(CUV*)ptr;
    *ptruv=uv;
}


// --------------------------------------------------

inline void CVertexBufferReadWrite::setWeight(uint idx, uint8 wgt, float w)
{
    uint8*  ptr;
    float*  ptrf;

    nlassert (_Parent->checkLockedBuffer());
    nlassert(wgt<CVertexBuffer::MaxWeight);
    nlassert(_Parent->_Flags & (CVertexBuffer::WeightFlag));

    ptr=(uint8*)(&_Parent->_LockedBuffer[idx*_Parent->_VertexSize]);
    ptr+=_Parent->_Offset[CVertexBuffer::Weight]+sizeof(float)*wgt;
    ptrf=(float*)ptr;
    *ptrf=w;
}

// --------------------------------------------------

inline void CVertexBufferReadWrite::setPaletteSkin(uint idx, CPaletteSkin ps)
{
    uint8*  ptr;
    CPaletteSkin    *pPalSkin;

    nlassert (_Parent->checkLockedBuffer());
    nlassert ( (_Parent->_Flags & CVertexBuffer::PaletteSkinFlag) == CVertexBuffer::PaletteSkinFlag);
    nlassert (_Parent->_Type[CVertexBuffer::PaletteSkin]==CVertexBuffer::UChar4);

    ptr=(uint8*)(&_Parent->_LockedBuffer[idx*_Parent->_VertexSize]);
    ptr+=_Parent->_Offset[CVertexBuffer::PaletteSkin];
    pPalSkin= (CPaletteSkin*)ptr;
    *pPalSkin= ps;
}

// --------------------------------------------------

inline void CVertexBufferReadWrite::setValueFloat1Ex (CVertexBuffer::TValue valueId, uint idx, float value)
{
    uint8*  ptr;
    float*  ptrf;

    nlassert (_Parent->checkLockedBuffer());
    nlassert(valueId<CVertexBuffer::NumValue);
    nlassert(_Parent->_Flags & (1<<(uint)valueId));
    nlassert((_Parent->_Type[valueId]==CVertexBuffer::Float4)||(_Parent->_Type[valueId]==CVertexBuffer::Float3)||(_Parent->_Type[valueId]==CVertexBuffer::Float2)||(_Parent->_Type[valueId]==CVertexBuffer::Float1));

    ptr=(uint8*)(&_Parent->_LockedBuffer[idx*_Parent->_VertexSize]);
    ptr+=_Parent->_Offset[valueId];
    ptrf=(float*)ptr;
    *ptrf=value;
}

// --------------------------------------------------

inline void CVertexBufferReadWrite::setValueFloat2Ex (CVertexBuffer::TValue valueId, uint idx, float x, float y)
{
    uint8*  ptr;
    float*  ptrf;

    nlassert (_Parent->checkLockedBuffer());
    nlassert(valueId<CVertexBuffer::NumValue);
    nlassert(_Parent->_Flags & (1<<(uint)valueId));
    nlassert((_Parent->_Type[valueId]==CVertexBuffer::Float4)||(_Parent->_Type[valueId]==CVertexBuffer::Float3)||(_Parent->_Type[valueId]==CVertexBuffer::Float2));

    ptr=(uint8*)(&_Parent->_LockedBuffer[idx*_Parent->_VertexSize]);
    ptr+=_Parent->_Offset[valueId];
    ptrf=(float*)ptr;
    ptrf[0]=x;
    ptrf[1]=y;
}

// --------------------------------------------------

inline void CVertexBufferReadWrite::setValueFloat3Ex (CVertexBuffer::TValue valueId, uint idx, float x, float y, float z)
{
    uint8*  ptr;
    float*  ptrf;

    nlassert (_Parent->checkLockedBuffer());
    nlassert(valueId<CVertexBuffer::NumValue);
    nlassert(_Parent->_Flags & (1<<(uint)valueId));
    nlassert((_Parent->_Type[valueId]==CVertexBuffer::Float4)||(_Parent->_Type[valueId]==CVertexBuffer::Float3));

    ptr=(uint8*)(&_Parent->_LockedBuffer[idx*_Parent->_VertexSize]);
    ptr+=_Parent->_Offset[valueId];
    ptrf=(float*)ptr;
    ptrf[0]=x;
    ptrf[1]=y;
    ptrf[2]=z;
}

// --------------------------------------------------

inline void CVertexBufferReadWrite::setValueFloat3Ex (CVertexBuffer::TValue valueId, uint idx, const NLMISC::CVector& theVector)
{
    uint8*  ptr;
    float*  ptrf;

    nlassert (_Parent->checkLockedBuffer());
    nlassert(valueId<CVertexBuffer::NumValue);
    nlassert(_Parent->_Flags & (1<<(uint)valueId));
    nlassert((_Parent->_Type[valueId]==CVertexBuffer::Float4)||(_Parent->_Type[valueId]==CVertexBuffer::Float3));

    ptr=(uint8*)(&_Parent->_LockedBuffer[idx*_Parent->_VertexSize]);
    ptr+=_Parent->_Offset[valueId];
    ptrf=(float*)ptr;
    memcpy (ptrf, &theVector, sizeof(float)*3);
}

// --------------------------------------------------

inline void CVertexBufferReadWrite::setValueFloat4Ex (CVertexBuffer::TValue valueId, uint idx, float x, float y, float z, float w)
{
    uint8*  ptr;
    float*  ptrf;

    nlassert (_Parent->checkLockedBuffer());
    nlassert(valueId<CVertexBuffer::NumValue);
    nlassert(_Parent->_Flags & (1<<(uint)valueId));
    nlassert(_Parent->_Type[valueId]==CVertexBuffer::Float4);

    ptr=(uint8*)(&_Parent->_LockedBuffer[idx*_Parent->_VertexSize]);
    ptr+=_Parent->_Offset[valueId];
    ptrf=(float*)ptr;
    ptrf[0]=x;
    ptrf[1]=y;
    ptrf[2]=z;
    ptrf[3]=w;
}

// --------------------------------------------------

inline void CVertexBufferReadWrite::setValueUChar4Ex (CVertexBuffer::TValue valueId, uint idx, CRGBA rgba)
{
    uint8*  ptr;
    CRGBA*  ptrr;

    nlassert (_Parent->checkLockedBuffer());
    nlassert(valueId<CVertexBuffer::NumValue);
    nlassert(_Parent->_Flags & (1<<(uint)valueId));
    nlassert(_Parent->_Type[valueId]==CVertexBuffer::UChar4);

    ptr=(uint8*)(&_Parent->_LockedBuffer[idx*_Parent->_VertexSize]);
    ptr+=_Parent->_Offset[valueId];
    ptrr=(CRGBA*)ptr;
    *ptrr=rgba;
}

// --------------------------------------------------

inline void CVertexBuffer::lock (CVertexBufferReadWrite &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 = _NbVerts;
            _LockedBuffer = DrvInfos->lock (first*_VertexSize, last*_VertexSize, false);
        }
        else
        {
            if (_NonResidentVertices.empty())
                _LockedBuffer = NULL;
            else
                _LockedBuffer = &(_NonResidentVertices[0]);
        }
    }
    else
        nlassert ((first==0)&&(last==0));

    _LockCounter++;
}

// --------------------------------------------------

inline void CVertexBuffer::lock (CVertexBufferRead &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 = _NbVerts;
            // Can read it ?
            nlassertex (_Location==RAMResident, ("Try to read a write only vertex buffer"));
            _LockedBuffer = DrvInfos->lock (first*_VertexSize, last*_VertexSize, true);
        }
        else
        {
            if (_NonResidentVertices.empty())
                _LockedBuffer = NULL;
            else
                _LockedBuffer = const_cast<uint8*>(&(_NonResidentVertices[0]));
        }
    }
    else
        nlassert ((first==0)&&(last==0));

    _LockCounter++;
}

// --------------------------------------------------

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

    if (_LockCounter)
        _LockCounter--;

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

        _LockedBuffer = NULL;
    }
}

// --------------------------------------------------

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

    if (_LockCounter)
        _LockCounter--;

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

        _LockedBuffer = NULL;
    }
}

// --------------------------------------------------

} // NL3D


#endif // NL_VERTEX_BUFFER_H

/* End of vertex_buffer.h */