Revision control
Copy as Markdown
// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "qssgdebugdrawsystem_p.h"
#include "qssgrenderhelpers_p.h"
#include "qssgrenderer_p.h"
#include "qssglayerrenderdata_p.h"
#include <QtQuick3DRuntimeRender/private/qssgrenderskymaterial_p.h>
#include "qssgrhiparticles_p.h"
#include "qssgrhiquadrenderer_p.h"
#include "../qssgrendercontextcore.h"
#include "../qssgrhicustommaterialsystem_p.h"
#include "../resourcemanager/qssgrenderbuffermanager_p.h"
#include "../qssgrenderdefaultmaterialshadergenerator_p.h"
#include "rendererimpl/qssgshadowmaphelpers_p.h"
#include <QtQuick3DUtils/private/qssgassert_p.h>
#include <QtGui/qquaternion.h>
#include <QtCore/qbitarray.h>
#include <cmath>
QT_BEGIN_NAMESPACE
static constexpr float QSSG_PI = float(M_PI);
static constexpr float QSSG_HALFPI = float(M_PI_2);
static const QRhiShaderResourceBinding::StageFlags RENDERER_VISIBILITY_ALL =
QRhiShaderResourceBinding::VertexStage | QRhiShaderResourceBinding::FragmentStage;
static QSSGRhiShaderPipelinePtr shadersForDefaultMaterial(QSSGRhiGraphicsPipelineState *ps,
QSSGSubsetRenderable &subsetRenderable,
const QSSGShaderFeatures &featureSet,
const QSSGUserShaderAugmentation &shaderAugmentation = {})
{
auto &renderer(subsetRenderable.renderer);
const auto &shaderPipeline = QSSGRendererPrivate::getShaderPipelineForDefaultMaterial(*renderer, subsetRenderable, featureSet, shaderAugmentation);
if (shaderPipeline) {
QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(*ps, shaderPipeline.get());
// NOTE: It's not just custom materials that can have custom property textures,
// augmented default materials can have them too.
shaderPipeline->resetExtraTextures();
}
return shaderPipeline;
}
static QSSGRhiShaderPipelinePtr shadersForParticleMaterial(QSSGRhiGraphicsPipelineState *ps,
QSSGParticlesRenderable &particleRenderable,
const QSSGShaderFeatures &featureSet)
{
auto &renderer(particleRenderable.renderer);
const auto &shaderPipeline = QSSGParticleRenderer::getShaderPipelineParticles(*renderer, particleRenderable, featureSet);
if (shaderPipeline)
QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(*ps, shaderPipeline.get());
return shaderPipeline;
}
static void updateUniformsForDefaultMaterial(QSSGRhiShaderPipeline &shaderPipeline,
QSSGRhiContext *rhiCtx,
const QSSGLayerRenderData &inData,
char *ubufData,
QSSGRhiGraphicsPipelineState *ps,
QSSGSubsetRenderable &subsetRenderable,
const QSSGRenderCameraList &cameras,
const QVector2D *depthAdjust,
const QMatrix4x4 *alteredModelViewProjection,
const QSSGRenderGraphObject *materialOverride = nullptr)
{
const auto &renderer(subsetRenderable.renderer);
const QMatrix4x4 clipSpaceCorrMatrix = rhiCtx->rhi()->clipSpaceCorrMatrix();
QSSGRenderMvpArray alteredMvpList;
if (alteredModelViewProjection)
alteredMvpList[0] = *alteredModelViewProjection;
const auto &modelNode = subsetRenderable.modelContext.model;
QRhiTexture *lightmapTexture = inData.getLightmapTexture(subsetRenderable.modelContext);
const auto &[localInstanceTransform, globalInstanceTransform] = inData.getInstanceTransforms(modelNode);
const QMatrix4x4 &modelMatrix(modelNode.usesBoneTexture() ? QMatrix4x4() : inData.getGlobalTransform(modelNode));
QSSGMaterialShaderGenerator::setRhiMaterialProperties(*renderer->contextInterface(),
shaderPipeline,
ubufData,
ps,
materialOverride ? *materialOverride : subsetRenderable.material,
subsetRenderable.shaderDescription,
inData.getDefaultMaterialPropertyTable(),
cameras,
alteredModelViewProjection ? alteredMvpList : subsetRenderable.modelContext.modelViewProjections,
subsetRenderable.modelContext.normalMatrix,
modelMatrix,
clipSpaceCorrMatrix,
localInstanceTransform,
globalInstanceTransform,
toDataView(modelNode.morphWeights),
subsetRenderable.firstImage,
subsetRenderable.opacity,
inData,
subsetRenderable.lights,
subsetRenderable.reflectionProbe,
subsetRenderable.renderableFlags.receivesShadows(),
subsetRenderable.renderableFlags.receivesReflections(),
depthAdjust,
lightmapTexture);
}
static QSSGBoxPoints computeFrustumBounds(const QMatrix4x4 &projection)
{
bool invertible = false;
QMatrix4x4 inv = projection.inverted(&invertible);
Q_ASSERT(invertible);
// The frustum points will be in this orientation
//
// bottom top
// 4__________5 7__________6
// \ / \ /
// \ / \ /
// \____/ \____/
// 0 1 3 2
return { inv.map(QVector3D(-1, -1, -1)), inv.map(QVector3D(+1, -1, -1)), inv.map(QVector3D(+1, +1, -1)),
inv.map(QVector3D(-1, +1, -1)), inv.map(QVector3D(-1, -1, +1)), inv.map(QVector3D(+1, -1, +1)),
inv.map(QVector3D(+1, +1, +1)), inv.map(QVector3D(-1, +1, +1)) };
}
static QSSGBoxPoints sliceFrustum(const QSSGBoxPoints &frustumPoints, float t0, float t1)
{
QSSGBoxPoints pts;
for (int i = 0; i < 4; ++i) {
const QVector3D forward = frustumPoints[i + 4] - frustumPoints[i];
pts[i] = frustumPoints[i] + forward * t0;
pts[i + 4] = frustumPoints[i] + forward * t1;
}
return pts;
}
static std::unique_ptr<QSSGRenderCamera> computeShadowCameraFromFrustum(const QMatrix4x4 &lightMatrix,
const QMatrix4x4 &lightMatrixInverted,
const QVector3D &lightPivot,
const QVector3D &lightForward,
const QVector3D &lightUp,
const float shadowMapResolution,
const float pcfRadius,
const QSSGBoxPoints &frustumPoints,
float frustumStartT,
float frustumEndT,
float frustumRadius,
bool lockShadowmapTexels,
const QSSGBounds3 &castingBox,
const QSSGBounds3 &receivingBox,
QSSGDebugDrawSystem *debugDrawSystem,
const bool drawCascades,
const bool drawSceneCascadeIntersection)
{
if (!castingBox.isFinite() || castingBox.isEmpty() || !receivingBox.isFinite() || receivingBox.isEmpty())
return nullptr; // Return early, no casting or receiving objects means no shadows
Q_ASSERT(frustumStartT <= frustumEndT);
Q_ASSERT(frustumStartT >= 0.f);
Q_ASSERT(frustumEndT <= 1.0f);
auto transformPoints = [&](const QSSGBoxPoints &points) {
QSSGBoxPoints result;
for (int i = 0; i < int(points.size()); ++i) {
result[i] = lightMatrix.map(points[i]);
}
return result;
};
QSSGBoxPoints frustumPointsSliced = sliceFrustum(frustumPoints, frustumStartT, frustumEndT);
if (drawCascades)
ShadowmapHelpers::addDebugFrustum(frustumPointsSliced, QColorConstants::Black, debugDrawSystem);
const QList<QVector3D> receivingSliced = ShadowmapHelpers::intersectBoxByFrustum(frustumPointsSliced,
receivingBox.toQSSGBoxPoints(),
drawSceneCascadeIntersection ? debugDrawSystem : nullptr,
QColorConstants::DarkGray);
if (receivingSliced.isEmpty())
return nullptr;
QSSGBounds3 receivingFrustumSlicedLightSpace;
for (const QVector3D &point : receivingSliced)
receivingFrustumSlicedLightSpace.include(lightMatrix.map(point));
// Slice casting box by frustumBounds' left, right, up, down planes
const QList<QVector3D> castingPointsLightSpace = ShadowmapHelpers::intersectBoxByBox(receivingFrustumSlicedLightSpace,
transformPoints(castingBox.toQSSGBoxPointsNoEmptyCheck()));
if (castingPointsLightSpace.isEmpty())
return nullptr;
// Create box containing casting and receiving from light space:
QSSGBounds3 castReceiveBounds;
for (const QVector3D &p : castingPointsLightSpace) {
castReceiveBounds.include(p);
}
for (const QVector3D &p : receivingFrustumSlicedLightSpace.toQSSGBoxPointsNoEmptyCheck()) {
float zMax = qMax(p.z(), castReceiveBounds.maximum.z());
float zMin = qMin(p.z(), castReceiveBounds.minimum.z());
castReceiveBounds.maximum.setZ(zMax);
castReceiveBounds.minimum.setZ(zMin);
}
// Expand to fit pcf radius
castReceiveBounds.fatten(pcfRadius);
QVector3D boundsCenterWorld = lightMatrixInverted.map(castReceiveBounds.center());
QVector3D boundsDims = castReceiveBounds.dimensions();
boundsDims.setZ(boundsDims.z() * 1.01f); // Expand slightly in z direction to avoid pancaking precision errors
if (lockShadowmapTexels) {
// Calculate center position aligned to texel size to avoid shimmering
const float diam = (pcfRadius + frustumRadius) * 2.0f;
const float texelsPerUnit = diam / shadowMapResolution;
QVector3D centerLight = lightMatrix.map(boundsCenterWorld);
float x = centerLight.x();
float y = centerLight.y();
float z = centerLight.z();
centerLight = QVector3D(int(x / texelsPerUnit), int(y / texelsPerUnit), int(z / texelsPerUnit)) * texelsPerUnit;
boundsCenterWorld = lightMatrixInverted.map(centerLight);
boundsDims.setX(diam);
boundsDims.setY(diam);
} else {
// We expand the shadowmap to cover the bounds with one extra texel on all sides
const float texelExpandFactor = shadowMapResolution / (shadowMapResolution - 2);
boundsDims.setX(boundsDims.x() * texelExpandFactor);
boundsDims.setY(boundsDims.y() * texelExpandFactor);
}
QRectF theViewport(0.0f, 0.0f, boundsDims.x(), boundsDims.y());
auto camera = std::make_unique<QSSGRenderCamera>(QSSGRenderGraphObject::Type::OrthographicCamera);
camera->clipPlanes = QSSGRenderCamera::ClipPlanes{-0.5f * boundsDims.z(), 0.5f * boundsDims.z()};
camera->fov = QSSGRenderCamera::FieldOfView::fromDegrees(90.f);
camera->parent = nullptr;
camera->localTransform = QSSGRenderNode::calculateTransformMatrix(boundsCenterWorld,
QSSGRenderNode::initScale,
lightPivot,
QQuaternion::fromDirection(lightForward, lightUp));
QSSGRenderCamera::calculateProjectionInternal(*camera, theViewport);
return camera;
}
static QVarLengthArray<std::unique_ptr<QSSGRenderCamera>, 4> setupCascadingCamerasForShadowMap(const QSSGLayerRenderData &data,
const QSSGRenderCamera &inCamera,
const QSSGRenderLight *inLight,
const int shadowMapResolution,
const float pcfRadius,
const float clipNear,
const float clipFar,
const QSSGBounds3 &castingObjectsBox,
const QSSGBounds3 &receivingObjectsBox,
bool lockShadowmapTexels,
QSSGDebugDrawSystem *debugDrawSystem,
bool drawCascades,
bool drawSceneCascadeIntersection)
{
Q_ASSERT(inLight->type == QSSGRenderLight::Type::DirectionalLight);
QVarLengthArray<std::unique_ptr<QSSGRenderCamera>, 4> result;
if (clipNear >= clipFar || qFuzzyCompare(clipNear, clipFar))
return result;
const QMatrix4x4 lightGlobalTransform = data.getGlobalTransform(*inLight);
const QVector3D lightDir = inLight->getDirection(lightGlobalTransform);
const QVector3D lightPivot = inLight->pivot;
const QVector3D forward = lightDir.normalized();
const QVector3D right = qFuzzyCompare(qAbs(forward.y()), 1.0f)
? QVector3D::crossProduct(forward, QVector3D(1, 0, 0)).normalized()
: QVector3D::crossProduct(forward, QVector3D(0, 1, 0)).normalized();
const QVector3D up = QVector3D::crossProduct(right, forward).normalized();
QMatrix4x4 lightMatrix;
lightMatrix.setRow(0, QVector4D(right, 0.0f));
lightMatrix.setRow(1, QVector4D(up, 0.0f));
lightMatrix.setRow(2, QVector4D(forward, 0.0f));
lightMatrix.setRow(3, QVector4D(0.0f, 0.0f, 0.0f, 1.0f));
QMatrix4x4 lightMatrixInverted = lightMatrix.inverted();
const float farScale = (clipFar - clipNear) / (inCamera.clipPlanes.clipFar() - inCamera.clipPlanes.clipNear());
const QMatrix4x4 cameraGlobalTransform = data.getGlobalTransform(inCamera);
QMatrix4x4 viewProjection(Qt::Uninitialized);
inCamera.calculateViewProjectionMatrix(cameraGlobalTransform, viewProjection);
const QSSGBoxPoints frustum = computeFrustumBounds(viewProjection);
const QSSGBoxPoints frustumUntransformed = lockShadowmapTexels ? computeFrustumBounds(inCamera.projection) : QSSGBoxPoints();
// We calculate the radius of the cascade without rotation or translation so we always get
// the same floating point value.
const auto calcFrustumRadius = [&](float t0, float t1) -> float {
const QSSGBoxPoints pts = sliceFrustum(frustumUntransformed, t0 * farScale, t1 * farScale);
QVector3D center = QVector3D(0.f, 0.f, 0.f);
for (QVector3D point : pts) {
center += point;
}
center = center * 0.125f;
float radiusSquared = 0;
for (QVector3D point : pts) {
radiusSquared = qMax(radiusSquared, (point - center).lengthSquared());
}
return std::sqrt(radiusSquared);
};
const auto computeSplitRanges = [inLight](const QVarLengthArray<float, 3> &splits) -> QVarLengthArray<QPair<float, float>, 4> {
QVarLengthArray<QPair<float, float>, 4> ranges;
const float csmBlendRatio = inLight->m_csmBlendRatio;
float t0 = 0.f;
for (qsizetype i = 0; i < splits.length(); i++) {
const float tI = qBound(qMin(t0 + 0.01f, 1.0f), splits[i], 1.0f);
ranges.emplace_back(t0, qMin(1.0f, tI + csmBlendRatio));
t0 = tI;
}
ranges.emplace_back(t0, 1.0f);
return ranges;
};
const auto computeFrustums = [&](const QVarLengthArray<float, 3> &splits) {
for (const auto &range : computeSplitRanges(splits)) {
const float frustumRadius = lockShadowmapTexels ? calcFrustumRadius(range.first, range.second) : 0.0f;
auto camera = computeShadowCameraFromFrustum(lightMatrix,
lightMatrixInverted,
lightPivot,
forward,
up,
shadowMapResolution,
pcfRadius,
frustum,
range.first * farScale,
range.second * farScale,
frustumRadius,
lockShadowmapTexels,
castingObjectsBox,
receivingObjectsBox,
debugDrawSystem,
drawCascades,
drawSceneCascadeIntersection);
result.emplace_back(std::move(camera));
}
};
switch (inLight->m_csmNumSplits) {
case 0: {
computeFrustums({});
break;
}
case 1: {
computeFrustums({ inLight->m_csmSplit1 });
break;
}
case 2: {
computeFrustums({ inLight->m_csmSplit1, inLight->m_csmSplit2 });
break;
}
case 3: {
computeFrustums({ inLight->m_csmSplit1, inLight->m_csmSplit2, inLight->m_csmSplit3 });
break;
}
default:
Q_UNREACHABLE();
break;
}
return result;
}
static void setupCubeReflectionCameras(const QSSGLayerRenderData &inData, const QSSGRenderReflectionProbe *inProbe, QSSGRenderCamera inCameras[6])
{
Q_ASSERT(inProbe != nullptr);
// setup light matrix
quint32 mapRes = 1 << inProbe->reflectionMapRes;
QRectF theViewport(0.0f, 0.0f, (float)mapRes, (float)mapRes);
static const QQuaternion rotOfs[6] {
QQuaternion::fromEulerAngles(0.f, qRadiansToDegrees(-QSSG_HALFPI), qRadiansToDegrees(QSSG_PI)),
QQuaternion::fromEulerAngles(0.f, qRadiansToDegrees(QSSG_HALFPI), qRadiansToDegrees(QSSG_PI)),
QQuaternion::fromEulerAngles(qRadiansToDegrees(QSSG_HALFPI), 0.f, 0.f),
QQuaternion::fromEulerAngles(qRadiansToDegrees(-QSSG_HALFPI), 0.f, 0.f),
QQuaternion::fromEulerAngles(0.f, qRadiansToDegrees(QSSG_PI), qRadiansToDegrees(-QSSG_PI)),
QQuaternion::fromEulerAngles(0.f, 0.f, qRadiansToDegrees(QSSG_PI)),
};
auto inProbeGlobalTranform = inData.getGlobalTransform(*inProbe);
const QVector3D inProbePos = QSSGRenderNode::getGlobalPos(inProbeGlobalTranform);
const QVector3D inProbePivot = inProbe->pivot;
for (int i = 0; i < 6; ++i) {
inCameras[i].parent = nullptr;
inCameras[i].clipPlanes = {1.0f, qMax<float>(2.0f, 10000.0f)};
inCameras[i].fov = QSSGRenderCamera::FieldOfView::fromDegrees(90.f);
inCameras[i].localTransform = QSSGRenderNode::calculateTransformMatrix(inProbePos, QSSGRenderNode::initScale, inProbePivot, rotOfs[i]);
QSSGRenderCamera::calculateProjectionInternal(inCameras[i], theViewport);
}
}
static void addOpaqueDepthPrePassBindings(QSSGRhiContext *rhiCtx,
QSSGRhiShaderPipeline *shaderPipeline,
QSSGRenderableImage *renderableImage,
QSSGRhiShaderResourceBindingList &bindings,
bool isCustomMaterialMeshSubset = false)
{
static const auto imageAffectsAlpha = [](QSSGRenderableImage::Type mapType) {
return mapType == QSSGRenderableImage::Type::BaseColor ||
mapType == QSSGRenderableImage::Type::Diffuse ||
mapType == QSSGRenderableImage::Type::Translucency ||
mapType == QSSGRenderableImage::Type::Opacity;
};
while (renderableImage) {
const auto mapType = renderableImage->m_mapType;
if (imageAffectsAlpha(mapType)) {
const char *samplerName = QSSGMaterialShaderGenerator::getSamplerName(mapType);
const int samplerHint = int(mapType);
int samplerBinding = shaderPipeline->bindingForTexture(samplerName, samplerHint);
if (samplerBinding >= 0) {
QRhiTexture *texture = renderableImage->m_texture.m_texture;
if (samplerBinding >= 0 && texture) {
const bool mipmapped = texture->flags().testFlag(QRhiTexture::MipMapped);
QRhiSampler *sampler = rhiCtx->sampler({ QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_minFilterType),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_magFilterType),
mipmapped ? QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_mipFilterType) : QRhiSampler::None,
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_horizontalTilingMode),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_verticalTilingMode),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_depthTilingMode)
});
bindings.addTexture(samplerBinding, RENDERER_VISIBILITY_ALL, texture, sampler);
}
} // else this is not necessarily an error, e.g. having metalness/roughness maps with metalness disabled
}
renderableImage = renderableImage->m_nextImage;
}
// For custom Materials we can't know which maps affect alpha, so map all
if (isCustomMaterialMeshSubset) {
QVector<QShaderDescription::InOutVariable> samplerVars =
shaderPipeline->fragmentStage()->shader().description().combinedImageSamplers();
const auto combinedSamplers = shaderPipeline->vertexStage()->shader().description().combinedImageSamplers();
for (const QShaderDescription::InOutVariable &var : combinedSamplers) {
auto it = std::find_if(samplerVars.cbegin(), samplerVars.cend(),
[&var](const QShaderDescription::InOutVariable &v) { return var.binding == v.binding; });
if (it == samplerVars.cend())
samplerVars.append(var);
}
int maxSamplerBinding = -1;
for (const QShaderDescription::InOutVariable &var : std::as_const(samplerVars))
maxSamplerBinding = qMax(maxSamplerBinding, var.binding);
// Will need to set unused image-samplers to something dummy
// because the shader code contains all custom property textures,
// and not providing a binding for all of them is invalid with some
// graphics APIs (and will need a real texture because setting a
// null handle or similar is not permitted with some of them so the
// srb does not accept null QRhiTextures either; but first let's
// figure out what bindings are unused in this frame)
QBitArray samplerBindingsSpecified(maxSamplerBinding + 1);
if (maxSamplerBinding >= 0) {
// custom property textures
int customTexCount = shaderPipeline->extraTextureCount();
for (int i = 0; i < customTexCount; ++i) {
const QSSGRhiTexture &t(shaderPipeline->extraTextureAt(i));
const int samplerBinding = shaderPipeline->bindingForTexture(t.name);
if (samplerBinding >= 0) {
samplerBindingsSpecified.setBit(samplerBinding);
QRhiSampler *sampler = rhiCtx->sampler(t.samplerDesc);
bindings.addTexture(samplerBinding,
RENDERER_VISIBILITY_ALL,
t.texture,
sampler);
}
}
}
// use a dummy texture for the unused samplers in the shader
QRhiSampler *dummySampler = rhiCtx->sampler({ QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None,
QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
QRhiTexture *dummyTexture = rhiCtx->dummyTexture({}, resourceUpdates);
QRhiTexture *dummyCubeTexture = rhiCtx->dummyTexture(QRhiTexture::CubeMap, resourceUpdates);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
for (const QShaderDescription::InOutVariable &var : std::as_const(samplerVars)) {
if (!samplerBindingsSpecified.testBit(var.binding)) {
QRhiTexture *t = var.type == QShaderDescription::SamplerCube ? dummyCubeTexture : dummyTexture;
bindings.addTexture(var.binding, RENDERER_VISIBILITY_ALL, t, dummySampler);
}
}
}
}
static void setupCubeShadowCameras(const QSSGLayerRenderData &inData,
const QSSGRenderLight *inLight,
float shadowMapFar,
QSSGRenderCamera inCameras[6])
{
Q_ASSERT(inLight != nullptr);
Q_ASSERT(inLight->type != QSSGRenderLight::Type::DirectionalLight);
// setup light matrix
quint32 mapRes = inLight->m_shadowMapRes;
QRectF theViewport(0.0f, 0.0f, (float)mapRes, (float)mapRes);
static const QQuaternion rotOfs[6] {
QQuaternion::fromEulerAngles(0.f, qRadiansToDegrees(-QSSG_HALFPI), qRadiansToDegrees(QSSG_PI)),
QQuaternion::fromEulerAngles(0.f, qRadiansToDegrees(QSSG_HALFPI), qRadiansToDegrees(QSSG_PI)),
QQuaternion::fromEulerAngles(qRadiansToDegrees(QSSG_HALFPI), 0.f, 0.f),
QQuaternion::fromEulerAngles(qRadiansToDegrees(-QSSG_HALFPI), 0.f, 0.f),
QQuaternion::fromEulerAngles(0.f, qRadiansToDegrees(QSSG_PI), qRadiansToDegrees(-QSSG_PI)),
QQuaternion::fromEulerAngles(0.f, 0.f, qRadiansToDegrees(QSSG_PI)),
};
const auto gt = inData.getGlobalTransform(*inLight);
const QVector3D inLightPos = QSSGRenderNode::getGlobalPos(gt);
constexpr QVector3D lightPivot = QVector3D(0, 0, 0);
for (int i = 0; i < 6; ++i) {
inCameras[i].parent = nullptr;
inCameras[i].clipPlanes = {1.0f, shadowMapFar};
inCameras[i].fov = QSSGRenderCamera::FieldOfView::fromDegrees(90.f);
inCameras[i].localTransform = QSSGRenderNode::calculateTransformMatrix(inLightPos, QSSGRenderNode::initScale, lightPivot, rotOfs[i]);
QSSGRenderCamera::calculateProjectionInternal(inCameras[i], theViewport);
}
/*
if ( inLight->type == RenderLightTypes::Point ) return;
QVector3D viewDirs[6];
QVector3D viewUp[6];
QMatrix3x3 theDirMatrix( inLight->m_GlobalTransform.getUpper3x3() );
viewDirs[0] = theDirMatrix.transform( QVector3D( 1.f, 0.f, 0.f ) );
viewDirs[2] = theDirMatrix.transform( QVector3D( 0.f, -1.f, 0.f ) );
viewDirs[4] = theDirMatrix.transform( QVector3D( 0.f, 0.f, 1.f ) );
viewDirs[0].normalize(); viewDirs[2].normalize(); viewDirs[4].normalize();
viewDirs[1] = -viewDirs[0];
viewDirs[3] = -viewDirs[2];
viewDirs[5] = -viewDirs[4];
viewUp[0] = viewDirs[2];
viewUp[1] = viewDirs[2];
viewUp[2] = viewDirs[5];
viewUp[3] = viewDirs[4];
viewUp[4] = viewDirs[2];
viewUp[5] = viewDirs[2];
for (int i = 0; i < 6; ++i)
{
inCameras[i].LookAt( inLightPos, viewUp[i], inLightPos + viewDirs[i] );
inCameras[i].CalculateGlobalVariables( theViewport, QVector2D( theViewport.m_Width,
theViewport.m_Height ) );
}
*/
}
static int setupInstancing(QSSGSubsetRenderable *renderable, QSSGRhiGraphicsPipelineState *ps, QSSGRhiContext *rhiCtx, const QVector3D &cameraDirection, const QVector3D &cameraPosition)
{
// TODO: non-static so it can be used from QSSGCustomMaterialSystem::rhiPrepareRenderable()?
const bool instancing = QSSGLayerRenderData::prepareInstancing(rhiCtx, renderable, cameraDirection, cameraPosition, renderable->instancingLodMin, renderable->instancingLodMax);
int instanceBufferBinding = 0;
if (instancing) {
auto &ia = QSSGRhiInputAssemblerStatePrivate::get(*ps);
// set up new bindings for instanced buffers
const quint32 stride = renderable->modelContext.model.instanceTable->stride();
QVarLengthArray<QRhiVertexInputBinding, 8> bindings;
std::copy(ia.inputLayout.cbeginBindings(), ia.inputLayout.cendBindings(), std::back_inserter(bindings));
bindings.append({ stride, QRhiVertexInputBinding::PerInstance });
instanceBufferBinding = bindings.size() - 1;
ia.inputLayout.setBindings(bindings.cbegin(), bindings.cend());
}
return instanceBufferBinding;
}
static void rhiPrepareResourcesForReflectionMap(const QSSGRenderContextInterface &context,
QSSGPassKey passKey,
const QSSGLayerRenderData &inData,
QSSGReflectionMapEntry *pEntry,
QSSGRhiGraphicsPipelineState *ps,
const QSSGRenderableObjectList &sortedOpaqueObjects,
QSSGRenderCamera &inCamera,
QSSGRenderer &renderer,
QSSGRenderTextureCubeFace cubeFace)
{
using namespace RenderHelpers;
QSSGRhiContext *rhiCtx = context.rhiContext().get();
if ((inData.layer.background == QSSGRenderLayer::Background::SkyBox && (inData.layer.lightProbe || inData.layer.skyMaterial))
|| inData.layer.background == QSSGRenderLayer::Background::SkyBoxCubeMap
|| (inData.layer.background == QSSGRenderLayer::Background::SkyMaterial && inData.layer.skyMaterial))
rhiPrepareSkyBoxForReflectionMap(context, passKey, inData.layer, inCamera, renderer, pEntry, cubeFace);
QSSGShaderFeatures features = inData.getShaderFeatures();
// because of alteredCamera/alteredMvp below
features.set(QSSGShaderFeatures::Feature::DisableMultiView, true);
features.set(QSSGShaderFeatures::Feature::Ssao, false);
const auto &defaultMaterialShaderKeyProperties = inData.getDefaultMaterialPropertyTable();
for (const auto &handle : sortedOpaqueObjects) {
QSSGRenderableObject &inObject = *handle.obj;
QMatrix4x4 modelViewProjection;
if (inObject.type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || inObject.type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QSSGSubsetRenderable &renderable(static_cast<QSSGSubsetRenderable &>(inObject));
const bool hasSkinning = defaultMaterialShaderKeyProperties.m_boneCount.getValue(renderable.shaderDescription) > 0;
const QMatrix4x4 &globalTransform = renderable.modelContext.globalTransform;
modelViewProjection = hasSkinning ? pEntry->m_viewProjection
: pEntry->m_viewProjection * globalTransform;
}
// here we pass on our own alteredCamera and alteredModelViewProjection
rhiPrepareRenderable(rhiCtx, passKey, inData, inObject, pEntry->m_rhiRenderPassDesc, ps, features, 1, 1,
&inCamera, &modelViewProjection, cubeFace, pEntry);
}
}
static inline void addDepthTextureBindings(QSSGRhiContext *rhiCtx,
QSSGRhiShaderPipeline *shaderPipeline,
QSSGRhiShaderResourceBindingList &bindings,
QBitArray *specifiedBindings = nullptr)
{
const auto markSpecifiedBinding = [specifiedBindings](int binding) {
if (specifiedBindings)
specifiedBindings->setBit(binding);
};
if (shaderPipeline->depthTexture()) {
const int depthTextureBinding = shaderPipeline->bindingForTexture("qt_depthTexture", int(QSSGRhiSamplerBindingHints::DepthTexture));
const int depthTextureArrayBinding = shaderPipeline->bindingForTexture("qt_depthTextureArray", int(QSSGRhiSamplerBindingHints::DepthTextureArray));
if (depthTextureBinding >= 0 || depthTextureArrayBinding >= 0) {
// nearest min/mag, no mipmap
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None,
QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });
if (depthTextureBinding >= 0) {
markSpecifiedBinding(depthTextureBinding);
bindings.addTexture(depthTextureBinding, RENDERER_VISIBILITY_ALL, shaderPipeline->depthTexture(), sampler);
}
if (depthTextureArrayBinding >= 0) {
markSpecifiedBinding(depthTextureArrayBinding);
bindings.addTexture(depthTextureArrayBinding, RENDERER_VISIBILITY_ALL, shaderPipeline->depthTexture(), sampler);
}
} // else ignore, not an error
}
// SSAO texture
if (shaderPipeline->ssaoTexture()) {
const int ssaoTextureBinding = shaderPipeline->bindingForTexture("qt_aoTexture", int(QSSGRhiSamplerBindingHints::AoTexture));
const int ssaoTextureArrayBinding = shaderPipeline->bindingForTexture("qt_aoTextureArray", int(QSSGRhiSamplerBindingHints::AoTextureArray));
if (ssaoTextureBinding >= 0 || ssaoTextureArrayBinding >= 0) {
// linear min/mag, no mipmap
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None,
QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });
if (ssaoTextureBinding >= 0) {
markSpecifiedBinding(ssaoTextureBinding);
bindings.addTexture(ssaoTextureBinding,
QRhiShaderResourceBinding::FragmentStage,
shaderPipeline->ssaoTexture(), sampler);
}
if (ssaoTextureArrayBinding >= 0) {
markSpecifiedBinding(ssaoTextureArrayBinding);
bindings.addTexture(ssaoTextureArrayBinding,
QRhiShaderResourceBinding::FragmentStage,
shaderPipeline->ssaoTexture(), sampler);
}
} // else ignore, not an error
}
}
static inline void addNormalTextureBindings(QSSGRhiContext *rhiCtx,
QSSGRhiShaderPipeline *shaderPipeline,
QSSGRhiShaderResourceBindingList &bindings)
{
if (shaderPipeline->normalTexture()) {
const int normalTextureBinding = shaderPipeline->bindingForTexture("qt_normalTexture", int(QSSGRhiSamplerBindingHints::NormalTexture));
if (normalTextureBinding >= 0) {
// nearest min/mag, no mipmap
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None,
QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });
bindings.addTexture(normalTextureBinding, RENDERER_VISIBILITY_ALL, shaderPipeline->normalTexture(), sampler);
} // else ignore, not an error
}
}
void RenderHelpers::addAccumulatorImageBindings(QSSGRhiShaderPipeline *shaderPipeline,
QSSGRhiShaderResourceBindingList &bindings)
{
const auto images = shaderPipeline->oitImages();
if (!images[0])
return;
#ifdef QSSG_OIT_USE_BUFFERS
bindings.addStorageBufferStore(3, QRhiShaderResourceBinding::FragmentStage, (QRhiBuffer*)images[0]);
bindings.addStorageBufferLoadStore(4, QRhiShaderResourceBinding::FragmentStage, (QRhiBuffer*)images[1]);
bindings.addStorageBufferLoadStore(5, QRhiShaderResourceBinding::FragmentStage, (QRhiBuffer*)images[2]);
#else
int abuf = shaderPipeline->bindingForStorageImage("qt_imgAbuffer");
int aux = shaderPipeline->bindingForStorageImage("qt_imgAux");
int counter = shaderPipeline->bindingForStorageImage("qt_imgCounter");
if (abuf == -1 || aux == -1 || counter == -1) {
qWarning()<<"Shader is missing image binding points;";
return;
}
bindings.addImageStore(abuf, QRhiShaderResourceBinding::FragmentStage, images[0], 0);
// atomic operations require loadstore
bindings.addImageLoadStore(aux, QRhiShaderResourceBinding::FragmentStage, images[1], 0);
bindings.addImageLoadStore(counter, QRhiShaderResourceBinding::FragmentStage, images[2], 0);
#endif
}
// Returns the srb for the bindings and records it in the draw call data, releasing the
// previously recorded srb if the bindings changed. The bindings refer to the draw call
// data's uniform buffer, so the srb must be owned by the draw call data; otherwise
// releaseDrawCallData() cannot purge it and the cache keeps an srb referencing a
// deleted buffer.
static QRhiShaderResourceBindings *drawCallDataSrb(QSSGRhiContextPrivate *rhiCtxD,
QSSGRhiDrawCallData &dcd,
const QSSGRhiShaderResourceBindingList &bindings)
{
if (!dcd.srb || bindings != dcd.bindings) {
dcd.srb = rhiCtxD->srb(bindings);
rhiCtxD->releaseCachedSrb(dcd.bindings);
dcd.bindings = bindings;
}
return dcd.srb;
}
static void rhiPrepareResourcesForShadowMap(QSSGRhiContext *rhiCtx,
const QSSGLayerRenderData &inData,
QSSGPassKey passKey,
QSSGShadowMapEntry *pEntry,
QSSGRhiGraphicsPipelineState *ps,
const QVector2D *depthAdjust,
const QSSGRenderableObjectList &sortedOpaqueObjects,
QSSGRenderCamera &inCamera,
bool orthographic,
QSSGRenderTextureCubeFace cubeFace,
quint32 cascadeIndex)
{
QSSGShaderFeatures featureSet;
if (orthographic)
featureSet.set(QSSGShaderFeatures::Feature::OrthoShadowPass, true);
else
featureSet.set(QSSGShaderFeatures::Feature::PerspectiveShadowPass, true);
// Do note how updateUniformsForDefaultMaterial() get a single camera and a
// custom mvp; make sure multiview is disabled in the shader generator using
// the common flag, instead of it having to write logic for checking for
// OrthoShadowPoss || CubeShadowPass.
featureSet.set(QSSGShaderFeatures::Feature::DisableMultiView, true);
const auto cubeFaceIdx = QSSGBaseTypeHelpers::indexOfCubeFace(cubeFace);
const auto &defaultMaterialShaderKeyProperties = inData.getDefaultMaterialPropertyTable();
QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
for (const auto &handle : sortedOpaqueObjects) {
QSSGRenderableObject *theObject = handle.obj;
QSSG_ASSERT(theObject->renderableFlags.castsShadows(), continue);
QSSGShaderFeatures objectFeatureSet = featureSet;
const bool isOpaqueDepthPrePass = theObject->depthWriteMode == QSSGDepthDrawMode::OpaquePrePass;
if (isOpaqueDepthPrePass)
objectFeatureSet.set(QSSGShaderFeatures::Feature::OpaqueDepthPrePass, true);
QSSGRhiDrawCallData *dcd = nullptr;
QMatrix4x4 modelViewProjection;
QSSGSubsetRenderable &renderable(static_cast<QSSGSubsetRenderable &>(*theObject));
if (theObject->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || theObject->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
const bool hasSkinning = defaultMaterialShaderKeyProperties.m_boneCount.getValue(renderable.shaderDescription) > 0;
modelViewProjection = hasSkinning ? pEntry->m_lightViewProjection[cascadeIndex]
: pEntry->m_lightViewProjection[cascadeIndex] * renderable.modelContext.globalTransform;
// cascadeIndex is 0..3 for directional light and 0 for the pointlight & spotlight
// cubeFaceIdx is 0 for directional & spotlight and 0..5 for the pointlight
// pEntry is unique per light and a light can only be one of directional, point, or spotlight.
// NOTE: The material is deliberately not part of the key here. The draw call data belongs to
// the shadow map entry, so swapping the material reuses it instead of creating a new one.
const quintptr entryIdx = cascadeIndex + cubeFaceIdx + (quintptr(renderable.subset.offset) << 3);
dcd = &rhiCtxD->drawCallData({ passKey, &renderable.modelContext.model, nullptr, pEntry, entryIdx });
}
QSSGRhiShaderResourceBindingList bindings;
QSSGRhiShaderPipelinePtr shaderPipeline;
QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(*theObject));
if (theObject->type == QSSGSubsetRenderable::Type::DefaultMaterialMeshSubset) {
const auto &material = static_cast<const QSSGRenderDefaultMaterial &>(subsetRenderable.getMaterial());
ps->cullMode = QSSGRhiHelpers::toCullMode(material.cullMode);
const bool blendParticles = defaultMaterialShaderKeyProperties.m_blendParticles.getValue(subsetRenderable.shaderDescription);
shaderPipeline = shadersForDefaultMaterial(ps, subsetRenderable, objectFeatureSet);
if (!shaderPipeline)
continue;
shaderPipeline->ensureCombinedUniformBuffer(&dcd->ubuf);
char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
// calls updateUni with an alteredCamera and alteredModelViewProjection
QSSGRenderCameraList cameras({ &inCamera });
updateUniformsForDefaultMaterial(*shaderPipeline, rhiCtx, inData, ubufData, ps, subsetRenderable, cameras, depthAdjust, &modelViewProjection);
if (blendParticles)
QSSGParticleRenderer::updateUniformsForParticleModel(*shaderPipeline, ubufData, &subsetRenderable.modelContext.model, subsetRenderable.subset.offset);
dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
if (blendParticles)
QSSGParticleRenderer::prepareParticlesForModel(*shaderPipeline, rhiCtx, bindings, &subsetRenderable.modelContext.model);
} else if (theObject->type == QSSGSubsetRenderable::Type::CustomMaterialMeshSubset) {
const auto &material = static_cast<const QSSGRenderCustomMaterial &>(subsetRenderable.getMaterial());
ps->cullMode = QSSGRhiHelpers::toCullMode(material.m_cullMode);
QSSGCustomMaterialSystem &customMaterialSystem(*subsetRenderable.renderer->contextInterface()->customMaterialSystem().get());
shaderPipeline = customMaterialSystem.shadersForCustomMaterial(ps, material, subsetRenderable, inData.getDefaultMaterialPropertyTable(), objectFeatureSet);
if (!shaderPipeline)
continue;
shaderPipeline->ensureCombinedUniformBuffer(&dcd->ubuf);
char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
// inCamera is the shadow camera, not the same as inData.renderedCameras
QSSGRenderCameraList cameras({ &inCamera });
customMaterialSystem.updateUniformsForCustomMaterial(*shaderPipeline, rhiCtx, inData, ubufData, ps, material, subsetRenderable,
cameras, depthAdjust, &modelViewProjection);
dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
}
if (theObject->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || theObject->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(*ps, shaderPipeline.get());
auto &ia = QSSGRhiInputAssemblerStatePrivate::get(*ps);
ia = subsetRenderable.subset.rhi.ia;
const QSSGRenderCameraDataList &cameraDatas(*inData.renderedCameraData);
int instanceBufferBinding = setupInstancing(&subsetRenderable, ps, rhiCtx, cameraDatas[0].direction, cameraDatas[0].position);
QSSGRhiHelpers::bakeVertexInputLocations(&ia, *shaderPipeline, instanceBufferBinding);
bindings.addUniformBuffer(0, RENDERER_VISIBILITY_ALL, dcd->ubuf);
// Depth and SSAO textures, in case a custom material's shader code does something with them.
addDepthTextureBindings(rhiCtx, shaderPipeline.get(), bindings);
// and the normal texture, if there is one.
addNormalTextureBindings(rhiCtx, shaderPipeline.get(), bindings);
if (isOpaqueDepthPrePass) {
addOpaqueDepthPrePassBindings(rhiCtx,
shaderPipeline.get(),
subsetRenderable.firstImage,
bindings,
(theObject->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset));
}
// There is no screen texture at this stage. But the shader from a
// custom material may rely on it, and an object with that material
// can end up in the shadow map's object list. So bind a dummy
// texture then due to the lack of other options.
const int screenTextureBinding = shaderPipeline->bindingForTexture("qt_screenTexture", int(QSSGRhiSamplerBindingHints::ScreenTexture));
const int screenTextureArrayBinding = shaderPipeline->bindingForTexture("qt_screenTextureArray", int(QSSGRhiSamplerBindingHints::ScreenTextureArray));
if (screenTextureBinding >= 0 || screenTextureArrayBinding >= 0) {
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None,
QRhiSampler::Repeat, QRhiSampler::Repeat, QRhiSampler::Repeat });
if (screenTextureBinding >= 0) {
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
QRhiTexture *dummyTexture = rhiCtx->dummyTexture({}, resourceUpdates);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
bindings.addTexture(screenTextureBinding,
QRhiShaderResourceBinding::FragmentStage,
dummyTexture, sampler);
}
if (screenTextureArrayBinding >= 0) {
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
QRhiTexture *dummyTexture = rhiCtx->dummyTexture({}, resourceUpdates, QSize(64, 64), Qt::black, inData.layer.viewCount);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
bindings.addTexture(screenTextureArrayBinding,
QRhiShaderResourceBinding::FragmentStage,
dummyTexture, sampler);
}
}
// Skinning
if (QRhiTexture *boneTexture = inData.getBonemapTexture(subsetRenderable.modelContext)) {
int binding = shaderPipeline->bindingForTexture("qt_boneTexture");
if (binding >= 0) {
QRhiSampler *boneSampler = rhiCtx->sampler({ QRhiSampler::Nearest,
QRhiSampler::Nearest,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::Repeat
});
bindings.addTexture(binding,
QRhiShaderResourceBinding::VertexStage,
boneTexture,
boneSampler);
}
}
// Morphing
auto *targetsTexture = subsetRenderable.subset.rhi.targetsTexture;
if (targetsTexture) {
int binding = shaderPipeline->bindingForTexture("qt_morphTargetTexture");
if (binding >= 0) {
QRhiSampler *targetsSampler = rhiCtx->sampler({ QRhiSampler::Nearest,
QRhiSampler::Nearest,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge
});
bindings.addTexture(binding, QRhiShaderResourceBinding::VertexStage, subsetRenderable.subset.rhi.targetsTexture, targetsSampler);
}
}
QRhiShaderResourceBindings *srb = drawCallDataSrb(rhiCtxD, *dcd, bindings);
subsetRenderable.rhiRenderData.shadowPass.pipeline = rhiCtxD->pipeline(*ps, pEntry->m_rhiRenderPassDesc[cascadeIndex], srb);
subsetRenderable.rhiRenderData.shadowPass.srb[cubeFaceIdx] = srb;
}
}
}
static void fillTargetBlend(QRhiGraphicsPipeline::TargetBlend *targetBlend, QSSGRenderDefaultMaterial::MaterialBlendMode materialBlend)
{
// Assuming default values in the other TargetBlend fields
switch (materialBlend) {
case QSSGRenderDefaultMaterial::MaterialBlendMode::Screen:
targetBlend->srcColor = QRhiGraphicsPipeline::SrcAlpha;
targetBlend->dstColor = QRhiGraphicsPipeline::One;
targetBlend->srcAlpha = QRhiGraphicsPipeline::One;
targetBlend->dstAlpha = QRhiGraphicsPipeline::One;
break;
case QSSGRenderDefaultMaterial::MaterialBlendMode::Multiply:
targetBlend->srcColor = QRhiGraphicsPipeline::DstColor;
targetBlend->dstColor = QRhiGraphicsPipeline::Zero;
targetBlend->srcAlpha = QRhiGraphicsPipeline::One;
targetBlend->dstAlpha = QRhiGraphicsPipeline::One;
break;
default:
// Use SourceOver for everything else
targetBlend->srcColor = QRhiGraphicsPipeline::SrcAlpha;
targetBlend->dstColor = QRhiGraphicsPipeline::OneMinusSrcAlpha;
targetBlend->srcAlpha = QRhiGraphicsPipeline::One;
targetBlend->dstAlpha = QRhiGraphicsPipeline::OneMinusSrcAlpha;
break;
}
}
void rhiPrepareRenderableImp(QSSGRhiContext *rhiCtx,
QSSGPassKey passKey,
const QSSGLayerRenderData &inData,
QSSGRenderableObject &inObject,
QRhiRenderPassDescriptor *renderPassDescriptor,
QSSGRhiGraphicsPipelineState *ps,
QSSGShaderFeatures featureSet,
int samples,
int viewCount,
bool screenMapPass,
QSSGRenderCamera *alteredCamera,
QMatrix4x4 *alteredModelViewProjection,
QSSGRenderTextureCubeFace cubeFace,
QSSGReflectionMapEntry *entry,
bool oit)
{
const auto &defaultMaterialShaderKeyProperties = inData.getDefaultMaterialPropertyTable();
switch (inObject.type) {
case QSSGRenderableObject::Type::DefaultMaterialMeshSubset:
{
QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(inObject));
if ((cubeFace == QSSGRenderTextureCubeFaceNone) && subsetRenderable.reflectionProbeIndex >= 0 && subsetRenderable.renderableFlags.testFlag(QSSGRenderableObjectFlag::ReceivesReflections))
featureSet.set(QSSGShaderFeatures::Feature::ReflectionProbe, true);
if ((cubeFace != QSSGRenderTextureCubeFaceNone)) {
// Disable tonemapping for the reflection pass
featureSet.disableTonemapping();
}
if (subsetRenderable.renderableFlags.rendersWithLightmap())
featureSet.set(QSSGShaderFeatures::Feature::Lightmap, true);
const auto &shaderPipeline = shadersForDefaultMaterial(ps, subsetRenderable, featureSet);
if (shaderPipeline) {
// Unlike the subsetRenderable (which is allocated per frame so is
// not persistent in any way), the model reference is persistent in
// the sense that it references the model node in the scene graph.
// Combined with the layer node (multiple View3Ds may share the
// same scene!), this is suitable as a key to get the uniform
// buffers that were used with the rendering of the same model in
// the previous frame.
QSSGRhiShaderResourceBindingList bindings;
const auto &modelNode = subsetRenderable.modelContext.model;
const bool blendParticles = defaultMaterialShaderKeyProperties.m_blendParticles.getValue(subsetRenderable.shaderDescription);
// NOTE:
// - entryIdx should 0 for QSSGRenderTextureCubeFaceNone (and a null entry).
// In all other cases the entryIdx is a combination of the cubeface idx and the subset
// offset, where the lower bits are the cubeface idx. The per-probe reflection map
// entry, if any, goes in the key's mapEntry slot. The key's resource must be the
// material itself, and nothing but the material, since
// cleanupDrawCallDataForResource() releases the entries for a to-be-destroyed
// material by matching on the resource.
const auto cubeFaceIdx = QSSGBaseTypeHelpers::indexOfCubeFace(cubeFace);
const quintptr entryIdx = quintptr(cubeFace != QSSGRenderTextureCubeFaceNone)
* (cubeFaceIdx + (quintptr(subsetRenderable.subset.offset) << 3));
QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
QSSGRhiDrawCallData &dcd = rhiCtxD->drawCallData({ passKey, &modelNode, &subsetRenderable.material, entry,
entryIdx });
shaderPipeline->ensureCombinedUniformBuffer(&dcd.ubuf);
char *ubufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
if (alteredCamera) {
Q_ASSERT(alteredModelViewProjection);
QSSGRenderCameraList cameras({ alteredCamera });
updateUniformsForDefaultMaterial(*shaderPipeline, rhiCtx, inData, ubufData, ps, subsetRenderable, cameras, nullptr, alteredModelViewProjection);
} else {
Q_ASSERT(!alteredModelViewProjection);
updateUniformsForDefaultMaterial(*shaderPipeline, rhiCtx, inData, ubufData, ps, subsetRenderable, inData.renderedCameras, nullptr, nullptr);
}
if (blendParticles)
QSSGParticleRenderer::updateUniformsForParticleModel(*shaderPipeline, ubufData, &subsetRenderable.modelContext.model, subsetRenderable.subset.offset);
dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame();
if (blendParticles)
QSSGParticleRenderer::prepareParticlesForModel(*shaderPipeline, rhiCtx, bindings, &subsetRenderable.modelContext.model);
// Skinning
if (QRhiTexture *boneTexture = inData.getBonemapTexture(subsetRenderable.modelContext)) {
int binding = shaderPipeline->bindingForTexture("qt_boneTexture");
if (binding >= 0) {
QRhiSampler *boneSampler = rhiCtx->sampler({ QRhiSampler::Nearest,
QRhiSampler::Nearest,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::Repeat
});
bindings.addTexture(binding,
QRhiShaderResourceBinding::VertexStage,
boneTexture,
boneSampler);
}
}
// Morphing
auto *targetsTexture = subsetRenderable.subset.rhi.targetsTexture;
if (targetsTexture) {
int binding = shaderPipeline->bindingForTexture("qt_morphTargetTexture");
if (binding >= 0) {
QRhiSampler *targetsSampler = rhiCtx->sampler({ QRhiSampler::Nearest,
QRhiSampler::Nearest,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge
});
bindings.addTexture(binding, QRhiShaderResourceBinding::VertexStage, subsetRenderable.subset.rhi.targetsTexture, targetsSampler);
}
}
ps->samples = samples;
ps->viewCount = viewCount;
const auto &material = static_cast<const QSSGRenderDefaultMaterial &>(subsetRenderable.getMaterial());
ps->cullMode = QSSGRhiHelpers::toCullMode(material.cullMode);
if (!oit || (oit && inData.layer.oitMethod == QSSGRenderLayer::OITMethod::None))
fillTargetBlend(&ps->targetBlend[0], material.blendMode);
auto &ia = QSSGRhiInputAssemblerStatePrivate::get(*ps);
ia = subsetRenderable.subset.rhi.ia;
const QSSGRenderCameraDataList &cameraDatas(*inData.renderedCameraData);
QVector3D cameraDirection = cameraDatas[0].direction;
QVector3D cameraPosition = cameraDatas[0].position;
if (alteredCamera) {
const QMatrix4x4 camGlobalTranform = inData.getGlobalTransform(*alteredCamera);
cameraDirection = QSSGRenderNode::getScalingCorrectDirection(camGlobalTranform);
cameraPosition = QSSGRenderNode::getGlobalPos(camGlobalTranform);
}
int instanceBufferBinding = setupInstancing(&subsetRenderable, ps, rhiCtx, cameraDirection, cameraPosition);
QSSGRhiHelpers::bakeVertexInputLocations(&ia, *shaderPipeline, instanceBufferBinding);
bindings.addUniformBuffer(0, RENDERER_VISIBILITY_ALL, dcd.ubuf, 0, shaderPipeline->ub0Size());
if (shaderPipeline->isLightingEnabled()) {
bindings.addUniformBuffer(1, RENDERER_VISIBILITY_ALL, dcd.ubuf,
shaderPipeline->ub0LightDataOffset(),
sizeof(QSSGShaderLightsUniformData));
bindings.addUniformBuffer(2, RENDERER_VISIBILITY_ALL, dcd.ubuf,
shaderPipeline->ub0DirectionalLightDataOffset(),
sizeof(QSSGShaderDirectionalLightsUniformData));
}
// Texture maps
QSSGRenderableImage *renderableImage = subsetRenderable.firstImage;
while (renderableImage) {
const char *samplerName = QSSGMaterialShaderGenerator::getSamplerName(renderableImage->m_mapType);
const int samplerHint = int(renderableImage->m_mapType);
int samplerBinding = shaderPipeline->bindingForTexture(samplerName, samplerHint);
if (samplerBinding >= 0) {
QRhiTexture *texture = renderableImage->m_texture.m_texture;
if (samplerBinding >= 0 && texture) {
const bool mipmapped = texture->flags().testFlag(QRhiTexture::MipMapped);
QSSGRhiSamplerDescription samplerDesc = {
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_minFilterType),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_magFilterType),
mipmapped ? QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_mipFilterType) : QRhiSampler::None,
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_horizontalTilingMode),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_verticalTilingMode),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_depthTilingMode)
};
rhiCtx->checkAndAdjustForNPoT(texture, &samplerDesc);
QRhiSampler *sampler = rhiCtx->sampler(samplerDesc);
bindings.addTexture(samplerBinding, RENDERER_VISIBILITY_ALL, texture, sampler);
}
} // else this is not necessarily an error, e.g. having metalness/roughness maps with metalness disabled
renderableImage = renderableImage->m_nextImage;
}
if (shaderPipeline->isLightingEnabled()) {
// Shadow map atlas
if (int binding = shaderPipeline->bindingForTexture("qt_shadowmap_texture"); binding >= 0) {
QRhiTexture *texture = shaderPipeline->shadowMapAtlasTexture();
if (!texture) {
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
texture = rhiCtx->dummyTexture({ }, resourceUpdates, QSize(1, 1), Qt::black, 2);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
}
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::Repeat });
bindings.addTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);
}
// Shadow map blue noise
if (int binding = shaderPipeline->bindingForTexture("qt_shadowmap_blue_noise_texture"); binding >= 0) {
if (auto shadowMapBlueNoise = shaderPipeline->shadowMapBlueNoiseTexture()) {
int binding = shaderPipeline->bindingForTexture("qt_shadowmap_blue_noise_texture");
if (binding >= 0) {
QRhiTexture *texture = shadowMapBlueNoise;
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
QRhiSampler::None,
QRhiSampler::Repeat,
QRhiSampler::Repeat,
QRhiSampler::Repeat });
Q_ASSERT(texture && sampler);
bindings.addTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);
}
} else {
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
QRhiTexture *texture = rhiCtx->dummyTexture({}, resourceUpdates);
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
QRhiSampler::None,
QRhiSampler::Repeat,
QRhiSampler::Repeat,
QRhiSampler::Repeat });
Q_ASSERT(texture && sampler);
bindings.addTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
}
}
// Prioritize reflection texture over Light Probe texture because
// reflection texture also contains the irradiance and pre filtered
// values for the light probe.
if (featureSet.isSet(QSSGShaderFeatures::Feature::ReflectionProbe)) {
int reflectionSampler = shaderPipeline->bindingForTexture("qt_reflectionMap");
QRhiTexture* reflectionTexture = inData.getReflectionMapManager()->reflectionMapEntry(subsetRenderable.reflectionProbeIndex)->m_rhiPrefilteredCube;
const auto mipMapFilter = reflectionTexture && reflectionTexture->flags().testFlag(QRhiTexture::Flag::MipMapped)
? QRhiSampler::Linear
: QRhiSampler::None;
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
mipMapFilter,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::Repeat });
if (reflectionSampler >= 0 && reflectionTexture)
bindings.addTexture(reflectionSampler, QRhiShaderResourceBinding::FragmentStage, reflectionTexture, sampler);
}
if (int binding = shaderPipeline->bindingForTexture("qt_lightProbe", int(QSSGRhiSamplerBindingHints::LightProbe));
binding >= 0) {
auto texture = shaderPipeline->lightProbeTexture();
if (!texture) {
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
texture = rhiCtx->dummyTexture(QRhiTexture::CubeMap, resourceUpdates);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
}
Q_ASSERT(texture);
QPair<QSSGRenderTextureCoordOp, QSSGRenderTextureCoordOp> tiling = shaderPipeline->lightProbeTiling();
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
QRhiSampler::Linear, // enables mipmapping
QSSGRhiHelpers::toRhi(tiling.first),
QSSGRhiHelpers::toRhi(tiling.second),
QRhiSampler::Repeat });
bindings.addTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);
}
// Screen Texture
if (shaderPipeline->screenTexture()) {
const int screenTextureBinding = shaderPipeline->bindingForTexture("qt_screenTexture", int(QSSGRhiSamplerBindingHints::ScreenTexture));
const int screenTextureArrayBinding = shaderPipeline->bindingForTexture("qt_screenTextureArray", int(QSSGRhiSamplerBindingHints::ScreenTextureArray));
if (screenTextureBinding >= 0 || screenTextureArrayBinding >= 0) {
QRhiTexture *screenTexture = shaderPipeline->screenTexture();
// If we're called as part of the screen map pass there's obviosly no screen texture available, but the shader may still expect it, so bind a dummy texture.
if (screenMapPass) {
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
// Just mirror what is set up by the ScreenMap pass.
const QRhiTexture::Flags flags = screenTexture->flags();
// and set the dummy texture so there's something for the shader to sample.
screenTexture = rhiCtx->dummyTexture(flags, resourceUpdates);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
}
// linear min/mag, mipmap filtering depends on the
// texture, with SCREEN_TEXTURE there are no mipmaps, but
// once SCREEN_MIP_TEXTURE is seen the texture (the same
// one) has mipmaps generated.
QRhiSampler::Filter mipFilter = shaderPipeline->screenTexture()->flags().testFlag(QRhiTexture::MipMapped)
? QRhiSampler::Linear : QRhiSampler::None;
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear, QRhiSampler::Linear, mipFilter,
QRhiSampler::Repeat, QRhiSampler::Repeat, QRhiSampler::Repeat });
if (screenTextureBinding >= 0) {
bindings.addTexture(screenTextureBinding,
QRhiShaderResourceBinding::FragmentStage,
screenTexture, sampler);
}
if (screenTextureArrayBinding >= 0) {
bindings.addTexture(screenTextureArrayBinding,
QRhiShaderResourceBinding::FragmentStage,
screenTexture, sampler);
}
} // else ignore, not an error
}
if (shaderPipeline->lightmapTexture()) {
int binding = shaderPipeline->bindingForTexture("qt_lightmap", int(QSSGRhiSamplerBindingHints::LightmapTexture));
if (binding >= 0) {
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None,
QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });
bindings.addTexture(binding,
QRhiShaderResourceBinding::FragmentStage,
shaderPipeline->lightmapTexture(), sampler);
} // else ignore, not an error
}
}
// Depth and SSAO textures
addDepthTextureBindings(rhiCtx, shaderPipeline.get(), bindings);
// Normal texture
addNormalTextureBindings(rhiCtx, shaderPipeline.get(), bindings);
if (oit && inData.layer.oitMethod == QSSGRenderLayer::OITMethod::LinkedList)
RenderHelpers::addAccumulatorImageBindings(shaderPipeline.get(), bindings);
// Instead of always doing a QHash find in srb(), store the binding
// list and the srb object in the per-model+material
// QSSGRhiUniformBufferSet. While this still needs comparing the
// binding list, to see if something has changed, it results in
// significant gains with lots of models in the scene (because the
// srb hash table becomes large then, so avoiding the lookup as
// much as possible is helpful)
QRhiShaderResourceBindings *&srb = dcd.srb;
bool srbChanged = false;
if (!srb || bindings != dcd.bindings) {
srb = rhiCtxD->srb(bindings);
rhiCtxD->releaseCachedSrb(dcd.bindings);
dcd.bindings = bindings;
srbChanged = true;
}
if (cubeFace != QSSGRenderTextureCubeFaceNone)
subsetRenderable.rhiRenderData.reflectionPass.srb[cubeFaceIdx] = srb;
else
subsetRenderable.rhiRenderData.mainPass.srb = srb;
const auto pipelineKey = QSSGGraphicsPipelineStateKey::create(*ps, renderPassDescriptor, srb);
if (dcd.pipeline
&& !srbChanged
&& dcd.renderTargetDescriptionHash == pipelineKey.extra.renderTargetDescriptionHash // we have the hash code anyway, use it to early out upon mismatch
&& dcd.renderTargetDescription == pipelineKey.renderTargetDescription
&& dcd.ps == *ps)
{
if (cubeFace != QSSGRenderTextureCubeFaceNone)
subsetRenderable.rhiRenderData.reflectionPass.pipeline = dcd.pipeline;
else
subsetRenderable.rhiRenderData.mainPass.pipeline = dcd.pipeline;
} else {
if (cubeFace != QSSGRenderTextureCubeFaceNone) {
subsetRenderable.rhiRenderData.reflectionPass.pipeline = rhiCtxD->pipeline(pipelineKey,
renderPassDescriptor,
srb);
dcd.pipeline = subsetRenderable.rhiRenderData.reflectionPass.pipeline;
} else {
subsetRenderable.rhiRenderData.mainPass.pipeline = rhiCtxD->pipeline(pipelineKey,
renderPassDescriptor,
srb);
dcd.pipeline = subsetRenderable.rhiRenderData.mainPass.pipeline;
}
dcd.renderTargetDescriptionHash = pipelineKey.extra.renderTargetDescriptionHash;
dcd.renderTargetDescription = pipelineKey.renderTargetDescription;
dcd.ps = *ps;
}
}
break;
}
case QSSGRenderableObject::Type::CustomMaterialMeshSubset:
{
QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(inObject));
const QSSGRenderCustomMaterial &material = static_cast<const QSSGRenderCustomMaterial &>(subsetRenderable.getMaterial());
QSSGCustomMaterialSystem &customMaterialSystem(*subsetRenderable.renderer->contextInterface()->customMaterialSystem().get());
featureSet.set(QSSGShaderFeatures::Feature::LightProbe, inData.layer.lightProbe || material.m_iblProbe);
if ((cubeFace == QSSGRenderTextureCubeFaceNone) && subsetRenderable.reflectionProbeIndex >= 0 && subsetRenderable.renderableFlags.testFlag(QSSGRenderableObjectFlag::ReceivesReflections))
featureSet.set(QSSGShaderFeatures::Feature::ReflectionProbe, true);
if (cubeFace != QSSGRenderTextureCubeFaceNone) {
// Disable tonemapping for the reflection pass
featureSet.disableTonemapping();
}
if (subsetRenderable.renderableFlags.rendersWithLightmap())
featureSet.set(QSSGShaderFeatures::Feature::Lightmap, true);
customMaterialSystem.rhiPrepareRenderable(ps, passKey, subsetRenderable, featureSet,
material, inData, renderPassDescriptor, samples, viewCount, screenMapPass,
alteredCamera, cubeFace, alteredModelViewProjection, entry, oit);
break;
}
case QSSGRenderableObject::Type::Particles:
{
QSSGParticlesRenderable &particleRenderable(static_cast<QSSGParticlesRenderable &>(inObject));
const auto &shaderPipeline = shadersForParticleMaterial(ps, particleRenderable, featureSet);
if (shaderPipeline) {
QSSGParticleRenderer::rhiPrepareRenderable(*shaderPipeline, passKey, rhiCtx, ps, particleRenderable, inData, renderPassDescriptor, samples, viewCount,
alteredCamera, cubeFace, entry, oit);
}
break;
}
}
}
void RenderHelpers::rhiPrepareRenderable(QSSGRhiContext *rhiCtx,
QSSGPassKey passKey,
const QSSGLayerRenderData &inData,
QSSGRenderableObject &inObject,
QRhiRenderPassDescriptor *renderPassDescriptor,
QSSGRhiGraphicsPipelineState *ps,
QSSGShaderFeatures featureSet,
int samples,
int viewCount,
QSSGRenderCamera *alteredCamera,
QMatrix4x4 *alteredModelViewProjection,
QSSGRenderTextureCubeFace cubeFace,
QSSGReflectionMapEntry *entry,
bool oit)
{
rhiPrepareRenderableImp(rhiCtx, passKey, inData, inObject, renderPassDescriptor, ps, featureSet, samples, viewCount,
false, alteredCamera, alteredModelViewProjection, cubeFace, entry, oit);
}
void RenderHelpers::rhiPrepareRenderableForScreenMapPass(QSSGRhiContext *rhiCtx,
QSSGPassKey passKey,
const QSSGLayerRenderData &inData,
QSSGRenderableObject &inObject,
QRhiRenderPassDescriptor *renderPassDescriptor,
QSSGRhiGraphicsPipelineState *ps,
QSSGShaderFeatures featureSet,
int samples,
int viewCount,
QSSGRenderCamera *alteredCamera,
QMatrix4x4 *alteredModelViewProjection,
QSSGRenderTextureCubeFace cubeFace,
QSSGReflectionMapEntry *entry,
bool oit)
{
rhiPrepareRenderableImp(rhiCtx, passKey, inData, inObject, renderPassDescriptor, ps, featureSet, samples, viewCount,
true, alteredCamera, alteredModelViewProjection, cubeFace, entry, oit);
}
void RenderHelpers::rhiRenderRenderable(QSSGRhiContext *rhiCtx,
const QSSGRhiGraphicsPipelineState &state,
QSSGRenderableObject &object,
bool *needsSetViewport,
QSSGRenderTextureCubeFace cubeFace,
qsizetype userPassIndex)
{
switch (object.type) {
case QSSGRenderableObject::Type::DefaultMaterialMeshSubset:
{
QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(object));
QSSG_ASSERT(QSSGUserRenderPassManager::maxUserPassSlots() == std::size(subsetRenderable.rhiRenderData.userPassData), return);
QRhiGraphicsPipeline *ps = (userPassIndex >= 0 && size_t(userPassIndex) < QSSGUserRenderPassManager::maxUserPassSlots())
? subsetRenderable.rhiRenderData.userPassData[userPassIndex].pipeline : subsetRenderable.rhiRenderData.mainPass.pipeline;
QRhiShaderResourceBindings *srb = (userPassIndex >= 0 && size_t(userPassIndex) < QSSGUserRenderPassManager::maxUserPassSlots())
? subsetRenderable.rhiRenderData.userPassData[userPassIndex].srb : subsetRenderable.rhiRenderData.mainPass.srb;
if (cubeFace != QSSGRenderTextureCubeFaceNone) {
const auto cubeFaceIdx = QSSGBaseTypeHelpers::indexOfCubeFace(cubeFace);
ps = subsetRenderable.rhiRenderData.reflectionPass.pipeline;
srb = subsetRenderable.rhiRenderData.reflectionPass.srb[cubeFaceIdx];
}
if (!ps || !srb)
return;
QRhiBuffer *vertexBuffer = subsetRenderable.subset.rhi.vertexBuffer->buffer();
QRhiBuffer *indexBuffer = subsetRenderable.subset.rhi.indexBuffer ? subsetRenderable.subset.rhi.indexBuffer->buffer() : nullptr;
QRhiCommandBuffer *cb = rhiCtx->commandBuffer();
// QRhi optimizes out unnecessary binding of the same pipline
cb->setGraphicsPipeline(ps);
cb->setShaderResources(srb);
if (*needsSetViewport) {
cb->setViewport(state.viewport);
if (state.flags.testFlag(QSSGRhiGraphicsPipelineState::Flag::UsesScissor))
cb->setScissor(state.scissor);
*needsSetViewport = false;
}
QRhiCommandBuffer::VertexInput vertexBuffers[2];
int vertexBufferCount = 1;
vertexBuffers[0] = QRhiCommandBuffer::VertexInput(vertexBuffer, 0);
quint32 instances = 1;
if ( subsetRenderable.modelContext.model.instancing()) {
instances = subsetRenderable.modelContext.model.instanceCount();
// If the instance count is 0, the bail out before trying to do any
// draw calls. Making an instanced draw call with a count of 0 is invalid
// for Metal and likely other API's as well.
// It is possible that the particale system may produce 0 instances here
if (instances == 0)
return;
vertexBuffers[1] = QRhiCommandBuffer::VertexInput(subsetRenderable.instanceBuffer, 0);
vertexBufferCount = 2;
}
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderCall);
if (state.flags.testFlag(QSSGRhiGraphicsPipelineState::Flag::UsesStencilRef))
cb->setStencilRef(state.stencilRef);
if (indexBuffer) {
cb->setVertexInput(0, vertexBufferCount, vertexBuffers, indexBuffer, 0, subsetRenderable.subset.rhi.indexBuffer->indexFormat());
cb->drawIndexed(subsetRenderable.subset.lodCount(subsetRenderable.subsetLevelOfDetail), instances, subsetRenderable.subset.lodOffset(subsetRenderable.subsetLevelOfDetail));
QSSGRHICTX_STAT(rhiCtx, drawIndexed(subsetRenderable.subset.lodCount(subsetRenderable.subsetLevelOfDetail), instances));
} else {
cb->setVertexInput(0, vertexBufferCount, vertexBuffers);
cb->draw(subsetRenderable.subset.count, instances, subsetRenderable.subset.offset);
QSSGRHICTX_STAT(rhiCtx, draw(subsetRenderable.subset.count, instances));
}
Q_QUICK3D_PROFILE_END_WITH_IDS(QQuick3DProfiler::Quick3DRenderCall, (subsetRenderable.subset.count | quint64(instances) << 32),
QVector<int>({subsetRenderable.modelContext.model.profilingId,
subsetRenderable.material.profilingId}));
break;
}
case QSSGRenderableObject::Type::CustomMaterialMeshSubset:
{
QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(object));
QSSGCustomMaterialSystem &customMaterialSystem(*subsetRenderable.renderer->contextInterface()->customMaterialSystem().get());
customMaterialSystem.rhiRenderRenderable(rhiCtx, subsetRenderable, needsSetViewport, cubeFace, state, userPassIndex);
break;
}
case QSSGRenderableObject::Type::Particles:
{
QSSGParticlesRenderable &renderable(static_cast<QSSGParticlesRenderable &>(object));
QSSGParticleRenderer::rhiRenderRenderable(rhiCtx, renderable, needsSetViewport, cubeFace, state);
break;
}
}
}
static QRhiViewport calculateAtlasViewport(QSize atlasPixelSize, const QSSGShadowMapEntry::AtlasEntry &atlasEntry, bool yIsUp) {
// Convert normalized offsets/scales to actual pixel values
float x = atlasEntry.uOffset * atlasPixelSize.width();
float w = atlasEntry.uvScale * atlasPixelSize.width();
float h = atlasEntry.uvScale * atlasPixelSize.height();
// Y in atlasEntry is top-based, whereas QRhiViewport is bottom-based
// topY in pixel = atlasEntry.vOffset * atlasPixelSize.height()
// so bottom-left Y = totalHeight - topY - h
float y;
if (!yIsUp)
y = atlasPixelSize.height() - (atlasEntry.vOffset * atlasPixelSize.height()) - h;
else
y = atlasEntry.vOffset * atlasPixelSize.height();
return QRhiViewport(x, y, w, h);
}
void RenderHelpers::rhiRenderShadowMap(QSSGRhiContext *rhiCtx,
QSSGPassKey passKey,
QSSGRhiGraphicsPipelineState &ps,
QSSGRenderShadowMap &shadowMapManager,
const QSSGRenderCamera &camera,
QSSGRenderCamera *debugCamera,
const QSSGShaderLightList &globalLights,
const QSSGRenderableObjectList &sortedOpaqueObjects,
QSSGRenderer &renderer,
const QSSGBounds3 &castingObjectsBox,
const QSSGBounds3 &receivingObjectsBox)
{
const QSSGLayerRenderData &layerData = *QSSGLayerRenderData::getCurrent(renderer);
QSSGDebugDrawSystem *debugDrawSystem = renderer.contextInterface()->debugDrawSystem().get();
const bool drawDirectionalLightShadowBoxes = layerData.layer.drawDirectionalLightShadowBoxes;
const bool drawPointLightShadowBoxes = layerData.layer.drawPointLightShadowBoxes;
const bool drawShadowCastingBounds = layerData.layer.drawShadowCastingBounds;
const bool drawShadowReceivingBounds = layerData.layer.drawShadowReceivingBounds;
const bool drawCascades = layerData.layer.drawCascades;
const bool drawSceneCascadeIntersection = layerData.layer.drawSceneCascadeIntersection;
const bool disableShadowCameraUpdate = layerData.layer.disableShadowCameraUpdate;
const bool drawCulledObjects = layerData.layer.drawCulledObjects;
QVector<bool> debugIsObjectCulled = drawCulledObjects ? QVector<bool>(sortedOpaqueObjects.size(), true) : QVector<bool>();
static const auto rhiRenderOneShadowMap = [](QSSGRhiContext *rhiCtx,
QSSGRhiGraphicsPipelineState *ps,
const QSSGRenderableObjectList &sortedOpaqueObjects,
int cubeFace,
const QSSGBounds3 cameraBounds,
QVector<bool> &debugIsObjectCulled,
bool drawCulledObjects) {
QRhiCommandBuffer *cb = rhiCtx->commandBuffer();
bool needsSetViewport = true;
for (int i = 0, n = sortedOpaqueObjects.size(); i < n; ++i) {
const QSSGRenderableObjectHandle &handle = sortedOpaqueObjects[i];
QSSGRenderableObject *theObject = handle.obj;
// Only attempt to cull models if both of its bounds are valid
if (theObject->globalBoundsInstancing.isFinite() && theObject->globalBounds.isFinite()) {
const QSSGBounds3 &globalBounds = !theObject->globalBoundsInstancing.isEmpty() ? theObject->globalBoundsInstancing
: theObject->globalBounds;
if (!globalBounds.isEmpty() && !cameraBounds.intersects(globalBounds)) {
continue;
}
}
if (Q_UNLIKELY(drawCulledObjects))
debugIsObjectCulled[i] = false;
QSSG_ASSERT(theObject->renderableFlags.castsShadows(), continue);
if (theObject->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || theObject->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QSSGSubsetRenderable *renderable(static_cast<QSSGSubsetRenderable *>(theObject));
QRhiBuffer *vertexBuffer = renderable->subset.rhi.vertexBuffer->buffer();
QRhiBuffer *indexBuffer = renderable->subset.rhi.indexBuffer
? renderable->subset.rhi.indexBuffer->buffer()
: nullptr;
// Ideally we shouldn't need to deal with this, as only "valid" objects should be processed at this point.
if (!renderable->rhiRenderData.shadowPass.pipeline)
continue;
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderCall);
cb->setGraphicsPipeline(renderable->rhiRenderData.shadowPass.pipeline);
QRhiShaderResourceBindings *srb = renderable->rhiRenderData.shadowPass.srb[cubeFace];
cb->setShaderResources(srb);
if (needsSetViewport) {
cb->setViewport(ps->viewport);
needsSetViewport = false;
}
QRhiCommandBuffer::VertexInput vertexBuffers[2];
int vertexBufferCount = 1;
vertexBuffers[0] = QRhiCommandBuffer::VertexInput(vertexBuffer, 0);
quint32 instances = 1;
if (renderable->modelContext.model.instancing()) {
instances = renderable->modelContext.model.instanceCount();
vertexBuffers[1] = QRhiCommandBuffer::VertexInput(renderable->instanceBuffer, 0);
vertexBufferCount = 2;
}
if (indexBuffer) {
cb->setVertexInput(0, vertexBufferCount, vertexBuffers, indexBuffer, 0, renderable->subset.rhi.indexBuffer->indexFormat());
cb->drawIndexed(renderable->subset.lodCount(renderable->subsetLevelOfDetail), instances, renderable->subset.lodOffset(renderable->subsetLevelOfDetail));
QSSGRHICTX_STAT(rhiCtx, drawIndexed(renderable->subset.lodCount(renderable->subsetLevelOfDetail), instances));
} else {
cb->setVertexInput(0, vertexBufferCount, vertexBuffers);
cb->draw(renderable->subset.count, instances, renderable->subset.offset);
QSSGRHICTX_STAT(rhiCtx, draw(renderable->subset.count, instances));
}
Q_QUICK3D_PROFILE_END_WITH_IDS(QQuick3DProfiler::Quick3DRenderCall, (renderable->subset.count | quint64(instances) << 32),
QVector<int>({renderable->modelContext.model.profilingId,
renderable->material.profilingId}));
}
}
};
static const auto rhiClearShadowMap = [](QSSGRenderer &renderer, QSSGRenderShadowMap &shadowMapManager, QSSGRhiContext *rhiCtx, QSSGRhiGraphicsPipelineState *ps, QRhiRenderPassDescriptor *renderPassDesc) {
auto clearShadowMapShaderPipeline = renderer.contextInterface()->shaderCache()->getBuiltInRhiShaders().getRhiClearShadowMapShader();
QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(*ps, clearShadowMapShaderPipeline.get());
// Disable Depth Test and Depth Write
ps->flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::DepthTestEnabled, false);
ps->flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled, false);
renderer.rhiQuadRenderer()->recordRenderQuad(rhiCtx, ps, shadowMapManager.shadowClearSrb(), renderPassDesc, {});
// Reset
ps->flags |= { QSSGRhiGraphicsPipelineState::Flag::DepthTestEnabled, QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled };
};
QRhi *rhi = rhiCtx->rhi();
QRhiCommandBuffer *cb = rhiCtx->commandBuffer();
// We need to deal with a clip depth range of [0, 1] or
// [-1, 1], depending on the graphics API underneath.
QVector2D depthAdjust; // (d + depthAdjust[0]) * depthAdjust[1] = d mapped to [0, 1]
if (rhi->isClipDepthZeroToOne()) {
// d is [0, 1] so no need for any mapping
depthAdjust[0] = 0.0f;
depthAdjust[1] = 1.0f;
} else {
// d is [-1, 1]
depthAdjust[0] = 1.0f;
depthAdjust[1] = 0.5f;
}
if (drawShadowCastingBounds)
ShadowmapHelpers::addDebugBox(castingObjectsBox.toQSSGBoxPointsNoEmptyCheck(), QColorConstants::Red, debugDrawSystem);
if (drawShadowReceivingBounds)
ShadowmapHelpers::addDebugBox(receivingObjectsBox.toQSSGBoxPointsNoEmptyCheck(), QColorConstants::Green, debugDrawSystem);
// Create shadow map for each light in the scene
const QSize atlasTextureSize = shadowMapManager.shadowMapAtlasTexture()->pixelSize();
// Make sure quad renderer is ready
renderer.rhiQuadRenderer()->prepareQuad(rhiCtx, nullptr);
for (int i = 0, ie = globalLights.size(); i != ie; ++i) {
if (!globalLights[i].shadows || globalLights[i].light->m_fullyBaked)
continue;
QSSGShadowMapEntry *pEntry = shadowMapManager.shadowMapEntry(i);
if (!pEntry)
continue;
const auto &light = globalLights[i].light;
if (!shadowMapManager.shadowMapAtlasTexture())
break;
if (light->type == QSSGRenderLight::Type::DirectionalLight || light->type == QSSGRenderLight::Type::SpotLight) {
const QSize size = atlasTextureSize * pEntry->m_atlasInfo[0].uvScale;
// This is just a way to store the old camera so we can use it for debug
// drawing. There are probably cleaner ways to do this
if (!disableShadowCameraUpdate && debugCamera) {
debugCamera->clipPlanes = camera.clipPlanes;
debugCamera->projection = camera.projection;
// NOTE: Since the debug camera is an internally injected camera, there will only be
// the local transform. Anywhere the global transform is looked up for the debug camera
// it will return the local transform.
debugCamera->localTransform = layerData.getGlobalTransform(camera);
}
QVarLengthArray<std::unique_ptr<QSSGRenderCamera>, 4> cascades;
if (light->type == QSSGRenderLight::Type::DirectionalLight) {
const float pcfRadius = light->m_softShadowQuality == QSSGRenderLight::SoftShadowQuality::Hard ? 0.f : light->m_pcfFactor;
const float clipNear = camera.clipPlanes.clipNear();
const float clipFar = qMin(light->m_shadowMapFar, camera.clipPlanes.clipFar());
const float clipRange = clipFar - clipNear;
cascades = setupCascadingCamerasForShadowMap(layerData,
disableShadowCameraUpdate ? *debugCamera : camera,
light,
size.width(),
pcfRadius,
clipNear,
clipFar,
castingObjectsBox,
receivingObjectsBox,
light->m_lockShadowmapTexels,
debugDrawSystem,
drawCascades,
drawSceneCascadeIntersection);
// Write the split distances from value 0 in the z-axis of the eye view-space
pEntry->m_csmSplits[0] = clipNear + clipRange * (light->m_csmNumSplits > 0 ? light->m_csmSplit1 : 1.0f);
pEntry->m_csmSplits[1] = clipNear + clipRange * (light->m_csmNumSplits > 1 ? light->m_csmSplit2 : 1.0f);
pEntry->m_csmSplits[2] = clipNear + clipRange * (light->m_csmNumSplits > 2 ? light->m_csmSplit3 : 1.0f);
pEntry->m_csmSplits[3] = clipNear + clipRange * 1.0f;
pEntry->m_shadowMapFar = clipFar;
} else if (light->type == QSSGRenderLight::Type::SpotLight) {
auto spotlightCamera = std::make_unique<QSSGRenderCamera>(QSSGRenderCamera::Type::PerspectiveCamera);
spotlightCamera->fov = QSSGRenderCamera::FieldOfView::fromDegrees(light->m_coneAngle * 2.0f);
spotlightCamera->clipPlanes = { 1.0f, light->m_shadowMapFar };
const QMatrix4x4 lightGlobalTransform = layerData.getGlobalTransform(*light);
const QVector3D lightDir = QSSGRenderNode::getDirection(lightGlobalTransform);
const QVector3D lightPos = QSSGRenderNode::getGlobalPos(lightGlobalTransform) - lightDir * spotlightCamera->clipPlanes.clipNear();
const QVector3D lightPivot = light->pivot;
const QVector3D forward = lightDir.normalized();
const QVector3D right = qFuzzyCompare(qAbs(forward.y()), 1.0f)
? QVector3D::crossProduct(forward, QVector3D(1, 0, 0)).normalized()
: QVector3D::crossProduct(forward, QVector3D(0, 1, 0)).normalized();
const QVector3D up = QVector3D::crossProduct(right, forward).normalized();
spotlightCamera->localTransform = QSSGRenderNode::calculateTransformMatrix(lightPos,
QSSGRenderNode::initScale,
lightPivot,
QQuaternion::fromDirection(forward, up));
QRectF theViewport(0.0f, 0.0f, (float)light->m_shadowMapRes, (float)light->m_shadowMapRes);
QSSGRenderCamera::calculateProjectionInternal(*spotlightCamera, theViewport);
cascades.push_back(std::move(spotlightCamera));
pEntry->m_shadowMapFar = light->m_shadowMapFar;
} else {
Q_UNREACHABLE();
}
memset(pEntry->m_csmActive, 0, sizeof(pEntry->m_csmActive));
QMatrix4x4 cascadeCameraGlobalTransforms(Qt::Uninitialized);
const QMatrix4x4 bias = { 0.5, 0.0, 0.0, 0.5,
0.0, 0.5, 0.0, 0.5,
0.0, 0.0, 0.5, 0.5,
0.0, 0.0, 0.0, 1.0 };
for (int cascadeIndex = 0; cascadeIndex < cascades.length(); cascadeIndex++) {
const auto &cascadeCamera = cascades[cascadeIndex];
if (!cascadeCamera)
continue;
cascadeCameraGlobalTransforms = layerData.getGlobalTransform(*cascadeCamera);
pEntry->m_csmActive[cascadeIndex] = 1.f;
QMatrix4x4 &viewProjection = pEntry->m_lightViewProjection[cascadeIndex];
cascadeCamera->calculateViewProjectionMatrix(cascadeCameraGlobalTransforms, viewProjection);
pEntry->m_lightViewProjection[cascadeIndex] = viewProjection;
pEntry->m_fixedScaleBiasMatrix[cascadeIndex] = bias * viewProjection;
const QMatrix4x4 inverted = viewProjection.inverted();
const float x = 0.5f / (inverted * QVector4D(1, 0, 0, 0)).length();
const float y = 0.5f / (inverted * QVector4D(0, 1, 0, 0)).length();
const float z = 0.5f / (inverted * QVector4D(0, 0, 1, 0)).length();
const QSSGBoxPoints frustumPoints = computeFrustumBounds(viewProjection);
const QSSGBounds3 bounds = QSSGBounds3(frustumPoints);
pEntry->m_dimensionsInverted[cascadeIndex] = QVector4D(x, y, z, 0.0f);
pEntry->m_lightView = cascadeCameraGlobalTransforms.inverted(); // pre-calculate this for the material
const bool isOrtho = cascadeCamera->type == QSSGRenderGraphObject::Type::OrthographicCamera;
ps.viewport = calculateAtlasViewport(atlasTextureSize, pEntry->m_atlasInfo[cascadeIndex], rhi->isYUpInFramebuffer());
rhiPrepareResourcesForShadowMap(rhiCtx, layerData, passKey, pEntry, &ps, &depthAdjust, sortedOpaqueObjects, *cascadeCamera, isOrtho, QSSGRenderTextureCubeFaceNone, cascadeIndex);
// Render into the 2D texture pEntry->m_rhiDepthMap, using
// pEntry->m_rhiDepthStencil as the (throwaway) depth/stencil buffer.
QRhiTextureRenderTarget *rt = pEntry->m_rhiRenderTargets[cascadeIndex];
cb->beginPass(rt, Qt::white, { 1.0f, 0 }, nullptr, rhiCtx->commonPassFlags());
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);
QSSGRHICTX_STAT(rhiCtx, beginRenderPass(rt));
rhiClearShadowMap(renderer, shadowMapManager, rhiCtx, &ps, rt->renderPassDescriptor());
rhiRenderOneShadowMap(rhiCtx, &ps, sortedOpaqueObjects, 0, bounds, debugIsObjectCulled, drawCulledObjects);
cb->endPass();
QSSGRHICTX_STAT(rhiCtx, endRenderPass());
if (drawDirectionalLightShadowBoxes) {
ShadowmapHelpers::addDirectionalLightDebugBox(frustumPoints, debugDrawSystem);
}
}
Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("shadow_map"));
} else { // Point Light
const QSize size = atlasTextureSize * pEntry->m_atlasInfo[0].uvScale;
ps.viewport = QRhiViewport(0, 0, float(size.width()), float(size.height()));
QSSGRenderCamera theCameras[6] { QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera},
QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera},
QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera},
QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera},
QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera},
QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera} };
const float shadowMapFar = qMax<float>(2.0f, light->m_shadowMapFar);
setupCubeShadowCameras(layerData, light, shadowMapFar, theCameras);
pEntry->m_lightView = QMatrix4x4();
pEntry->m_shadowMapFar = shadowMapFar;
const bool swapYFaces = !rhi->isYUpInFramebuffer();
QMatrix4x4 cameraGlobalTransform(Qt::Uninitialized);
for (const auto face : QSSGRenderTextureCubeFaces) {
cameraGlobalTransform = layerData.getGlobalTransform(theCameras[quint8(face)]);
theCameras[quint8(face)].calculateViewProjectionMatrix(cameraGlobalTransform, pEntry->m_lightViewProjection[0]);
pEntry->m_lightCubeView[quint8(face)] = cameraGlobalTransform.inverted(); // pre-calculate this for the material
rhiPrepareResourcesForShadowMap(rhiCtx,
layerData,
passKey,
pEntry,
&ps,
&depthAdjust,
sortedOpaqueObjects,
theCameras[quint8(face)],
false,
face,
0);
}
// The bounds should be the same for all view projections of the cube
const QVector3D center = QSSGRenderNode::getGlobalPos(layerData.getGlobalTransform(*light));
const QSSGBounds3 bounds = QSSGBounds3(center - QVector3D(shadowMapFar, shadowMapFar, shadowMapFar),
center + QVector3D(shadowMapFar, shadowMapFar, shadowMapFar));
for (const auto face : QSSGRenderTextureCubeFaces) {
// Render into one face of the cubemap texture pEntry->m_rhiDephCube, using
// pEntry->m_rhiDepthStencil as the (throwaway) depth/stencil buffer.
QSSGRenderTextureCubeFace outFace = face;
// FACE S T GL
// +x -z, -y right
// -x +z, -y left
// +y +x, +z top
// -y +x, -z bottom
// +z +x, -y front
// -z -x, -y back
// FACE S T D3D
// +x -z, +y right
// -x +z, +y left
// +y +x, -z bottom
// -y +x, +z top
// +z +x, +y front
// -z -x, +y back
if (swapYFaces) {
// +Y and -Y faces get swapped (D3D, Vulkan, Metal).
// See shadowMapping.glsllib. This is complemented there by reversing T as well.
if (outFace == QSSGRenderTextureCubeFace::PosY)
outFace = QSSGRenderTextureCubeFace::NegY;
else if (outFace == QSSGRenderTextureCubeFace::NegY)
outFace = QSSGRenderTextureCubeFace::PosY;
}
QRhiTextureRenderTarget *rt = pEntry->m_rhiRenderTargetCube[quint8(outFace)];
cb->beginPass(rt, Qt::white, { 1.0f, 0 }, nullptr, rhiCtx->commonPassFlags());
QSSGRHICTX_STAT(rhiCtx, beginRenderPass(rt));
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);
rhiRenderOneShadowMap(rhiCtx, &ps, sortedOpaqueObjects, quint8(face), bounds, debugIsObjectCulled, drawCulledObjects);
cb->endPass();
QSSGRHICTX_STAT(rhiCtx, endRenderPass());
Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QSSG_RENDERPASS_NAME("shadow_cube", 0, outFace));
}
// Render the CubeMap into the shadowMapAtlasTexture
// NOTE: These passes don't require a manual clear because we will always write every pixel in that atlas space
// Render the front hemisphere of the cube map into the shadow map atlas
QRhiTextureRenderTarget *rtFront = pEntry->m_rhiRenderTargets[0]; // A layer in the Atlas
QRhiRenderPassDescriptor *frontDesc = pEntry->m_rhiRenderPassDesc[0];
auto atlasShaderPipeline = renderer.contextInterface()->shaderCache()->getBuiltInRhiShaders().getRhiCubeMapToAtlasShader();
ps.viewport = calculateAtlasViewport(atlasTextureSize, pEntry->m_atlasInfo[0], rhi->isYUpInFramebuffer());
QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, atlasShaderPipeline.get());
QRhiShaderResourceBindings *srb = pEntry->m_cubeToAtlasFrontSrb;
cb->beginPass(rtFront, Qt::white, { 1.0f, 0 }, nullptr, rhiCtx->commonPassFlags());
QSSGRHICTX_STAT(rhiCtx, beginRenderPass(rtFront));
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);
renderer.rhiQuadRenderer()->recordRenderQuad(rhiCtx, &ps, srb, frontDesc, QSSGRhiQuadRenderer::UvCoords);
cb->endPass();
QSSGRHICTX_STAT(rhiCtx, endRenderPass());
Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QSSG_RENDERPASS_NAME("shadow_atlas", 6, 0));
// Render the back hemisphere of the cube map into the shadow map atlas
QRhiTextureRenderTarget *rtBack = pEntry->m_rhiRenderTargets[1]; // A layer in the Atlas
QRhiRenderPassDescriptor *backDesc = pEntry->m_rhiRenderPassDesc[1];
srb = pEntry->m_cubeToAtlasBackSrb;
ps.viewport = calculateAtlasViewport(atlasTextureSize, pEntry->m_atlasInfo[1], rhi->isYUpInFramebuffer());
cb->beginPass(rtBack, Qt::white, { 1.0f, 0 }, nullptr, rhiCtx->commonPassFlags());
QSSGRHICTX_STAT(rhiCtx, beginRenderPass(rtBack));
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);
renderer.rhiQuadRenderer()->recordRenderQuad(rhiCtx, &ps, srb, backDesc, QSSGRhiQuadRenderer::UvCoords);
cb->endPass();
QSSGRHICTX_STAT(rhiCtx, endRenderPass());
Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QSSG_RENDERPASS_NAME("shadow_atlas", 7, 0));
// reset pipeline (This part is necessary, but not ideal)
ps = layerData.getPipelineState();
ps.flags |= { QSSGRhiGraphicsPipelineState::Flag::DepthTestEnabled, QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled };
ps.depthBias = 2;
ps.slopeScaledDepthBias = 1.5f;
if (drawPointLightShadowBoxes) {
ShadowmapHelpers::addDebugBox(bounds.toQSSGBoxPoints(), QColorConstants::Yellow, debugDrawSystem);
}
}
}
if (Q_UNLIKELY(drawCulledObjects)) {
for (int i = 0, n = sortedOpaqueObjects.size(); i < n; ++i) {
QSSGRenderableObject *theObject = sortedOpaqueObjects[i].obj;
const QSSGBounds3 &globalBounds = !theObject->globalBoundsInstancing.isEmpty() ? theObject->globalBoundsInstancing
: theObject->globalBounds;
const QColor color = debugIsObjectCulled[i] ? QColorConstants::Red : QColorConstants::Green;
ShadowmapHelpers::addDebugBox(globalBounds.toQSSGBoxPointsNoEmptyCheck(), color, debugDrawSystem);
}
}
}
void RenderHelpers::rhiRenderReflectionMap(const QSSGRenderContextInterface &context,
QSSGPassKey passKey,
const QSSGLayerRenderData &inData,
QSSGRhiGraphicsPipelineState *ps,
QSSGRenderReflectionMap &reflectionMapManager,
const std::vector<QSSGRenderReflectionProbe *> &reflectionProbes,
const QSSGRenderableObjectList &reflectionPassObjects,
QSSGRenderer &renderer)
{
QSSGRhiContext *rhiCtx = context.rhiContext().get();
QRhi *rhi = rhiCtx->rhi();
QRhiCommandBuffer *cb = rhiCtx->commandBuffer();
const bool renderSkybox = (inData.layer.background == QSSGRenderLayer::Background::SkyBox
|| inData.layer.background == QSSGRenderLayer::Background::SkyBoxCubeMap
|| inData.layer.background == QSSGRenderLayer::Background::SkyMaterial)
&& rhiCtx->rhi()->isFeatureSupported(QRhi::TexelFetch);
for (size_t i = 0, ie = reflectionProbes.size(); i != ie; ++i) {
QSSGReflectionMapEntry *pEntry = reflectionMapManager.reflectionMapEntry(int(i));
if (!pEntry)
continue;
if (!pEntry->m_needsRender)
continue;
if (reflectionProbes[i]->refreshMode == QSSGRenderReflectionProbe::ReflectionRefreshMode::FirstFrame && pEntry->m_rendered)
continue;
if (reflectionProbes[i]->texture)
continue;
Q_ASSERT(pEntry->m_rhiDepthStencil);
Q_ASSERT(pEntry->m_rhiCube);
const QSize size = pEntry->m_rhiCube->pixelSize();
ps->viewport = QRhiViewport(0, 0, float(size.width()), float(size.height()));
QSSGRenderCamera theCameras[6] { QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera},
QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera},
QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera},
QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera},
QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera},
QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera} };
setupCubeReflectionCameras(inData, reflectionProbes[i], theCameras);
const bool swapYFaces = !rhi->isYUpInFramebuffer();
QMatrix4x4 cameraGlobalTransform(Qt::Uninitialized);
for (const auto face : QSSGRenderTextureCubeFaces) {
const auto cubeFaceIdx = QSSGBaseTypeHelpers::indexOfCubeFace(face);
cameraGlobalTransform = inData.getGlobalTransform(theCameras[cubeFaceIdx]);
theCameras[cubeFaceIdx].calculateViewProjectionMatrix(cameraGlobalTransform, pEntry->m_viewProjection);
rhiPrepareResourcesForReflectionMap(context, passKey, inData, pEntry, ps, reflectionPassObjects, theCameras[cubeFaceIdx], renderer, face);
}
QRhiRenderPassDescriptor *renderPassDesc = nullptr;
for (auto face : QSSGRenderTextureCubeFaces) {
if (pEntry->m_timeSlicing == QSSGRenderReflectionProbe::ReflectionTimeSlicing::IndividualFaces)
face = pEntry->m_timeSliceFace;
QSSGRenderTextureCubeFace outFace = face;
// Faces are swapped similarly to shadow maps due to differences in backends
// Prefilter step handles correcting orientation differences in the final render
if (swapYFaces) {
if (outFace == QSSGRenderTextureCubeFace::PosY)
outFace = QSSGRenderTextureCubeFace::NegY;
else if (outFace == QSSGRenderTextureCubeFace::NegY)
outFace = QSSGRenderTextureCubeFace::PosY;
}
QRhiTextureRenderTarget *rt = pEntry->m_rhiRenderTargets[quint8(outFace)];
cb->beginPass(rt, reflectionProbes[i]->clearColor, { 1.0f, 0 }, nullptr, rhiCtx->commonPassFlags());
QSSGRHICTX_STAT(rhiCtx, beginRenderPass(rt));
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass);
if (renderSkybox && pEntry->m_skyBoxSrbs[quint8(face)]) {
const auto &shaderCache = renderer.contextInterface()->shaderCache();
const bool useSkyBoxQuad = inData.layer.background == QSSGRenderLayer::Background::SkyBox
|| inData.layer.background == QSSGRenderLayer::Background::SkyMaterial;
const auto &shaderPipeline = useSkyBoxQuad
? shaderCache->getBuiltInRhiShaders().getRhiSkyBoxShader(QSSGRenderLayer::TonemapMode::None,
inData.layer.skyBoxIsRgbe8,
1)
: shaderCache->getBuiltInRhiShaders().getRhiSkyBoxCubeShader(QSSGRenderLayer::TonemapMode::None,
!inData.layer.skyBoxIsSrgb,
1);
Q_ASSERT(shaderPipeline);
QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(*ps, shaderPipeline.get());
QRhiShaderResourceBindings *srb = pEntry->m_skyBoxSrbs[quint8(face)];
if (!renderPassDesc)
renderPassDesc = rt->newCompatibleRenderPassDescriptor();
rt->setRenderPassDescriptor(renderPassDesc);
useSkyBoxQuad ? renderer.rhiQuadRenderer()->recordRenderQuad(rhiCtx, ps, srb, renderPassDesc, {})
: renderer.rhiCubeRenderer()->recordRenderCube(rhiCtx, ps, srb, renderPassDesc, {});
}
bool needsSetViewport = true;
for (const auto &handle : reflectionPassObjects)
rhiRenderRenderable(rhiCtx, *ps, *handle.obj, &needsSetViewport, face);
cb->endPass();
QSSGRHICTX_STAT(rhiCtx, endRenderPass());
Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QSSG_RENDERPASS_NAME("reflection_cube", 0, outFace));
if (pEntry->m_timeSlicing == QSSGRenderReflectionProbe::ReflectionTimeSlicing::IndividualFaces)
break;
}
if (renderPassDesc)
renderPassDesc->deleteLater();
pEntry->renderMips(rhiCtx);
if (pEntry->m_timeSlicing == QSSGRenderReflectionProbe::ReflectionTimeSlicing::IndividualFaces)
pEntry->m_timeSliceFace = QSSGBaseTypeHelpers::next(pEntry->m_timeSliceFace); // Wraps
if (reflectionProbes[i]->refreshMode == QSSGRenderReflectionProbe::ReflectionRefreshMode::FirstFrame)
pEntry->m_rendered = true;
reflectionProbes[i]->hasScheduledUpdate = false;
pEntry->m_needsRender = false;
}
}
bool RenderHelpers::rhiPrepareAoTexture(QSSGRhiContext *rhiCtx,
const QSize &size,
QSSGRhiRenderableTexture *renderableTex,
quint8 viewCount)
{
QRhi *rhi = rhiCtx->rhi();
bool needsBuild = false;
if (!renderableTex->texture) {
QRhiTexture::Flags flags = QRhiTexture::RenderTarget;
// the ambient occlusion texture is always non-msaa, even if multisampling is used in the main pass
if (viewCount <= 1)
renderableTex->texture = rhi->newTexture(QRhiTexture::RGBA8, size, 1, flags);
else
renderableTex->texture = rhi->newTextureArray(QRhiTexture::RGBA8, viewCount, size, 1, flags);
needsBuild = true;
} else if (renderableTex->texture->pixelSize() != size) {
renderableTex->texture->setPixelSize(size);
needsBuild = true;
}
if (needsBuild) {
if (!renderableTex->texture->create()) {
qWarning("Failed to build ambient occlusion texture (size %dx%d)", size.width(), size.height());
renderableTex->reset();
return false;
}
renderableTex->resetRenderTarget();
QRhiTextureRenderTargetDescription desc;
QRhiColorAttachment colorAttachment(renderableTex->texture);
colorAttachment.setMultiViewCount(viewCount);
desc.setColorAttachments({ colorAttachment });
renderableTex->rt = rhi->newTextureRenderTarget(desc);
renderableTex->rt->setName(QByteArrayLiteral("Ambient occlusion"));
renderableTex->rpDesc = renderableTex->rt->newCompatibleRenderPassDescriptor();
renderableTex->rt->setRenderPassDescriptor(renderableTex->rpDesc);
if (!renderableTex->rt->create()) {
qWarning("Failed to build render target for ambient occlusion texture");
renderableTex->reset();
return false;
}
}
return true;
}
void RenderHelpers::rhiRenderAoTexture(QSSGRhiContext *rhiCtx,
QSSGPassKey passKey,
QSSGRenderer &renderer,
QSSGRhiShaderPipeline &shaderPipeline,
QSSGRhiGraphicsPipelineState &ps,
const QSSGAmbientOcclusionSettings &ao,
const QSSGRhiRenderableTexture &rhiAoTexture,
const QSSGRhiRenderableTexture &rhiDepthTexture,
const QSSGRenderCamera &camera)
{
QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
// no texelFetch in GLSL <= 120 and GLSL ES 100
if (!rhiCtx->rhi()->isFeatureSupported(QRhi::TexelFetch)) {
QRhiCommandBuffer *cb = rhiCtx->commandBuffer();
// just clear and stop there
cb->beginPass(rhiAoTexture.rt, Qt::white, { 1.0f, 0 });
QSSGRHICTX_STAT(rhiCtx, beginRenderPass(rhiAoTexture.rt));
cb->endPass();
QSSGRHICTX_STAT(rhiCtx, endRenderPass());
return;
}
QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, &shaderPipeline);
const float R2 = ao.aoDistance * ao.aoDistance * 0.16f;
const QSize textureSize = rhiAoTexture.texture->pixelSize();
const float rw = float(textureSize.width());
const float rh = float(textureSize.height());
const float fov = camera.fov.asVerticalFov(rw / rh).radians();
const float tanHalfFovY = tanf(0.5f * fov * (rh / rw));
const float invFocalLenX = tanHalfFovY * (rw / rh);
const QVector4D aoProps(ao.aoStrength * 0.01f, ao.aoDistance * 0.4f, ao.aoSoftness * 0.02f, ao.aoBias);
const QVector4D aoProps2(float(ao.aoSamplerate), (ao.aoDither) ? 1.0f : 0.0f, 0.0f, 0.0f);
const QVector4D aoScreenConst(1.0f / R2, rh / (2.0f * tanHalfFovY), 1.0f / rw, 1.0f / rh);
const QVector4D uvToEyeConst(2.0f * invFocalLenX, -2.0f * tanHalfFovY, -invFocalLenX, tanHalfFovY);
const QVector2D cameraProps = camera.clipPlanes;
// layout(std140, binding = 0) uniform buf {
// vec4 aoProperties;
// vec4 aoProperties2;
// vec4 aoScreenConst;
// vec4 uvToEyeConst;
// vec2 cameraProperties;
const int UBUF_SIZE = 72;
QSSGRhiDrawCallData &dcd(rhiCtxD->drawCallData({ passKey, nullptr, nullptr, nullptr, 0 }));
if (!dcd.ubuf) {
dcd.ubuf = rhiCtx->rhi()->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, UBUF_SIZE);
dcd.ubuf->create();
}
char *ubufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
memcpy(ubufData, &aoProps, 16);
memcpy(ubufData + 16, &aoProps2, 16);
memcpy(ubufData + 32, &aoScreenConst, 16);
memcpy(ubufData + 48, &uvToEyeConst, 16);
memcpy(ubufData + 64, &cameraProps, 8);
dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame();
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None,
QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });
QSSGRhiShaderResourceBindingList bindings;
bindings.addUniformBuffer(0, RENDERER_VISIBILITY_ALL, dcd.ubuf);
// binding 1 is either a sampler2D or sampler2DArray, matching
// rhiDepthTexture.texture, no special casing needed here
bindings.addTexture(1, QRhiShaderResourceBinding::FragmentStage, rhiDepthTexture.texture, sampler);
QRhiShaderResourceBindings *srb = rhiCtxD->srb(bindings);
renderer.rhiQuadRenderer()->prepareQuad(rhiCtx, nullptr);
renderer.rhiQuadRenderer()->recordRenderQuadPass(rhiCtx, &ps, srb, rhiAoTexture.rt, {});
}
bool RenderHelpers::rhiPrepareScreenTexture(QSSGRhiContext *rhiCtx,
const QSize &size,
bool wantsMips,
QSSGRhiRenderableTexture *renderableTex,
quint8 viewCount)
{
QRhi *rhi = rhiCtx->rhi();
bool needsBuild = false;
QRhiTexture::Flags flags = QRhiTexture::RenderTarget;
if (wantsMips)
flags |= QRhiTexture::MipMapped | QRhiTexture::UsedWithGenerateMips;
if (!renderableTex->texture) {
// always non-msaa, even if multisampling is used in the main pass
if (viewCount <= 1)
renderableTex->texture = rhi->newTexture(QRhiTexture::RGBA8, size, 1, flags);
else
renderableTex->texture = rhi->newTextureArray(QRhiTexture::RGBA8, viewCount, size, 1, flags);
needsBuild = true;
} else if (renderableTex->texture->pixelSize() != size) {
renderableTex->texture->setPixelSize(size);
needsBuild = true;
}
if (!renderableTex->depthStencil && !renderableTex->depthTexture) {
if (viewCount <= 1)
renderableTex->depthStencil = rhi->newRenderBuffer(QRhiRenderBuffer::DepthStencil, size);
else
renderableTex->depthTexture = rhi->newTextureArray(QRhiTexture::D24S8, viewCount, size, 1, QRhiTexture::RenderTarget);
needsBuild = true;
} else {
if (renderableTex->depthStencil && renderableTex->depthStencil->pixelSize() != size) {
renderableTex->depthStencil->setPixelSize(size);
needsBuild = true;
} else if (renderableTex->depthTexture && renderableTex->depthTexture->pixelSize() != size) {
renderableTex->depthTexture->setPixelSize(size);
needsBuild = true;
}
}
if (needsBuild) {
if (!renderableTex->texture->create()) {
qWarning("Failed to build screen texture (size %dx%d)", size.width(), size.height());
renderableTex->reset();
return false;
}
if (renderableTex->depthStencil && !renderableTex->depthStencil->create()) {
qWarning("Failed to build depth-stencil buffer for screen texture (size %dx%d)",
size.width(), size.height());
renderableTex->reset();
return false;
} else if (renderableTex->depthTexture && !renderableTex->depthTexture->create()) {
qWarning("Failed to build depth-stencil texture array (multiview) for screen texture (size %dx%d)",
size.width(), size.height());
renderableTex->reset();
return false;
}
renderableTex->resetRenderTarget();
QRhiTextureRenderTargetDescription desc;
QRhiColorAttachment colorAttachment(renderableTex->texture);
colorAttachment.setMultiViewCount(viewCount);
desc.setColorAttachments({ colorAttachment });
if (renderableTex->depthStencil)
desc.setDepthStencilBuffer(renderableTex->depthStencil);
else if (renderableTex->depthTexture)
desc.setDepthTexture(renderableTex->depthTexture);
renderableTex->rt = rhi->newTextureRenderTarget(desc);
renderableTex->rt->setName(QByteArrayLiteral("Screen texture"));
renderableTex->rpDesc = renderableTex->rt->newCompatibleRenderPassDescriptor();
renderableTex->rt->setRenderPassDescriptor(renderableTex->rpDesc);
if (!renderableTex->rt->create()) {
qWarning("Failed to build render target for screen texture");
renderableTex->reset();
return false;
}
}
return true;
}
void RenderHelpers::rhiPrepareGrid(QSSGRhiContext *rhiCtx, QSSGPassKey passKey, QSSGRenderLayer &layer, QSSGRenderCameraList &cameras, QSSGRenderer &renderer)
{
QSSG_ASSERT(layer.renderData, return);
const auto *renderData = layer.renderData;
QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
QRhiCommandBuffer *cb = rhiCtx->commandBuffer();
cb->debugMarkBegin(QByteArrayLiteral("Quick3D prepare grid"));
QSSGRhiShaderResourceBindingList bindings;
int uniformBinding = 0;
const int ubufSize = cameras.count() >= 2 ? 276 : 148;
QSSGRhiDrawCallData &dcd(rhiCtxD->drawCallData({ passKey, nullptr, nullptr, nullptr, 0 })); // Change to Grid?
QRhi *rhi = rhiCtx->rhi();
if (!dcd.ubuf) {
dcd.ubuf = rhi->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, ubufSize);
dcd.ubuf->create();
}
// Param
const auto clipPlanes = cameras[0]->clipPlanes;
const float scale = layer.gridScale;
const quint32 gridFlags = layer.gridFlags;
const float yFactor = rhi->isYUpInNDC() ? 1.0f : -1.0f;
quint32 ubufOffset = 0;
char *ubufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
QMatrix4x4 cameraGlobalTransform(Qt::Uninitialized);
QMatrix4x4 viewProj(Qt::Uninitialized);
for (qsizetype viewIdx = 0; viewIdx < cameras.count(); ++viewIdx) {
cameraGlobalTransform = renderData->getGlobalTransform(*cameras[viewIdx]);
cameras[viewIdx]->calculateViewProjectionMatrix(cameraGlobalTransform, viewProj);
QMatrix4x4 invViewProj = viewProj.inverted();
quint32 viewDataOffset = ubufOffset;
memcpy(ubufData + viewDataOffset + viewIdx * 64, viewProj.constData(), 64);
viewDataOffset += 64 * cameras.count();
memcpy(ubufData + viewDataOffset + viewIdx * 64, invViewProj.constData(), 64);
}
ubufOffset += (64 + 64) * cameras.count();
memcpy(ubufData + ubufOffset, &clipPlanes, 8);
ubufOffset += 8;
memcpy(ubufData + ubufOffset, &scale, 4);
ubufOffset += 4;
memcpy(ubufData + ubufOffset, &yFactor, 4);
ubufOffset += 4;
memcpy(ubufData + ubufOffset, &gridFlags, 4);
dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame();
bindings.addUniformBuffer(uniformBinding, RENDERER_VISIBILITY_ALL, dcd.ubuf);
layer.gridSrb = rhiCtxD->srb(bindings);
renderer.rhiQuadRenderer()->prepareQuad(rhiCtx, nullptr);
cb->debugMarkEnd();
}
static void rhiPrepareSkyBox_helper(const QSSGRenderContextInterface &context,
QSSGPassKey passKey,
QSSGRenderLayer &layer,
QSSGRenderCameraList &cameras,
QSSGRenderer &renderer,
QSSGReflectionMapEntry *entry = nullptr,
QSSGRenderTextureCubeFace cubeFace = QSSGRenderTextureCubeFaceNone,
uint tonemapMode = 0)
{
QSSG_ASSERT(layer.renderData, return);
const auto *renderData = layer.renderData;
auto rhiCtx = context.rhiContext().get();
QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
QSSGRenderImageTexture lightProbeTexture;
switch (layer.background) {
case QSSGRenderLayer::Background::SkyBox:
lightProbeTexture = renderer.contextInterface()->bufferManager()->loadRenderImage(layer.lightProbe,
QSSGBufferManager::MipModeBsdf);
break;
case QSSGRenderLayer::Background::SkyBoxCubeMap:
lightProbeTexture = renderer.contextInterface()->bufferManager()->loadRenderImage(layer.skyBoxCubeMap,
QSSGBufferManager::MipModeDisable);
break;
case QSSGRenderLayer::Background::SkyMaterial:
lightProbeTexture = renderData->skyMaterialTexture;
break;
default:
Q_UNREACHABLE_RETURN();
}
if (lightProbeTexture.m_texture == nullptr) {
// No valid texture this frame; drop any previously built SRB rather than
// reuse one that may reference a texture ensureTextures() has since deleted.
if (cubeFace != QSSGRenderTextureCubeFaceNone) {
// All 6 face SRBs bind the same light probe texture, so all of them (not
// just the face passed in this call) are equally stale.
for (QRhiShaderResourceBindings *&srb : entry->m_skyBoxSrbs)
srb = nullptr;
} else {
layer.skyBoxSrb = nullptr;
}
return;
}
const bool cubeMapMode = layer.background == QSSGRenderLayer::Background::SkyBoxCubeMap;
if (cubeFace == QSSGRenderTextureCubeFaceNone)
layer.skyBoxIsRgbe8 = lightProbeTexture.m_flags.isRgbe8();
if (cubeMapMode)
layer.skyBoxIsSrgb = !lightProbeTexture.m_flags.isLinear();
QSSGRhiShaderResourceBindingList bindings;
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
cubeMapMode ? QRhiSampler::None : QRhiSampler::Linear, // cube map doesn't have mipmaps
QRhiSampler::Repeat,
QRhiSampler::ClampToEdge,
QRhiSampler::Repeat });
int samplerBinding = 1; // the shader code is hand-written, so we don't need to look that up
bindings.addTexture(samplerBinding, QRhiShaderResourceBinding::FragmentStage, lightProbeTexture.m_texture, sampler);
const auto cubeFaceIdx = QSSGBaseTypeHelpers::indexOfCubeFace(cubeFace);
const quintptr entryIdx = quintptr(cubeFace != QSSGRenderTextureCubeFaceNone) * cubeFaceIdx;
QSSGRhiDrawCallData &dcd = rhiCtxD->drawCallData({ passKey, nullptr, nullptr, entry, entryIdx });
QRhi *rhi = rhiCtx->rhi();
const quint32 ubufSize = cameras.count() >= 2 ? 416 : 240; // same ubuf layout for both skybox and skyboxcube
if (!dcd.ubuf || dcd.ubuf->size() != ubufSize) {
delete dcd.ubuf;
dcd.ubuf = rhi->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, int(ubufSize));
dcd.ubuf->create();
}
float adjustY = rhi->isYUpInNDC() ? 1.0f : -1.0f;
const float exposure = layer.lightProbeSettings.probeExposure;
// orientation
const QMatrix3x3 &rotationMatrix(layer.lightProbeSettings.probeOrientation);
// The cubemap shader doesn't use blur or mipmapping, so it uses those for tonemapping and texture color space
const float blurAmountOrSrgb = cubeMapMode ? layer.skyBoxIsSrgb : layer.skyboxBlurAmount;
const float maxMipLevelOrTonemapMode = cubeMapMode ? float(tonemapMode) : float(lightProbeTexture.m_mipmapCount - 2);
const QVector4D skyboxProperties = {
adjustY,
exposure,
blurAmountOrSrgb,
maxMipLevelOrTonemapMode
};
char *ubufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
quint32 ubufOffset = 0;
// skyboxProperties
memcpy(ubufData + ubufOffset, &skyboxProperties, 16);
ubufOffset += 16;
// orientation
memcpy(ubufData + ubufOffset, rotationMatrix.constData(), 12);
ubufOffset += 16;
memcpy(ubufData + ubufOffset, (char *)rotationMatrix.constData() + 12, 12);
ubufOffset += 16;
memcpy(ubufData + ubufOffset, (char *)rotationMatrix.constData() + 24, 12);
ubufOffset += 16;
for (qsizetype viewIdx = 0; viewIdx < cameras.count(); ++viewIdx) {
const QMatrix4x4 &inverseProjection = cameras[viewIdx]->projection.inverted();
const QMatrix4x4 &viewMatrix = renderData->getGlobalTransform(*cameras[viewIdx]);
QMatrix4x4 viewProjection(Qt::Uninitialized); // For cube mode
cameras[viewIdx]->calculateViewProjectionWithoutTranslation(viewMatrix, 0.1f, 5.0f, viewProjection);
quint32 viewDataOffset = ubufOffset;
memcpy(ubufData + viewDataOffset + viewIdx * 64, viewProjection.constData(), 64);
viewDataOffset += cameras.count() * 64;
memcpy(ubufData + viewDataOffset + viewIdx * 64, inverseProjection.constData(), 64);
viewDataOffset += cameras.count() * 64;
memcpy(ubufData + viewDataOffset + viewIdx * 48, viewMatrix.constData(), 48);
}
dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame();
bindings.addUniformBuffer(0, RENDERER_VISIBILITY_ALL, dcd.ubuf);
if (cubeFace != QSSGRenderTextureCubeFaceNone) {
const auto cubeFaceIdx = QSSGBaseTypeHelpers::indexOfCubeFace(cubeFace);
entry->m_skyBoxSrbs[cubeFaceIdx] = rhiCtxD->srb(bindings);
} else {
layer.skyBoxSrb = rhiCtxD->srb(bindings);
}
if (cubeMapMode)
renderer.rhiCubeRenderer()->prepareCube(rhiCtx, nullptr);
else
renderer.rhiQuadRenderer()->prepareQuad(rhiCtx, nullptr);
}
void RenderHelpers::rhiPrepareSkyBox(const QSSGRenderContextInterface &context,
QSSGPassKey passKey,
QSSGRenderLayer &layer,
QSSGRenderCameraList &cameras,
QSSGRenderer &renderer,
uint tonemapMode)
{
auto rhiCtx = context.rhiContext().get();
QRhiCommandBuffer *cb = rhiCtx->commandBuffer();
cb->debugMarkBegin(QByteArrayLiteral("Quick3D prepare skybox"));
rhiPrepareSkyBox_helper(context, passKey, layer, cameras, renderer, nullptr, QSSGRenderTextureCubeFaceNone, tonemapMode);
cb->debugMarkEnd();
}
void RenderHelpers::rhiPrepareSkyBoxForReflectionMap(const QSSGRenderContextInterface &context,
QSSGPassKey passKey,
QSSGRenderLayer &layer,
QSSGRenderCamera &inCamera,
QSSGRenderer &renderer,
QSSGReflectionMapEntry *entry,
QSSGRenderTextureCubeFace cubeFace)
{
QSSGRhiContext *rhiCtx = context.rhiContext().get();
QRhiCommandBuffer *cb = rhiCtx->commandBuffer();
cb->debugMarkBegin(QByteArrayLiteral("Quick3D prepare skybox for reflection cube map"));
QSSGRenderCameraList cameras({ &inCamera });
rhiPrepareSkyBox_helper(context, passKey, layer, cameras, renderer, entry, cubeFace);
cb->debugMarkEnd();
}
bool RenderHelpers::rhiPrepareDepthPass(QSSGRhiContext *rhiCtx,
QSSGPassKey passKey,
const QSSGRhiGraphicsPipelineState &basePipelineState,
QRhiRenderPassDescriptor *rpDesc,
QSSGLayerRenderData &inData,
const QSSGRenderableObjectList &sortedOpaqueObjects,
const QSSGRenderableObjectList &sortedTransparentObjects,
int samples,
int viewCount)
{
static const auto rhiPrepareDepthPassForObject = [](QSSGRhiContext *rhiCtx,
QSSGPassKey passKey,
QSSGLayerRenderData &inData,
QSSGRenderableObject *obj,
QRhiRenderPassDescriptor *rpDesc,
QSSGRhiGraphicsPipelineState *ps) {
QSSGRhiShaderPipelinePtr shaderPipeline;
QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
const bool isOpaqueDepthPrePass = obj->depthWriteMode == QSSGDepthDrawMode::OpaquePrePass;
QSSGShaderFeatures featureSet;
featureSet.set(QSSGShaderFeatures::Feature::DepthPass, true);
if (isOpaqueDepthPrePass)
featureSet.set(QSSGShaderFeatures::Feature::OpaqueDepthPrePass, true);
QSSGRhiDrawCallData *dcd = nullptr;
if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(*obj));
const void *modelNode = &subsetRenderable.modelContext.model;
dcd = &rhiCtxD->drawCallData({ passKey, modelNode, &subsetRenderable.material, nullptr, 0 });
}
if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset) {
QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(*obj));
const auto &material = static_cast<const QSSGRenderDefaultMaterial &>(subsetRenderable.getMaterial());
ps->cullMode = QSSGRhiHelpers::toCullMode(material.cullMode);
shaderPipeline = shadersForDefaultMaterial(ps, subsetRenderable, featureSet);
if (shaderPipeline) {
shaderPipeline->ensureCombinedUniformBuffer(&dcd->ubuf);
char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
updateUniformsForDefaultMaterial(*shaderPipeline, rhiCtx, inData, ubufData, ps, subsetRenderable, inData.renderedCameras, nullptr, nullptr);
dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
} else {
return false;
}
} else if (obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(*obj));
const auto &customMaterial = static_cast<const QSSGRenderCustomMaterial &>(subsetRenderable.getMaterial());
ps->cullMode = QSSGRhiHelpers::toCullMode(customMaterial.m_cullMode);
QSSGCustomMaterialSystem &customMaterialSystem(*subsetRenderable.renderer->contextInterface()->customMaterialSystem().get());
shaderPipeline = customMaterialSystem.shadersForCustomMaterial(ps, customMaterial, subsetRenderable, inData.getDefaultMaterialPropertyTable(), featureSet);
if (shaderPipeline) {
shaderPipeline->ensureCombinedUniformBuffer(&dcd->ubuf);
char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
customMaterialSystem.updateUniformsForCustomMaterial(*shaderPipeline, rhiCtx, inData, ubufData, ps, customMaterial, subsetRenderable,
inData.renderedCameras, nullptr, nullptr);
dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
} else {
return false;
}
}
// the rest is common, only relying on QSSGSubsetRenderableBase, not the subclasses
if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(*obj));
auto &ia = QSSGRhiInputAssemblerStatePrivate::get(*ps);
ia = subsetRenderable.subset.rhi.ia;
const QSSGRenderCameraDataList &cameraDatas(*inData.renderedCameraData);
int instanceBufferBinding = setupInstancing(&subsetRenderable, ps, rhiCtx, cameraDatas[0].direction, cameraDatas[0].position);
QSSGRhiHelpers::bakeVertexInputLocations(&ia, *shaderPipeline, instanceBufferBinding);
QSSGRhiShaderResourceBindingList bindings;
bindings.addUniformBuffer(0, RENDERER_VISIBILITY_ALL, dcd->ubuf);
// Depth and SSAO textures, in case a custom material's shader code does something with them.
addDepthTextureBindings(rhiCtx, shaderPipeline.get(), bindings);
if (isOpaqueDepthPrePass) {
addOpaqueDepthPrePassBindings(rhiCtx,
shaderPipeline.get(),
subsetRenderable.firstImage,
bindings,
(obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset));
}
// There is no normal texture at this stage. But the shader from a
// custom material may rely on it. Bind a dummy texture then due to
// the lack of other options.
const int normalTextureBinding = shaderPipeline->bindingForTexture("qt_normalTexture", int(QSSGRhiSamplerBindingHints::NormalTexture));
if (normalTextureBinding >= 0) {
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None,
QRhiSampler::Repeat, QRhiSampler::Repeat, QRhiSampler::Repeat });
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
QRhiTexture *dummyTexture = rhiCtx->dummyTexture({}, resourceUpdates);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
bindings.addTexture(normalTextureBinding, RENDERER_VISIBILITY_ALL, dummyTexture, sampler);
}
// Skinning
if (QRhiTexture *boneTexture = inData.getBonemapTexture(subsetRenderable.modelContext)) {
int binding = shaderPipeline->bindingForTexture("qt_boneTexture");
if (binding >= 0) {
QRhiSampler *boneSampler = rhiCtx->sampler({ QRhiSampler::Nearest,
QRhiSampler::Nearest,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::Repeat
});
bindings.addTexture(binding,
QRhiShaderResourceBinding::VertexStage,
boneTexture,
boneSampler);
}
}
// Morphing
auto *targetsTexture = subsetRenderable.subset.rhi.targetsTexture;
if (targetsTexture) {
int binding = shaderPipeline->bindingForTexture("qt_morphTargetTexture");
if (binding >= 0) {
QRhiSampler *targetsSampler = rhiCtx->sampler({ QRhiSampler::Nearest,
QRhiSampler::Nearest,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge
});
bindings.addTexture(binding, QRhiShaderResourceBinding::VertexStage, subsetRenderable.subset.rhi.targetsTexture, targetsSampler);
}
}
QRhiShaderResourceBindings *srb = drawCallDataSrb(rhiCtxD, *dcd, bindings);
subsetRenderable.rhiRenderData.depthPrePass.pipeline = rhiCtxD->pipeline(*ps,
rpDesc,
srb);
subsetRenderable.rhiRenderData.depthPrePass.srb = srb;
}
return true;
};
// Phase 1 (prepare) for the Z prepass or the depth texture generation.
// These renders opaque (Z prepass), or opaque and transparent (depth
// texture), objects with depth test/write enabled, and color write
// disabled, using a very simple set of shaders.
QSSGRhiGraphicsPipelineState ps = basePipelineState; // viewport and others are filled out already
// We took a copy of the pipeline state since we do not want to conflict
// with what rhiPrepare() collects for its own use. So here just change
// whatever we need.
ps.samples = samples;
ps.viewCount = viewCount;
ps.flags |= { QSSGRhiGraphicsPipelineState::Flag::DepthTestEnabled, QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled };
ps.targetBlend[0].colorWrite = {};
for (const QSSGRenderableObjectHandle &handle : sortedOpaqueObjects) {
if (!rhiPrepareDepthPassForObject(rhiCtx, passKey, inData, handle.obj, rpDesc, &ps))
return false;
}
for (const QSSGRenderableObjectHandle &handle : sortedTransparentObjects) {
if (!rhiPrepareDepthPassForObject(rhiCtx, passKey, inData, handle.obj, rpDesc, &ps))
return false;
}
return true;
}
void RenderHelpers::rhiRenderDepthPass(QSSGRhiContext *rhiCtx,
const QSSGRhiGraphicsPipelineState &pipelineState,
const QSSGRenderableObjectList &sortedOpaqueObjects,
const QSSGRenderableObjectList &sortedTransparentObjects,
bool *needsSetViewport)
{
static const auto rhiRenderDepthPassForImp = [](QSSGRhiContext *rhiCtx,
const QSSGRhiGraphicsPipelineState &pipelineState,
const QSSGRenderableObjectList &objects,
bool *needsSetViewport) {
for (const auto &oh : objects) {
QSSGRenderableObject *obj = oh.obj;
// casts to SubsetRenderableBase so it works for both default and custom materials
if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QRhiCommandBuffer *cb = rhiCtx->commandBuffer();
QSSGSubsetRenderable *subsetRenderable(static_cast<QSSGSubsetRenderable *>(obj));
QRhiBuffer *vertexBuffer = subsetRenderable->subset.rhi.vertexBuffer->buffer();
QRhiBuffer *indexBuffer = subsetRenderable->subset.rhi.indexBuffer
? subsetRenderable->subset.rhi.indexBuffer->buffer()
: nullptr;
QRhiGraphicsPipeline *ps = subsetRenderable->rhiRenderData.depthPrePass.pipeline;
if (!ps)
return;
QRhiShaderResourceBindings *srb = subsetRenderable->rhiRenderData.depthPrePass.srb;
if (!srb)
return;
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderCall);
cb->setGraphicsPipeline(ps);
cb->setShaderResources(srb);
if (*needsSetViewport) {
cb->setViewport(pipelineState.viewport);
*needsSetViewport = false;
}
QRhiCommandBuffer::VertexInput vertexBuffers[2];
int vertexBufferCount = 1;
vertexBuffers[0] = QRhiCommandBuffer::VertexInput(vertexBuffer, 0);
quint32 instances = 1;
if (subsetRenderable->modelContext.model.instancing()) {
instances = subsetRenderable->modelContext.model.instanceCount();
vertexBuffers[1] = QRhiCommandBuffer::VertexInput(subsetRenderable->instanceBuffer, 0);
vertexBufferCount = 2;
}
if (indexBuffer) {
cb->setVertexInput(0, vertexBufferCount, vertexBuffers, indexBuffer, 0, subsetRenderable->subset.rhi.indexBuffer->indexFormat());
cb->drawIndexed(subsetRenderable->subset.lodCount(subsetRenderable->subsetLevelOfDetail), instances, subsetRenderable->subset.lodOffset(subsetRenderable->subsetLevelOfDetail));
QSSGRHICTX_STAT(rhiCtx, drawIndexed(subsetRenderable->subset.lodCount(subsetRenderable->subsetLevelOfDetail), instances));
} else {
cb->setVertexInput(0, vertexBufferCount, vertexBuffers);
cb->draw(subsetRenderable->subset.count, instances, subsetRenderable->subset.offset);
QSSGRHICTX_STAT(rhiCtx, draw(subsetRenderable->subset.count, instances));
}
Q_QUICK3D_PROFILE_END_WITH_IDS(QQuick3DProfiler::Quick3DRenderCall, (subsetRenderable->subset.count | quint64(instances) << 32),
QVector<int>({subsetRenderable->modelContext.model.profilingId,
subsetRenderable->material.profilingId}));
}
}
};
rhiRenderDepthPassForImp(rhiCtx, pipelineState, sortedOpaqueObjects, needsSetViewport);
rhiRenderDepthPassForImp(rhiCtx, pipelineState, sortedTransparentObjects, needsSetViewport);
}
bool RenderHelpers::rhiPrepareDepthTexture(QSSGRhiContext *rhiCtx,
const QSize &size,
QSSGRhiRenderableTexture *renderableTex,
quint8 viewCount,
int samples)
{
QRhi *rhi = rhiCtx->rhi();
bool needsBuild = false;
if (!renderableTex->texture) {
QRhiTexture::Format format = QRhiTexture::D32F;
if (!rhi->isTextureFormatSupported(format))
format = QRhiTexture::D16;
if (!rhi->isTextureFormatSupported(format))
qWarning("Depth texture not supported");
if (viewCount <= 1)
renderableTex->texture = rhiCtx->rhi()->newTexture(format, size, samples, QRhiTexture::RenderTarget);
else
renderableTex->texture = rhiCtx->rhi()->newTextureArray(format, viewCount, size, 1, QRhiTexture::RenderTarget);
needsBuild = true;
} else if (renderableTex->texture->pixelSize() != size) {
renderableTex->texture->setPixelSize(size);
needsBuild = true;
}
if (needsBuild) {
if (!renderableTex->texture->create()) {
qWarning("Failed to build depth texture (size %dx%d, format %d)",
size.width(), size.height(), int(renderableTex->texture->format()));
renderableTex->reset();
return false;
}
renderableTex->resetRenderTarget();
QRhiTextureRenderTargetDescription rtDesc;
rtDesc.setDepthTexture(renderableTex->texture);
renderableTex->rt = rhi->newTextureRenderTarget(rtDesc);
renderableTex->rt->setName(QByteArrayLiteral("Depth texture"));
renderableTex->rpDesc = renderableTex->rt->newCompatibleRenderPassDescriptor();
renderableTex->rt->setRenderPassDescriptor(renderableTex->rpDesc);
if (!renderableTex->rt->create()) {
qWarning("Failed to build render target for depth texture");
renderableTex->reset();
return false;
}
}
return true;
}
bool RenderHelpers::rhiPrepareNormalPass(QSSGRhiContext *rhiCtx,
QSSGPassKey passKey,
const QSSGRhiGraphicsPipelineState &basePipelineState,
QRhiRenderPassDescriptor *rpDesc,
QSSGLayerRenderData &inData,
const QSSGRenderableObjectList &sortedOpaqueObjects)
{
QSSGRhiGraphicsPipelineState ps = basePipelineState;
ps.depthFunc = QRhiGraphicsPipeline::LessOrEqual;
ps.flags.setFlag(QSSGRhiGraphicsPipelineState::Flag::BlendEnabled, false);
for (const QSSGRenderableObjectHandle &handle : sortedOpaqueObjects) {
QSSGRenderableObject *obj = handle.obj;
QSSGRhiShaderPipelinePtr shaderPipeline;
QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
QSSGShaderFeatures featureSet;
featureSet.set(QSSGShaderFeatures::Feature::NormalPass, true);
QSSGRhiDrawCallData *dcd = nullptr;
if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QSSGSubsetRenderable &subsetRenderable(*static_cast<QSSGSubsetRenderable *>(obj));
const void *modelNode = &subsetRenderable.modelContext.model;
dcd = &rhiCtxD->drawCallData({ passKey, modelNode, &subsetRenderable.material, nullptr, 0 });
}
if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset) {
QSSGSubsetRenderable &subsetRenderable(*static_cast<QSSGSubsetRenderable *>(obj));
const auto &material = static_cast<const QSSGRenderDefaultMaterial &>(subsetRenderable.getMaterial());
ps.cullMode = QSSGRhiHelpers::toCullMode(material.cullMode);
shaderPipeline = shadersForDefaultMaterial(&ps, subsetRenderable, featureSet);
if (shaderPipeline) {
shaderPipeline->ensureCombinedUniformBuffer(&dcd->ubuf);
char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
updateUniformsForDefaultMaterial(*shaderPipeline, rhiCtx, inData, ubufData, &ps, subsetRenderable, inData.renderedCameras, nullptr, nullptr);
dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
}
} else if (obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QSSGSubsetRenderable &subsetRenderable(*static_cast<QSSGSubsetRenderable *>(obj));
const auto &customMaterial = static_cast<const QSSGRenderCustomMaterial &>(subsetRenderable.getMaterial());
ps.cullMode = QSSGRhiHelpers::toCullMode(customMaterial.m_cullMode);
const auto &customMaterialSystem = subsetRenderable.renderer->contextInterface()->customMaterialSystem();
shaderPipeline = customMaterialSystem->shadersForCustomMaterial(&ps, customMaterial, subsetRenderable, inData.getDefaultMaterialPropertyTable(), featureSet);
if (shaderPipeline) {
shaderPipeline->ensureCombinedUniformBuffer(&dcd->ubuf);
char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
customMaterialSystem->updateUniformsForCustomMaterial(*shaderPipeline, rhiCtx, inData, ubufData, &ps, customMaterial, subsetRenderable,
inData.renderedCameras, nullptr, nullptr);
dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
}
}
// the rest is common, only relying on QSSGSubsetRenderableBase, not the subclasses
if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(*obj));
auto &ia = QSSGRhiInputAssemblerStatePrivate::get(ps);
ia = subsetRenderable.subset.rhi.ia;
const QSSGRenderCameraDataList &cameraDatas(*inData.renderedCameraData);
int instanceBufferBinding = setupInstancing(&subsetRenderable, &ps, rhiCtx, cameraDatas[0].direction, cameraDatas[0].position);
QSSGRhiHelpers::bakeVertexInputLocations(&ia, *shaderPipeline, instanceBufferBinding);
QSSGRhiShaderResourceBindingList bindings;
bindings.addUniformBuffer(0, RENDERER_VISIBILITY_ALL, dcd->ubuf);
// Texture maps
QSSGRenderableImage *renderableImage = subsetRenderable.firstImage;
while (renderableImage) {
const char *samplerName = QSSGMaterialShaderGenerator::getSamplerName(renderableImage->m_mapType);
const int samplerHint = int(renderableImage->m_mapType);
int samplerBinding = shaderPipeline->bindingForTexture(samplerName, samplerHint);
if (samplerBinding >= 0) {
QRhiTexture *texture = renderableImage->m_texture.m_texture;
if (samplerBinding >= 0 && texture) {
const bool mipmapped = texture->flags().testFlag(QRhiTexture::MipMapped);
QSSGRhiSamplerDescription samplerDesc = {
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_minFilterType),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_magFilterType),
mipmapped ? QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_mipFilterType) : QRhiSampler::None,
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_horizontalTilingMode),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_verticalTilingMode),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_depthTilingMode)
};
rhiCtx->checkAndAdjustForNPoT(texture, &samplerDesc);
QRhiSampler *sampler = rhiCtx->sampler(samplerDesc);
bindings.addTexture(samplerBinding, RENDERER_VISIBILITY_ALL, texture, sampler);
}
} // else this is not necessarily an error, e.g. having metalness/roughness maps with metalness disabled
renderableImage = renderableImage->m_nextImage;
}
addDepthTextureBindings(rhiCtx, shaderPipeline.get(), bindings);
// There is no normal texture at this stage, obviously.
const int normalTextureBinding = shaderPipeline->bindingForTexture("qt_normalTexture", int(QSSGRhiSamplerBindingHints::NormalTexture));
if (normalTextureBinding >= 0) {
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None,
QRhiSampler::Repeat, QRhiSampler::Repeat, QRhiSampler::Repeat });
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
QRhiTexture *dummyTexture = rhiCtx->dummyTexture({}, resourceUpdates);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
bindings.addTexture(normalTextureBinding, RENDERER_VISIBILITY_ALL, dummyTexture, sampler);
}
// Shadow maps are not needed since lighting-related shading is mostly skipped in the normal texture's pass
// Skinning
if (QRhiTexture *boneTexture = inData.getBonemapTexture(subsetRenderable.modelContext)) {
int binding = shaderPipeline->bindingForTexture("qt_boneTexture");
if (binding >= 0) {
QRhiSampler *boneSampler = rhiCtx->sampler({ QRhiSampler::Nearest,
QRhiSampler::Nearest,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::Repeat
});
bindings.addTexture(binding,
QRhiShaderResourceBinding::VertexStage,
boneTexture,
boneSampler);
}
}
// Morphing
auto *targetsTexture = subsetRenderable.subset.rhi.targetsTexture;
if (targetsTexture) {
int binding = shaderPipeline->bindingForTexture("qt_morphTargetTexture");
if (binding >= 0) {
QRhiSampler *targetsSampler = rhiCtx->sampler({ QRhiSampler::Nearest,
QRhiSampler::Nearest,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge
});
bindings.addTexture(binding, QRhiShaderResourceBinding::VertexStage, subsetRenderable.subset.rhi.targetsTexture, targetsSampler);
}
}
QRhiShaderResourceBindings *srb = drawCallDataSrb(rhiCtxD, *dcd, bindings);
subsetRenderable.rhiRenderData.normalPass.pipeline = rhiCtxD->pipeline(ps,
rpDesc,
srb);
subsetRenderable.rhiRenderData.normalPass.srb = srb;
}
}
return true;
}
void RenderHelpers::rhiRenderNormalPass(QSSGRhiContext *rhiCtx,
const QSSGRhiGraphicsPipelineState &pipelineState,
const QSSGRenderableObjectList &sortedOpaqueObjects,
bool *needsSetViewport)
{
for (const auto &oh : sortedOpaqueObjects) {
QSSGRenderableObject *obj = oh.obj;
// casts to SubsetRenderableBase so it works for both default and custom materials
if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QRhiCommandBuffer *cb = rhiCtx->commandBuffer();
QSSGSubsetRenderable *subsetRenderable(static_cast<QSSGSubsetRenderable *>(obj));
QRhiBuffer *vertexBuffer = subsetRenderable->subset.rhi.vertexBuffer->buffer();
QRhiBuffer *indexBuffer = subsetRenderable->subset.rhi.indexBuffer
? subsetRenderable->subset.rhi.indexBuffer->buffer()
: nullptr;
QRhiGraphicsPipeline *graphicsPipeline = subsetRenderable->rhiRenderData.normalPass.pipeline;
if (!graphicsPipeline)
return;
QRhiShaderResourceBindings *srb = subsetRenderable->rhiRenderData.normalPass.srb;
if (!srb)
return;
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderCall);
cb->setGraphicsPipeline(graphicsPipeline);
cb->setShaderResources(srb);
if (needsSetViewport) {
cb->setViewport(pipelineState.viewport);
*needsSetViewport = false;
}
QRhiCommandBuffer::VertexInput vertexBuffers[2];
int vertexBufferCount = 1;
vertexBuffers[0] = QRhiCommandBuffer::VertexInput(vertexBuffer, 0);
quint32 instances = 1;
if (subsetRenderable->modelContext.model.instancing()) {
instances = subsetRenderable->modelContext.model.instanceCount();
vertexBuffers[1] = QRhiCommandBuffer::VertexInput(subsetRenderable->instanceBuffer, 0);
vertexBufferCount = 2;
}
if (indexBuffer) {
cb->setVertexInput(0, vertexBufferCount, vertexBuffers, indexBuffer, 0, subsetRenderable->subset.rhi.indexBuffer->indexFormat());
cb->drawIndexed(subsetRenderable->subset.lodCount(subsetRenderable->subsetLevelOfDetail), instances, subsetRenderable->subset.lodOffset(subsetRenderable->subsetLevelOfDetail));
QSSGRHICTX_STAT(rhiCtx, drawIndexed(subsetRenderable->subset.lodCount(subsetRenderable->subsetLevelOfDetail), instances));
} else {
cb->setVertexInput(0, vertexBufferCount, vertexBuffers);
cb->draw(subsetRenderable->subset.count, instances, subsetRenderable->subset.offset);
QSSGRHICTX_STAT(rhiCtx, draw(subsetRenderable->subset.count, instances));
}
Q_QUICK3D_PROFILE_END_WITH_IDS(QQuick3DProfiler::Quick3DRenderCall, (subsetRenderable->subset.count | quint64(instances) << 32),
QVector<int>({subsetRenderable->modelContext.model.profilingId,
subsetRenderable->material.profilingId}));
}
}
}
qsizetype RenderHelpers::rhiPrepareOverrideMaterialUserPass(QSSGRhiContext *rhiCtx,
QSSGPassKey passKey,
const QSSGRhiGraphicsPipelineState &basePipelineState,
QRhiRenderPassDescriptor *rpDesc,
QSSGRenderGraphObject *overrideMaterial,
QSSGLayerRenderData &inData,
QSSGRenderableObjectList &inObjects,
QSSGShaderFeatures featureSet)
{
// Make sure we have a valid override material before acquireing a user pass slot!
const qsizetype index = overrideMaterial ? inData.getUserRenderPassManager()->acquireUserPassSlot() : -1;
// If the index is negative, it means there are no more available slots for user passes, so we can skip the preparation and rendering of this pass.
if (index < 0)
return index;
QSSGRhiGraphicsPipelineState ps = basePipelineState;
QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
const bool isCustomMaterial = (overrideMaterial->type == QSSGRenderGraphObject::Type::CustomMaterial);
const bool isDefaultMaterial = (overrideMaterial->type == QSSGRenderGraphObject::Type::DefaultMaterial ||
overrideMaterial->type == QSSGRenderGraphObject::Type::PrincipledMaterial ||
overrideMaterial->type == QSSGRenderGraphObject::Type::SpecularGlossyMaterial);
if (!isCustomMaterial && !isDefaultMaterial) {
qDebug() << "Override material must be a default or custom material.";
return -1;
}
for (const QSSGRenderableObjectHandle &handle : std::as_const(inObjects)) {
QSSGRenderableObject *obj = handle.obj;
if (obj->type != QSSGRenderableObject::Type::DefaultMaterialMeshSubset &&
obj->type != QSSGRenderableObject::Type::CustomMaterialMeshSubset)
continue;
QSSGSubsetRenderable &subsetRenderable(*static_cast<QSSGSubsetRenderable *>(obj));
const void *modelNode = &subsetRenderable.modelContext.model;
// All user passes share the pass key, so the slot index tells them apart.
QSSGRhiDrawCallData *dcd = &rhiCtxD->drawCallData({ passKey, modelNode, overrideMaterial, nullptr,
quintptr(index) });
// Update the shader key to reflect the override material's properties
// The subsetRenderable.shaderDescription was set during prepareModelsForRender for the original material,
// but we need it to reflect the override material when paired with this model/subset.
{
QSSGRenderableObjectFlags renderableFlags = subsetRenderable.renderableFlags;
float opacity = subsetRenderable.opacity;
// Determine lighting conditions from the subset's lights
const bool hasAnyLights = !subsetRenderable.lights.isEmpty();
const bool anyLightHasShadows = std::any_of(subsetRenderable.lights.begin(),
subsetRenderable.lights.end(),
[](const QSSGShaderLight &light) { return light.shadows; });
// We need a non-const reference to layerPrepResult flags
// Make a copy since the prepare functions might modify it
auto layerPrepFlags = inData.layerPrepResult.getFlags();
if (isCustomMaterial) {
auto &material = static_cast<QSSGRenderCustomMaterial &>(*overrideMaterial);
auto prepResult = inData.prepareCustomMaterialForRender(material, renderableFlags, opacity,
false, hasAnyLights, anyLightHasShadows,
layerPrepFlags);
subsetRenderable.shaderDescription = prepResult.materialKey;
} else {
auto &material = static_cast<QSSGRenderDefaultMaterial &>(*overrideMaterial);
auto prepResult = inData.prepareDefaultMaterialForRender(material, renderableFlags, opacity,
hasAnyLights, anyLightHasShadows,
layerPrepFlags);
subsetRenderable.shaderDescription = prepResult.materialKey;
}
}
QSSGRhiShaderPipelinePtr shaderPipeline;
if (isCustomMaterial) {
const auto &material = static_cast<const QSSGRenderCustomMaterial &>(*overrideMaterial);
if (!ps.userSetCullMode)
ps.cullMode = QSSGRhiHelpers::toCullMode(material.m_cullMode);
QSSGCustomMaterialSystem &customMaterialSystem(*subsetRenderable.renderer->contextInterface()->customMaterialSystem().get());
shaderPipeline = customMaterialSystem.shadersForCustomMaterial(&ps, material, subsetRenderable,
inData.getDefaultMaterialPropertyTable(), featureSet);
if (shaderPipeline) {
shaderPipeline->ensureCombinedUniformBuffer(&dcd->ubuf);
char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
customMaterialSystem.updateUniformsForCustomMaterial(*shaderPipeline, rhiCtx, inData, ubufData, &ps, material,
subsetRenderable, inData.renderedCameras, nullptr, nullptr);
dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
}
} else {
const auto &material = static_cast<const QSSGRenderDefaultMaterial &>(*overrideMaterial);
if (!ps.userSetCullMode)
ps.cullMode = QSSGRhiHelpers::toCullMode(material.cullMode);
shaderPipeline = shadersForDefaultMaterial(&ps, subsetRenderable, featureSet);
if (shaderPipeline) {
shaderPipeline->ensureCombinedUniformBuffer(&dcd->ubuf);
char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
updateUniformsForDefaultMaterial(*shaderPipeline, rhiCtx, inData, ubufData, &ps, subsetRenderable,
inData.renderedCameras, nullptr, nullptr, overrideMaterial);
dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
}
}
if (!shaderPipeline)
continue;
auto &ia = QSSGRhiInputAssemblerStatePrivate::get(ps);
ia = subsetRenderable.subset.rhi.ia;
const QSSGRenderCameraDataList &cameraDatas(*inData.renderedCameraData);
int instanceBufferBinding = setupInstancing(&subsetRenderable, &ps, rhiCtx, cameraDatas[0].direction, cameraDatas[0].position);
QSSGRhiHelpers::bakeVertexInputLocations(&ia, *shaderPipeline, instanceBufferBinding);
QSSGRhiShaderResourceBindingList bindings;
bindings.addUniformBuffer(0, RENDERER_VISIBILITY_ALL, dcd->ubuf);
// Texture maps from the renderable
QSSGRenderableImage *renderableImage = subsetRenderable.firstImage;
while (renderableImage) {
const char *samplerName = QSSGMaterialShaderGenerator::getSamplerName(renderableImage->m_mapType);
const int samplerHint = int(renderableImage->m_mapType);
int samplerBinding = shaderPipeline->bindingForTexture(samplerName, samplerHint);
if (samplerBinding >= 0) {
QRhiTexture *texture = renderableImage->m_texture.m_texture;
if (texture) {
const bool mipmapped = texture->flags().testFlag(QRhiTexture::MipMapped);
QSSGRhiSamplerDescription samplerDesc = {
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_minFilterType),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_magFilterType),
mipmapped ? QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_mipFilterType) : QRhiSampler::None,
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_horizontalTilingMode),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_verticalTilingMode),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_depthTilingMode)
};
rhiCtx->checkAndAdjustForNPoT(texture, &samplerDesc);
QRhiSampler *sampler = rhiCtx->sampler(samplerDesc);
bindings.addTexture(samplerBinding, RENDERER_VISIBILITY_ALL, texture, sampler);
}
}
renderableImage = renderableImage->m_nextImage;
}
addDepthTextureBindings(rhiCtx, shaderPipeline.get(), bindings);
// Dummy normal texture
const int normalTextureBinding = shaderPipeline->bindingForTexture("qt_normalTexture", int(QSSGRhiSamplerBindingHints::NormalTexture));
if (normalTextureBinding >= 0) {
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None,
QRhiSampler::Repeat, QRhiSampler::Repeat, QRhiSampler::Repeat });
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
QRhiTexture *dummyTexture = rhiCtx->dummyTexture({}, resourceUpdates);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
bindings.addTexture(normalTextureBinding, RENDERER_VISIBILITY_ALL, dummyTexture, sampler);
}
// Skinning
if (QRhiTexture *boneTexture = inData.getBonemapTexture(subsetRenderable.modelContext)) {
int binding = shaderPipeline->bindingForTexture("qt_boneTexture");
if (binding >= 0) {
QRhiSampler *boneSampler = rhiCtx->sampler({ QRhiSampler::Nearest,
QRhiSampler::Nearest,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::Repeat
});
bindings.addTexture(binding,
QRhiShaderResourceBinding::VertexStage,
boneTexture,
boneSampler);
}
}
// Morphing
auto *targetsTexture = subsetRenderable.subset.rhi.targetsTexture;
if (targetsTexture) {
int binding = shaderPipeline->bindingForTexture("qt_morphTargetTexture");
if (binding >= 0) {
QRhiSampler *targetsSampler = rhiCtx->sampler({ QRhiSampler::Nearest,
QRhiSampler::Nearest,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge
});
bindings.addTexture(binding, QRhiShaderResourceBinding::VertexStage, subsetRenderable.subset.rhi.targetsTexture, targetsSampler);
}
}
// Lighting
if (shaderPipeline->isLightingEnabled()) {
bindings.addUniformBuffer(1, RENDERER_VISIBILITY_ALL, dcd->ubuf,
shaderPipeline->ub0LightDataOffset(),
sizeof(QSSGShaderLightsUniformData));
bindings.addUniformBuffer(2, RENDERER_VISIBILITY_ALL, dcd->ubuf,
shaderPipeline->ub0DirectionalLightDataOffset(),
sizeof(QSSGShaderDirectionalLightsUniformData));
// Shadow map atlas
if (int binding = shaderPipeline->bindingForTexture("qt_shadowmap_texture"); binding >= 0) {
QRhiTexture *texture = shaderPipeline->shadowMapAtlasTexture();
if (!texture) {
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
texture = rhiCtx->dummyTexture({ }, resourceUpdates, QSize(1, 1), Qt::black, 2);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
}
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::Repeat });
bindings.addTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);
}
// Shadow map blue noise
if (int binding = shaderPipeline->bindingForTexture("qt_shadowmap_blue_noise_texture"); binding >= 0) {
QRhiTexture *texture = shaderPipeline->shadowMapBlueNoiseTexture();
if (!texture) {
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
texture = rhiCtx->dummyTexture({ }, resourceUpdates);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
}
QRhiSampler *sampler = rhiCtx->sampler(
{ QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None, QRhiSampler::Repeat, QRhiSampler::Repeat, QRhiSampler::Repeat });
bindings.addTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);
}
// Light probe
if (int binding = shaderPipeline->bindingForTexture("qt_lightProbe", int(QSSGRhiSamplerBindingHints::LightProbe));
binding >= 0) {
auto texture = shaderPipeline->lightProbeTexture();
if (!texture) {
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
texture = rhiCtx->dummyTexture(QRhiTexture::CubeMap, resourceUpdates);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
}
Q_ASSERT(texture);
QPair<QSSGRenderTextureCoordOp, QSSGRenderTextureCoordOp> tiling = shaderPipeline->lightProbeTiling();
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
QRhiSampler::Linear, // enables mipmapping
QSSGRhiHelpers::toRhi(tiling.first),
QSSGRhiHelpers::toRhi(tiling.second),
QRhiSampler::Repeat });
bindings.addTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);
}
}
QRhiShaderResourceBindings *srb = drawCallDataSrb(rhiCtxD, *dcd, bindings);
QSSG_ASSERT(srb, continue);
auto &rhiPassData = subsetRenderable.rhiRenderData.userPassData[index];
rhiPassData.pipeline = rhiCtxD->pipeline(ps, rpDesc, srb);
rhiPassData.srb = srb;
}
return index;
}
qsizetype RenderHelpers::rhiPrepareOriginalMaterialUserPass(QSSGRhiContext *rhiCtx,
QSSGPassKey passKey,
const QSSGRhiGraphicsPipelineState &basePipelineState,
QRhiRenderPassDescriptor *rpDesc,
const QSSGLayerRenderData &inData,
QSSGRenderableObjectList &inObjects,
QSSGShaderFeatures featureSet)
{
const qsizetype index = inData.getUserRenderPassManager()->acquireUserPassSlot();
// If the index is negative, it means there are no more available slots for user passes, so we can't prepare the original material pass.
if (index < 0)
return index;
QSSGRhiGraphicsPipelineState ps = basePipelineState;
QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
for (const QSSGRenderableObjectHandle &handle : std::as_const(inObjects)) {
QSSGRenderableObject *obj = handle.obj;
QSSGRhiShaderPipelinePtr shaderPipeline;
QSSGRhiDrawCallData *dcd = nullptr;
if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset ||
obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QSSGSubsetRenderable &subsetRenderable(*static_cast<QSSGSubsetRenderable *>(obj));
const void *modelNode = &subsetRenderable.modelContext.model;
// All user passes share the pass key, so the slot index tells them apart.
dcd = &rhiCtxD->drawCallData({ passKey, modelNode, &subsetRenderable.material, nullptr, quintptr(index) });
}
if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset) {
QSSGSubsetRenderable &subsetRenderable(*static_cast<QSSGSubsetRenderable *>(obj));
const auto &material = static_cast<const QSSGRenderDefaultMaterial &>(subsetRenderable.getMaterial());
if (!ps.userSetCullMode)
ps.cullMode = QSSGRhiHelpers::toCullMode(material.cullMode);
shaderPipeline = shadersForDefaultMaterial(&ps, subsetRenderable, featureSet);
if (shaderPipeline) {
shaderPipeline->ensureCombinedUniformBuffer(&dcd->ubuf);
char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
updateUniformsForDefaultMaterial(*shaderPipeline, rhiCtx, inData, ubufData, &ps, subsetRenderable,
inData.renderedCameras, nullptr, nullptr);
dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
}
} else if (obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QSSGSubsetRenderable &subsetRenderable(*static_cast<QSSGSubsetRenderable *>(obj));
const auto &material = static_cast<const QSSGRenderCustomMaterial &>(subsetRenderable.getMaterial());
if (!ps.userSetCullMode)
ps.cullMode = QSSGRhiHelpers::toCullMode(material.m_cullMode);
QSSGCustomMaterialSystem &customMaterialSystem(*subsetRenderable.renderer->contextInterface()->customMaterialSystem().get());
shaderPipeline = customMaterialSystem.shadersForCustomMaterial(&ps, material, subsetRenderable,
inData.getDefaultMaterialPropertyTable(), featureSet);
if (shaderPipeline) {
shaderPipeline->ensureCombinedUniformBuffer(&dcd->ubuf);
char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
customMaterialSystem.updateUniformsForCustomMaterial(*shaderPipeline, rhiCtx, inData, ubufData, &ps, material,
subsetRenderable, inData.renderedCameras, nullptr, nullptr);
dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
}
}
if (!shaderPipeline)
continue;
// The rest is common for both default and custom materials
if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset ||
obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(*obj));
auto &ia = QSSGRhiInputAssemblerStatePrivate::get(ps);
ia = subsetRenderable.subset.rhi.ia;
const QSSGRenderCameraDataList &cameraDatas(*inData.renderedCameraData);
int instanceBufferBinding = setupInstancing(&subsetRenderable, &ps, rhiCtx, cameraDatas[0].direction, cameraDatas[0].position);
QSSGRhiHelpers::bakeVertexInputLocations(&ia, *shaderPipeline, instanceBufferBinding);
QSSGRhiShaderResourceBindingList bindings;
bindings.addUniformBuffer(0, RENDERER_VISIBILITY_ALL, dcd->ubuf);
// Texture maps
QSSGRenderableImage *renderableImage = subsetRenderable.firstImage;
while (renderableImage) {
const char *samplerName = QSSGMaterialShaderGenerator::getSamplerName(renderableImage->m_mapType);
const int samplerHint = int(renderableImage->m_mapType);
int samplerBinding = shaderPipeline->bindingForTexture(samplerName, samplerHint);
if (samplerBinding >= 0) {
QRhiTexture *texture = renderableImage->m_texture.m_texture;
if (samplerBinding >= 0 && texture) {
const bool mipmapped = texture->flags().testFlag(QRhiTexture::MipMapped);
QSSGRhiSamplerDescription samplerDesc = {
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_minFilterType),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_magFilterType),
mipmapped ? QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_mipFilterType) : QRhiSampler::None,
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_horizontalTilingMode),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_verticalTilingMode),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_depthTilingMode)
};
rhiCtx->checkAndAdjustForNPoT(texture, &samplerDesc);
QRhiSampler *sampler = rhiCtx->sampler(samplerDesc);
bindings.addTexture(samplerBinding, RENDERER_VISIBILITY_ALL, texture, sampler);
}
}
renderableImage = renderableImage->m_nextImage;
}
addDepthTextureBindings(rhiCtx, shaderPipeline.get(), bindings);
// Dummy normal texture
const int normalTextureBinding = shaderPipeline->bindingForTexture("qt_normalTexture", int(QSSGRhiSamplerBindingHints::NormalTexture));
if (normalTextureBinding >= 0) {
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None,
QRhiSampler::Repeat, QRhiSampler::Repeat, QRhiSampler::Repeat });
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
QRhiTexture *dummyTexture = rhiCtx->dummyTexture({}, resourceUpdates);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
bindings.addTexture(normalTextureBinding, RENDERER_VISIBILITY_ALL, dummyTexture, sampler);
}
// Skinning
if (QRhiTexture *boneTexture = inData.getBonemapTexture(subsetRenderable.modelContext)) {
int binding = shaderPipeline->bindingForTexture("qt_boneTexture");
if (binding >= 0) {
QRhiSampler *boneSampler = rhiCtx->sampler({ QRhiSampler::Nearest,
QRhiSampler::Nearest,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::Repeat
});
bindings.addTexture(binding,
QRhiShaderResourceBinding::VertexStage,
boneTexture,
boneSampler);
}
}
// Morphing
auto *targetsTexture = subsetRenderable.subset.rhi.targetsTexture;
if (targetsTexture) {
int binding = shaderPipeline->bindingForTexture("qt_morphTargetTexture");
if (binding >= 0) {
QRhiSampler *targetsSampler = rhiCtx->sampler({ QRhiSampler::Nearest,
QRhiSampler::Nearest,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge
});
bindings.addTexture(binding, QRhiShaderResourceBinding::VertexStage, subsetRenderable.subset.rhi.targetsTexture, targetsSampler);
}
}
// Lighting
if (shaderPipeline->isLightingEnabled()) {
bindings.addUniformBuffer(1, RENDERER_VISIBILITY_ALL, dcd->ubuf,
shaderPipeline->ub0LightDataOffset(),
sizeof(QSSGShaderLightsUniformData));
bindings.addUniformBuffer(2, RENDERER_VISIBILITY_ALL, dcd->ubuf,
shaderPipeline->ub0DirectionalLightDataOffset(),
sizeof(QSSGShaderDirectionalLightsUniformData));
// Shadow map atlas
if (int binding = shaderPipeline->bindingForTexture("qt_shadowmap_texture"); binding >= 0) {
QRhiTexture *texture = shaderPipeline->shadowMapAtlasTexture();
if (!texture) {
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
texture = rhiCtx->dummyTexture({ }, resourceUpdates);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
}
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::Repeat });
bindings.addTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);
}
// Shadow map blue noise
if (int binding = shaderPipeline->bindingForTexture("qt_shadowmap_blue_noise_texture"); binding >= 0) {
if (auto shadowMapBlueNoise = shaderPipeline->shadowMapBlueNoiseTexture()) {
int binding = shaderPipeline->bindingForTexture("qt_shadowmap_blue_noise_texture");
if (binding >= 0) {
QRhiTexture *texture = shadowMapBlueNoise;
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
QRhiSampler::None,
QRhiSampler::Repeat,
QRhiSampler::Repeat,
QRhiSampler::Repeat });
Q_ASSERT(texture && sampler);
bindings.addTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);
}
} else {
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
QRhiTexture *texture = rhiCtx->dummyTexture({}, resourceUpdates);
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
QRhiSampler::None,
QRhiSampler::Repeat,
QRhiSampler::Repeat,
QRhiSampler::Repeat });
Q_ASSERT(texture && sampler);
bindings.addTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
}
}
// Reflection probe or light probe
if (featureSet.isSet(QSSGShaderFeatures::Feature::ReflectionProbe)) {
int reflectionSampler = shaderPipeline->bindingForTexture("qt_reflectionMap");
QRhiTexture* reflectionTexture = inData.getReflectionMapManager()->reflectionMapEntry(subsetRenderable.reflectionProbeIndex)->m_rhiPrefilteredCube;
const auto mipMapFilter = reflectionTexture && reflectionTexture->flags().testFlag(QRhiTexture::Flag::MipMapped)
? QRhiSampler::Linear
: QRhiSampler::None;
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
mipMapFilter,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::Repeat });
if (reflectionSampler >= 0 && reflectionTexture)
bindings.addTexture(reflectionSampler, QRhiShaderResourceBinding::FragmentStage, reflectionTexture, sampler);
}
if (int binding = shaderPipeline->bindingForTexture("qt_lightProbe", int(QSSGRhiSamplerBindingHints::LightProbe));
binding >= 0) {
auto texture = shaderPipeline->lightProbeTexture();
if (!texture) {
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
texture = rhiCtx->dummyTexture(QRhiTexture::CubeMap, resourceUpdates);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
}
Q_ASSERT(texture);
QPair<QSSGRenderTextureCoordOp, QSSGRenderTextureCoordOp> tiling = shaderPipeline->lightProbeTiling();
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
QRhiSampler::Linear, // enables mipmapping
QSSGRhiHelpers::toRhi(tiling.first),
QSSGRhiHelpers::toRhi(tiling.second),
QRhiSampler::Repeat });
bindings.addTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);
}
// Screen Texture
if (shaderPipeline->screenTexture()) {
const int screenTextureBinding = shaderPipeline->bindingForTexture("qt_screenTexture", int(QSSGRhiSamplerBindingHints::ScreenTexture));
const int screenTextureArrayBinding = shaderPipeline->bindingForTexture("qt_screenTextureArray", int(QSSGRhiSamplerBindingHints::ScreenTextureArray));
if (screenTextureBinding >= 0 || screenTextureArrayBinding >= 0) {
QRhiSampler::Filter mipFilter = shaderPipeline->screenTexture()->flags().testFlag(QRhiTexture::MipMapped)
? QRhiSampler::Linear : QRhiSampler::None;
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear, QRhiSampler::Linear, mipFilter,
QRhiSampler::Repeat, QRhiSampler::Repeat, QRhiSampler::Repeat });
if (screenTextureBinding >= 0) {
bindings.addTexture(screenTextureBinding,
QRhiShaderResourceBinding::FragmentStage,
shaderPipeline->screenTexture(), sampler);
}
if (screenTextureArrayBinding >= 0) {
bindings.addTexture(screenTextureArrayBinding,
QRhiShaderResourceBinding::FragmentStage,
shaderPipeline->screenTexture(), sampler);
}
}
}
if (shaderPipeline->lightmapTexture()) {
int binding = shaderPipeline->bindingForTexture("qt_lightmap", int(QSSGRhiSamplerBindingHints::LightmapTexture));
if (binding >= 0) {
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None,
QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });
bindings.addTexture(binding,
QRhiShaderResourceBinding::FragmentStage,
shaderPipeline->lightmapTexture(), sampler);
}
}
}
// Custom property textures
{
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
int maxSamplerBinding = -1;
QVector<QShaderDescription::InOutVariable> samplerVars =
shaderPipeline->fragmentStage()->shader().description().combinedImageSamplers();
const auto combinedSamplers = shaderPipeline->vertexStage()->shader().description().combinedImageSamplers();
for (const QShaderDescription::InOutVariable &var : combinedSamplers) {
auto it = std::find_if(samplerVars.cbegin(), samplerVars.cend(),
[&var](const QShaderDescription::InOutVariable &v) { return var.binding == v.binding; });
if (it == samplerVars.cend())
samplerVars.append(var);
}
for (const QShaderDescription::InOutVariable &var : std::as_const(samplerVars))
maxSamplerBinding = qMax(maxSamplerBinding, var.binding);
if (maxSamplerBinding >= 0) {
int extraTexCount = shaderPipeline->extraTextureCount();
for (int i = 0; i < extraTexCount; ++i) {
QSSGRhiTexture &t(shaderPipeline->extraTextureAt(i));
const int samplerBinding = shaderPipeline->bindingForTexture(t.name);
if (samplerBinding >= 0) {
rhiCtx->checkAndAdjustForNPoT(t.texture, &t.samplerDesc);
QRhiSampler *sampler = rhiCtx->sampler(t.samplerDesc);
bindings.addTexture(samplerBinding,
QRhiShaderResourceBinding::FragmentStage,
t.texture,
sampler);
}
}
}
}
QRhiShaderResourceBindings *srb = drawCallDataSrb(rhiCtxD, *dcd, bindings);
QSSG_ASSERT(srb, continue);
auto &rhiPassData = subsetRenderable.rhiRenderData.userPassData[index];
rhiPassData.pipeline = rhiCtxD->pipeline(ps, rpDesc, srb);
rhiPassData.srb = srb;
}
}
return index;
}
qsizetype RenderHelpers::rhiPrepareAugmentedUserPass(QSSGRhiContext *rhiCtx,
QSSGPassKey passKey,
const QSSGRhiGraphicsPipelineState &basePipelineState,
QRhiRenderPassDescriptor *rpDesc,
const QSSGUserShaderAugmentation &shaderAugmentation,
const QSSGLayerRenderData &inData,
QSSGRenderableObjectList &inObjects,
QSSGShaderFeatures featureSet)
{
const qsizetype index = inData.getUserRenderPassManager()->acquireUserPassSlot();
// If there's no available slot, we can't prepare this pass. This can happen if the user shader augmentation tries to use more slots than the maximum allowed.
if (index < 0)
return index;
QSSGRhiGraphicsPipelineState ps = basePipelineState;
for (const QSSGRenderableObjectHandle &handle : std::as_const(inObjects)) {
QSSGRenderableObject *obj = handle.obj;
QSSGRhiShaderPipelinePtr shaderPipeline;
QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
const auto &bufferManager = inData.contextInterface()->bufferManager();
featureSet.set(QSSGShaderFeatures::Feature::UserRenderPass, true);
QSSGRhiDrawCallData *dcd = nullptr;
if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QSSGSubsetRenderable &subsetRenderable(*static_cast<QSSGSubsetRenderable *>(obj));
const void *modelNode = &subsetRenderable.modelContext.model;
// All user passes share the pass key, so the slot index tells them apart.
dcd = &rhiCtxD->drawCallData({ passKey, modelNode, &subsetRenderable.material, nullptr, quintptr(index) });
}
if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset) {
QSSGSubsetRenderable &subsetRenderable(*static_cast<QSSGSubsetRenderable *>(obj));
const auto &material = static_cast<const QSSGRenderDefaultMaterial &>(subsetRenderable.getMaterial());
if (!ps.userSetCullMode)
ps.cullMode = QSSGRhiHelpers::toCullMode(material.cullMode);
shaderPipeline = shadersForDefaultMaterial(&ps, subsetRenderable, featureSet, shaderAugmentation);
if (shaderPipeline) {
shaderPipeline->ensureCombinedUniformBuffer(&dcd->ubuf);
char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
// Now do user augmentation specific uniform updates
for (const auto &u : shaderAugmentation.propertyUniforms)
shaderPipeline->setShaderResources(ubufData, *bufferManager, u.name, u.value, u.shaderDataType);
updateUniformsForDefaultMaterial(*shaderPipeline, rhiCtx, inData, ubufData, &ps, subsetRenderable, inData.renderedCameras, nullptr, nullptr);
dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
}
} else if (obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QSSGSubsetRenderable &subsetRenderable(*static_cast<QSSGSubsetRenderable *>(obj));
const auto &material = static_cast<const QSSGRenderCustomMaterial &>(subsetRenderable.getMaterial());
if (!ps.userSetCullMode)
ps.cullMode = QSSGRhiHelpers::toCullMode(material.m_cullMode);
QSSGCustomMaterialSystem &customMaterialSystem(*subsetRenderable.renderer->contextInterface()->customMaterialSystem().get());
// Don't apply a shader augmentation to an unshaded custom material (they should do their own augmentations with preprocessor conditionals)
if (material.m_shadingMode == QSSGRenderCustomMaterial::ShadingMode::Unshaded)
shaderPipeline = customMaterialSystem.shadersForCustomMaterial(&ps, material, subsetRenderable, inData.getDefaultMaterialPropertyTable(), featureSet);
else
shaderPipeline = customMaterialSystem.shadersForCustomMaterial(&ps, material, subsetRenderable, inData.getDefaultMaterialPropertyTable(), featureSet, shaderAugmentation);
if (shaderPipeline) {
shaderPipeline->ensureCombinedUniformBuffer(&dcd->ubuf);
char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
// Apply user augmentation specific uniform updates
for (const auto &u : shaderAugmentation.propertyUniforms)
shaderPipeline->setShaderResources(ubufData, *bufferManager, u.name, u.value, u.shaderDataType);
customMaterialSystem.updateUniformsForCustomMaterial(*shaderPipeline, rhiCtx, inData, ubufData, &ps, material,
subsetRenderable, inData.renderedCameras, nullptr, nullptr);
dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
}
}
if (!shaderPipeline) {
// bail
qDebug() << "Failed to prepare user augmented pass for object.";
return -1;
}
// the rest is common, only relying on QSSGSubsetRenderableBase, not the subclasses
if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(*obj));
auto &ia = QSSGRhiInputAssemblerStatePrivate::get(ps);
ia = subsetRenderable.subset.rhi.ia;
const QSSGRenderCameraDataList &cameraDatas(*inData.renderedCameraData);
int instanceBufferBinding = setupInstancing(&subsetRenderable, &ps, rhiCtx, cameraDatas[0].direction, cameraDatas[0].position);
QSSGRhiHelpers::bakeVertexInputLocations(&ia, *shaderPipeline, instanceBufferBinding);
QSSGRhiShaderResourceBindingList bindings;
bindings.addUniformBuffer(0, RENDERER_VISIBILITY_ALL, dcd->ubuf);
// The generated shader declares a sampler for every custom
// property texture, and some graphics APIs reject an srb that
// leaves one of them unbound. Track which sampler bindings get
// taken as they are added, so the unused ones can be filled with
// dummy textures at the end.
QVector<QShaderDescription::InOutVariable> samplerVars =
shaderPipeline->fragmentStage()->shader().description().combinedImageSamplers();
const auto combinedSamplers = shaderPipeline->vertexStage()->shader().description().combinedImageSamplers();
for (const QShaderDescription::InOutVariable &var : combinedSamplers) {
auto it = std::find_if(samplerVars.cbegin(), samplerVars.cend(),
[&var](const QShaderDescription::InOutVariable &v) { return var.binding == v.binding; });
if (it == samplerVars.cend())
samplerVars.append(var);
}
int maxSamplerBinding = -1;
for (const QShaderDescription::InOutVariable &var : std::as_const(samplerVars))
maxSamplerBinding = qMax(maxSamplerBinding, var.binding);
QBitArray specifiedBindings(maxSamplerBinding + 1);
const auto addTrackedTexture = [&](int binding, QRhiShaderResourceBinding::StageFlags stage,
QRhiTexture *texture, QRhiSampler *sampler) {
specifiedBindings.setBit(binding);
bindings.addTexture(binding, stage, texture, sampler);
};
// Texture maps
QSSGRenderableImage *renderableImage = subsetRenderable.firstImage;
while (renderableImage) {
const char *samplerName = QSSGMaterialShaderGenerator::getSamplerName(renderableImage->m_mapType);
const int samplerHint = int(renderableImage->m_mapType);
int samplerBinding = shaderPipeline->bindingForTexture(samplerName, samplerHint);
if (samplerBinding >= 0) {
QRhiTexture *texture = renderableImage->m_texture.m_texture;
if (samplerBinding >= 0 && texture) {
const bool mipmapped = texture->flags().testFlag(QRhiTexture::MipMapped);
QSSGRhiSamplerDescription samplerDesc = {
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_minFilterType),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_magFilterType),
mipmapped ? QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_mipFilterType) : QRhiSampler::None,
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_horizontalTilingMode),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_verticalTilingMode),
QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_depthTilingMode)
};
rhiCtx->checkAndAdjustForNPoT(texture, &samplerDesc);
QRhiSampler *sampler = rhiCtx->sampler(samplerDesc);
addTrackedTexture(samplerBinding, RENDERER_VISIBILITY_ALL, texture, sampler);
}
} // else this is not necessarily an error, e.g. having metalness/roughness maps with metalness disabled
renderableImage = renderableImage->m_nextImage;
}
addDepthTextureBindings(rhiCtx, shaderPipeline.get(), bindings, &specifiedBindings);
// There is no normal texture at this stage, obviously.
const int normalTextureBinding = shaderPipeline->bindingForTexture("qt_normalTexture", int(QSSGRhiSamplerBindingHints::NormalTexture));
if (normalTextureBinding >= 0) {
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None,
QRhiSampler::Repeat, QRhiSampler::Repeat, QRhiSampler::Repeat });
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
QRhiTexture *dummyTexture = rhiCtx->dummyTexture({}, resourceUpdates);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
addTrackedTexture(normalTextureBinding, RENDERER_VISIBILITY_ALL, dummyTexture, sampler);
}
// Shadow maps are not needed since lighting-related shading is mostly skipped in the normal texture's pass
// Skinning
if (QRhiTexture *boneTexture = inData.getBonemapTexture(subsetRenderable.modelContext)) {
int binding = shaderPipeline->bindingForTexture("qt_boneTexture");
if (binding >= 0) {
QRhiSampler *boneSampler = rhiCtx->sampler({ QRhiSampler::Nearest,
QRhiSampler::Nearest,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::Repeat
});
addTrackedTexture(binding,
QRhiShaderResourceBinding::VertexStage,
boneTexture,
boneSampler);
}
}
// Morphing
auto *targetsTexture = subsetRenderable.subset.rhi.targetsTexture;
if (targetsTexture) {
int binding = shaderPipeline->bindingForTexture("qt_morphTargetTexture");
if (binding >= 0) {
QRhiSampler *targetsSampler = rhiCtx->sampler({ QRhiSampler::Nearest,
QRhiSampler::Nearest,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge
});
addTrackedTexture(binding, QRhiShaderResourceBinding::VertexStage, subsetRenderable.subset.rhi.targetsTexture, targetsSampler);
}
}
// Lighting
if (shaderPipeline->isLightingEnabled()) {
bindings.addUniformBuffer(1, RENDERER_VISIBILITY_ALL, dcd->ubuf,
shaderPipeline->ub0LightDataOffset(),
sizeof(QSSGShaderLightsUniformData));
bindings.addUniformBuffer(2, RENDERER_VISIBILITY_ALL, dcd->ubuf,
shaderPipeline->ub0DirectionalLightDataOffset(),
sizeof(QSSGShaderDirectionalLightsUniformData));
// Shadow map atlas
if (int binding = shaderPipeline->bindingForTexture("qt_shadowmap_texture"); binding >= 0) {
QRhiTexture *texture = shaderPipeline->shadowMapAtlasTexture();
if (!texture) {
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
texture = rhiCtx->dummyTexture({ }, resourceUpdates, QSize(1, 1), Qt::black, 2);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
}
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::Repeat });
addTrackedTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);
}
// Shadow map blue noise
if (int binding = shaderPipeline->bindingForTexture("qt_shadowmap_blue_noise_texture"); binding >= 0) {
if (auto shadowMapBlueNoise = shaderPipeline->shadowMapBlueNoiseTexture()) {
int binding = shaderPipeline->bindingForTexture("qt_shadowmap_blue_noise_texture");
if (binding >= 0) {
QRhiTexture *texture = shadowMapBlueNoise;
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
QRhiSampler::None,
QRhiSampler::Repeat,
QRhiSampler::Repeat,
QRhiSampler::Repeat });
Q_ASSERT(texture && sampler);
addTrackedTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);
}
} else {
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
QRhiTexture *texture = rhiCtx->dummyTexture({}, resourceUpdates);
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
QRhiSampler::None,
QRhiSampler::Repeat,
QRhiSampler::Repeat,
QRhiSampler::Repeat });
Q_ASSERT(texture && sampler);
addTrackedTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
}
}
// Prioritize reflection texture over Light Probe texture because
// reflection texture also contains the irradiance and pre filtered
// values for the light probe.
if (featureSet.isSet(QSSGShaderFeatures::Feature::ReflectionProbe)) {
int reflectionSampler = shaderPipeline->bindingForTexture("qt_reflectionMap");
QRhiTexture* reflectionTexture = inData.getReflectionMapManager()->reflectionMapEntry(subsetRenderable.reflectionProbeIndex)->m_rhiPrefilteredCube;
const auto mipMapFilter = reflectionTexture && reflectionTexture->flags().testFlag(QRhiTexture::Flag::MipMapped)
? QRhiSampler::Linear
: QRhiSampler::None;
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
mipMapFilter,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::Repeat });
if (reflectionSampler >= 0 && reflectionTexture)
addTrackedTexture(reflectionSampler, QRhiShaderResourceBinding::FragmentStage, reflectionTexture, sampler);
}
if (int binding = shaderPipeline->bindingForTexture("qt_lightProbe", int(QSSGRhiSamplerBindingHints::LightProbe));
binding >= 0) {
auto texture = shaderPipeline->lightProbeTexture();
if (!texture) {
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
texture = rhiCtx->dummyTexture(QRhiTexture::CubeMap, resourceUpdates);
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
}
Q_ASSERT(texture);
QPair<QSSGRenderTextureCoordOp, QSSGRenderTextureCoordOp> tiling = shaderPipeline->lightProbeTiling();
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear,
QRhiSampler::Linear,
QRhiSampler::Linear, // enables mipmapping
QSSGRhiHelpers::toRhi(tiling.first),
QSSGRhiHelpers::toRhi(tiling.second),
QRhiSampler::Repeat });
addTrackedTexture(binding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);
}
// Screen Texture
if (shaderPipeline->screenTexture()) {
const int screenTextureBinding = shaderPipeline->bindingForTexture("qt_screenTexture", int(QSSGRhiSamplerBindingHints::ScreenTexture));
const int screenTextureArrayBinding = shaderPipeline->bindingForTexture("qt_screenTextureArray", int(QSSGRhiSamplerBindingHints::ScreenTextureArray));
if (screenTextureBinding >= 0 || screenTextureArrayBinding >= 0) {
// linear min/mag, mipmap filtering depends on the
// texture, with SCREEN_TEXTURE there are no mipmaps, but
// once SCREEN_MIP_TEXTURE is seen the texture (the same
// one) has mipmaps generated.
QRhiSampler::Filter mipFilter = shaderPipeline->screenTexture()->flags().testFlag(QRhiTexture::MipMapped)
? QRhiSampler::Linear : QRhiSampler::None;
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear, QRhiSampler::Linear, mipFilter,
QRhiSampler::Repeat, QRhiSampler::Repeat, QRhiSampler::Repeat });
if (screenTextureBinding >= 0) {
addTrackedTexture(screenTextureBinding,
QRhiShaderResourceBinding::FragmentStage,
shaderPipeline->screenTexture(), sampler);
}
if (screenTextureArrayBinding >= 0) {
addTrackedTexture(screenTextureArrayBinding,
QRhiShaderResourceBinding::FragmentStage,
shaderPipeline->screenTexture(), sampler);
}
} // else ignore, not an error
}
if (shaderPipeline->lightmapTexture()) {
int binding = shaderPipeline->bindingForTexture("qt_lightmap", int(QSSGRhiSamplerBindingHints::LightmapTexture));
if (binding >= 0) {
QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Linear, QRhiSampler::Linear, QRhiSampler::None,
QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });
addTrackedTexture(binding,
QRhiShaderResourceBinding::FragmentStage,
shaderPipeline->lightmapTexture(), sampler);
} // else ignore, not an error
}
}
{
if (maxSamplerBinding >= 0) {
// custom property textures
int extraTexCount = shaderPipeline->extraTextureCount();
for (int i = 0; i < extraTexCount; ++i) {
QSSGRhiTexture &t(shaderPipeline->extraTextureAt(i));
const int samplerBinding = shaderPipeline->bindingForTexture(t.name);
if (samplerBinding >= 0) {
rhiCtx->checkAndAdjustForNPoT(t.texture, &t.samplerDesc);
QRhiSampler *sampler = rhiCtx->sampler(t.samplerDesc);
addTrackedTexture(samplerBinding,
QRhiShaderResourceBinding::FragmentStage,
t.texture,
sampler);
}
}
}
// Use a dummy texture for the samplers left unbound above.
QRhiSampler *dummySampler = rhiCtx->sampler({ QRhiSampler::Nearest, QRhiSampler::Nearest, QRhiSampler::None,
QRhiSampler::ClampToEdge, QRhiSampler::ClampToEdge, QRhiSampler::Repeat });
QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch();
QRhiTexture *dummyTexture = rhiCtx->dummyTexture({}, resourceUpdates);
QRhiTexture *dummyTextureArray = rhiCtx->dummyTexture({}, resourceUpdates, QSize(64, 64), Qt::black, qMax(2u, inData.layer.viewCount));
QRhiTexture *dummyTexture3D = rhiCtx->dummyTexture(QRhiTexture::ThreeDimensional, resourceUpdates);
QRhiTexture *dummyCubeTexture = rhiCtx->dummyTexture(QRhiTexture::CubeMap, resourceUpdates);
QRhiTexture *dummyCubeTextureArray = rhiCtx->dummyTexture(QRhiTexture::CubeMap, resourceUpdates, QSize(64, 64), Qt::black, qMax(2u, inData.layer.viewCount));
rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates);
for (const QShaderDescription::InOutVariable &var : std::as_const(samplerVars)) {
if (!specifiedBindings.testBit(var.binding)) {
QRhiTexture *t = nullptr;
if (var.type == QShaderDescription::SamplerCube)
t = dummyCubeTexture;
else if (var.type == QShaderDescription::Sampler3D)
t = dummyTexture3D;
else if (var.type == QShaderDescription::Sampler2DArray)
t = dummyTextureArray;
else if (var.type == QShaderDescription::SamplerCubeArray)
t = dummyCubeTextureArray;
else
t = dummyTexture;
bindings.addTexture(var.binding, RENDERER_VISIBILITY_ALL, t, dummySampler);
}
}
}
QRhiShaderResourceBindings *srb = drawCallDataSrb(rhiCtxD, *dcd, bindings);
QSSG_ASSERT(srb, return -1);
auto &rhiPassData = subsetRenderable.rhiRenderData.userPassData[index];
rhiPassData.pipeline = rhiCtxD->pipeline(ps, rpDesc, srb);
rhiPassData.srb = srb;
}
}
return index;
}
bool RenderHelpers::rhiPrepareMotionVectorTexture(QSSGRhiContext *rhiCtx,
const QSize &size,
QSSGRhiRenderableTexture *renderableTex){
QRhi *rhi = rhiCtx->rhi();
bool needsBuild = false;
QRhiTexture::Flags flags = QRhiTexture::RenderTarget;
if (!renderableTex->texture) {
renderableTex->texture = rhi->newTexture(QRhiTexture::RGBA16F, size, 1, flags);
needsBuild = true;
} else if (renderableTex->texture->pixelSize() != size) {
renderableTex->texture->setPixelSize(size);
needsBuild = true;
}
if (!renderableTex->depthStencil && !renderableTex->depthTexture) {
renderableTex->depthStencil = rhi->newRenderBuffer(QRhiRenderBuffer::DepthStencil, size);
needsBuild = true;
} else {
if (renderableTex->depthStencil && renderableTex->depthStencil->pixelSize() != size) {
renderableTex->depthStencil->setPixelSize(size);
needsBuild = true;
}
}
if (needsBuild) {
if (!renderableTex->texture->create()) {
qWarning("Failed to build motionvector texture (size %dx%d)", size.width(), size.height());
renderableTex->reset();
return false;
}
if (renderableTex->depthStencil && !renderableTex->depthStencil->create()) {
qWarning("Failed to build depth-stencil buffer for motionvector texture (size %dx%d)",
size.width(), size.height());
renderableTex->reset();
return false;
}
renderableTex->resetRenderTarget();
QRhiTextureRenderTargetDescription desc;
QRhiColorAttachment colorAttachment(renderableTex->texture);
desc.setColorAttachments({ colorAttachment });
if (renderableTex->depthStencil)
desc.setDepthStencilBuffer(renderableTex->depthStencil);
renderableTex->rt = rhi->newTextureRenderTarget(desc);
renderableTex->rt->setName(QByteArrayLiteral("Motionvector texture"));
renderableTex->rpDesc = renderableTex->rt->newCompatibleRenderPassDescriptor();
renderableTex->rt->setRenderPassDescriptor(renderableTex->rpDesc);
if (!renderableTex->rt->create()) {
qWarning("Failed to build render target for motionvector texture");
renderableTex->reset();
return false;
}
}
return true;
}
void RenderHelpers::rhiPrepareMotionVectorRenderable(QSSGRhiContext *rhiCtx,
QSSGPassKey passKey,
const QSSGLayerRenderData &inData,
const QMatrix4x4 &viewProjection,
QSSGRenderableObject &inObject,
QRhiRenderPassDescriptor *renderPassDescriptor,
QSSGRhiGraphicsPipelineState *ps,
QSSGRenderMotionVectorMap &motionVectorMapManager)
{
if (inObject.type != QSSGRenderableObject::Type::DefaultMaterialMeshSubset &&
inObject.type != QSSGRenderableObject::Type::CustomMaterialMeshSubset)
return;
QSSGSubsetRenderable &subsetRenderable = static_cast<QSSGSubsetRenderable &>(inObject);
auto &modelNode = subsetRenderable.modelContext.model;
bool skin = modelNode.usesBoneTexture();
bool instance = modelNode.instanceCount() > 0;
bool morph = modelNode.morphTargets.size() > 0;
QSSGRhiShaderPipelinePtr shaderPipeline = inData.contextInterface()->shaderCache()->
getBuiltInRhiShaders().getRhiMotionVectorShader(skin, instance, morph);
if (!shaderPipeline)
return;
QSSGRhiShaderResourceBindingList bindings;
QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);
QSSGRhiDrawCallData &dcd = rhiCtxD->drawCallData({ passKey, &modelNode, nullptr, nullptr, 0 });
QSSGRenderTextureData *boneTextureData = nullptr;
if (modelNode.skin)
boneTextureData = modelNode.skin;
else if (modelNode.skeleton)
boneTextureData = &modelNode.skeleton->boneTexData;
QMatrix4x4 modelViewProjection = subsetRenderable.modelContext.modelViewProjections[0];
QMatrix4x4 instanceLocal;
QMatrix4x4 instanceGlobal;
if (instance) {
instanceLocal = inData.getInstanceTransforms(modelNode).local;
instanceGlobal = inData.getInstanceTransforms(modelNode).global;
if (!skin)
modelViewProjection = viewProjection;
}
auto motionData = motionVectorMapManager.trackMotionData(&modelNode,
modelViewProjection,
instanceLocal,
instanceGlobal,
boneTextureData,
modelNode.instanceTable,
modelNode.morphWeights);
float velocityAmount = subsetRenderable.modelContext.model.motionVectorScale;
int morphTargetCount = modelNode.morphWeights.count();
// mat4 mvp; // 64
// mat4 prevMVP; // 64
// mat4 instanceLocal; // 64
// mat4 instanceGlobal; // 64
// mat4 prevInstanceLocal; // 64
// mat4 prevInstanceGlobal; // 64
// vec4 currentAndLastJitter; // 16
// float velocityAmount; // 4
// int morphTargetCount; // 4
// vec2 padding; // 8
const int ubufSize = 416;
if (!dcd.ubuf) {
dcd.ubuf = rhiCtx->rhi()->newBuffer(QRhiBuffer::Dynamic,
QRhiBuffer::UniformBuffer,
ubufSize);
dcd.ubuf->create();
}
char *ubufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
int ubufOffset = 0;
memcpy(ubufData, modelViewProjection.constData(), 64);
ubufOffset += 64;
memcpy(ubufData + ubufOffset, motionData.prevModelViewProjection.constData(), 64);
ubufOffset += 64;
memcpy(ubufData + ubufOffset, instanceLocal.constData(), 64);
ubufOffset += 64;
memcpy(ubufData + ubufOffset, instanceGlobal.constData(), 64);
ubufOffset += 64;
memcpy(ubufData + ubufOffset, motionData.prevInstanceLocal.constData(), 64);
ubufOffset += 64;
memcpy(ubufData + ubufOffset, motionData.prevInstanceGlobal.constData(), 64);
ubufOffset += 64;
memcpy(ubufData + ubufOffset, &inData.layer.currentAndLastJitter, 16);
ubufOffset += 16;
memcpy(ubufData + ubufOffset, &velocityAmount, 4);
ubufOffset += 4;
memcpy(ubufData + ubufOffset, &morphTargetCount, 4);
dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame();
bindings.addUniformBuffer(0, QRhiShaderResourceBinding::VertexStage |
QRhiShaderResourceBinding::FragmentStage, dcd.ubuf);
QRhiSampler *nearestSampler = nullptr;
if (skin || instance) {
nearestSampler = rhiCtx->sampler({ QRhiSampler::Nearest,
QRhiSampler::Nearest,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::Repeat
});
}
if (skin) {
int binding = shaderPipeline->bindingForTexture("qt_boneTexture");
if (binding >= 0) {
bindings.addTexture(binding,
QRhiShaderResourceBinding::VertexStage,
inData.getBonemapTexture(subsetRenderable.modelContext),
nearestSampler);
binding = shaderPipeline->bindingForTexture("lastBoneTexture");
if (binding >= 0) {
bindings.addTexture(binding,
QRhiShaderResourceBinding::VertexStage,
motionData.prevBoneTexture.m_texture,
nearestSampler);
}
}
}
if (instance) {
int binding = shaderPipeline->bindingForTexture("lastInstanceTexture");
if (binding >= 0) {
bindings.addTexture(binding,
QRhiShaderResourceBinding::VertexStage,
motionData.prevInstanceTexture.m_texture,
nearestSampler);
}
}
auto *targetsTexture = subsetRenderable.subset.rhi.targetsTexture;
if (targetsTexture) {
int binding = shaderPipeline->bindingForTexture("qt_morphTargetTexture");
if (binding >= 0) {
QRhiSampler *targetsSampler = rhiCtx->sampler({ QRhiSampler::Nearest,
QRhiSampler::Nearest,
QRhiSampler::None,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge,
QRhiSampler::ClampToEdge
});
bindings.addTexture(binding, QRhiShaderResourceBinding::VertexStage, subsetRenderable.subset.rhi.targetsTexture, targetsSampler);
if ((binding = shaderPipeline->bindingForTexture("morphWeightTexture")) >= 0)
bindings.addTexture(binding, QRhiShaderResourceBinding::VertexStage, motionData.currentMorphWeightTexture.m_texture, targetsSampler);
if ((binding = shaderPipeline->bindingForTexture("lastMorphWeightTexture")) >= 0)
bindings.addTexture(binding, QRhiShaderResourceBinding::VertexStage, motionData.prevMorphWeightTexture.m_texture, targetsSampler);
}
}
auto &ia = QSSGRhiInputAssemblerStatePrivate::get(*ps);
ia = subsetRenderable.subset.rhi.ia;
const QSSGRenderCameraDataList &cameraDatas(*inData.renderedCameraData);
QVector3D cameraDirection = cameraDatas[0].direction;
QVector3D cameraPosition = cameraDatas[0].position;
int instanceBufferBinding = setupInstancing(&subsetRenderable, ps, rhiCtx, cameraDirection, cameraPosition);
QSSGRhiHelpers::bakeVertexInputLocations(&ia, *shaderPipeline, instanceBufferBinding);
QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(*ps, shaderPipeline.get());
QRhiShaderResourceBindings *&srb = dcd.srb;
bool srbChanged = false;
if (!srb || bindings != dcd.bindings) {
srb = rhiCtxD->srb(bindings);
rhiCtxD->releaseCachedSrb(dcd.bindings);
dcd.bindings = bindings;
srbChanged = true;
}
subsetRenderable.rhiRenderData.motionVectorPass.srb = srb;
const auto pipelineKey = QSSGGraphicsPipelineStateKey::create(*ps, renderPassDescriptor, srb);
if (dcd.pipeline
&& !srbChanged
&& dcd.renderTargetDescriptionHash == pipelineKey.extra.renderTargetDescriptionHash
&& dcd.renderTargetDescription == pipelineKey.renderTargetDescription
&& dcd.ps == *ps)
{
subsetRenderable.rhiRenderData.motionVectorPass.pipeline = dcd.pipeline;
} else {
subsetRenderable.rhiRenderData.motionVectorPass.pipeline = rhiCtxD->pipeline(pipelineKey,
renderPassDescriptor,
srb);
dcd.pipeline = subsetRenderable.rhiRenderData.motionVectorPass.pipeline;
dcd.renderTargetDescriptionHash = pipelineKey.extra.renderTargetDescriptionHash;
dcd.renderTargetDescription = pipelineKey.renderTargetDescription;
dcd.ps = *ps;
}
}
void RenderHelpers::rhiRenderMotionVector(QSSGRhiContext *rhiCtx,
const QSSGRhiGraphicsPipelineState &state,
const QSSGRenderableObjectList *motionVectorPassObjects,
int bucketsCount)
{
bool needsSetViewport = true;
auto renderObjectList = [&](const QSSGRenderableObjectList &objects) {
for (const auto &handle : objects) {
QSSGRenderableObject &object = *handle.obj;
// Only handle mesh subsets
if (object.type != QSSGRenderableObject::Type::DefaultMaterialMeshSubset &&
object.type != QSSGRenderableObject::Type::CustomMaterialMeshSubset)
continue;
QSSGSubsetRenderable &subsetRenderable = static_cast<QSSGSubsetRenderable &>(object);
QRhiGraphicsPipeline *ps = subsetRenderable.rhiRenderData.motionVectorPass.pipeline;
QRhiShaderResourceBindings *srb = subsetRenderable.rhiRenderData.motionVectorPass.srb;
if (!ps || !srb)
return;
QRhiBuffer *vertexBuffer = subsetRenderable.subset.rhi.vertexBuffer->buffer();
QRhiBuffer *indexBuffer = subsetRenderable.subset.rhi.indexBuffer ? subsetRenderable.subset.rhi.indexBuffer->buffer() : nullptr;
QRhiCommandBuffer *cb = rhiCtx->commandBuffer();
// QRhi optimizes out unnecessary binding of the same pipline
cb->setGraphicsPipeline(ps);
cb->setShaderResources(srb);
if (needsSetViewport) {
cb->setViewport(state.viewport);
if (state.flags.testFlag(QSSGRhiGraphicsPipelineState::Flag::UsesScissor))
cb->setScissor(state.scissor);
needsSetViewport = false;
}
QRhiCommandBuffer::VertexInput vertexBuffers[2];
int vertexBufferCount = 1;
vertexBuffers[0] = QRhiCommandBuffer::VertexInput(vertexBuffer, 0);
quint32 instances = 1;
if ( subsetRenderable.modelContext.model.instancing()) {
instances = subsetRenderable.modelContext.model.instanceCount();
// If the instance count is 0, bail out before trying to do any
// draw calls. Making an instanced draw call with a count of 0 is invalid
// for Metal and likely other API's as well.
// It is possible that the particle systems may produce 0 instances here
if (instances == 0)
return;
vertexBuffers[1] = QRhiCommandBuffer::VertexInput(subsetRenderable.instanceBuffer, 0);
vertexBufferCount = 2;
}
Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderCall);
if (state.flags.testFlag(QSSGRhiGraphicsPipelineState::Flag::UsesStencilRef))
cb->setStencilRef(state.stencilRef);
if (indexBuffer) {
cb->setVertexInput(0, vertexBufferCount, vertexBuffers, indexBuffer, 0, subsetRenderable.subset.rhi.indexBuffer->indexFormat());
cb->drawIndexed(subsetRenderable.subset.lodCount(subsetRenderable.subsetLevelOfDetail), instances, subsetRenderable.subset.lodOffset(subsetRenderable.subsetLevelOfDetail));
QSSGRHICTX_STAT(rhiCtx, drawIndexed(subsetRenderable.subset.lodCount(subsetRenderable.subsetLevelOfDetail), instances));
} else {
cb->setVertexInput(0, vertexBufferCount, vertexBuffers);
cb->draw(subsetRenderable.subset.count, instances, subsetRenderable.subset.offset);
QSSGRHICTX_STAT(rhiCtx, draw(subsetRenderable.subset.count, instances));
}
Q_QUICK3D_PROFILE_END_WITH_IDS(QQuick3DProfiler::Quick3DRenderCall, (subsetRenderable.subset.count | quint64(instances) << 32),
QVector<int>({subsetRenderable.modelContext.model.profilingId,
subsetRenderable.material.profilingId}));
}
};
for (int i = 0; i < bucketsCount; ++i)
renderObjectList(motionVectorPassObjects[i]);
}
QT_END_NAMESPACE