#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__