QRhiVertexInputAttribute Class

Describes a single vertex input element. More...

Header: #include <QRhiVertexInputAttribute>
CMake: find_package(Qt6 REQUIRED COMPONENTS Gui)
target_link_libraries(mytarget PRIVATE Qt6::Gui)
qmake: QT += gui
Since: Qt 6.6

Public Types

enum Format { Float4, Float3, Float2, Float, UNormByte4, …, Half }

Public Functions

QRhiVertexInputAttribute()
QRhiVertexInputAttribute(int binding, int location, QRhiVertexInputAttribute::Format format, quint32 offset, int matrixSlice = -1)
int binding() const
QRhiVertexInputAttribute::Format format() const
int location() const
int matrixSlice() const
quint32 offset() const
void setBinding(int b)
void setFormat(QRhiVertexInputAttribute::Format f)
void setLocation(int loc)
void setMatrixSlice(int slice)
void setOffset(quint32 ofs)
size_t qHash(const QRhiVertexInputAttribute &v, size_t seed = 0)
bool operator!=(const QRhiVertexInputAttribute &a, const QRhiVertexInputAttribute &b)
bool operator==(const QRhiVertexInputAttribute &a, const QRhiVertexInputAttribute &b)

Detailed Description

The members specify the binding number, location, format, and offset for a single vertex input element.

Note: For HLSL it is assumed that the vertex shader translated from SPIR-V uses TEXCOORD<location> as the semantic for each input. Hence no separate semantic name and index.

As an example, assume a vertex shader with the following inputs:

layout(location = 0) in vec4 position;
layout(location = 1) in vec2 texcoord;

Now let's assume that we have 3 component vertex positions (x, y, z) and 2 component texture coordinates (u, v) are provided in a non-interleaved format in a buffer (or separate buffers even). Once two bindings are defined, the attributes could be specified as:

QRhiVertexInputLayout inputLayout;
inputLayout.setBindings({
    { 3 * sizeof(float) },
    { 2 * sizeof(float) }
});
inputLayout.setAttributes({
    { 0, 0, QRhiVertexInputAttribute::Float3, 0 },
    { 1, 1, QRhiVertexInputAttribute::Float2, 0 }
});

Once a graphics pipeline with this vertex input layout is bound, the vertex inputs could be set up like the following for drawing a cube with 36 vertices, assuming we have a single buffer with first the positions and then the texture coordinates:

const QRhiCommandBuffer::VertexInput vbufBindings[] = {
    { cubeBuf, 0 },
    { cubeBuf, 36 * 3 * sizeof(float) }
};
cb->setVertexInput(0, 2, vbufBindings);

When working with interleaved data, there will typically be just one binding, with multiple attributes referring to that same buffer binding point:

QRhiVertexInputLayout inputLayout;
inputLayout.setBindings({
    { 5 * sizeof(float) }
});
inputLayout.setAttributes({
    { 0, 0, QRhiVertexInputAttribute::Float3, 0 },
    { 0, 1, QRhiVertexInputAttribute::Float2, 3 * sizeof(float) }
});

and then:

const QRhiCommandBuffer::VertexInput vbufBinding(interleavedCubeBuf, 0);
cb->setVertexInput(0, 1, &vbufBinding);

Note: This is a RHI API with limited compatibility guarantees, see QRhi for details.

See also QRhiCommandBuffer::setVertexInput().

Member Type Documentation

enum QRhiVertexInputAttribute::Format

Specifies the type of the element data.

