qt 6.5.1 original

tests/manual/rhi/tessellation/CMakeLists.txt

@@ -0,0 +1,25 @@
+# Copyright (C) 2022 The Qt Company Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+
+qt_internal_add_manual_test(tessellation
+    GUI
+    SOURCES
+        tessellation.cpp
+    LIBRARIES
+        Qt::Gui
+        Qt::GuiPrivate
+)
+
+set(tessellation_resource_files
+    "test.vert.qsb"
+    "test.tesc.qsb"
+    "test.tese.qsb"
+    "test.frag.qsb"
+)
+
+qt_internal_add_resource(tessellation "tessellation"
+    PREFIX
+        "/"
+    FILES
+        ${tessellation_resource_files}
+)

tests/manual/rhi/tessellation/buildshaders.bat

@@ -0,0 +1,6 @@
+qsb --glsl 320es,410 --hlsl 50 --msl 12 --msltess test.vert -o test.vert.qsb
+qsb --glsl 320es,410 --msl 12 --tess-mode triangles test.tesc -o test.tesc.qsb
+qsb -r hlsl,50,test_hull.hlsl test.tesc.qsb
+qsb --glsl 320es,410 --msl 12  --tess-vertex-count 3 test.tese -o test.tese.qsb
+qsb -r hlsl,50,test_domain.hlsl test.tese.qsb
+qsb --glsl 320es,410 --hlsl 50 --msl 12 test.frag -o test.frag.qsb

tests/manual/rhi/tessellation/tessellation.cpp

