1	// Copyright (C) 2023 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	#ifndef QRHI_H
5	#define QRHI_H
6
7	//
8	// W A R N I N G
9	// -------------
10	//
11	// This file is part of the RHI API, with limited compatibility guarantees.
12	// Usage of this API may make your code source and binary incompatible with
13	// future versions of Qt.
14	//
15
16	#include <QtGui/qtguiglobal.h>
17	#include <QtCore/qsize.h>
18	#include <QtCore/qlist.h>
19	#include <QtCore/qvarlengtharray.h>
20	#include <QtCore/qthread.h>
21	#include <QtGui/qmatrix4x4.h>
22	#include <QtGui/qcolor.h>
23	#include <QtGui/qimage.h>
24	#include <functional>
25	#include <array>
26
27	#include <rhi/qshader.h>
28
29	QT_BEGIN_NAMESPACE
30
31	class QWindow;
32	class QRhi;
33	class QRhiImplementation;
34	class QRhiBuffer;
35	class QRhiRenderBuffer;
36	class QRhiTexture;
37	class QRhiSampler;
38	class QRhiCommandBuffer;
39	class QRhiResourceUpdateBatch;
40	class QRhiResourceUpdateBatchPrivate;
41	class QRhiSwapChain;
42
43	class Q_GUI_EXPORT QRhiDepthStencilClearValue
44	{
45	public:
46	QRhiDepthStencilClearValue() = default;
47	QRhiDepthStencilClearValue(float d, quint32 s);
48
49	float depthClearValue() const { return m_d; }
50	void setDepthClearValue(float d) { m_d = d; }
51
52	quint32 stencilClearValue() const { return m_s; }
53	void setStencilClearValue(quint32 s) { m_s = s; }
54
55	private:
56	float m_d = 1.0f;
57	quint32 m_s = 0;
58
59	friend bool operator==(const QRhiDepthStencilClearValue &a, const QRhiDepthStencilClearValue &b) noexcept
60	{
61	return a.m_d == b.m_d && a.m_s == b.m_s;
62	}
63
64	friend bool operator!=(const QRhiDepthStencilClearValue &a, const QRhiDepthStencilClearValue &b) noexcept
65	{
66	return !(a == b);
67	}
68
69	friend size_t qHash(const QRhiDepthStencilClearValue &v, size_t seed = 0) noexcept
70	{
71	QtPrivate::QHashCombine hash;
72	seed = hash(seed, v.m_d);
73	seed = hash(seed, v.m_s);
74	return seed;
75	}
76	};
77
78	Q_DECLARE_TYPEINFO(QRhiDepthStencilClearValue, Q_RELOCATABLE_TYPE);
79
80	#ifndef QT_NO_DEBUG_STREAM
81	Q_GUI_EXPORT QDebug operator<<(QDebug, const QRhiDepthStencilClearValue &);
82	#endif
83
84	class Q_GUI_EXPORT QRhiViewport
85	{
86	public:
87	QRhiViewport() = default;
88	QRhiViewport(float x, float y, float w, float h, float minDepth = 0.0f, float maxDepth = 1.0f);
89
90	std::array<float, 4> viewport() const { return m_rect; }
91	void setViewport(float x, float y, float w, float h) {
92	m_rect[0] = x; m_rect[1] = y; m_rect[2] = w; m_rect[3] = h;
93	}
94
95	float minDepth() const { return m_minDepth; }
96	void setMinDepth(float minDepth) { m_minDepth = minDepth; }
97
98	float maxDepth() const { return m_maxDepth; }
99	void setMaxDepth(float maxDepth) { m_maxDepth = maxDepth; }
100
101	private:
102	std::array<float, 4> m_rect { ._M_elems: { 0.0f, 0.0f, 0.0f, 0.0f } };
103	float m_minDepth = 0.0f;
104	float m_maxDepth = 1.0f;
105
106	friend bool operator==(const QRhiViewport &a, const QRhiViewport &b) noexcept
107	{
108	return a.m_rect == b.m_rect
109	&& a.m_minDepth == b.m_minDepth
110	&& a.m_maxDepth == b.m_maxDepth;
111	}
112
113	friend bool operator!=(const QRhiViewport &a, const QRhiViewport &b) noexcept
114	{
115	return !(a == b);
116	}
117
118	friend size_t qHash(const QRhiViewport &v, size_t seed = 0) noexcept
119	{
120	QtPrivate::QHashCombine hash;
121	seed = hash(seed, v.m_rect[0]);
122	seed = hash(seed, v.m_rect[1]);
123	seed = hash(seed, v.m_rect[2]);
124	seed = hash(seed, v.m_rect[3]);
125	seed = hash(seed, v.m_minDepth);
126	seed = hash(seed, v.m_maxDepth);
127	return seed;
128	}
129	};
130
131	Q_DECLARE_TYPEINFO(QRhiViewport, Q_RELOCATABLE_TYPE);
132
133	#ifndef QT_NO_DEBUG_STREAM
134	Q_GUI_EXPORT QDebug operator<<(QDebug, const QRhiViewport &);
135	#endif
136
137	class Q_GUI_EXPORT QRhiScissor
138	{
139	public:
140	QRhiScissor() = default;
141	QRhiScissor(int x, int y, int w, int h);
142
143	std::array<int, 4> scissor() const { return m_rect; }
144	void setScissor(int x, int y, int w, int h) {
145	m_rect[0] = x; m_rect[1] = y; m_rect[2] = w; m_rect[3] = h;
146	}
147
148	private:
149	std::array<int, 4> m_rect { ._M_elems: { 0, 0, 0, 0 } };
150
151	friend bool operator==(const QRhiScissor &a, const QRhiScissor &b) noexcept
152	{
153	return a.m_rect == b.m_rect;
154	}
155
156	friend bool operator!=(const QRhiScissor &a, const QRhiScissor &b) noexcept
157	{
158	return !(a == b);
159	}
160
161	friend size_t qHash(const QRhiScissor &v, size_t seed = 0) noexcept
162	{
163	QtPrivate::QHashCombine hash;
164	seed = hash(seed, v.m_rect[0]);
165	seed = hash(seed, v.m_rect[1]);
166	seed = hash(seed, v.m_rect[2]);
167	seed = hash(seed, v.m_rect[3]);
168	return seed;
169	}
170	};
171
172	Q_DECLARE_TYPEINFO(QRhiScissor, Q_RELOCATABLE_TYPE);
173
174	#ifndef QT_NO_DEBUG_STREAM
175	Q_GUI_EXPORT QDebug operator<<(QDebug, const QRhiScissor &);
176	#endif
177
178	class Q_GUI_EXPORT QRhiVertexInputBinding
179	{
180	public:
181	enum Classification {
182	PerVertex,
183	PerInstance
184	};
185
186	QRhiVertexInputBinding() = default;
187	QRhiVertexInputBinding(quint32 stride, Classification cls = PerVertex, quint32 stepRate = 1);
188
189	quint32 stride() const { return m_stride; }
190	void setStride(quint32 s) { m_stride = s; }
191
192	Classification classification() const { return m_classification; }
193	void setClassification(Classification c) { m_classification = c; }
194
195	quint32 instanceStepRate() const { return m_instanceStepRate; }
196	void setInstanceStepRate(quint32 rate) { m_instanceStepRate = rate; }
197
198	private:
199	quint32 m_stride = 0;
200	Classification m_classification = PerVertex;
201	quint32 m_instanceStepRate = 1;
202
203	friend bool operator==(const QRhiVertexInputBinding &a, const QRhiVertexInputBinding &b) noexcept
204	{
205	return a.m_stride == b.m_stride
206	&& a.m_classification == b.m_classification
207	&& a.m_instanceStepRate == b.m_instanceStepRate;
208	}
209
210	friend bool operator!=(const QRhiVertexInputBinding &a, const QRhiVertexInputBinding &b) noexcept
211	{
212	return !(a == b);
213	}
214
215	friend size_t qHash(const QRhiVertexInputBinding &v, size_t seed = 0) noexcept
216	{
217	QtPrivate::QHashCombine hash;
218	seed = hash(seed, v.m_stride);
219	seed = hash(seed, v.m_classification);
220	seed = hash(seed, v.m_instanceStepRate);
221	return seed;
222	}
223	};
224
225	Q_DECLARE_TYPEINFO(QRhiVertexInputBinding, Q_RELOCATABLE_TYPE);
226
227	#ifndef QT_NO_DEBUG_STREAM
228	Q_GUI_EXPORT QDebug operator<<(QDebug, const QRhiVertexInputBinding &);
229	#endif
230
231	class Q_GUI_EXPORT QRhiVertexInputAttribute
232	{
233	public:
234	enum Format {
235	Float4,
236	Float3,
237	Float2,
238	Float,
239	UNormByte4,
240	UNormByte2,
241	UNormByte,
242	UInt4,
243	UInt3,
244	UInt2,
245	UInt,
246	SInt4,
247	SInt3,
248	SInt2,
249	SInt,
250	Half4,
251	Half3,
252	Half2,
253	Half,
254	UShort4,
255	UShort3,
256	UShort2,
257	UShort,
258	SShort4,
259	SShort3,
260	SShort2,
261	SShort,
262	};
263
264	QRhiVertexInputAttribute() = default;
265	QRhiVertexInputAttribute(int binding, int location, Format format, quint32 offset, int matrixSlice = -1);
266
267	int binding() const { return m_binding; }
268	void setBinding(int b) { m_binding = b; }
269
270	int location() const { return m_location; }
271	void setLocation(int loc) { m_location = loc; }
272
273	Format format() const { return m_format; }
274	void setFormat(Format f) { m_format = f; }
275
276	quint32 offset() const { return m_offset; }
277	void setOffset(quint32 ofs) { m_offset = ofs; }
278
279	int matrixSlice() const { return m_matrixSlice; }
280	void setMatrixSlice(int slice) { m_matrixSlice = slice; }
281
282	private:
283	int m_binding = 0;
284	int m_location = 0;
285	Format m_format = Float4;
286	quint32 m_offset = 0;
287	int m_matrixSlice = -1;
288
289	friend bool operator==(const QRhiVertexInputAttribute &a, const QRhiVertexInputAttribute &b) noexcept
290	{
291	return a.m_binding == b.m_binding
292	&& a.m_location == b.m_location
293	&& a.m_format == b.m_format
294	&& a.m_offset == b.m_offset;
295	// matrixSlice excluded intentionally
296	}
297
298	friend bool operator!=(const QRhiVertexInputAttribute &a, const QRhiVertexInputAttribute &b) noexcept
299	{
300	return !(a == b);
301	}
302
303	friend size_t qHash(const QRhiVertexInputAttribute &v, size_t seed = 0) noexcept
304	{
305	QtPrivate::QHashCombine hash;
306	seed = hash(seed, v.m_binding);
307	seed = hash(seed, v.m_location);
308	seed = hash(seed, v.m_format);
309	seed = hash(seed, v.m_offset);
310	return seed;
311	}
312	};
313
314	Q_DECLARE_TYPEINFO(QRhiVertexInputAttribute, Q_RELOCATABLE_TYPE);
315
316	#ifndef QT_NO_DEBUG_STREAM
317	Q_GUI_EXPORT QDebug operator<<(QDebug, const QRhiVertexInputAttribute &);
318	#endif
319
320	class Q_GUI_EXPORT QRhiVertexInputLayout
321	{
322	public:
323	QRhiVertexInputLayout() = default;
324
325	void setBindings(std::initializer_list<QRhiVertexInputBinding> list) { m_bindings = list; }
326	template<typename InputIterator>
327	void setBindings(InputIterator first, InputIterator last)
328	{
329	m_bindings.clear();
330	std::copy(first, last, std::back_inserter(x&: m_bindings));
331	}
332	const QRhiVertexInputBinding *cbeginBindings() const { return m_bindings.cbegin(); }
333	const QRhiVertexInputBinding *cendBindings() const { return m_bindings.cend(); }
334	const QRhiVertexInputBinding *bindingAt(qsizetype index) const { return &m_bindings.at(idx: index); }
335	qsizetype bindingCount() const { return m_bindings.count(); }
336
337	void setAttributes(std::initializer_list<QRhiVertexInputAttribute> list) { m_attributes = list; }
338	template<typename InputIterator>
339	void setAttributes(InputIterator first, InputIterator last)
340	{
341	m_attributes.clear();
342	std::copy(first, last, std::back_inserter(x&: m_attributes));
343	}
344	const QRhiVertexInputAttribute *cbeginAttributes() const { return m_attributes.cbegin(); }
345	const QRhiVertexInputAttribute *cendAttributes() const { return m_attributes.cend(); }
346	const QRhiVertexInputAttribute *attributeAt(qsizetype index) const { return &m_attributes.at(idx: index); }
347	qsizetype attributeCount() const { return m_attributes.count(); }
348
349	private:
350	QVarLengthArray<QRhiVertexInputBinding, 8> m_bindings;
351	QVarLengthArray<QRhiVertexInputAttribute, 8> m_attributes;
352
353	friend bool operator==(const QRhiVertexInputLayout &a, const QRhiVertexInputLayout &b) noexcept
354	{
355	return a.m_bindings == b.m_bindings && a.m_attributes == b.m_attributes;
356	}
357
358	friend bool operator!=(const QRhiVertexInputLayout &a, const QRhiVertexInputLayout &b) noexcept
359	{
360	return !(a == b);
361	}
362
363	friend size_t qHash(const QRhiVertexInputLayout &v, size_t seed = 0) noexcept
364	{
365	QtPrivate::QHashCombine hash;
366	seed = hash(seed, v.m_bindings);
367	seed = hash(seed, v.m_attributes);
368	return seed;
369	}
370
371	friend Q_GUI_EXPORT QDebug operator<<(QDebug, const QRhiVertexInputLayout &);
372	};
373
374	#ifndef QT_NO_DEBUG_STREAM
375	Q_GUI_EXPORT QDebug operator<<(QDebug, const QRhiVertexInputLayout &);
376	#endif
377
378	class Q_GUI_EXPORT QRhiShaderStage
379	{
380	public:
381	enum Type {
382	Vertex,
383	TessellationControl,
384	TessellationEvaluation,
385	Geometry,
386	Fragment,
387	Compute
388	};
389
390	QRhiShaderStage() = default;
391	QRhiShaderStage(Type type, const QShader &shader,
392	QShader::Variant v = QShader::StandardShader);
393
394	Type type() const { return m_type; }
395	void setType(Type t) { m_type = t; }
396
397	QShader shader() const { return m_shader; }
398	void setShader(const QShader &s) { m_shader = s; }
399
400	QShader::Variant shaderVariant() const { return m_shaderVariant; }
401	void setShaderVariant(QShader::Variant v) { m_shaderVariant = v; }
402
403	private:
404	Type m_type = Vertex;
405	QShader m_shader;
406	QShader::Variant m_shaderVariant = QShader::StandardShader;
407
408	friend bool operator==(const QRhiShaderStage &a, const QRhiShaderStage &b) noexcept
409	{
410	return a.m_type == b.m_type
411	&& a.m_shader == b.m_shader
412	&& a.m_shaderVariant == b.m_shaderVariant;
413	}
414
415	friend bool operator!=(const QRhiShaderStage &a, const QRhiShaderStage &b) noexcept
416	{
417	return !(a == b);
418	}
419
420	friend size_t qHash(const QRhiShaderStage &v, size_t seed = 0) noexcept
421	{
422	QtPrivate::QHashCombine hash;
423	seed = hash(seed, v.m_type);
424	seed = hash(seed, v.m_shader);
425	seed = hash(seed, v.m_shaderVariant);
426	return seed;
427	}
428	};
429
430	Q_DECLARE_TYPEINFO(QRhiShaderStage, Q_RELOCATABLE_TYPE);
431
432	#ifndef QT_NO_DEBUG_STREAM
433	Q_GUI_EXPORT QDebug operator<<(QDebug, const QRhiShaderStage &);
434	#endif
435
436	using QRhiGraphicsShaderStage = QRhiShaderStage;
437
438	class Q_GUI_EXPORT QRhiShaderResourceBinding
439	{
440	public:
441	enum Type {
442	UniformBuffer,
443	SampledTexture,
444	Texture,
445	Sampler,
446	ImageLoad,
447	ImageStore,
448	ImageLoadStore,
449	BufferLoad,
450	BufferStore,
451	BufferLoadStore
452	};
453
454	enum StageFlag {
455	VertexStage = 1 << 0,
456	TessellationControlStage = 1 << 1,
457	TessellationEvaluationStage = 1 << 2,
458	GeometryStage = 1 << 3,
459	FragmentStage = 1 << 4,
460	ComputeStage = 1 << 5
461	};
462	Q_DECLARE_FLAGS(StageFlags, StageFlag)
463
464	QRhiShaderResourceBinding() = default;
465
466	bool isLayoutCompatible(const QRhiShaderResourceBinding &other) const;
467
468	static QRhiShaderResourceBinding uniformBuffer(int binding, StageFlags stage, QRhiBuffer *buf);
469	static QRhiShaderResourceBinding uniformBuffer(int binding, StageFlags stage, QRhiBuffer *buf, quint32 offset, quint32 size);
470	static QRhiShaderResourceBinding uniformBufferWithDynamicOffset(int binding, StageFlags stage, QRhiBuffer *buf, quint32 size);
471
472	static QRhiShaderResourceBinding sampledTexture(int binding, StageFlags stage, QRhiTexture *tex, QRhiSampler *sampler);
473
474	struct TextureAndSampler {
475	QRhiTexture *tex;
476	QRhiSampler *sampler;
477	};
478	static QRhiShaderResourceBinding sampledTextures(int binding, StageFlags stage, int count, const TextureAndSampler *texSamplers);
479
480	static QRhiShaderResourceBinding texture(int binding, StageFlags stage, QRhiTexture *tex);
481	static QRhiShaderResourceBinding textures(int binding, StageFlags stage, int count, QRhiTexture **tex);
482	static QRhiShaderResourceBinding sampler(int binding, StageFlags stage, QRhiSampler *sampler);
483
484	static QRhiShaderResourceBinding imageLoad(int binding, StageFlags stage, QRhiTexture *tex, int level);
485	static QRhiShaderResourceBinding imageStore(int binding, StageFlags stage, QRhiTexture *tex, int level);
486	static QRhiShaderResourceBinding imageLoadStore(int binding, StageFlags stage, QRhiTexture *tex, int level);
487
488	static QRhiShaderResourceBinding bufferLoad(int binding, StageFlags stage, QRhiBuffer *buf);
489	static QRhiShaderResourceBinding bufferLoad(int binding, StageFlags stage, QRhiBuffer *buf, quint32 offset, quint32 size);
490	static QRhiShaderResourceBinding bufferStore(int binding, StageFlags stage, QRhiBuffer *buf);
491	static QRhiShaderResourceBinding bufferStore(int binding, StageFlags stage, QRhiBuffer *buf, quint32 offset, quint32 size);
492	static QRhiShaderResourceBinding bufferLoadStore(int binding, StageFlags stage, QRhiBuffer *buf);
493	static QRhiShaderResourceBinding bufferLoadStore(int binding, StageFlags stage, QRhiBuffer *buf, quint32 offset, quint32 size);
494
495	struct Data
496	{
497	int binding;
498	QRhiShaderResourceBinding::StageFlags stage;
499	QRhiShaderResourceBinding::Type type;
500	struct UniformBufferData {
501	QRhiBuffer *buf;
502	quint32 offset;
503	quint32 maybeSize;
504	bool hasDynamicOffset;
505	};
506	static constexpr int MAX_TEX_SAMPLER_ARRAY_SIZE = 16;
507	struct TextureAndOrSamplerData {
508	int count;
509	TextureAndSampler texSamplers[MAX_TEX_SAMPLER_ARRAY_SIZE];
510	};
511	struct StorageImageData {
512	QRhiTexture *tex;
513	int level;
514	};
515	struct StorageBufferData {
516	QRhiBuffer *buf;
517	quint32 offset;
518	quint32 maybeSize;
519	};
520	union {
521	UniformBufferData ubuf;
522	TextureAndOrSamplerData stex;
523	StorageImageData simage;
524	StorageBufferData sbuf;
525	} u;
526
527	int arraySize() const
528	{
529	return type == QRhiShaderResourceBinding::SampledTexture || type == QRhiShaderResourceBinding::Texture
530	? u.stex.count
531	: 1;
532	}
533
534	template<typename Output>
535	Output serialize(Output dst) const
536	{
537	// must write out exactly LAYOUT_DESC_ENTRIES_PER_BINDING elements here
538	*dst++ = quint32(binding);
539	*dst++ = quint32(stage);
540	*dst++ = quint32(type);
541	*dst++ = quint32(arraySize());
542	return dst;
543	}
544	};
545
546	static constexpr int LAYOUT_DESC_ENTRIES_PER_BINDING = 4;
547
548	template<typename Output>
549	static void serializeLayoutDescription(const QRhiShaderResourceBinding *first,
550	const QRhiShaderResourceBinding *last,
551	Output dst)
552	{
553	while (first != last) {
554	dst = first->d.serialize(dst);
555	++first;
556	}
557	}
558
559	private:
560	Data d;
561	friend class QRhiImplementation;
562	};
563
564	Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiShaderResourceBinding::StageFlags)
565
566	Q_DECLARE_TYPEINFO(QRhiShaderResourceBinding, Q_PRIMITIVE_TYPE);
567
568	Q_GUI_EXPORT bool operator==(const QRhiShaderResourceBinding &a, const QRhiShaderResourceBinding &b) noexcept;
569	Q_GUI_EXPORT bool operator!=(const QRhiShaderResourceBinding &a, const QRhiShaderResourceBinding &b) noexcept;
570	Q_GUI_EXPORT size_t qHash(const QRhiShaderResourceBinding &b, size_t seed = 0) noexcept;
571	#ifndef QT_NO_DEBUG_STREAM
572	Q_GUI_EXPORT QDebug operator<<(QDebug, const QRhiShaderResourceBinding &);
573	#endif
574
575	class Q_GUI_EXPORT QRhiColorAttachment
576	{
577	public:
578	QRhiColorAttachment() = default;
579	QRhiColorAttachment(QRhiTexture *texture);
580	QRhiColorAttachment(QRhiRenderBuffer *renderBuffer);
581
582	QRhiTexture *texture() const { return m_texture; }
583	void setTexture(QRhiTexture *tex) { m_texture = tex; }
584
585	QRhiRenderBuffer *renderBuffer() const { return m_renderBuffer; }
586	void setRenderBuffer(QRhiRenderBuffer *rb) { m_renderBuffer = rb; }
587
588	int layer() const { return m_layer; }
589	void setLayer(int layer) { m_layer = layer; }
590
591	int level() const { return m_level; }
592	void setLevel(int level) { m_level = level; }
593
594	QRhiTexture *resolveTexture() const { return m_resolveTexture; }
595	void setResolveTexture(QRhiTexture *tex) { m_resolveTexture = tex; }
596
597	int resolveLayer() const { return m_resolveLayer; }
598	void setResolveLayer(int layer) { m_resolveLayer = layer; }
599
600	int resolveLevel() const { return m_resolveLevel; }
601	void setResolveLevel(int level) { m_resolveLevel = level; }
602
603	int multiViewCount() const { return m_multiViewCount; }
604	void setMultiViewCount(int count) { m_multiViewCount = count; }
605
606	private:
607	QRhiTexture *m_texture = nullptr;
608	QRhiRenderBuffer *m_renderBuffer = nullptr;
609	int m_layer = 0;
610	int m_level = 0;
611	QRhiTexture *m_resolveTexture = nullptr;
612	int m_resolveLayer = 0;
613	int m_resolveLevel = 0;
614	int m_multiViewCount = 0;
615	};
616
617	Q_DECLARE_TYPEINFO(QRhiColorAttachment, Q_RELOCATABLE_TYPE);
618
619	class Q_GUI_EXPORT QRhiTextureRenderTargetDescription
620	{
621	public:
622	QRhiTextureRenderTargetDescription() = default;
623	QRhiTextureRenderTargetDescription(const QRhiColorAttachment &colorAttachment);
624	QRhiTextureRenderTargetDescription(const QRhiColorAttachment &colorAttachment, QRhiRenderBuffer *depthStencilBuffer);
625	QRhiTextureRenderTargetDescription(const QRhiColorAttachment &colorAttachment, QRhiTexture *depthTexture);
626
627	void setColorAttachments(std::initializer_list<QRhiColorAttachment> list) { m_colorAttachments = list; }
628	template<typename InputIterator>
629	void setColorAttachments(InputIterator first, InputIterator last)
630	{
631	m_colorAttachments.clear();
632	std::copy(first, last, std::back_inserter(x&: m_colorAttachments));
633	}
634	const QRhiColorAttachment *cbeginColorAttachments() const { return m_colorAttachments.cbegin(); }
635	const QRhiColorAttachment *cendColorAttachments() const { return m_colorAttachments.cend(); }
636	const QRhiColorAttachment *colorAttachmentAt(qsizetype index) const { return &m_colorAttachments.at(idx: index); }
637	qsizetype colorAttachmentCount() const { return m_colorAttachments.count(); }
638
639	QRhiRenderBuffer *depthStencilBuffer() const { return m_depthStencilBuffer; }
640	void setDepthStencilBuffer(QRhiRenderBuffer *renderBuffer) { m_depthStencilBuffer = renderBuffer; }
641
642	QRhiTexture *depthTexture() const { return m_depthTexture; }
643	void setDepthTexture(QRhiTexture *texture) { m_depthTexture = texture; }
644
645	QRhiTexture *depthResolveTexture() const { return m_depthResolveTexture; }
646	void setDepthResolveTexture(QRhiTexture *tex) { m_depthResolveTexture = tex; }
647
648	private:
649	QVarLengthArray<QRhiColorAttachment, 8> m_colorAttachments;
650	QRhiRenderBuffer *m_depthStencilBuffer = nullptr;
651	QRhiTexture *m_depthTexture = nullptr;
652	QRhiTexture *m_depthResolveTexture = nullptr;
653	};
654
655	class Q_GUI_EXPORT QRhiTextureSubresourceUploadDescription
656	{
657	public:
658	QRhiTextureSubresourceUploadDescription() = default;
659	explicit QRhiTextureSubresourceUploadDescription(const QImage &image);
660	QRhiTextureSubresourceUploadDescription(const void *data, quint32 size);
661	explicit QRhiTextureSubresourceUploadDescription(const QByteArray &data);
662
663	QImage image() const { return m_image; }
664	void setImage(const QImage &image) { m_image = image; }
665
666	QByteArray data() const { return m_data; }
667	void setData(const QByteArray &data) { m_data = data; }
668
669	quint32 dataStride() const { return m_dataStride; }
670	void setDataStride(quint32 stride) { m_dataStride = stride; }
671
672	QPoint destinationTopLeft() const { return m_destinationTopLeft; }
673	void setDestinationTopLeft(const QPoint &p) { m_destinationTopLeft = p; }
674
675	QSize sourceSize() const { return m_sourceSize; }
676	void setSourceSize(const QSize &size) { m_sourceSize = size; }
677
678	QPoint sourceTopLeft() const { return m_sourceTopLeft; }
679	void setSourceTopLeft(const QPoint &p) { m_sourceTopLeft = p; }
680
681	private:
682	QImage m_image;
683	QByteArray m_data;
684	quint32 m_dataStride = 0;
685	QPoint m_destinationTopLeft;
686	QSize m_sourceSize;
687	QPoint m_sourceTopLeft;
688	};
689
690	Q_DECLARE_TYPEINFO(QRhiTextureSubresourceUploadDescription, Q_RELOCATABLE_TYPE);
691
692	class Q_GUI_EXPORT QRhiTextureUploadEntry
693	{
694	public:
695	QRhiTextureUploadEntry() = default;
696	QRhiTextureUploadEntry(int layer, int level, const QRhiTextureSubresourceUploadDescription &desc);
697
698	int layer() const { return m_layer; }
699	void setLayer(int layer) { m_layer = layer; }
700
701	int level() const { return m_level; }
702	void setLevel(int level) { m_level = level; }
703
704	QRhiTextureSubresourceUploadDescription description() const { return m_desc; }
705	void setDescription(const QRhiTextureSubresourceUploadDescription &desc) { m_desc = desc; }
706
707	private:
708	int m_layer = 0;
709	int m_level = 0;
710	QRhiTextureSubresourceUploadDescription m_desc;
711	};
712
713	Q_DECLARE_TYPEINFO(QRhiTextureUploadEntry, Q_RELOCATABLE_TYPE);
714
715	class Q_GUI_EXPORT QRhiTextureUploadDescription
716	{
717	public:
718	QRhiTextureUploadDescription() = default;
719	QRhiTextureUploadDescription(const QRhiTextureUploadEntry &entry);
720	QRhiTextureUploadDescription(std::initializer_list<QRhiTextureUploadEntry> list);
721
722	void setEntries(std::initializer_list<QRhiTextureUploadEntry> list) { m_entries = list; }
723	template<typename InputIterator>
724	void setEntries(InputIterator first, InputIterator last)
725	{
726	m_entries.clear();
727	std::copy(first, last, std::back_inserter(x&: m_entries));
728	}
729	const QRhiTextureUploadEntry *cbeginEntries() const { return m_entries.cbegin(); }
730	const QRhiTextureUploadEntry *cendEntries() const { return m_entries.cend(); }
731	const QRhiTextureUploadEntry *entryAt(qsizetype index) const { return &m_entries.at(idx: index); }
732	qsizetype entryCount() const { return m_entries.count(); }
733
734	private:
735	QVarLengthArray<QRhiTextureUploadEntry, 16> m_entries;
736	};
737
738	class Q_GUI_EXPORT QRhiTextureCopyDescription
739	{
740	public:
741	QRhiTextureCopyDescription() = default;
742
743	QSize pixelSize() const { return m_pixelSize; }
744	void setPixelSize(const QSize &sz) { m_pixelSize = sz; }
745
746	int sourceLayer() const { return m_sourceLayer; }
747	void setSourceLayer(int layer) { m_sourceLayer = layer; }
748
749	int sourceLevel() const { return m_sourceLevel; }
750	void setSourceLevel(int level) { m_sourceLevel = level; }
751
752	QPoint sourceTopLeft() const { return m_sourceTopLeft; }
753	void setSourceTopLeft(const QPoint &p) { m_sourceTopLeft = p; }
754
755	int destinationLayer() const { return m_destinationLayer; }
756	void setDestinationLayer(int layer) { m_destinationLayer = layer; }
757
758	int destinationLevel() const { return m_destinationLevel; }
759	void setDestinationLevel(int level) { m_destinationLevel = level; }
760
761	QPoint destinationTopLeft() const { return m_destinationTopLeft; }
762	void setDestinationTopLeft(const QPoint &p) { m_destinationTopLeft = p; }
763
764	private:
765	QSize m_pixelSize;
766	int m_sourceLayer = 0;
767	int m_sourceLevel = 0;
768	QPoint m_sourceTopLeft;
769	int m_destinationLayer = 0;
770	int m_destinationLevel = 0;
771	QPoint m_destinationTopLeft;
772	};
773
774	Q_DECLARE_TYPEINFO(QRhiTextureCopyDescription, Q_RELOCATABLE_TYPE);
775
776	class Q_GUI_EXPORT QRhiReadbackDescription
777	{
778	public:
779	QRhiReadbackDescription() = default;
780	QRhiReadbackDescription(QRhiTexture *texture);
781
782	QRhiTexture *texture() const { return m_texture; }
783	void setTexture(QRhiTexture *tex) { m_texture = tex; }
784
785	int layer() const { return m_layer; }
786	void setLayer(int layer) { m_layer = layer; }
787
788	int level() const { return m_level; }
789	void setLevel(int level) { m_level = level; }
790
791	private:
792	QRhiTexture *m_texture = nullptr;
793	int m_layer = 0;
794	int m_level = 0;
795	};
796
797	Q_DECLARE_TYPEINFO(QRhiReadbackDescription, Q_RELOCATABLE_TYPE);
798
799	struct Q_GUI_EXPORT QRhiNativeHandles
800	{
801	};
802
803	class Q_GUI_EXPORT QRhiResource
804	{
805	public:
806	enum Type {
807	Buffer,
808	Texture,
809	Sampler,
810	RenderBuffer,
811	RenderPassDescriptor,
812	SwapChainRenderTarget,
813	TextureRenderTarget,
814	ShaderResourceBindings,
815	GraphicsPipeline,
816	SwapChain,
817	ComputePipeline,
818	CommandBuffer
819	};
820
821	virtual ~QRhiResource();
822
823	virtual Type resourceType() const = 0;
824
825	virtual void destroy() = 0;
826
827	void deleteLater();
828
829	QByteArray name() const;
830	void setName(const QByteArray &name);
831
832	quint64 globalResourceId() const;
833
834	QRhi *rhi() const;
835
836	protected:
837	QRhiResource(QRhiImplementation *rhi);
838	Q_DISABLE_COPY(QRhiResource)
839	friend class QRhiImplementation;
840	QRhiImplementation *m_rhi = nullptr;
841	quint64 m_id;
842	QByteArray m_objectName;
843	};
844
845	class Q_GUI_EXPORT QRhiBuffer : public QRhiResource
846	{
847	public:
848	enum Type {
849	Immutable,
850	Static,
851	Dynamic
852	};
853
854	enum UsageFlag {
855	VertexBuffer = 1 << 0,
856	IndexBuffer = 1 << 1,
857	UniformBuffer = 1 << 2,
858	StorageBuffer = 1 << 3
859	};
860	Q_DECLARE_FLAGS(UsageFlags, UsageFlag)
861
862	struct NativeBuffer {
863	const void *objects[3];
864	int slotCount;
865	};
866
867	QRhiResource::Type resourceType() const override;
868
869	Type type() const { return m_type; }
870	void setType(Type t) { m_type = t; }
871
872	UsageFlags usage() const { return m_usage; }
873	void setUsage(UsageFlags u) { m_usage = u; }
874
875	quint32 size() const { return m_size; }
876	void setSize(quint32 sz) { m_size = sz; }
877
878	virtual bool create() = 0;
879
880	virtual NativeBuffer nativeBuffer();
881
882	virtual char *beginFullDynamicBufferUpdateForCurrentFrame();
883	virtual void endFullDynamicBufferUpdateForCurrentFrame();
884	virtual void fullDynamicBufferUpdateForCurrentFrame(const void *data, quint32 size = 0);
885
886	protected:
887	QRhiBuffer(QRhiImplementation *rhi, Type type_, UsageFlags usage_, quint32 size_);
888	Type m_type;
889	UsageFlags m_usage;
890	quint32 m_size;
891	};
892
893	Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiBuffer::UsageFlags)
894
895	class Q_GUI_EXPORT QRhiTexture : public QRhiResource
896	{
897	public:
898	enum Flag {
899	RenderTarget = 1 << 0,
900	CubeMap = 1 << 2,
901	MipMapped = 1 << 3,
902	sRGB = 1 << 4,
903	UsedAsTransferSource = 1 << 5,
904	UsedWithGenerateMips = 1 << 6,
905	UsedWithLoadStore = 1 << 7,
906	UsedAsCompressedAtlas = 1 << 8,
907	ExternalOES = 1 << 9,
908	ThreeDimensional = 1 << 10,
909	TextureRectangleGL = 1 << 11,
910	TextureArray = 1 << 12,
911	OneDimensional = 1 << 13
912	};
913	Q_DECLARE_FLAGS(Flags, Flag)
914
915	enum Format {
916	UnknownFormat,
917
918	RGBA8,
919	BGRA8,
920	R8,
921	RG8,
922	R16,
923	RG16,
924	RED_OR_ALPHA8,
925
926	RGBA16F,
927	RGBA32F,
928	R16F,
929	R32F,
930
931	RGB10A2,
932
933	D16,
934	D24,
935	D24S8,
936	D32F,
937
938	BC1,
939	BC2,
940	BC3,
941	BC4,
942	BC5,
943	BC6H,
944	BC7,
945
946	ETC2_RGB8,
947	ETC2_RGB8A1,
948	ETC2_RGBA8,
949
950	ASTC_4x4,
951	ASTC_5x4,
952	ASTC_5x5,
953	ASTC_6x5,
954	ASTC_6x6,
955	ASTC_8x5,
956	ASTC_8x6,
957	ASTC_8x8,
958	ASTC_10x5,
959	ASTC_10x6,
960	ASTC_10x8,
961	ASTC_10x10,
962	ASTC_12x10,
963	ASTC_12x12
964	};
965
966	struct NativeTexture {
967	quint64 object;
968	int layout; // or state
969	};
970
971	QRhiResource::Type resourceType() const override;
972
973	Format format() const { return m_format; }
974	void setFormat(Format fmt) { m_format = fmt; }
975
976	QSize pixelSize() const { return m_pixelSize; }
977	void setPixelSize(const QSize &sz) { m_pixelSize = sz; }
978
979	int depth() const { return m_depth; }
980	void setDepth(int depth) { m_depth = depth; }
981
982	int arraySize() const { return m_arraySize; }
983	void setArraySize(int arraySize) { m_arraySize = arraySize; }
984
985	int arrayRangeStart() const { return m_arrayRangeStart; }
986	int arrayRangeLength() const { return m_arrayRangeLength; }
987	void setArrayRange(int startIndex, int count)
988	{
989	m_arrayRangeStart = startIndex;
990	m_arrayRangeLength = count;
991	}
992
993	Flags flags() const { return m_flags; }
994	void setFlags(Flags f) { m_flags = f; }
995
996	int sampleCount() const { return m_sampleCount; }
997	void setSampleCount(int s) { m_sampleCount = s; }
998
999	struct ViewFormat {
1000	QRhiTexture::Format format;
1001	bool srgb;
1002	};
1003	ViewFormat readViewFormat() const { return m_readViewFormat; }
1004	void setReadViewFormat(const ViewFormat &fmt) { m_readViewFormat = fmt; }
1005	ViewFormat writeViewFormat() const { return m_writeViewFormat; }
1006	void setWriteViewFormat(const ViewFormat &fmt) { m_writeViewFormat = fmt; }
1007
1008	virtual bool create() = 0;
1009	virtual NativeTexture nativeTexture();
1010	virtual bool createFrom(NativeTexture src);
1011	virtual void setNativeLayout(int layout);
1012
1013	protected:
1014	QRhiTexture(QRhiImplementation *rhi, Format format_, const QSize &pixelSize_, int depth_,
1015	int arraySize_, int sampleCount_, Flags flags_);
1016	Format m_format;
1017	QSize m_pixelSize;
1018	int m_depth;
1019	int m_arraySize;
1020	int m_sampleCount;
1021	Flags m_flags;
1022	int m_arrayRangeStart = -1;
1023	int m_arrayRangeLength = -1;
1024	ViewFormat m_readViewFormat = { .format: UnknownFormat, .srgb: false };
1025	ViewFormat m_writeViewFormat = { .format: UnknownFormat, .srgb: false };
1026	};
1027
1028	Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiTexture::Flags)
1029
1030	class Q_GUI_EXPORT QRhiSampler : public QRhiResource
1031	{
1032	public:
1033	enum Filter {
1034	None,
1035	Nearest,
1036	Linear
1037	};
1038
1039	enum AddressMode {
1040	Repeat,
1041	ClampToEdge,
1042	Mirror,
1043	};
1044
1045	enum CompareOp {
1046	Never,
1047	Less,
1048	Equal,
1049	LessOrEqual,
1050	Greater,
1051	NotEqual,
1052	GreaterOrEqual,
1053	Always
1054	};
1055
1056	QRhiResource::Type resourceType() const override;
1057
1058	Filter magFilter() const { return m_magFilter; }
1059	void setMagFilter(Filter f) { m_magFilter = f; }
1060
1061	Filter minFilter() const { return m_minFilter; }
1062	void setMinFilter(Filter f) { m_minFilter = f; }
1063
1064	Filter mipmapMode() const { return m_mipmapMode; }
1065	void setMipmapMode(Filter f) { m_mipmapMode = f; }
1066
1067	AddressMode addressU() const { return m_addressU; }
1068	void setAddressU(AddressMode mode) { m_addressU = mode; }
1069
1070	AddressMode addressV() const { return m_addressV; }
1071	void setAddressV(AddressMode mode) { m_addressV = mode; }
1072
1073	AddressMode addressW() const { return m_addressW; }
1074	void setAddressW(AddressMode mode) { m_addressW = mode; }
1075
1076	CompareOp textureCompareOp() const { return m_compareOp; }
1077	void setTextureCompareOp(CompareOp op) { m_compareOp = op; }
1078
1079	virtual bool create() = 0;
1080
1081	protected:
1082	QRhiSampler(QRhiImplementation *rhi,
1083	Filter magFilter_, Filter minFilter_, Filter mipmapMode_,
1084	AddressMode u_, AddressMode v_, AddressMode w_);
1085	Filter m_magFilter;
1086	Filter m_minFilter;
1087	Filter m_mipmapMode;
1088	AddressMode m_addressU;
1089	AddressMode m_addressV;
1090	AddressMode m_addressW;
1091	CompareOp m_compareOp;
1092	};
1093
1094	class Q_GUI_EXPORT QRhiRenderBuffer : public QRhiResource
1095	{
1096	public:
1097	enum Type {
1098	DepthStencil,
1099	Color
1100	};
1101
1102	enum Flag {
1103	UsedWithSwapChainOnly = 1 << 0
1104	};
1105	Q_DECLARE_FLAGS(Flags, Flag)
1106
1107	struct NativeRenderBuffer {
1108	quint64 object;
1109	};
1110
1111	QRhiResource::Type resourceType() const override;
1112
1113	Type type() const { return m_type; }
1114	void setType(Type t) { m_type = t; }
1115
1116	QSize pixelSize() const { return m_pixelSize; }
1117	void setPixelSize(const QSize &sz) { m_pixelSize = sz; }
1118
1119	int sampleCount() const { return m_sampleCount; }
1120	void setSampleCount(int s) { m_sampleCount = s; }
1121
1122	Flags flags() const { return m_flags; }
1123	void setFlags(Flags f) { m_flags = f; }
1124
1125	virtual bool create() = 0;
1126	virtual bool createFrom(NativeRenderBuffer src);
1127
1128	virtual QRhiTexture::Format backingFormat() const = 0;
1129
1130	protected:
1131	QRhiRenderBuffer(QRhiImplementation *rhi, Type type_, const QSize &pixelSize_,
1132	int sampleCount_, Flags flags_, QRhiTexture::Format backingFormatHint_);
1133	Type m_type;
1134	QSize m_pixelSize;
1135	int m_sampleCount;
1136	Flags m_flags;
1137	QRhiTexture::Format m_backingFormatHint;
1138	};
1139
1140	Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiRenderBuffer::Flags)
1141
1142	class Q_GUI_EXPORT QRhiRenderPassDescriptor : public QRhiResource
1143	{
1144	public:
1145	QRhiResource::Type resourceType() const override;
1146
1147	virtual bool isCompatible(const QRhiRenderPassDescriptor *other) const = 0;
1148	virtual const QRhiNativeHandles *nativeHandles();
1149
1150	virtual QRhiRenderPassDescriptor *newCompatibleRenderPassDescriptor() const = 0;
1151
1152	virtual QVector<quint32> serializedFormat() const = 0;
1153
1154	protected:
1155	QRhiRenderPassDescriptor(QRhiImplementation *rhi);
1156	};
1157
1158	class Q_GUI_EXPORT QRhiRenderTarget : public QRhiResource
1159	{
1160	public:
1161	virtual QSize pixelSize() const = 0;
1162	virtual float devicePixelRatio() const = 0;
1163	virtual int sampleCount() const = 0;
1164
1165	QRhiRenderPassDescriptor *renderPassDescriptor() const { return m_renderPassDesc; }
1166	void setRenderPassDescriptor(QRhiRenderPassDescriptor *desc) { m_renderPassDesc = desc; }
1167
1168	protected:
1169	QRhiRenderTarget(QRhiImplementation *rhi);
1170	QRhiRenderPassDescriptor *m_renderPassDesc = nullptr;
1171	};
1172
1173	class Q_GUI_EXPORT QRhiSwapChainRenderTarget : public QRhiRenderTarget
1174	{
1175	public:
1176	QRhiResource::Type resourceType() const override;
1177	QRhiSwapChain *swapChain() const { return m_swapchain; }
1178
1179	protected:
1180	QRhiSwapChainRenderTarget(QRhiImplementation *rhi, QRhiSwapChain *swapchain_);
1181	QRhiSwapChain *m_swapchain;
1182	};
1183
1184	class Q_GUI_EXPORT QRhiTextureRenderTarget : public QRhiRenderTarget
1185	{
1186	public:
1187	enum Flag {
1188	PreserveColorContents = 1 << 0,
1189	PreserveDepthStencilContents = 1 << 1,
1190	DoNotStoreDepthStencilContents = 1 << 2
1191	};
1192	Q_DECLARE_FLAGS(Flags, Flag)
1193
1194	QRhiResource::Type resourceType() const override;
1195
1196	QRhiTextureRenderTargetDescription description() const { return m_desc; }
1197	void setDescription(const QRhiTextureRenderTargetDescription &desc) { m_desc = desc; }
1198
1199	Flags flags() const { return m_flags; }
1200	void setFlags(Flags f) { m_flags = f; }
1201
1202	virtual QRhiRenderPassDescriptor *newCompatibleRenderPassDescriptor() = 0;
1203
1204	virtual bool create() = 0;
1205
1206	protected:
1207	QRhiTextureRenderTarget(QRhiImplementation *rhi, const QRhiTextureRenderTargetDescription &desc_, Flags flags_);
1208	QRhiTextureRenderTargetDescription m_desc;
1209	Flags m_flags;
1210	};
1211
1212	Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiTextureRenderTarget::Flags)
1213
1214	class Q_GUI_EXPORT QRhiShaderResourceBindings : public QRhiResource
1215	{
1216	public:
1217	QRhiResource::Type resourceType() const override;
1218
1219	void setBindings(std::initializer_list<QRhiShaderResourceBinding> list) { m_bindings = list; }
1220	template<typename InputIterator>
1221	void setBindings(InputIterator first, InputIterator last)
1222	{
1223	m_bindings.clear();
1224	std::copy(first, last, std::back_inserter(x&: m_bindings));
1225	}
1226	const QRhiShaderResourceBinding *cbeginBindings() const { return m_bindings.cbegin(); }
1227	const QRhiShaderResourceBinding *cendBindings() const { return m_bindings.cend(); }
1228	const QRhiShaderResourceBinding *bindingAt(qsizetype index) const { return &m_bindings.at(idx: index); }
1229	qsizetype bindingCount() const { return m_bindings.count(); }
1230
1231	bool isLayoutCompatible(const QRhiShaderResourceBindings *other) const;
1232
1233	QVector<quint32> serializedLayoutDescription() const { return m_layoutDesc; }
1234
1235	virtual bool create() = 0;
1236
1237	enum UpdateFlag {
1238	BindingsAreSorted = 0x01
1239	};
1240	Q_DECLARE_FLAGS(UpdateFlags, UpdateFlag)
1241
1242	virtual void updateResources(UpdateFlags flags = {}) = 0;
1243
1244	protected:
1245	static constexpr int BINDING_PREALLOC = 12;
1246	QRhiShaderResourceBindings(QRhiImplementation *rhi);
1247	QVarLengthArray<QRhiShaderResourceBinding, BINDING_PREALLOC> m_bindings;
1248	size_t m_layoutDescHash = 0;
1249	// Intentionally not using QVLA for m_layoutDesc: clients like Qt Quick are much
1250	// better served with an implicitly shared container here, because they will likely
1251	// throw this directly into structs serving as cache keys.
1252	QVector<quint32> m_layoutDesc;
1253	friend class QRhiImplementation;
1254	#ifndef QT_NO_DEBUG_STREAM
1255	friend Q_GUI_EXPORT QDebug operator<<(QDebug, const QRhiShaderResourceBindings &);
1256	#endif
1257	};
1258
1259	Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiShaderResourceBindings::UpdateFlags)
1260
1261	#ifndef QT_NO_DEBUG_STREAM
1262	Q_GUI_EXPORT QDebug operator<<(QDebug, const QRhiShaderResourceBindings &);
1263	#endif
1264
1265	// The proper name. Until it gets rolled out universally, have the better name
1266	// as a typedef. Eventually it should be reversed (the old name being a typedef
1267	// to the new one).
1268	using QRhiShaderResourceBindingSet = QRhiShaderResourceBindings;
1269
1270	class Q_GUI_EXPORT QRhiGraphicsPipeline : public QRhiResource
1271	{
1272	public:
1273	enum Flag {
1274	UsesBlendConstants = 1 << 0,
1275	UsesStencilRef = 1 << 1,
1276	UsesScissor = 1 << 2,
1277	CompileShadersWithDebugInfo = 1 << 3
1278	};
1279	Q_DECLARE_FLAGS(Flags, Flag)
1280
1281	enum Topology {
1282	Triangles,
1283	TriangleStrip,
1284	TriangleFan,
1285	Lines,
1286	LineStrip,
1287	Points,
1288	Patches
1289	};
1290
1291	enum CullMode {
1292	None,
1293	Front,
1294	Back
1295	};
1296
1297	enum FrontFace {
1298	CCW,
1299	CW
1300	};
1301
1302	enum ColorMaskComponent {
1303	R = 1 << 0,
1304	G = 1 << 1,
1305	B = 1 << 2,
1306	A = 1 << 3
1307	};
1308	Q_DECLARE_FLAGS(ColorMask, ColorMaskComponent)
1309
1310	enum BlendFactor {
1311	Zero,
1312	One,
1313	SrcColor,
1314	OneMinusSrcColor,
1315	DstColor,
1316	OneMinusDstColor,
1317	SrcAlpha,
1318	OneMinusSrcAlpha,
1319	DstAlpha,
1320	OneMinusDstAlpha,
1321	ConstantColor,
1322	OneMinusConstantColor,
1323	ConstantAlpha,
1324	OneMinusConstantAlpha,
1325	SrcAlphaSaturate,
1326	Src1Color,
1327	OneMinusSrc1Color,
1328	Src1Alpha,
1329	OneMinusSrc1Alpha
1330	};
1331
1332	enum BlendOp {
1333	Add,
1334	Subtract,
1335	ReverseSubtract,
1336	Min,
1337	Max
1338	};
1339
1340	struct TargetBlend {
1341	ColorMask colorWrite = ColorMask(0xF); // R | G | B | A
1342	bool enable = false;
1343	BlendFactor srcColor = One;
1344	BlendFactor dstColor = OneMinusSrcAlpha;
1345	BlendOp opColor = Add;
1346	BlendFactor srcAlpha = One;
1347	BlendFactor dstAlpha = OneMinusSrcAlpha;
1348	BlendOp opAlpha = Add;
1349	};
1350
1351	enum CompareOp {
1352	Never,
1353	Less,
1354	Equal,
1355	LessOrEqual,
1356	Greater,
1357	NotEqual,
1358	GreaterOrEqual,
1359	Always
1360	};
1361
1362	enum StencilOp {
1363	StencilZero,
1364	Keep,
1365	Replace,
1366	IncrementAndClamp,
1367	DecrementAndClamp,
1368	Invert,
1369	IncrementAndWrap,
1370	DecrementAndWrap
1371	};
1372
1373	struct StencilOpState {
1374	StencilOp failOp = Keep;
1375	StencilOp depthFailOp = Keep;
1376	StencilOp passOp = Keep;
1377	CompareOp compareOp = Always;
1378	};
1379
1380	enum PolygonMode {
1381	Fill,
1382	Line
1383	};
1384
1385	QRhiResource::Type resourceType() const override;
1386
1387	Flags flags() const { return m_flags; }
1388	void setFlags(Flags f) { m_flags = f; }
1389
1390	Topology topology() const { return m_topology; }
1391	void setTopology(Topology t) { m_topology = t; }
1392
1393	CullMode cullMode() const { return m_cullMode; }
1394	void setCullMode(CullMode mode) { m_cullMode = mode; }
1395
1396	FrontFace frontFace() const { return m_frontFace; }
1397	void setFrontFace(FrontFace f) { m_frontFace = f; }
1398
1399	void setTargetBlends(std::initializer_list<TargetBlend> list) { m_targetBlends = list; }
1400	template<typename InputIterator>
1401	void setTargetBlends(InputIterator first, InputIterator last)
1402	{
1403	m_targetBlends.clear();
1404	std::copy(first, last, std::back_inserter(x&: m_targetBlends));
1405	}
1406	const TargetBlend *cbeginTargetBlends() const { return m_targetBlends.cbegin(); }
1407	const TargetBlend *cendTargetBlends() const { return m_targetBlends.cend(); }
1408	const TargetBlend *targetBlendAt(qsizetype index) const { return &m_targetBlends.at(idx: index); }
1409	qsizetype targetBlendCount() const { return m_targetBlends.count(); }
1410
1411	bool hasDepthTest() const { return m_depthTest; }
1412	void setDepthTest(bool enable) { m_depthTest = enable; }
1413
1414	bool hasDepthWrite() const { return m_depthWrite; }
1415	void setDepthWrite(bool enable) { m_depthWrite = enable; }
1416
1417	CompareOp depthOp() const { return m_depthOp; }
1418	void setDepthOp(CompareOp op) { m_depthOp = op; }
1419
1420	bool hasStencilTest() const { return m_stencilTest; }
1421	void setStencilTest(bool enable) { m_stencilTest = enable; }
1422
1423	StencilOpState stencilFront() const { return m_stencilFront; }
1424	void setStencilFront(const StencilOpState &state) { m_stencilFront = state; }
1425
1426	StencilOpState stencilBack() const { return m_stencilBack; }
1427	void setStencilBack(const StencilOpState &state) { m_stencilBack = state; }
1428
1429	quint32 stencilReadMask() const { return m_stencilReadMask; }
1430	void setStencilReadMask(quint32 mask) { m_stencilReadMask = mask; }
1431
1432	quint32 stencilWriteMask() const { return m_stencilWriteMask; }
1433	void setStencilWriteMask(quint32 mask) { m_stencilWriteMask = mask; }
1434
1435	int sampleCount() const { return m_sampleCount; }
1436	void setSampleCount(int s) { m_sampleCount = s; }
1437
1438	float lineWidth() const { return m_lineWidth; }
1439	void setLineWidth(float width) { m_lineWidth = width; }
1440
1441	int depthBias() const { return m_depthBias; }
1442	void setDepthBias(int bias) { m_depthBias = bias; }
1443
1444	float slopeScaledDepthBias() const { return m_slopeScaledDepthBias; }
1445	void setSlopeScaledDepthBias(float bias) { m_slopeScaledDepthBias = bias; }
1446
1447	void setShaderStages(std::initializer_list<QRhiShaderStage> list) { m_shaderStages = list; }
1448	template<typename InputIterator>
1449	void setShaderStages(InputIterator first, InputIterator last)
1450	{
1451	m_shaderStages.clear();
1452	std::copy(first, last, std::back_inserter(x&: m_shaderStages));
1453	}
1454	const QRhiShaderStage *cbeginShaderStages() const { return m_shaderStages.cbegin(); }
1455	const QRhiShaderStage *cendShaderStages() const { return m_shaderStages.cend(); }
1456	const QRhiShaderStage *shaderStageAt(qsizetype index) const { return &m_shaderStages.at(idx: index); }
1457	qsizetype shaderStageCount() const { return m_shaderStages.count(); }
1458
1459	QRhiVertexInputLayout vertexInputLayout() const { return m_vertexInputLayout; }
1460	void setVertexInputLayout(const QRhiVertexInputLayout &layout) { m_vertexInputLayout = layout; }
1461
1462	QRhiShaderResourceBindings *shaderResourceBindings() const { return m_shaderResourceBindings; }
1463	void setShaderResourceBindings(QRhiShaderResourceBindings *srb) { m_shaderResourceBindings = srb; }
1464
1465	QRhiRenderPassDescriptor *renderPassDescriptor() const { return m_renderPassDesc; }
1466	void setRenderPassDescriptor(QRhiRenderPassDescriptor *desc) { m_renderPassDesc = desc; }
1467
1468	int patchControlPointCount() const { return m_patchControlPointCount; }
1469	void setPatchControlPointCount(int count) { m_patchControlPointCount = count; }
1470
1471	PolygonMode polygonMode() const {return m_polygonMode; }
1472	void setPolygonMode(PolygonMode mode) {m_polygonMode = mode; }
1473
1474	int multiViewCount() const { return m_multiViewCount; }
1475	void setMultiViewCount(int count) { m_multiViewCount = count; }
1476
1477	virtual bool create() = 0;
1478
1479	protected:
1480	QRhiGraphicsPipeline(QRhiImplementation *rhi);
1481	Flags m_flags;
1482	Topology m_topology = Triangles;
1483	CullMode m_cullMode = None;
1484	FrontFace m_frontFace = CCW;
1485	QVarLengthArray<TargetBlend, 8> m_targetBlends;
1486	bool m_depthTest = false;
1487	bool m_depthWrite = false;
1488	CompareOp m_depthOp = Less;
1489	bool m_stencilTest = false;
1490	StencilOpState m_stencilFront;
1491	StencilOpState m_stencilBack;
1492	quint32 m_stencilReadMask = 0xFF;
1493	quint32 m_stencilWriteMask = 0xFF;
1494	int m_sampleCount = 1;
1495	float m_lineWidth = 1.0f;
1496	int m_depthBias = 0;
1497	float m_slopeScaledDepthBias = 0.0f;
1498	int m_patchControlPointCount = 3;
1499	PolygonMode m_polygonMode = Fill;
1500	int m_multiViewCount = 0;
1501	QVarLengthArray<QRhiShaderStage, 4> m_shaderStages;
1502	QRhiVertexInputLayout m_vertexInputLayout;
1503	QRhiShaderResourceBindings *m_shaderResourceBindings = nullptr;
1504	QRhiRenderPassDescriptor *m_renderPassDesc = nullptr;
1505	};
1506
1507	Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiGraphicsPipeline::Flags)
1508	Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiGraphicsPipeline::ColorMask)
1509	Q_DECLARE_TYPEINFO(QRhiGraphicsPipeline::TargetBlend, Q_RELOCATABLE_TYPE);
1510
1511	struct QRhiSwapChainHdrInfo
1512	{
1513	enum LimitsType {
1514	LuminanceInNits,
1515	ColorComponentValue
1516	};
1517
1518	enum LuminanceBehavior {
1519	SceneReferred,
1520	DisplayReferred
1521	};
1522
1523	LimitsType limitsType;
1524	union {
1525	struct {
1526	float minLuminance;
1527	float maxLuminance;
1528	} luminanceInNits;
1529	struct {
1530	float maxColorComponentValue;
1531	float maxPotentialColorComponentValue;
1532	} colorComponentValue;
1533	} limits;
1534	LuminanceBehavior luminanceBehavior;
1535	float sdrWhiteLevel;
1536	};
1537
1538	Q_DECLARE_TYPEINFO(QRhiSwapChainHdrInfo, Q_RELOCATABLE_TYPE);
1539
1540	#ifndef QT_NO_DEBUG_STREAM
1541	Q_GUI_EXPORT QDebug operator<<(QDebug, const QRhiSwapChainHdrInfo &);
1542	#endif
1543
1544	struct QRhiSwapChainProxyData
1545	{
1546	void *reserved[2] = {};
1547	};
1548
1549	class Q_GUI_EXPORT QRhiSwapChain : public QRhiResource
1550	{
1551	public:
1552	enum Flag {
1553	SurfaceHasPreMulAlpha = 1 << 0,
1554	SurfaceHasNonPreMulAlpha = 1 << 1,
1555	sRGB = 1 << 2,
1556	UsedAsTransferSource = 1 << 3,
1557	NoVSync = 1 << 4,
1558	MinimalBufferCount = 1 << 5
1559	};
1560	Q_DECLARE_FLAGS(Flags, Flag)
1561
1562	enum Format {
1563	SDR,
1564	HDRExtendedSrgbLinear,
1565	HDR10,
1566	HDRExtendedDisplayP3Linear
1567	};
1568
1569	enum StereoTargetBuffer {
1570	LeftBuffer,
1571	RightBuffer
1572	};
1573
1574	QRhiResource::Type resourceType() const override;
1575
1576	QWindow *window() const { return m_window; }
1577	void setWindow(QWindow *window) { m_window = window; }
1578
1579	QRhiSwapChainProxyData proxyData() const { return m_proxyData; }
1580	void setProxyData(const QRhiSwapChainProxyData &d) { m_proxyData = d; }
1581
1582	Flags flags() const { return m_flags; }
1583	void setFlags(Flags f) { m_flags = f; }
1584
1585	Format format() const { return m_format; }
1586	void setFormat(Format f) { m_format = f; }
1587
1588	QRhiRenderBuffer *depthStencil() const { return m_depthStencil; }
1589	void setDepthStencil(QRhiRenderBuffer *ds) { m_depthStencil = ds; }
1590
1591	int sampleCount() const { return m_sampleCount; }
1592	void setSampleCount(int samples) { m_sampleCount = samples; }
1593
1594	QRhiRenderPassDescriptor *renderPassDescriptor() const { return m_renderPassDesc; }
1595	void setRenderPassDescriptor(QRhiRenderPassDescriptor *desc) { m_renderPassDesc = desc; }
1596
1597	QSize currentPixelSize() const { return m_currentPixelSize; }
1598
1599	virtual QRhiCommandBuffer *currentFrameCommandBuffer() = 0;
1600	virtual QRhiRenderTarget *currentFrameRenderTarget() = 0;
1601	virtual QRhiRenderTarget *currentFrameRenderTarget(StereoTargetBuffer targetBuffer);
1602	virtual QSize surfacePixelSize() = 0;
1603	virtual bool isFormatSupported(Format f) = 0;
1604	virtual QRhiRenderPassDescriptor *newCompatibleRenderPassDescriptor() = 0;
1605	virtual bool createOrResize() = 0;
1606	virtual QRhiSwapChainHdrInfo hdrInfo();
1607
1608	protected:
1609	QRhiSwapChain(QRhiImplementation *rhi);
1610	QWindow *m_window = nullptr;
1611	Flags m_flags;
1612	Format m_format = SDR;
1613	QRhiRenderBuffer *m_depthStencil = nullptr;
1614	int m_sampleCount = 1;
1615	QRhiRenderPassDescriptor *m_renderPassDesc = nullptr;
1616	QSize m_currentPixelSize;
1617	QRhiSwapChainProxyData m_proxyData;
1618	};
1619
1620	Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiSwapChain::Flags)
1621
1622	class Q_GUI_EXPORT QRhiComputePipeline : public QRhiResource
1623	{
1624	public:
1625	enum Flag {
1626	CompileShadersWithDebugInfo = 1 << 0
1627	};
1628	Q_DECLARE_FLAGS(Flags, Flag)
1629
1630	QRhiResource::Type resourceType() const override;
1631	virtual bool create() = 0;
1632
1633	Flags flags() const { return m_flags; }
1634	void setFlags(Flags f) { m_flags = f; }
1635
1636	QRhiShaderStage shaderStage() const { return m_shaderStage; }
1637	void setShaderStage(const QRhiShaderStage &stage) { m_shaderStage = stage; }
1638
1639	QRhiShaderResourceBindings *shaderResourceBindings() const { return m_shaderResourceBindings; }
1640	void setShaderResourceBindings(QRhiShaderResourceBindings *srb) { m_shaderResourceBindings = srb; }
1641
1642	protected:
1643	QRhiComputePipeline(QRhiImplementation *rhi);
1644	Flags m_flags;
1645	QRhiShaderStage m_shaderStage;
1646	QRhiShaderResourceBindings *m_shaderResourceBindings = nullptr;
1647	};
1648
1649	Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiComputePipeline::Flags)
1650
1651	class Q_GUI_EXPORT QRhiCommandBuffer : public QRhiResource
1652	{
1653	public:
1654	enum IndexFormat {
1655	IndexUInt16,
1656	IndexUInt32
1657	};
1658
1659	enum BeginPassFlag {
1660	ExternalContent = 0x01,
1661	DoNotTrackResourcesForCompute = 0x02
1662	};
1663	Q_DECLARE_FLAGS(BeginPassFlags, BeginPassFlag)
1664
1665	QRhiResource::Type resourceType() const override;
1666
1667	void resourceUpdate(QRhiResourceUpdateBatch *resourceUpdates);
1668
1669	void beginPass(QRhiRenderTarget *rt,
1670	const QColor &colorClearValue,
1671	const QRhiDepthStencilClearValue &depthStencilClearValue,
1672	QRhiResourceUpdateBatch *resourceUpdates = nullptr,
1673	BeginPassFlags flags = {});
1674	void endPass(QRhiResourceUpdateBatch *resourceUpdates = nullptr);
1675
1676	void setGraphicsPipeline(QRhiGraphicsPipeline *ps);
1677	using DynamicOffset = QPair<int, quint32>; // binding, offset
1678	void setShaderResources(QRhiShaderResourceBindings *srb = nullptr,
1679	int dynamicOffsetCount = 0,
1680	const DynamicOffset *dynamicOffsets = nullptr);
1681	using VertexInput = QPair<QRhiBuffer *, quint32>; // buffer, offset
1682	void setVertexInput(int startBinding, int bindingCount, const VertexInput *bindings,
1683	QRhiBuffer *indexBuf = nullptr, quint32 indexOffset = 0,
1684	IndexFormat indexFormat = IndexUInt16);
1685
1686	void setViewport(const QRhiViewport &viewport);
1687	void setScissor(const QRhiScissor &scissor);
1688	void setBlendConstants(const QColor &c);
1689	void setStencilRef(quint32 refValue);
1690
1691	void draw(quint32 vertexCount,
1692	quint32 instanceCount = 1,
1693	quint32 firstVertex = 0,
1694	quint32 firstInstance = 0);
1695
1696	void drawIndexed(quint32 indexCount,
1697	quint32 instanceCount = 1,
1698	quint32 firstIndex = 0,
1699	qint32 vertexOffset = 0,
1700	quint32 firstInstance = 0);
1701
1702	void debugMarkBegin(const QByteArray &name);
1703	void debugMarkEnd();
1704	void debugMarkMsg(const QByteArray &msg);
1705
1706	void beginComputePass(QRhiResourceUpdateBatch *resourceUpdates = nullptr, BeginPassFlags flags = {});
1707	void endComputePass(QRhiResourceUpdateBatch *resourceUpdates = nullptr);
1708	void setComputePipeline(QRhiComputePipeline *ps);
1709	void dispatch(int x, int y, int z);
1710
1711	const QRhiNativeHandles *nativeHandles();
1712	void beginExternal();
1713	void endExternal();
1714
1715	double lastCompletedGpuTime();
1716
1717	protected:
1718	QRhiCommandBuffer(QRhiImplementation *rhi);
1719	};
1720
1721	Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiCommandBuffer::BeginPassFlags)
1722
1723	struct Q_GUI_EXPORT QRhiReadbackResult
1724	{
1725	std::function<void()> completed = nullptr;
1726	QRhiTexture::Format format;
1727	QSize pixelSize;
1728	QByteArray data;
1729	};
1730
1731	class Q_GUI_EXPORT QRhiResourceUpdateBatch
1732	{
1733	public:
1734	~QRhiResourceUpdateBatch();
1735
1736	void release();
1737
1738	void merge(QRhiResourceUpdateBatch *other);
1739	bool hasOptimalCapacity() const;
1740
1741	void updateDynamicBuffer(QRhiBuffer *buf, quint32 offset, quint32 size, const void *data);
1742	void uploadStaticBuffer(QRhiBuffer *buf, quint32 offset, quint32 size, const void *data);
1743	void uploadStaticBuffer(QRhiBuffer *buf, const void *data);
1744	void readBackBuffer(QRhiBuffer *buf, quint32 offset, quint32 size, QRhiReadbackResult *result);
1745	void uploadTexture(QRhiTexture *tex, const QRhiTextureUploadDescription &desc);
1746	void uploadTexture(QRhiTexture *tex, const QImage &image);
1747	void copyTexture(QRhiTexture *dst, QRhiTexture *src, const QRhiTextureCopyDescription &desc = QRhiTextureCopyDescription());
1748	void readBackTexture(const QRhiReadbackDescription &rb, QRhiReadbackResult *result);
1749	void generateMips(QRhiTexture *tex);
1750
1751	private:
1752	QRhiResourceUpdateBatch(QRhiImplementation *rhi);
1753	Q_DISABLE_COPY(QRhiResourceUpdateBatch)
1754	QRhiResourceUpdateBatchPrivate *d;
1755	friend class QRhiResourceUpdateBatchPrivate;
1756	friend class QRhi;
1757	};
1758
1759	struct Q_GUI_EXPORT QRhiDriverInfo
1760	{
1761	enum DeviceType {
1762	UnknownDevice,
1763	IntegratedDevice,
1764	DiscreteDevice,
1765	ExternalDevice,
1766	VirtualDevice,
1767	CpuDevice
1768	};
1769
1770	QByteArray deviceName;
1771	quint64 deviceId = 0;
1772	quint64 vendorId = 0;
1773	DeviceType deviceType = UnknownDevice;
1774	};
1775
1776	Q_DECLARE_TYPEINFO(QRhiDriverInfo, Q_RELOCATABLE_TYPE);
1777
1778	#ifndef QT_NO_DEBUG_STREAM
1779	Q_GUI_EXPORT QDebug operator<<(QDebug, const QRhiDriverInfo &);
1780	#endif
1781
1782	struct Q_GUI_EXPORT QRhiStats
1783	{
1784	qint64 totalPipelineCreationTime = 0;
1785	// Vulkan or D3D12 memory allocator statistics
1786	quint32 blockCount = 0;
1787	quint32 allocCount = 0;
1788	quint64 usedBytes = 0;
1789	quint64 unusedBytes = 0;
1790	// D3D12 only, from IDXGIAdapter3::QueryVideoMemoryInfo(), incl. all resources
1791	quint64 totalUsageBytes = 0;
1792	};
1793
1794	Q_DECLARE_TYPEINFO(QRhiStats, Q_RELOCATABLE_TYPE);
1795
1796	#ifndef QT_NO_DEBUG_STREAM
1797	Q_GUI_EXPORT QDebug operator<<(QDebug, const QRhiStats &);
1798	#endif
1799
1800	struct Q_GUI_EXPORT QRhiInitParams
1801	{
1802	};
1803
1804	class Q_GUI_EXPORT QRhi
1805	{
1806	public:
1807	enum Implementation {
1808	Null,
1809	Vulkan,
1810	OpenGLES2,
1811	D3D11,
1812	Metal,
1813	D3D12
1814	};
1815
1816	enum Flag {
1817	EnableDebugMarkers = 1 << 0,
1818	PreferSoftwareRenderer = 1 << 1,
1819	EnablePipelineCacheDataSave = 1 << 2,
1820	EnableTimestamps = 1 << 3,
1821	SuppressSmokeTestWarnings = 1 << 4
1822	};
1823	Q_DECLARE_FLAGS(Flags, Flag)
1824
1825	enum FrameOpResult {
1826	FrameOpSuccess = 0,
1827	FrameOpError,
1828	FrameOpSwapChainOutOfDate,
1829	FrameOpDeviceLost
1830	};
1831
1832	enum Feature {
1833	MultisampleTexture = 1,
1834	MultisampleRenderBuffer,
1835	DebugMarkers,
1836	Timestamps,
1837	Instancing,
1838	CustomInstanceStepRate,
1839	PrimitiveRestart,
1840	NonDynamicUniformBuffers,
1841	NonFourAlignedEffectiveIndexBufferOffset,
1842	NPOTTextureRepeat,
1843	RedOrAlpha8IsRed,
1844	ElementIndexUint,
1845	Compute,
1846	WideLines,
1847	VertexShaderPointSize,
1848	BaseVertex,
1849	BaseInstance,
1850	TriangleFanTopology,
1851	ReadBackNonUniformBuffer,
1852	ReadBackNonBaseMipLevel,
1853	TexelFetch,
1854	RenderToNonBaseMipLevel,
1855	IntAttributes,
1856	ScreenSpaceDerivatives,
1857	ReadBackAnyTextureFormat,
1858	PipelineCacheDataLoadSave,
1859	ImageDataStride,
1860	RenderBufferImport,
1861	ThreeDimensionalTextures,
1862	RenderTo3DTextureSlice,
1863	TextureArrays,
1864	Tessellation,
1865	GeometryShader,
1866	TextureArrayRange,
1867	NonFillPolygonMode,
1868	OneDimensionalTextures,
1869	OneDimensionalTextureMipmaps,
1870	HalfAttributes,
1871	RenderToOneDimensionalTexture,
1872	ThreeDimensionalTextureMipmaps,
1873	MultiView,
1874	TextureViewFormat,
1875	ResolveDepthStencil
1876	};
1877
1878	enum BeginFrameFlag {
1879	};
1880	Q_DECLARE_FLAGS(BeginFrameFlags, BeginFrameFlag)
1881
1882	enum EndFrameFlag {
1883	SkipPresent = 1 << 0
1884	};
1885	Q_DECLARE_FLAGS(EndFrameFlags, EndFrameFlag)
1886
1887	enum ResourceLimit {
1888	TextureSizeMin = 1,
1889	TextureSizeMax,
1890	MaxColorAttachments,
1891	FramesInFlight,
1892	MaxAsyncReadbackFrames,
1893	MaxThreadGroupsPerDimension,
1894	MaxThreadsPerThreadGroup,
1895	MaxThreadGroupX,
1896	MaxThreadGroupY,
1897	MaxThreadGroupZ,
1898	TextureArraySizeMax,
1899	MaxUniformBufferRange,
1900	MaxVertexInputs,
1901	MaxVertexOutputs
1902	};
1903
1904	~QRhi();
1905
1906	static QRhi *create(Implementation impl,
1907	QRhiInitParams *params,
1908	Flags flags = {},
1909	QRhiNativeHandles *importDevice = nullptr);
1910	static bool probe(Implementation impl, QRhiInitParams *params);
1911
1912	Implementation backend() const;
1913	const char *backendName() const;
1914	static const char *backendName(Implementation impl);
1915	QRhiDriverInfo driverInfo() const;
1916	QThread *thread() const;
1917
1918	using CleanupCallback = std::function<void(QRhi *)>;
1919	void addCleanupCallback(const CleanupCallback &callback);
1920	void addCleanupCallback(const void *key, const CleanupCallback &callback);
1921	void removeCleanupCallback(const void *key);
1922	void runCleanup();
1923
1924	QRhiGraphicsPipeline *newGraphicsPipeline();
1925	QRhiComputePipeline *newComputePipeline();
1926	QRhiShaderResourceBindings *newShaderResourceBindings();
1927
1928	QRhiBuffer *newBuffer(QRhiBuffer::Type type,
1929	QRhiBuffer::UsageFlags usage,
1930	quint32 size);
1931
1932	QRhiRenderBuffer *newRenderBuffer(QRhiRenderBuffer::Type type,
1933	const QSize &pixelSize,
1934	int sampleCount = 1,
1935	QRhiRenderBuffer::Flags flags = {},
1936	QRhiTexture::Format backingFormatHint = QRhiTexture::UnknownFormat);
1937
1938	QRhiTexture *newTexture(QRhiTexture::Format format,
1939	const QSize &pixelSize,
1940	int sampleCount = 1,
1941	QRhiTexture::Flags flags = {});
1942
1943	QRhiTexture *newTexture(QRhiTexture::Format format,
1944	int width, int height, int depth,
1945	int sampleCount = 1,
1946	QRhiTexture::Flags flags = {});
1947
1948	QRhiTexture *newTextureArray(QRhiTexture::Format format,
1949	int arraySize,
1950	const QSize &pixelSize,
1951	int sampleCount = 1,
1952	QRhiTexture::Flags flags = {});
1953
1954	QRhiSampler *newSampler(QRhiSampler::Filter magFilter,
1955	QRhiSampler::Filter minFilter,
1956	QRhiSampler::Filter mipmapMode,
1957	QRhiSampler::AddressMode addressU,
1958	QRhiSampler::AddressMode addressV,
1959	QRhiSampler::AddressMode addressW = QRhiSampler::Repeat);
1960
1961	QRhiTextureRenderTarget *newTextureRenderTarget(const QRhiTextureRenderTargetDescription &desc,
1962	QRhiTextureRenderTarget::Flags flags = {});
1963
1964	QRhiSwapChain *newSwapChain();
1965	FrameOpResult beginFrame(QRhiSwapChain *swapChain, BeginFrameFlags flags = {});
1966	FrameOpResult endFrame(QRhiSwapChain *swapChain, EndFrameFlags flags = {});
1967	bool isRecordingFrame() const;
1968	int currentFrameSlot() const;
1969
1970	FrameOpResult beginOffscreenFrame(QRhiCommandBuffer **cb, BeginFrameFlags flags = {});
1971	FrameOpResult endOffscreenFrame(EndFrameFlags flags = {});
1972
1973	QRhi::FrameOpResult finish();
1974
1975	QRhiResourceUpdateBatch *nextResourceUpdateBatch();
1976
1977	QList<int> supportedSampleCounts() const;
1978
1979	int ubufAlignment() const;
1980	int ubufAligned(int v) const;
1981
1982	static int mipLevelsForSize(const QSize &size);
1983	static QSize sizeForMipLevel(int mipLevel, const QSize &baseLevelSize);
1984
1985	bool isYUpInFramebuffer() const;
1986	bool isYUpInNDC() const;
1987	bool isClipDepthZeroToOne() const;
1988
1989	QMatrix4x4 clipSpaceCorrMatrix() const;
1990
1991	bool isTextureFormatSupported(QRhiTexture::Format format, QRhiTexture::Flags flags = {}) const;
1992	bool isFeatureSupported(QRhi::Feature feature) const;
1993	int resourceLimit(ResourceLimit limit) const;
1994
1995	const QRhiNativeHandles *nativeHandles();
1996	bool makeThreadLocalNativeContextCurrent();
1997
1998	static constexpr int MAX_MIP_LEVELS = 16; // -> max width or height is 65536
1999
2000	void releaseCachedResources();
2001
2002	bool isDeviceLost() const;
2003
2004	QByteArray pipelineCacheData();
2005	void setPipelineCacheData(const QByteArray &data);
2006
2007	QRhiStats statistics() const;
2008
2009	static QRhiSwapChainProxyData updateSwapChainProxyData(Implementation impl, QWindow *window);
2010
2011	protected:
2012	QRhi();
2013
2014	private:
2015	Q_DISABLE_COPY(QRhi)
2016	QRhiImplementation *d = nullptr;
2017	};
2018
2019	Q_DECLARE_OPERATORS_FOR_FLAGS(QRhi::Flags)
2020	Q_DECLARE_OPERATORS_FOR_FLAGS(QRhi::BeginFrameFlags)
2021	Q_DECLARE_OPERATORS_FOR_FLAGS(QRhi::EndFrameFlags)
2022
2023	QT_END_NAMESPACE
2024
2025	#include <rhi/qrhi_platform.h>
2026
2027	#endif
2028