ConstantValueDescription
QRhiVertexInputAttribute::Float40Four component float vector
QRhiVertexInputAttribute::Float31Three component float vector
QRhiVertexInputAttribute::Float22Two component float vector
QRhiVertexInputAttribute::Float3Float
QRhiVertexInputAttribute::UNormByte44Four component normalized unsigned byte vector
QRhiVertexInputAttribute::UNormByte25Two component normalized unsigned byte vector
QRhiVertexInputAttribute::UNormByte6Normalized unsigned byte
QRhiVertexInputAttribute::UInt47Four component unsigned integer vector
QRhiVertexInputAttribute::UInt38Three component unsigned integer vector
QRhiVertexInputAttribute::UInt29Two component unsigned integer vector
QRhiVertexInputAttribute::UInt10Unsigned integer
QRhiVertexInputAttribute::SInt411Four component signed integer vector
QRhiVertexInputAttribute::SInt312Three component signed integer vector
QRhiVertexInputAttribute::SInt213Two component signed integer vector
QRhiVertexInputAttribute::SInt14Signed integer
QRhiVertexInputAttribute::Half415Four component half precision (16 bit) float vector
QRhiVertexInputAttribute::Half316Three component half precision (16 bit) float vector
QRhiVertexInputAttribute::Half217Two component half precision (16 bit) float vector
QRhiVertexInputAttribute::Half18Half precision (16 bit) float

Note: Support for half precision floating point attributes is indicated at run time by the QRhi::Feature::HalfAttributes feature flag. Note that Direct3D 11/12 supports half input attributes, but does not support the Half3 type. The D3D backends pass through Half3 as Half4. To ensure cross platform compatibility, Half3 inputs should be padded to 8 bytes.

Member Function Documentation

[constexpr noexcept] QRhiVertexInputAttribute::QRhiVertexInputAttribute()

Constructs a default vertex input attribute description.

QRhiVertexInputAttribute::QRhiVertexInputAttribute(int binding, int location, QRhiVertexInputAttribute::Format format, quint32 offset, int matrixSlice = -1)

Constructs a vertex input attribute description with the specified binding number, location, format, and offset.

matrixSlice should be -1 except when this attribute corresponds to a row or column of a matrix (for example, a 4x4 matrix becomes 4 vec4s, consuming 4 consecutive vertex input locations), in which case it is the index of the row or column. location - matrixSlice must always be equal to the location for the first row or column of the unrolled matrix.

int QRhiVertexInputAttribute::binding() const

Returns the binding point index.

See also setBinding().

QRhiVertexInputAttribute::Format QRhiVertexInputAttribute::format() const

Returns the format of the vertex input element.

See also setFormat().

int QRhiVertexInputAttribute::location() const

Returns the location of the vertex input element.

See also setLocation().

int QRhiVertexInputAttribute::matrixSlice() const

Returns the matrix slice if the input element corresponds to a row or column of a matrix, or -1 if not relevant.

See also setMatrixSlice().

quint32 QRhiVertexInputAttribute::offset() const

Returns the byte offset for the input element.

See also setOffset().

void QRhiVertexInputAttribute::setBinding(int b)

Sets the binding point index to b. By default this is set to 0.

See also binding().

void QRhiVertexInputAttribute::setFormat(QRhiVertexInputAttribute::Format f)

Sets the format of the vertex input element to f. By default this is set to Float4.

See also format().

void QRhiVertexInputAttribute::setLocation(int loc)

Sets the location of the vertex input element to loc. By default this is set to 0.

See also location().

void QRhiVertexInputAttribute::setMatrixSlice(int slice)

Sets the matrix slice. By default this is set to -1, and should be set to a >= 0 value only when this attribute corresponds to a row or column of a matrix (for example, a 4x4 matrix becomes 4 vec4s, consuming 4 consecutive vertex input locations), in which case it is the index of the row or column. location - matrixSlice must always be equal to the location for the first row or column of the unrolled matrix.

See also matrixSlice().

void QRhiVertexInputAttribute::setOffset(quint32 ofs)

Sets the byte offset for the input element to ofs.

See also offset().

Related Non-Members

[noexcept] size_t qHash(const QRhiVertexInputAttribute &v, size_t seed = 0)

Returns the hash value for v, using seed to seed the calculation.

[noexcept] bool operator!=(const QRhiVertexInputAttribute &a, const QRhiVertexInputAttribute &b)

Returns false if the values in the two QRhiVertexInputAttribute objects a and b are equal; otherwise returns true.

[noexcept] bool operator==(const QRhiVertexInputAttribute &a, const QRhiVertexInputAttribute &b)

Returns true if the values in the two QRhiVertexInputAttribute objects a and b are equal.

© 2024 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.