Qt
Internal/Contributor docs for the Qt SDK. Note: These are NOT official API docs; those are found at https://doc.qt.io/
Loading...
Searching...
No Matches
qsgrhisupport.cpp
Go to the documentation of this file.
1// Copyright (C) 2019 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4#include "qsgrhisupport_p.h"
5#include "qsgcontext_p.h"
6#include "qsgdefaultrendercontext_p.h"
7
8#include <QtQuick/private/qquickitem_p.h>
9#include <QtQuick/private/qquickwindow_p.h>
10
11#include <QtGui/qwindow.h>
12
13#if QT_CONFIG(vulkan)
14#include <QtGui/private/qvulkandefaultinstance_p.h>
15#endif
16
17#include <QOperatingSystemVersion>
18#include <QLockFile>
19#include <QSaveFile>
20#include <QStandardPaths>
21#include <QDir>
22#include <QFileInfo>
23#include <QSysInfo>
24#include <QOffscreenSurface>
25
26#ifdef Q_OS_WIN
27#include <dxgiformat.h>
28#endif
29
30#include <memory>
31
32QT_BEGIN_NAMESPACE
33
34QSGRhiSupport::QSGRhiSupport()
35{
36}
37
38void QSGRhiSupport::applySettings()
39{
40 // Multiple calls to this function are perfectly possible!
41 // Just store that it was called at least once.
42 m_settingsApplied = true;
43
44 // This is also done when creating the renderloop but we may be before that
45 // in case we get here due to a setGraphicsApi() -> configure() early
46 // on in main(). Avoid losing info logs since troubleshooting gets
47 // confusing otherwise.
48 QSGRhiSupport::checkEnvQSgInfo();
49
50 if (m_requested.valid) {
51 // explicit rhi backend request from C++ (e.g. via QQuickWindow)
52 switch (m_requested.api) {
53 case QSGRendererInterface::OpenGL:
54 m_rhiBackend = QRhi::OpenGLES2;
55 break;
56 case QSGRendererInterface::Direct3D11:
57 m_rhiBackend = QRhi::D3D11;
58 break;
59 case QSGRendererInterface::Direct3D12:
60 m_rhiBackend = QRhi::D3D12;
61 break;
62 case QSGRendererInterface::Vulkan:
63 m_rhiBackend = QRhi::Vulkan;
64 break;
65 case QSGRendererInterface::Metal:
66 m_rhiBackend = QRhi::Metal;
67 break;
68 case QSGRendererInterface::Null:
69 m_rhiBackend = QRhi::Null;
70 break;
71 default:
72 Q_ASSERT_X(false, "QSGRhiSupport", "Internal error: unhandled GraphicsApi type");
73 break;
74 }
75 } else {
76 // check env.vars., fall back to platform-specific defaults when backend is not set
77 const QByteArray rhiBackend = qgetenv("QSG_RHI_BACKEND");
78 if (rhiBackend == QByteArrayLiteral("gl")
79 || rhiBackend == QByteArrayLiteral("gles2")
80 || rhiBackend == QByteArrayLiteral("opengl"))
81 {
82 m_rhiBackend = QRhi::OpenGLES2;
83 } else if (rhiBackend == QByteArrayLiteral("d3d11") || rhiBackend == QByteArrayLiteral("d3d")) {
84 m_rhiBackend = QRhi::D3D11;
85 } else if (rhiBackend == QByteArrayLiteral("d3d12")) {
86 m_rhiBackend = QRhi::D3D12;
87 } else if (rhiBackend == QByteArrayLiteral("vulkan")) {
88 m_rhiBackend = QRhi::Vulkan;
89 } else if (rhiBackend == QByteArrayLiteral("metal")) {
90 m_rhiBackend = QRhi::Metal;
91 } else if (rhiBackend == QByteArrayLiteral("null")) {
92 m_rhiBackend = QRhi::Null;
93 } else {
94 if (!rhiBackend.isEmpty()) {
95 qWarning("Unknown key \"%s\" for QSG_RHI_BACKEND, falling back to default backend.",
96 rhiBackend.constData());
97 }
98#if defined(Q_OS_WIN)
99 m_rhiBackend = QRhi::D3D11;
100#elif QT_CONFIG(metal)
101 m_rhiBackend = QRhi::Metal;
102#elif QT_CONFIG(opengl)
103 m_rhiBackend = QRhi::OpenGLES2;
104#else
105 m_rhiBackend = QRhi::Vulkan;
106#endif
107
108 // Now that we established our initial choice, we may want to opt
109 // for another backend under certain special circumstances.
110 adjustToPlatformQuirks();
111 }
112 }
113
114 // At this point the RHI backend is fixed, it cannot be changed once we
115 // return from this function. This is because things like the QWindow
116 // (QQuickWindow) may depend on the graphics API as well (surfaceType
117 // f.ex.), and all that is based on what we report from here. So further
118 // adjustments are not possible (or, at minimum, not safe and portable).
119}
120
121void QSGRhiSupport::adjustToPlatformQuirks()
122{
123#if QT_CONFIG(metal)
124 // A macOS VM may not have Metal support at all. We have to decide at this
125 // point, it will be too late afterwards, and the only way is to see if
126 // MTLCreateSystemDefaultDevice succeeds.
127 if (m_rhiBackend == QRhi::Metal) {
128 QRhiMetalInitParams rhiParams;
129 if (!QRhi::probe(m_rhiBackend, &rhiParams)) {
130 m_rhiBackend = QRhi::OpenGLES2;
131 qCDebug(QSG_LOG_INFO, "Metal does not seem to be supported. Falling back to OpenGL.");
132 }
133 }
134#endif
135}
136
137void QSGRhiSupport::checkEnvQSgInfo()
138{
139 // For compatibility with 5.3 and earlier's QSG_INFO environment variables
140 if (qEnvironmentVariableIsSet("QSG_INFO"))
141 const_cast<QLoggingCategory &>(QSG_LOG_INFO()).setEnabled(QtDebugMsg, true);
142}
143
144
145#if QT_CONFIG(opengl)
146#ifndef GL_BGRA
147#define GL_BGRA 0x80E1
148#endif
149
150#ifndef GL_R8
151#define GL_R8 0x8229
152#endif
153
154#ifndef GL_RG8
155#define GL_RG8 0x822B
156#endif
157
158#ifndef GL_RG
159#define GL_RG 0x8227
160#endif
161
162#ifndef GL_R16
163#define GL_R16 0x822A
164#endif
165
166#ifndef GL_RG16
167#define GL_RG16 0x822C
168#endif
169
170#ifndef GL_RED
171#define GL_RED 0x1903
172#endif
173
174#ifndef GL_RGBA8
175#define GL_RGBA8 0x8058
176#endif
177
178#ifndef GL_RGBA32F
179#define GL_RGBA32F 0x8814
180#endif
181
182#ifndef GL_RGBA16F
183#define GL_RGBA16F 0x881A
184#endif
185
186#ifndef GL_R16F
187#define GL_R16F 0x822D
188#endif
189
190#ifndef GL_R32F
191#define GL_R32F 0x822E
192#endif
193
194#ifndef GL_DEPTH_COMPONENT16
195#define GL_DEPTH_COMPONENT16 0x81A5
196#endif
197
198#ifndef GL_DEPTH_COMPONENT24
199#define GL_DEPTH_COMPONENT24 0x81A6
200#endif
201
202#ifndef GL_DEPTH_COMPONENT32F
203#define GL_DEPTH_COMPONENT32F 0x8CAC
204#endif
205
206#ifndef GL_DEPTH24_STENCIL8
207#define GL_DEPTH24_STENCIL8 0x88F0
208#endif
209
210#ifndef GL_DEPTH_STENCIL
211#define GL_DEPTH_STENCIL 0x84F9
212#endif
213
214#ifndef GL_RGB10_A2
215#define GL_RGB10_A2 0x8059
216#endif
217
218#ifndef GL_SRGB_ALPHA
219#define GL_SRGB_ALPHA 0x8C42
220#endif
221
222#ifndef GL_SRGB8_ALPHA8
223#define GL_SRGB8_ALPHA8 0x8C43
224#endif
225
226QRhiTexture::Format QSGRhiSupport::toRhiTextureFormatFromGL(uint format, QRhiTexture::Flags *flags)
227{
228 bool sRGB = false;
229 auto rhiFormat = QRhiTexture::UnknownFormat;
230 switch (format) {
231 case GL_SRGB_ALPHA:
232 case GL_SRGB8_ALPHA8:
233 sRGB = true;
234 Q_FALLTHROUGH();
235 case GL_RGBA:
236 case GL_RGBA8:
237 case 0:
238 rhiFormat = QRhiTexture::RGBA8;
239 break;
240 case GL_BGRA:
241 rhiFormat = QRhiTexture::BGRA8;
242 break;
243 case GL_R16:
244 rhiFormat = QRhiTexture::R16;
245 break;
246 case GL_RG16:
247 rhiFormat = QRhiTexture::RG16;
248 break;
249 case GL_RED:
250 Q_FALLTHROUGH();
251 case GL_R8:
252 rhiFormat = QRhiTexture::R8;
253 break;
254 case GL_RG:
255 Q_FALLTHROUGH();
256 case GL_RG8:
257 rhiFormat = QRhiTexture::RG8;
258 break;
259 case GL_ALPHA:
260 rhiFormat = QRhiTexture::RED_OR_ALPHA8;
261 break;
262 case GL_RGBA16F:
263 rhiFormat = QRhiTexture::RGBA16F;
264 break;
265 case GL_RGBA32F:
266 rhiFormat = QRhiTexture::RGBA32F;
267 break;
268 case GL_R16F:
269 rhiFormat = QRhiTexture::R16F;
270 break;
271 case GL_R32F:
272 rhiFormat = QRhiTexture::R32F;
273 break;
274 case GL_RGB10_A2:
275 rhiFormat = QRhiTexture::RGB10A2;
276 break;
277 case GL_DEPTH_COMPONENT:
278 Q_FALLTHROUGH();
279 case GL_DEPTH_COMPONENT16:
280 rhiFormat = QRhiTexture::D16;
281 break;
282 case GL_DEPTH_COMPONENT24:
283 rhiFormat = QRhiTexture::D24;
284 break;
285 case GL_DEPTH_STENCIL:
286 Q_FALLTHROUGH();
287 case GL_DEPTH24_STENCIL8:
288 rhiFormat = QRhiTexture::D24S8;
289 break;
290 case GL_DEPTH_COMPONENT32F:
291 rhiFormat = QRhiTexture::D32F;
292 break;
293 default:
294 qWarning("GL format %d is not supported", format);
295 break;
296 }
297 if (sRGB)
298 (*flags) |=(QRhiTexture::sRGB);
299 return rhiFormat;
300}
301#endif
302
303#if QT_CONFIG(vulkan)
304QRhiTexture::Format QSGRhiSupport::toRhiTextureFormatFromVulkan(uint format, QRhiTexture::Flags *flags)
305{
306 auto rhiFormat = QRhiTexture::UnknownFormat;
307 bool sRGB = false;
308 switch (format) {
309 case VK_FORMAT_R8G8B8A8_SRGB:
310 sRGB = true;
311 Q_FALLTHROUGH();
312 case VK_FORMAT_R8G8B8A8_UNORM:
313 case VK_FORMAT_UNDEFINED:
314 rhiFormat = QRhiTexture::RGBA8;
315 break;
316 case VK_FORMAT_B8G8R8A8_SRGB:
317 sRGB = true;
318 Q_FALLTHROUGH();
319 case VK_FORMAT_B8G8R8A8_UNORM:
320 rhiFormat = QRhiTexture::BGRA8;
321 break;
322 case VK_FORMAT_R8_SRGB:
323 sRGB = true;
324 Q_FALLTHROUGH();
325 case VK_FORMAT_R8_UNORM:
326 rhiFormat = QRhiTexture::R8;
327 break;
328 case VK_FORMAT_R8G8_SRGB:
329 sRGB = true;
330 Q_FALLTHROUGH();
331 case VK_FORMAT_R8G8_UNORM:
332 rhiFormat = QRhiTexture::RG8;
333 break;
334 case VK_FORMAT_R16_UNORM:
335 rhiFormat = QRhiTexture::R16;
336 break;
337 case VK_FORMAT_R16G16_UNORM:
338 rhiFormat = QRhiTexture::RG16;
339 break;
340 case VK_FORMAT_R16G16B16A16_SFLOAT:
341 rhiFormat = QRhiTexture::RGBA16F;
342 break;
343 case VK_FORMAT_R32G32B32A32_SFLOAT:
344 rhiFormat = QRhiTexture::RGBA32F;
345 break;
346 case VK_FORMAT_R16_SFLOAT:
347 rhiFormat = QRhiTexture::R16F;
348 break;
349 case VK_FORMAT_R32_SFLOAT:
350 rhiFormat = QRhiTexture::R32F;
351 break;
352 case VK_FORMAT_A2B10G10R10_UNORM_PACK32: // intentionally
353 Q_FALLTHROUGH();
354 case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
355 rhiFormat = QRhiTexture::RGB10A2;
356 break;
357 case VK_FORMAT_D16_UNORM:
358 rhiFormat = QRhiTexture::D16;
359 break;
360 case VK_FORMAT_X8_D24_UNORM_PACK32:
361 rhiFormat = QRhiTexture::D24;
362 break;
363 case VK_FORMAT_D24_UNORM_S8_UINT:
364 rhiFormat = QRhiTexture::D24S8;
365 break;
366 case VK_FORMAT_D32_SFLOAT:
367 rhiFormat = QRhiTexture::D32F;
368 break;
369 case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
370 sRGB = true;
371 Q_FALLTHROUGH();
372 case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
373 rhiFormat = QRhiTexture::BC1;
374 break;
375 case VK_FORMAT_BC2_SRGB_BLOCK:
376 sRGB = true;
377 Q_FALLTHROUGH();
378 case VK_FORMAT_BC2_UNORM_BLOCK:
379 rhiFormat = QRhiTexture::BC2;
380 break;
381 case VK_FORMAT_BC3_SRGB_BLOCK:
382 sRGB = true;
383 Q_FALLTHROUGH();
384 case VK_FORMAT_BC3_UNORM_BLOCK:
385 rhiFormat = QRhiTexture::BC3;
386 break;
387 case VK_FORMAT_BC4_UNORM_BLOCK:
388 rhiFormat = QRhiTexture::BC4;
389 break;
390 case VK_FORMAT_BC5_UNORM_BLOCK:
391 rhiFormat = QRhiTexture::BC5;
392 break;
393 case VK_FORMAT_BC6H_UFLOAT_BLOCK:
394 rhiFormat = QRhiTexture::BC6H;
395 break;
396 case VK_FORMAT_BC7_SRGB_BLOCK:
397 sRGB = true;
398 Q_FALLTHROUGH();
399 case VK_FORMAT_BC7_UNORM_BLOCK:
400 rhiFormat = QRhiTexture::BC7;
401 break;
402 case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
403 sRGB = true;
404 Q_FALLTHROUGH();
405 case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
406 rhiFormat = QRhiTexture::ETC2_RGB8;
407 break;
408 case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
409 sRGB = true;
410 Q_FALLTHROUGH();
411 case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
412 rhiFormat = QRhiTexture::ETC2_RGB8A1;
413 break;
414 case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
415 sRGB = true;
416 Q_FALLTHROUGH();
417 case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
418 rhiFormat = QRhiTexture::ETC2_RGBA8;
419 break;
420 case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
421 sRGB = true;
422 Q_FALLTHROUGH();
423 case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
424 rhiFormat = QRhiTexture::ASTC_4x4;
425 break;
426 case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
427 sRGB = true;
428 Q_FALLTHROUGH();
429 case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
430 rhiFormat = QRhiTexture::ASTC_5x4;
431 break;
432 case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
433 sRGB = true;
434 Q_FALLTHROUGH();
435 case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
436 rhiFormat = QRhiTexture::ASTC_5x5;
437 break;
438 case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
439 sRGB = true;
440 Q_FALLTHROUGH();
441 case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
442 rhiFormat = QRhiTexture::ASTC_6x5;
443 break;
444 case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
445 sRGB = true;
446 Q_FALLTHROUGH();
447 case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
448 rhiFormat = QRhiTexture::ASTC_6x6;
449 break;
450 case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
451 sRGB = true;
452 Q_FALLTHROUGH();
453 case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
454 rhiFormat = QRhiTexture::ASTC_8x5;
455 break;
456 case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
457 sRGB = true;
458 Q_FALLTHROUGH();
459 case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
460 rhiFormat = QRhiTexture::ASTC_8x6;
461 break;
462 case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
463 sRGB = true;
464 Q_FALLTHROUGH();
465 case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
466 rhiFormat = QRhiTexture::ASTC_8x8;
467 break;
468 case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
469 sRGB = true;
470 Q_FALLTHROUGH();
471 case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
472 rhiFormat = QRhiTexture::ASTC_10x5;
473 break;
474 case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
475 sRGB = true;
476 Q_FALLTHROUGH();
477 case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
478 rhiFormat = QRhiTexture::ASTC_10x6;
479 break;
480 case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
481 sRGB = true;
482 Q_FALLTHROUGH();
483 case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
484 rhiFormat = QRhiTexture::ASTC_10x8;
485 break;
486 case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
487 sRGB = true;
488 Q_FALLTHROUGH();
489 case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
490 rhiFormat = QRhiTexture::ASTC_10x10;
491 break;
492 case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
493 sRGB = true;
494 Q_FALLTHROUGH();
495 case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
496 rhiFormat = QRhiTexture::ASTC_12x10;
497 break;
498 case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
499 sRGB = true;
500 Q_FALLTHROUGH();
501 case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
502 rhiFormat = QRhiTexture::ASTC_12x12;
503 break;
504 default:
505 qWarning("VkFormat %d is not supported", format);
506 break;
507 }
508 if (sRGB)
509 (*flags) |=(QRhiTexture::sRGB);
510 return rhiFormat;
511}
512#endif
513
514#ifdef Q_OS_WIN
515QRhiTexture::Format QSGRhiSupport::toRhiTextureFormatFromDXGI(uint format, QRhiTexture::Flags *flags)
516{
517 auto rhiFormat = QRhiTexture::UnknownFormat;
518 bool sRGB = false;
519 switch (format) {
520 case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB:
521 sRGB = true;
522 Q_FALLTHROUGH();
523 case DXGI_FORMAT_R8G8B8A8_UNORM:
524 case DXGI_FORMAT_UNKNOWN:
525 rhiFormat = QRhiTexture::RGBA8;
526 break;
527 case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB:
528 sRGB = true;
529 Q_FALLTHROUGH();
530 case DXGI_FORMAT_B8G8R8A8_UNORM:
531 rhiFormat = QRhiTexture::BGRA8;
532 break;
533 case DXGI_FORMAT_R8_UNORM:
534 rhiFormat = QRhiTexture::R8;
535 break;
536 case DXGI_FORMAT_R8G8_UNORM:
537 rhiFormat = QRhiTexture::RG8;
538 break;
539 case DXGI_FORMAT_R16_UNORM:
540 rhiFormat = QRhiTexture::R16;
541 break;
542 case DXGI_FORMAT_R16G16_UNORM:
543 rhiFormat = QRhiTexture::RG16;
544 break;
545 case DXGI_FORMAT_R16G16B16A16_FLOAT:
546 rhiFormat = QRhiTexture::RGBA16F;
547 break;
548 case DXGI_FORMAT_R32G32B32A32_FLOAT:
549 rhiFormat = QRhiTexture::RGBA32F;
550 break;
551 case DXGI_FORMAT_R16_FLOAT:
552 rhiFormat = QRhiTexture::R16F;
553 break;
554 case DXGI_FORMAT_R32_FLOAT:
555 rhiFormat = QRhiTexture::R32F;
556 break;
557 case DXGI_FORMAT_R10G10B10A2_UNORM:
558 rhiFormat = QRhiTexture::RGB10A2;
559 break;
560 case DXGI_FORMAT_R16_TYPELESS:
561 rhiFormat = QRhiTexture::D16;
562 break;
563 case DXGI_FORMAT_R24_UNORM_X8_TYPELESS:
564 rhiFormat = QRhiTexture::D24;
565 break;
566 case DXGI_FORMAT_D24_UNORM_S8_UINT:
567 rhiFormat = QRhiTexture::D24S8;
568 break;
569 case DXGI_FORMAT_R32_TYPELESS:
570 rhiFormat = QRhiTexture::D32F;
571 break;
572 case DXGI_FORMAT_BC1_UNORM_SRGB:
573 sRGB = true;
574 Q_FALLTHROUGH();
575 case DXGI_FORMAT_BC1_UNORM:
576 rhiFormat = QRhiTexture::BC1;
577 break;
578 case DXGI_FORMAT_BC2_UNORM_SRGB:
579 sRGB = true;
580 Q_FALLTHROUGH();
581 case DXGI_FORMAT_BC2_UNORM:
582 rhiFormat = QRhiTexture::BC2;
583 break;
584 case DXGI_FORMAT_BC3_UNORM_SRGB:
585 sRGB = true;
586 Q_FALLTHROUGH();
587 case DXGI_FORMAT_BC3_UNORM:
588 rhiFormat = QRhiTexture::BC3;
589 break;
590 case DXGI_FORMAT_BC4_UNORM:
591 rhiFormat = QRhiTexture::BC4;
592 break;
593 case DXGI_FORMAT_BC5_UNORM:
594 rhiFormat = QRhiTexture::BC5;
595 break;
596 case DXGI_FORMAT_BC6H_UF16:
597 rhiFormat = QRhiTexture::BC6H;
598 break;
599 case DXGI_FORMAT_BC7_UNORM_SRGB:
600 sRGB = true;
601 Q_FALLTHROUGH();
602 case DXGI_FORMAT_BC7_UNORM:
603 rhiFormat = QRhiTexture::BC7;
604 break;
605 default:
606 qWarning("DXGI_FORMAT %d is not supported", format);
607 break;
608 }
609 if (sRGB)
610 (*flags) |=(QRhiTexture::sRGB);
611 return rhiFormat;
612}
613#endif
614
615#if QT_CONFIG(metal)
616namespace QSGRhiSupportMac {
617 QRhiTexture::Format toRhiTextureFormatFromMetal(uint format, QRhiTexture::Flags *flags);
618}
619QRhiTexture::Format QSGRhiSupport::toRhiTextureFormatFromMetal(uint format, QRhiTexture::Flags *flags)
620{
621 return QSGRhiSupportMac::toRhiTextureFormatFromMetal(format, flags);
622}
623#endif
624
625void QSGRhiSupport::configure(QSGRendererInterface::GraphicsApi api)
626{
627 if (api == QSGRendererInterface::Unknown) {
628 // behave as if nothing was explicitly requested
629 m_requested.valid = false;
630 applySettings();
631 } else {
632 Q_ASSERT(QSGRendererInterface::isApiRhiBased(api));
633 m_requested.valid = true;
634 m_requested.api = api;
635 applySettings();
636 }
637}
638
639QSGRhiSupport *QSGRhiSupport::instance_internal()
640{
641 static QSGRhiSupport inst;
642 return &inst;
643}
644
645QSGRhiSupport *QSGRhiSupport::instance()
646{
647 QSGRhiSupport *inst = instance_internal();
648 if (!inst->m_settingsApplied)
649 inst->applySettings();
650 return inst;
651}
652
653QString QSGRhiSupport::rhiBackendName() const
654{
655 return QString::fromUtf8(QRhi::backendName(m_rhiBackend));
656}
657
658QSGRendererInterface::GraphicsApi QSGRhiSupport::graphicsApi() const
659{
660 switch (m_rhiBackend) {
661 case QRhi::Null:
662 return QSGRendererInterface::Null;
663 case QRhi::Vulkan:
664 return QSGRendererInterface::Vulkan;
665 case QRhi::OpenGLES2:
666 return QSGRendererInterface::OpenGL;
667 case QRhi::D3D11:
668 return QSGRendererInterface::Direct3D11;
669 case QRhi::D3D12:
670 return QSGRendererInterface::Direct3D12;
671 case QRhi::Metal:
672 return QSGRendererInterface::Metal;
673 default:
674 return QSGRendererInterface::Unknown;
675 }
676}
677
678QSurface::SurfaceType QSGRhiSupport::windowSurfaceType() const
679{
680 switch (m_rhiBackend) {
681 case QRhi::Vulkan:
682 return QSurface::VulkanSurface;
683 case QRhi::OpenGLES2:
684 return QSurface::OpenGLSurface;
685 case QRhi::D3D11:
686 case QRhi::D3D12:
687 return QSurface::Direct3DSurface;
688 case QRhi::Metal:
689 return QSurface::MetalSurface;
690 default:
691 return QSurface::OpenGLSurface;
692 }
693}
694
695#if QT_CONFIG(vulkan)
696static const void *qsgrhi_vk_rifResource(QSGRendererInterface::Resource res,
697 const QRhiNativeHandles *nat,
698 const QRhiNativeHandles *cbNat,
699 const QRhiNativeHandles *rpNat)
700{
701 const QRhiVulkanNativeHandles *vknat = static_cast<const QRhiVulkanNativeHandles *>(nat);
702 const QRhiVulkanCommandBufferNativeHandles *maybeVkCbNat =
703 static_cast<const QRhiVulkanCommandBufferNativeHandles *>(cbNat);
704 const QRhiVulkanRenderPassNativeHandles *maybeVkRpNat =
705 static_cast<const QRhiVulkanRenderPassNativeHandles *>(rpNat);
706
707 switch (res) {
708 case QSGRendererInterface::DeviceResource:
709 return &vknat->dev;
710 case QSGRendererInterface::CommandQueueResource:
711 return &vknat->gfxQueue;
712 case QSGRendererInterface::CommandListResource:
713 if (maybeVkCbNat)
714 return &maybeVkCbNat->commandBuffer;
715 else
716 return nullptr;
717 case QSGRendererInterface::PhysicalDeviceResource:
718 return &vknat->physDev;
719 case QSGRendererInterface::RenderPassResource:
720 if (maybeVkRpNat)
721 return &maybeVkRpNat->renderPass;
722 else
723 return nullptr;
724 case QSGRendererInterface::GraphicsQueueFamilyIndexResource:
725 return &vknat->gfxQueueFamilyIdx;
726 case QSGRendererInterface::GraphicsQueueIndexResource:
727 return &vknat->gfxQueueIdx;
728 default:
729 return nullptr;
730 }
731}
732#endif
733
734#if QT_CONFIG(opengl)
735static const void *qsgrhi_gl_rifResource(QSGRendererInterface::Resource res, const QRhiNativeHandles *nat)
736{
737 const QRhiGles2NativeHandles *glnat = static_cast<const QRhiGles2NativeHandles *>(nat);
738 switch (res) {
739 case QSGRendererInterface::OpenGLContextResource:
740 return glnat->context;
741 default:
742 return nullptr;
743 }
744}
745#endif
746
747#ifdef Q_OS_WIN
748static const void *qsgrhi_d3d11_rifResource(QSGRendererInterface::Resource res, const QRhiNativeHandles *nat)
749{
750 const QRhiD3D11NativeHandles *d3dnat = static_cast<const QRhiD3D11NativeHandles *>(nat);
751 switch (res) {
752 case QSGRendererInterface::DeviceResource:
753 return d3dnat->dev;
754 case QSGRendererInterface::DeviceContextResource:
755 return d3dnat->context;
756 default:
757 return nullptr;
758 }
759}
760
761static const void *qsgrhi_d3d12_rifResource(QSGRendererInterface::Resource res, const QRhiNativeHandles *nat)
762{
763 const QRhiD3D12NativeHandles *d3dnat = static_cast<const QRhiD3D12NativeHandles *>(nat);
764 switch (res) {
765 case QSGRendererInterface::DeviceResource:
766 return d3dnat->dev;
767 case QSGRendererInterface::CommandQueueResource:
768 return d3dnat->commandQueue;
769 default:
770 return nullptr;
771 }
772}
773#endif
774
775#if QT_CONFIG(metal)
776static const void *qsgrhi_mtl_rifResource(QSGRendererInterface::Resource res, const QRhiNativeHandles *nat,
777 const QRhiNativeHandles *cbNat)
778{
779 const QRhiMetalNativeHandles *mtlnat = static_cast<const QRhiMetalNativeHandles *>(nat);
780 const QRhiMetalCommandBufferNativeHandles *maybeMtlCbNat =
781 static_cast<const QRhiMetalCommandBufferNativeHandles *>(cbNat);
782
783 switch (res) {
784 case QSGRendererInterface::DeviceResource:
785 return mtlnat->dev;
786 case QSGRendererInterface::CommandQueueResource:
787 return mtlnat->cmdQueue;
788 case QSGRendererInterface::CommandListResource:
789 if (maybeMtlCbNat)
790 return maybeMtlCbNat->commandBuffer;
791 else
792 return nullptr;
793 case QSGRendererInterface::CommandEncoderResource:
794 if (maybeMtlCbNat)
795 return maybeMtlCbNat->encoder;
796 else
797 return nullptr;
798 default:
799 return nullptr;
800 }
801}
802#endif
803
804const void *QSGRhiSupport::rifResource(QSGRendererInterface::Resource res,
805 const QSGDefaultRenderContext *rc,
806 const QQuickWindow *w)
807{
808 QRhi *rhi = rc->rhi();
809 if (!rhi)
810 return nullptr;
811
812 // Accessing the underlying QRhi* objects are essential both for Qt Quick
813 // 3D and advanced solutions, such as VR engine integrations.
814 switch (res) {
815 case QSGRendererInterface::RhiResource:
816 return rhi;
817 case QSGRendererInterface::RhiSwapchainResource:
818 return QQuickWindowPrivate::get(w)->swapchain;
819 case QSGRendererInterface::RhiRedirectCommandBuffer:
820 return QQuickWindowPrivate::get(w)->redirect.commandBuffer;
821 case QSGRendererInterface::RhiRedirectRenderTarget:
822 return QQuickWindowPrivate::get(w)->redirect.rt.rt.renderTarget;
823 default:
824 break;
825 }
826
827 const QRhiNativeHandles *nat = rhi->nativeHandles();
828 if (!nat)
829 return nullptr;
830
831 switch (m_rhiBackend) {
832#if QT_CONFIG(vulkan)
833 case QRhi::Vulkan:
834 {
835 QRhiCommandBuffer *cb = rc->currentFrameCommandBuffer();
836 QRhiRenderPassDescriptor *rp = rc->currentFrameRenderPass();
837 return qsgrhi_vk_rifResource(res, nat,
838 cb ? cb->nativeHandles() : nullptr,
839 rp ? rp->nativeHandles() : nullptr);
840 }
841#endif
842#if QT_CONFIG(opengl)
843 case QRhi::OpenGLES2:
844 return qsgrhi_gl_rifResource(res, nat);
845#endif
846#ifdef Q_OS_WIN
847 case QRhi::D3D11:
848 return qsgrhi_d3d11_rifResource(res, nat);
849 case QRhi::D3D12:
850 return qsgrhi_d3d12_rifResource(res, nat);
851#endif
852#if QT_CONFIG(metal)
853 case QRhi::Metal:
854 {
855 QRhiCommandBuffer *cb = rc->currentFrameCommandBuffer();
856 return qsgrhi_mtl_rifResource(res, nat, cb ? cb->nativeHandles() : nullptr);
857 }
858#endif
859 default:
860 return nullptr;
861 }
862}
863
864int QSGRhiSupport::chooseSampleCount(int samples, QRhi *rhi)
865{
866 int msaaSampleCount = samples;
867 if (qEnvironmentVariableIsSet("QSG_SAMPLES"))
868 msaaSampleCount = qEnvironmentVariableIntValue("QSG_SAMPLES");
869 msaaSampleCount = qMax(1, msaaSampleCount);
870 if (msaaSampleCount > 1) {
871 const QVector<int> supportedSampleCounts = rhi->supportedSampleCounts();
872 if (!supportedSampleCounts.contains(msaaSampleCount)) {
873 int reducedSampleCount = 1;
874 for (int i = supportedSampleCounts.size() - 1; i >= 0; --i) {
875 if (supportedSampleCounts[i] <= msaaSampleCount) {
876 reducedSampleCount = supportedSampleCounts[i];
877 break;
878 }
879 }
880 qWarning() << "Requested MSAA sample count" << msaaSampleCount
881 << "but supported sample counts are" << supportedSampleCounts
882 << ", using sample count" << reducedSampleCount << "instead";
883 msaaSampleCount = reducedSampleCount;
884 }
885 }
886 return msaaSampleCount;
887}
888
889int QSGRhiSupport::chooseSampleCountForWindowWithRhi(QWindow *window, QRhi *rhi)
890{
891 return chooseSampleCount(qMax(QSurfaceFormat::defaultFormat().samples(), window->requestedFormat().samples()), rhi);
892}
893
894// must be called on the main thread
895QOffscreenSurface *QSGRhiSupport::maybeCreateOffscreenSurface(QWindow *window)
896{
897 QOffscreenSurface *offscreenSurface = nullptr;
898#if QT_CONFIG(opengl)
899 if (rhiBackend() == QRhi::OpenGLES2) {
900 const QSurfaceFormat format = window->requestedFormat();
901 offscreenSurface = QRhiGles2InitParams::newFallbackSurface(format);
902 }
903#else
904 Q_UNUSED(window);
905#endif
906 return offscreenSurface;
907}
908
909void QSGRhiSupport::prepareWindowForRhi(QQuickWindow *window)
910{
911#if QT_CONFIG(vulkan)
912 if (rhiBackend() == QRhi::Vulkan) {
913 QQuickWindowPrivate *wd = QQuickWindowPrivate::get(window);
914 // QQuickWindows must get a QVulkanInstance automatically (it is
915 // created when the first window is constructed and is destroyed only
916 // on exit), unless the application decided to set its own. With
917 // QQuickRenderControl, no QVulkanInstance is created, because it must
918 // always be under the application's control then (since the default
919 // instance we could create here would not be configurable by the
920 // application in any way, and that is often not acceptable).
921 if (!window->vulkanInstance() && !wd->renderControl) {
922 QVulkanInstance *vkinst = QVulkanDefaultInstance::instance();
923 if (vkinst)
924 qCDebug(QSG_LOG_INFO) << "Got Vulkan instance from QVulkanDefaultInstance, requested api version was" << vkinst->apiVersion();
925 else
926 qCDebug(QSG_LOG_INFO) << "No Vulkan instance from QVulkanDefaultInstance, expect problems";
927 window->setVulkanInstance(vkinst);
928 }
929 }
930#else
931 Q_UNUSED(window);
932#endif
933}
934
935static inline bool ensureWritableDir(const QString &name)
936{
937 QDir::root().mkpath(name);
938 return QFileInfo(name).isWritable();
939}
940
941static QString automaticPipelineCacheDir()
942{
943 static bool checked = false;
944 static QString currentCacheDir;
945 static bool cacheWritable = false;
946
947 if (checked)
948 return cacheWritable ? currentCacheDir : QString();
949
950 checked = true;
951
952 // Intentionally not using the global cache path (GenericCacheLocation) -
953 // we do not want forever growing pipeline cache files that contain
954 // everything from all Qt apps ever run (that would affect load times
955 // eventually, resource use, etc.). Stick to being application-specific.
956
957 const QString cachePath = QStandardPaths::writableLocation(QStandardPaths::CacheLocation);
958 const QString subPath = QLatin1String("/qtpipelinecache-") + QSysInfo::buildAbi() + QLatin1Char('/');
959
960 if (!cachePath.isEmpty()) {
961 currentCacheDir = cachePath + subPath;
962 cacheWritable = ensureWritableDir(currentCacheDir);
963 }
964
965 return cacheWritable ? currentCacheDir : QString();
966}
967
968static inline QString automaticPipelineCacheFileName(QRhi *rhi)
969{
970 const QString cacheDir = automaticPipelineCacheDir();
971 if (!cacheDir.isEmpty())
972 return cacheDir + QLatin1String("qqpc_") + QString::fromLatin1(rhi->backendName()).toLower();
973
974 return QString();
975}
976
977static inline bool isAutomaticPipelineCacheLoadSkippedForWindow(Qt::WindowFlags wflags)
978{
979 return wflags.testFlag(Qt::ToolTip) || wflags.testFlag(Qt::SplashScreen);
980}
981
982static inline bool isAutomaticPipelineCacheSaveSkippedForWindow(Qt::WindowFlags wflags)
983{
984 // this catches Tool, ToolTip, SplashScreen as well
985 return wflags.testFlag(Qt::Dialog) || wflags.testFlag(Qt::Popup);
986}
987
988#if !QT_CONFIG(temporaryfile)
989static inline QString pipelineCacheLockFileName(const QString &name)
990{
991 return name + QLatin1String(".lck");
992}
993#endif
994
995void QSGRhiSupport::preparePipelineCache(QRhi *rhi, QQuickWindow *window)
996{
997 QQuickWindowPrivate *wd = QQuickWindowPrivate::get(window);
998
999 // the explicitly set filename always takes priority as per docs
1000 QString pipelineCacheLoad = wd->graphicsConfig.pipelineCacheLoadFile();
1001 bool isAutomatic = false;
1002 if (pipelineCacheLoad.isEmpty() && wd->graphicsConfig.isAutomaticPipelineCacheEnabled()) {
1003 if (!isAutomaticPipelineCacheLoadSkippedForWindow(window->flags())) {
1004 pipelineCacheLoad = automaticPipelineCacheFileName(rhi);
1005 isAutomatic = true;
1006 }
1007 }
1008
1009 if (pipelineCacheLoad.isEmpty())
1010 return;
1011
1012#if !QT_CONFIG(temporaryfile)
1013 QLockFile lock(pipelineCacheLockFileName(pipelineCacheLoad));
1014 if (!lock.lock()) {
1015 qWarning("Could not create pipeline cache lock file '%s'",
1016 qPrintable(lock.fileName()));
1017 return;
1018 }
1019#endif
1020
1021 QFile f(pipelineCacheLoad);
1022 if (!f.open(QIODevice::ReadOnly)) {
1023 if (!isAutomatic) {
1024 qWarning("Could not open pipeline cache source file '%s'",
1025 qPrintable(pipelineCacheLoad));
1026 }
1027 return;
1028 }
1029
1030 const QByteArray buf = f.readAll();
1031 if (!buf.isEmpty()) {
1032 qCDebug(QSG_LOG_INFO, "Attempting to seed pipeline cache for QRhi %p from '%s'",
1033 rhi, qPrintable(pipelineCacheLoad));
1034 rhi->setPipelineCacheData(buf);
1035 }
1036}
1037
1038void QSGRhiSupport::finalizePipelineCache(QRhi *rhi, const QQuickGraphicsConfiguration &config)
1039{
1040 // output the rhi statistics about pipelines, as promised by the documentation
1041 qCDebug(QSG_LOG_INFO, "Total time spent on pipeline creation during the lifetime of the QRhi %p was %lld ms",
1042 rhi, rhi->statistics().totalPipelineCreationTime);
1043
1044 // the explicitly set filename always takes priority as per docs
1045 QString pipelineCacheSave = config.pipelineCacheSaveFile();
1046 bool isAutomatic = false;
1047 if (pipelineCacheSave.isEmpty() && config.isAutomaticPipelineCacheEnabled()) {
1048 pipelineCacheSave = automaticPipelineCacheFileName(rhi);
1049 isAutomatic = true;
1050 }
1051
1052 if (pipelineCacheSave.isEmpty())
1053 return;
1054
1055 const QByteArray buf = rhi->pipelineCacheData();
1056
1057 // If empty, do nothing. This is exactly what will happen if the rhi was
1058 // created without QRhi::EnablePipelineCacheDataSave set.
1059 if (buf.isEmpty()) {
1060 if (isAutomatic) {
1061 // Attempt to remove the file. If it does not exist or this fails,
1062 // that's fine. The goal is just to prevent warnings from
1063 // setPipelineCacheData in future runs, e.g. if the Qt or driver
1064 // version does not match _and_ we do not generate any data at run
1065 // time, then not writing the file out also means the warning would
1066 // appear again and again on every run. Prevent that.
1067 QDir().remove(pipelineCacheSave);
1068 }
1069 return;
1070 }
1071
1072
1073#if QT_CONFIG(temporaryfile)
1074 QSaveFile f(pipelineCacheSave);
1075#else
1076 QLockFile lock(pipelineCacheLockFileName(pipelineCacheSave));
1077 if (!lock.lock()) {
1078 qWarning("Could not create pipeline cache lock file '%s'",
1079 qPrintable(lock.fileName()));
1080 return;
1081 }
1082 QFile f(pipelineCacheSave);
1083#endif
1084 if (!f.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
1085 if (!isAutomatic) {
1086 const QString msg = f.errorString();
1087 qWarning("Could not open pipeline cache output file '%s': %s",
1088 qPrintable(pipelineCacheSave), qPrintable(msg));
1089 }
1090 return;
1091 }
1092
1093 qCDebug(QSG_LOG_INFO, "Writing pipeline cache contents (%d bytes) for QRhi %p to '%s'",
1094 int(buf.size()), rhi, qPrintable(pipelineCacheSave));
1095
1096 if (f.write(buf) != buf.size()
1097#if QT_CONFIG(temporaryfile)
1098 || !f.commit()
1099#endif
1100 )
1101 {
1102 if (!isAutomatic) {
1103 const QString msg = f.errorString();
1104 qWarning("Could not write pipeline cache: %s", qPrintable(msg));
1105 }
1106 return;
1107 }
1108}
1109
1110// must be called on the render thread
1111QSGRhiSupport::RhiCreateResult QSGRhiSupport::createRhi(QQuickWindow *window, QSurface *offscreenSurface, bool forcePreferSwRenderer)
1112{
1113 QRhi *rhi = nullptr;
1114 QQuickWindowPrivate *wd = QQuickWindowPrivate::get(window);
1115 const QQuickGraphicsDevicePrivate *customDevD = QQuickGraphicsDevicePrivate::get(&wd->customDeviceObjects);
1116 if (customDevD->type == QQuickGraphicsDevicePrivate::Type::Rhi) {
1117 rhi = customDevD->u.rhi;
1118 if (rhi) {
1119 preparePipelineCache(rhi, window);
1120 return { rhi, false };
1121 }
1122 }
1123
1124 const bool debugLayer = wd->graphicsConfig.isDebugLayerEnabled();
1125 const bool debugMarkers = wd->graphicsConfig.isDebugMarkersEnabled();
1126 const bool timestamps = wd->graphicsConfig.timestampsEnabled();
1127 const bool preferSoftware = wd->graphicsConfig.prefersSoftwareDevice() || forcePreferSwRenderer;
1128 const bool pipelineCacheSave = !wd->graphicsConfig.pipelineCacheSaveFile().isEmpty()
1129 || (wd->graphicsConfig.isAutomaticPipelineCacheEnabled()
1130 && !isAutomaticPipelineCacheSaveSkippedForWindow(window->flags()));
1131
1132 const QString backendName = rhiBackendName();
1133 qCDebug(QSG_LOG_INFO,
1134 "Creating QRhi with backend %s for window %p (wflags 0x%X)\n"
1135 " Graphics API debug/validation layers: %d\n"
1136 " Debug markers: %d\n"
1137 " Timestamps: %d\n"
1138 " Prefer software device: %d%s\n"
1139 " Shader/pipeline cache collection: %d",
1140 qPrintable(backendName), window, int(window->flags()), debugLayer,
1141 debugMarkers, timestamps, preferSoftware, forcePreferSwRenderer ? " [FORCED]" : "", pipelineCacheSave);
1142
1143 QRhi::Flags flags;
1144 flags |= QRhi::SuppressSmokeTestWarnings;
1145 if (debugMarkers)
1146 flags |= QRhi::EnableDebugMarkers;
1147 if (timestamps)
1148 flags |= QRhi::EnableTimestamps;
1149 if (preferSoftware)
1150 flags |= QRhi::PreferSoftwareRenderer;
1151 if (pipelineCacheSave)
1152 flags |= QRhi::EnablePipelineCacheDataSave;
1153
1154 QRhiAdapter *rhiAdapter = customDevD->type == QQuickGraphicsDevicePrivate::Type::RhiAdapter ? customDevD->u.rhiAdapter : nullptr;
1155 const QRhi::Implementation backend = rhiBackend();
1156 if (backend == QRhi::Null) {
1157 QRhiNullInitParams rhiParams;
1158 rhi = QRhi::create(backend, &rhiParams, flags, nullptr, rhiAdapter);
1159 }
1160#if QT_CONFIG(opengl)
1161 if (backend == QRhi::OpenGLES2) {
1162 const QSurfaceFormat format = window->requestedFormat();
1163 QRhiGles2InitParams rhiParams;
1164 rhiParams.format = format;
1165 rhiParams.fallbackSurface = offscreenSurface;
1166 rhiParams.window = window;
1167 if (customDevD->type == QQuickGraphicsDevicePrivate::Type::OpenGLContext) {
1168 QRhiGles2NativeHandles importDev;
1169 importDev.context = customDevD->u.context;
1170 qCDebug(QSG_LOG_INFO, "Using existing QOpenGLContext %p", importDev.context);
1171 rhi = QRhi::create(backend, &rhiParams, flags, &importDev);
1172 } else {
1173 rhi = QRhi::create(backend, &rhiParams, flags, nullptr, rhiAdapter);
1174 }
1175 }
1176#else
1177 Q_UNUSED(offscreenSurface);
1178 if (backend == QRhi::OpenGLES2)
1179 qWarning("OpenGL was requested for Qt Quick, but this build of Qt has no OpenGL support.");
1180#endif
1181#if QT_CONFIG(vulkan)
1182 if (backend == QRhi::Vulkan) {
1183 if (debugLayer)
1184 QVulkanDefaultInstance::setFlag(QVulkanDefaultInstance::EnableValidation, true);
1185 QRhiVulkanInitParams rhiParams;
1186 prepareWindowForRhi(window); // sets a vulkanInstance if not yet present
1187 rhiParams.inst = window->vulkanInstance();
1188 if (!rhiParams.inst)
1189 qWarning("No QVulkanInstance set for QQuickWindow, this is wrong.");
1190 if (window->handle()) // only used for vkGetPhysicalDeviceSurfaceSupportKHR and that implies having a valid native window
1191 rhiParams.window = window;
1192 rhiParams.deviceExtensions = wd->graphicsConfig.deviceExtensions();
1193 if (customDevD->type == QQuickGraphicsDevicePrivate::Type::DeviceObjects) {
1194 QRhiVulkanNativeHandles importDev;
1195 importDev.physDev = reinterpret_cast<VkPhysicalDevice>(customDevD->u.deviceObjects.physicalDevice);
1196 importDev.dev = reinterpret_cast<VkDevice>(customDevD->u.deviceObjects.device);
1197 importDev.gfxQueueFamilyIdx = customDevD->u.deviceObjects.queueFamilyIndex;
1198 importDev.gfxQueueIdx = customDevD->u.deviceObjects.queueIndex;
1199 qCDebug(QSG_LOG_INFO, "Using existing native Vulkan physical device %p device %p graphics queue family index %d",
1200 importDev.physDev, importDev.dev, importDev.gfxQueueFamilyIdx);
1201 rhi = QRhi::create(backend, &rhiParams, flags, &importDev);
1202 } else if (customDevD->type == QQuickGraphicsDevicePrivate::Type::PhysicalDevice) {
1203 QRhiVulkanNativeHandles importDev;
1204 importDev.physDev = reinterpret_cast<VkPhysicalDevice>(customDevD->u.physicalDevice.physicalDevice);
1205 qCDebug(QSG_LOG_INFO, "Using existing native Vulkan physical device %p", importDev.physDev);
1206 rhi = QRhi::create(backend, &rhiParams, flags, &importDev);
1207 } else {
1208 rhi = QRhi::create(backend, &rhiParams, flags, nullptr, rhiAdapter);
1209 }
1210 }
1211#else
1212 if (backend == QRhi::Vulkan)
1213 qWarning("Vulkan was requested for Qt Quick, but this build of Qt has no Vulkan support.");
1214#endif
1215#ifdef Q_OS_WIN
1216 if (backend == QRhi::D3D11) {
1217 QRhiD3D11InitParams rhiParams;
1218 rhiParams.enableDebugLayer = debugLayer;
1219 if (customDevD->type == QQuickGraphicsDevicePrivate::Type::DeviceAndContext) {
1220 QRhiD3D11NativeHandles importDev;
1221 importDev.dev = customDevD->u.deviceAndContext.device;
1222 importDev.context = customDevD->u.deviceAndContext.context;
1223 qCDebug(QSG_LOG_INFO, "Using existing native D3D11 device %p and context %p",
1224 importDev.dev, importDev.context);
1225 rhi = QRhi::create(backend, &rhiParams, flags, &importDev);
1226 } else if (customDevD->type == QQuickGraphicsDevicePrivate::Type::Adapter) {
1227 QRhiD3D11NativeHandles importDev;
1228 importDev.adapterLuidLow = customDevD->u.adapter.luidLow;
1229 importDev.adapterLuidHigh = customDevD->u.adapter.luidHigh;
1230 importDev.featureLevel = customDevD->u.adapter.featureLevel;
1231 qCDebug(QSG_LOG_INFO, "Using D3D11 adapter LUID %u, %d and feature level %d",
1232 importDev.adapterLuidLow, importDev.adapterLuidHigh, importDev.featureLevel);
1233 rhi = QRhi::create(backend, &rhiParams, flags, &importDev);
1234 } else {
1235 rhi = QRhi::create(backend, &rhiParams, flags, nullptr, rhiAdapter);
1236 if (!rhi && attemptReinitWithSwRastUponFail() && !flags.testFlag(QRhi::PreferSoftwareRenderer) && !rhiAdapter) {
1237 qCDebug(QSG_LOG_INFO, "Failed to create a D3D device with default settings; "
1238 "attempting to get a software rasterizer backed device instead");
1239 flags |= QRhi::PreferSoftwareRenderer;
1240 rhi = QRhi::create(backend, &rhiParams, flags);
1241 }
1242 }
1243 } else if (backend == QRhi::D3D12) {
1244 QRhiD3D12InitParams rhiParams;
1245 rhiParams.enableDebugLayer = debugLayer;
1246 if (customDevD->type == QQuickGraphicsDevicePrivate::Type::DeviceAndContext) {
1247 QRhiD3D12NativeHandles importDev;
1248 importDev.dev = customDevD->u.deviceAndContext.device;
1249 qCDebug(QSG_LOG_INFO, "Using existing native D3D12 device %p", importDev.dev);
1250 rhi = QRhi::create(backend, &rhiParams, flags, &importDev);
1251 } else if (customDevD->type == QQuickGraphicsDevicePrivate::Type::Adapter) {
1252 QRhiD3D12NativeHandles importDev;
1253 importDev.adapterLuidLow = customDevD->u.adapter.luidLow;
1254 importDev.adapterLuidHigh = customDevD->u.adapter.luidHigh;
1255 importDev.minimumFeatureLevel = customDevD->u.adapter.featureLevel;
1256 qCDebug(QSG_LOG_INFO, "Using D3D12 adapter LUID %u, %d and minimum feature level %d",
1257 importDev.adapterLuidLow, importDev.adapterLuidHigh, importDev.minimumFeatureLevel);
1258 rhi = QRhi::create(backend, &rhiParams, flags, &importDev);
1259 } else {
1260 QRhiAdapter *rhiAdapter = customDevD->type == QQuickGraphicsDevicePrivate::Type::RhiAdapter ? customDevD->u.rhiAdapter : nullptr;
1261 rhi = QRhi::create(backend, &rhiParams, flags, nullptr, rhiAdapter);
1262 if (!rhi && attemptReinitWithSwRastUponFail() && !flags.testFlag(QRhi::PreferSoftwareRenderer) && !rhiAdapter) {
1263 qCDebug(QSG_LOG_INFO, "Failed to create a D3D device with default settings; "
1264 "attempting to get a software rasterizer backed device instead");
1265 flags |= QRhi::PreferSoftwareRenderer;
1266 rhi = QRhi::create(backend, &rhiParams, flags);
1267 }
1268 }
1269 }
1270#endif
1271#if QT_CONFIG(metal)
1272 if (backend == QRhi::Metal) {
1273 QRhiMetalInitParams rhiParams;
1274 if (customDevD->type == QQuickGraphicsDevicePrivate::Type::DeviceAndCommandQueue) {
1275 QRhiMetalNativeHandles importDev;
1276 importDev.dev = (MTLDevice *) customDevD->u.deviceAndCommandQueue.device;
1277 importDev.cmdQueue = (MTLCommandQueue *) customDevD->u.deviceAndCommandQueue.cmdQueue;
1278 qCDebug(QSG_LOG_INFO, "Using existing native Metal device %p and command queue %p",
1279 importDev.dev, importDev.cmdQueue);
1280 rhi = QRhi::create(backend, &rhiParams, flags, &importDev);
1281 } else {
1282 rhi = QRhi::create(backend, &rhiParams, flags, nullptr, rhiAdapter);
1283 }
1284 }
1285#endif
1286
1287 if (rhi) {
1288 qCDebug(QSG_LOG_INFO, "Created QRhi %p for window %p", rhi, window);
1289 preparePipelineCache(rhi, window);
1290 } else {
1291 qWarning("Failed to create RHI (backend %d)", backend);
1292 }
1293
1294 return { rhi, true };
1295}
1296
1297void QSGRhiSupport::destroyRhi(QRhi *rhi, const QQuickGraphicsConfiguration &config)
1298{
1299 if (!rhi)
1300 return;
1301
1302 if (!rhi->isDeviceLost())
1303 finalizePipelineCache(rhi, config);
1304
1305 delete rhi;
1306}
1307
1308QImage QSGRhiSupport::grabAndBlockInCurrentFrame(QRhi *rhi, QRhiCommandBuffer *cb, QRhiTexture *src)
1309{
1310 Q_ASSERT(rhi->isRecordingFrame());
1311
1312 QRhiReadbackResult result;
1313 QRhiReadbackDescription readbackDesc(src); // null src == read from swapchain backbuffer
1314 QRhiResourceUpdateBatch *resourceUpdates = rhi->nextResourceUpdateBatch();
1315 resourceUpdates->readBackTexture(readbackDesc, &result);
1316
1317 cb->resourceUpdate(resourceUpdates);
1318 rhi->finish(); // make sure the readback has finished, stall the pipeline if needed
1319
1320 // May be RGBA or BGRA. Plus premultiplied alpha.
1321 QImage::Format imageFormat;
1322 if (result.format == QRhiTexture::BGRA8) {
1323#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
1324 imageFormat = QImage::Format_ARGB32_Premultiplied;
1325#else
1326 imageFormat = QImage::Format_RGBA8888_Premultiplied;
1327 // ### and should swap too
1328#endif
1329 } else {
1330 imageFormat = QImage::Format_RGBA8888_Premultiplied;
1331 }
1332
1333 const uchar *p = reinterpret_cast<const uchar *>(result.data.constData());
1334 const QImage img(p, result.pixelSize.width(), result.pixelSize.height(), imageFormat);
1335
1336 if (rhi->isYUpInFramebuffer())
1337 return img.flipped();
1338
1339 return img.copy();
1340}
1341
1342QImage QSGRhiSupport::grabOffscreen(QQuickWindow *window)
1343{
1344 // Set up and then tear down the entire rendering infrastructure. This
1345 // function is called on the gui/main thread - but that's alright because
1346 // there is no onscreen rendering initialized at this point (so no render
1347 // thread for instance).
1348
1349 QQuickWindowPrivate *wd = QQuickWindowPrivate::get(window);
1350 // It is expected that window is not using QQuickRenderControl, i.e. it is
1351 // a normal QQuickWindow that just happens to be not exposed.
1352 Q_ASSERT(!wd->renderControl);
1353
1354 QScopedPointer<QOffscreenSurface> offscreenSurface(maybeCreateOffscreenSurface(window));
1355 RhiCreateResult rhiResult = createRhi(window, offscreenSurface.data());
1356 if (!rhiResult.rhi) {
1357 qWarning("Failed to initialize QRhi for offscreen readback");
1358 return QImage();
1359 }
1360 std::unique_ptr<QRhi> rhiOwner(rhiResult.rhi);
1361 QRhi *rhi = rhiResult.own ? rhiOwner.get() : rhiOwner.release();
1362
1363 const QSize pixelSize = window->size() * window->devicePixelRatio();
1364 QScopedPointer<QRhiTexture> texture(rhi->newTexture(QRhiTexture::RGBA8, pixelSize, 1,
1365 QRhiTexture::RenderTarget | QRhiTexture::UsedAsTransferSource));
1366 if (!texture->create()) {
1367 qWarning("Failed to build texture for offscreen readback");
1368 return QImage();
1369 }
1370 QScopedPointer<QRhiRenderBuffer> depthStencil(rhi->newRenderBuffer(QRhiRenderBuffer::DepthStencil, pixelSize, 1));
1371 if (!depthStencil->create()) {
1372 qWarning("Failed to create depth/stencil buffer for offscreen readback");
1373 return QImage();
1374 }
1375 QRhiTextureRenderTargetDescription rtDesc(texture.data());
1376 rtDesc.setDepthStencilBuffer(depthStencil.data());
1377 QScopedPointer<QRhiTextureRenderTarget> rt(rhi->newTextureRenderTarget(rtDesc));
1378 QScopedPointer<QRhiRenderPassDescriptor> rpDesc(rt->newCompatibleRenderPassDescriptor());
1379 rt->setRenderPassDescriptor(rpDesc.data());
1380 if (!rt->create()) {
1381 qWarning("Failed to build render target for offscreen readback");
1382 return QImage();
1383 }
1384
1385 wd->rhi = rhi;
1386
1387 QSGDefaultRenderContext::InitParams params;
1388 params.rhi = rhi;
1389 params.sampleCount = 1;
1390 params.initialSurfacePixelSize = pixelSize;
1391 params.maybeSurface = window;
1392 wd->context->initialize(&params);
1393
1394 // There was no rendercontrol which means a custom render target
1395 // should not be set either. Set our own, temporarily.
1396 auto renderTarget = QQuickRenderTarget::fromRhiRenderTarget(rt.data());
1397 // Pass on the scale factor. No need to use effectiveDevicePixelRatio(),
1398 // because there is no rendercontrol anyway.
1399 renderTarget.setDevicePixelRatio(window->devicePixelRatio());
1400 window->setRenderTarget(renderTarget);
1401
1402 QRhiCommandBuffer *cb = nullptr;
1403 if (rhi->beginOffscreenFrame(&cb) != QRhi::FrameOpSuccess) {
1404 qWarning("Failed to start recording the frame for offscreen readback");
1405 return QImage();
1406 }
1407
1408 wd->setCustomCommandBuffer(cb);
1409 wd->polishItems();
1410 wd->syncSceneGraph();
1411 wd->renderSceneGraph();
1412 wd->setCustomCommandBuffer(nullptr);
1413
1414 QImage image = grabAndBlockInCurrentFrame(rhi, cb, texture.data());
1415 rhi->endOffscreenFrame();
1416
1417 image.setDevicePixelRatio(window->devicePixelRatio());
1418 wd->cleanupNodesOnShutdown();
1419 wd->context->invalidate();
1420
1421 window->setRenderTarget(QQuickRenderTarget());
1422 wd->rhi = nullptr;
1423
1424 return image;
1425}
1426
1427#ifdef Q_OS_WEBOS
1428QImage QSGRhiSupport::grabOffscreenForProtectedContent(QQuickWindow *window)
1429{
1430 // If a context is created for protected content, grabbing GPU
1431 // resources are restricted. For the case, normal context
1432 // and surface are needed to allow CPU access.
1433 // So dummy offscreen window is used here
1434 // This function is called in rendering thread.
1435
1436 QScopedPointer<QQuickWindow> offscreenWindow;
1437 QQuickWindowPrivate *wd = QQuickWindowPrivate::get(window);
1438 // It is expected that window is not using QQuickRenderControl, i.e. it is
1439 // a normal QQuickWindow that just happens to be not exposed.
1440 Q_ASSERT(!wd->renderControl);
1441
1442 // If context and surface are created for protected content,
1443 // CPU can't read the frame resources. So normal context and surface are needed.
1444 if (window->requestedFormat().testOption(QSurfaceFormat::ProtectedContent)) {
1445 QSurfaceFormat surfaceFormat = window->requestedFormat();
1446 surfaceFormat.setOption(QSurfaceFormat::ProtectedContent, false);
1447 offscreenWindow.reset(new QQuickWindow());
1448 offscreenWindow->setFormat(surfaceFormat);
1449 }
1450
1451 QScopedPointer<QOffscreenSurface> offscreenSurface(maybeCreateOffscreenSurface(window));
1452 RhiCreateResult rhiResult = createRhi(offscreenWindow.data() ? offscreenWindow.data() : window, offscreenSurface.data());
1453 if (!rhiResult.rhi) {
1454 qWarning("Failed to initialize QRhi for offscreen readback");
1455 return QImage();
1456 }
1457 QScopedPointer<QRhi> rhiOwner(rhiResult.rhi);
1458 QRhi *rhi = rhiResult.own ? rhiOwner.data() : rhiOwner.take();
1459
1460 const QSize pixelSize = window->size() * window->devicePixelRatio();
1461 QScopedPointer<QRhiTexture> texture(rhi->newTexture(QRhiTexture::RGBA8, pixelSize, 1,
1462 QRhiTexture::RenderTarget | QRhiTexture::UsedAsTransferSource));
1463 if (!texture->create()) {
1464 qWarning("Failed to build texture for offscreen readback");
1465 return QImage();
1466 }
1467 QScopedPointer<QRhiRenderBuffer> depthStencil(rhi->newRenderBuffer(QRhiRenderBuffer::DepthStencil, pixelSize, 1));
1468 if (!depthStencil->create()) {
1469 qWarning("Failed to create depth/stencil buffer for offscreen readback");
1470 return QImage();
1471 }
1472 QRhiTextureRenderTargetDescription rtDesc(texture.data());
1473 rtDesc.setDepthStencilBuffer(depthStencil.data());
1474 QScopedPointer<QRhiTextureRenderTarget> rt(rhi->newTextureRenderTarget(rtDesc));
1475 QScopedPointer<QRhiRenderPassDescriptor> rpDesc(rt->newCompatibleRenderPassDescriptor());
1476 rt->setRenderPassDescriptor(rpDesc.data());
1477 if (!rt->create()) {
1478 qWarning("Failed to build render target for offscreen readback");
1479 return QImage();
1480 }
1481
1482 // Backup the original Rhi
1483 QRhi *currentRhi = wd->rhi;
1484 wd->rhi = rhi;
1485
1486 QSGDefaultRenderContext::InitParams params;
1487 params.rhi = rhi;
1488 params.sampleCount = 1;
1489 params.initialSurfacePixelSize = pixelSize;
1490 params.maybeSurface = window;
1491 wd->context->initialize(&params);
1492
1493 // Backup the original RenderTarget
1494 QQuickRenderTarget currentRenderTarget = window->renderTarget();
1495 // There was no rendercontrol which means a custom render target
1496 // should not be set either. Set our own, temporarily.
1497 window->setRenderTarget(QQuickRenderTarget::fromRhiRenderTarget(rt.data()));
1498
1499 QRhiCommandBuffer *cb = nullptr;
1500 if (rhi->beginOffscreenFrame(&cb) != QRhi::FrameOpSuccess) {
1501 qWarning("Failed to start recording the frame for offscreen readback");
1502 return QImage();
1503 }
1504
1505 wd->setCustomCommandBuffer(cb);
1506 wd->polishItems();
1507 wd->syncSceneGraph();
1508 wd->renderSceneGraph();
1509 wd->setCustomCommandBuffer(nullptr);
1510
1511 QImage image = grabAndBlockInCurrentFrame(rhi, cb, texture.data());
1512 rhi->endOffscreenFrame();
1513
1514 image.setDevicePixelRatio(window->devicePixelRatio());
1515
1516 // Called from gui/main thread on no onscreen rendering initialized
1517 if (!currentRhi) {
1518 wd->cleanupNodesOnShutdown();
1519 wd->context->invalidate();
1520
1521 window->setRenderTarget(QQuickRenderTarget());
1522 wd->rhi = nullptr;
1523 } else {
1524 // Called from rendering thread for protected content
1525 // Restore to original Rhi, RenderTarget and Context
1526 window->setRenderTarget(currentRenderTarget);
1527 wd->rhi = currentRhi;
1528 params.rhi = currentRhi;
1529 wd->context->initialize(&params);
1530 }
1531
1532 return image;
1533}
1534#endif
1535
1536void QSGRhiSupport::applySwapChainFormat(QRhiSwapChain *scWithWindowSet, QQuickWindow *window)
1537{
1538 Q_ASSERT(scWithWindowSet->window() == window);
1539
1540 QRhiSwapChain::Format swapChainFormat = QRhiSwapChain::SDR;
1541
1542 QByteArray hdrRequest = qgetenv("QSG_RHI_HDR");
1543 if (hdrRequest.isEmpty())
1544 hdrRequest = window->property("_qt_sg_hdr_format").toByteArray();
1545
1546 if (!hdrRequest.isEmpty()) {
1547 hdrRequest = hdrRequest.toLower();
1548 if (hdrRequest == QByteArrayLiteral("scrgb") || hdrRequest == QByteArrayLiteral("extendedsrgblinear"))
1549 swapChainFormat = QRhiSwapChain::HDRExtendedSrgbLinear;
1550 else if (hdrRequest == QByteArrayLiteral("hdr10"))
1551 swapChainFormat = QRhiSwapChain::HDR10;
1552 else if (hdrRequest == QByteArrayLiteral("p3"))
1553 swapChainFormat = QRhiSwapChain::HDRExtendedDisplayP3Linear;
1554 }
1555
1556 const char *fmtStr = "unknown";
1557 switch (swapChainFormat) {
1558 case QRhiSwapChain::SDR:
1559 fmtStr = "SDR";
1560 break;
1561 case QRhiSwapChain::HDRExtendedSrgbLinear:
1562 fmtStr = "scRGB";
1563 break;
1564 case QRhiSwapChain::HDR10:
1565 fmtStr = "HDR10";
1566 break;
1567 case QRhiSwapChain::HDRExtendedDisplayP3Linear:
1568 fmtStr = "Extended Linear Display P3";
1569 break;
1570 default:
1571 break;
1572 }
1573
1574 if (!scWithWindowSet->isFormatSupported(swapChainFormat)) {
1575 if (swapChainFormat != QRhiSwapChain::SDR) {
1576 qCDebug(QSG_LOG_INFO, "Requested a %s swapchain but it is reported to be unsupported with the current display(s). "
1577 "In multi-screen configurations make sure the window is located on a HDR-enabled screen. "
1578 "Request ignored, using SDR swapchain.", fmtStr);
1579 }
1580 return;
1581 }
1582
1583 scWithWindowSet->setFormat(swapChainFormat);
1584
1585 if (swapChainFormat != QRhiSwapChain::SDR) {
1586 qCDebug(QSG_LOG_INFO, "Creating %s swapchain", fmtStr);
1587 qCDebug(QSG_LOG_INFO) << "HDR output info:" << scWithWindowSet->hdrInfo();
1588 }
1589}
1590
1591QRhiTexture::Format QSGRhiSupport::toRhiTextureFormat(uint nativeFormat, QRhiTexture::Flags *flags) const
1592{
1593 switch (m_rhiBackend) {
1594#if QT_CONFIG(vulkan)
1595 case QRhi::Vulkan:
1596 return toRhiTextureFormatFromVulkan(nativeFormat, flags);
1597#endif
1598#if QT_CONFIG(opengl)
1599 case QRhi::OpenGLES2:
1600 Q_UNUSED(flags);
1601 return toRhiTextureFormatFromGL(nativeFormat, flags);
1602#endif
1603#ifdef Q_OS_WIN
1604 case QRhi::D3D11:
1605 case QRhi::D3D12:
1606 return toRhiTextureFormatFromDXGI(nativeFormat, flags);
1607#endif
1608#if QT_CONFIG(metal)
1609 case QRhi::Metal:
1610 return toRhiTextureFormatFromMetal(nativeFormat, flags);
1611#endif
1612 default:
1613 return QRhiTexture::UnknownFormat;
1614 }
1615 Q_UNUSED(nativeFormat)
1616 Q_UNUSED(flags)
1617}
1618
1619bool QSGRhiSupport::attemptReinitWithSwRastUponFail() const
1620{
1621 const QRhi::Implementation backend = rhiBackend();
1622
1623 // On Windows it makes sense to retry using a software adapter whenever
1624 // device creation or swapchain creation fails, as WARP is usually available
1625 // (built in to the OS) and is good quality. This helps a lot in particular
1626 // when running in a VM that cripples proper 3D graphics.
1627 if (backend == QRhi::D3D11 || backend == QRhi::D3D12)
1628 return true;
1629
1630 return false;
1631}
1632
1633QT_END_NAMESPACE
isAutomaticPipelineCacheLoadSkippedForWindow
static bool isAutomaticPipelineCacheLoadSkippedForWindow(Qt::WindowFlags wflags)
Definition qsgrhisupport.cpp:977
automaticPipelineCacheDir
static QString automaticPipelineCacheDir()
Definition qsgrhisupport.cpp:941
ensureWritableDir
static bool ensureWritableDir(const QString &name)
Definition qsgrhisupport.cpp:935
automaticPipelineCacheFileName
static QString automaticPipelineCacheFileName(QRhi *rhi)
Definition qsgrhisupport.cpp:968
isAutomaticPipelineCacheSaveSkippedForWindow
static bool isAutomaticPipelineCacheSaveSkippedForWindow(Qt::WindowFlags wflags)
Definition qsgrhisupport.cpp:982