mirror of
https://github.com/ARMSX2/ARMSX2.git
synced 2026-08-24 16:50:16 -07:00
3rdparty: Update D3D12MA to v3.1.0
This commit is contained in:
JordanTheToaster
committed by
lightningterror
lightningterror
parent
f50ad3b63e
commit
6794bae8da
Vendored
+11
@@ -1,3 +1,14 @@
|
||||
# 3.1.0 (2026-02-23)
|
||||
|
||||
- Added supported for resource tight alignment (feature added in Agility SDK 1.618.1). It is used automatically when available.
|
||||
- Added function `Allocator::IsTightAlignmentSupported`.
|
||||
- Added `ALLOCATOR_FLAG_DONT_USE_TIGHT_ALIGNMENT`.
|
||||
- Fixes and improvements in the internal function `AllocatorPimpl::GetResourceAllocationInfo` (which decides when to use small alignment or tight alignment), including:
|
||||
- Added support for 1D and 3D textures when `D3D12MA_USE_SMALL_RESOURCE_PLACEMENT_ALIGNMENT = 2` (#78, #79).
|
||||
- Fix for cases when `D3D12_TEXTURE_LAYOUT_64KB_*_SWIZZLE` is used (#86).
|
||||
- Fixes for build errors in MinGW (#77).
|
||||
- Fixes and improvements in documentation and tests.
|
||||
|
||||
# 3.0.1 (2025-05-08)
|
||||
|
||||
- Fixed macros `D3D12MA_RECOMMENDED_ALLOCATOR_FLAGS`, `D3D12MA_RECOMMENDED_POOL_FLAGS` (#73).
|
||||
|
||||
Vendored
+1
-1
@@ -1,4 +1,4 @@
|
||||
Copyright (c) 2019-2025 Advanced Micro Devices, Inc. All rights reserved.
|
||||
Copyright (c) 2019-2026 Advanced Micro Devices, Inc. All rights reserved.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
|
||||
Vendored
+1
-1
@@ -8,7 +8,7 @@ Easy to integrate memory allocation library for Direct3D 12.
|
||||
|
||||
**Changelog:** See [CHANGELOG.md](CHANGELOG.md)
|
||||
|
||||
**Product page:** [D3D12 Memory Allocator on GPUOpen](https://gpuopen.com/gaming-product/d3d12-memory-allocator/)
|
||||
**Product page:** [D3D12 Memory Allocator on GPUOpen](https://gpuopen.com/d3d12-memory-allocator/)
|
||||
|
||||
[](http://isitmaintained.com/project/GPUOpen-LibrariesAndSDKs/D3D12MemoryAllocator "Average time to resolve an issue")
|
||||
|
||||
|
||||
+42
-6
@@ -1,5 +1,5 @@
|
||||
//
|
||||
// Copyright (c) 2019-2025 Advanced Micro Devices, Inc. All rights reserved.
|
||||
// Copyright (c) 2019-2026 Advanced Micro Devices, Inc. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
@@ -24,9 +24,9 @@
|
||||
|
||||
/** \mainpage D3D12 Memory Allocator
|
||||
|
||||
<b>Version 3.0.1</b> (2025-05-08)
|
||||
<b>Version 3.1.0</b> (2026-02-23)
|
||||
|
||||
Copyright (c) 2019-2025 Advanced Micro Devices, Inc. All rights reserved. \n
|
||||
Copyright (c) 2019-2026 Advanced Micro Devices, Inc. All rights reserved. \n
|
||||
License: MIT
|
||||
|
||||
Documentation of all members: D3D12MemAlloc.h
|
||||
@@ -64,7 +64,7 @@ Documentation of all members: D3D12MemAlloc.h
|
||||
|
||||
\section main_see_also Web links
|
||||
|
||||
- [Direct3D 12 Memory Allocator at GPUOpen.com](https://gpuopen.com/gaming-product/d3d12-memory-allocator/) - product page
|
||||
- [Direct3D 12 Memory Allocator at GPUOpen.com](https://gpuopen.com/d3d12-memory-allocator/) - product page
|
||||
- [GPUOpen-LibrariesAndSDKs/D3D12MemoryAllocator at GitHub.com](https://github.com/GPUOpen-LibrariesAndSDKs/D3D12MemoryAllocator) - source code repository
|
||||
*/
|
||||
|
||||
@@ -1112,8 +1112,19 @@ enum ALLOCATOR_FLAGS
|
||||
which may take longer than creating placed resources in existing heaps.
|
||||
Passing this flag will disable this committed preference globally for the allocator.
|
||||
It can also be disabled for a single allocation by using #ALLOCATION_FLAG_STRATEGY_MIN_TIME.
|
||||
|
||||
If the tight resource alignment feature is used by the library (which happens automatically whenever supported,
|
||||
unless you use flag #ALLOCATOR_FLAG_DONT_USE_TIGHT_ALIGNMENT), then small buffers are not preferred as committed.
|
||||
Long story short, you don't need to specify any of these flags.
|
||||
The library chooses the most optimal method automatically.
|
||||
*/
|
||||
ALLOCATOR_FLAG_DONT_PREFER_SMALL_BUFFERS_COMMITTED = 0x10,
|
||||
/** Disables the use of the tight alignment feature even when it is supported on the current system.
|
||||
By default, the feature is used whenever available.
|
||||
|
||||
Support can be checked by D3D12MA::Allocator::IsTightAlignmentSupported() regardless of using this flag.
|
||||
*/
|
||||
ALLOCATOR_FLAG_DONT_USE_TIGHT_ALIGNMENT = 0x20,
|
||||
};
|
||||
|
||||
/// \brief Parameters of created Allocator object. To be used with CreateAllocator().
|
||||
@@ -1189,6 +1200,12 @@ public:
|
||||
This flag is fetched from `D3D12_FEATURE_D3D12_OPTIONS16::GPUUploadHeapSupported`.
|
||||
*/
|
||||
BOOL IsGPUUploadHeapSupported() const;
|
||||
/** \brief Returns true if resource tight alignment is supported on the current system.
|
||||
When supported, it is automatically used by the library, unless
|
||||
#ALLOCATOR_FLAG_DONT_USE_TIGHT_ALIGNMENT flag was specified on allocator creation.
|
||||
This flag is fetched from `D3D12_FEATURE_DATA_TIGHT_ALIGNMENT::SupportTier`.
|
||||
*/
|
||||
BOOL IsTightAlignmentSupported() const;
|
||||
/** \brief Returns total amount of memory of specific segment group, in bytes.
|
||||
|
||||
\param memorySegmentGroup use `DXGI_MEMORY_SEGMENT_GROUP_LOCAL` or `DXGI_MEMORY_SEGMENT_GROUP_NON_LOCAL`.
|
||||
@@ -1800,7 +1817,7 @@ DEFINE_ENUM_FLAG_OPERATORS(D3D12MA::VIRTUAL_ALLOCATION_FLAGS);
|
||||
/// \endcond
|
||||
|
||||
/**
|
||||
\page faq Frequenty asked questions
|
||||
\page faq Frequently asked questions
|
||||
|
||||
<b>What is %D3D12MA?</b>
|
||||
|
||||
@@ -2864,6 +2881,23 @@ and D3D12MA::POOL_FLAG_MSAA_TEXTURES_ALWAYS_COMMITTED on the creation of any cus
|
||||
With those flags, the alignment of the heaps created by %D3D12MA can be lower, but any MSAA textures are created as committed.
|
||||
You should always use these flags in your code unless you really need to create some MSAA textures as placed.
|
||||
|
||||
With DirectX 12 Agility SDK 1.618.1, Microsoft added a new feature called **"tight alignment"**.
|
||||
Note this is a separate feature than the "small alignment" described earlier.
|
||||
When using this new SDK and a compatible graphics driver, the API exposes support for this new feature.
|
||||
Then, a new flag `D3D12_RESOURCE_FLAG_USE_TIGHT_ALIGNMENT` can be added when creating a resource.
|
||||
D3D12 can then return the alignment required for the resource smaller than the default ones described above.
|
||||
This library automatically makes use of the tight alignment feature when available and adds that new resource flag.
|
||||
When the tight alignment is enabled, the heuristics that creates small buffers as committed described above is deactivated,
|
||||
as it is no longer needed.
|
||||
|
||||
You can check if the tight alignment it is available in the current system by calling D3D12MA::Allocator::IsTightAlignmentSupported().
|
||||
You can tell the library to not use it by specifying D3D12MA::ALLOCATOR_FLAG_DONT_USE_TIGHT_ALIGNMENT.
|
||||
Typically, you don't need to do any of those.
|
||||
|
||||
The library automatically aligns all buffers to at least 256 B, even when the system supports smaller alignment.
|
||||
This is the alignment required for constant buffers, expressed by `D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT` constant.
|
||||
You can override this logic for \subpage custom_pools with a specific D3D12MA::POOL_DESC::MinAllocationAlignment.
|
||||
|
||||
\page defragmentation Defragmentation
|
||||
|
||||
Interleaved allocations and deallocations of many objects of varying size can
|
||||
@@ -3558,7 +3592,7 @@ Features deliberately excluded from the scope of this library:
|
||||
- **Descriptor allocation.** Although also called "heaps", objects that represent
|
||||
descriptors are separate part of the D3D12 API from buffers and textures.
|
||||
You can still use \ref virtual_allocator to manage descriptors and their ranges inside a descriptor heap.
|
||||
- **Support for reserved (tiled) resources.** We don't recommend using them.
|
||||
- **Support for reserved (tiled) resources.** We don't recommend using them. For more information, see [1].
|
||||
- Support for `ID3D12Device::Evict` and `MakeResident`. We don't recommend using them.
|
||||
You can call them on the D3D12 objects manually.
|
||||
Plese keep in mind, however, that eviction happens on the level of entire `ID3D12Heap` memory blocks
|
||||
@@ -3575,4 +3609,6 @@ Features deliberately excluded from the scope of this library:
|
||||
It is recommended to disable such warnings instead.
|
||||
- This is a C++ library. **Bindings or ports to any other programming languages** are welcome as external projects but
|
||||
are not going to be included into this repository.
|
||||
|
||||
[1] Antoine Richermoz, Fabrice Neyret. The Sad State of Hardware Virtual Textures. UGA - Universite Grenoble Alpes; INRIA Grenoble - Rhone-Alpes. 2025, pp.13. hal-05138369
|
||||
*/
|
||||
|
||||
+104
-21
@@ -1,5 +1,5 @@
|
||||
//
|
||||
// Copyright (c) 2019-2025 Advanced Micro Devices, Inc. All rights reserved.
|
||||
// Copyright (c) 2019-2026 Advanced Micro Devices, Inc. All rights reserved.
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
// of this software and associated documentation files (the "Software"), to deal
|
||||
@@ -33,11 +33,24 @@
|
||||
#include <shared_mutex>
|
||||
#endif
|
||||
|
||||
// Includes needed for MinGW - see #71.
|
||||
#ifndef _MSC_VER
|
||||
#include <guiddef.h>
|
||||
// guiddef.h must be included first.
|
||||
#include <dxguids.h>
|
||||
// On older mingw versions, using the Agility SDK will cause linker errors unless dxguids.h is included.
|
||||
// But on newer mingw versions, the includes aren't necessary thus no need to grab DirectX-Headers.
|
||||
// Release cycles are slow for LTS distros on Linux, so this codeblock will need to stay for a few years.
|
||||
#if defined(__MINGW64_VERSION_MAJOR) && defined(__MINGW64_VERSION_MINOR) && \
|
||||
defined(__MINGW64_VERSION_BUGFIX) && defined(__ID3D12Device8_INTERFACE_DEFINED__)
|
||||
#define D3D12MA_MAKE_MINGW_VERSION(x, y, z) ((x << 20u) | (y << 10u) | (z))
|
||||
#if D3D12MA_MAKE_MINGW_VERSION(__MINGW64_VERSION_MAJOR, __MINGW64_VERSION_MINOR, \
|
||||
__MINGW64_VERSION_BUGFIX) <= D3D12MA_MAKE_MINGW_VERSION(11, 0, 1)
|
||||
#if defined(__has_include)
|
||||
#if !__has_include(<dxguids.h>)
|
||||
#error "mingw or gcc detected. dxguids.h is needed. You can grab it from https://github.com/microsoft/DirectX-Headers or if you're on Ubuntu just run sudo apt install directx-headers-dev"
|
||||
#endif
|
||||
#endif
|
||||
#include <guiddef.h>
|
||||
// // guiddef.h must be included first.
|
||||
#include <dxguids.h>
|
||||
#endif
|
||||
#undef D3D12MA_MAKE_MINGW_VERSION
|
||||
#endif
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
@@ -93,6 +106,14 @@
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef D3D12MA_DEFAULT_ALIGNMENT
|
||||
/*
|
||||
Default alignment of allocations in default pools and custom pools with MinAllocationAlignment == 0.
|
||||
Can be lowered for custom pools by specifying custom MinAllocationAlignment > 0.
|
||||
*/
|
||||
#define D3D12MA_DEFAULT_ALIGNMENT D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT
|
||||
#endif
|
||||
|
||||
#ifndef D3D12MA_DEBUG_ALIGNMENT
|
||||
/*
|
||||
Minimum alignment of all allocations, in bytes.
|
||||
@@ -126,6 +147,14 @@ especially to test compatibility with D3D12_RESOURCE_HEAP_TIER_1 on modern GPUs.
|
||||
#define D3D12MA_DEFAULT_BLOCK_SIZE (64ull * 1024 * 1024)
|
||||
#endif
|
||||
|
||||
#ifndef D3D12MA_TIGHT_ALIGNMENT_SUPPORTED
|
||||
#if D3D12_SDK_VERSION >= 618
|
||||
#define D3D12MA_TIGHT_ALIGNMENT_SUPPORTED 1
|
||||
#else
|
||||
#define D3D12MA_TIGHT_ALIGNMENT_SUPPORTED 0
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifndef D3D12MA_OPTIONS16_SUPPORTED
|
||||
#if D3D12_SDK_VERSION >= 610
|
||||
#define D3D12MA_OPTIONS16_SUPPORTED 1
|
||||
@@ -186,6 +215,7 @@ static const D3D12_HEAP_FLAGS RESOURCE_CLASS_HEAP_FLAGS =
|
||||
static const D3D12_RESIDENCY_PRIORITY D3D12_RESIDENCY_PRIORITY_NONE = D3D12_RESIDENCY_PRIORITY(0);
|
||||
|
||||
static const D3D12_HEAP_TYPE D3D12_HEAP_TYPE_GPU_UPLOAD_COPY = (D3D12_HEAP_TYPE)5;
|
||||
static const D3D12_RESOURCE_FLAGS D3D12_RESOURCE_FLAG_USE_TIGHT_ALIGNMENT_COPY = (D3D12_RESOURCE_FLAGS)0x400;
|
||||
|
||||
#ifndef _D3D12MA_ENUM_DECLARATIONS
|
||||
|
||||
@@ -787,11 +817,9 @@ static bool ValidateAllocateMemoryParameters(
|
||||
return pAllocDesc &&
|
||||
pAllocInfo &&
|
||||
ppAllocation &&
|
||||
(pAllocInfo->Alignment == 0 ||
|
||||
pAllocInfo->Alignment == D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT ||
|
||||
pAllocInfo->Alignment == D3D12_DEFAULT_MSAA_RESOURCE_PLACEMENT_ALIGNMENT) &&
|
||||
pAllocInfo->SizeInBytes != 0 &&
|
||||
pAllocInfo->SizeInBytes % (64ull * 1024) == 0;
|
||||
IsPow2(pAllocInfo->Alignment) &&
|
||||
pAllocInfo->SizeInBytes > 0 &&
|
||||
pAllocInfo->SizeInBytes % 4 == 0;
|
||||
}
|
||||
|
||||
#endif // _D3D12MA_FUNCTIONS
|
||||
@@ -5960,6 +5988,8 @@ public:
|
||||
BOOL IsCacheCoherentUMA() const { return m_D3D12Architecture.CacheCoherentUMA; }
|
||||
bool SupportsResourceHeapTier2() const { return m_D3D12Options.ResourceHeapTier >= D3D12_RESOURCE_HEAP_TIER_2; }
|
||||
bool IsGPUUploadHeapSupported() const { return m_GPUUploadHeapSupported != FALSE; }
|
||||
bool IsTightAlignmentSupported() const { return m_TightAlignmentSupported != FALSE; }
|
||||
bool IsTightAlignmentEnabled() const { return IsTightAlignmentSupported() && m_UseTightAlignment; }
|
||||
bool UseMutex() const { return m_UseMutex; }
|
||||
AllocationObjectAllocator& GetAllocationObjectAllocator() { return m_AllocationObjectAllocator; }
|
||||
UINT GetCurrentFrameIndex() const { return m_CurrentFrameIndex.load(); }
|
||||
@@ -6046,7 +6076,8 @@ private:
|
||||
const bool m_UseMutex;
|
||||
const bool m_AlwaysCommitted;
|
||||
const bool m_MsaaAlwaysCommitted;
|
||||
const bool m_PreferSmallBuffersCommitted;
|
||||
bool m_PreferSmallBuffersCommitted;
|
||||
const bool m_UseTightAlignment;
|
||||
bool m_DefaultPoolsNotZeroed = false;
|
||||
ID3D12Device* m_Device; // AddRef
|
||||
#ifdef __ID3D12Device1_INTERFACE_DEFINED__
|
||||
@@ -6074,6 +6105,7 @@ private:
|
||||
DXGI_ADAPTER_DESC m_AdapterDesc;
|
||||
D3D12_FEATURE_DATA_D3D12_OPTIONS m_D3D12Options;
|
||||
BOOL m_GPUUploadHeapSupported = FALSE;
|
||||
BOOL m_TightAlignmentSupported = FALSE;
|
||||
D3D12_FEATURE_DATA_ARCHITECTURE m_D3D12Architecture;
|
||||
AllocationObjectAllocator m_AllocationObjectAllocator;
|
||||
|
||||
@@ -6155,7 +6187,8 @@ AllocatorPimpl::AllocatorPimpl(const ALLOCATION_CALLBACKS& allocationCallbacks,
|
||||
: m_UseMutex((desc.Flags & ALLOCATOR_FLAG_SINGLETHREADED) == 0),
|
||||
m_AlwaysCommitted((desc.Flags & ALLOCATOR_FLAG_ALWAYS_COMMITTED) != 0),
|
||||
m_MsaaAlwaysCommitted((desc.Flags & ALLOCATOR_FLAG_MSAA_TEXTURES_ALWAYS_COMMITTED) != 0),
|
||||
m_PreferSmallBuffersCommitted((desc.Flags & ALLOCATOR_FLAG_DONT_PREFER_SMALL_BUFFERS_COMMITTED) == 0),
|
||||
m_PreferSmallBuffersCommitted((desc.Flags& ALLOCATOR_FLAG_DONT_PREFER_SMALL_BUFFERS_COMMITTED) == 0),
|
||||
m_UseTightAlignment((desc.Flags & ALLOCATOR_FLAG_DONT_USE_TIGHT_ALIGNMENT) == 0),
|
||||
m_Device(desc.pDevice),
|
||||
m_Adapter(desc.pAdapter),
|
||||
m_PreferredBlockSize(desc.PreferredBlockSize != 0 ? desc.PreferredBlockSize : D3D12MA_DEFAULT_BLOCK_SIZE),
|
||||
@@ -6244,6 +6277,25 @@ HRESULT AllocatorPimpl::Init(const ALLOCATOR_DESC& desc)
|
||||
}
|
||||
#endif // #if D3D12MA_OPTIONS16_SUPPORTED
|
||||
|
||||
#if D3D12MA_TIGHT_ALIGNMENT_SUPPORTED
|
||||
{
|
||||
D3D12_FEATURE_DATA_TIGHT_ALIGNMENT tightAlignment = {};
|
||||
hr = m_Device->CheckFeatureSupport(D3D12_FEATURE_D3D12_TIGHT_ALIGNMENT, &tightAlignment, sizeof(tightAlignment));
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
m_TightAlignmentSupported = tightAlignment.SupportTier >= D3D12_TIGHT_ALIGNMENT_TIER_1;
|
||||
|
||||
// If tight alignment is supported (checked by the code above) and wasn't disabled by the developer
|
||||
// (with ALLOCATOR_FLAG_DONT_USE_TIGHT_ALIGNMENT), disable the preference for creating small buffers as committed,
|
||||
// as if ALLOCATOR_FLAG_DONT_PREFER_SMALL_BUFFERS_COMMITTED was specified.
|
||||
if (IsTightAlignmentEnabled())
|
||||
{
|
||||
m_PreferSmallBuffersCommitted = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif // #if D3D12MA_TIGHT_ALIGNMENT_SUPPORTED
|
||||
|
||||
hr = m_Device->CheckFeatureSupport(D3D12_FEATURE_ARCHITECTURE, &m_D3D12Architecture, sizeof(m_D3D12Architecture));
|
||||
if (FAILED(hr))
|
||||
{
|
||||
@@ -6273,7 +6325,7 @@ HRESULT AllocatorPimpl::Init(const ALLOCATOR_DESC& desc)
|
||||
0, // minBlockCount
|
||||
SIZE_MAX, // maxBlockCount
|
||||
false, // explicitBlockSize
|
||||
D3D12MA_DEBUG_ALIGNMENT, // minAllocationAlignment
|
||||
(UINT64)D3D12MA_DEFAULT_ALIGNMENT, // minAllocationAlignment
|
||||
0, // Default algorithm,
|
||||
m_MsaaAlwaysCommitted,
|
||||
NULL, // pProtectedSession
|
||||
@@ -6940,6 +6992,9 @@ void AllocatorPimpl::BuildStatsString(WCHAR** ppStatsString, BOOL detailedMap)
|
||||
|
||||
json.WriteString(L"GPUUploadHeapSupported");
|
||||
json.WriteBool(m_GPUUploadHeapSupported != FALSE);
|
||||
|
||||
json.WriteString(L"TightAlignmentSupported");
|
||||
json.WriteBool(m_TightAlignmentSupported != FALSE);
|
||||
}
|
||||
json.EndObject();
|
||||
}
|
||||
@@ -7758,8 +7813,24 @@ HRESULT AllocatorPimpl::GetResourceAllocationInfo(
|
||||
D3D12_RESOURCE_ALLOCATION_INFO& outAllocInfo) const
|
||||
{
|
||||
#ifdef __ID3D12Device1_INTERFACE_DEFINED__
|
||||
/* Optional optimization: Microsoft documentation says:
|
||||
https://docs.microsoft.com/en-us/windows/win32/api/d3d12/nf-d3d12-id3d12device-getresourceallocationinfo
|
||||
|
||||
#if D3D12MA_TIGHT_ALIGNMENT_SUPPORTED
|
||||
if (IsTightAlignmentEnabled())
|
||||
{
|
||||
// Don't allow USE_TIGHT_ALIGNMENT together with ALLOW_CROSS_ADAPTER as there is a D3D Debug Layer error:
|
||||
// D3D12 ERROR: ID3D12Device::GetResourceAllocationInfo: D3D12_RESOURCE_DESC::Flag D3D12_RESOURCE_FLAG_USE_TIGHT_ALIGNMENT will be ignored since D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER is set. [ STATE_CREATION ERROR #599: CREATERESOURCE_INVALIDMISCFLAGS]
|
||||
// Also don't allow it together with D3D12_TEXTURE_LAYOUT_64KB_*_SWIZZLE, as there is this error (see issue #86):
|
||||
// D3D12 ERROR: ID3D12Device::GetResourceAllocationInfo: D3D12_RESOURCE_DESC::Flag D3D12_RESOURCE_FLAG_USE_TIGHT_ALIGNMENT is not valid when the layout is either D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE or D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE (...). [ STATE_CREATION ERROR #599: CREATERESOURCE_INVALIDMISCFLAGS]
|
||||
if((inOutResourceDesc.Flags & D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER) == 0
|
||||
&& (inOutResourceDesc.Layout != D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE && inOutResourceDesc.Layout != D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE))
|
||||
{
|
||||
inOutResourceDesc.Flags |= D3D12_RESOURCE_FLAG_USE_TIGHT_ALIGNMENT;
|
||||
}
|
||||
}
|
||||
#endif // #if D3D12MA_TIGHT_ALIGNMENT_SUPPORTED
|
||||
|
||||
/* Optional optimization: Microsoft documentation of the ID3D12Device::
|
||||
GetResourceAllocationInfo function says:
|
||||
|
||||
Your application can forgo using GetResourceAllocationInfo for buffer resources
|
||||
(D3D12_RESOURCE_DIMENSION_BUFFER). Buffers have the same size on all adapters,
|
||||
@@ -7767,20 +7838,25 @@ HRESULT AllocatorPimpl::GetResourceAllocationInfo(
|
||||
D3D12_RESOURCE_DESC::Width.
|
||||
*/
|
||||
if (inOutResourceDesc.Alignment == 0 &&
|
||||
inOutResourceDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER)
|
||||
inOutResourceDesc.Dimension == D3D12_RESOURCE_DIMENSION_BUFFER &&
|
||||
!IsTightAlignmentEnabled())
|
||||
{
|
||||
outAllocInfo = {
|
||||
AlignUp<UINT64>(inOutResourceDesc.Width, D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT), // SizeInBytes
|
||||
D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT }; // Alignment
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
#endif // #ifdef __ID3D12Device1_INTERFACE_DEFINED__
|
||||
|
||||
HRESULT hr = S_OK;
|
||||
|
||||
#if D3D12MA_USE_SMALL_RESOURCE_PLACEMENT_ALIGNMENT
|
||||
if (inOutResourceDesc.Alignment == 0 &&
|
||||
inOutResourceDesc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE2D &&
|
||||
(inOutResourceDesc.Flags & D3D12_RESOURCE_FLAG_USE_TIGHT_ALIGNMENT_COPY) == 0 &&
|
||||
(inOutResourceDesc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE1D ||
|
||||
inOutResourceDesc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE2D ||
|
||||
inOutResourceDesc.Dimension == D3D12_RESOURCE_DIMENSION_TEXTURE3D) &&
|
||||
(inOutResourceDesc.Flags & (D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET | D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL)) == 0
|
||||
#if D3D12MA_USE_SMALL_RESOURCE_PLACEMENT_ALIGNMENT == 1
|
||||
&& CanUseSmallAlignment(inOutResourceDesc)
|
||||
@@ -8088,7 +8164,7 @@ BlockVector::BlockVector(
|
||||
m_MinBlockCount(minBlockCount),
|
||||
m_MaxBlockCount(maxBlockCount),
|
||||
m_ExplicitBlockSize(explicitBlockSize),
|
||||
m_MinAllocationAlignment(minAllocationAlignment),
|
||||
m_MinAllocationAlignment(D3D12MA_MAX(minAllocationAlignment, (UINT64)D3D12MA_DEBUG_ALIGNMENT)),
|
||||
m_Algorithm(algorithm),
|
||||
m_DenyMsaaTextures(denyMsaaTextures),
|
||||
m_ProtectedSession(pProtectedSession),
|
||||
@@ -9241,12 +9317,14 @@ PoolPimpl::PoolPimpl(AllocatorPimpl* allocator, const POOL_DESC& desc)
|
||||
D3D12MA_ASSERT(m_Desc.pProtectedSession == NULL);
|
||||
#endif
|
||||
|
||||
const UINT64 minAlignment = desc.MinAllocationAlignment > 0 ? desc.MinAllocationAlignment : D3D12MA_DEFAULT_ALIGNMENT;
|
||||
|
||||
m_BlockVector = D3D12MA_NEW(allocator->GetAllocs(), BlockVector)(
|
||||
allocator, desc.HeapProperties, desc.HeapFlags,
|
||||
preferredBlockSize,
|
||||
desc.MinBlockCount, maxBlockCount,
|
||||
explicitBlockSize,
|
||||
D3D12MA_MAX(desc.MinAllocationAlignment, (UINT64)D3D12MA_DEBUG_ALIGNMENT),
|
||||
minAlignment,
|
||||
(desc.Flags & POOL_FLAG_ALGORITHM_MASK) != 0,
|
||||
(desc.Flags & POOL_FLAG_MSAA_TEXTURES_ALWAYS_COMMITTED) != 0,
|
||||
desc.pProtectedSession,
|
||||
@@ -9709,6 +9787,11 @@ BOOL Allocator::IsGPUUploadHeapSupported() const
|
||||
return m_Pimpl->IsGPUUploadHeapSupported();
|
||||
}
|
||||
|
||||
BOOL Allocator::IsTightAlignmentSupported() const
|
||||
{
|
||||
return m_Pimpl->IsTightAlignmentSupported();
|
||||
}
|
||||
|
||||
UINT64 Allocator::GetMemoryCapacity(UINT memorySegmentGroup) const
|
||||
{
|
||||
return m_Pimpl->GetMemoryCapacity(memorySegmentGroup);
|
||||
@@ -9800,7 +9883,7 @@ HRESULT Allocator::AllocateMemory(
|
||||
return E_INVALIDARG;
|
||||
}
|
||||
D3D12MA_DEBUG_GLOBAL_MUTEX_LOCK
|
||||
return m_Pimpl->AllocateMemory(pAllocDesc, pAllocInfo, ppAllocation);
|
||||
return m_Pimpl->AllocateMemory(pAllocDesc, pAllocInfo, ppAllocation);
|
||||
}
|
||||
|
||||
HRESULT Allocator::CreateAliasingResource(
|
||||
|
||||
Reference in New Issue
Block a user