cDXGPUStream.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cDXGPUStream_H
#define _INC_cDXGPUStream_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cDXBase.h"
 
#ifdef USE_DX9
#include "cDXBuffer.h"
#include "GrayCore/include/cIUnkPtr.h"
 
namespace Gray3D
{
 
        class GRAY3D_LINK cDXGPUQuad : public cDXBase   // typically a cSingleton
        {
 
                typedef cDXBase SUPER_t;
                static const int k_QuadIncrement = 4 * 1024;
 
        public:
                cDXGPUQuad() noexcept
                        : m_CurQuadNum(0)
                {
                }
                HRESULT SetQuadIndices(int numberOfQuads);
 
                virtual HRESULT OnLostDeviceX()
                {
                        m_pQuadIndices.ReleasePtr();
                        m_CurQuadNum = 0;
                        return SUPER_t::OnLostDeviceX();
                }
 
        public:
                cIUnkPtr<IDirect3DIndexBuffer9> m_pQuadIndices;
                int m_CurQuadNum;
        };
 
        class GRAY3D_LINK cDXGPUIndex : public cDXBase  // typically a cSingleton
        {
                typedef cDXBase SUPER_t;
                enum
                {
                        DYN_INDICES_BUFFER_SIZE = (16384 * 2 * 2),
                };
        public:
                cDXGPUIndex() noexcept
                        : m_FirstIdx(-1)
                        , m_CurIdxBufLen(0)
                {
                }
 
                // SetIndices to dynamic index stream
                // Call this as initial setup before rendering groups of primitives with dynamic indices
                HRESULT SetIndices();
 
                // Prepare for writing the indices. Returns pointer to first index - indices is 16-bit
                // expects number of indices to write. This number should be the actual number
                // of indices that would be filled/used
                // Buffer returned is WRITE-ONLY - don't do stuff that will read back from it.
                // It will work, but will slow things down a lot
                WORD* LockIndices(int numIdx);
 
                // Signal for finish writing, readying for rendering
                // returns the "physical" index of first index - you should offset DrawIndexedPrimitive by this amount
                // (StartIndex)
                int UnlockIndices();
 
                virtual HRESULT OnResetDeviceX();
                virtual HRESULT OnLostDeviceX()
                {
                        m_pDynIndices.ReleasePtr();
                        return SUPER_t::OnLostDeviceX();
                }
        public:
                cIUnkPtr<IDirect3DIndexBuffer9> m_pDynIndices;  // TODO: Merge with cDXBufferIndexT
                int m_FirstIdx;
                size_t m_CurIdxBufLen; // size of m_pDynIndices
        };
 
        class GRAY3D_LINK cDXGPUVert : public cDXBase   // typically a cSingleton
        {
                typedef cDXBase SUPER_t;
                // maximum values for single dynamic vertex and index lock/batch
                // if you require larger (unlikely, as this data goes thru CPU), break data into these smaller batches
                enum
                {
                        DYN_VERTICES_BUFFER_SIZE = (16384 * 32),
                };
        public:
                cDXGPUVert() noexcept
                        : m_FirstVtx(-1)
                        , m_CurVtxBufLen(0)
                {
                }
 
                // SetStreamSource to dynamic vertex stream.
                // Call this as initial setup before rendering groups of primitives with dynamic vertices
                HRESULT SetVertStreamSource(int streamNumber, size_t nVertStride);
 
                // Prepare for writing the vertices. Returns pointer to first vertex
                // expects number of vertices to write and stride. Vertex number should be the actual number
                // of vertices that would be filled/used
                // Buffer returned is WRITE-ONLY - don't do stuff that will read back from it.
                // It will work, but will slow things down a lot
                void* LockVertices(int numVtx, size_t nVertStride);
 
                // Signal for finish writing, readying for rendering
                // returns the "physical" index of first vertex - you should offset Draw(Indexed)Primitive by this amount
                // (StartVertex or BaseVertexIndex)
                int UnlockVertices();
 
                virtual HRESULT OnResetDeviceX();
                virtual HRESULT OnLostDeviceX()
                {
                        m_pDynVertices.ReleasePtr();
                        return SUPER_t::OnLostDeviceX();
                }
 
        public:
                cIUnkPtr<IDirect3DVertexBuffer9> m_pDynVertices; // TODO: Merge with cDXBufferVertexT
                UINT m_FirstVtx;
                size_t m_CurVtxBufLen; // size of m_pDynVertices
        };
}
#endif // USE_DX9
#endif