aboutsummaryrefslogtreecommitdiff
path: root/contrib/DirectX-Headers-1.618.2/googletest/MockDevice.hpp
diff options
context:
space:
mode:
author3gg <3gg@shellblade.net>2025-12-02 16:39:36 -0800
committer3gg <3gg@shellblade.net>2025-12-02 16:39:36 -0800
commit6c8ae19be66cee247980a48e736a4e05d14de179 (patch)
treed860767907bf0cbe17ec66422e11bea700cf56d9 /contrib/DirectX-Headers-1.618.2/googletest/MockDevice.hpp
parent8f594c8ebd11f0e5f8a0c6369c3fe7383d250cbe (diff)
Immediate-mode renderer, triangle demo, shader compilation in cmake, Agility SDKHEADmain
Diffstat (limited to 'contrib/DirectX-Headers-1.618.2/googletest/MockDevice.hpp')
-rw-r--r--contrib/DirectX-Headers-1.618.2/googletest/MockDevice.hpp1299
1 files changed, 1299 insertions, 0 deletions
diff --git a/contrib/DirectX-Headers-1.618.2/googletest/MockDevice.hpp b/contrib/DirectX-Headers-1.618.2/googletest/MockDevice.hpp
new file mode 100644
index 0000000..748d5ba
--- /dev/null
+++ b/contrib/DirectX-Headers-1.618.2/googletest/MockDevice.hpp
@@ -0,0 +1,1299 @@
1// Copyright (c) Microsoft Corporation.
2// Licensed under the MIT License.
3#ifndef DIRECTX_HEADERS_MOCK_DEVICE_HPP
4#define DIRECTX_HEADERS_MOCK_DEVICE_HPP
5#include <unordered_map>
6
7#ifndef __RPC_FAR
8#define __RPC_FAR
9#endif
10
11#include <directx/d3d12.h>
12#include <directx/dxcore.h>
13#include <directx/d3dx12.h>
14#include "dxguids/dxguids.h"
15
16class MockDevice : public ID3D12Device
17{
18public: // Constructors and custom functions
19 MockDevice(UINT NodeCount = 1)
20 : m_NodeCount(NodeCount)
21 , m_TileBasedRenderer(m_NodeCount, false)
22 , m_UMA(m_NodeCount, false)
23 , m_CacheCoherentUMA(m_NodeCount, false)
24 , m_IsolatedMMU(m_NodeCount, false)
25 , m_ProtectedResourceSessionSupport(m_NodeCount, D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE)
26 , m_HeapSerializationTier(m_NodeCount, D3D12_HEAP_SERIALIZATION_TIER_0)
27 , m_ProtectedResourceSessionTypeCount(m_NodeCount, 0)
28 , m_ProtectedResourceSessionTypes(m_NodeCount)
29 {
30
31 }
32
33 virtual ~MockDevice() = default;
34
35 void SetNodeCount(UINT NewCount)
36 {
37 m_NodeCount = NewCount;
38 m_TileBasedRenderer.resize(NewCount);
39 m_UMA.resize(NewCount);
40 m_CacheCoherentUMA.resize(NewCount);
41 m_IsolatedMMU.resize(NewCount);
42 m_ProtectedResourceSessionSupport.resize(NewCount);
43 m_HeapSerializationTier.resize(NewCount);
44 m_ProtectedResourceSessionTypeCount.resize(NewCount);
45 m_ProtectedResourceSessionTypes.resize(NewCount);
46 }
47
48public: // ID3D12Device
49 UINT STDMETHODCALLTYPE GetNodeCount() override
50 {
51 return m_NodeCount;
52 }
53
54 HRESULT STDMETHODCALLTYPE CreateCommandQueue(
55 _In_ const D3D12_COMMAND_QUEUE_DESC *pDesc,
56 REFIID riid,
57 _COM_Outptr_ void **ppCommandQueue
58 ) override
59 {
60 return S_OK;
61 }
62
63 HRESULT STDMETHODCALLTYPE CreateCommandAllocator(
64 _In_ D3D12_COMMAND_LIST_TYPE type,
65 REFIID riid,
66 _COM_Outptr_ void **ppCommandAllocator
67 ) override
68 {
69 return S_OK;
70 }
71
72 HRESULT STDMETHODCALLTYPE CreateGraphicsPipelineState(
73 _In_ const D3D12_GRAPHICS_PIPELINE_STATE_DESC *pDesc,
74 REFIID riid,
75 _COM_Outptr_ void **ppPipelineState
76 ) override
77 {
78 return S_OK;
79 }
80
81 HRESULT STDMETHODCALLTYPE CreateComputePipelineState(
82 _In_ const D3D12_COMPUTE_PIPELINE_STATE_DESC *pDesc,
83 REFIID riid,
84 _COM_Outptr_ void **ppPipelineState
85 ) override
86 {
87 return S_OK;
88 }
89
90 HRESULT STDMETHODCALLTYPE CreateCommandList(
91 _In_ UINT nodeMask,
92 _In_ D3D12_COMMAND_LIST_TYPE type,
93 _In_ ID3D12CommandAllocator *pCommandAllocator,
94 _In_opt_ ID3D12PipelineState *pInitialState,
95 REFIID riid,
96 _COM_Outptr_ void **ppCommandList
97 ) override
98 {
99 return S_OK;
100 }
101
102 virtual HRESULT STDMETHODCALLTYPE CreateDescriptorHeap(
103 _In_ const D3D12_DESCRIPTOR_HEAP_DESC *pDescriptorHeapDesc,
104 REFIID riid,
105 _COM_Outptr_ void **ppvHeap
106 ) override
107 {
108 return S_OK;
109 }
110
111 virtual UINT STDMETHODCALLTYPE GetDescriptorHandleIncrementSize(
112 _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapType
113 ) override
114 {
115 return 0;
116 }
117
118 virtual HRESULT STDMETHODCALLTYPE CreateRootSignature(
119 _In_ UINT nodeMask,
120 _In_reads_(blobLengthInBytes) const void *pBlobWithRootSignature,
121 _In_ SIZE_T blobLengthInBytes,
122 REFIID riid,
123 _COM_Outptr_ void **ppvRootSignature
124 ) override
125 {
126 return S_OK;
127 }
128
129 virtual void STDMETHODCALLTYPE CreateConstantBufferView(
130 _In_opt_ const D3D12_CONSTANT_BUFFER_VIEW_DESC *pDesc,
131 _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor
132 ) override
133 {
134 return;
135 }
136
137 virtual void STDMETHODCALLTYPE CreateShaderResourceView(
138 _In_opt_ ID3D12Resource *pResource,
139 _In_opt_ const D3D12_SHADER_RESOURCE_VIEW_DESC *pDesc,
140 _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor
141 ) override
142 {
143 return;
144 }
145
146 virtual void STDMETHODCALLTYPE CreateUnorderedAccessView(
147 _In_opt_ ID3D12Resource *pResource,
148 _In_opt_ ID3D12Resource *pCounterResource,
149 _In_opt_ const D3D12_UNORDERED_ACCESS_VIEW_DESC *pDesc,
150 _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor
151 ) override
152 {
153 return;
154 }
155
156 virtual void STDMETHODCALLTYPE CreateRenderTargetView(
157 _In_opt_ ID3D12Resource *pResource,
158 _In_opt_ const D3D12_RENDER_TARGET_VIEW_DESC *pDesc,
159 _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor
160 ) override
161 {
162 return;
163 }
164
165 virtual void STDMETHODCALLTYPE CreateDepthStencilView(
166 _In_opt_ ID3D12Resource *pResource,
167 _In_opt_ const D3D12_DEPTH_STENCIL_VIEW_DESC *pDesc,
168 _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) override
169 {
170 return;
171 }
172
173 virtual void STDMETHODCALLTYPE CreateSampler(
174 _In_ const D3D12_SAMPLER_DESC *pDesc,
175 _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptor) override
176 {
177 return;
178 }
179
180 virtual void STDMETHODCALLTYPE CopyDescriptors(
181 _In_ UINT NumDestDescriptorRanges,
182 _In_reads_(NumDestDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pDestDescriptorRangeStarts,
183 _In_reads_opt_(NumDestDescriptorRanges) const UINT *pDestDescriptorRangeSizes,
184 _In_ UINT NumSrcDescriptorRanges,
185 _In_reads_(NumSrcDescriptorRanges) const D3D12_CPU_DESCRIPTOR_HANDLE *pSrcDescriptorRangeStarts,
186 _In_reads_opt_(NumSrcDescriptorRanges) const UINT *pSrcDescriptorRangeSizes,
187 _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType) override
188 {
189 return;
190 }
191
192 virtual void STDMETHODCALLTYPE CopyDescriptorsSimple(
193 _In_ UINT NumDescriptors,
194 _In_ D3D12_CPU_DESCRIPTOR_HANDLE DestDescriptorRangeStart,
195 _In_ D3D12_CPU_DESCRIPTOR_HANDLE SrcDescriptorRangeStart,
196 _In_ D3D12_DESCRIPTOR_HEAP_TYPE DescriptorHeapsType) override
197 {
198 return;
199 }
200
201#if defined(_MSC_VER) || !defined(_WIN32)
202 virtual D3D12_RESOURCE_ALLOCATION_INFO STDMETHODCALLTYPE GetResourceAllocationInfo(
203 _In_ UINT visibleMask,
204 _In_ UINT numResourceDescs,
205 _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs) override
206 {
207 D3D12_RESOURCE_ALLOCATION_INFO mockInfo = {};
208 return mockInfo;
209 }
210#else
211 virtual D3D12_RESOURCE_ALLOCATION_INFO *STDMETHODCALLTYPE GetResourceAllocationInfo(
212 D3D12_RESOURCE_ALLOCATION_INFO * RetVal,
213 _In_ UINT visibleMask,
214 _In_ UINT numResourceDescs,
215 _In_reads_(numResourceDescs) const D3D12_RESOURCE_DESC *pResourceDescs) override
216 {
217 if (RetVal)
218 {
219 *RetVal = {};
220 }
221 return RetVal;
222 }
223#endif
224
225#if defined(_MSC_VER) || !defined(_WIN32)
226 virtual D3D12_HEAP_PROPERTIES STDMETHODCALLTYPE GetCustomHeapProperties(
227 _In_ UINT nodeMask,
228 D3D12_HEAP_TYPE heapType) override
229 {
230 D3D12_HEAP_PROPERTIES mockProps = {};
231 return mockProps;
232 }
233#else
234 virtual D3D12_HEAP_PROPERTIES *STDMETHODCALLTYPE GetCustomHeapProperties(
235 D3D12_HEAP_PROPERTIES * RetVal,
236 _In_ UINT nodeMask,
237 D3D12_HEAP_TYPE heapType) override
238 {
239 if (RetVal)
240 {
241 *RetVal = {};
242 }
243 return RetVal;
244 }
245#endif
246
247 virtual HRESULT STDMETHODCALLTYPE CreateCommittedResource(
248 _In_ const D3D12_HEAP_PROPERTIES *pHeapProperties,
249 D3D12_HEAP_FLAGS HeapFlags,
250 _In_ const D3D12_RESOURCE_DESC *pDesc,
251 D3D12_RESOURCE_STATES InitialResourceState,
252 _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue,
253 REFIID riidResource,
254 _COM_Outptr_opt_ void **ppvResource) override
255 {
256 return S_OK;
257 }
258
259 virtual HRESULT STDMETHODCALLTYPE CreateHeap(
260 _In_ const D3D12_HEAP_DESC *pDesc,
261 REFIID riid,
262 _COM_Outptr_opt_ void **ppvHeap) override
263 {
264 return S_OK;
265 }
266
267 virtual HRESULT STDMETHODCALLTYPE CreatePlacedResource(
268 _In_ ID3D12Heap *pHeap,
269 UINT64 HeapOffset,
270 _In_ const D3D12_RESOURCE_DESC *pDesc,
271 D3D12_RESOURCE_STATES InitialState,
272 _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue,
273 REFIID riid,
274 _COM_Outptr_opt_ void **ppvResource) override
275 {
276 return S_OK;
277 }
278
279 virtual HRESULT STDMETHODCALLTYPE CreateReservedResource(
280 _In_ const D3D12_RESOURCE_DESC *pDesc,
281 D3D12_RESOURCE_STATES InitialState,
282 _In_opt_ const D3D12_CLEAR_VALUE *pOptimizedClearValue,
283 REFIID riid,
284 _COM_Outptr_opt_ void **ppvResource) override
285 {
286 return S_OK;
287 }
288
289 virtual HRESULT STDMETHODCALLTYPE CreateSharedHandle(
290 _In_ ID3D12DeviceChild *pObject,
291 _In_opt_ const SECURITY_ATTRIBUTES *pAttributes,
292 DWORD Access,
293 _In_opt_ LPCWSTR Name,
294 _Out_ HANDLE *pHandle) override
295 {
296 return S_OK;
297 }
298
299 virtual HRESULT STDMETHODCALLTYPE OpenSharedHandle(
300 _In_ HANDLE NTHandle,
301 REFIID riid,
302 _COM_Outptr_opt_ void **ppvObj) override
303 {
304 return S_OK;
305 }
306
307 virtual HRESULT STDMETHODCALLTYPE OpenSharedHandleByName(
308 _In_ LPCWSTR Name,
309 DWORD Access,
310 /* [annotation][out] */
311 _Out_ HANDLE *pNTHandle) override
312 {
313 return S_OK;
314 }
315
316 virtual HRESULT STDMETHODCALLTYPE MakeResident(
317 UINT NumObjects,
318 _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects) override
319 {
320 return S_OK;
321 }
322
323 virtual HRESULT STDMETHODCALLTYPE Evict(
324 UINT NumObjects,
325 _In_reads_(NumObjects) ID3D12Pageable *const *ppObjects) override
326 {
327 return S_OK;
328 }
329
330 virtual HRESULT STDMETHODCALLTYPE CreateFence(
331 UINT64 InitialValue,
332 D3D12_FENCE_FLAGS Flags,
333 REFIID riid,
334 _COM_Outptr_ void **ppFence) override
335 {
336 return S_OK;
337 }
338
339 virtual HRESULT STDMETHODCALLTYPE GetDeviceRemovedReason( void) override
340 {
341 return S_OK;
342 }
343
344 virtual void STDMETHODCALLTYPE GetCopyableFootprints(
345 _In_ const D3D12_RESOURCE_DESC *pResourceDesc,
346 _In_range_(0,D3D12_REQ_SUBRESOURCES) UINT FirstSubresource,
347 _In_range_(0,D3D12_REQ_SUBRESOURCES-FirstSubresource) UINT NumSubresources,
348 UINT64 BaseOffset,
349 _Out_writes_opt_(NumSubresources) D3D12_PLACED_SUBRESOURCE_FOOTPRINT *pLayouts,
350 _Out_writes_opt_(NumSubresources) UINT *pNumRows,
351 _Out_writes_opt_(NumSubresources) UINT64 *pRowSizeInBytes,
352 _Out_opt_ UINT64 *pTotalBytes) override
353 {
354 return;
355 }
356
357 virtual HRESULT STDMETHODCALLTYPE CreateQueryHeap(
358 _In_ const D3D12_QUERY_HEAP_DESC *pDesc,
359 REFIID riid,
360 _COM_Outptr_opt_ void **ppvHeap) override
361 {
362 return S_OK;
363 }
364
365 virtual HRESULT STDMETHODCALLTYPE SetStablePowerState(
366 BOOL Enable) override
367 {
368 return S_OK;
369 }
370
371 virtual HRESULT STDMETHODCALLTYPE CreateCommandSignature(
372 _In_ const D3D12_COMMAND_SIGNATURE_DESC *pDesc,
373 _In_opt_ ID3D12RootSignature *pRootSignature,
374 REFIID riid,
375 _COM_Outptr_opt_ void **ppvCommandSignature) override
376 {
377 return S_OK;
378 }
379
380 virtual void STDMETHODCALLTYPE GetResourceTiling(
381 _In_ ID3D12Resource *pTiledResource,
382 _Out_opt_ UINT *pNumTilesForEntireResource,
383 _Out_opt_ D3D12_PACKED_MIP_INFO *pPackedMipDesc,
384 _Out_opt_ D3D12_TILE_SHAPE *pStandardTileShapeForNonPackedMips,
385 _Inout_opt_ UINT *pNumSubresourceTilings,
386 _In_ UINT FirstSubresourceTilingToGet,
387 _Out_writes_(*pNumSubresourceTilings) D3D12_SUBRESOURCE_TILING *pSubresourceTilingsForNonPackedMips) override
388 {
389 return;
390 }
391
392#if defined(_MSC_VER) || !defined(_WIN32)
393 virtual LUID STDMETHODCALLTYPE GetAdapterLuid( void) override
394 {
395 LUID mockLuid = {};
396 return mockLuid;
397 }
398#else
399 virtual LUID *STDMETHODCALLTYPE GetAdapterLuid(
400 LUID * RetVal) override
401 {
402 if (RetVal)
403 {
404 *RetVal = {};
405 }
406 return RetVal;
407 }
408#endif
409
410public: // ID3D12Object
411 virtual HRESULT STDMETHODCALLTYPE GetPrivateData(
412 _In_ REFGUID guid,
413 _Inout_ UINT *pDataSize,
414 _Out_writes_bytes_opt_( *pDataSize ) void *pData) override
415 {
416 return S_OK;
417 }
418
419 virtual HRESULT STDMETHODCALLTYPE SetPrivateData(
420 _In_ REFGUID guid,
421 _In_ UINT DataSize,
422 _In_reads_bytes_opt_( DataSize ) const void *pData) override
423 {
424 return S_OK;
425 }
426
427 virtual HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(
428 _In_ REFGUID guid,
429 _In_opt_ const IUnknown *pData) override
430 {
431 return S_OK;
432 }
433
434 virtual HRESULT STDMETHODCALLTYPE SetName(
435 _In_z_ LPCWSTR Name) override
436 {
437 return S_OK;
438 }
439
440public: // IUnknown
441 virtual HRESULT STDMETHODCALLTYPE QueryInterface(
442 /* [in] */ REFIID riid,
443 /* [iid_is][out] */ _COM_Outptr_ void __RPC_FAR *__RPC_FAR *ppvObject) override
444 {
445 *ppvObject = this;
446 return S_OK;
447 }
448
449 virtual ULONG STDMETHODCALLTYPE AddRef() override
450 {
451 // Casual implementation. No actual actions
452 return 0;
453 }
454
455 virtual ULONG STDMETHODCALLTYPE Release() override
456 {
457 return 0;
458 }
459
460
461 // Major function we need to work with
462 virtual HRESULT STDMETHODCALLTYPE CheckFeatureSupport(
463 D3D12_FEATURE Feature,
464 _Inout_updates_bytes_(FeatureSupportDataSize) void *pFeatureSupportData,
465 UINT FeatureSupportDataSize
466 ) override
467 {
468 switch( Feature )
469 {
470 case D3D12_FEATURE_D3D12_OPTIONS:
471 {
472 D3D12_FEATURE_DATA_D3D12_OPTIONS* pD3D12Options = static_cast<D3D12_FEATURE_DATA_D3D12_OPTIONS*>(pFeatureSupportData);
473 if (FeatureSupportDataSize != sizeof(D3D12_FEATURE_DATA_D3D12_OPTIONS))
474 {
475 return E_INVALIDARG;
476 }
477 pD3D12Options->DoublePrecisionFloatShaderOps = m_DoublePrecisionFloatShaderOps;
478 pD3D12Options->OutputMergerLogicOp = m_OutputMergerLogicOp;
479 pD3D12Options->MinPrecisionSupport = m_ShaderMinPrecisionSupport10Bit | m_ShaderMinPrecisionSupport16Bit;
480 pD3D12Options->TiledResourcesTier = m_TiledResourcesTier;
481 pD3D12Options->ResourceBindingTier = m_ResourceBindingTier;
482 pD3D12Options->PSSpecifiedStencilRefSupported = (m_FeatureLevel >= D3D_FEATURE_LEVEL_11_1) && m_PSSpecifiedStencilRefSupported;
483 pD3D12Options->TypedUAVLoadAdditionalFormats = (m_FeatureLevel >= D3D_FEATURE_LEVEL_11_0) && m_TypedUAVLoadAdditionalFormats;
484 pD3D12Options->ROVsSupported = (m_FeatureLevel >= D3D_FEATURE_LEVEL_11_0) && m_ROVsSupported;
485 pD3D12Options->ConservativeRasterizationTier = (m_FeatureLevel >= D3D_FEATURE_LEVEL_11_1) ? m_ConservativeRasterizationTier : D3D12_CONSERVATIVE_RASTERIZATION_TIER_NOT_SUPPORTED;
486 pD3D12Options->MaxGPUVirtualAddressBitsPerResource = m_MaxGPUVirtualAddressBitsPerResource;
487 pD3D12Options->StandardSwizzle64KBSupported = m_StandardSwizzle64KBSupported;
488 #ifdef DX_ASTC_PROTOTYPE_ENABLED
489 pD3D12Options->ASTCProfile = ASTCProfile();
490 #endif
491 pD3D12Options->CrossNodeSharingTier = m_CrossNodeSharingTier;
492 pD3D12Options->CrossAdapterRowMajorTextureSupported = m_CrossAdapterRowMajorTextureSupported;
493 pD3D12Options->VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation = m_VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation;
494 pD3D12Options->ResourceHeapTier = m_ResourceHeapTier;
495 } return S_OK;
496
497 case D3D12_FEATURE_D3D12_OPTIONS1:
498 {
499 if (!m_Options1Available)
500 {
501 return E_INVALIDARG;
502 }
503 D3D12_FEATURE_DATA_D3D12_OPTIONS1* pD3D12Options1 = static_cast<D3D12_FEATURE_DATA_D3D12_OPTIONS1*>(pFeatureSupportData);
504 if (FeatureSupportDataSize != sizeof(D3D12_FEATURE_DATA_D3D12_OPTIONS1))
505 {
506 return E_INVALIDARG;
507 }
508 pD3D12Options1->WaveOps = m_WaveOpsSupported;
509 pD3D12Options1->WaveLaneCountMin = m_WaveLaneCountMin;
510 pD3D12Options1->WaveLaneCountMax = m_WaveLaneCountMax;
511 pD3D12Options1->TotalLaneCount = m_TotalLaneCount;
512 pD3D12Options1->ExpandedComputeResourceStates = m_ExpandedComputeResourceStates;
513 pD3D12Options1->Int64ShaderOps = m_Int64ShaderOpsSupported;
514 } return S_OK;
515
516
517 case D3D12_FEATURE_D3D12_OPTIONS2:
518 {
519 if (!m_Options2Available)
520 {
521 return E_INVALIDARG;
522 }
523
524 D3D12_FEATURE_DATA_D3D12_OPTIONS2* pD3D12Options2 = static_cast<D3D12_FEATURE_DATA_D3D12_OPTIONS2*>(pFeatureSupportData);
525 if (FeatureSupportDataSize != sizeof(D3D12_FEATURE_DATA_D3D12_OPTIONS2))
526 {
527 return E_INVALIDARG;
528 }
529 pD3D12Options2->DepthBoundsTestSupported = m_DepthBoundsTestSupport;
530 pD3D12Options2->ProgrammableSamplePositionsTier = m_ProgrammableSamplePositionsTier;
531 } return S_OK;
532
533 case D3D12_FEATURE_ROOT_SIGNATURE:
534 {
535 if (!m_RootSignatureAvailable)
536 {
537 return E_INVALIDARG;
538 }
539 D3D12_FEATURE_DATA_ROOT_SIGNATURE* pRootSig = static_cast<D3D12_FEATURE_DATA_ROOT_SIGNATURE*>(pFeatureSupportData);
540 if (FeatureSupportDataSize != sizeof(D3D12_FEATURE_DATA_ROOT_SIGNATURE))
541 {
542 return E_INVALIDARG;
543 }
544 switch (pRootSig->HighestVersion)
545 {
546 case D3D_ROOT_SIGNATURE_VERSION_1_0:
547 case D3D_ROOT_SIGNATURE_VERSION_1_1:
548 break;
549 default:
550 return E_INVALIDARG;
551 }
552 pRootSig->HighestVersion = static_cast<D3D_ROOT_SIGNATURE_VERSION>(std::min<int>(pRootSig->HighestVersion, m_RootSignatureHighestVersion));
553 } return S_OK;
554
555
556 case D3D12_FEATURE_ARCHITECTURE:
557 {
558 D3D12_FEATURE_DATA_ARCHITECTURE* pFData =
559 static_cast< D3D12_FEATURE_DATA_ARCHITECTURE* >( pFeatureSupportData );
560 if (FeatureSupportDataSize != sizeof( *pFData ))
561 {
562 return E_INVALIDARG;
563 }
564
565 // Testing only
566 // If Architecture1 is available, use data from architecture1
567 if (m_Architecture1Available)
568 {
569 D3D12_FEATURE_DATA_ARCHITECTURE1 CurFData;
570 CurFData.NodeIndex = pFData->NodeIndex;
571
572 HRESULT hr;
573 if (FAILED( hr = CheckFeatureSupport( D3D12_FEATURE_ARCHITECTURE1, &CurFData, sizeof( CurFData ) ) ))
574 {
575 return hr;
576 }
577
578 pFData->TileBasedRenderer = CurFData.TileBasedRenderer;
579 pFData->UMA = CurFData.UMA;
580 pFData->CacheCoherentUMA = CurFData.CacheCoherentUMA;
581 }
582 else // Otherwise, load the data directly
583 {
584 // The original procedure will generate and return an E_INVALIDARG error if the NodeIndex is out of scope
585 // Mocking the behavior here by returning the rror
586 if (!(pFData->NodeIndex < m_NodeCount))
587 {
588 return E_INVALIDARG;
589 }
590 pFData->TileBasedRenderer = m_TileBasedRenderer[pFData->NodeIndex];
591 pFData->UMA = m_UMA[pFData->NodeIndex];
592 pFData->CacheCoherentUMA = m_CacheCoherentUMA[pFData->NodeIndex];
593 // Note that Architecture doesn't have the IsolatedMMU field.
594 }
595 } return S_OK;
596 case D3D12_FEATURE_ARCHITECTURE1:
597 {
598 // Mocking the case where ARCHITECTURE1 is not supported
599 if (!m_Architecture1Available || !m_ArchitectureSucceed) {
600 return E_INVALIDARG;
601 }
602
603 D3D12_FEATURE_DATA_ARCHITECTURE1* pFData =
604 static_cast< D3D12_FEATURE_DATA_ARCHITECTURE1* >( pFeatureSupportData );
605 if (FeatureSupportDataSize != sizeof( *pFData ))
606 {
607 return E_INVALIDARG;
608 }
609
610 // The original procedure will generate and return an E_INVALIDARG error if the NodeIndex is out of scope
611 // Mocking the behavior here by returning the rror
612 if (!(pFData->NodeIndex < m_NodeCount))
613 {
614 return E_INVALIDARG;
615 }
616
617 UINT localIndex = pFData->NodeIndex;
618 pFData->TileBasedRenderer = m_TileBasedRenderer[localIndex];
619 pFData->UMA = m_UMA[localIndex];
620 pFData->CacheCoherentUMA = m_CacheCoherentUMA[localIndex];
621 pFData->IsolatedMMU = m_IsolatedMMU[localIndex];
622
623 } return S_OK;
624
625 case D3D12_FEATURE_FEATURE_LEVELS:
626 {
627 D3D12_FEATURE_DATA_FEATURE_LEVELS* pFData =
628 static_cast< D3D12_FEATURE_DATA_FEATURE_LEVELS* >( pFeatureSupportData );
629 if (FeatureSupportDataSize != sizeof( *pFData ))
630 {
631 return E_INVALIDARG;
632 }
633
634 if (pFData->NumFeatureLevels == 0 || pFData->pFeatureLevelsRequested == nullptr)
635 {
636 return E_INVALIDARG;
637 }
638
639 pFData->MaxSupportedFeatureLevel = D3D_FEATURE_LEVEL(0);
640 for (UINT i = 0; i < pFData->NumFeatureLevels; ++i)
641 {
642 if (pFData->pFeatureLevelsRequested[i] <= m_FeatureLevel &&
643 pFData->pFeatureLevelsRequested[i] > pFData->MaxSupportedFeatureLevel)
644 {
645 pFData->MaxSupportedFeatureLevel = pFData->pFeatureLevelsRequested[i];
646 }
647 }
648 return pFData->MaxSupportedFeatureLevel == D3D_FEATURE_LEVEL(0) ?
649 DXGI_ERROR_UNSUPPORTED : S_OK;
650 }
651
652 case D3D12_FEATURE_FORMAT_SUPPORT:
653 {
654 D3D12_FEATURE_DATA_FORMAT_SUPPORT* pFData =
655 static_cast< D3D12_FEATURE_DATA_FORMAT_SUPPORT* >( pFeatureSupportData );
656 if (FeatureSupportDataSize != sizeof( *pFData ))
657 {
658 return E_INVALIDARG;
659 }
660 m_FormatReceived = pFData->Format;
661 pFData->Support1 = m_FormatSupport1;
662 pFData->Support2 = m_FormatSupport2;
663 // Based on the original implementation, if there's no support for the format, return an E_FAIL
664 if (m_FormatSupport1 == D3D12_FORMAT_SUPPORT1_NONE && m_FormatSupport2 == D3D12_FORMAT_SUPPORT2_NONE)
665 {
666 return E_FAIL;
667 }
668 } return S_OK;
669
670 case D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS:
671 {
672 D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS* pFData =
673 static_cast< D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS* >( pFeatureSupportData );
674 if (FeatureSupportDataSize != sizeof( *pFData ))
675 {
676 return E_INVALIDARG;
677 }
678
679 m_FormatReceived = pFData->Format;
680 m_SampleCountReceived = pFData->SampleCount;
681 m_MultisampleQualityLevelFlagsReceived = pFData->Flags;
682
683 // The original check implementation may return E_FAIL
684 // Valid results are non-negative values including 0, smaller than D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT
685 if (!m_MultisampleQualityLevelsSucceed)
686 {
687 // NumQualityLevels will be set to 0 should the check fails
688 pFData->NumQualityLevels = 0;
689 return E_FAIL;
690 }
691
692 pFData->NumQualityLevels = m_NumQualityLevels;
693 } return S_OK;
694 case D3D12_FEATURE_FORMAT_INFO:
695 {
696 D3D12_FEATURE_DATA_FORMAT_INFO* pFData =
697 static_cast< D3D12_FEATURE_DATA_FORMAT_INFO* > ( pFeatureSupportData );
698 if (FeatureSupportDataSize != sizeof( *pFData ))
699 {
700 return E_INVALIDARG;
701 }
702
703 m_FormatReceived = pFData->Format;
704
705 // If the format is not supported, an E_INVALIDARG will be returned
706 if (!m_DXGIFormatSupported)
707 {
708 return E_INVALIDARG;
709 }
710
711 pFData->PlaneCount = m_PlaneCount;
712
713 } return S_OK;
714 case D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT:
715 {
716 D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT* pFData =
717 static_cast< D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT* >( pFeatureSupportData );
718 if (FeatureSupportDataSize != sizeof( *pFData ))
719 {
720 return E_INVALIDARG;
721 }
722 pFData->MaxGPUVirtualAddressBitsPerProcess = m_MaxGPUVirtualAddressBitsPerProcess;
723 pFData->MaxGPUVirtualAddressBitsPerResource = m_MaxGPUVirtualAddressBitsPerResource;
724
725 } return S_OK;
726 case D3D12_FEATURE_SHADER_MODEL:
727 {
728 D3D12_FEATURE_DATA_SHADER_MODEL* pSM =
729 static_cast<D3D12_FEATURE_DATA_SHADER_MODEL*>(pFeatureSupportData);
730 if (FeatureSupportDataSize != sizeof(*pSM))
731 {
732 return E_INVALIDARG;
733 }
734 switch (pSM->HighestShaderModel)
735 {
736 case D3D_SHADER_MODEL_5_1:
737 case D3D_SHADER_MODEL_6_0:
738 case D3D_SHADER_MODEL_6_1:
739 case D3D_SHADER_MODEL_6_2:
740 case D3D_SHADER_MODEL_6_3:
741 case D3D_SHADER_MODEL_6_4:
742 case D3D_SHADER_MODEL_6_5:
743 case D3D_SHADER_MODEL_6_6:
744 case D3D_SHADER_MODEL_6_7:
745 break;
746 default:
747 return E_INVALIDARG;
748 }
749 pSM->HighestShaderModel = static_cast<D3D_SHADER_MODEL>(std::min<int>(pSM->HighestShaderModel,m_HighestSupportedShaderModel));
750 } return S_OK;
751 case D3D12_FEATURE_SHADER_CACHE:
752 {
753 if (!m_ShaderCacheAvailable)
754 {
755 return E_INVALIDARG;
756 }
757 D3D12_FEATURE_DATA_SHADER_CACHE* pFlags =
758 static_cast<D3D12_FEATURE_DATA_SHADER_CACHE*>(pFeatureSupportData);
759 if (FeatureSupportDataSize != sizeof(*pFlags))
760 {
761 return E_INVALIDARG;
762 }
763 pFlags->SupportFlags = m_ShaderCacheSupportFlags;
764 } return S_OK;
765 case D3D12_FEATURE_COMMAND_QUEUE_PRIORITY:
766 {
767 if (!m_CommandQueuePriorityAvailable)
768 {
769 return E_INVALIDARG;
770 }
771 D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY* pFlags =
772 static_cast<D3D12_FEATURE_DATA_COMMAND_QUEUE_PRIORITY*>(pFeatureSupportData);
773 if (FeatureSupportDataSize != sizeof(*pFlags))
774 {
775 return E_INVALIDARG;
776 }
777
778 if (pFlags->CommandListType >= D3D12_COMMAND_LIST_TYPE_VIDEO_ENCODE+1)
779 {
780 return E_INVALIDARG;
781 }
782
783 if (pFlags->Priority == D3D12_COMMAND_QUEUE_PRIORITY_NORMAL || pFlags->Priority == D3D12_COMMAND_QUEUE_PRIORITY_HIGH)
784 {
785 pFlags->PriorityForTypeIsSupported = TRUE;
786 }
787 else if (pFlags->Priority == D3D12_COMMAND_QUEUE_PRIORITY_GLOBAL_REALTIME)
788 {
789 pFlags->PriorityForTypeIsSupported = m_GlobalRealtimeCommandQueueSupport; // Simplified
790 }
791 else
792 {
793 return E_INVALIDARG;
794 }
795
796 } return S_OK;
797
798 case D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_SUPPORT:
799 {
800 if (!m_ProtectedResourceSessionAvailable)
801 {
802 return E_INVALIDARG;
803 }
804 D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT* pProtectedResourceSessionSupport =
805 static_cast<D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT*>(pFeatureSupportData);
806 if ( FeatureSupportDataSize != sizeof(*pProtectedResourceSessionSupport)
807 || pProtectedResourceSessionSupport->NodeIndex >= GetNodeCount())
808 {
809 return E_INVALIDARG;
810 }
811
812 pProtectedResourceSessionSupport->Support = m_ContentProtectionSupported ?
813 m_ProtectedResourceSessionSupport[pProtectedResourceSessionSupport->NodeIndex]
814 : D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAG_NONE;
815
816 } return S_OK;
817
818 case D3D12_FEATURE_D3D12_OPTIONS3:
819 {
820 if (!m_Options3Available)
821 {
822 return E_INVALIDARG;
823 }
824 D3D12_FEATURE_DATA_D3D12_OPTIONS3* pD3D12Options3 = static_cast<D3D12_FEATURE_DATA_D3D12_OPTIONS3*>(pFeatureSupportData);
825 if (FeatureSupportDataSize != sizeof(D3D12_FEATURE_DATA_D3D12_OPTIONS3))
826 {
827 return E_INVALIDARG;
828 }
829 pD3D12Options3->CopyQueueTimestampQueriesSupported = m_CopyQueueTimestampQueriesSupported;
830 pD3D12Options3->CastingFullyTypedFormatSupported = m_CastingFullyTypedFormatsSupported;
831 pD3D12Options3->WriteBufferImmediateSupportFlags = m_GetCachedWriteBufferImmediateSupportFlags;
832 pD3D12Options3->ViewInstancingTier = m_ViewInstancingTier;
833 pD3D12Options3->BarycentricsSupported = m_BarycentricsSupported;
834
835 } return S_OK;
836 case D3D12_FEATURE_EXISTING_HEAPS:
837 {
838 if (!m_ExistingHeapsAvailable)
839 {
840 return E_INVALIDARG;
841 }
842 auto* pSupport = static_cast<D3D12_FEATURE_DATA_EXISTING_HEAPS*>(pFeatureSupportData);
843 if (FeatureSupportDataSize != sizeof(*pSupport))
844 {
845 return E_INVALIDARG;
846 }
847 pSupport->Supported = m_ExistingHeapCaps;
848 } return S_OK;
849 case D3D12_FEATURE_D3D12_OPTIONS4:
850 {
851 if (!m_Options4Available)
852 {
853 return E_INVALIDARG;
854 }
855 auto* pD3D12Options4 = static_cast<D3D12_FEATURE_DATA_D3D12_OPTIONS4*>(pFeatureSupportData);
856 if (FeatureSupportDataSize != sizeof(*pD3D12Options4))
857 {
858 return E_INVALIDARG;
859 }
860
861 // Reserved Buffer Placement was cut, except for 64KB Aligned MSAA Textures
862 pD3D12Options4->MSAA64KBAlignedTextureSupported = m_MSAA64KBAlignedTextureSupported;
863 pD3D12Options4->SharedResourceCompatibilityTier = m_SharedResourceCompatibilityTier; // Simplified
864 pD3D12Options4->Native16BitShaderOpsSupported = m_Native16BitShaderOpsSupported;
865 } return S_OK;
866 case D3D12_FEATURE_SERIALIZATION:
867 {
868 if (!m_SerializationAvailable)
869 {
870 return E_INVALIDARG;
871 }
872 auto* pSerialization = static_cast<D3D12_FEATURE_DATA_SERIALIZATION*>(pFeatureSupportData);
873 if (FeatureSupportDataSize != sizeof(*pSerialization))
874 {
875 return E_INVALIDARG;
876 }
877
878 const UINT NodeIndex = pSerialization->NodeIndex;
879 if (NodeIndex >= m_NodeCount)
880 {
881 return E_INVALIDARG;
882 }
883 pSerialization->HeapSerializationTier = m_HeapSerializationTier[NodeIndex];
884 } return S_OK;
885 case D3D12_FEATURE_CROSS_NODE:
886 {
887 if (!m_CrossNodeAvailable)
888 {
889 return E_INVALIDARG;
890 }
891 auto* pCrossNode = static_cast<D3D12_FEATURE_DATA_CROSS_NODE*>(pFeatureSupportData);
892 if (FeatureSupportDataSize != sizeof(*pCrossNode))
893 {
894 return E_INVALIDARG;
895 }
896
897 pCrossNode->SharingTier = m_CrossNodeSharingTier;
898 pCrossNode->AtomicShaderInstructions = m_AtomicShaderInstructions;
899 } return S_OK;
900 case D3D12_FEATURE_D3D12_OPTIONS5:
901 {
902 if (!m_Options5Available)
903 {
904 return E_INVALIDARG;
905 }
906 auto* pD3D12Options5 = static_cast<D3D12_FEATURE_DATA_D3D12_OPTIONS5*>(pFeatureSupportData);
907 if (FeatureSupportDataSize != sizeof(*pD3D12Options5))
908 {
909 return E_INVALIDARG;
910 }
911
912 pD3D12Options5->RaytracingTier = m_RaytracingTier;
913 pD3D12Options5->RenderPassesTier = m_RenderPassesTier;
914 pD3D12Options5->SRVOnlyTiledResourceTier3 = m_SRVOnlyTiledResourceTier3;
915 } return S_OK;
916 case D3D12_FEATURE_DISPLAYABLE:
917 {
918 if (!m_DisplayableAvailable)
919 {
920 return E_INVALIDARG;
921 }
922 auto* pD3D12Displayable = static_cast<D3D12_FEATURE_DATA_DISPLAYABLE*>(pFeatureSupportData);
923 if (FeatureSupportDataSize != sizeof(*pD3D12Displayable)) // Feature_D3D1XDisplayable
924 {
925 return E_INVALIDARG;
926 }
927
928 pD3D12Displayable->DisplayableTexture = m_DisplayableTexture;
929 pD3D12Displayable->SharedResourceCompatibilityTier = m_SharedResourceCompatibilityTier;
930 } return S_OK;
931
932 case D3D12_FEATURE_D3D12_OPTIONS6:
933 {
934 if (!m_Options6Available)
935 {
936 return E_INVALIDARG;
937 }
938
939 auto* pD3D12Options6 = static_cast<D3D12_FEATURE_DATA_D3D12_OPTIONS6*>(pFeatureSupportData);
940 if (FeatureSupportDataSize != sizeof(*pD3D12Options6))
941 {
942 return E_INVALIDARG;
943 }
944 pD3D12Options6->AdditionalShadingRatesSupported = m_AdditionalShadingRatesSupported;
945 pD3D12Options6->BackgroundProcessingSupported = m_BackgroundProcessingSupported;
946 pD3D12Options6->PerPrimitiveShadingRateSupportedWithViewportIndexing = m_PerPrimitiveShadingRateSupportedWithViewportIndexing;
947 pD3D12Options6->ShadingRateImageTileSize = m_ShadingRateImageTileSize;
948 pD3D12Options6->VariableShadingRateTier = m_VariableShadingRateTier;
949 } return S_OK;
950 case D3D12_FEATURE_QUERY_META_COMMAND:
951 {
952 if (m_QueryMetaCommandAvailable)
953 {
954 if (FeatureSupportDataSize != sizeof(D3D12_FEATURE_DATA_QUERY_META_COMMAND))
955 {
956 return E_INVALIDARG;
957 }
958
959 // Only checks inputs and outputs
960 auto* pQueryData = static_cast<D3D12_FEATURE_DATA_QUERY_META_COMMAND*>(pFeatureSupportData);
961 m_CommandID = pQueryData->CommandId;
962 m_pQueryInputData = pQueryData->pQueryInputData;
963 m_NodeMask = pQueryData->NodeMask;
964 m_QueryInputDataSizeInBytes = pQueryData->QueryInputDataSizeInBytes;
965
966 pQueryData->QueryOutputDataSizeInBytes = m_QueryOutputDataSizeInBytes;
967 pQueryData->pQueryOutputData = m_pQueryOutputData;
968 }
969 else
970 {
971 return E_INVALIDARG;
972 }
973 } return S_OK;
974 case D3D12_FEATURE_D3D12_OPTIONS7:
975 {
976 if (!m_Options7Available)
977 {
978 return E_INVALIDARG;
979 }
980 auto* pD3D12Options7 = static_cast<D3D12_FEATURE_DATA_D3D12_OPTIONS7*>(pFeatureSupportData);
981 if (FeatureSupportDataSize != sizeof(*pD3D12Options7))
982 {
983 return E_INVALIDARG;
984 }
985
986 pD3D12Options7->MeshShaderTier = m_MeshShaderTier;
987 pD3D12Options7->SamplerFeedbackTier = m_SamplerFeedbackTier;
988 } return S_OK;
989 case D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPE_COUNT:
990 {
991 if (!m_ProtectedResourceSessionTypeCountAvailable)
992 {
993 return E_INVALIDARG;
994 }
995 auto* pProtectedResourceSessionTypesCount =
996 static_cast<D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT*>(pFeatureSupportData);
997 if ( FeatureSupportDataSize != sizeof(*pProtectedResourceSessionTypesCount)
998 || pProtectedResourceSessionTypesCount->NodeIndex >= GetNodeCount())
999 {
1000 return E_INVALIDARG;
1001 }
1002
1003 pProtectedResourceSessionTypesCount->Count = m_ProtectedResourceSessionTypeCount[pProtectedResourceSessionTypesCount->NodeIndex];
1004 } return S_OK;
1005 case D3D12_FEATURE_PROTECTED_RESOURCE_SESSION_TYPES:
1006 {
1007 if (!m_ProtectedResourceSessionTypesAvailable)
1008 {
1009 return E_INVALIDARG;
1010 }
1011 auto* pProtectedResourceSessionTypes =
1012 static_cast<D3D12_FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES*>(pFeatureSupportData);
1013 if ( FeatureSupportDataSize != sizeof(*pProtectedResourceSessionTypes)
1014 || pProtectedResourceSessionTypes->NodeIndex >= GetNodeCount())
1015 {
1016 return E_INVALIDARG;
1017 }
1018 UINT ExpectedCount = m_ProtectedResourceSessionTypeCount[pProtectedResourceSessionTypes->NodeIndex];
1019 if (pProtectedResourceSessionTypes->Count != ExpectedCount)
1020 {
1021 return E_INVALIDARG;
1022 }
1023
1024 if (ExpectedCount > 0)
1025 {
1026 memcpy(pProtectedResourceSessionTypes->pTypes, m_ProtectedResourceSessionTypes[pProtectedResourceSessionTypes->NodeIndex].data(), ExpectedCount * sizeof(*pProtectedResourceSessionTypes->pTypes));
1027 }
1028
1029 } return S_OK;
1030
1031 case D3D12_FEATURE_D3D12_OPTIONS8:
1032 {
1033 if (!m_Options8Available)
1034 {
1035 return E_INVALIDARG;
1036 }
1037 D3D12_FEATURE_DATA_D3D12_OPTIONS8 *pD3D12Options8 = static_cast<D3D12_FEATURE_DATA_D3D12_OPTIONS8*>(pFeatureSupportData);
1038 if (FeatureSupportDataSize != sizeof(*pD3D12Options8))
1039 {
1040 return E_INVALIDARG;
1041 }
1042
1043 pD3D12Options8->UnalignedBlockTexturesSupported = m_UnalignedBlockTexturesSupported;
1044 } return S_OK;
1045 case D3D12_FEATURE_D3D12_OPTIONS9:
1046 {
1047 if (!m_Options9Available)
1048 {
1049 return E_INVALIDARG;
1050 }
1051 D3D12_FEATURE_DATA_D3D12_OPTIONS9 *pD3D12Options9 = static_cast<D3D12_FEATURE_DATA_D3D12_OPTIONS9*>(pFeatureSupportData);
1052 if (FeatureSupportDataSize != sizeof(*pD3D12Options9))
1053 {
1054 return E_INVALIDARG;
1055 }
1056
1057 pD3D12Options9->AtomicInt64OnGroupSharedSupported = m_AtomicInt64OnGroupSharedSupported;
1058 pD3D12Options9->AtomicInt64OnTypedResourceSupported = m_AtomicInt64OnTypedResourceSupported;
1059 pD3D12Options9->DerivativesInMeshAndAmplificationShadersSupported = m_DerivativesInMeshAndAmplificationShadersSupported;
1060 pD3D12Options9->MeshShaderPipelineStatsSupported = m_MeshShaderPipelineStatsSupported;
1061 pD3D12Options9->MeshShaderSupportsFullRangeRenderTargetArrayIndex = m_MeshShaderSupportsFullRangeRenderTargetArrayIndex;
1062 pD3D12Options9->WaveMMATier = m_WaveMMATier;
1063 } return S_OK;
1064 case D3D12_FEATURE_D3D12_OPTIONS10:
1065 {
1066 if (!m_Options10Available)
1067 {
1068 return E_INVALIDARG;
1069 }
1070 D3D12_FEATURE_DATA_D3D12_OPTIONS10* pD3D12Options10 = static_cast<D3D12_FEATURE_DATA_D3D12_OPTIONS10*>(pFeatureSupportData);
1071 if (FeatureSupportDataSize != sizeof(*pD3D12Options10))
1072 {
1073 return E_INVALIDARG;
1074 }
1075
1076 pD3D12Options10->MeshShaderPerPrimitiveShadingRateSupported = m_MeshShaderPerPrimitiveShadingRateSupported;
1077 pD3D12Options10->VariableRateShadingSumCombinerSupported = m_VariableRateShadingSumCombinerSupported;
1078 } return S_OK;
1079 case D3D12_FEATURE_D3D12_OPTIONS11:
1080 {
1081 if (!m_Options11Available)
1082 {
1083 return E_INVALIDARG;
1084 }
1085 D3D12_FEATURE_DATA_D3D12_OPTIONS11* pD3D12Options11 = static_cast<D3D12_FEATURE_DATA_D3D12_OPTIONS11*>(pFeatureSupportData);
1086 if (FeatureSupportDataSize != sizeof(*pD3D12Options11))
1087 {
1088 return E_INVALIDARG;
1089 }
1090
1091 pD3D12Options11->AtomicInt64OnDescriptorHeapResourceSupported = m_AtomicInt64OnDescriptorHeapResourceSupported;
1092 } return S_OK;
1093 case D3D12_FEATURE_D3D12_OPTIONS12:
1094 {
1095 if (!m_Options12Available)
1096 {
1097 return E_INVALIDARG;
1098 }
1099 D3D12_FEATURE_DATA_D3D12_OPTIONS12* pD3D12Options12 = static_cast<D3D12_FEATURE_DATA_D3D12_OPTIONS12*>(pFeatureSupportData);
1100 if (FeatureSupportDataSize != sizeof(*pD3D12Options12))
1101 {
1102 return E_INVALIDARG;
1103 }
1104
1105 pD3D12Options12->MSPrimitivesPipelineStatisticIncludesCulledPrimitives = m_MSPrimitivesPipelineStatisticIncludesCulledPrimitives;
1106 pD3D12Options12->EnhancedBarriersSupported = m_EnhancedBarriersSupported;
1107 } return S_OK;
1108
1109 default:
1110 return E_INVALIDARG;
1111 }
1112 }
1113
1114public: // For simplicity, allow tests to set the internal state values for this mock class
1115 // General
1116 UINT m_NodeCount; // Simulated number of computing nodes
1117
1118 // 0: Options
1119 bool m_D3D12OptionsAvailable = true;
1120 BOOL m_DoublePrecisionFloatShaderOps = false;
1121 BOOL m_OutputMergerLogicOp = false;
1122 D3D12_SHADER_MIN_PRECISION_SUPPORT m_ShaderMinPrecisionSupport10Bit = D3D12_SHADER_MIN_PRECISION_SUPPORT_NONE;
1123 D3D12_SHADER_MIN_PRECISION_SUPPORT m_ShaderMinPrecisionSupport16Bit = D3D12_SHADER_MIN_PRECISION_SUPPORT_NONE;
1124 D3D12_TILED_RESOURCES_TIER m_TiledResourcesTier = D3D12_TILED_RESOURCES_TIER_NOT_SUPPORTED;
1125 D3D12_RESOURCE_BINDING_TIER m_ResourceBindingTier = (D3D12_RESOURCE_BINDING_TIER)0;
1126 BOOL m_PSSpecifiedStencilRefSupported = false;
1127 BOOL m_TypedUAVLoadAdditionalFormats = false;
1128 BOOL m_ROVsSupported = false;
1129 D3D12_CONSERVATIVE_RASTERIZATION_TIER m_ConservativeRasterizationTier = D3D12_CONSERVATIVE_RASTERIZATION_TIER_NOT_SUPPORTED;
1130 UINT m_MaxGPUVirtualAddressBitsPerResource = 0;
1131 BOOL m_StandardSwizzle64KBSupported = false;
1132 D3D12_CROSS_NODE_SHARING_TIER m_CrossNodeSharingTier = D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED;
1133 BOOL m_CrossAdapterRowMajorTextureSupported = false;
1134 BOOL m_VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation = false;
1135 D3D12_RESOURCE_HEAP_TIER m_ResourceHeapTier = (D3D12_RESOURCE_HEAP_TIER)0;
1136
1137 // 1: Architecture & 16: Architecture1
1138 bool m_ArchitectureSucceed = true;
1139 bool m_Architecture1Available = false; // Mock the case where Architecture1 is not supported
1140 std::vector<BOOL> m_TileBasedRenderer;
1141 std::vector<BOOL> m_UMA;
1142 std::vector<BOOL> m_CacheCoherentUMA;
1143 std::vector<BOOL> m_IsolatedMMU;
1144
1145 // 2: Feature Levels
1146 bool m_FeatureLevelsAvailable = true;
1147 D3D_FEATURE_LEVEL m_FeatureLevel = D3D_FEATURE_LEVEL_12_0; // Set higher to allow other tests to pass correctly
1148
1149 // 3: Feature Format Support
1150 // Forwarding call only. Make sure that the input parameters are correctly forwarded
1151 bool m_FormatSupportAvailable = true;
1152 DXGI_FORMAT m_FormatReceived;
1153 D3D12_FORMAT_SUPPORT1 m_FormatSupport1 = D3D12_FORMAT_SUPPORT1_NONE;
1154 D3D12_FORMAT_SUPPORT2 m_FormatSupport2 = D3D12_FORMAT_SUPPORT2_NONE;
1155
1156 // 4: Multisample Quality Levels
1157 bool m_MultisampleQualityLevelsSucceed = true;
1158 UINT m_SampleCountReceived;
1159 D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS m_MultisampleQualityLevelFlagsReceived;
1160 UINT m_NumQualityLevels = 0;
1161
1162 // 5: Format Info
1163 bool m_DXGIFormatSupported = true;
1164 UINT m_PlaneCount = 0;
1165
1166 // 6: GPU Virtual Address Support
1167 bool m_GPUVASupportAvailable = true;
1168 UINT m_MaxGPUVirtualAddressBitsPerProcess = 0;
1169
1170 // 7: Shader Model
1171 D3D_SHADER_MODEL m_HighestSupportedShaderModel = D3D_SHADER_MODEL_5_1;
1172
1173 // 8: Options1
1174 bool m_Options1Available = true;
1175 bool m_WaveOpsSupported = false;
1176 UINT m_WaveLaneCountMin = 0;
1177 UINT m_WaveLaneCountMax = 0;
1178 UINT m_TotalLaneCount = 0;
1179 bool m_ExpandedComputeResourceStates = false;
1180 bool m_Int64ShaderOpsSupported = false;
1181
1182 // 10: Protected Resource Session Support
1183 bool m_ProtectedResourceSessionAvailable = true;
1184 bool m_ContentProtectionSupported = true;
1185 std::vector<D3D12_PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS> m_ProtectedResourceSessionSupport;
1186
1187 // 12: Root Signature
1188 bool m_RootSignatureAvailable = true;
1189 D3D_ROOT_SIGNATURE_VERSION m_RootSignatureHighestVersion = (D3D_ROOT_SIGNATURE_VERSION)0;
1190
1191 // 18: D3D12 Options2
1192 bool m_Options2Available = true;
1193 bool m_DepthBoundsTestSupport = false;
1194 D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER m_ProgrammableSamplePositionsTier = D3D12_PROGRAMMABLE_SAMPLE_POSITIONS_TIER_NOT_SUPPORTED;
1195
1196 // 19: Shader Cache
1197 bool m_ShaderCacheAvailable = true;
1198 D3D12_SHADER_CACHE_SUPPORT_FLAGS m_ShaderCacheSupportFlags = D3D12_SHADER_CACHE_SUPPORT_NONE; // Lazy implementation
1199
1200 // 20: Command Queue Priority
1201 bool m_CommandQueuePriorityAvailable = true;
1202 bool m_GlobalRealtimeCommandQueueSupport = false;
1203
1204 // 21: Options3
1205 bool m_Options3Available = true;
1206 bool m_CopyQueueTimestampQueriesSupported = false;
1207 bool m_CastingFullyTypedFormatsSupported = false;
1208 D3D12_COMMAND_LIST_SUPPORT_FLAGS m_GetCachedWriteBufferImmediateSupportFlags = D3D12_COMMAND_LIST_SUPPORT_FLAG_NONE;
1209 D3D12_VIEW_INSTANCING_TIER m_ViewInstancingTier = D3D12_VIEW_INSTANCING_TIER_NOT_SUPPORTED;
1210 bool m_BarycentricsSupported = false;
1211
1212 // 22: Existing Heaps
1213 bool m_ExistingHeapsAvailable = true;
1214 bool m_ExistingHeapCaps = false;
1215
1216 // 23: Options4
1217 bool m_Options4Available = true;
1218 bool m_MSAA64KBAlignedTextureSupported = false;
1219 D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER m_SharedResourceCompatibilityTier = D3D12_SHARED_RESOURCE_COMPATIBILITY_TIER_0;
1220 bool m_Native16BitShaderOpsSupported = false;
1221
1222 // 24: Serialization
1223 bool m_SerializationAvailable = true;
1224 std::vector<D3D12_HEAP_SERIALIZATION_TIER> m_HeapSerializationTier;
1225
1226 // 25: Cross Node
1227 bool m_CrossNodeAvailable = true;
1228 bool m_AtomicShaderInstructions = false;
1229
1230 // 27: Options5
1231 bool m_Options5Available = true;
1232 bool m_SRVOnlyTiledResourceTier3 = false;
1233 D3D12_RENDER_PASS_TIER m_RenderPassesTier = D3D12_RENDER_PASS_TIER_0;
1234 D3D12_RAYTRACING_TIER m_RaytracingTier = D3D12_RAYTRACING_TIER_NOT_SUPPORTED;
1235
1236 // 28: Displayable
1237 bool m_DisplayableAvailable = true;
1238 bool m_DisplayableTexture = false;
1239 // SharedResourceCompatibilityTier is located in Options4
1240
1241 // 30: Options6
1242 bool m_Options6Available = true;
1243 bool m_AdditionalShadingRatesSupported = false;
1244 bool m_PerPrimitiveShadingRateSupportedWithViewportIndexing = false;
1245 D3D12_VARIABLE_SHADING_RATE_TIER m_VariableShadingRateTier = D3D12_VARIABLE_SHADING_RATE_TIER_NOT_SUPPORTED;
1246 UINT m_ShadingRateImageTileSize = 0;
1247 bool m_BackgroundProcessingSupported = false;
1248
1249 // 31: Query Meta Command
1250 bool m_QueryMetaCommandAvailable = true;
1251 GUID m_CommandID = {};
1252 UINT m_NodeMask = 0;
1253 const void* m_pQueryInputData = nullptr;
1254 SIZE_T m_QueryInputDataSizeInBytes = 0;
1255 void* m_pQueryOutputData = nullptr;
1256 SIZE_T m_QueryOutputDataSizeInBytes = 0;
1257
1258 // 32: Options7
1259 bool m_Options7Available = true;
1260 D3D12_MESH_SHADER_TIER m_MeshShaderTier = D3D12_MESH_SHADER_TIER_NOT_SUPPORTED;
1261 D3D12_SAMPLER_FEEDBACK_TIER m_SamplerFeedbackTier = D3D12_SAMPLER_FEEDBACK_TIER_NOT_SUPPORTED;
1262
1263 // 33: Protected Resource Session Type Count
1264 bool m_ProtectedResourceSessionTypeCountAvailable = true;
1265 std::vector<UINT> m_ProtectedResourceSessionTypeCount;
1266
1267 // 34: Protected Resource Session Types
1268 bool m_ProtectedResourceSessionTypesAvailable = true;
1269 std::vector<std::vector<GUID>> m_ProtectedResourceSessionTypes;
1270
1271 // 36: Options8
1272 bool m_Options8Available = true;
1273 bool m_UnalignedBlockTexturesSupported = false;
1274
1275 // 37: Options9
1276 bool m_Options9Available = true;
1277 bool m_MeshShaderPipelineStatsSupported = false;
1278 bool m_MeshShaderSupportsFullRangeRenderTargetArrayIndex = false;
1279 bool m_AtomicInt64OnTypedResourceSupported = false;
1280 bool m_AtomicInt64OnGroupSharedSupported = false;
1281 bool m_DerivativesInMeshAndAmplificationShadersSupported = false;
1282 D3D12_WAVE_MMA_TIER m_WaveMMATier = D3D12_WAVE_MMA_TIER_NOT_SUPPORTED;
1283
1284 // 39: Options10
1285 bool m_Options10Available = true;
1286 bool m_VariableRateShadingSumCombinerSupported = false;
1287 bool m_MeshShaderPerPrimitiveShadingRateSupported = false;
1288
1289 // 40: Options11
1290 bool m_Options11Available = true;
1291 bool m_AtomicInt64OnDescriptorHeapResourceSupported = false;
1292
1293 // 41: Options12
1294 bool m_Options12Available = true;
1295 D3D12_TRI_STATE m_MSPrimitivesPipelineStatisticIncludesCulledPrimitives = D3D12_TRI_STATE_UNKNOWN;
1296 bool m_EnhancedBarriersSupported = false;
1297};
1298
1299#endif \ No newline at end of file
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-04 12:33:58 +0000