Skip to content

Run Windows games on Apple Silicon — free, open source, with an open compatibility database that tells you what actually works.

dx12probe: Unreal-style init checks on the enumerated adapter, the objects an RHI creates before any frame (highball-db#48)

Gauthier Piarrette98fb5483e6db
diff --git a/spike/tsshim/probe.c b/spike/tsshim/probe.c
index fbec06f..81749c9 100644
--- a/spike/tsshim/probe.c
+++ b/spike/tsshim/probe.c
@@ -8,6 +8,7 @@
#include <stdarg.h>
#include <d3d12.h>
#include <dxgi1_4.h>
+#include <dxgi1_6.h>
static void say(const char *fmt, ...) {
va_list ap; va_start(ap, fmt); vfprintf(stdout, fmt, ap); va_end(ap); fputc('\n', stdout); fflush(stdout);
@@ -132,6 +133,183 @@ int main(void) {
IDXGIFactory4_Release(fx);
} else say("dxgi: no factory");
}
+
+ // == deeper: the calls Unreal's D3D12 RHI makes at init, on the enumerated adapter rather
+ // than the default one, plus the objects it creates before any frame (highball-db#48:
+ // Hogwarts Legacy refuses DirectX 12 on macOS 15 while the device probe above is clean).
+ say("== deeper (Unreal-style init on the enumerated adapter)");
+ {
+ typedef HRESULT (WINAPI *cf2_t)(UINT, REFIID, void **);
+ HMODULE dxgi = LoadLibraryA("dxgi.dll");
+ cf2_t cf2 = dxgi ? (cf2_t)GetProcAddress(dxgi, "CreateDXGIFactory2") : NULL;
+ IDXGIFactory4 *fx = NULL;
+ HRESULT r = cf2 ? cf2(0, &IID_IDXGIFactory4, (void **)&fx) : E_FAIL;
+ say("CreateDXGIFactory2(IDXGIFactory4): 0x%08lx", (unsigned long)r);
+ IDXGIAdapter1 *ad = NULL;
+ if (SUCCEEDED(r) && fx) {
+ IDXGIFactory6 *f6 = NULL;
+ r = IDXGIFactory4_QueryInterface(fx, &IID_IDXGIFactory6, (void **)&f6);
+ say("factory QI IDXGIFactory6: 0x%08lx", (unsigned long)r);
+ if (SUCCEEDED(r) && f6) {
+ r = IDXGIFactory6_EnumAdapterByGpuPreference(f6, 0, DXGI_GPU_PREFERENCE_HIGH_PERFORMANCE, &IID_IDXGIAdapter1, (void **)&ad);
+ say("EnumAdapterByGpuPreference(0, high performance): 0x%08lx", (unsigned long)r);
+ IDXGIFactory6_Release(f6);
+ }
+ if (!ad) { r = IDXGIFactory4_EnumAdapters1(fx, 0, &ad); say("EnumAdapters1(0): 0x%08lx", (unsigned long)r); }
+ }
+ if (ad) {
+ IDXGIAdapter3 *a3 = NULL; IDXGIAdapter4 *a4 = NULL;
+ say("adapter QI IDXGIAdapter3: 0x%08lx", (unsigned long)IDXGIAdapter1_QueryInterface(ad, &IID_IDXGIAdapter3, (void **)&a3));
+ if (a3) IDXGIAdapter3_Release(a3);
+ say("adapter QI IDXGIAdapter4: 0x%08lx", (unsigned long)IDXGIAdapter1_QueryInterface(ad, &IID_IDXGIAdapter4, (void **)&a4));
+ if (a4) IDXGIAdapter4_Release(a4);
+ LARGE_INTEGER umd = {{0}};
+ r = IDXGIAdapter1_CheckInterfaceSupport(ad, &IID_IDXGIDevice, &umd);
+ say("adapter CheckInterfaceSupport(IDXGIDevice): 0x%08lx, driver %u.%u.%u.%u", (unsigned long)r,
+ HIWORD(umd.HighPart), LOWORD(umd.HighPart), HIWORD(umd.LowPart), LOWORD(umd.LowPart));
+ ID3D12Device *d = NULL;
+ r = create((IUnknown *)ad, D3D_FEATURE_LEVEL_11_0, &IID_ID3D12Device, (void **)&d);
+ say("D3D12CreateDevice(adapter, 11_0): 0x%08lx", (unsigned long)r);
+ if (SUCCEEDED(r) && d) {
+ D3D_FEATURE_LEVEL want[] = { D3D_FEATURE_LEVEL_12_1, D3D_FEATURE_LEVEL_12_0, D3D_FEATURE_LEVEL_11_1, D3D_FEATURE_LEVEL_11_0 };
+ D3D12_FEATURE_DATA_FEATURE_LEVELS fl = { 4, want, 0 };
+ r = ID3D12Device_CheckFeatureSupport(d, D3D12_FEATURE_FEATURE_LEVELS, &fl, sizeof fl);
+ say("CheckFeatureSupport(FEATURE_LEVELS 12_1..11_0): 0x%08lx -> max 0x%x", (unsigned long)r, fl.MaxSupportedFeatureLevel);
+ static const int SMS[] = { 0x66, 0x65, 0x60, 0x51 };
+ for (int i = 0; i < 4; i++) {
+ D3D12_FEATURE_DATA_SHADER_MODEL sm = { (D3D_SHADER_MODEL)SMS[i] };
+ r = ID3D12Device_CheckFeatureSupport(d, D3D12_FEATURE_SHADER_MODEL, &sm, sizeof sm);
+ say("CheckFeatureSupport(SHADER_MODEL ask 0x%x): 0x%08lx -> 0x%x", SMS[i], (unsigned long)r, sm.HighestShaderModel);
+ }
+ D3D12_FEATURE_DATA_ROOT_SIGNATURE rs = { D3D_ROOT_SIGNATURE_VERSION_1_1 };
+ r = ID3D12Device_CheckFeatureSupport(d, D3D12_FEATURE_ROOT_SIGNATURE, &rs, sizeof rs);
+ say("CheckFeatureSupport(ROOT_SIGNATURE ask 1_1): 0x%08lx -> highest 0x%x", (unsigned long)r, rs.HighestVersion);
+ D3D12_FEATURE_DATA_D3D12_OPTIONS o = {0};
+ r = ID3D12Device_CheckFeatureSupport(d, D3D12_FEATURE_D3D12_OPTIONS, &o, sizeof o);
+ say("OPTIONS: 0x%08lx, DoublePrecision %d, MinPrecision 0x%x, TypedUAVLoad %d, ROVs %d, StdSwizzle64KB %d, CrossNodeSharing %d, CrossAdapterRowMajor %d, VPAndRTArrayIndex %d",
+ (unsigned long)r, o.DoublePrecisionFloatShaderOps, o.MinPrecisionSupport, o.TypedUAVLoadAdditionalFormats, o.ROVsSupported,
+ o.StandardSwizzle64KBSupported, o.CrossNodeSharingTier, o.CrossAdapterRowMajorTextureSupported, o.VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation);
+ D3D12_FEATURE_DATA_D3D12_OPTIONS2 o2 = {0};
+ r = ID3D12Device_CheckFeatureSupport(d, D3D12_FEATURE_D3D12_OPTIONS2, &o2, sizeof o2);
+ say("OPTIONS2: 0x%08lx, DepthBoundsTest %d, ProgrammableSamplePositionsTier %d", (unsigned long)r, o2.DepthBoundsTestSupported, o2.ProgrammableSamplePositionsTier);
+ D3D12_FEATURE_DATA_D3D12_OPTIONS4 o4 = {0};
+ r = ID3D12Device_CheckFeatureSupport(d, D3D12_FEATURE_D3D12_OPTIONS4, &o4, sizeof o4);
+ say("OPTIONS4: 0x%08lx, Native16Bit %d, SharedResourceCompat %d", (unsigned long)r, o4.Native16BitShaderOpsSupported, o4.SharedResourceCompatibilityTier);
+ D3D12_FEATURE_DATA_D3D12_OPTIONS6 o6 = {0};
+ r = ID3D12Device_CheckFeatureSupport(d, D3D12_FEATURE_D3D12_OPTIONS6, &o6, sizeof o6);
+ say("OPTIONS6: 0x%08lx, VariableShadingRateTier %d, BackgroundProcessing %d", (unsigned long)r, o6.VariableShadingRateTier, o6.BackgroundProcessingSupported);
+ D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT va = {0};
+ r = ID3D12Device_CheckFeatureSupport(d, D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT, &va, sizeof va);
+ say("GPU_VIRTUAL_ADDRESS_SUPPORT: 0x%08lx, per resource %u bits, per process %u bits", (unsigned long)r, va.MaxGPUVirtualAddressBitsPerResource, va.MaxGPUVirtualAddressBitsPerProcess);
+ D3D12_FEATURE_DATA_FORMAT_SUPPORT fs = { DXGI_FORMAT_R8G8B8A8_UNORM, 0, 0 };
+ r = ID3D12Device_CheckFeatureSupport(d, D3D12_FEATURE_FORMAT_SUPPORT, &fs, sizeof fs);
+ say("FORMAT_SUPPORT(R8G8B8A8_UNORM): 0x%08lx, support1 0x%x, support2 0x%x", (unsigned long)r, fs.Support1, fs.Support2);
+ static const struct { const IID *iid; const char *name; } DEVS[] = {
+ { &IID_ID3D12Device1, "ID3D12Device1" }, { &IID_ID3D12Device2, "ID3D12Device2" }, { &IID_ID3D12Device3, "ID3D12Device3" },
+ { &IID_ID3D12Device4, "ID3D12Device4" }, { &IID_ID3D12Device5, "ID3D12Device5" }, { &IID_ID3D12Device6, "ID3D12Device6" },
+ { &IID_ID3D12Device7, "ID3D12Device7" }, { &IID_ID3D12Device8, "ID3D12Device8" }, { &IID_ID3D12InfoQueue, "ID3D12InfoQueue" },
+ };
+ for (unsigned i = 0; i < sizeof DEVS / sizeof DEVS[0]; i++) {
+ IUnknown *u = NULL;
+ r = ID3D12Device_QueryInterface(d, DEVS[i].iid, (void **)&u);
+ say("device QI %s: 0x%08lx", DEVS[i].name, (unsigned long)r);
+ if (u) IUnknown_Release(u);
+ }
+ static const struct { D3D12_COMMAND_LIST_TYPE t; const char *name; } QUEUES[] = {
+ { D3D12_COMMAND_LIST_TYPE_DIRECT, "direct" }, { D3D12_COMMAND_LIST_TYPE_COMPUTE, "compute" }, { D3D12_COMMAND_LIST_TYPE_COPY, "copy" } };
+ for (int i = 0; i < 3; i++) {
+ D3D12_COMMAND_QUEUE_DESC qd2 = { QUEUES[i].t, 0, D3D12_COMMAND_QUEUE_FLAG_NONE, 0 };
+ ID3D12CommandQueue *q2 = NULL;
+ r = ID3D12Device_CreateCommandQueue(d, &qd2, &IID_ID3D12CommandQueue, (void **)&q2);
+ say("CreateCommandQueue(%s): 0x%08lx", QUEUES[i].name, (unsigned long)r);
+ if (q2) ID3D12CommandQueue_Release(q2);
+ }
+ ID3D12Fence *fence = NULL;
+ r = ID3D12Device_CreateFence(d, 0, D3D12_FENCE_FLAG_NONE, &IID_ID3D12Fence, (void **)&fence);
+ say("CreateFence: 0x%08lx", (unsigned long)r);
+ if (fence) ID3D12Fence_Release(fence);
+ ID3D12CommandAllocator *alloc = NULL;
+ r = ID3D12Device_CreateCommandAllocator(d, D3D12_COMMAND_LIST_TYPE_DIRECT, &IID_ID3D12CommandAllocator, (void **)&alloc);
+ say("CreateCommandAllocator(direct): 0x%08lx", (unsigned long)r);
+ if (alloc) {
+ ID3D12GraphicsCommandList *cl = NULL;
+ r = ID3D12Device_CreateCommandList(d, 0, D3D12_COMMAND_LIST_TYPE_DIRECT, alloc, NULL, &IID_ID3D12GraphicsCommandList, (void **)&cl);
+ say("CreateCommandList(direct): 0x%08lx", (unsigned long)r);
+ if (cl) {
+ static const struct { const IID *iid; const char *name; } CLS[] = {
+ { &IID_ID3D12GraphicsCommandList1, "GraphicsCommandList1" }, { &IID_ID3D12GraphicsCommandList2, "GraphicsCommandList2" },
+ { &IID_ID3D12GraphicsCommandList3, "GraphicsCommandList3" }, { &IID_ID3D12GraphicsCommandList4, "GraphicsCommandList4" } };
+ for (int i = 0; i < 4; i++) {
+ IUnknown *u = NULL;
+ r = ID3D12GraphicsCommandList_QueryInterface(cl, CLS[i].iid, (void **)&u);
+ say("command list QI %s: 0x%08lx", CLS[i].name, (unsigned long)r);
+ if (u) IUnknown_Release(u);
+ }
+ ID3D12GraphicsCommandList_Release(cl);
+ }
+ ID3D12CommandAllocator_Release(alloc);
+ }
+ static const struct { D3D12_DESCRIPTOR_HEAP_TYPE t; UINT n; D3D12_DESCRIPTOR_HEAP_FLAGS f; const char *name; } HEAPS[] = {
+ { D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 1000000, D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE, "CBV_SRV_UAV 1000000 shader visible" },
+ { D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 65536, D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE, "CBV_SRV_UAV 65536 shader visible" },
+ { D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER, 2048, D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE, "SAMPLER 2048 shader visible" },
+ { D3D12_DESCRIPTOR_HEAP_TYPE_RTV, 1024, D3D12_DESCRIPTOR_HEAP_FLAG_NONE, "RTV 1024" },
+ { D3D12_DESCRIPTOR_HEAP_TYPE_DSV, 256, D3D12_DESCRIPTOR_HEAP_FLAG_NONE, "DSV 256" } };
+ for (unsigned i = 0; i < sizeof HEAPS / sizeof HEAPS[0]; i++) {
+ D3D12_DESCRIPTOR_HEAP_DESC hd = { HEAPS[i].t, HEAPS[i].n, HEAPS[i].f, 0 };
+ ID3D12DescriptorHeap *h = NULL;
+ r = ID3D12Device_CreateDescriptorHeap(d, &hd, &IID_ID3D12DescriptorHeap, (void **)&h);
+ say("CreateDescriptorHeap(%s): 0x%08lx", HEAPS[i].name, (unsigned long)r);
+ if (h) ID3D12DescriptorHeap_Release(h);
+ }
+ {
+ D3D12_HEAP_PROPERTIES hp = { D3D12_HEAP_TYPE_DEFAULT, D3D12_CPU_PAGE_PROPERTY_UNKNOWN, D3D12_MEMORY_POOL_UNKNOWN, 0, 0 };
+ D3D12_HEAP_PROPERTIES up = { D3D12_HEAP_TYPE_UPLOAD, D3D12_CPU_PAGE_PROPERTY_UNKNOWN, D3D12_MEMORY_POOL_UNKNOWN, 0, 0 };
+ D3D12_RESOURCE_DESC buf = { D3D12_RESOURCE_DIMENSION_BUFFER, 0, 65536, 1, 1, 1, DXGI_FORMAT_UNKNOWN, {1, 0}, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, D3D12_RESOURCE_FLAG_NONE };
+ D3D12_RESOURCE_DESC tex = { D3D12_RESOURCE_DIMENSION_TEXTURE2D, 0, 256, 256, 1, 1, DXGI_FORMAT_R8G8B8A8_UNORM, {1, 0}, D3D12_TEXTURE_LAYOUT_UNKNOWN, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET };
+ D3D12_RESOURCE_DESC dep = { D3D12_RESOURCE_DIMENSION_TEXTURE2D, 0, 256, 256, 1, 1, DXGI_FORMAT_D32_FLOAT, {1, 0}, D3D12_TEXTURE_LAYOUT_UNKNOWN, D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL };
+ D3D12_RESOURCE_DESC uav = { D3D12_RESOURCE_DIMENSION_BUFFER, 0, 65536, 1, 1, 1, DXGI_FORMAT_UNKNOWN, {1, 0}, D3D12_TEXTURE_LAYOUT_ROW_MAJOR, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS };
+ struct { const D3D12_HEAP_PROPERTIES *h; const D3D12_RESOURCE_DESC *d; D3D12_RESOURCE_STATES s; const char *name; } RES[] = {
+ { &hp, &buf, D3D12_RESOURCE_STATE_COMMON, "default buffer 64K" }, { &up, &buf, D3D12_RESOURCE_STATE_GENERIC_READ, "upload buffer 64K" },
+ { &hp, &tex, D3D12_RESOURCE_STATE_RENDER_TARGET, "render target 256x256 RGBA8" }, { &hp, &dep, D3D12_RESOURCE_STATE_DEPTH_WRITE, "depth 256x256 D32" },
+ { &hp, &uav, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, "UAV buffer 64K" } };
+ for (unsigned i = 0; i < sizeof RES / sizeof RES[0]; i++) {
+ ID3D12Resource *res = NULL;
+ r = ID3D12Device_CreateCommittedResource(d, RES[i].h, D3D12_HEAP_FLAG_NONE, RES[i].d, RES[i].s, NULL, &IID_ID3D12Resource, (void **)&res);
+ say("CreateCommittedResource(%s): 0x%08lx", RES[i].name, (unsigned long)r);
+ if (res) ID3D12Resource_Release(res);
+ }
+ D3D12_HEAP_DESC hd = { 64 << 20, hp, 0, D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS };
+ ID3D12Heap *heap = NULL;
+ r = ID3D12Device_CreateHeap(d, &hd, &IID_ID3D12Heap, (void **)&heap);
+ say("CreateHeap(64 MB buffers): 0x%08lx", (unsigned long)r);
+ if (heap) ID3D12Heap_Release(heap);
+ }
+ {
+ typedef HRESULT (WINAPI *ser_t)(const D3D12_VERSIONED_ROOT_SIGNATURE_DESC *, ID3DBlob **, ID3DBlob **);
+ ser_t ser = (ser_t)GetProcAddress(m, "D3D12SerializeVersionedRootSignature");
+ D3D12_VERSIONED_ROOT_SIGNATURE_DESC vd;
+ memset(&vd, 0, sizeof vd);
+ vd.Version = D3D_ROOT_SIGNATURE_VERSION_1_1;
+ vd.Desc_1_1.Flags = D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT;
+ ID3DBlob *blob = NULL, *err = NULL;
+ r = ser ? ser(&vd, &blob, &err) : E_NOTIMPL;
+ say("D3D12SerializeVersionedRootSignature(1_1, empty): 0x%08lx", (unsigned long)r);
+ if (SUCCEEDED(r) && blob) {
+ ID3D12RootSignature *rsig = NULL;
+ r = ID3D12Device_CreateRootSignature(d, 0, ID3D10Blob_GetBufferPointer(blob), ID3D10Blob_GetBufferSize(blob), &IID_ID3D12RootSignature, (void **)&rsig);
+ say("CreateRootSignature: 0x%08lx", (unsigned long)r);
+ if (rsig) ID3D12RootSignature_Release(rsig);
+ ID3D10Blob_Release(blob);
+ }
+ if (err) ID3D10Blob_Release(err);
+ }
+ ID3D12Device_Release(d);
+ }
+ IDXGIAdapter1_Release(ad);
+ }
+ if (fx) IDXGIFactory4_Release(fx);
+ }
say("dx12probe: done");
return 0;
}