|
|
#ifndef __VBUFFER_HPP__
#define __VBUFFER_HPP__
/*==========================================================================;
* * Copyright (C) 1999-2000 Microsoft Corporation. All Rights Reserved. * * File: vbuffer.hpp * Content: Class header the vertex buffer class * ***************************************************************************/
// Includes
#include "buffer.hpp"
// The base-class implementation of the vertex buffer assumes
// that it is resides system-memory. It may be managed.
class CVertexBuffer : public IDirect3DVertexBuffer8, public CBuffer{public: // Creation function for Vertex Buffers
static HRESULT Create(CBaseDevice *pDevice, DWORD cbLength, DWORD dwUsage, DWORD dwFVF, D3DPOOL Pool, REF_TYPE refType, IDirect3DVertexBuffer8 **ppVertexBuffer); static HRESULT CreateSysmemVertexBuffer(CBaseDevice *pDevice, DWORD cbLength, DWORD dwFVF, DWORD dwUsage, DWORD dwActualUsage, D3DPOOL Pool, D3DPOOL ActualPool, REF_TYPE refType, CVertexBuffer **pVB);
static HRESULT CreateDriverVertexBuffer(CBaseDevice *pDevice, DWORD cbLength, DWORD dwFVF, DWORD dwUsage, DWORD dwActualUsage, D3DPOOL Pool, D3DPOOL ActualPool, REF_TYPE refType, CVertexBuffer **pVB);
static HRESULT CreateDriverManagedVertexBuffer(CBaseDevice *pDevice, DWORD cbLength, DWORD dwFVF, DWORD dwUsage, DWORD dwActualUsage, D3DPOOL Pool, D3DPOOL ActualPool, REF_TYPE refType, CVertexBuffer **pVB);
// Methods for Resource Management
// Create duplicate of current object in new pool;
// LOD is ignored for our type
virtual HRESULT Clone(D3DPOOL Pool, CResource **ppResource) const;
virtual const D3DBUFFER_DESC* GetBufferDesc() const;
virtual HRESULT LockI(DWORD dwFlags) {return D3D_OK;} virtual HRESULT UnlockI() {return D3D_OK;} virtual void SetCachedDataPointer(BYTE *pData) {}
HRESULT UpdateDirtyPortion(CResource *pResourceTarget);
DWORD GetFVF() const { return m_desc.FVF; }
// IUnknown methods
STDMETHOD(QueryInterface) (REFIID riid, LPVOID FAR * ppvObj); STDMETHOD_(ULONG,AddRef) (); STDMETHOD_(ULONG,Release) ();
// Some Methods for IDirect3DBuffer
STDMETHOD(SetPrivateData)(REFGUID riid, CONST VOID *pvData, DWORD cbData, DWORD dwFlags);
STDMETHOD(GetPrivateData)(REFGUID riid, LPVOID pvData, LPDWORD pcbData);
STDMETHOD(FreePrivateData)(REFGUID riid);
STDMETHOD(GetDevice)(IDirect3DDevice8 **ppDevice); STDMETHOD_(DWORD, GetPriority)(); STDMETHOD_(DWORD, SetPriority)(DWORD dwPriority); STDMETHOD_(void, PreLoad)(); STDMETHOD_(D3DRESOURCETYPE, GetType)();
// Methods for IDirect3DVertexBuffer8
STDMETHOD(Lock)(UINT cbOffsetToLock, UINT cbSizeToLock, BYTE **ppbData, DWORD dwFlags); STDMETHOD(Unlock)(); STDMETHOD(GetDesc)(D3DVERTEXBUFFER_DESC *pDesc);
DWORD GetVertexSize() const { return m_vertsize; } DWORD GetNumVertices() const { return m_numverts; } WORD* GetClipCodes() const { return m_pClipCodes; } void AllocateClipCodes();
BYTE* Data() const { DXGASSERT(m_desc.Usage & D3DUSAGE_SOFTWAREPROCESSING); DXGASSERT(m_desc.Pool == D3DPOOL_SYSTEMMEM || m_desc.Pool == D3DPOOL_MANAGED); DXGASSERT(m_LockCount == 0); return GetPrivateDataPointer(); }
protected:
CVertexBuffer(CBaseDevice *pDevice, DWORD cbLength, DWORD dwFVF, DWORD dwUsage, DWORD dwActualUsage, D3DPOOL Pool, D3DPOOL ActualPool, REF_TYPE refType, HRESULT *phr); virtual ~CVertexBuffer() { delete[] m_pClipCodes; }
#if DBG
HRESULT ValidateLockParams(UINT cbOffsetToLock, UINT SizeToLock, BYTE **ppbData, DWORD dwFlags) const;#endif // DBG
D3DVERTEXBUFFER_DESC m_desc; DWORD m_usageUser; DWORD m_numverts; DWORD m_vertsize; WORD* m_pClipCodes;
}; // class CVertexBuffer
class CVertexBufferMT : public CVertexBuffer{public: STDMETHOD(Lock)(UINT cbOffsetToLock, UINT cbSizeToLock, BYTE **ppbData, DWORD dwFlags) { API_ENTER(Device()); return CVertexBuffer::Lock(cbOffsetToLock, cbSizeToLock, ppbData, dwFlags); }
STDMETHOD(Unlock)() { API_ENTER(Device()); return CVertexBuffer::Unlock(); }
friend CVertexBuffer;
protected:
CVertexBufferMT(CBaseDevice *pDevice, DWORD cbLength, DWORD dwFVF, DWORD Usage, DWORD ActualUsage, D3DPOOL Pool, D3DPOOL ActualPool, REF_TYPE refType, HRESULT *phr) : CVertexBuffer(pDevice, cbLength, dwFVF, Usage, ActualUsage, Pool, ActualPool, refType, phr) { }
}; // class CVertexBufferMT
// This derived version of the vertex buffer class
// overrides lock/unlock to call the driver instead
class CDriverVertexBuffer : public CVertexBuffer{public: STDMETHOD(Lock)(UINT cbOffsetToLock, UINT cbSizeToLock, BYTE **ppbData, DWORD dwFlags); STDMETHOD(Unlock)();
// Alloc CVertexBuffer to construct this object
friend CVertexBuffer;
HRESULT LockI(DWORD dwFlags); HRESULT UnlockI(); BYTE* GetCachedDataPointer() const { return m_pbData; } void SetCachedDataPointer(BYTE *pData) { m_pbData = pData; }
BYTE* Data() const { DXGASSERT(FALSE); // Direct pointer access not supported
return 0; }
protected: CDriverVertexBuffer(CBaseDevice *pDevice, DWORD cbLength, DWORD dwFVF, DWORD Usage, DWORD ActualUsage, D3DPOOL Pool, D3DPOOL ActualPool, REF_TYPE refType, HRESULT *phr); ~CDriverVertexBuffer();
BYTE* m_pbData; // stores cached pointer
}; // class CDriverVertexBuffer
class CDriverVertexBufferMT : public CDriverVertexBuffer{public: STDMETHOD(Lock)(UINT cbOffsetToLock, UINT cbSizeToLock, BYTE **ppbData, DWORD dwFlags) { API_ENTER(Device()); return CDriverVertexBuffer::Lock(cbOffsetToLock, cbSizeToLock, ppbData, dwFlags); }
STDMETHOD(Unlock)() { API_ENTER(Device()); return CDriverVertexBuffer::Unlock(); }
friend CVertexBuffer;
protected: CDriverVertexBufferMT(CBaseDevice *pDevice, DWORD cbLength, DWORD dwFVF, DWORD Usage, DWORD ActualUsage, D3DPOOL Pool, D3DPOOL ActualPool, REF_TYPE refType, HRESULT *phr) : CDriverVertexBuffer(pDevice, cbLength, dwFVF, Usage, ActualUsage, Pool, ActualPool, refType, phr) { }
}; // class CVertexBufferMT
// This derived version of the vertex buffer class
// overrides lock/unlock to call the driver instead
class CDriverManagedVertexBuffer : public CVertexBuffer{public: STDMETHOD(Lock)(UINT cbOffsetToLock, UINT cbSizeToLock, BYTE **ppbData, DWORD dwFlags); STDMETHOD(Unlock)();
HRESULT LockI(DWORD dwFlags) {return D3D_OK;} HRESULT UnlockI() {return D3D_OK;}
BYTE* Data() const { DXGASSERT(m_desc.Usage & D3DUSAGE_SOFTWAREPROCESSING); DXGASSERT((m_desc.Usage & D3DUSAGE_WRITEONLY) == 0); DXGASSERT(m_LockCount == 0); DXGASSERT(m_pbData != 0); return m_pbData; }
// Alloc CVertexBuffer to construct this object
friend CVertexBuffer;
protected: CDriverManagedVertexBuffer(CBaseDevice *pDevice, DWORD cbLength, DWORD dwFVF, DWORD Usage, DWORD ActualUsage, D3DPOOL Pool, D3DPOOL ActualPool, REF_TYPE refType, HRESULT *phr);
HRESULT UpdateCachedPointer(CBaseDevice*);
friend HRESULT CResource::RestoreDriverManagementState(CBaseDevice*);
BYTE* m_pbData; // stores cached pointer
BOOL m_bDriverCalled;
}; // class CDriverVertexBuffer
class CDriverManagedVertexBufferMT : public CDriverManagedVertexBuffer{public: STDMETHOD(Lock)(UINT cbOffsetToLock, UINT cbSizeToLock, BYTE **ppbData, DWORD dwFlags) { API_ENTER(Device()); return CDriverManagedVertexBuffer::Lock(cbOffsetToLock, cbSizeToLock, ppbData, dwFlags); }
STDMETHOD(Unlock)() { API_ENTER(Device()); return CDriverManagedVertexBuffer::Unlock(); }
// Alloc CVertexBuffer to construct this object
friend CVertexBuffer;
protected: CDriverManagedVertexBufferMT(CBaseDevice *pDevice, DWORD cbLength, DWORD dwFVF, DWORD Usage, DWORD ActualUsage, D3DPOOL Pool, D3DPOOL ActualPool, REF_TYPE refType, HRESULT *phr) : CDriverManagedVertexBuffer(pDevice, cbLength, dwFVF, Usage, ActualUsage, Pool, ActualPool, refType, phr) { }
}; // class CDriverVertexBufferMT
#endif // __VBUFFER_HPP__
|
