qrhi.h 41.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
/****************************************************************************
**
** Copyright (C) 2018 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the Qt RHI module
**
** $QT_BEGIN_LICENSE:LGPL3$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPLv3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or later as published by the Free
** Software Foundation and appearing in the file LICENSE.GPL included in
** the packaging of this file. Please review the following information to
** ensure the GNU General Public License version 2.0 requirements will be
** met: http://www.gnu.org/licenses/gpl-2.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#ifndef QRHI_H
#define QRHI_H

#include <QtRhi/qtrhiglobal.h>
#include <QVector4D>
#include <QVector2D>
#include <QSize>
#include <QMatrix4x4>
#include <QVector>
46
#include <QThread>
47
#include <QImage>
48
#include <QtRhi/QBakedShader>
49
#include <functional>
50 51 52 53

QT_BEGIN_NAMESPACE

class QWindow;
Laszlo Agocs's avatar
Laszlo Agocs committed
54 55 56 57 58
class QRhiImplementation;
class QRhiBuffer;
class QRhiRenderBuffer;
class QRhiTexture;
class QRhiSampler;
59 60
class QRhiCommandBuffer;
class QRhiResourceUpdateBatch;
61
class QRhiResourceUpdateBatchPrivate;
62
class QRhiProfiler;
63
class QRhiShaderResourceBindingPrivate;
64

65
class Q_RHI_EXPORT QRhiColorClearValue
66
{
67
public:
Laszlo Agocs's avatar
Laszlo Agocs committed
68 69 70
    QRhiColorClearValue();
    explicit QRhiColorClearValue(const QVector4D &c);
    QRhiColorClearValue(float r, float g, float b, float a);
71 72 73 74 75 76

    QVector4D rgba() const { return m_rgba; }
    void setRgba(const QVector4D &c) { m_rgba = c; }

private:
    QVector4D m_rgba;
77 78 79 80
};

Q_DECLARE_TYPEINFO(QRhiColorClearValue, Q_MOVABLE_TYPE);

81 82 83
Q_RHI_EXPORT bool operator==(const QRhiColorClearValue &a, const QRhiColorClearValue &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT bool operator!=(const QRhiColorClearValue &a, const QRhiColorClearValue &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT uint qHash(const QRhiColorClearValue &v, uint seed = 0) Q_DECL_NOTHROW;
84 85 86
#ifndef QT_NO_DEBUG_STREAM
Q_RHI_EXPORT QDebug operator<<(QDebug, const QRhiColorClearValue &);
#endif
87

88
class Q_RHI_EXPORT QRhiDepthStencilClearValue
89
{
90
public:
Laszlo Agocs's avatar
Laszlo Agocs committed
91 92
    QRhiDepthStencilClearValue();
    QRhiDepthStencilClearValue(float d, quint32 s);
93 94 95 96 97 98 99 100 101 102

    float depthClearValue() const { return m_d; }
    void setDepthClearValue(float d) { m_d = d; }

    quint32 stencilClearValue() const { return m_s; }
    void setStencilClearValue(quint32 s) { m_s = s; }

private:
    float m_d;
    quint32 m_s;
103 104 105 106
};

Q_DECLARE_TYPEINFO(QRhiDepthStencilClearValue, Q_MOVABLE_TYPE);

107 108 109
Q_RHI_EXPORT bool operator==(const QRhiDepthStencilClearValue &a, const QRhiDepthStencilClearValue &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT bool operator!=(const QRhiDepthStencilClearValue &a, const QRhiDepthStencilClearValue &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT uint qHash(const QRhiDepthStencilClearValue &v, uint seed = 0) Q_DECL_NOTHROW;
110 111 112
#ifndef QT_NO_DEBUG_STREAM
Q_RHI_EXPORT QDebug operator<<(QDebug, const QRhiDepthStencilClearValue &);
#endif
113

114
class Q_RHI_EXPORT QRhiViewport
115
{
116
public:
Laszlo Agocs's avatar
Laszlo Agocs committed
117 118
    QRhiViewport();
    QRhiViewport(float x, float y, float w, float h, float minDepth = 0.0f, float maxDepth = 1.0f);
119 120 121 122 123 124 125 126 127 128 129 130 131 132

    QVector4D viewport() const { return m_rect; }
    void setViewport(const QVector4D &v) { m_rect = v; }

    float minDepth() const { return m_minDepth; }
    void setMinDepth(float minDepth) { m_minDepth = minDepth; }

    float maxDepth() const { return m_maxDepth; }
    void setMaxDepth(float maxDepth) { m_maxDepth = maxDepth; }

private:
    QVector4D m_rect;
    float m_minDepth;
    float m_maxDepth;
133 134 135 136
};

Q_DECLARE_TYPEINFO(QRhiViewport, Q_MOVABLE_TYPE);

137 138 139
Q_RHI_EXPORT bool operator==(const QRhiViewport &a, const QRhiViewport &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT bool operator!=(const QRhiViewport &a, const QRhiViewport &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT uint qHash(const QRhiViewport &v, uint seed = 0) Q_DECL_NOTHROW;
140 141 142
#ifndef QT_NO_DEBUG_STREAM
Q_RHI_EXPORT QDebug operator<<(QDebug, const QRhiViewport &);
#endif
143

144
class Q_RHI_EXPORT QRhiScissor
145
{
146
public:
Laszlo Agocs's avatar
Laszlo Agocs committed
147 148
    QRhiScissor();
    QRhiScissor(int x, int y, int w, int h);
149 150 151 152 153 154

    QVector4D scissor() const { return m_rect; }
    void setScissor(const QVector4D &v) { m_rect = v; }

private:
    QVector4D m_rect;
155 156 157 158
};

Q_DECLARE_TYPEINFO(QRhiScissor, Q_MOVABLE_TYPE);

159 160 161
Q_RHI_EXPORT bool operator==(const QRhiScissor &a, const QRhiScissor &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT bool operator!=(const QRhiScissor &a, const QRhiScissor &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT uint qHash(const QRhiScissor &v, uint seed = 0) Q_DECL_NOTHROW;
162 163 164
#ifndef QT_NO_DEBUG_STREAM
Q_RHI_EXPORT QDebug operator<<(QDebug, const QRhiScissor &);
#endif
165

166
class Q_RHI_EXPORT QRhiVertexInputBinding
167
{
168 169 170 171 172 173
public:
    enum Classification {
        PerVertex,
        PerInstance
    };

Laszlo Agocs's avatar
Laszlo Agocs committed
174 175
    QRhiVertexInputBinding();
    QRhiVertexInputBinding(quint32 stride, Classification cls = PerVertex, int stepRate = 1);
176 177 178 179 180 181 182 183 184 185 186 187 188 189

    quint32 stride() const { return m_stride; }
    void setStride(quint32 s) { m_stride = s; }

    Classification classification() const { return m_classification; }
    void setClassification(Classification c) { m_classification = c; }

    int instanceStepRate() const { return m_instanceStepRate; }
    void setInstanceStepRate(int rate) { m_instanceStepRate = rate; }

private:
    quint32 m_stride;
    Classification m_classification;
    int m_instanceStepRate;
190
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
191 192 193 194
};

Q_DECLARE_TYPEINFO(QRhiVertexInputBinding, Q_MOVABLE_TYPE);

195 196 197
Q_RHI_EXPORT bool operator==(const QRhiVertexInputBinding &a, const QRhiVertexInputBinding &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT bool operator!=(const QRhiVertexInputBinding &a, const QRhiVertexInputBinding &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT uint qHash(const QRhiVertexInputBinding &v, uint seed = 0) Q_DECL_NOTHROW;
198 199 200
#ifndef QT_NO_DEBUG_STREAM
Q_RHI_EXPORT QDebug operator<<(QDebug, const QRhiVertexInputBinding &);
#endif
201

202 203 204 205 206 207 208 209 210 211 212 213 214
class Q_RHI_EXPORT QRhiVertexInputAttribute
{
public:
    enum Format {
        Float4,
        Float3,
        Float2,
        Float,
        UNormByte4,
        UNormByte2,
        UNormByte
    };

Laszlo Agocs's avatar
Laszlo Agocs committed
215 216
    QRhiVertexInputAttribute();
    QRhiVertexInputAttribute(int binding, int location, Format format, quint32 offset);
217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234

    int binding() const { return m_binding; }
    void setBinding(int b) { m_binding = b; }

    int location() const { return m_location; }
    void setLocation(int loc) { m_location = loc; }

    Format format() const { return m_format; }
    void setFormt(Format f) { m_format = f; }

    quint32 offset() const { return m_offset; }
    void setOffset(quint32 ofs) { m_offset = ofs; }

private:
    int m_binding;
    int m_location;
    Format m_format;
    quint32 m_offset;
235
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
236 237 238 239
};

Q_DECLARE_TYPEINFO(QRhiVertexInputAttribute, Q_MOVABLE_TYPE);

240 241 242
Q_RHI_EXPORT bool operator==(const QRhiVertexInputAttribute &a, const QRhiVertexInputAttribute &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT bool operator!=(const QRhiVertexInputAttribute &a, const QRhiVertexInputAttribute &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT uint qHash(const QRhiVertexInputAttribute &v, uint seed = 0) Q_DECL_NOTHROW;
243 244 245
#ifndef QT_NO_DEBUG_STREAM
Q_RHI_EXPORT QDebug operator<<(QDebug, const QRhiVertexInputAttribute &);
#endif
246

247 248 249
class Q_RHI_EXPORT QRhiVertexInputLayout
{
public:
Laszlo Agocs's avatar
Laszlo Agocs committed
250 251
    QRhiVertexInputLayout();

252 253 254 255 256 257 258 259 260
    QVector<QRhiVertexInputBinding> bindings() const { return m_bindings; }
    void setBindings(const QVector<QRhiVertexInputBinding> &v) { m_bindings = v; }

    QVector<QRhiVertexInputAttribute> attributes() const { return m_attributes; }
    void setAttributes(const QVector<QRhiVertexInputAttribute> &v) { m_attributes = v; }

private:
    QVector<QRhiVertexInputBinding> m_bindings;
    QVector<QRhiVertexInputAttribute> m_attributes;
261
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
262 263 264 265
};

Q_DECLARE_TYPEINFO(QRhiVertexInputLayout, Q_MOVABLE_TYPE);

266 267 268
Q_RHI_EXPORT bool operator==(const QRhiVertexInputLayout &a, const QRhiVertexInputLayout &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT bool operator!=(const QRhiVertexInputLayout &a, const QRhiVertexInputLayout &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT uint qHash(const QRhiVertexInputLayout &v, uint seed = 0) Q_DECL_NOTHROW;
269 270 271
#ifndef QT_NO_DEBUG_STREAM
Q_RHI_EXPORT QDebug operator<<(QDebug, const QRhiVertexInputLayout &);
#endif
272

273
class Q_RHI_EXPORT QRhiGraphicsShaderStage
274
{
275
public:
276 277 278
    enum Type {
        Vertex,
        Fragment,
279
        Geometry,
280 281
        TessellationControl,
        TessellationEvaluation
282 283
    };

Laszlo Agocs's avatar
Laszlo Agocs committed
284
    QRhiGraphicsShaderStage();
285 286
    QRhiGraphicsShaderStage(Type type, const QBakedShader &shader,
                            QBakedShaderKey::ShaderVariant v = QBakedShaderKey::StandardShader);
287

288 289 290 291 292 293
    Type type() const { return m_type; }
    void setType(Type t) { m_type = t; }

    QBakedShader shader() const { return m_shader; }
    void setShader(const QBakedShader &s) { m_shader = s; }

294 295 296
    QBakedShaderKey::ShaderVariant shaderVariant() const { return m_shaderVariant; }
    void setShaderVariant(QBakedShaderKey::ShaderVariant v) { m_shaderVariant = v; }

297 298 299
private:
    Type m_type;
    QBakedShader m_shader;
300
    QBakedShaderKey::ShaderVariant m_shaderVariant = QBakedShaderKey::StandardShader;
301
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
302 303 304 305
};

Q_DECLARE_TYPEINFO(QRhiGraphicsShaderStage, Q_MOVABLE_TYPE);

306 307 308
Q_RHI_EXPORT bool operator==(const QRhiGraphicsShaderStage &a, const QRhiGraphicsShaderStage &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT bool operator!=(const QRhiGraphicsShaderStage &a, const QRhiGraphicsShaderStage &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT uint qHash(const QRhiGraphicsShaderStage &s, uint seed = 0) Q_DECL_NOTHROW;
309 310 311
#ifndef QT_NO_DEBUG_STREAM
Q_RHI_EXPORT QDebug operator<<(QDebug, const QRhiGraphicsShaderStage &);
#endif
312

313
class Q_RHI_EXPORT QRhiShaderResourceBinding
Laszlo Agocs's avatar
Laszlo Agocs committed
314
{
315
public:
Laszlo Agocs's avatar
Laszlo Agocs committed
316 317 318 319 320 321 322 323
    enum Type {
        UniformBuffer,
        SampledTexture
    };

    enum StageFlag {
        VertexStage = 1 << 0,
        FragmentStage = 1 << 1,
324 325 326
        GeometryStage = 1 << 2,
        TessellationControlStage = 1 << 3,
        TessellationEvaluationStage = 1 << 4
Laszlo Agocs's avatar
Laszlo Agocs committed
327 328 329
    };
    Q_DECLARE_FLAGS(StageFlags, StageFlag)

330 331 332 333 334 335
    QRhiShaderResourceBinding();
    QRhiShaderResourceBinding(const QRhiShaderResourceBinding &other);
    QRhiShaderResourceBinding &operator=(const QRhiShaderResourceBinding &other);
    ~QRhiShaderResourceBinding();
    void detach();

336 337
    bool isLayoutCompatible(const QRhiShaderResourceBinding &other) const;

338 339
    static QRhiShaderResourceBinding uniformBuffer(int binding, StageFlags stage, QRhiBuffer *buf);
    static QRhiShaderResourceBinding uniformBuffer(int binding, StageFlags stage, QRhiBuffer *buf, int offset, int size);
340
    static QRhiShaderResourceBinding uniformBufferWithDynamicOffset(int binding, StageFlags stage, QRhiBuffer *buf, int size);
341 342 343 344 345
    static QRhiShaderResourceBinding sampledTexture(int binding, StageFlags stage, QRhiTexture *tex, QRhiSampler *sampler);

private:
    QRhiShaderResourceBindingPrivate *d;
    friend class QRhiShaderResourceBindingPrivate;
346 347 348
    friend Q_RHI_EXPORT bool operator==(const QRhiShaderResourceBinding &, const QRhiShaderResourceBinding &) Q_DECL_NOTHROW;
    friend Q_RHI_EXPORT bool operator!=(const QRhiShaderResourceBinding &, const QRhiShaderResourceBinding &) Q_DECL_NOTHROW;
    friend Q_RHI_EXPORT uint qHash(const QRhiShaderResourceBinding &, uint) Q_DECL_NOTHROW;
Laszlo Agocs's avatar
Laszlo Agocs committed
349 350 351
#ifndef QT_NO_DEBUG_STREAM
    friend Q_RHI_EXPORT QDebug operator<<(QDebug, const QRhiShaderResourceBinding &);
#endif
Laszlo Agocs's avatar
Laszlo Agocs committed
352 353 354 355
};

Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiShaderResourceBinding::StageFlags)

356 357 358
Q_RHI_EXPORT bool operator==(const QRhiShaderResourceBinding &a, const QRhiShaderResourceBinding &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT bool operator!=(const QRhiShaderResourceBinding &a, const QRhiShaderResourceBinding &b) Q_DECL_NOTHROW;
Q_RHI_EXPORT uint qHash(const QRhiShaderResourceBinding &b, uint seed = 0) Q_DECL_NOTHROW;
Laszlo Agocs's avatar
Laszlo Agocs committed
359 360 361
#ifndef QT_NO_DEBUG_STREAM
Q_RHI_EXPORT QDebug operator<<(QDebug, const QRhiShaderResourceBinding &);
#endif
362

363
class Q_RHI_EXPORT QRhiColorAttachment
Laszlo Agocs's avatar
Laszlo Agocs committed
364
{
365
public:
Laszlo Agocs's avatar
Laszlo Agocs committed
366 367 368
    QRhiColorAttachment();
    QRhiColorAttachment(QRhiTexture *texture);
    QRhiColorAttachment(QRhiRenderBuffer *renderBuffer);
369

370 371
    QRhiTexture *texture() const { return m_texture; }
    void setTexture(QRhiTexture *tex) { m_texture = tex; }
372

373 374
    QRhiRenderBuffer *renderBuffer() const { return m_renderBuffer; }
    void setRenderBuffer(QRhiRenderBuffer *rb) { m_renderBuffer = rb; }
375

376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
    int layer() const { return m_layer; }
    void setLayer(int layer) { m_layer = layer; }

    int level() const { return m_level; }
    void setLevel(int level) { m_level = level; }

    QRhiTexture *resolveTexture() const { return m_resolveTexture; }
    void setResolveTexture(QRhiTexture *tex) { m_resolveTexture = tex; }

    int resolveLayer() const { return m_resolveLayer; }
    void setResolveLayer(int layer) { m_resolveLayer = layer; }

    int resolveLevel() const { return m_resolveLevel; }
    void setResolveLevel(int level) { m_resolveLevel = level; }

private:
    QRhiTexture *m_texture = nullptr;
    QRhiRenderBuffer *m_renderBuffer = nullptr;
    int m_layer = 0;
    int m_level = 0;
    QRhiTexture *m_resolveTexture = nullptr;
    int m_resolveLayer = 0;
    int m_resolveLevel = 0;
399
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
400 401 402 403 404 405 406
};

Q_DECLARE_TYPEINFO(QRhiColorAttachment, Q_MOVABLE_TYPE);

class Q_RHI_EXPORT QRhiTextureRenderTargetDescription
{
public:
Laszlo Agocs's avatar
Laszlo Agocs committed
407 408 409 410
    QRhiTextureRenderTargetDescription();
    QRhiTextureRenderTargetDescription(const QRhiColorAttachment &colorAttachment);
    QRhiTextureRenderTargetDescription(const QRhiColorAttachment &colorAttachment, QRhiRenderBuffer *depthStencilBuffer);
    QRhiTextureRenderTargetDescription(const QRhiColorAttachment &colorAttachment, QRhiTexture *depthTexture);
411 412 413 414 415 416 417 418 419 420 421 422 423 424

    QVector<QRhiColorAttachment> colorAttachments() const { return m_colorAttachments; }
    void setColorAttachments(const QVector<QRhiColorAttachment> &att) { m_colorAttachments = att; }

    QRhiRenderBuffer *depthStencilBuffer() const { return m_depthStencilBuffer; }
    void setDepthStencilBuffer(QRhiRenderBuffer *renderBuffer) { m_depthStencilBuffer = renderBuffer; }

    QRhiTexture *depthTexture() const { return m_depthTexture; }
    void setDepthTexture(QRhiTexture *texture) { m_depthTexture = texture; }

private:
    QVector<QRhiColorAttachment> m_colorAttachments;
    QRhiRenderBuffer *m_depthStencilBuffer = nullptr;
    QRhiTexture *m_depthTexture = nullptr;
425
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
Laszlo Agocs's avatar
Laszlo Agocs committed
426 427 428 429
};

Q_DECLARE_TYPEINFO(QRhiTextureRenderTargetDescription, Q_MOVABLE_TYPE);

430
class Q_RHI_EXPORT QRhiTextureMipLevel
Laszlo Agocs's avatar
Laszlo Agocs committed
431
{
432
public:
Laszlo Agocs's avatar
Laszlo Agocs committed
433 434
    QRhiTextureMipLevel();
    QRhiTextureMipLevel(const QImage &image);
435
    QRhiTextureMipLevel(const QByteArray &data);
436 437 438 439

    QImage image() const { return m_image; }
    void setImage(const QImage &image) { m_image = image; }

440 441
    QByteArray data() const { return m_data; }
    void setData(const QByteArray &data) { m_data = data; }
442 443 444 445 446 447 448 449 450 451 452 453

    QPoint destinationTopLeft() const { return m_destinationTopLeft; }
    void setDestinationTopLeft(const QPoint &p) { m_destinationTopLeft = p; }

    QSize sourceSize() const { return m_sourceSize; }
    void setSourceSize(const QSize &size) { m_sourceSize = size; }

    QPoint sourceTopLeft() const { return m_sourceTopLeft; }
    void setSourceTopLeft(const QPoint &p) { m_sourceTopLeft = p; }

private:
    QImage m_image;
454
    QByteArray m_data;
455 456 457
    QPoint m_destinationTopLeft;
    QSize m_sourceSize;
    QPoint m_sourceTopLeft;
458
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
459 460 461 462 463 464 465
};

Q_DECLARE_TYPEINFO(QRhiTextureMipLevel, Q_MOVABLE_TYPE);

class Q_RHI_EXPORT QRhiTextureLayer
{
public:
Laszlo Agocs's avatar
Laszlo Agocs committed
466 467
    QRhiTextureLayer();
    QRhiTextureLayer(const QVector<QRhiTextureMipLevel> &mipImages);
468 469 470 471 472 473

    QVector<QRhiTextureMipLevel> mipImages() const { return m_mipImages; }
    void setMipImages(const QVector<QRhiTextureMipLevel> &images) { m_mipImages = images; }

private:
    QVector<QRhiTextureMipLevel> m_mipImages;
474
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
475
};
476

477 478 479 480 481
Q_DECLARE_TYPEINFO(QRhiTextureLayer, Q_MOVABLE_TYPE);

class Q_RHI_EXPORT QRhiTextureUploadDescription
{
public:
Laszlo Agocs's avatar
Laszlo Agocs committed
482 483
    QRhiTextureUploadDescription();
    QRhiTextureUploadDescription(const QVector<QRhiTextureLayer> &layers);
484 485 486 487 488 489

    QVector<QRhiTextureLayer> layers() const { return m_layers; }
    void setLayers(const QVector<QRhiTextureLayer> &layers) { m_layers = layers; }

private:
    QVector<QRhiTextureLayer> m_layers;
490
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
Laszlo Agocs's avatar
Laszlo Agocs committed
491 492 493 494
};

Q_DECLARE_TYPEINFO(QRhiTextureUploadDescription, Q_MOVABLE_TYPE);

495
class Q_RHI_EXPORT QRhiTextureCopyDescription
496
{
497
public:
Laszlo Agocs's avatar
Laszlo Agocs committed
498
    QRhiTextureCopyDescription();
499 500 501 502 503 504 505 506 507 508 509 510 511 512 513

    QSize pixelSize() const { return m_pixelSize; }
    void setPixelSize(const QSize &sz) { m_pixelSize = sz; }

    int sourceLayer() const { return m_sourceLayer; }
    void setSourceLayer(int layer) { m_sourceLayer = layer; }

    int sourceLevel() const { return m_sourceLevel; }
    void setSourceLevel(int level) { m_sourceLevel = level; }

    QPoint sourceTopLeft() const { return m_sourceTopLeft; }
    void setSourceTopLeft(const QPoint &p) { m_sourceTopLeft = p; }

    int destinationLayer() const { return m_destinationLayer; }
    void setDestinationLayer(int layer) { m_destinationLayer = layer; }
514

515 516 517 518 519 520 521 522 523 524 525 526 527 528
    int destinationLevel() const { return m_destinationLevel; }
    void setDestinationLevel(int level) { m_destinationLevel = level; }

    QPoint destinationTopLeft() const { return m_destinationTopLeft; }
    void setDestinationTopLeft(const QPoint &p) { m_destinationTopLeft = p; }

private:
    QSize m_pixelSize;
    int m_sourceLayer = 0;
    int m_sourceLevel = 0;
    QPoint m_sourceTopLeft;
    int m_destinationLayer = 0;
    int m_destinationLevel = 0;
    QPoint m_destinationTopLeft;
529
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
530 531 532 533
};

Q_DECLARE_TYPEINFO(QRhiTextureCopyDescription, Q_MOVABLE_TYPE);

534
class Q_RHI_EXPORT QRhiReadbackDescription
Laszlo Agocs's avatar
Laszlo Agocs committed
535
{
536
public:
Laszlo Agocs's avatar
Laszlo Agocs committed
537 538
    QRhiReadbackDescription();
    QRhiReadbackDescription(QRhiTexture *texture);
539 540 541 542 543 544

    QRhiTexture *texture() const { return m_texture; }
    void setTexture(QRhiTexture *tex) { m_texture = tex; }

    int layer() const { return m_layer; }
    void setLayer(int layer) { m_layer = layer; }
545

546 547 548 549 550 551 552
    int level() const { return m_level; }
    void setLevel(int level) { m_level = level; }

private:
    QRhiTexture *m_texture = nullptr;
    int m_layer = 0;
    int m_level = 0;
553
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
Laszlo Agocs's avatar
Laszlo Agocs committed
554 555
};

556 557
Q_DECLARE_TYPEINFO(QRhiReadbackDescription, Q_MOVABLE_TYPE);

558 559 560 561
struct Q_RHI_EXPORT QRhiNativeHandles
{
};

562 563 564 565
class Q_RHI_EXPORT QRhiResource
{
public:
    virtual ~QRhiResource();
566

567 568
    virtual void release() = 0;
    void releaseAndDestroy();
569
    void releaseAndDestroyLater();
570

571 572 573
    QByteArray name() const;
    void setName(const QByteArray &name);

574 575
    quint64 globalResourceId() const;

576
protected:
577
    QRhiResource(QRhiImplementation *rhi);
578
    Q_DISABLE_COPY(QRhiResource)
Laszlo Agocs's avatar
Laszlo Agocs committed
579
    friend class QRhiImplementation;
580 581 582
    QRhiImplementation *m_rhi = nullptr;
    quint64 m_id;
    QByteArray m_objectName;
Laszlo Agocs's avatar
Laszlo Agocs committed
583
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
584 585 586 587 588 589
};

class Q_RHI_EXPORT QRhiBuffer : public QRhiResource
{
public:
    enum Type {
590 591 592
        Immutable,
        Static,
        Dynamic
593 594 595 596 597 598 599 600 601
    };

    enum UsageFlag {
        VertexBuffer = 1 << 0,
        IndexBuffer = 1 << 1,
        UniformBuffer = 1 << 2
    };
    Q_DECLARE_FLAGS(UsageFlags, UsageFlag)

Laszlo Agocs's avatar
Laszlo Agocs committed
602 603 604 605 606 607 608 609
    Type type() const { return m_type; }
    void setType(Type t) { m_type = t; }

    UsageFlags usage() const { return m_usage; }
    void setUsage(UsageFlags u) { m_usage = u; }

    int size() const { return m_size; }
    void setSize(int sz) { m_size = sz; }
610 611 612 613 614

    virtual bool build() = 0;

protected:
    QRhiBuffer(QRhiImplementation *rhi, Type type_, UsageFlags usage_, int size_);
Laszlo Agocs's avatar
Laszlo Agocs committed
615 616
    Type m_type;
    UsageFlags m_usage;
617
    int m_size;
618
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
619 620 621 622 623 624 625 626 627
};

Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiBuffer::UsageFlags)

class Q_RHI_EXPORT QRhiTexture : public QRhiResource
{
public:
    enum Flag {
        RenderTarget = 1 << 0,
628
        ChangesFrequently = 1 << 1,
629
        CubeMap = 1 << 2,
630
        MipMapped = 1 << 3,
631
        sRGB = 1 << 4,
632
        UsedAsTransferSource = 1 << 5,
633
        UsedWithGenerateMips = 1 << 6
634 635 636 637
    };
    Q_DECLARE_FLAGS(Flags, Flag)

    enum Format {
638 639
        UnknownFormat,

640 641 642 643
        RGBA8,
        BGRA8,
        R8,
        R16,
644
        RED_OR_ALPHA8,
645

646 647 648
        RGBA16F,
        RGBA32F,

649
        D16,
Laszlo Agocs's avatar
Laszlo Agocs committed
650
        D32F,
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677

        BC1,
        BC2,
        BC3,
        BC4,
        BC5,
        BC6H,
        BC7,

        ETC2_RGB8,
        ETC2_RGB8A1,
        ETC2_RGBA8,

        ASTC_4x4,
        ASTC_5x4,
        ASTC_5x5,
        ASTC_6x5,
        ASTC_6x6,
        ASTC_8x5,
        ASTC_8x6,
        ASTC_8x8,
        ASTC_10x5,
        ASTC_10x6,
        ASTC_10x8,
        ASTC_10x10,
        ASTC_12x10,
        ASTC_12x12
678 679
    };

Laszlo Agocs's avatar
Laszlo Agocs committed
680 681 682 683 684 685 686 687
    Format format() const { return m_format; }
    void setFormat(Format fmt) { m_format = fmt; }

    QSize pixelSize() const { return m_pixelSize; }
    void setPixelSize(const QSize &sz) { m_pixelSize = sz; }

    Flags flags() const { return m_flags; }
    void setFlags(Flags f) { m_flags = f; }
688

Laszlo Agocs's avatar
Laszlo Agocs committed
689 690 691
    int sampleCount() const { return m_sampleCount; }
    void setSampleCount(int s) { m_sampleCount = s; }

692
    virtual bool build() = 0;
693 694
    virtual const QRhiNativeHandles *nativeHandles();
    virtual bool buildFrom(const QRhiNativeHandles *src);
695

696
protected:
Laszlo Agocs's avatar
Laszlo Agocs committed
697 698
    QRhiTexture(QRhiImplementation *rhi, Format format_, const QSize &pixelSize_,
                int sampleCount_, Flags flags_);
Laszlo Agocs's avatar
Laszlo Agocs committed
699 700
    Format m_format;
    QSize m_pixelSize;
Laszlo Agocs's avatar
Laszlo Agocs committed
701
    int m_sampleCount;
Laszlo Agocs's avatar
Laszlo Agocs committed
702
    Flags m_flags;
703
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
704 705 706 707 708 709 710 711
};

Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiTexture::Flags)

class Q_RHI_EXPORT QRhiSampler : public QRhiResource
{
public:
    enum Filter {
712
        None,
713 714 715 716 717 718 719 720 721 722 723 724
        Nearest,
        Linear
    };

    enum AddressMode {
        Repeat,
        ClampToEdge,
        Border,
        Mirror,
        MirrorOnce
    };

Laszlo Agocs's avatar
Laszlo Agocs committed
725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
    Filter magFilter() const { return m_magFilter; }
    void setMagFilter(Filter f) { m_magFilter = f; }

    Filter minFilter() const { return m_minFilter; }
    void setMinFilter(Filter f) { m_minFilter = f; }

    Filter mipmapMode() const { return m_mipmapMode; }
    void setMipmapMode(Filter f) { m_mipmapMode = f; }

    AddressMode addressU() const { return m_addressU; }
    void setAddressU(AddressMode mode) { m_addressU = mode; }

    AddressMode addressV() const { return m_addressV; }
    void setAddressV(AddressMode mode) { m_addressV = mode; }

    AddressMode addressW() const { return m_addressW; }
    void setAddressW(AddressMode mode) { m_addressW = mode; }
742 743 744 745 746 747 748

    virtual bool build() = 0;

protected:
    QRhiSampler(QRhiImplementation *rhi,
                Filter magFilter_, Filter minFilter_, Filter mipmapMode_,
                AddressMode u_, AddressMode v_, AddressMode w_);
Laszlo Agocs's avatar
Laszlo Agocs committed
749 750 751 752 753 754
    Filter m_magFilter;
    Filter m_minFilter;
    Filter m_mipmapMode;
    AddressMode m_addressU;
    AddressMode m_addressV;
    AddressMode m_addressW;
755
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
756 757
};

Laszlo Agocs's avatar
Laszlo Agocs committed
758 759 760 761 762 763 764 765 766
class Q_RHI_EXPORT QRhiRenderBuffer : public QRhiResource
{
public:
    enum Type {
        DepthStencil,
        Color
    };

    enum Flag {
767
        UsedWithSwapChainOnly = 1 << 0
Laszlo Agocs's avatar
Laszlo Agocs committed
768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793
    };
    Q_DECLARE_FLAGS(Flags, Flag)

    Type type() const { return m_type; }
    void setType(Type t) { m_type = t; }

    QSize pixelSize() const { return m_pixelSize; }
    void setPixelSize(const QSize &sz) { m_pixelSize = sz; }

    int sampleCount() const { return m_sampleCount; }
    void setSampleCount(int s) { m_sampleCount = s; }

    Flags flags() const { return m_flags; }
    void setFlags(Flags h) { m_flags = h; }

    virtual bool build() = 0;

    virtual QRhiTexture::Format backingFormat() const = 0;

protected:
    QRhiRenderBuffer(QRhiImplementation *rhi, Type type_, const QSize &pixelSize_,
                     int sampleCount_, Flags flags_);
    Type m_type;
    QSize m_pixelSize;
    int m_sampleCount;
    Flags m_flags;
794
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
Laszlo Agocs's avatar
Laszlo Agocs committed
795 796 797 798
};

Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiRenderBuffer::Flags)

799
class Q_RHI_EXPORT QRhiRenderPassDescriptor : public QRhiResource
800 801
{
protected:
802
    QRhiRenderPassDescriptor(QRhiImplementation *rhi);
803
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
804 805 806 807 808 809 810 811 812 813 814 815
};

class Q_RHI_EXPORT QRhiRenderTarget : public QRhiResource
{
public:
    enum Type {
        RtRef,
        RtTexture
    };

    virtual Type type() const = 0;
    virtual QSize sizeInPixels() const = 0;
Laszlo Agocs's avatar
Laszlo Agocs committed
816
    virtual float devicePixelRatio() const = 0;
817
    virtual int sampleCount() const = 0;
818

819 820
    QRhiRenderPassDescriptor *renderPassDescriptor() const { return m_renderPassDesc; }
    void setRenderPassDescriptor(QRhiRenderPassDescriptor *desc) { m_renderPassDesc = desc; }
821 822 823

protected:
    QRhiRenderTarget(QRhiImplementation *rhi);
824
    QRhiRenderPassDescriptor *m_renderPassDesc = nullptr;
825
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
826 827 828 829 830 831
};

class Q_RHI_EXPORT QRhiTextureRenderTarget : public QRhiRenderTarget
{
public:
    enum Flag {
832 833
        PreserveColorContents = 1 << 0,
        PreserveDepthStencilContents = 1 << 1
834 835 836
    };
    Q_DECLARE_FLAGS(Flags, Flag)

Laszlo Agocs's avatar
Laszlo Agocs committed
837 838
    QRhiTextureRenderTargetDescription description() const { return m_desc; }
    void setDescription(const QRhiTextureRenderTargetDescription &desc) { m_desc = desc; }
839

Laszlo Agocs's avatar
Laszlo Agocs committed
840 841 842
    Flags flags() const { return m_flags; }
    void setFlags(Flags f) { m_flags = f; }

843
    virtual QRhiRenderPassDescriptor *newCompatibleRenderPassDescriptor() = 0;
Laszlo Agocs's avatar
Laszlo Agocs committed
844

845 846 847 848
    virtual bool build() = 0;

protected:
    QRhiTextureRenderTarget(QRhiImplementation *rhi, const QRhiTextureRenderTargetDescription &desc_, Flags flags_);
Laszlo Agocs's avatar
Laszlo Agocs committed
849 850
    QRhiTextureRenderTargetDescription m_desc;
    Flags m_flags;
851 852 853 854 855 856 857
};

Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiTextureRenderTarget::Flags)

class Q_RHI_EXPORT QRhiShaderResourceBindings : public QRhiResource
{
public:
Laszlo Agocs's avatar
Laszlo Agocs committed
858 859
    QVector<QRhiShaderResourceBinding> bindings() const { return m_bindings; }
    void setBindings(const QVector<QRhiShaderResourceBinding> &b) { m_bindings = b; }
860

861 862
    bool isLayoutCompatible(const QRhiShaderResourceBindings *other) const;

863 864 865 866
    virtual bool build() = 0;

protected:
    QRhiShaderResourceBindings(QRhiImplementation *rhi);
Laszlo Agocs's avatar
Laszlo Agocs committed
867
    QVector<QRhiShaderResourceBinding> m_bindings;
868
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
Laszlo Agocs's avatar
Laszlo Agocs committed
869 870 871
#ifndef QT_NO_DEBUG_STREAM
    friend Q_RHI_EXPORT QDebug operator<<(QDebug, const QRhiShaderResourceBindings &);
#endif
872 873
};

Laszlo Agocs's avatar
Laszlo Agocs committed
874 875 876 877
#ifndef QT_NO_DEBUG_STREAM
Q_RHI_EXPORT QDebug operator<<(QDebug, const QRhiShaderResourceBindings &);
#endif

878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895
class Q_RHI_EXPORT QRhiGraphicsPipeline : public QRhiResource
{
public:
    enum Flag {
        UsesBlendConstants = 1 << 0,
        UsesStencilRef = 1 << 1,
        UsesScissor = 1 << 2
    };
    Q_DECLARE_FLAGS(Flags, Flag)

    enum Topology {
        Triangles,
        TriangleStrip,
        Lines,
        LineStrip,
        Points
    };

896
    enum CullMode {
897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984
        None,
        Front,
        Back
    };

    enum FrontFace {
        CCW,
        CW
    };

    enum ColorMaskComponent {
        R = 1 << 0,
        G = 1 << 1,
        B = 1 << 2,
        A = 1 << 3
    };
    Q_DECLARE_FLAGS(ColorMask, ColorMaskComponent)

    enum BlendFactor {
        Zero,
        One,
        SrcColor,
        OneMinusSrcColor,
        DstColor,
        OneMinusDstColor,
        SrcAlpha,
        OneMinusSrcAlpha,
        DstAlpha,
        OneMinusDstAlpha,
        ConstantColor,
        OneMinusConstantColor,
        ConstantAlpha,
        OneMinusConstantAlpha,
        SrcAlphaSaturate,
        Src1Color,
        OneMinusSrc1Color,
        Src1Alpha,
        OneMinusSrc1Alpha
    };

    enum BlendOp {
        Add,
        Subtract,
        ReverseSubtract,
        Min,
        Max
    };

    struct TargetBlend {
        ColorMask colorWrite = ColorMask(0xF); // R | G | B | A
        bool enable = false;
        BlendFactor srcColor = One;
        BlendFactor dstColor = OneMinusSrcAlpha;
        BlendOp opColor = Add;
        BlendFactor srcAlpha = One;
        BlendFactor dstAlpha = OneMinusSrcAlpha;
        BlendOp opAlpha = Add;
    };

    enum CompareOp {
        Never,
        Less,
        Equal,
        LessOrEqual,
        Greater,
        NotEqual,
        GreaterOrEqual,
        Always
    };

    enum StencilOp {
        StencilZero,
        Keep,
        Replace,
        IncrementAndClamp,
        DecrementAndClamp,
        Invert,
        IncrementAndWrap,
        DecrementAndWrap
    };

    struct StencilOpState {
        StencilOp failOp = Keep;
        StencilOp depthFailOp = Keep;
        StencilOp passOp = Keep;
        CompareOp compareOp = Always;
    };

Laszlo Agocs's avatar
Laszlo Agocs committed
985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
    Flags flags() const { return m_flags; }
    void setFlags(Flags f) { m_flags = f; }

    Topology topology() const { return m_topology; }
    void setTopology(Topology t) { m_topology = t; }

    CullMode cullMode() const { return m_cullMode; }
    void setCullMode(CullMode mode) { m_cullMode = mode; }

    FrontFace frontFace() const { return m_frontFace; }
    void setFrontFace(FrontFace f) { m_frontFace = f; }

    QVector<TargetBlend> targetBlends() const { return m_targetBlends; }
    void setTargetBlends(const QVector<TargetBlend> &blends) { m_targetBlends = blends; }

    bool hasDepthTest() const { return m_depthTest; }
    void setDepthTest(bool enable) { m_depthTest = enable; }

    bool hasDepthWrite() const { return m_depthWrite; }
    void setDepthWrite(bool enable) { m_depthWrite = enable; }

    CompareOp depthOp() const { return m_depthOp; }
    void setDepthOp(CompareOp op) { m_depthOp = op; }

    bool hasStencilTest() const { return m_stencilTest; }
    void setStencilTest(bool enable) { m_stencilTest = enable; }

    StencilOpState stencilFront() const { return m_stencilFront; }
    void setStencilFront(const StencilOpState &state) { m_stencilFront = state; }

    StencilOpState stencilBack() const { return m_stencilBack; }
    void setStencilBack(const StencilOpState &state) { m_stencilBack = state; }

    quint32 stencilReadMask() const { return m_stencilReadMask; }
    void setStencilReadMask(quint32 mask) { m_stencilReadMask = mask; }

    quint32 stencilWriteMask() const { return m_stencilWriteMask; }
    void setStencilWriteMask(quint32 mask) { m_stencilWriteMask = mask; }

    int sampleCount() const { return m_sampleCount; }
    void setSampleCount(int s) { m_sampleCount = s; }

    QVector<QRhiGraphicsShaderStage> shaderStages() const { return m_shaderStages; }
    void setShaderStages(const QVector<QRhiGraphicsShaderStage> &stages) { m_shaderStages = stages; }

    QRhiVertexInputLayout vertexInputLayout() const { return m_vertexInputLayout; }
    void setVertexInputLayout(const QRhiVertexInputLayout &layout) { m_vertexInputLayout = layout; }

    QRhiShaderResourceBindings *shaderResourceBindings() const { return m_shaderResourceBindings; }
    void setShaderResourceBindings(QRhiShaderResourceBindings *srb) { m_shaderResourceBindings = srb; }

1036 1037
    QRhiRenderPassDescriptor *renderPassDescriptor() const { return m_renderPassDesc; }
    void setRenderPassDescriptor(QRhiRenderPassDescriptor *desc) { m_renderPassDesc = desc; }
1038 1039 1040 1041 1042

    virtual bool build() = 0;

protected:
    QRhiGraphicsPipeline(QRhiImplementation *rhi);
Laszlo Agocs's avatar
Laszlo Agocs committed
1043 1044 1045 1046
    Flags m_flags;
    Topology m_topology = Triangles;
    CullMode m_cullMode = None;
    FrontFace m_frontFace = CCW;
1047
    QVector<TargetBlend> m_targetBlends;
Laszlo Agocs's avatar
Laszlo Agocs committed
1048 1049 1050 1051 1052 1053
    bool m_depthTest = false;
    bool m_depthWrite = false;
    CompareOp m_depthOp = Less;
    bool m_stencilTest = false;
    StencilOpState m_stencilFront;
    StencilOpState m_stencilBack;
1054 1055 1056
    quint32 m_stencilReadMask = 0xFF;
    quint32 m_stencilWriteMask = 0xFF;
    int m_sampleCount = 1;
Laszlo Agocs's avatar
Laszlo Agocs committed
1057 1058
    QVector<QRhiGraphicsShaderStage> m_shaderStages;
    QRhiVertexInputLayout m_vertexInputLayout;
1059
    QRhiShaderResourceBindings *m_shaderResourceBindings = nullptr;
1060
    QRhiRenderPassDescriptor *m_renderPassDesc = nullptr;
1061
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
1062 1063 1064 1065 1066 1067 1068 1069 1070
};

Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiGraphicsPipeline::Flags)
Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiGraphicsPipeline::ColorMask)
Q_DECLARE_TYPEINFO(QRhiGraphicsPipeline::TargetBlend, Q_MOVABLE_TYPE);

class Q_RHI_EXPORT QRhiSwapChain : public QRhiResource
{
public:
1071
    enum Flag {
1072
        SurfaceHasPreMulAlpha = 1 << 0,
1073
        SurfaceHasNonPreMulAlpha = 1 << 1,
1074
        sRGB = 1 << 2,
1075 1076
        UsedAsTransferSource = 1 << 3,
        NoVSync = 1 << 4
1077
    };
1078
    Q_DECLARE_FLAGS(Flags, Flag)
1079

Laszlo Agocs's avatar
Laszlo Agocs committed
1080 1081 1082
    QWindow *window() const { return m_window; }
    void setWindow(QWindow *window) { m_window = window; }

1083 1084
    Flags flags() const { return m_flags; }
    void setFlags(Flags f) { m_flags = f; }
Laszlo Agocs's avatar
Laszlo Agocs committed
1085 1086 1087 1088 1089 1090 1091

    QRhiRenderBuffer *depthStencil() const { return m_depthStencil; }
    void setDepthStencil(QRhiRenderBuffer *ds) { m_depthStencil = ds; }

    int sampleCount() const { return m_sampleCount; }
    void setSampleCount(int samples) { m_sampleCount = samples; }

1092 1093
    QRhiRenderPassDescriptor *renderPassDescriptor() const { return m_renderPassDesc; }
    void setRenderPassDescriptor(QRhiRenderPassDescriptor *desc) { m_renderPassDesc = desc; }
1094

Laszlo Agocs's avatar
Laszlo Agocs committed
1095 1096 1097
    QObject *target() const { return m_target; }
    void setTarget(QObject *obj) { m_target = obj; }

1098 1099
    QSize currentPixelSize() const { return m_currentPixelSize; }

1100 1101
    virtual QRhiCommandBuffer *currentFrameCommandBuffer() = 0;
    virtual QRhiRenderTarget *currentFrameRenderTarget() = 0;
1102
    virtual QSize surfacePixelSize() = 0;
1103
    virtual QRhiRenderPassDescriptor *newCompatibleRenderPassDescriptor() = 0;
Laszlo Agocs's avatar
Laszlo Agocs committed
1104
    virtual bool buildOrResize() = 0;
1105 1106 1107

protected:
    QRhiSwapChain(QRhiImplementation *rhi);
Laszlo Agocs's avatar
Laszlo Agocs committed
1108
    QWindow *m_window = nullptr;
1109
    Flags m_flags;
Laszlo Agocs's avatar
Laszlo Agocs committed
1110 1111
    QRhiRenderBuffer *m_depthStencil = nullptr;
    int m_sampleCount = 1;
1112
    QRhiRenderPassDescriptor *m_renderPassDesc = nullptr;
Laszlo Agocs's avatar
Laszlo Agocs committed
1113
    QObject *m_target = nullptr;
1114
    QSize m_currentPixelSize;
1115
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
1116 1117
};

1118
Q_DECLARE_OPERATORS_FOR_FLAGS(QRhiSwapChain::Flags)
1119

1120 1121 1122 1123 1124 1125 1126 1127
class Q_RHI_EXPORT QRhiCommandBuffer : public QRhiResource
{
public:
    enum IndexFormat {
        IndexUInt16,
        IndexUInt32
    };

1128 1129
    void resourceUpdate(QRhiResourceUpdateBatch *resourceUpdates);

1130
    void beginPass(QRhiRenderTarget *rt,
1131 1132
                   const QRhiColorClearValue &colorClearValue,
                   const QRhiDepthStencilClearValue &depthStencilClearValue,
1133
                   QRhiResourceUpdateBatch *resourceUpdates = nullptr);
1134
    void endPass(QRhiResourceUpdateBatch *resourceUpdates = nullptr);
1135

1136 1137 1138 1139
    void setGraphicsPipeline(QRhiGraphicsPipeline *ps);
    using DynamicOffset = QPair<int, quint32>; // binding, offset
    void setShaderResources(QRhiShaderResourceBindings *srb = nullptr,
                            const QVector<DynamicOffset> &dynamicOffsets = QVector<DynamicOffset>());
1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160
    using VertexInput = QPair<QRhiBuffer *, quint32>; // buffer, offset
    void setVertexInput(int startBinding, const QVector<VertexInput> &bindings,
                        QRhiBuffer *indexBuf = nullptr, quint32 indexOffset = 0,
                        IndexFormat indexFormat = IndexUInt16);

    void setViewport(const QRhiViewport &viewport);
    void setScissor(const QRhiScissor &scissor);
    void setBlendConstants(const QVector4D &c);
    void setStencilRef(quint32 refValue);

    void draw(quint32 vertexCount,
              quint32 instanceCount = 1,
              quint32 firstVertex = 0,
              quint32 firstInstance = 0);

    void drawIndexed(quint32 indexCount,
                     quint32 instanceCount = 1,
                     quint32 firstIndex = 0,
                     qint32 vertexOffset = 0,
                     quint32 firstInstance = 0);

1161 1162 1163 1164
    void debugMarkBegin(const QByteArray &name);
    void debugMarkEnd();
    void debugMarkMsg(const QByteArray &msg);

1165 1166
protected:
    QRhiCommandBuffer(QRhiImplementation *rhi);
1167
    Q_DECL_UNUSED_MEMBER quint64 m_reserved;
1168 1169 1170 1171 1172 1173 1174 1175 1176
};

struct Q_RHI_EXPORT QRhiReadbackResult
{
    std::function<void()> completed = nullptr;
    QRhiTexture::Format format;
    QSize pixelSize;
    QByteArray data;
}; // non-movable due to the std::function
1177

1178
class Q_RHI_EXPORT QRhiResourceUpdateBatch
1179 1180 1181
{
public:
    ~QRhiResourceUpdateBatch();
1182

1183 1184
    void release();

1185 1186
    void merge(QRhiResourceUpdateBatch *other);

1187
    void updateDynamicBuffer(QRhiBuffer *buf, int offset, int size, const void *data);
1188
    void uploadStaticBuffer(QRhiBuffer *buf, int offset, int size, const void *data);
1189
    void uploadStaticBuffer(QRhiBuffer *buf, const void *data);
Laszlo Agocs's avatar
Laszlo Agocs committed
1190
    void uploadTexture(QRhiTexture *tex, const QRhiTextureUploadDescription &desc);
1191
    void uploadTexture(QRhiTexture *tex, const QImage &image);
1192
    void copyTexture(QRhiTexture *dst, QRhiTexture *src, const QRhiTextureCopyDescription &desc = QRhiTextureCopyDescription());
1193
    void readBackTexture(const QRhiReadbackDescription &rb, QRhiReadbackResult *result);
1194
    void generateMips(QRhiTexture *tex);
1195 1196 1197 1198 1199

private:
    QRhiResourceUpdateBatch(QRhiImplementation *rhi);
    Q_DISABLE_COPY(QRhiResourceUpdateBatch)
    QRhiResourceUpdateBatchPrivate *d;
1200
    friend class QRhiResourceUpdateBatchPrivate;
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211
    friend class QRhi;
};

struct Q_RHI_EXPORT QRhiInitParams
{
};

class Q_RHI_EXPORT QRhi
{
public:
    enum Implementation {
Laszlo Agocs's avatar
Laszlo Agocs committed
1212
        Null,
1213 1214 1215 1216 1217 1218
        Vulkan,
        OpenGLES2,
        D3D11,
        Metal
    };

1219
    enum Flag {
1220 1221
        EnableProfiling = 1 << 0,
        EnableDebugMarkers = 1 << 1
1222 1223 1224
    };
    Q_DECLARE_FLAGS(Flags, Flag)

1225 1226 1227 1228 1229 1230 1231
    enum FrameOpResult {
        FrameOpSuccess = 0,
        FrameOpError,
        FrameOpSwapChainOutOfDate,
        FrameOpDeviceLost
    };

1232 1233
    enum Feature {
        MultisampleTexture = 1,
1234
        MultisampleRenderBuffer,
1235
        DebugMarkers,
1236 1237
        Timestamps,
        Instancing,
1238
        CustomInstanceStepRate,
1239 1240
        PrimitiveRestart,
        GeometryShaders,
1241
        TessellationShaders,
1242
        NonDynamicUniformBuffers,
1243
        NonFourAlignedEffectiveIndexBufferOffset,
1244 1245
        NPOTTextureRepeat,
        RedOrAlpha8IsRed
1246 1247
    };

1248 1249 1250 1251 1252 1253 1254 1255 1256
    enum BeginFrameFlag {
    };
    Q_DECLARE_FLAGS(BeginFrameFlags, BeginFrameFlag)

    enum EndFrameFlag {
        SkipPresent = 1 << 0
    };
    Q_DECLARE_FLAGS(EndFrameFlags, EndFrameFlag)

Laszlo Agocs's avatar
Laszlo Agocs committed
1257
    enum ResourceLimit {
1258
        TextureSizeMin = 1,
Laszlo Agocs's avatar
Laszlo Agocs committed
1259 1260
        TextureSizeMax,
        MaxColorAttachments
1261 1262
    };

1263 1264
    ~QRhi();

1265 1266 1267 1268
    static QRhi *create(Implementation impl,
                        QRhiInitParams *params,
                        Flags flags = Flags(),
                        QRhiNativeHandles *importDevice = nullptr);
1269

1270
    Implementation backend() const;
1271
    QThread *thread() const;
1272

1273 1274
    QRhiGraphicsPipeline *newGraphicsPipeline();
    QRhiShaderResourceBindings *newShaderResourceBindings();
1275

1276 1277 1278
    QRhiBuffer *newBuffer(QRhiBuffer::Type type,
                          QRhiBuffer::UsageFlags usage,
                          int size);
1279

1280 1281 1282
    QRhiRenderBuffer *newRenderBuffer(QRhiRenderBuffer::Type type,
                                      const QSize &pixelSize,
                                      int sampleCount = 1,
Laszlo Agocs's avatar
Laszlo Agocs committed
1283
                                      QRhiRenderBuffer::Flags flags = QRhiRenderBuffer::Flags());
1284

1285 1286
    QRhiTexture *newTexture(QRhiTexture::Format format,
                            const QSize &pixelSize,
Laszlo Agocs's avatar
Laszlo Agocs committed
1287
                            int sampleCount = 1,
1288
                            QRhiTexture::Flags flags = QRhiTexture::Flags());
1289

1290 1291 1292
    QRhiSampler *newSampler(QRhiSampler::Filter magFilter, QRhiSampler::Filter minFilter,
                            QRhiSampler::Filter mipmapMode,
                            QRhiSampler::AddressMode u, QRhiSampler::AddressMode v, QRhiSampler::AddressMode w = QRhiSampler::ClampToEdge);
1293

1294 1295
    QRhiTextureRenderTarget *newTextureRenderTarget(const QRhiTextureRenderTargetDescription &desc,
                                                    QRhiTextureRenderTarget::Flags flags = QRhiTextureRenderTarget::Flags());
1296

1297
    QRhiSwapChain *newSwapChain();
1298 1299
    FrameOpResult beginFrame(QRhiSwapChain *swapChain, BeginFrameFlags flags = BeginFrameFlags());
    FrameOpResult endFrame(QRhiSwapChain *swapChain, EndFrameFlags flags = EndFrameFlags());
1300

1301
    FrameOpResult beginOffscreenFrame(QRhiCommandBuffer **cb);
1302 1303 1304
    FrameOpResult endOffscreenFrame();

    QRhi::FrameOpResult finish();
1305

1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316
    QRhiResourceUpdateBatch *nextResourceUpdateBatch();

    QVector<int> supportedSampleCounts() const;

    int ubufAlignment() const;
    int ubufAligned(int v) const;

    int mipLevelsForSize(const QSize &size) const;
    QSize sizeForMipLevel(int mipLevel, const QSize &baseLevelSize) const;

    bool isYUpInFramebuffer() const;
Laszlo Agocs's avatar
Laszlo Agocs committed
1317
    bool isYUpInNDC() const;
1318 1319 1320

    QMatrix4x4 clipSpaceCorrMatrix() const;

1321
    bool isTextureFormatSupported(QRhiTexture::Format format, QRhiTexture::Flags flags = QRhiTexture::Flags()) const;
1322
    bool isFeatureSupported(QRhi::Feature feature) const;
Laszlo Agocs's avatar
Laszlo Agocs committed
1323
    int resourceLimit(ResourceLimit limit) const;
1324

1325 1326
    const QRhiNativeHandles *nativeHandles();

1327
    QRhiProfiler *profiler();
1328

1329 1330 1331 1332 1333 1334 1335 1336
protected:
    QRhi();

private:
    Q_DISABLE_COPY(QRhi)
    QRhiImplementation *d = nullptr;
};

1337
Q_DECLARE_OPERATORS_FOR_FLAGS(QRhi::Flags)
1338 1339
Q_DECLARE_OPERATORS_FOR_FLAGS(QRhi::BeginFrameFlags)
Q_DECLARE_OPERATORS_FOR_FLAGS(QRhi::EndFrameFlags)
1340

1341 1342 1343
QT_END_NAMESPACE

#endif