cDXBuffer.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cDXBuffer_H
#define _INC_cDXBuffer_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cDXBase.h"
#include <GrayLib/include/Math/cVector.h>
 
#ifdef USE_DX9
 
namespace Gray3D
{
        template <class _TYPE_VERT = cVector3f>
        class GRAY3D_LINK cDXBufferVertexT
        {
        private:
                _TYPE_VERT* m_pVertex;          
                IDirect3DVertexBuffer9* m_pIVertexBuffer;       
 
        public:
                cDXBufferVertexT(IDirect3DVertexBuffer9* pIVertexBuffer)
                        : m_pIVertexBuffer(pIVertexBuffer)
                        , m_pVertex(nullptr)
                {
                }
                cDXBufferVertexT(IDirect3DVertexBuffer9* pIVertexBuffer, UINT uStart, UINT uQtyToLock, DWORD dwFlags = 0)
                        : m_pIVertexBuffer(pIVertexBuffer)
                        , m_pVertex(nullptr)
                {
                        ASSERT(m_pIVertexBuffer != nullptr);
                        Lock(uStart, uQtyToLock, dwFlags);
                }
                ~cDXBufferVertexT()
                {
                        Unlock();
                }
                bool isLockValid() const noexcept
                {
                        return m_pVertex != nullptr;
                }
                HRESULT LockStride(size_t nVertStride = sizeof(cVector3f), UINT uStart = 0, UINT uQtyToLock = 0, DWORD dwFlags = 0)
                {
                        ASSERT(m_pIVertexBuffer != nullptr);
                        HRESULT hRes = m_pIVertexBuffer->Lock(uStart,
                                uQtyToLock*nVertStride,
                                reinterpret_cast<void**>(&m_pVertex),
                                dwFlags);
                        if (FAILED(hRes))
                        {
                                DEBUG_ERR(("Lock vertex buffer FAIL ERR='%s'", LOGERR(hRes)));
                                m_pVertex = nullptr;
                        }
                        return hRes;
                }
                HRESULT Lock(UINT uStart = 0, UINT uQtyToLock = 0, DWORD dwFlags = 0)
                {
                        return LockStride(sizeof(_TYPE_VERT), uStart, uQtyToLock, dwFlags);
                }
                void Unlock()
                {
                        if (m_pVertex != nullptr)
                        {
                                ASSERT(m_pIVertexBuffer != nullptr);
                                m_pVertex = nullptr;
                                ASSERT(m_pIVertexBuffer != nullptr);
                                m_pIVertexBuffer->Unlock();
                        }
                }
                operator _TYPE_VERT* () const
                {
                        ASSERT(m_pVertex != nullptr);
                        return m_pVertex;
                }
                _TYPE_VERT* get_VertexPtr() const
                {
                        ASSERT(m_pVertex != nullptr);
                        return m_pVertex;
                }
        };
 