@@ -0,0 +1,129 @@
+// Copyright (C) 2021 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause
+
+#include "../shared/examplefw.h"
+
+static const float tri[] = {
+    0.0f, 0.5f, 0.0f,     0.0f, 0.0f, 1.0f,
+    -0.5f, -0.5f, 0.0f,   1.0f, 0.0f, 0.0f,
+    0.5f, -0.5f, 0.0f,    0.0f, 1.0f, 0.0f,
+};
+
+static const bool INDEXED = false;
+static const quint32 indices[] = { 0, 1, 2 };
+
+struct {
+    QVector<QRhiResource *> releasePool;
+    QRhiBuffer *vbuf = nullptr;
+    QRhiBuffer *ibuf = nullptr;
+    QRhiBuffer *ubuf = nullptr;
+    QRhiShaderResourceBindings *srb = nullptr;
+    QRhiGraphicsPipeline *ps = nullptr;
+    QRhiResourceUpdateBatch *initialUpdates = nullptr;
+    QMatrix4x4 winProj;
+    float time = 0.0f;
+} d;
+
+void Window::customInit()
+{
+    if (!m_r->isFeatureSupported(QRhi::Tessellation))
+        qFatal("Tessellation is not supported");
+
+    d.vbuf = m_r->newBuffer(QRhiBuffer::Immutable, QRhiBuffer::VertexBuffer, sizeof(tri));
+    d.vbuf->create();
+    d.releasePool << d.vbuf;
+
+    if (INDEXED) {
+        d.ibuf = m_r->newBuffer(QRhiBuffer::Immutable, QRhiBuffer::IndexBuffer, sizeof(indices));
+        d.ibuf->create();
+        d.releasePool << d.ibuf;
+    }
+
+    d.ubuf = m_r->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, 64 + 4 + 4);
+    d.ubuf->create();
+    d.releasePool << d.ubuf;
+
+    d.srb = m_r->newShaderResourceBindings();
+    d.releasePool << d.srb;
+    const QRhiShaderResourceBinding::StageFlags tese = QRhiShaderResourceBinding::TessellationEvaluationStage;
+    d.srb->setBindings({ QRhiShaderResourceBinding::uniformBuffer(0, tese, d.ubuf) });
+    d.srb->create();
+
+    d.ps = m_r->newGraphicsPipeline();
+    d.releasePool << d.ps;
+
+    d.ps->setTopology(QRhiGraphicsPipeline::Patches);
+    d.ps->setPatchControlPointCount(3);
+
+    d.ps->setShaderStages({
+        { QRhiShaderStage::Vertex, getShader(QLatin1String(":/test.vert.qsb")) },
+        { QRhiShaderStage::TessellationControl, getShader(QLatin1String(":/test.tesc.qsb")) },
+        { QRhiShaderStage::TessellationEvaluation, getShader(QLatin1String(":/test.tese.qsb")) },
+        { QRhiShaderStage::Fragment, getShader(QLatin1String(":/test.frag.qsb")) }
+    });
+
+    d.ps->setCullMode(QRhiGraphicsPipeline::Back);
+    d.ps->setPolygonMode(QRhiGraphicsPipeline::Line);
+    d.ps->setDepthTest(true);
+    d.ps->setDepthWrite(true);
+    QRhiVertexInputLayout inputLayout;
+    inputLayout.setBindings({
+        { 6 * sizeof(float) }
+    });
+    inputLayout.setAttributes({
+        { 0, 0, QRhiVertexInputAttribute::Float3, 0 },
+        { 0, 1, QRhiVertexInputAttribute::Float3, 3 * sizeof(float) }
+    });
+    d.ps->setVertexInputLayout(inputLayout);
+    d.ps->setShaderResourceBindings(d.srb);
+    d.ps->setRenderPassDescriptor(m_rp);
+    d.ps->create();
+
+    d.initialUpdates = m_r->nextResourceUpdateBatch();
+    d.initialUpdates->uploadStaticBuffer(d.vbuf, tri);
+
+    const float amplitude = 0.5f;
+    d.initialUpdates->updateDynamicBuffer(d.ubuf, 68, 4, &amplitude);
+
+    if (INDEXED)
+        d.initialUpdates->uploadStaticBuffer(d.ibuf, indices);
+}
+
+void Window::customRelease()
+{
+    qDeleteAll(d.releasePool);
+    d.releasePool.clear();
+}
+
+void Window::customRender()
+{
+    const QSize outputSizeInPixels = m_sc->currentPixelSize();
+    QRhiCommandBuffer *cb = m_sc->currentFrameCommandBuffer();
+    QRhiResourceUpdateBatch *u = m_r->nextResourceUpdateBatch();
+    if (d.initialUpdates) {
+        u->merge(d.initialUpdates);
+        d.initialUpdates->release();
+        d.initialUpdates = nullptr;
+    }
+    if (d.winProj != m_proj) {
+        d.winProj = m_proj;
+        u->updateDynamicBuffer(d.ubuf, 0, 64, d.winProj.constData());
+    }
+    u->updateDynamicBuffer(d.ubuf, 64, 4, &d.time);
+    d.time += 0.01f;
+
+    cb->beginPass(m_sc->currentFrameRenderTarget(), m_clearColor, { 1.0f, 0 }, u);
+    cb->setGraphicsPipeline(d.ps);
+    cb->setViewport({ 0, 0, float(outputSizeInPixels.width()), float(outputSizeInPixels.height()) });
+    cb->setShaderResources();
+    QRhiCommandBuffer::VertexInput vbufBinding(d.vbuf, 0);
+    if (INDEXED) {
+        cb->setVertexInput(0, 1, &vbufBinding, d.ibuf, 0, QRhiCommandBuffer::IndexUInt32);
+        cb->drawIndexed(3);
+    } else {
+        cb->setVertexInput(0, 1, &vbufBinding);
+        cb->draw(3);
+    }
+
+    cb->endPass();
+}

tests/manual/rhi/tessellation/test.frag

@@ -0,0 +1,10 @@
+#version 440
+
+layout(location = 0) in vec3 v_color;
+
+layout(location = 0) out vec4 fragColor;
+
+void main()
+{
+    fragColor = vec4(v_color, 1.0);
+}

tests/manual/rhi/tessellation/test.tesc

@@ -0,0 +1,27 @@
+#version 440
+
+layout(vertices = 3) out;
+
+layout(location = 0) in vec3 inColor[];
+
+layout(location = 0) out vec3 outColor[];
+
+// these serve no purpose, just exist to test per-patch outputs
+layout(location = 1) patch out vec3 stuff;
+layout(location = 2) patch out float more_stuff;
+
+void main()
+{
+    if (gl_InvocationID == 0) {
+        gl_TessLevelOuter[0] = 4.0;
+        gl_TessLevelOuter[1] = 4.0;
+        gl_TessLevelOuter[2] = 4.0;
+
+        gl_TessLevelInner[0] = 4.0;
+    }
+
+    gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;
+    outColor[gl_InvocationID] = inColor[gl_InvocationID];
+    stuff = vec3(1.0);
+    more_stuff = 1.0;
+}

