matrixfurry.com
The open source OpenXR runtime
tests: Port aux d3d11 import tests to d3d12
Part-of: <https://gitlab.freedesktop.org/monado/monado/-/merge_requests/2577>
authored by
Krzysztof Lesiak
and committed by
korejan
85aeeeec
e5ec5755
+207
-1
+6
-1
tests/CMakeLists.txt
+6
-1
tests/CMakeLists.txt
···
27
27
list(APPEND tests tests_aux_d3d_d3d11 tests_comp_client_d3d11)
28
28
endif()
29
29
if(XRT_HAVE_D3D12)
30
-
list(APPEND tests tests_comp_client_d3d12)
30
+
list(APPEND tests tests_aux_d3d_d3d12 tests_comp_client_d3d12)
31
31
endif()
32
32
if(XRT_HAVE_VULKAN)
33
33
list(APPEND tests tests_comp_client_vulkan tests_uv_to_tangent)
···
87
87
endif()
88
88
89
89
if(XRT_HAVE_D3D12)
90
+
target_link_libraries(tests_aux_d3d_d3d12 PRIVATE aux_d3d)
90
91
target_link_libraries(tests_comp_client_d3d12 PRIVATE comp_client comp_mock)
91
92
endif()
92
93
···
112
113
if(XRT_HAVE_VULKAN AND XRT_HAVE_D3D11)
113
114
target_link_libraries(tests_aux_d3d_d3d11 PRIVATE comp_util aux_vk)
114
115
endif()
116
+
117
+
if(XRT_HAVE_VULKAN AND XRT_HAVE_D3D12)
118
+
target_link_libraries(tests_aux_d3d_d3d12 PRIVATE comp_util aux_vk)
119
+
endif()
+201
tests/tests_aux_d3d_d3d12.cpp
+201
tests/tests_aux_d3d_d3d12.cpp
···
1
+
// Copyright 2022, Collabora, Ltd.
2
+
// Copyright 2025, Holo-Light GmbH
3
+
// SPDX-License-Identifier: BSL-1.0
4
+
/*!
5
+
* @file
6
+
* @brief Direct3D 12 tests.
7
+
* @author Rylie Pavlik <rylie.pavlik@collabora.com>
8
+
* @author Krzysztof Lesiak <c-k.lesiak@holo-light.com>
9
+
*/
10
+
11
+
#include "catch_amalgamated.hpp"
12
+
13
+
#include <util/u_win32_com_guard.hpp>
14
+
#include <d3d/d3d_dxgi_helpers.hpp>
15
+
#include <d3d/d3d_d3d12_helpers.hpp>
16
+
#include <d3d/d3d_d3d12_allocator.hpp>
17
+
#include "aux_d3d_dxgi_formats.hpp"
18
+
19
+
#ifdef XRT_HAVE_VULKAN
20
+
#include "vktest_init_bundle.hpp"
21
+
#include <vk/vk_image_allocator.h>
22
+
#include <util/u_handles.h>
23
+
#include <d3d/d3d_dxgi_formats.h>
24
+
#endif
25
+
26
+
using namespace xrt::auxiliary::util;
27
+
28
+
TEST_CASE("d3d12_device", "[.][needgpu]")
29
+
{
30
+
ComGuard comGuard;
31
+
32
+
wil::com_ptr<IDXGIAdapter> adapter;
33
+
CHECK_NOTHROW(adapter = xrt::auxiliary::d3d::getAdapterByIndex(0, U_LOGGING_TRACE));
34
+
CHECK(adapter);
35
+
36
+
wil::com_ptr<ID3D12Device> device;
37
+
CHECK_NOTHROW(device = xrt::auxiliary::d3d::d3d12::createDevice(adapter, U_LOGGING_TRACE));
38
+
CHECK(device);
39
+
}
40
+
41
+
#ifdef XRT_HAVE_VULKAN
42
+
43
+
static inline bool
44
+
tryImport(struct vk_bundle *vk,
45
+
std::vector<wil::unique_handle> &handles,
46
+
const struct xrt_swapchain_create_info &xsci,
47
+
size_t image_mem_size)
48
+
{
49
+
// in d3d11 tryImport handles is const..here we do away with it so we can call release on handles passed in?
50
+
// I need to read more about wil and figure out lifetime semantics of all this.
51
+
52
+
INFO("Testing import into Vulkan");
53
+
54
+
static constexpr bool use_dedicated_allocation = false;
55
+
xrt_swapchain_create_info vk_info = xsci;
56
+
vk_info.format = d3d_dxgi_format_to_vk((DXGI_FORMAT)xsci.format);
57
+
const auto free_vk_ic = [&](struct vk_image_collection *vkic) {
58
+
vk_ic_destroy(vk, vkic);
59
+
delete vkic;
60
+
};
61
+
62
+
std::shared_ptr<vk_image_collection> vkic{new vk_image_collection, free_vk_ic};
63
+
64
+
uint32_t image_count = static_cast<uint32_t>(handles.size());
65
+
66
+
// Populate for import
67
+
std::vector<xrt_image_native> xins;
68
+
xins.reserve(image_count);
69
+
70
+
for (auto &handle : handles) {
71
+
xrt_image_native xin;
72
+
xin.handle = handle.get();
73
+
xin.size = image_mem_size;
74
+
xin.use_dedicated_allocation = use_dedicated_allocation;
75
+
xin.is_dxgi_handle = false;
76
+
77
+
xins.emplace_back(xin);
78
+
}
79
+
80
+
// Import into a vulkan image collection
81
+
bool result = VK_SUCCESS == vk_ic_from_natives(vk, &vk_info, xins.data(), (uint32_t)xins.size(), vkic.get());
82
+
83
+
if (result) {
84
+
// The imported swapchain took ownership of them now, release them from ownership here.
85
+
for (wil::unique_handle &h : handles) {
86
+
h.release();
87
+
}
88
+
}
89
+
return result;
90
+
}
91
+
#else
92
+
93
+
static inline bool
94
+
tryImport(struct vk_bundle * /* vk */,
95
+
std::vector<wil::unique_handle> const & /* handles */,
96
+
const struct xrt_swapchain_create_info & /* xsci */)
97
+
{
98
+
return true;
99
+
}
100
+
101
+
#endif
102
+
103
+
TEST_CASE("d3d12_allocate", "[.][needgpu]")
104
+
{
105
+
unique_vk_bundle vk = makeVkBundle();
106
+
107
+
#ifdef XRT_HAVE_VULKAN
108
+
REQUIRE(vktest_init_bundle(vk.get()));
109
+
#endif
110
+
111
+
ComGuard comGuard;
112
+
113
+
wil::com_ptr<IDXGIAdapter> adapter = xrt::auxiliary::d3d::getAdapterByIndex(0, U_LOGGING_TRACE);
114
+
wil::com_ptr<ID3D12Device> device = xrt::auxiliary::d3d::d3d12::createDevice(adapter, U_LOGGING_TRACE);
115
+
std::vector<wil::com_ptr<ID3D12Resource>> images;
116
+
std::vector<wil::unique_handle> handles;
117
+
size_t out_image_mem_size = 0;
118
+
119
+
size_t image_count = 3;
120
+
121
+
xrt_swapchain_create_info xsci{};
122
+
CAPTURE(xsci.sample_count = 1);
123
+
CAPTURE(xsci.width = 800);
124
+
CAPTURE(xsci.height = 600);
125
+
126
+
CAPTURE(xsci.mip_count = 1);
127
+
xsci.face_count = 1;
128
+
xsci.array_size = 1;
129
+
130
+
SECTION("create images")
131
+
{
132
+
auto nameAndFormat = GENERATE(values(namesAndFormats));
133
+
DYNAMIC_SECTION("Texture format " << nameAndFormat.first)
134
+
{
135
+
auto format = nameAndFormat.second;
136
+
CAPTURE(isDepthStencilFormat(format));
137
+
xsci.format = format;
138
+
if (isDepthStencilFormat(format)) {
139
+
xsci.bits = XRT_SWAPCHAIN_USAGE_DEPTH_STENCIL;
140
+
} else {
141
+
xsci.bits = XRT_SWAPCHAIN_USAGE_COLOR;
142
+
}
143
+
xsci.bits = (xrt_swapchain_usage_bits)(xsci.bits | XRT_SWAPCHAIN_USAGE_SAMPLED);
144
+
images.clear();
145
+
handles.clear();
146
+
147
+
SECTION("invalid array size 0")
148
+
{
149
+
CAPTURE(xsci.array_size = 0);
150
+
REQUIRE(XRT_SUCCESS !=
151
+
xrt::auxiliary::d3d::d3d12::allocateSharedImages(
152
+
*device.get(), xsci, image_count, images, handles, out_image_mem_size));
153
+
CHECK(images.empty());
154
+
CHECK(handles.empty());
155
+
}
156
+
SECTION("not array")
157
+
{
158
+
CAPTURE(xsci.array_size);
159
+
REQUIRE(XRT_SUCCESS ==
160
+
xrt::auxiliary::d3d::d3d12::allocateSharedImages(
161
+
*device.get(), xsci, image_count, images, handles, out_image_mem_size));
162
+
CHECK(images.size() == image_count);
163
+
CHECK(handles.size() == image_count);
164
+
CHECK(tryImport(vk.get(), handles, xsci, out_image_mem_size));
165
+
}
166
+
SECTION("array of 2")
167
+
{
168
+
CAPTURE(xsci.array_size = 2);
169
+
REQUIRE(XRT_SUCCESS ==
170
+
xrt::auxiliary::d3d::d3d12::allocateSharedImages(
171
+
*device.get(), xsci, image_count, images, handles, out_image_mem_size));
172
+
CHECK(images.size() == image_count);
173
+
CHECK(handles.size() == image_count);
174
+
CHECK(tryImport(vk.get(), handles, xsci, out_image_mem_size));
175
+
}
176
+
// this does not return an error...so i guess allocating cubemaps with d3d12 is fine?
177
+
// SECTION("cubemaps not implemented")
178
+
// {
179
+
// CAPTURE(xsci.array_size);
180
+
// CAPTURE(xsci.face_count = 6);
181
+
// REQUIRE(XRT_ERROR_ALLOCATION ==
182
+
// xrt::auxiliary::d3d::d3d12::allocateSharedImages(*device.get(), xsci,
183
+
// imageCount,
184
+
// images, handles,
185
+
// outImageMemSize));
186
+
// CHECK(images.empty());
187
+
// CHECK(handles.empty());
188
+
// }
189
+
SECTION("protected content not implemented")
190
+
{
191
+
CAPTURE(xsci.array_size);
192
+
CAPTURE(xsci.create = XRT_SWAPCHAIN_CREATE_PROTECTED_CONTENT);
193
+
REQUIRE(XRT_ERROR_SWAPCHAIN_FLAG_VALID_BUT_UNSUPPORTED ==
194
+
xrt::auxiliary::d3d::d3d12::allocateSharedImages(
195
+
*device.get(), xsci, image_count, images, handles, out_image_mem_size));
196
+
CHECK(images.empty());
197
+
CHECK(handles.empty());
198
+
}
199
+
}
200
+
}
201
+
}