driver_opengl_vertex_buffer_hard.h

Go to the documentation of this file.

/* Copyright, 2000-2002 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_DRIVER_OPENGL_VERTEX_BUFFER_HARD_H
#define NL_DRIVER_OPENGL_VERTEX_BUFFER_HARD_H

#include "nel/misc/types_nl.h"


namespace NL3D
{


class   CDriverGL;
class   IVertexBufferHardGL;
class   CVertexBufferInfo;
class   CVertexBufferHardGLMapObjectATI;
class   CVertexBufferHardARB;



// ***************************************************************************
// ***************************************************************************
// VBHard interface for both NVidia / ATI extension.
// ***************************************************************************
// ***************************************************************************




// ***************************************************************************
class IVertexArrayRange
{
public:
    IVertexArrayRange(CDriverGL *drv);
    virtual ~IVertexArrayRange();

    virtual bool                    allocate(uint32 size, CVertexBuffer::TPreferredMemory vbType)= 0;
    virtual void                    free()= 0;
    virtual IVertexBufferHardGL     *createVBHardGL(uint size, CVertexBuffer *vb) =0;
    virtual uint                    sizeAllocated() const =0;
    // Check & invalidate lost buffers. Default assume they can't be lost
    virtual void updateLostBuffers() {}
    // Get driver
    CDriverGL   *getDriver() const { return _Driver; }
    // tmp, for debug
    #ifdef NL_DEBUG
        virtual void         dumpMappedBuffers() {}
    #endif
protected:
    CDriverGL   *_Driver;
};



// ***************************************************************************
class IVertexBufferHardGL
{
public:

    IVertexBufferHardGL(CDriverGL *drv, CVertexBuffer *vb);
    virtual ~IVertexBufferHardGL();


    // ATI and NVidia have their own methods.
    virtual void        *lock() = 0;
    virtual void        unlock() = 0;
    virtual void        unlock(uint start, uint end) = 0;
    virtual void        *getPointer() = 0;

    virtual void            enable() =0;
    virtual void            disable() =0;

    virtual void        setupVBInfos(CVertexBufferInfo &vb) = 0;

    enum TVBType { NVidiaVB, ATIVB, ATIMapObjectVB, ARBVB, UnknownVB };
    // true if NVidia vertex buffer hard.
    TVBType  VBType;
    // For Fence access. Ignored for ATI.
    bool                GPURenderingAfterFence;

    // test if buffer content is invalid. If so, no rendering should occurs (rendering should silently fail)
    bool                            isInvalid() { return _Invalid; }

public:

    CVertexBuffer       *VB;

protected:
    CDriverGL           *_Driver;
    bool         _Invalid;
};



// ***************************************************************************
// ***************************************************************************
// NVidia implementation
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
class CVertexArrayRangeNVidia : public IVertexArrayRange
{
public:
    CVertexArrayRangeNVidia(CDriverGL *drv);


    // @{
    virtual bool                    allocate(uint32 size, CVertexBuffer::TPreferredMemory vbType);
    virtual void                    free();
    virtual IVertexBufferHardGL     *createVBHardGL(uint size, CVertexBuffer *vb);
    virtual uint                    sizeAllocated() const;
    // @}


    // Those methods read/write in _Driver->_CurrentVertexArrayRange.
    void            enable();
    void            disable();

    void            freeVB(void *ptr);


// *************************
private:
    void        *_VertexArrayPtr;
    uint32      _VertexArraySize;

    // Allocator.
    NLMISC::CHeapMemory     _HeapMemory;

    bool            allocated() const {return _VertexArrayPtr!=NULL;}
    void            *allocateVB(uint32 size);

};



// ***************************************************************************
class CVertexBufferHardGLNVidia : public IVertexBufferHardGL
{
public:

    CVertexBufferHardGLNVidia(CDriverGL *drv, CVertexBuffer *vb);
    virtual ~CVertexBufferHardGLNVidia();


    // @{
    virtual void        *lock();
    virtual void        unlock();
    virtual void        unlock(uint start, uint end);
    virtual void        *getPointer();
    virtual void        enable();
    virtual void        disable();
    virtual void        lockHintStatic(bool staticLock);
    virtual void        setupVBInfos(CVertexBufferInfo &vb);
    // @}


    // setup ptrs allocated by createVBHard(), and init Fence.
    void                    initGL(CVertexArrayRangeNVidia *var, void *vertexPtr);


    // true if a setFence() has been done, without a finishFence(). NB: not the same thing as nglTestFenceNV()!!
    bool            isFenceSet() const {return _FenceSet;}
    // set or re-set the fence, whatever isFenceSet().
    void            setFence();
    // if(isFenceSet()), finish the fence, else no-op
    void            finishFence();
    // if fence is not set, no-op, else test nglTestFenceNV(), and update local _FenceSet flag.
    void            testFence();

    bool            getLockHintStatic() const {return _LockHintStatic;}

// *************************
private:
    CVertexArrayRangeNVidia     *_VertexArrayRange;
    void                        *_VertexPtr;

    // The fence inserted in command stream
    GLuint              _Fence;
    // True if a setFence() has been done, without a finishFence().
    bool                _FenceSet;

    bool                _LockHintStatic;

};



// ***************************************************************************
// ***************************************************************************
// ATI implementation
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
// This is a fake value to simulate allocation on CHeapMemory for ATI mgt.
// NB: can set 0, since won't work for multiple reasons....
#define NL3D_DRV_ATI_FAKE_MEM_START 0x10000


// ***************************************************************************
class CVertexArrayRangeATI : public IVertexArrayRange
{
public:
    CVertexArrayRangeATI(CDriverGL *drv);


    // @{
    virtual bool                    allocate(uint32 size, CVertexBuffer::TPreferredMemory vbType);
    virtual void                    free();
    virtual IVertexBufferHardGL     *createVBHardGL(uint size, CVertexBuffer *vb);
    virtual uint                    sizeAllocated() const;
    // @}


    // Those methods read/write in _Driver->_CurrentVertexArrayRange.
    void            enable();
    void            disable();

    void            freeVB(void *ptr);


    uint            getATIVertexObjectId() const {return _VertexObjectId;}

// *************************
private:
    uint        _VertexObjectId;
    bool        _Allocated;
    uint32      _VertexArraySize;

    // Allocator. NB: We don't have any Mem Ptr For ATI extension, so use a Fake Ptr: NL3D_DRV_ATI_FAKE_MEM_START
    NLMISC::CHeapMemory     _HeapMemory;

    void            *allocateVB(uint32 size);

};




// ***************************************************************************
class CVertexBufferHardGLATI : public IVertexBufferHardGL
{
public:

    CVertexBufferHardGLATI(CDriverGL *drv, CVertexBuffer *vb);
    virtual ~CVertexBufferHardGLATI();


    // @{
    virtual void        *lock();
    virtual void        unlock();
    virtual void        unlock(uint start, uint end);
    virtual void        *getPointer();
    virtual void        enable();
    virtual void        disable();
    virtual void        lockHintStatic(bool staticLock);
    virtual void        setupVBInfos(CVertexBufferInfo &vb);
    // @}


    bool                    createRAMMirror(uint memSize);

    void                    initGL(CVertexArrayRangeATI *var, void *vertexPtr);


public:

    uint                    getATIVertexObjectId() const {return _VertexArrayRange->getATIVertexObjectId();}


// *************************
private:
    CVertexArrayRangeATI        *_VertexArrayRange;
    void                        *_VertexPtr;
    void                        *_RAMMirrorVertexPtr;
    uint                        _RAMMirrorVertexSize;

};



class CVertexArrayRangeMapObjectATI : public IVertexArrayRange
{
public:
    CVertexArrayRangeMapObjectATI(CDriverGL *drv);


    // @{
    virtual bool                    allocate(uint32 size, CVertexBuffer::TPreferredMemory vbType);
    virtual void                    free();
    virtual IVertexBufferHardGL     *createVBHardGL(uint size, CVertexBuffer *vb);
    virtual uint                    sizeAllocated() const { return _SizeAllocated; }
    // @}


    // Those methods read/write in _Driver->_CurrentVertexArrayRange.
    void            enable();
    void            disable();

    CVertexBuffer::TPreferredMemory getVBType() const { return _VBType; }

    // check & invalidate lost buffers
    void updateLostBuffers();

    // tmp for debug
    #ifdef NL_DEBUG
        void dumpMappedBuffers();
    #endif

// *************************
private:
    CVertexBuffer::TPreferredMemory _VBType;
    uint32               _SizeAllocated;
public:
    // for use by CVertexBufferHardGLMapObjectATI
    std::list<CVertexBufferHardGLMapObjectATI *> _LostVBList;
    #ifdef NL_DEBUG
        std::list<CVertexBufferHardGLMapObjectATI *> _MappedVBList;
    #endif
};


class CVertexBufferHardGLMapObjectATI : public IVertexBufferHardGL
{
public:

    CVertexBufferHardGLMapObjectATI(CDriverGL *drv, CVertexBuffer *vb);
    virtual ~CVertexBufferHardGLMapObjectATI();


    // @{
    virtual void        *lock();
    virtual void        unlock();
    virtual void        unlock(uint start, uint end);
    virtual void        *getPointer();
    virtual void        enable();
    virtual void        disable();
    virtual void        lockHintStatic(bool staticLock);
    virtual void        setupVBInfos(CVertexBufferInfo &vb);
    // @}

    void                    initGL(CVertexArrayRangeMapObjectATI *var, uint vertexObjectID);


public:

    uint                    getATIVertexObjectId() const { return _VertexObjectId;}


// *************************
private:
    void                           *_VertexPtr; // pointer on current datas. Null if not locked
    CVertexArrayRangeMapObjectATI  *_VertexArrayRange;
    // if buffer has been invalidated, returns a dummy memory block and silently fails rendering
    std::vector<uint8>              _DummyVB;
    // Invalidate the buffer (when it is lost, or when a lock fails)
    void                            invalidate();
public:
    // for use by CVertexArrayRangeMapObjectATI
    std::list<CVertexBufferHardGLMapObjectATI *>::iterator _IteratorInLostVBList;
    uint                           _VertexObjectId;
    // tmp for debug
    #ifdef NL_DEBUG
        bool                            _Unmapping;
        std::list<CVertexBufferHardGLMapObjectATI *>::iterator _IteratorInMappedVBList;
    #endif
};

// ***************************************************************************
// ***************************************************************************
// ARB_vertex_buffer_object implementation
// ***************************************************************************
// ***************************************************************************
class CVertexArrayRangeARB : public IVertexArrayRange
{
public:
    CVertexArrayRangeARB(CDriverGL *drv);


    // @{
    virtual bool                    allocate(uint32 size, CVertexBuffer::TPreferredMemory vbType);
    virtual void                    free();
    virtual IVertexBufferHardGL     *createVBHardGL(uint size, CVertexBuffer *vb);
    virtual uint                    sizeAllocated() const { return _SizeAllocated; }
    // @}


    // Those methods read/write in _Driver->_CurrentVertexArrayRange.
    void            enable();
    void            disable();
    // check & invalidate lost buffers
    void updateLostBuffers();
    //
    #ifdef NL_DEBUG
        virtual void         dumpMappedBuffers();
    #endif
// *************************
private:
    CVertexBuffer::TPreferredMemory _VBType;
    uint32                          _SizeAllocated;
    // for use by CVertexBufferHardARB
public:
    std::list<CVertexBufferHardARB *> _LostVBList;
    #ifdef NL_DEBUG
        std::list<CVertexBufferHardARB *> _MappedVBList;
    #endif
};


class CVertexBufferHardARB : public IVertexBufferHardGL
{
public:

    CVertexBufferHardARB(CDriverGL *drv, CVertexBuffer *vb);
    virtual ~CVertexBufferHardARB();


    // @{
    virtual void        *lock();
    virtual void        unlock();
    virtual void        unlock(uint startVert, uint endVert);
    virtual void        *getPointer();
    virtual void        enable();
    virtual void        disable();
    virtual void        lockHintStatic(bool staticLock);
    virtual void        setupVBInfos(CVertexBufferInfo &vb);
    // @}

    void                    initGL(uint vertexObjectID, CVertexArrayRangeARB *var, CVertexBuffer::TPreferredMemory memType);


public:

    uint                    getARBVertexObjectId() const { return _VertexObjectId;}

    // Invalidate the buffer (when it is lost, or when a lock fails)
    void                            invalidate();

    // tmp
    void checkMappedVBList();

// *************************
private:
    CVertexArrayRangeARB            *_VertexArrayRange;
    CVertexBuffer::TPreferredMemory _MemType;
    void                            *_VertexPtr; // pointer on current datas. Null if not locked
    // if buffer has been invalidated, returns a dummy memory block and silently fails rendering
    std::vector<uint8>              _DummyVB;
    // for use by CVertexArrayRangeARB
    std::list<CVertexBufferHardARB *>::iterator _IteratorInLostVBList;
public:
    uint                            _VertexObjectId;
    // tmp for debug
    #ifdef NL_DEBUG
        bool _Unmapping;
        std::list<CVertexBufferHardARB *>::iterator _IteratorInMappedVBList;
    #endif
};


} // NL3D


#endif // NL_DRIVER_OPENGL_VERTEX_BUFFER_HARD_H

/* End of driver_opengl_vertex_buffer_hard.h */