tests/manual/rhi/tessellation/test.tese

@@ -0,0 +1,27 @@
+#version 440
+
+layout(triangles, fractional_odd_spacing, ccw) in;
+
+layout(location = 0) in vec3 inColor[];
+
+layout(location = 0) out vec3 outColor;
+
+// these serve no purpose, just exist to test per-patch outputs
+layout(location = 1) patch in vec3 stuff;
+layout(location = 2) patch in float more_stuff;
+
+layout(std140, binding = 0) uniform buf {
+    mat4 mvp;
+    float time;
+    float amplitude;
+};
+
+void main()
+{
+    vec4 pos = (gl_TessCoord.x * gl_in[0].gl_Position) + (gl_TessCoord.y * gl_in[1].gl_Position) + (gl_TessCoord.z * gl_in[2].gl_Position);
+    gl_Position = mvp * pos;
+    gl_Position.x += sin(time + pos.y) * amplitude;
+    outColor = gl_TessCoord.x * inColor[0] + gl_TessCoord.y * inColor[1] + gl_TessCoord.z * inColor[2]
+    // these are all 1.0, just here to exercise the shader generation and the runtime pipeline setup
+        * stuff.x * more_stuff * (gl_TessLevelOuter[0] / 4.0) * (gl_TessLevelInner[0] / 4.0);
+}

tests/manual/rhi/tessellation/test.vert

@@ -0,0 +1,12 @@
+#version 440
+
+layout(location = 0) in vec3 position;
+layout(location = 1) in vec3 color;
+
+layout(location = 0) out vec3 v_color;
+
+void main()
+{
+    gl_Position = vec4(position, 1.0);
+    v_color = color;
+}

tests/manual/rhi/tessellation/test_domain.hlsl

@@ -0,0 +1,38 @@
+struct Input
+{
+    float edges[3] : SV_TessFactor;
+    float inside : SV_InsideTessFactor;
+};
+
+struct PatchInput
+{
+    float3 position : POSITION;
+    float3 color : COLOR;
+};
+
+struct PixelInput
+{
+    float3 color : TEXCOORD0;
+    float4 position : SV_POSITION;
+};
+
+cbuffer buf : register(b0)
+{
+    row_major float4x4 mvp : packoffset(c0);
+    float time : packoffset(c4);
+    float amplitude : packoffset(c4.y);
+};
+
+[domain("tri")]
+PixelInput main(Input input, float3 uvwCoord : SV_DomainLocation, const OutputPatch<PatchInput, 3> patch)
+{
+    PixelInput output;
+
+    float3 vertexPosition = uvwCoord.x * patch[0].position + uvwCoord.y * patch[1].position + uvwCoord.z * patch[2].position;
+    output.position = mul(float4(vertexPosition, 1.0f), mvp);
+    output.position.x += sin(time + vertexPosition.y) * amplitude;
+
+    output.color = uvwCoord.x * patch[0].color + uvwCoord.y * patch[1].color + uvwCoord.z * patch[2].color;
+
+    return output;
+}

tests/manual/rhi/tessellation/test_hull.hlsl

@@ -0,0 +1,40 @@
+struct Input
+{
+    float3 color : TEXCOORD0;
+    float4 position : SV_Position;
+};
+
+struct Output
+{
+    float3 position : POSITION;
+    float3 color : COLOR;
+};
+
+struct ConstantData
+{
+    float edges[3] : SV_TessFactor;
+    float inside : SV_InsideTessFactor;
+};
+
+ConstantData patchConstFunc(InputPatch<Input, 3> ip, uint PatchID : SV_PrimitiveID )
+{
+    ConstantData d;
+    d.edges[0] = 4.0;
+    d.edges[1] = 4.0;
+    d.edges[2] = 4.0;
+    d.inside = 4.0;
+    return d;
+}
+
+[domain("tri")]
+[partitioning("integer")]
+[outputtopology("triangle_cw")]
+[outputcontrolpoints(3)]
+[patchconstantfunc("patchConstFunc")]
+Output main(InputPatch<Input, 3> patch, uint pointId : SV_OutputControlPointID, uint patchId : SV_PrimitiveID)
+{
+    Output output;
+    output.position = patch[pointId].position;
+    output.color = patch[pointId].color;
+    return output;
+}