354 lines
12 KiB
C++
354 lines
12 KiB
C++
#ifndef __IBUFFER_HPP__
|
|
#define __IBUFFER_HPP__
|
|
|
|
/*==========================================================================;
|
|
*
|
|
* Copyright (C) 1999-2000 Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
* File: ibuffer.hpp
|
|
* Content: Class header the Index buffer class
|
|
*
|
|
***************************************************************************/
|
|
|
|
// Includes
|
|
#include "buffer.hpp"
|
|
|
|
// The base-class implementation of the Index buffer assumes
|
|
// that it is resides system-memory. It may be managed.
|
|
class CIndexBuffer : public IDirect3DIndexBuffer8, public CBuffer
|
|
{
|
|
public:
|
|
// Creation function for Index Buffers
|
|
static HRESULT Create(CBaseDevice *pDevice,
|
|
DWORD cbLength,
|
|
DWORD dwUsage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
REF_TYPE refType,
|
|
IDirect3DIndexBuffer8 **ppIndexBuffer);
|
|
|
|
static HRESULT CreateSysmemIndexBuffer(CBaseDevice *pDevice,
|
|
DWORD cbLength,
|
|
DWORD dwUsage,
|
|
DWORD dwActualUsage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
D3DPOOL ActualPool,
|
|
REF_TYPE refType,
|
|
CIndexBuffer **pIB);
|
|
|
|
static HRESULT CreateDriverIndexBuffer(CBaseDevice *pDevice,
|
|
DWORD cbLength,
|
|
DWORD dwUsage,
|
|
DWORD dwActualUsage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
D3DPOOL ActualPool,
|
|
REF_TYPE refType,
|
|
CIndexBuffer **pVB);
|
|
|
|
static HRESULT CreateDriverManagedIndexBuffer(CBaseDevice *pDevice,
|
|
DWORD cbLength,
|
|
DWORD dwUsage,
|
|
DWORD dwActualUsage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
D3DPOOL ActualPool,
|
|
REF_TYPE refType,
|
|
CIndexBuffer **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;
|
|
|
|
HRESULT UpdateDirtyPortion(CResource *pResourceTarget);
|
|
|
|
// 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 IDirect3DIndexBuffer8
|
|
STDMETHOD(Lock)(UINT cbOffsetToLock,
|
|
UINT cbSizeToLock,
|
|
BYTE **ppbData,
|
|
DWORD dwFlags);
|
|
|
|
STDMETHOD(Unlock)();
|
|
STDMETHOD(GetDesc)(D3DINDEXBUFFER_DESC *pDesc);
|
|
|
|
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:
|
|
|
|
CIndexBuffer(CBaseDevice *pDevice,
|
|
DWORD cbLength,
|
|
DWORD dwUsage,
|
|
DWORD dwActualUsage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
D3DPOOL ActualPool,
|
|
REF_TYPE refType,
|
|
HRESULT *phr);
|
|
|
|
#if DBG
|
|
HRESULT ValidateLockParams(UINT cbOffsetToLock,
|
|
UINT SizeToLock,
|
|
BYTE **ppbData,
|
|
DWORD dwFlags) const;
|
|
#endif // DBG
|
|
|
|
// Member data
|
|
D3DINDEXBUFFER_DESC m_desc;
|
|
DWORD m_usageUser;
|
|
|
|
}; // class CIndexBuffer
|
|
|
|
class CIndexBufferMT : public CIndexBuffer
|
|
{
|
|
public:
|
|
STDMETHOD(Lock)(UINT cbOffsetToLock,
|
|
UINT cbSizeToLock,
|
|
BYTE **ppbData,
|
|
DWORD dwFlags)
|
|
{
|
|
API_ENTER(Device());
|
|
return CIndexBuffer::Lock(cbOffsetToLock, cbSizeToLock, ppbData, dwFlags);
|
|
}
|
|
|
|
STDMETHOD(Unlock)()
|
|
{
|
|
API_ENTER(Device());
|
|
return CIndexBuffer::Unlock();
|
|
}
|
|
|
|
friend CIndexBuffer;
|
|
|
|
protected:
|
|
|
|
CIndexBufferMT(CBaseDevice *pDevice,
|
|
DWORD cbLength,
|
|
DWORD Usage,
|
|
DWORD ActualUsage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
D3DPOOL ActualPool,
|
|
REF_TYPE refType,
|
|
HRESULT *phr) :
|
|
CIndexBuffer(pDevice,
|
|
cbLength,
|
|
Usage,
|
|
ActualUsage,
|
|
Format,
|
|
Pool,
|
|
ActualPool,
|
|
refType,
|
|
phr)
|
|
{
|
|
}
|
|
|
|
}; // class CIndexBufferMT
|
|
|
|
// This derived version of the Index buffer class
|
|
// overrides lock/unlock to call the driver instead
|
|
class CDriverIndexBuffer : public CIndexBuffer
|
|
{
|
|
public:
|
|
STDMETHOD(Lock)(UINT cbOffsetToLock,
|
|
UINT cbSizeToLock,
|
|
BYTE **ppbData,
|
|
DWORD dwFlags);
|
|
STDMETHOD(Unlock)();
|
|
|
|
HRESULT LockI(DWORD dwFlags);
|
|
HRESULT UnlockI();
|
|
|
|
BYTE* Data() const
|
|
{
|
|
DXGASSERT(FALSE); // Direct pointer access not supported
|
|
return 0;
|
|
}
|
|
|
|
// Alloc CIndexBuffer to construct this object
|
|
friend CIndexBuffer;
|
|
|
|
protected:
|
|
CDriverIndexBuffer(CBaseDevice *pDevice,
|
|
DWORD cbLength,
|
|
DWORD Usage,
|
|
DWORD ActualUsage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
D3DPOOL ActualPool,
|
|
REF_TYPE refType,
|
|
HRESULT *phr);
|
|
~CDriverIndexBuffer();
|
|
|
|
BYTE* m_pbData; // stores cached pointer
|
|
|
|
}; // class CDriverIndexBuffer
|
|
|
|
class CDriverIndexBufferMT : public CDriverIndexBuffer
|
|
{
|
|
public:
|
|
STDMETHOD(Lock)(UINT cbOffsetToLock,
|
|
UINT cbSizeToLock,
|
|
BYTE **ppbData,
|
|
DWORD dwFlags)
|
|
{
|
|
API_ENTER(Device());
|
|
return CDriverIndexBuffer::Lock(cbOffsetToLock, cbSizeToLock, ppbData, dwFlags);
|
|
}
|
|
|
|
STDMETHOD(Unlock)()
|
|
{
|
|
API_ENTER(Device());
|
|
return CDriverIndexBuffer::Unlock();
|
|
}
|
|
|
|
friend CIndexBuffer;
|
|
|
|
protected:
|
|
CDriverIndexBufferMT(CBaseDevice *pDevice,
|
|
DWORD cbLength,
|
|
DWORD Usage,
|
|
DWORD ActualUsage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
D3DPOOL ActualPool,
|
|
REF_TYPE refType,
|
|
HRESULT *phr) :
|
|
CDriverIndexBuffer(pDevice,
|
|
cbLength,
|
|
Usage,
|
|
ActualUsage,
|
|
Format,
|
|
Pool,
|
|
ActualPool,
|
|
refType,
|
|
phr)
|
|
{
|
|
}
|
|
|
|
}; // class CIndexBufferMT
|
|
|
|
// This derived version of the Index buffer class
|
|
// overrides lock/unlock to call the driver instead
|
|
class CDriverManagedIndexBuffer : public CIndexBuffer
|
|
{
|
|
public:
|
|
STDMETHOD(Lock)(UINT cbOffsetToLock,
|
|
UINT cbSizeToLock,
|
|
BYTE **ppbData,
|
|
DWORD dwFlags);
|
|
STDMETHOD(Unlock)();
|
|
|
|
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 CIndexBuffer to construct this object
|
|
friend CIndexBuffer;
|
|
|
|
protected:
|
|
CDriverManagedIndexBuffer(CBaseDevice *pDevice,
|
|
DWORD cbLength,
|
|
DWORD Usage,
|
|
DWORD ActualUsage,
|
|
D3DFORMAT Format,
|
|
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 CDriverManagedIndexBuffer
|
|
|
|
class CDriverManagedIndexBufferMT : public CDriverManagedIndexBuffer
|
|
{
|
|
public:
|
|
STDMETHOD(Lock)(UINT cbOffsetToLock,
|
|
UINT cbSizeToLock,
|
|
BYTE **ppbData,
|
|
DWORD dwFlags)
|
|
{
|
|
API_ENTER(Device());
|
|
return CDriverManagedIndexBuffer::Lock(cbOffsetToLock, cbSizeToLock, ppbData, dwFlags);
|
|
}
|
|
|
|
STDMETHOD(Unlock)()
|
|
{
|
|
API_ENTER(Device());
|
|
return CDriverManagedIndexBuffer::Unlock();
|
|
}
|
|
|
|
// Alloc CIndexBuffer to construct this object
|
|
friend CIndexBuffer;
|
|
|
|
protected:
|
|
CDriverManagedIndexBufferMT(CBaseDevice *pDevice,
|
|
DWORD cbLength,
|
|
DWORD Usage,
|
|
DWORD ActualUsage,
|
|
D3DFORMAT Format,
|
|
D3DPOOL Pool,
|
|
D3DPOOL ActualPool,
|
|
REF_TYPE refType,
|
|
HRESULT *phr) :
|
|
CDriverManagedIndexBuffer(pDevice,
|
|
cbLength,
|
|
Usage,
|
|
ActualUsage,
|
|
Format,
|
|
Pool,
|
|
ActualPool,
|
|
refType,
|
|
phr)
|
|
{
|
|
}
|
|
|
|
}; // class CDriverIndexBufferMT
|
|
|
|
#endif // __IBUFFER_HPP__
|