Initial commit with PS4 and XBone stuff trimmed.

1 files changed, 351 insertions, 0 deletions

diff --git a/demo/Effects11/d3dxGlobal.cpp b/demo/Effects11/d3dxGlobal.cpp
new file mode 100644
index 0000000..72f4efb
--- /dev/null
+++ b/demo/Effects11/d3dxGlobal.cpp
@@ -0,0 +1,351 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
+//
+//  File:       d3dxGlobal.cpp
+//  Content:    D3DX11 Effects implementation for helper data structures
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#include "pchfx.h"
+#include <intsafe.h>
+
+namespace D3DX11Core
+{
+
+//////////////////////////////////////////////////////////////////////////
+// CMemoryStream - A class to simplify reading binary data
+//////////////////////////////////////////////////////////////////////////
+
+CMemoryStream::CMemoryStream()
+{
+    m_pData = NULL;
+    m_cbData = 0;
+    m_readPtr = 0;
+}
+
+CMemoryStream::~CMemoryStream()
+{
+}
+
+HRESULT CMemoryStream::SetData(const void *pData, SIZE_T size)
+{
+    m_pData = (BYTE*) pData;
+    m_cbData = size;
+    m_readPtr = 0;
+
+    return S_OK;
+}
+
+HRESULT CMemoryStream::ReadAtOffset(SIZE_T offset, SIZE_T size, void **ppData)
+{
+    if (offset >= m_cbData)
+        return E_FAIL;
+
+    m_readPtr = offset;
+    return Read(ppData, size);
+}
+
+HRESULT CMemoryStream::ReadAtOffset(SIZE_T offset, LPCSTR *ppString)
+{
+    if (offset >= m_cbData)
+        return E_FAIL;
+
+    m_readPtr = offset;
+    return Read(ppString);
+}
+
+HRESULT CMemoryStream::Read(void **ppData, SIZE_T size)
+{
+    SIZE_T temp = m_readPtr + size;
+
+    if (temp < m_readPtr || temp > m_cbData)
+        return E_FAIL;
+
+    *ppData = m_pData + m_readPtr;
+    m_readPtr = temp;
+    return S_OK;
+}
+
+HRESULT CMemoryStream::Read(UINT *pDword)
+{
+    UINT *pTempDword;
+    HRESULT hr;
+
+    hr = Read((void**) &pTempDword, sizeof(UINT));
+    if (FAILED(hr))
+        return E_FAIL;
+
+    *pDword = *pTempDword;
+    return S_OK;
+}
+
+HRESULT CMemoryStream::Read(LPCSTR *ppString)
+{
+    SIZE_T iChar;
+
+    for(iChar=m_readPtr; m_pData[iChar]; iChar++)
+    {
+        if (iChar > m_cbData)
+            return E_FAIL;      
+    }
+
+    *ppString = (LPCSTR) (m_pData + m_readPtr);
+    m_readPtr = iChar;
+
+    return S_OK;
+}
+
+SIZE_T CMemoryStream::GetPosition()
+{
+    return m_readPtr;
+}
+
+HRESULT CMemoryStream::Seek(SIZE_T offset)
+{
+    if (offset > m_cbData)
+        return E_FAIL;
+
+    m_readPtr = offset;
+    return S_OK;
+}
+
+}
+
+//////////////////////////////////////////////////////////////////////////
+// CDataBlock - used to dynamically build up the effect file in memory
+//////////////////////////////////////////////////////////////////////////
+
+CDataBlock::CDataBlock()
+{
+    m_size = 0;
+    m_maxSize = 0;
+    m_pData = NULL;
+    m_pNext = NULL;
+    m_IsAligned = FALSE;
+}
+
+CDataBlock::~CDataBlock()
+{
+    SAFE_DELETE_ARRAY(m_pData);
+    SAFE_DELETE(m_pNext);
+}
+
+void CDataBlock::EnableAlignment()
+{
+    m_IsAligned = TRUE;
+}
+
+HRESULT CDataBlock::AddData(const void *pvNewData, UINT bufferSize, CDataBlock **ppBlock)
+{
+    HRESULT hr = S_OK;
+    UINT bytesToCopy;
+    const BYTE *pNewData = (const BYTE*) pvNewData;
+
+    if (m_maxSize == 0)
+    {
+        // This is a brand new DataBlock, fill it up
+        m_maxSize = max(8192, bufferSize);
+
+        VN( m_pData = NEW BYTE[m_maxSize] );
+    }
+
+    D3DXASSERT(m_pData == AlignToPowerOf2(m_pData, c_DataAlignment));
+
+    bytesToCopy = min(m_maxSize - m_size, bufferSize);
+    memcpy(m_pData + m_size, pNewData, bytesToCopy);
+    pNewData += bytesToCopy;
+    
+    if (m_IsAligned)
+    {
+        D3DXASSERT(m_size == AlignToPowerOf2(m_size, c_DataAlignment));
+        m_size += AlignToPowerOf2(bytesToCopy, c_DataAlignment);
+    }
+    else
+    {
+        m_size += bytesToCopy;
+    }
+    
+    bufferSize -= bytesToCopy;
+    *ppBlock = this;
+
+    if (bufferSize != 0)
+    {
+        D3DXASSERT(NULL == m_pNext); // make sure we're not overwriting anything
+
+        // Couldn't fit all data into this block, spill over into next
+        VN( m_pNext = NEW CDataBlock() );
+        if (m_IsAligned)
+        {
+            m_pNext->EnableAlignment();
+        }
+        VH( m_pNext->AddData(pNewData, bufferSize, ppBlock) );
+    }
+
+lExit:
+    return hr;
+}
+
+void* CDataBlock::Allocate(UINT bufferSize, CDataBlock **ppBlock)
+{
+    void *pRetValue;
+    UINT temp = m_size + bufferSize;
+
+    if (temp < m_size)
+        return NULL;
+
+    *ppBlock = this;
+
+    if (m_maxSize == 0)
+    {
+        // This is a brand new DataBlock, fill it up
+        m_maxSize = max(8192, bufferSize);
+
+        m_pData = NEW BYTE[m_maxSize];
+        if (!m_pData)
+            return NULL;
+        memset(m_pData, 0xDD, m_maxSize);
+    }
+    else if (temp > m_maxSize)
+    {
+        D3DXASSERT(NULL == m_pNext); // make sure we're not overwriting anything
+
+        // Couldn't fit data into this block, spill over into next
+        m_pNext = NEW CDataBlock();
+        if (!m_pNext)
+            return NULL;
+        if (m_IsAligned)
+        {
+            m_pNext->EnableAlignment();
+        }
+
+        return m_pNext->Allocate(bufferSize, ppBlock);
+    }
+
+    D3DXASSERT(m_pData == AlignToPowerOf2(m_pData, c_DataAlignment));
+
+    pRetValue = m_pData + m_size;
+    if (m_IsAligned)
+    {
+        D3DXASSERT(m_size == AlignToPowerOf2(m_size, c_DataAlignment));
+        m_size = AlignToPowerOf2(temp, c_DataAlignment);
+    }
+    else
+    {
+        m_size = temp;
+    }
+
+    return pRetValue;
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+CDataBlockStore::CDataBlockStore()
+{
+    m_pFirst = NULL;
+    m_pLast = NULL;
+    m_Size = 0;
+    m_Offset = 0;
+    m_IsAligned = FALSE;
+
+#if _DEBUG
+    m_cAllocations = 0;
+#endif
+}
+
+CDataBlockStore::~CDataBlockStore()
+{
+    // Can't just do SAFE_DELETE(m_pFirst) since it blows the stack when deleting long chains of data
+    CDataBlock* pData = m_pFirst;
+    while(pData)
+    {
+        CDataBlock* pCurrent = pData;
+        pData = pData->m_pNext;
+        pCurrent->m_pNext = NULL;
+        delete pCurrent;
+    }
+
+    // m_pLast will be deleted automatically
+}
+
+void CDataBlockStore::EnableAlignment()
+{
+    m_IsAligned = TRUE;
+}
+
+HRESULT CDataBlockStore::AddString(LPCSTR pString, UINT *pOffset)
+{
+    size_t strSize = strlen(pString) + 1;
+    D3DXASSERT( strSize <= 0xffffffff );
+    return AddData(pString, (UINT)strSize, pOffset);
+}
+
+HRESULT CDataBlockStore::AddData(const void *pNewData, UINT bufferSize, UINT *pCurOffset)
+{
+    HRESULT hr = S_OK;
+
+    if (bufferSize == 0)
+    {        
+        if (pCurOffset)
+        {
+            *pCurOffset = 0;
+        }
+        goto lExit;
+    }
+
+    if (!m_pFirst)
+    {
+        VN( m_pFirst = NEW CDataBlock() );
+        if (m_IsAligned)
+        {
+            m_pFirst->EnableAlignment();
+        }
+        m_pLast = m_pFirst;
+    }
+
+    if (pCurOffset)
+        *pCurOffset = m_Size + m_Offset;
+
+    VH( m_pLast->AddData(pNewData, bufferSize, &m_pLast) );
+    m_Size += bufferSize;
+
+lExit:
+    return hr;
+}
+
+void* CDataBlockStore::Allocate(UINT bufferSize)
+{
+    void *pRetValue = NULL;
+
+#if _DEBUG
+    m_cAllocations++;
+#endif
+
+    if (!m_pFirst)
+    {
+        m_pFirst = NEW CDataBlock();
+        if (!m_pFirst)
+            return NULL;
+
+        if (m_IsAligned)
+        {
+            m_pFirst->EnableAlignment();
+        }
+        m_pLast = m_pFirst;
+    }
+
+    if (FAILED(UIntAdd(m_Size, bufferSize, &m_Size)))
+        return NULL;
+
+    pRetValue = m_pLast->Allocate(bufferSize, &m_pLast);
+    if (!pRetValue)
+        return NULL;
+
+    return pRetValue;
+}
+
+UINT CDataBlockStore::GetSize()
+{
+    return m_Size;
+}