        template <typename _TYPE_INDEX = WORD>
        class GRAY3D_LINK cDXBufferIndexT
        {
        private:
                _TYPE_INDEX* m_pIndex;          
                IDirect3DIndexBuffer9* m_pIIndexBuffer;         
        public:
                cDXBufferIndexT(IDirect3DIndexBuffer9* pIIndexBuffer)
                        : m_pIIndexBuffer(pIIndexBuffer)
                        , m_pIndex(nullptr)
                {
                }
                cDXBufferIndexT(IDirect3DIndexBuffer9* pIIndexBuffer, UINT uStart, UINT uQtyToLock, DWORD dwFlags = 0)
                        : m_pIIndexBuffer(pIIndexBuffer)
                        , m_pIndex(nullptr)
                {
                        Lock(uStart, uQtyToLock, dwFlags);
                }
                ~cDXBufferIndexT()
                {
                        Unlock();
                }
                bool isLockValid() const noexcept
                {
                        return m_pIndex != nullptr;
                }
                HRESULT Lock(UINT uStart = 0, UINT uQtyToLock = 0, DWORD dwFlags = 0)
                {
                        ASSERT(m_pIIndexBuffer != nullptr);
                        HRESULT hRes = m_pIIndexBuffer->Lock(uStart,
                                uQtyToLock * sizeof(_TYPE_INDEX),
                                reinterpret_cast<void**>(&m_pIndex),
                                dwFlags);
                        if (FAILED(hRes))
                        {
                                DEBUG_ERR(("Lock index buffer FAIL ERR='%s'", LOGERR(hRes)));
                                m_pIndex = nullptr;
                        }
                        return hRes;
                }
                void Unlock()
                {
                        if (m_pIndex != nullptr)
                        {
                                ASSERT(m_pIIndexBuffer != nullptr);
                                m_pIndex = nullptr;
                                ASSERT(m_pIIndexBuffer != nullptr);
                                m_pIIndexBuffer->Unlock();
                        }
                }
                _TYPE_INDEX GetIndex(int i) const
                {
                        ASSERT(m_pIndex != nullptr);
                        ASSERT(i >= 0);                 
                        return m_pIndex[i];
                }
                void SetIndex(int i, _TYPE_INDEX wVal)
                {
                        ASSERT(m_pIndex != nullptr);
                        ASSERT(i >= 0);                 
                        m_pIndex[i] = wVal;
                }
                _TYPE_INDEX* get_IndexPtr() const
                {
                        ASSERT(m_pIndex != nullptr);
                        return m_pIndex;
                }
                operator _TYPE_INDEX* () const
                {
                        ASSERT(m_pIndex != nullptr);
                        return m_pIndex;
                }
        };
 
        //*****************************************************************
 
        class GRAY3D_LINK cDXVertexBatch
        {
 
        public:
                const DWORD m_dwMaxObjects;             
                const DWORD m_dwChunkObjects;   
                const size_t m_nVertStride;             
 
                UINT m_uiLockBase;                              
                cIUnkPtr<IDirect3DVertexBuffer9>        m_pVB;
                void* m_pVerticesLocked;                
 
        public:
                cDXVertexBatch(DWORD dwMaxObjects, DWORD dwChunkObjects, size_t nVertStride)
                        : m_dwMaxObjects(dwMaxObjects)
                        , m_dwChunkObjects(dwChunkObjects)
                        , m_nVertStride(nVertStride)    // bytes
                        , m_uiLockBase(dwMaxObjects)
                        , m_pVerticesLocked(nullptr)
                {
                        ASSERT(m_dwChunkObjects < m_dwMaxObjects);
                        ASSERT(nVertStride);
                }
                ~cDXVertexBatch() noexcept
                {
                }
 
                HRESULT CreateBuffer(IDirect3DDevice9* pDevice);
 
                void OnLostDeviceX()
                {
                        m_pVB.ReleasePtr();
                }
 
                void* GetNextChunk();
 
                void RenderPrepare(DWORD dwObjects)
                {
                        ASSERT(dwObjects <= m_dwChunkObjects);
                        if (m_pVerticesLocked == nullptr)
                        {
                                ASSERT(!dwObjects);
                                return;
                        }
                        m_pVerticesLocked = nullptr;
                        m_pVB->Unlock();
                }
        };
 
        class GRAY3D_LINK cDXVertexBillboards : public cDXVertexBatch
        {
 
                typedef cDXVertexBatch SUPER_t;
 
        public:
                static const int k_VERTICES = 4;        
                static const int k_INDEXES = 6;         
 
        public:
                cDXVertexBillboards(DWORD dwMaxObjects, DWORD dwChunkObjects, size_t nVertStride)
                        : cDXVertexBatch(dwMaxObjects, dwChunkObjects, nVertStride)
                {}
 
                HRESULT CreateBuffer(ID3DDevice* pDevice);
                HRESULT RenderChunk(ID3DDevice* pDevice, UINT dwObjects);
                void* RenderChunkFull(ID3DDevice* pDevice);
        };
};
 
#endif // USE_DX9
#endif // _INC_cDXBuffer_H