//
// Direct3D 11 Effects Header for ID3DX11Effect Implementation
//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
};
- SType() :
+ SType() noexcept :
VarType(EVT_Invalid),
Elements(0),
pTypeName(nullptr),
TotalSize(0),
Stride(0),
- PackedSize(0)
+ PackedSize(0),
+ StructType{}
{
- C_ASSERT( sizeof(NumericType) <= sizeof(StructType) );
- C_ASSERT( sizeof(ObjectType) <= sizeof(StructType) );
- C_ASSERT( sizeof(InterfaceType) <= sizeof(StructType) );
- ZeroMemory( &StructType, sizeof(StructType) );
+ static_assert(sizeof(NumericType) <= sizeof(StructType), "SType union issue");
+ static_assert(sizeof(ObjectType) <= sizeof(StructType), "SType union issue");
+ static_assert(sizeof(InterfaceType) <= sizeof(StructType), "SType union issue");
}
bool IsEqual(SType *pOtherType) const;
STDMETHOD_(LPCSTR, GetMemberSemantic)(uint32_t Index) override { return ((SType*)pType)->GetMemberSemantic(Index); }
IUNKNOWN_IMP(SSingleElementType, ID3DX11EffectType, IUnknown);
+
+ SSingleElementType() noexcept :
+ pType(nullptr)
+ {
+ }
};
//////////////////////////////////////////////////////////////////////////
uint32_t AssignmentCount;
SAssignment *pAssignments;
- SBaseBlock();
+ SBaseBlock() noexcept;
bool ApplyAssignments(CEffect *pEffect);
bool InitiallyValid;
bool HasDependencies;
- STechnique();
+ STechnique() noexcept;
STDMETHOD_(bool, IsValid)() override;
STDMETHOD(GetDesc)(_Out_ D3DX11_TECHNIQUE_DESC *pDesc) override;
bool InitiallyValid;
bool HasDependencies;
- SGroup();
+ SGroup() noexcept;
STDMETHOD_(bool, IsValid)() override;
STDMETHOD(GetDesc)(_Out_ D3DX11_GROUP_DESC *pDesc) override;
bool InitiallyValid; // validity of all state objects and shaders in pass upon BindToDevice
bool HasDependencies; // if pass expressions or pass state blocks have dependencies on variables (if true, IsValid != InitiallyValid possibly)
- SPassBlock();
+ SPassBlock() noexcept;
void ApplyPassAssignments();
bool CheckShaderDependencies( _In_ const SShaderBlock* pBlock );
D3D11_DEPTH_STENCIL_DESC BackingStore;
bool IsValid;
- SDepthStencilBlock();
+ SDepthStencilBlock() noexcept;
};
struct SBlendBlock : SBaseBlock
D3D11_BLEND_DESC BackingStore;
bool IsValid;
- SBlendBlock();
+ SBlendBlock() noexcept;
};
struct SRasterizerBlock : SBaseBlock
D3D11_RASTERIZER_DESC BackingStore;
bool IsValid;
- SRasterizerBlock();
+ SRasterizerBlock() noexcept;
};
struct SSamplerBlock : SBaseBlock
SShaderResource *pTexture;
} BackingStore;
- SSamplerBlock();
+ SSamplerBlock() noexcept;
};
struct SInterface
{
SClassInstanceGlobalVariable* pClassInstance;
- SInterface()
+ SInterface() noexcept :
+ pClassInstance(nullptr)
{
- pClassInstance = nullptr;
}
};
{
ID3D11ShaderResourceView *pShaderResource;
- SShaderResource()
+ SShaderResource() noexcept :
+ pShaderResource(nullptr)
{
- pShaderResource = nullptr;
}
-
};
struct SUnorderedAccessView
{
ID3D11UnorderedAccessView *pUnorderedAccessView;
- SUnorderedAccessView()
+ SUnorderedAccessView() noexcept :
+ pUnorderedAccessView(nullptr)
{
- pUnorderedAccessView = nullptr;
}
-
};
struct SRenderTargetView
{
ID3D11RenderTargetView *pRenderTargetView;
- SRenderTargetView();
+ SRenderTargetView() noexcept :
+ pRenderTargetView(nullptr)
+ {
+ }
};
struct SDepthStencilView
{
ID3D11DepthStencilView *pDepthStencilView;
- SDepthStencilView();
+ SDepthStencilView() noexcept :
+ pDepthStencilView(nullptr)
+ {
+ }
};
T *ppFXPointers; // Array of ptrs to FX objects (CBs, SShaderResources, etc)
D3DTYPE *ppD3DObjects; // Array of ptrs to matching D3D objects
- SShaderDependency()
+ SShaderDependency() noexcept :
+ StartIndex(0),
+ Count(0),
+ ppFXPointers(nullptr),
+ ppD3DObjects(nullptr)
{
- StartIndex = Count = 0;
-
- ppD3DObjects = nullptr;
- ppFXPointers = nullptr;
}
};
ID3DBlob *pInputSignatureBlob; // The input signature is separated from the bytecode because it
// is always available, even after Optimize() has been called.
- SShaderBlock(SD3DShaderVTable *pVirtualTable = nullptr);
+ SShaderBlock(SD3DShaderVTable *pVirtualTable = nullptr) noexcept;
EObjectType GetShaderType();
{
char *pString;
- SString();
+ SString() noexcept :
+ pString(nullptr)
+ {
+ }
};
char *pSemantic;
uint32_t ExplicitBindPoint;
- SVariable()
+ SVariable() noexcept
{
ZeroMemory(this, sizeof(*this));
ExplicitBindPoint = uint32_t(-1);
{
SShaderBlock *pShaderBlock;
- SAnonymousShader(_In_opt_ SShaderBlock *pBlock = nullptr);
+ SAnonymousShader(_In_opt_ SShaderBlock *pBlock = nullptr) noexcept;
// ID3DX11EffectShaderVariable interface
STDMETHOD_(bool, IsValid)() override;
CEffect *pEffect;
- SConstantBuffer()
+ SConstantBuffer() noexcept :
+ pD3DObject(nullptr),
+ TBuffer{},
+ pBackingStore(nullptr),
+ Size(0),
+ pName(nullptr),
+ AnnotationCount(0),
+ pAnnotations(nullptr),
+ VariableCount(0),
+ pVariables(nullptr),
+ ExplicitBindPoint(uint32_t(-1)),
+ IsDirty(false),
+ IsTBuffer(false),
+ IsUserManaged(false),
+ IsEffectOptimized(false),
+ IsUsedByExpression(false),
+ IsUserPacked(false),
+ IsSingle(false),
+ IsNonUpdatable(false),
+ pMemberData(nullptr),
+ pEffect(nullptr)
{
- pD3DObject = nullptr;
- ZeroMemory(&TBuffer, sizeof(TBuffer));
- ExplicitBindPoint = uint32_t(-1);
- pBackingStore = nullptr;
- Size = 0;
- pName = nullptr;
- VariableCount = 0;
- pVariables = nullptr;
- AnnotationCount = 0;
- pAnnotations = nullptr;
- IsDirty = false;
- IsTBuffer = false;
- IsUserManaged = false;
- IsEffectOptimized = false;
- IsUsedByExpression = false;
- IsUserPacked = false;
- IsSingle = false;
- IsNonUpdatable = false;
- pEffect = nullptr;
}
bool ClonedSingle() const;
{
SGlobalVariable *pVariable;
- SDependency()
+ SDependency() noexcept :
+ pVariable(nullptr)
{
- pVariable = nullptr;
}
};
return IsObjectAssignmentHelper(LhsType);
}
- SAssignment()
+ SAssignment() noexcept :
+ LhsType(ELHS_Invalid),
+ AssignmentType(ERAT_Invalid),
+ LastRecomputedTime(0),
+ DependencyCount(0),
+ pDependencies(nullptr),
+ Destination{0},
+ Source{0},
+ DataSize(0),
+ MaxElements(0)
{
- LhsType = ELHS_Invalid;
- AssignmentType = ERAT_Invalid;
-
- Destination.pGeneric = nullptr;
- Source.pGeneric = nullptr;
-
- LastRecomputedTime = 0;
- DependencyCount = 0;
- pDependencies = nullptr;
-
- DataSize = 0;
}
};
return (pData >= m_pData && pData < (m_pData + m_dwBufferSize));
}
- CEffectHeap();
+ CEffectHeap() noexcept;
~CEffectHeap();
};
friend struct SConstantBuffer;
public:
- CEffect( uint32_t Flags = 0 );
+ CEffect( uint32_t Flags = 0 ) noexcept;
virtual ~CEffect();
void ReleaseShaderRefection();
//
// Effect API entry point
//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
struct handle_closer { void operator()(HANDLE h) { if (h) CloseHandle(h); } };
-typedef public std::unique_ptr<void, handle_closer> ScopedHandle;
+typedef std::unique_ptr<void, handle_closer> ScopedHandle;
-inline HANDLE safe_handle( HANDLE h ) { return (h == INVALID_HANDLE_VALUE) ? 0 : h; }
+inline HANDLE safe_handle( HANDLE h ) { return (h == INVALID_HANDLE_VALUE) ? nullptr : h; }
//-------------------------------------------------------------------------------------
static HRESULT LoadBinaryFromFile( _In_z_ LPCWSTR pFileName, _Inout_ std::unique_ptr<uint8_t[]>& data, _Out_ uint32_t& size )
{
// open the file
-#if (0 && _WIN32_WINNT >= _WIN32_WINNT_WIN8)
+#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
ScopedHandle hFile( safe_handle( CreateFile2( pFileName,
GENERIC_READ,
FILE_SHARE_READ,
}
// Get the file size
- LARGE_INTEGER FileSize = { 0 };
-
-#if (0 && _WIN32_WINNT >= _WIN32_WINNT_VISTA)
FILE_STANDARD_INFO fileInfo;
if ( !GetFileInformationByHandleEx( hFile.get(), FileStandardInfo, &fileInfo, sizeof(fileInfo) ) )
{
return HRESULT_FROM_WIN32( GetLastError() );
}
- FileSize = fileInfo.EndOfFile;
-#else
- GetFileSizeEx( hFile.get(), &FileSize );
-#endif
// File is too big for 32-bit allocation or contains no data, so reject read
- if ( !FileSize.LowPart || FileSize.HighPart > 0)
+ if ( !fileInfo.EndOfFile.LowPart || fileInfo.EndOfFile.HighPart > 0 )
{
return E_FAIL;
}
// create enough space for the file data
- data.reset( new uint8_t[ FileSize.LowPart ] );
+ data.reset( new uint8_t[ fileInfo.EndOfFile.LowPart ] );
if (!data)
{
return E_OUTOFMEMORY;
DWORD BytesRead = 0;
if (!ReadFile( hFile.get(),
data.get(),
- FileSize.LowPart,
+ fileInfo.EndOfFile.LowPart,
&BytesRead,
nullptr
))
return HRESULT_FROM_WIN32( GetLastError() );
}
- if (BytesRead < FileSize.LowPart)
+ if (BytesRead < fileInfo.EndOfFile.LowPart)
{
return E_FAIL;
}
return hr;
}
-typedef HRESULT(WINAPI* D3DCOMPILE)(LPCVOID pSrcData,
- SIZE_T SrcDataSize,
- LPCSTR pSourceName,
- CONST D3D_SHADER_MACRO* pDefines,
- ID3DInclude* pInclude,
- LPCSTR pEntrypoint,
- LPCSTR pTarget,
- UINT Flags1,
- UINT Flags2,
- ID3DBlob** ppCode,
- ID3DBlob** ppErrorMsgs);
-extern D3DCOMPILE ppD3DCompile;
//--------------------------------------------------------------------------------------
+
_Use_decl_annotations_
HRESULT D3DX11CompileEffectFromMemory( LPCVOID pData, SIZE_T DataLength, LPCSTR srcName,
const D3D_SHADER_MACRO *pDefines, ID3DInclude *pInclude, UINT HLSLFlags, UINT FXFlags,
}
ID3DBlob *blob = nullptr;
- HRESULT hr = ppD3DCompile( pData, DataLength, srcName, pDefines, pInclude, "", "fx_5_0", HLSLFlags, FXFlags, &blob, ppErrors );
+ HRESULT hr = D3DCompile( pData, DataLength, srcName, pDefines, pInclude, "", "fx_5_0", HLSLFlags, FXFlags, &blob, ppErrors );
if ( FAILED(hr) )
{
DPF(0, "D3DCompile of fx_5_0 profile failed: %08X", hr );
}
return hr;
}
-//--------------------------------------------------------------------------------------
-typedef HRESULT(WINAPI* D3DCOMPILEFROMFILE)(LPCWSTR pFileName,
- CONST D3D_SHADER_MACRO* pDefines,
- ID3DInclude* pInclude,
- LPCSTR pEntrypoint,
- LPCSTR pTarget,
- UINT Flags1,
- UINT Flags2,
- ID3DBlob** ppCode,
- ID3DBlob** ppErrorMsgs);
-extern D3DCOMPILEFROMFILE pD3DCompileFromFile;
+//--------------------------------------------------------------------------------------
_Use_decl_annotations_
HRESULT D3DX11CompileEffectFromFile( LPCWSTR pFileName,
#if (D3D_COMPILER_VERSION >= 46) && ( !defined(WINAPI_FAMILY) || ( (WINAPI_FAMILY != WINAPI_FAMILY_APP) && (WINAPI_FAMILY != WINAPI_FAMILY_PHONE_APP) ) )
- HRESULT hr = pD3DCompileFromFile( pFileName, pDefines, pInclude, "", "fx_5_0", HLSLFlags, FXFlags, &blob, ppErrors );
+ HRESULT hr = D3DCompileFromFile( pFileName, pDefines, pInclude, "", "fx_5_0", HLSLFlags, FXFlags, &blob, ppErrors );
if ( FAILED(hr) )
{
DPF(0, "D3DCompileFromFile of fx_5_0 profile failed %08X: %ls", hr, pFileName );
// This is the binary file interface shared between the Effects
// compiler and runtime.
//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
//
// Direct3D Effects file loading code
//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
#define PRIVATENEW new(m_BulkHeap)
-typedef HRESULT(WINAPI* D3DREFLECT)(LPCVOID pSrcData, SIZE_T SrcDataSize, REFIID pInterface, void **ppReflector);
-extern D3DREFLECT pD3DReflect;
-typedef HRESULT(WINAPI *D3DGETBLOBPART)(LPCVOID pSrcData, SIZE_T SrcDataSize, D3D_BLOB_PART Part, UINT Flags, ID3DBlob** ppPart);
-extern D3DGETBLOBPART pD3DGetBlobPart;
-
namespace D3DX11Effects
{
// A simple class which assists in adding data to a block of memory
//////////////////////////////////////////////////////////////////////////
-CEffectHeap::CEffectHeap() : m_pData(nullptr), m_dwSize(0), m_dwBufferSize(0)
+CEffectHeap::CEffectHeap() noexcept :
+ m_pData(nullptr),
+ m_dwSize(0),
+ m_dwBufferSize(0)
{
}
// A helper class which loads an effect
//////////////////////////////////////////////////////////////////////////
+CEffectLoader::CEffectLoader() noexcept :
+ m_pData(nullptr),
+ m_pHeader(nullptr),
+ m_Version(0),
+ m_pEffect(nullptr),
+ m_pReflection(nullptr),
+ m_dwBufferSize(0),
+ m_pOldVars(nullptr),
+ m_pOldShaders(nullptr),
+ m_pOldDS(nullptr),
+ m_pOldAB(nullptr),
+ m_pOldRS(nullptr),
+ m_pOldCBs(nullptr),
+ m_pOldSamplers(nullptr),
+ m_OldInterfaceCount(0),
+ m_pOldInterfaces(nullptr),
+ m_pOldShaderResources(nullptr),
+ m_pOldUnorderedAccessViews(nullptr),
+ m_pOldRenderTargetViews(nullptr),
+ m_pOldDepthStencilViews(nullptr),
+ m_pOldStrings(nullptr),
+ m_pOldMemberDataBlocks(nullptr),
+ m_pvOldMemberInterfaces(nullptr),
+ m_pOldGroups(nullptr),
+ m_EffectMemory(0),
+ m_ReflectionMemory(0)
+{
+}
+
_Use_decl_annotations_
HRESULT CEffectLoader::GetUnstructuredDataBlock(uint32_t offset, uint32_t *pdwSize, void **ppData)
{
// Inline shader assignments must be object types
assert(pAssignment->IsObjectAssignment());
- C_ASSERT( offsetof(SBinaryAssignment::SInlineShader,oShader) == offsetof(SBinaryShaderData5,oShader) );
- C_ASSERT( offsetof(SBinaryAssignment::SInlineShader,oSODecl) == offsetof(SBinaryShaderData5,oSODecls) );
+ static_assert(offsetof(SBinaryAssignment::SInlineShader, oShader) == offsetof(SBinaryShaderData5, oShader), "ECAT_InlineShader issue");
+ static_assert(offsetof(SBinaryAssignment::SInlineShader, oSODecl) == offsetof(SBinaryShaderData5, oSODecls), "ECAT_InlineShader5 issue");
if( psAssignments[i].AssignmentType == ECAT_InlineShader )
{
VHD( m_msUnstructured.ReadAtOffset(psAssignments[i].oInitializer, sizeof(*psInlineShader), (void**) &psInlineShader),
SBinaryShaderData5 *psInlineShader5;
};
- C_ASSERT( offsetof(SBinaryGSSOInitializer,oShader) == 0 );
- C_ASSERT( offsetof(SBinaryShaderData5,oShader) == 0 );
+ static_assert(offsetof(SBinaryGSSOInitializer, oShader) == 0, "Union issue");
+ static_assert(offsetof(SBinaryShaderData5, oShader) == 0, "Union issue");
pShaderBlock = &m_pEffect->m_pShaderBlocks[m_pEffect->m_ShaderBlockCount];
}
else
{
- DPF(0, "%s: Sampler %s[%u] does not have a texture bound to it, even though the sampler array is used in a DX9-style texture load instruction", g_szEffectLoadArea, pName, j);
+ DPF(0, "%s: Sampler %s[%zu] does not have a texture bound to it, even though the sampler array is used in a DX9-style texture load instruction", g_szEffectLoadArea, pName, j);
}
VH( E_FAIL );
}
// Initialize the reflection interface
- VHD(pD3DReflect( pShaderBlock->pReflectionData->pBytecode, pShaderBlock->pReflectionData->BytecodeLength, IID_ID3D11ShaderReflection, (void**)&pShaderBlock->pReflectionData->pReflection ),
+ VHD( D3DReflect( pShaderBlock->pReflectionData->pBytecode, pShaderBlock->pReflectionData->BytecodeLength, IID_ID3D11ShaderReflection, (void**)&pShaderBlock->pReflectionData->pReflection ),
"Internal loading error: cannot create shader reflection object." );
// Get dependencies
if( EOT_VertexShader == pShaderBlock->GetShaderType() )
{
assert( pShaderBlock->pInputSignatureBlob == nullptr );
- VHD(pD3DGetBlobPart( pShaderBlock->pReflectionData->pBytecode, pShaderBlock->pReflectionData->BytecodeLength,
+ VHD( D3DGetBlobPart( pShaderBlock->pReflectionData->pBytecode, pShaderBlock->pReflectionData->BytecodeLength,
D3D_BLOB_INPUT_SIGNATURE_BLOB, 0,
&pShaderBlock->pInputSignatureBlob ),
"Internal loading error: cannot get input signature." );
// Direct3D 11 Effects header for the FX file loader
// A CEffectLoader is created at load time to facilitate loading
//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
uint32_t start;
uint32_t last;
CEffectVector<void *> vResources; // should be (last - start) in length, resource type depends on the range type
+
+ SRange() noexcept :
+ start(0),
+ last(0)
+ {
+ }
};
// Used during load to validate assignments
SRasterizerBlock *m_pOldRS;
SConstantBuffer *m_pOldCBs;
SSamplerBlock *m_pOldSamplers;
- uint32_t m_OldInterfaceCount;
+ uint32_t m_OldInterfaceCount;
SInterface *m_pOldInterfaces;
SShaderResource *m_pOldShaderResources;
SUnorderedAccessView *m_pOldUnorderedAccessViews;
HRESULT GetUnstructuredDataBlock(_In_ uint32_t offset, _Out_ uint32_t *pdwSize, _Outptr_result_buffer_(*pdwSize) void **ppData);
// This function makes a copy of the array of SInterfaceParameters, but not a copy of the strings
HRESULT GetInterfaceParametersAndAddToReflection( _In_ uint32_t InterfaceCount, _In_ uint32_t offset, _Outptr_result_buffer_all_maybenull_(InterfaceCount) SShaderBlock::SInterfaceParameter **ppInterfaces );
+
public:
+ CEffectLoader() noexcept;
HRESULT LoadEffect(_In_ CEffect *pEffect, _In_reads_bytes_(cbEffectBuffer) const void *pEffectBuffer, _In_ uint32_t cbEffectBuffer);
};
-
-}
\ No newline at end of file
+}
// are typically called when creating, cloning, or optimizing an
// Effect, or reflecting a variable.
//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
extern SUnorderedAccessView g_NullUnorderedAccessView;
-SBaseBlock::SBaseBlock()
-: BlockType(EBT_Invalid)
-, IsUserManaged(false)
-, AssignmentCount(0)
-, pAssignments(nullptr)
+SBaseBlock::SBaseBlock() noexcept :
+ BlockType(EBT_Invalid),
+ IsUserManaged(false),
+ AssignmentCount(0),
+ pAssignments(nullptr)
{
-
}
-SPassBlock::SPassBlock()
+SPassBlock::SPassBlock() noexcept :
+ BackingStore{},
+ pName(nullptr),
+ AnnotationCount(0),
+ pAnnotations(nullptr),
+ pEffect(nullptr),
+ InitiallyValid(true),
+ HasDependencies(false)
{
- pName = nullptr;
- AnnotationCount = 0;
- pAnnotations = nullptr;
- InitiallyValid = true;
- HasDependencies = false;
- ZeroMemory(&BackingStore, sizeof(BackingStore));
}
-STechnique::STechnique()
-: pName(nullptr)
-, PassCount(0)
-, pPasses(nullptr)
-, AnnotationCount(0)
-, pAnnotations(nullptr)
-, InitiallyValid( true )
-, HasDependencies( false )
+STechnique::STechnique() noexcept :
+ pName(nullptr),
+ PassCount(0),
+ pPasses(nullptr),
+ AnnotationCount(0),
+ pAnnotations(nullptr),
+ InitiallyValid( true ),
+ HasDependencies( false )
{
}
-SGroup::SGroup()
-: pName(nullptr)
-, TechniqueCount(0)
-, pTechniques(nullptr)
-, AnnotationCount(0)
-, pAnnotations(nullptr)
-, InitiallyValid( true )
-, HasDependencies( false )
+SGroup::SGroup() noexcept :
+ pName(nullptr),
+ TechniqueCount(0),
+ pTechniques(nullptr),
+ AnnotationCount(0),
+ pAnnotations(nullptr),
+ InitiallyValid( true ),
+ HasDependencies( false )
{
}
-SDepthStencilBlock::SDepthStencilBlock()
+SDepthStencilBlock::SDepthStencilBlock() noexcept :
+ pDSObject(nullptr),
+ BackingStore{},
+ IsValid(true)
{
- pDSObject = nullptr;
- ZeroMemory(&BackingStore, sizeof(BackingStore));
- IsValid = true;
-
BackingStore.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
BackingStore.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
BackingStore.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
BackingStore.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
}
-SBlendBlock::SBlendBlock()
+SBlendBlock::SBlendBlock() noexcept :
+ pBlendObject(nullptr),
+ BackingStore{},
+ IsValid(true)
{
- pBlendObject = nullptr;
- ZeroMemory(&BackingStore, sizeof(BackingStore));
- IsValid = true;
-
BackingStore.AlphaToCoverageEnable = false;
BackingStore.IndependentBlendEnable = true;
for( size_t i=0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++ )
}
}
-SRasterizerBlock::SRasterizerBlock()
+SRasterizerBlock::SRasterizerBlock() noexcept :
+ pRasterizerObject(nullptr),
+ BackingStore{},
+ IsValid(true)
{
- pRasterizerObject = nullptr;
- ZeroMemory(&BackingStore, sizeof(BackingStore));
- IsValid = true;
-
BackingStore.AntialiasedLineEnable = false;
BackingStore.CullMode = D3D11_CULL_BACK;
BackingStore.DepthBias = D3D11_DEFAULT_DEPTH_BIAS;
BackingStore.DepthClipEnable = true;
}
-SSamplerBlock::SSamplerBlock()
+SSamplerBlock::SSamplerBlock() noexcept :
+ pD3DObject(nullptr),
+ BackingStore{}
{
- pD3DObject = nullptr;
- ZeroMemory(&BackingStore, sizeof(BackingStore));
-
BackingStore.SamplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
BackingStore.SamplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
BackingStore.SamplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
BackingStore.SamplerDesc.MaxLOD = FLT_MAX;
}
-SShaderBlock::SShaderBlock(SD3DShaderVTable *pVirtualTable)
+SShaderBlock::SShaderBlock(SD3DShaderVTable *pVirtualTable) noexcept :
+ IsValid(true),
+ pVT(pVirtualTable),
+ pReflectionData(nullptr),
+ pD3DObject(nullptr),
+ CBDepCount(0),
+ pCBDeps(nullptr),
+ SampDepCount(0),
+ pSampDeps(nullptr),
+ InterfaceDepCount(0),
+ pInterfaceDeps(nullptr),
+ ResourceDepCount(0),
+ pResourceDeps(nullptr),
+ UAVDepCount(0),
+ pUAVDeps(nullptr),
+ TBufferDepCount(0),
+ ppTbufDeps(nullptr),
+ pInputSignatureBlob(nullptr)
{
- IsValid = true;
-
- pVT = pVirtualTable;
-
- pReflectionData = nullptr;
-
- pD3DObject = nullptr;
-
- CBDepCount = 0;
- pCBDeps = nullptr;
-
- SampDepCount = 0;
- pSampDeps = nullptr;
-
- InterfaceDepCount = 0;
- pInterfaceDeps = nullptr;
-
- ResourceDepCount = 0;
- pResourceDeps = nullptr;
-
- UAVDepCount = 0;
- pUAVDeps = nullptr;
-
- TBufferDepCount = 0;
- ppTbufDeps = nullptr;
-
- pInputSignatureBlob = nullptr;
}
HRESULT SShaderBlock::OnDeviceBind()
D3D11_SHADER_DESC ShaderDesc;
VH( pReflectionData->pReflection->GetDesc( &ShaderDesc ) );
- D3D11_SIGNATURE_PARAMETER_DESC ParamDesc ={0};
+ D3D11_SIGNATURE_PARAMETER_DESC ParamDesc ={};
if( pReflectionData->IsNullGS )
{
switch( SigType )
return hr;
}
-SString::SString()
-{
- pString = nullptr;
-}
-
-SRenderTargetView::SRenderTargetView()
-{
- pRenderTargetView = nullptr;
-}
-
-SDepthStencilView::SDepthStencilView()
-{
- pDepthStencilView = nullptr;
-}
-
void * GetBlockByIndex(EVarType VarType, EObjectType ObjectType, void *pBaseBlock, uint32_t Index)
{
switch( VarType )
// CEffect
//--------------------------------------------------------------------------------------
-CEffect::CEffect( uint32_t Flags )
+CEffect::CEffect( uint32_t Flags ) noexcept :
+ m_RefCount(1),
+ m_Flags(Flags),
+ m_pReflection(nullptr),
+ m_VariableCount(0),
+ m_pVariables(nullptr),
+ m_AnonymousShaderCount(0),
+ m_pAnonymousShaders(nullptr),
+ m_TechniqueCount(0),
+ m_GroupCount(0),
+ m_pGroups(nullptr),
+ m_pNullGroup(nullptr),
+ m_ShaderBlockCount(0),
+ m_pShaderBlocks(nullptr),
+ m_DepthStencilBlockCount(0),
+ m_pDepthStencilBlocks(nullptr),
+ m_BlendBlockCount(0),
+ m_pBlendBlocks(nullptr),
+ m_RasterizerBlockCount(0),
+ m_pRasterizerBlocks(nullptr),
+ m_SamplerBlockCount(0),
+ m_pSamplerBlocks(nullptr),
+ m_MemberDataCount(0),
+ m_pMemberDataBlocks(nullptr),
+ m_InterfaceCount(0),
+ m_pInterfaces(nullptr),
+ m_CBCount(0),
+ m_pCBs(nullptr),
+ m_StringCount(0),
+ m_pStrings(nullptr),
+ m_ShaderResourceCount(0),
+ m_pShaderResources(nullptr),
+ m_UnorderedAccessViewCount(0),
+ m_pUnorderedAccessViews(nullptr),
+ m_RenderTargetViewCount(0),
+ m_pRenderTargetViews(nullptr),
+ m_DepthStencilViewCount(0),
+ m_pDepthStencilViews(nullptr),
+ m_LocalTimer(1),
+ m_FXLIndex(0),
+ m_pDevice(nullptr),
+ m_pContext(nullptr),
+ m_pClassLinkage(nullptr),
+ m_pTypePool(nullptr),
+ m_pStringPool(nullptr),
+ m_pPooledHeap(nullptr),
+ m_pOptimizedTypeHeap(nullptr)
{
- m_RefCount = 1;
-
- m_pVariables = nullptr;
- m_pAnonymousShaders = nullptr;
- m_pGroups = nullptr;
- m_pNullGroup = nullptr;
- m_pShaderBlocks = nullptr;
- m_pDepthStencilBlocks = nullptr;
- m_pBlendBlocks = nullptr;
- m_pRasterizerBlocks = nullptr;
- m_pSamplerBlocks = nullptr;
- m_pCBs = nullptr;
- m_pStrings = nullptr;
- m_pMemberDataBlocks = nullptr;
- m_pInterfaces = nullptr;
- m_pShaderResources = nullptr;
- m_pUnorderedAccessViews = nullptr;
- m_pRenderTargetViews = nullptr;
- m_pDepthStencilViews = nullptr;
- m_pDevice = nullptr;
- m_pClassLinkage = nullptr;
- m_pContext = nullptr;
-
- m_VariableCount = 0;
- m_AnonymousShaderCount = 0;
- m_ShaderBlockCount = 0;
- m_DepthStencilBlockCount = 0;
- m_BlendBlockCount = 0;
- m_RasterizerBlockCount = 0;
- m_SamplerBlockCount = 0;
- m_StringCount = 0;
- m_MemberDataCount = 0;
- m_InterfaceCount = 0;
- m_ShaderResourceCount = 0;
- m_UnorderedAccessViewCount = 0;
- m_RenderTargetViewCount = 0;
- m_DepthStencilViewCount = 0;
- m_CBCount = 0;
- m_TechniqueCount = 0;
- m_GroupCount = 0;
-
- m_pReflection = nullptr;
- m_LocalTimer = 1;
- m_Flags = Flags;
- m_FXLIndex = 0;
-
- m_pTypePool = nullptr;
- m_pStringPool = nullptr;
- m_pPooledHeap = nullptr;
- m_pOptimizedTypeHeap = nullptr;
}
void CEffect::ReleaseShaderRefection()
if (pInfoQueue)
{
- D3D11_INFO_QUEUE_FILTER filter;
+ D3D11_INFO_QUEUE_FILTER filter = {};
D3D11_MESSAGE_CATEGORY messageCategory = D3D11_MESSAGE_CATEGORY_STATE_SETTING;
- ZeroMemory(&filter, sizeof(filter));
filter.DenyList.NumCategories = 1;
filter.DenyList.pCategoryList = &messageCategory;
//
// Direct3D 11 Effects public reflection APIs
//
-//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
// ID3DX11EffectShaderVariable (SAnonymousShader implementation)
////////////////////////////////////////////////////////////////////////////////
-SAnonymousShader::SAnonymousShader(_In_opt_ SShaderBlock *pBlock) : pShaderBlock(pBlock)
+SAnonymousShader::SAnonymousShader(_In_opt_ SShaderBlock *pBlock) noexcept :
+ pShaderBlock(pBlock)
{
}
if( FAILED( strcpy_s( NameCopy, MAX_GROUP_TECHNIQUE_SIZE, Name ) ) )
{
- DPF( 0, "Group|Technique name has a length greater than %u.", MAX_GROUP_TECHNIQUE_SIZE );
+ DPF( 0, "Group|Technique name has a length greater than %zu.", MAX_GROUP_TECHNIQUE_SIZE );
return &g_InvalidTechnique;
}
// These functions are expected to be called at high frequency
// (when applying a pass).
//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
{
m_LocalTimer++;
-#ifndef _M_X64
+#if !defined(_M_X64) && !defined(_M_ARM64)
#if _DEBUG
if (m_LocalTimer > g_TimerRolloverCount)
{
- DPF(0, "Rolling over timer (current time: %u, rollover cap: %u).", m_LocalTimer, g_TimerRolloverCount);
+ DPF(0, "Rolling over timer (current time: %zu, rollover cap: %u).", m_LocalTimer, g_TimerRolloverCount);
#else
if (m_LocalTimer >= 0x80000000) // check to see if we've exceeded ~2 billion
{
//
// Direct3D 11 Effects States Header
//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
// This file defines properties of states which can appear in
// state blocks and pass blocks.
//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
// Direct3D 11 Effects Variable reflection template
// These templates define the many Effect variable types.
//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
return pEffect;
}
- TTopLevelVariable() : pEffect (nullptr)
+ TTopLevelVariable() noexcept :
+ pEffect(nullptr)
{
}
// Required to create member/element variable interfaces
TTopLevelVariable<ID3DX11EffectVariable> *pTopLevelEntity;
- TMember()
+ TMember() noexcept :
+ IsSingleElement(false),
+ pTopLevelEntity(nullptr)
{
- IsSingleElement = false;
- pTopLevelEntity = nullptr;
}
CEffect* GetEffect()
// if numeric, pointer to the constant buffer where this variable lives
SConstantBuffer *pCB;
- uint32_t AnnotationCount;
+ uint32_t AnnotationCount;
SAnnotation *pAnnotations;
- TGlobalVariable() :
+ TGlobalVariable() noexcept :
LastModifiedTime(0),
pCB(nullptr),
AnnotationCount(0),
// Lifetime for most Effects objects is based on the the lifetime of the master
// effect, so the reference count is not used.
//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
The MIT License (MIT)
-Copyright (c) 2017 Microsoft Corp
+Copyright (c) 2009-2020 Microsoft Corp
Permission is hereby granted, free of charge, to any person obtaining a copy of this
software and associated documentation files (the "Software"), to deal in the Software
//
// Direct3D 11 Effects Stream Out Decl Parser
//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
char m_pError[ MAX_ERROR_SIZE + 1 ]; // Error buffer
public:
- CSOParser()
+ CSOParser() noexcept :
+ m_newEntry{},
+ m_SemanticString{},
+ m_pError{}
{
- ZeroMemory(&m_newEntry, sizeof(m_newEntry));
- ZeroMemory(m_SemanticString, sizeof(m_SemanticString));
- m_pError[0] = 0;
}
~CSOParser()
//
// Direct3D 11 Effect Types & APIs Header
//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
#pragma once
-#define D3DX11_EFFECTS_VERSION 1121
+#define D3DX11_EFFECTS_VERSION 1126
#if defined(_XBOX_ONE) && defined(_TITLE)
#include <d3d11_x.h>
-#define DCOMMON_H_INCLUDED
#define NO_D3D11_DEBUG_NAME
#else
#include <d3d11_1.h>
_Out_ ID3DX11Effect **ppEffect,
_Outptr_opt_result_maybenull_ ID3DBlob **ppErrors );
+
+//----------------------------------------------------------------------------
+// D3DX11DebugMute
+//
+// Controls the output of diagnostic information in DEBUG builds. No effect
+// in RELEASE builds.
+//
+// Returns the previous state so you can do temporary suppression like:
+//
+// bool oldmute = D3DX11DebugMute(true);
+// ...
+// D3DX11DebugMute(oldmute);
+//
+//----------------------------------------------------------------------------
+
+bool D3DX11DebugMute(bool mute);
+
#ifdef __cplusplus
}
#endif //__cplusplus
//
// Direct3D 11 Effects implementation for helper data structures
//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
namespace D3DX11Core
{
-//////////////////////////////////////////////////////////////////////////
-// CMemoryStream - A class to simplify reading binary data
-//////////////////////////////////////////////////////////////////////////
+ //////////////////////////////////////////////////////////////////////////
+ // CMemoryStream - A class to simplify reading binary data
+ //////////////////////////////////////////////////////////////////////////
-CMemoryStream::CMemoryStream() : m_pData(nullptr), m_cbData(0), m_readPtr(0)
-{
-}
+ CMemoryStream::CMemoryStream() noexcept :
+ m_pData(nullptr),
+ m_cbData(0),
+ m_readPtr(0)
+ {
+ }
-CMemoryStream::~CMemoryStream()
-{
-}
+ CMemoryStream::~CMemoryStream()
+ {
+ }
-_Use_decl_annotations_
-HRESULT CMemoryStream::SetData(const void *pData, size_t size)
-{
- m_pData = (uint8_t*) pData;
- m_cbData = size;
- m_readPtr = 0;
+ _Use_decl_annotations_
+ HRESULT CMemoryStream::SetData(const void* pData, size_t size)
+ {
+ m_pData = (uint8_t*)pData;
+ m_cbData = size;
+ m_readPtr = 0;
- return S_OK;
-}
+ return S_OK;
+ }
-_Use_decl_annotations_
-HRESULT CMemoryStream::ReadAtOffset(size_t offset, size_t size, void **ppData)
-{
- if (offset >= m_cbData)
- return E_FAIL;
+ _Use_decl_annotations_
+ 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);
-}
+ m_readPtr = offset;
+ return Read(ppData, size);
+ }
-_Use_decl_annotations_
-HRESULT CMemoryStream::ReadAtOffset(size_t offset, LPCSTR *ppString)
-{
- if (offset >= m_cbData)
- return E_FAIL;
+ _Use_decl_annotations_
+ HRESULT CMemoryStream::ReadAtOffset(size_t offset, LPCSTR* ppString)
+ {
+ if (offset >= m_cbData)
+ return E_FAIL;
- m_readPtr = offset;
- return Read(ppString);
-}
+ m_readPtr = offset;
+ return Read(ppString);
+ }
-_Use_decl_annotations_
-HRESULT CMemoryStream::Read(void **ppData, size_t size)
-{
- size_t temp = m_readPtr + size;
+ _Use_decl_annotations_
+ HRESULT CMemoryStream::Read(void** ppData, size_t size)
+ {
+ size_t temp = m_readPtr + size;
- if (temp < m_readPtr || temp > m_cbData)
- return E_FAIL;
+ if (temp < m_readPtr || temp > m_cbData)
+ return E_FAIL;
- *ppData = m_pData + m_readPtr;
- m_readPtr = temp;
- return S_OK;
-}
+ *ppData = m_pData + m_readPtr;
+ m_readPtr = temp;
+ return S_OK;
+ }
-_Use_decl_annotations_
-HRESULT CMemoryStream::Read(uint32_t *pDword)
-{
- uint32_t *pTempDword;
- HRESULT hr;
+ _Use_decl_annotations_
+ HRESULT CMemoryStream::Read(uint32_t* pDword)
+ {
+ uint32_t* pTempDword;
+ HRESULT hr;
- hr = Read((void**) &pTempDword, sizeof(uint32_t));
- if (FAILED(hr))
- return E_FAIL;
+ hr = Read((void**)&pTempDword, sizeof(uint32_t));
+ if (FAILED(hr))
+ return E_FAIL;
- *pDword = *pTempDword;
- return S_OK;
-}
+ *pDword = *pTempDword;
+ return S_OK;
+ }
-_Use_decl_annotations_
-HRESULT CMemoryStream::Read(LPCSTR *ppString)
-{
- size_t iChar=m_readPtr;
- for(; m_pData[iChar]; iChar++)
+ _Use_decl_annotations_
+ HRESULT CMemoryStream::Read(LPCSTR* ppString)
{
- if (iChar > m_cbData)
- return E_FAIL;
- }
+ size_t iChar = m_readPtr;
+ for (; m_pData[iChar]; iChar++)
+ {
+ if (iChar > m_cbData)
+ return E_FAIL;
+ }
- *ppString = (LPCSTR) (m_pData + m_readPtr);
- m_readPtr = iChar;
+ *ppString = (LPCSTR)(m_pData + m_readPtr);
+ m_readPtr = iChar;
- return S_OK;
-}
+ return S_OK;
+ }
-size_t CMemoryStream::GetPosition()
-{
- return m_readPtr;
-}
+ size_t CMemoryStream::GetPosition()
+ {
+ return m_readPtr;
+ }
-HRESULT CMemoryStream::Seek(_In_ size_t offset)
-{
- if (offset > m_cbData)
- return E_FAIL;
+ HRESULT CMemoryStream::Seek(_In_ size_t offset)
+ {
+ if (offset > m_cbData)
+ return E_FAIL;
- m_readPtr = offset;
- return S_OK;
-}
+ m_readPtr = offset;
+ return S_OK;
+ }
}
// CDataBlock - used to dynamically build up the effect file in memory
//////////////////////////////////////////////////////////////////////////
-CDataBlock::CDataBlock() :
+CDataBlock::CDataBlock() noexcept :
m_size(0),
m_maxSize(0),
m_pData(nullptr),
}
_Use_decl_annotations_
-HRESULT CDataBlock::AddData(const void *pvNewData, uint32_t bufferSize, CDataBlock **ppBlock)
+HRESULT CDataBlock::AddData(const void* pvNewData, uint32_t bufferSize, CDataBlock** ppBlock)
{
HRESULT hr = S_OK;
uint32_t bytesToCopy;
- const uint8_t *pNewData = (const uint8_t*) pvNewData;
+ const uint8_t* pNewData = (const uint8_t*)pvNewData;
if (m_maxSize == 0)
{
// This is a brand new DataBlock, fill it up
m_maxSize = std::max<uint32_t>(8192, bufferSize);
- VN( m_pData = new uint8_t[m_maxSize] );
+ VN(m_pData = new uint8_t[m_maxSize]);
}
assert(m_pData == AlignToPowerOf2(m_pData, c_DataAlignment));
bytesToCopy = std::min(m_maxSize - m_size, bufferSize);
memcpy(m_pData + m_size, pNewData, bytesToCopy);
pNewData += bytesToCopy;
-
+
if (m_IsAligned)
{
assert(m_size == AlignToPowerOf2(m_size, c_DataAlignment));
{
m_size += bytesToCopy;
}
-
+
bufferSize -= bytesToCopy;
*ppBlock = this;
assert(nullptr == 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() );
+ VN(m_pNext = new CDataBlock());
if (m_IsAligned)
{
m_pNext->EnableAlignment();
}
- VH( m_pNext->AddData(pNewData, bufferSize, ppBlock) );
+ VH(m_pNext->AddData(pNewData, bufferSize, ppBlock));
}
lExit:
}
_Use_decl_annotations_
-void* CDataBlock::Allocate(uint32_t bufferSize, CDataBlock **ppBlock)
+void* CDataBlock::Allocate(uint32_t bufferSize, CDataBlock** ppBlock)
{
- void *pRetValue;
+ void* pRetValue;
uint32_t temp = m_size + bufferSize;
if (temp < m_size)
//////////////////////////////////////////////////////////////////////////
-CDataBlockStore::CDataBlockStore() :
+CDataBlockStore::CDataBlockStore() noexcept :
m_pFirst(nullptr),
m_pLast(nullptr),
m_Size(0),
{
// 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)
+ while (pData)
{
CDataBlock* pCurrent = pData;
pData = pData->m_pNext;
}
_Use_decl_annotations_
-HRESULT CDataBlockStore::AddString(LPCSTR pString, uint32_t *pOffset)
+HRESULT CDataBlockStore::AddString(LPCSTR pString, uint32_t* pOffset)
{
size_t strSize = strlen(pString) + 1;
- assert( strSize <= 0xffffffff );
+ assert(strSize <= 0xffffffff);
return AddData(pString, (uint32_t)strSize, pOffset);
}
_Use_decl_annotations_
-HRESULT CDataBlockStore::AddData(const void *pNewData, uint32_t bufferSize, uint32_t *pCurOffset)
+HRESULT CDataBlockStore::AddData(const void* pNewData, uint32_t bufferSize, uint32_t* pCurOffset)
{
HRESULT hr = S_OK;
if (bufferSize == 0)
- {
+ {
if (pCurOffset)
{
*pCurOffset = 0;
if (!m_pFirst)
{
- VN( m_pFirst = new CDataBlock() );
+ VN(m_pFirst = new CDataBlock());
if (m_IsAligned)
{
m_pFirst->EnableAlignment();
if (pCurOffset)
*pCurOffset = m_Size + m_Offset;
- VH( m_pLast->AddData(pNewData, bufferSize, &m_pLast) );
+ VH(m_pLast->AddData(pNewData, bufferSize, &m_pLast));
m_Size += bufferSize;
lExit:
void* CDataBlockStore::Allocate(_In_ uint32_t bufferSize)
{
- void *pRetValue = nullptr;
+ void* pRetValue = nullptr;
#if _DEBUG
m_cAllocations++;
//////////////////////////////////////////////////////////////////////////
+static bool s_mute = false;
+
+bool D3DX11DebugMute(bool mute)
+{
+ bool previous = s_mute;
+ s_mute = mute;
+ return previous;
+}
+
#ifdef _DEBUG
_Use_decl_annotations_
void __cdecl D3DXDebugPrintf(UINT lvl, LPCSTR szFormat, ...)
{
+ if (s_mute)
+ return;
+
UNREFERENCED_PARAMETER(lvl);
- char strA[4096];
- char strB[4096];
+ char strA[4096] = {};
+ char strB[4096] = {};
va_list ap;
va_start(ap, szFormat);
//
// Direct3D 11 Effects helper defines and data structures
//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
size_t GetPosition();
HRESULT Seek(_In_ size_t offset);
- CMemoryStream();
+ CMemoryStream() noexcept;
~CMemoryStream();
};
}
-#if defined(_DEBUG) && !defined(_M_X64)
+#if defined(_DEBUG) && !defined(_M_X64) && !defined(_M_ARM64)
namespace D3DX11Debug
{
public:
HRESULT m_hLastError;
- CEffectVector<T>() : m_hLastError(S_OK), m_pData(nullptr), m_CurSize(0), m_MaxSize(0)
+ CEffectVector<T>() noexcept :
+ m_hLastError(S_OK),
+ m_pData(nullptr),
+ m_CurSize(0),
+ m_MaxSize(0)
{
#if _DEBUG
m_pCastData = nullptr;
bool m_bValid;
public:
- CheckedNumber<T, MaxValue>() : m_Value(0), m_bValid(true)
+ CheckedNumber<T, MaxValue>() noexcept :
+ m_Value(0),
+ m_bValid(true)
{
}
void EnableAlignment();
- CDataBlock();
+ CDataBlock() noexcept;
~CDataBlock();
friend class CDataBlockStore;
uint32_t GetSize();
void EnableAlignment();
- CDataBlockStore();
+ CDataBlockStore() noexcept;
~CDataBlockStore();
};
}
};
- CEffectHashTable() : m_rgpHashEntries(nullptr), m_NumHashSlots(0), m_NumEntries(0), m_bOwnHashEntryArray(false)
+ CEffectHashTable() noexcept :
+ m_rgpHashEntries(nullptr),
+ m_NumHashSlots(0),
+ m_NumEntries(0),
+ m_bOwnHashEntryArray(false)
{
}
CDataBlockStore *m_pPrivateHeap;
public:
- CEffectHashTableWithPrivateHeap()
+ CEffectHashTableWithPrivateHeap() noexcept :
+ m_pPrivateHeap(nullptr)
{
- m_pPrivateHeap = nullptr;
}
void Cleanup()
//
// Direct3D 11 shader effects precompiled header
//
-// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
-// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
-// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
-// PARTICULAR PURPOSE.
-//
// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
//
// http://go.microsoft.com/fwlink/p/?LinkId=271568
//--------------------------------------------------------------------------------------
projects / francis / winuae.git / commitdiff