1 | // Copyright (C) 2023 The Qt Company Ltd. |
---|---|
2 | // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only |
3 | |
4 | #include "qssgdebugdrawsystem_p.h" |
5 | #include "qssgrenderhelpers_p.h" |
6 | |
7 | #include "qssgrenderer_p.h" |
8 | #include "qssglayerrenderdata_p.h" |
9 | #include "qssgrhiparticles_p.h" |
10 | #include "qssgrhiquadrenderer_p.h" |
11 | #include "../qssgrendercontextcore.h" |
12 | #include "../qssgrhicustommaterialsystem_p.h" |
13 | #include "../resourcemanager/qssgrenderbuffermanager_p.h" |
14 | #include "../qssgrenderdefaultmaterialshadergenerator_p.h" |
15 | #include "rendererimpl/qssgshadowmaphelpers_p.h" |
16 | #include <QtQuick3DUtils/private/qssgassert_p.h> |
17 | |
18 | #include <QtCore/qbitarray.h> |
19 | |
20 | QT_BEGIN_NAMESPACE |
21 | |
22 | static constexpr float QSSG_PI = float(M_PI); |
23 | static constexpr float QSSG_HALFPI = float(M_PI_2); |
24 | |
25 | static const QRhiShaderResourceBinding::StageFlags RENDERER_VISIBILITY_ALL = |
26 | QRhiShaderResourceBinding::VertexStage | QRhiShaderResourceBinding::FragmentStage; |
27 | |
28 | static QSSGRhiShaderPipelinePtr shadersForDefaultMaterial(QSSGRhiGraphicsPipelineState *ps, |
29 | QSSGSubsetRenderable &subsetRenderable, |
30 | const QSSGShaderFeatures &featureSet) |
31 | { |
32 | auto &renderer(subsetRenderable.renderer); |
33 | const auto &shaderPipeline = QSSGRendererPrivate::getShaderPipelineForDefaultMaterial(renderer&: *renderer, inRenderable&: subsetRenderable, inFeatureSet: featureSet); |
34 | if (shaderPipeline) |
35 | QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps&: *ps, pipeline: shaderPipeline.get()); |
36 | return shaderPipeline; |
37 | } |
38 | |
39 | static QSSGRhiShaderPipelinePtr shadersForParticleMaterial(QSSGRhiGraphicsPipelineState *ps, |
40 | QSSGParticlesRenderable &particleRenderable) |
41 | { |
42 | const auto &renderer(particleRenderable.renderer); |
43 | const auto &shaderCache = renderer->contextInterface()->shaderCache(); |
44 | auto featureLevel = particleRenderable.particles.m_featureLevel; |
45 | const auto &shaderPipeline = shaderCache->getBuiltInRhiShaders().getRhiParticleShader(featureLevel, viewCount: ps->viewCount); |
46 | if (shaderPipeline) |
47 | QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps&: *ps, pipeline: shaderPipeline.get()); |
48 | return shaderPipeline; |
49 | } |
50 | |
51 | static void updateUniformsForDefaultMaterial(QSSGRhiShaderPipeline &shaderPipeline, |
52 | QSSGRhiContext *rhiCtx, |
53 | const QSSGLayerRenderData &inData, |
54 | char *ubufData, |
55 | QSSGRhiGraphicsPipelineState *ps, |
56 | QSSGSubsetRenderable &subsetRenderable, |
57 | const QSSGRenderCameraList &cameras, |
58 | const QVector2D *depthAdjust, |
59 | const QMatrix4x4 *alteredModelViewProjection) |
60 | { |
61 | const auto &renderer(subsetRenderable.renderer); |
62 | const QMatrix4x4 clipSpaceCorrMatrix = rhiCtx->rhi()->clipSpaceCorrMatrix(); |
63 | QSSGRenderMvpArray alteredMvpList; |
64 | if (alteredModelViewProjection) |
65 | alteredMvpList[0] = *alteredModelViewProjection; |
66 | |
67 | const auto &modelNode = subsetRenderable.modelContext.model; |
68 | QRhiTexture *lightmapTexture = inData.getLightmapTexture(modelContext: subsetRenderable.modelContext); |
69 | |
70 | const QMatrix4x4 &localInstanceTransform(modelNode.localInstanceTransform); |
71 | const QMatrix4x4 &globalInstanceTransform(modelNode.globalInstanceTransform); |
72 | const QMatrix4x4 &modelMatrix(modelNode.usesBoneTexture() ? QMatrix4x4() : subsetRenderable.globalTransform); |
73 | |
74 | QSSGMaterialShaderGenerator::setRhiMaterialProperties(*renderer->contextInterface(), |
75 | shaders&: shaderPipeline, |
76 | ubufData, |
77 | inPipelineState: ps, |
78 | inMaterial: subsetRenderable.material, |
79 | inKey: subsetRenderable.shaderDescription, |
80 | inProperties: inData.getDefaultMaterialPropertyTable(), |
81 | inCameras: cameras, |
82 | inModelViewProjections: alteredModelViewProjection ? alteredMvpList : subsetRenderable.modelContext.modelViewProjections, |
83 | inNormalMatrix: subsetRenderable.modelContext.normalMatrix, |
84 | inGlobalTransform: modelMatrix, |
85 | clipSpaceCorrMatrix, |
86 | localInstanceTransform, |
87 | globalInstanceTransform, |
88 | inMorphWeights: toDataView(type: modelNode.morphWeights), |
89 | inFirstImage: subsetRenderable.firstImage, |
90 | inOpacity: subsetRenderable.opacity, |
91 | inRenderProperties: inData, |
92 | inLights: subsetRenderable.lights, |
93 | reflectionProbe: subsetRenderable.reflectionProbe, |
94 | receivesShadows: subsetRenderable.renderableFlags.receivesShadows(), |
95 | receivesReflections: subsetRenderable.renderableFlags.receivesReflections(), |
96 | shadowDepthAdjust: depthAdjust, |
97 | lightmapTexture); |
98 | } |
99 | |
100 | std::pair<QSSGBounds3, QSSGBounds3> RenderHelpers::calculateSortedObjectBounds(const QSSGRenderableObjectList &sortedOpaqueObjects, |
101 | const QSSGRenderableObjectList &sortedTransparentObjects) |
102 | { |
103 | QSSGBounds3 boundsCasting; |
104 | QSSGBounds3 boundsReceiving; |
105 | for (const auto handles : { &sortedOpaqueObjects, &sortedTransparentObjects }) { |
106 | // Since we may have nodes that are not a child of the camera parent we go through all |
107 | // the opaque objects and include them in the bounds. Failing to do this can result in |
108 | // too small bounds. |
109 | for (const QSSGRenderableObjectHandle &handle : *handles) { |
110 | const QSSGRenderableObject &obj = *handle.obj; |
111 | // We skip objects not casting or receiving shadows since they don't influence or need to be covered by the shadow map |
112 | if (obj.renderableFlags.castsShadows()) |
113 | boundsCasting.include(b: obj.globalBounds); |
114 | if (obj.renderableFlags.receivesShadows()) |
115 | boundsReceiving.include(b: obj.globalBounds); |
116 | } |
117 | } |
118 | return { boundsCasting, boundsReceiving }; |
119 | } |
120 | |
121 | static QSSGBoxPoints computeFrustumBounds(const QMatrix4x4 &projection) |
122 | { |
123 | bool invertible = false; |
124 | QMatrix4x4 inv = projection.inverted(invertible: &invertible); |
125 | Q_ASSERT(invertible); |
126 | |
127 | // The frustum points will be in this orientation |
128 | // |
129 | // bottom top |
130 | // 4__________5 7__________6 |
131 | // \ / \ / |
132 | // \ / \ / |
133 | // \____/ \____/ |
134 | // 0 1 3 2 |
135 | return { inv.map(point: QVector3D(-1, -1, -1)), inv.map(point: QVector3D(+1, -1, -1)), inv.map(point: QVector3D(+1, +1, -1)), |
136 | inv.map(point: QVector3D(-1, +1, -1)), inv.map(point: QVector3D(-1, -1, +1)), inv.map(point: QVector3D(+1, -1, +1)), |
137 | inv.map(point: QVector3D(+1, +1, +1)), inv.map(point: QVector3D(-1, +1, +1)) }; |
138 | } |
139 | |
140 | static QSSGBoxPoints sliceFrustum(const QSSGBoxPoints &frustumPoints, float t0, float t1) |
141 | { |
142 | QSSGBoxPoints pts; |
143 | for (int i = 0; i < 4; ++i) { |
144 | const QVector3D forward = frustumPoints[i + 4] - frustumPoints[i]; |
145 | pts[i] = frustumPoints[i] + forward * t0; |
146 | pts[i + 4] = frustumPoints[i] + forward * t1; |
147 | } |
148 | return pts; |
149 | } |
150 | |
151 | static std::unique_ptr<QSSGRenderCamera> computeShadowCameraFromFrustum(const QMatrix4x4 &lightMatrix, |
152 | const QMatrix4x4 &lightMatrixInverted, |
153 | const QVector3D &lightPivot, |
154 | const QVector3D &lightForward, |
155 | const QVector3D &lightUp, |
156 | const float shadowMapResolution, |
157 | const float pcfRadius, |
158 | const QSSGBoxPoints &frustumPoints, |
159 | float frustumStartT, |
160 | float frustumEndT, |
161 | const QSSGBounds3 &castingBox, |
162 | const QSSGBounds3 &receivingBox, |
163 | QSSGDebugDrawSystem *debugDrawSystem, |
164 | const bool drawCascades, |
165 | const bool drawSceneCascadeIntersection) |
166 | { |
167 | if (!castingBox.isFinite() || castingBox.isEmpty() || !receivingBox.isFinite() || receivingBox.isEmpty()) |
168 | return nullptr; // Return early, no casting or receiving objects means no shadows |
169 | |
170 | Q_ASSERT(frustumStartT <= frustumEndT); |
171 | Q_ASSERT(frustumStartT >= 0.f); |
172 | Q_ASSERT(frustumEndT <= 1.0f); |
173 | |
174 | auto transformPoints = [&](const QSSGBoxPoints &points) { |
175 | QSSGBoxPoints result; |
176 | for (int i = 0; i < int(points.size()); ++i) { |
177 | result[i] = lightMatrix.map(point: points[i]); |
178 | } |
179 | return result; |
180 | }; |
181 | |
182 | QSSGBoxPoints frustumPointsSliced = sliceFrustum(frustumPoints, t0: frustumStartT, t1: frustumEndT); |
183 | if (drawCascades) |
184 | ShadowmapHelpers::addDebugFrustum(frustumPoints: frustumPointsSliced, color: QColorConstants::Black, debugDrawSystem); |
185 | |
186 | QList<QVector3D> receivingSliced = ShadowmapHelpers::intersectBoxByFrustum(frustumPoints: frustumPointsSliced, |
187 | box: receivingBox.toQSSGBoxPoints(), |
188 | debugDrawSystem: drawSceneCascadeIntersection ? debugDrawSystem : nullptr, |
189 | color: QColorConstants::DarkGray); |
190 | if (receivingSliced.isEmpty()) |
191 | return nullptr; |
192 | |
193 | QSSGBounds3 receivingFrustumSlicedLightSpace; |
194 | for (const QVector3D &point : receivingSliced) |
195 | receivingFrustumSlicedLightSpace.include(v: lightMatrix.map(point)); |
196 | |
197 | // Slice casting box by frustumBounds' left, right, up, down planes |
198 | QList<QVector3D> castingPointsLightSpace = ShadowmapHelpers::intersectBoxByBox(boxBounds: receivingFrustumSlicedLightSpace, |
199 | box: transformPoints(castingBox.toQSSGBoxPointsNoEmptyCheck())); |
200 | if (castingPointsLightSpace.isEmpty()) |
201 | return nullptr; |
202 | |
203 | // Create box containing casting and receiving from light space: |
204 | QSSGBounds3 castReceiveBounds; |
205 | for (const QVector3D &p : castingPointsLightSpace) { |
206 | castReceiveBounds.include(v: p); |
207 | } |
208 | |
209 | for (const QVector3D &p : receivingFrustumSlicedLightSpace.toQSSGBoxPointsNoEmptyCheck()) { |
210 | float zMax = qMax(a: p.z(), b: castReceiveBounds.maximum.z()); |
211 | float zMin = qMin(a: p.z(), b: castReceiveBounds.minimum.z()); |
212 | castReceiveBounds.maximum.setZ(zMax); |
213 | castReceiveBounds.minimum.setZ(zMin); |
214 | } |
215 | |
216 | // Expand to fit pcf radius |
217 | castReceiveBounds.fatten(distance: pcfRadius); |
218 | |
219 | QVector3D boundsCenterWorld = lightMatrixInverted.map(point: castReceiveBounds.center()); |
220 | QVector3D boundsDims = castReceiveBounds.dimensions(); |
221 | boundsDims.setZ(boundsDims.z() * 1.01f); // Expand slightly in z direction to avoid pancaking precision errors |
222 | |
223 | // We expand the shadowmap to cover the bounds with one extra texel on all sides |
224 | const float texelExpandFactor = shadowMapResolution / (shadowMapResolution - 2); |
225 | |
226 | QRectF theViewport(0.0f, 0.0f, boundsDims.x() * texelExpandFactor, boundsDims.y() * texelExpandFactor); |
227 | |
228 | auto camera = std::make_unique<QSSGRenderCamera>(args: QSSGRenderGraphObject::Type::OrthographicCamera); |
229 | camera->clipNear = -0.5f * boundsDims.z(); |
230 | camera->clipFar = 0.5f * boundsDims.z(); |
231 | camera->fov = qDegreesToRadians(degrees: 90.f); |
232 | camera->parent = nullptr; |
233 | camera->localTransform = QSSGRenderNode::calculateTransformMatrix(position: boundsCenterWorld, |
234 | scale: QSSGRenderNode::initScale, |
235 | pivot: lightPivot, |
236 | rotation: QQuaternion::fromDirection(direction: lightForward, up: lightUp)); |
237 | camera->calculateGlobalVariables(inViewport: theViewport); |
238 | |
239 | return camera; |
240 | } |
241 | |
242 | static QVarLengthArray<std::unique_ptr<QSSGRenderCamera>, 4> setupCascadingCamerasForShadowMap(const QSSGRenderCamera &inCamera, |
243 | const QSSGRenderLight *inLight, |
244 | const int shadowMapResolution, |
245 | const float pcfRadius, |
246 | const float clipNear, |
247 | const float clipFar, |
248 | const QSSGBounds3 &castingObjectsBox, |
249 | const QSSGBounds3 &receivingObjectsBox, |
250 | QSSGDebugDrawSystem *debugDrawSystem, |
251 | bool drawCascades, |
252 | bool drawSceneCascadeIntersection) |
253 | { |
254 | Q_ASSERT(inLight->type == QSSGRenderLight::Type::DirectionalLight); |
255 | QVarLengthArray<std::unique_ptr<QSSGRenderCamera>, 4> result; |
256 | |
257 | if (clipNear >= clipFar || qFuzzyCompare(p1: clipNear, p2: clipFar)) |
258 | return result; |
259 | |
260 | const QVector3D lightDir = inLight->getDirection(); |
261 | const QVector3D lightPivot = inLight->pivot; |
262 | |
263 | const QVector3D forward = lightDir.normalized(); |
264 | const QVector3D right = qFuzzyCompare(p1: qAbs(t: forward.y()), p2: 1.0f) |
265 | ? QVector3D::crossProduct(v1: forward, v2: QVector3D(1, 0, 0)).normalized() |
266 | : QVector3D::crossProduct(v1: forward, v2: QVector3D(0, 1, 0)).normalized(); |
267 | const QVector3D up = QVector3D::crossProduct(v1: right, v2: forward).normalized(); |
268 | |
269 | QMatrix4x4 lightMatrix; |
270 | lightMatrix.setRow(index: 0, value: QVector4D(right, 0.0f)); |
271 | lightMatrix.setRow(index: 1, value: QVector4D(up, 0.0f)); |
272 | lightMatrix.setRow(index: 2, value: QVector4D(forward, 0.0f)); |
273 | lightMatrix.setRow(index: 3, value: QVector4D(0.0f, 0.0f, 0.0f, 1.0f)); |
274 | QMatrix4x4 lightMatrixInverted = lightMatrix.inverted(); |
275 | |
276 | const float farScale = (clipFar - clipNear) / (inCamera.clipFar - inCamera.clipNear); |
277 | |
278 | QMatrix4x4 viewProjection(Qt::Uninitialized); |
279 | inCamera.calculateViewProjectionMatrix(outMatrix&: viewProjection); |
280 | const QSSGBoxPoints frustum = computeFrustumBounds(projection: viewProjection); |
281 | |
282 | const auto computeSplitRanges = [inLight](const QVarLengthArray<float, 3> &splits) -> QVarLengthArray<QPair<float, float>, 4> { |
283 | QVarLengthArray<QPair<float, float>, 4> ranges; |
284 | const float csmBlendRatio = inLight->m_csmBlendRatio; |
285 | float t0 = 0.f; |
286 | for (qsizetype i = 0; i < splits.length(); i++) { |
287 | const float tI = qBound(min: qMin(a: t0 + 0.01f, b: 1.0f), val: splits[i], max: 1.0f); |
288 | ranges.emplace_back(args&: t0, args: qMin(a: 1.0f, b: tI + csmBlendRatio)); |
289 | t0 = tI; |
290 | } |
291 | ranges.emplace_back(args&: t0, args: 1.0f); |
292 | return ranges; |
293 | }; |
294 | |
295 | const auto computeFrustums = [&](const QVarLengthArray<float, 3> &splits) { |
296 | for (const auto &range : computeSplitRanges(splits)) { |
297 | auto camera = computeShadowCameraFromFrustum(lightMatrix, |
298 | lightMatrixInverted, |
299 | lightPivot, |
300 | lightForward: forward, |
301 | lightUp: up, |
302 | shadowMapResolution, |
303 | pcfRadius, |
304 | frustumPoints: frustum, |
305 | frustumStartT: range.first * farScale, |
306 | frustumEndT: range.second * farScale, |
307 | castingBox: castingObjectsBox, |
308 | receivingBox: receivingObjectsBox, |
309 | debugDrawSystem, |
310 | drawCascades, |
311 | drawSceneCascadeIntersection); |
312 | result.emplace_back(args: std::move(camera)); |
313 | } |
314 | }; |
315 | |
316 | switch (inLight->m_csmNumSplits) { |
317 | case 0: { |
318 | computeFrustums({}); |
319 | break; |
320 | } |
321 | case 1: { |
322 | computeFrustums({ inLight->m_csmSplit1 }); |
323 | break; |
324 | } |
325 | case 2: { |
326 | computeFrustums({ inLight->m_csmSplit1, inLight->m_csmSplit2 }); |
327 | break; |
328 | } |
329 | case 3: { |
330 | computeFrustums({ inLight->m_csmSplit1, inLight->m_csmSplit2, inLight->m_csmSplit3 }); |
331 | break; |
332 | } |
333 | default: |
334 | Q_UNREACHABLE(); |
335 | break; |
336 | } |
337 | |
338 | return result; |
339 | } |
340 | |
341 | static void setupCubeReflectionCameras(const QSSGRenderReflectionProbe *inProbe, QSSGRenderCamera inCameras[6]) |
342 | { |
343 | Q_ASSERT(inProbe != nullptr); |
344 | |
345 | // setup light matrix |
346 | quint32 mapRes = 1 << inProbe->reflectionMapRes; |
347 | QRectF theViewport(0.0f, 0.0f, (float)mapRes, (float)mapRes); |
348 | static const QQuaternion rotOfs[6] { |
349 | QQuaternion::fromEulerAngles(pitch: 0.f, yaw: qRadiansToDegrees(radians: -QSSG_HALFPI), roll: qRadiansToDegrees(radians: QSSG_PI)), |
350 | QQuaternion::fromEulerAngles(pitch: 0.f, yaw: qRadiansToDegrees(radians: QSSG_HALFPI), roll: qRadiansToDegrees(radians: QSSG_PI)), |
351 | QQuaternion::fromEulerAngles(pitch: qRadiansToDegrees(radians: QSSG_HALFPI), yaw: 0.f, roll: 0.f), |
352 | QQuaternion::fromEulerAngles(pitch: qRadiansToDegrees(radians: -QSSG_HALFPI), yaw: 0.f, roll: 0.f), |
353 | QQuaternion::fromEulerAngles(pitch: 0.f, yaw: qRadiansToDegrees(radians: QSSG_PI), roll: qRadiansToDegrees(radians: -QSSG_PI)), |
354 | QQuaternion::fromEulerAngles(pitch: 0.f, yaw: 0.f, roll: qRadiansToDegrees(radians: QSSG_PI)), |
355 | }; |
356 | |
357 | const QVector3D inProbePos = inProbe->getGlobalPos(); |
358 | const QVector3D inProbePivot = inProbe->pivot; |
359 | |
360 | for (int i = 0; i < 6; ++i) { |
361 | inCameras[i].parent = nullptr; |
362 | inCameras[i].clipNear = 1.0f; |
363 | inCameras[i].clipFar = qMax<float>(a: 2.0f, b: 10000.0f); |
364 | inCameras[i].fov = qDegreesToRadians(degrees: 90.f); |
365 | |
366 | inCameras[i].localTransform = QSSGRenderNode::calculateTransformMatrix(position: inProbePos, scale: QSSGRenderNode::initScale, pivot: inProbePivot, rotation: rotOfs[i]); |
367 | inCameras[i].calculateGlobalVariables(inViewport: theViewport); |
368 | } |
369 | } |
370 | |
371 | static void addOpaqueDepthPrePassBindings(QSSGRhiContext *rhiCtx, |
372 | QSSGRhiShaderPipeline *shaderPipeline, |
373 | QSSGRenderableImage *renderableImage, |
374 | QSSGRhiShaderResourceBindingList &bindings, |
375 | bool isCustomMaterialMeshSubset = false) |
376 | { |
377 | static const auto imageAffectsAlpha = [](QSSGRenderableImage::Type mapType) { |
378 | return mapType == QSSGRenderableImage::Type::BaseColor || |
379 | mapType == QSSGRenderableImage::Type::Diffuse || |
380 | mapType == QSSGRenderableImage::Type::Translucency || |
381 | mapType == QSSGRenderableImage::Type::Opacity; |
382 | }; |
383 | |
384 | while (renderableImage) { |
385 | const auto mapType = renderableImage->m_mapType; |
386 | if (imageAffectsAlpha(mapType)) { |
387 | const char *samplerName = QSSGMaterialShaderGenerator::getSamplerName(type: mapType); |
388 | const int samplerHint = int(mapType); |
389 | int samplerBinding = shaderPipeline->bindingForTexture(name: samplerName, hint: samplerHint); |
390 | if (samplerBinding >= 0) { |
391 | QRhiTexture *texture = renderableImage->m_texture.m_texture; |
392 | if (samplerBinding >= 0 && texture) { |
393 | const bool mipmapped = texture->flags().testFlag(flag: QRhiTexture::MipMapped); |
394 | QRhiSampler *sampler = rhiCtx->sampler(samplerDescription: { .minFilter: QSSGRhiHelpers::toRhi(op: renderableImage->m_imageNode.m_minFilterType), |
395 | .magFilter: QSSGRhiHelpers::toRhi(op: renderableImage->m_imageNode.m_magFilterType), |
396 | .mipmap: mipmapped ? QSSGRhiHelpers::toRhi(op: renderableImage->m_imageNode.m_mipFilterType) : QRhiSampler::None, |
397 | .hTiling: QSSGRhiHelpers::toRhi(tiling: renderableImage->m_imageNode.m_horizontalTilingMode), |
398 | .vTiling: QSSGRhiHelpers::toRhi(tiling: renderableImage->m_imageNode.m_verticalTilingMode), |
399 | .zTiling: QSSGRhiHelpers::toRhi(tiling: renderableImage->m_imageNode.m_depthTilingMode) |
400 | }); |
401 | bindings.addTexture(binding: samplerBinding, stage: RENDERER_VISIBILITY_ALL, tex: texture, sampler); |
402 | } |
403 | } // else this is not necessarily an error, e.g. having metalness/roughness maps with metalness disabled |
404 | } |
405 | renderableImage = renderableImage->m_nextImage; |
406 | } |
407 | // For custom Materials we can't know which maps affect alpha, so map all |
408 | if (isCustomMaterialMeshSubset) { |
409 | QVector<QShaderDescription::InOutVariable> samplerVars = |
410 | shaderPipeline->fragmentStage()->shader().description().combinedImageSamplers(); |
411 | for (const QShaderDescription::InOutVariable &var : shaderPipeline->vertexStage()->shader().description().combinedImageSamplers()) { |
412 | auto it = std::find_if(first: samplerVars.cbegin(), last: samplerVars.cend(), |
413 | pred: [&var](const QShaderDescription::InOutVariable &v) { return var.binding == v.binding; }); |
414 | if (it == samplerVars.cend()) |
415 | samplerVars.append(t: var); |
416 | } |
417 | |
418 | int maxSamplerBinding = -1; |
419 | for (const QShaderDescription::InOutVariable &var : samplerVars) |
420 | maxSamplerBinding = qMax(a: maxSamplerBinding, b: var.binding); |
421 | |
422 | // Will need to set unused image-samplers to something dummy |
423 | // because the shader code contains all custom property textures, |
424 | // and not providing a binding for all of them is invalid with some |
425 | // graphics APIs (and will need a real texture because setting a |
426 | // null handle or similar is not permitted with some of them so the |
427 | // srb does not accept null QRhiTextures either; but first let's |
428 | // figure out what bindings are unused in this frame) |
429 | QBitArray samplerBindingsSpecified(maxSamplerBinding + 1); |
430 | |
431 | if (maxSamplerBinding >= 0) { |
432 | // custom property textures |
433 | int customTexCount = shaderPipeline->extraTextureCount(); |
434 | for (int i = 0; i < customTexCount; ++i) { |
435 | const QSSGRhiTexture &t(shaderPipeline->extraTextureAt(index: i)); |
436 | const int samplerBinding = shaderPipeline->bindingForTexture(name: t.name); |
437 | if (samplerBinding >= 0) { |
438 | samplerBindingsSpecified.setBit(samplerBinding); |
439 | QRhiSampler *sampler = rhiCtx->sampler(samplerDescription: t.samplerDesc); |
440 | bindings.addTexture(binding: samplerBinding, |
441 | stage: RENDERER_VISIBILITY_ALL, |
442 | tex: t.texture, |
443 | sampler); |
444 | } |
445 | } |
446 | } |
447 | |
448 | // use a dummy texture for the unused samplers in the shader |
449 | QRhiSampler *dummySampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Nearest, .magFilter: QRhiSampler::Nearest, .mipmap: QRhiSampler::None, |
450 | .hTiling: QRhiSampler::ClampToEdge, .vTiling: QRhiSampler::ClampToEdge, .zTiling: QRhiSampler::Repeat }); |
451 | QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch(); |
452 | QRhiTexture *dummyTexture = rhiCtx->dummyTexture(flags: {}, rub: resourceUpdates); |
453 | QRhiTexture *dummyCubeTexture = rhiCtx->dummyTexture(flags: QRhiTexture::CubeMap, rub: resourceUpdates); |
454 | rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates); |
455 | |
456 | for (const QShaderDescription::InOutVariable &var : samplerVars) { |
457 | if (!samplerBindingsSpecified.testBit(i: var.binding)) { |
458 | QRhiTexture *t = var.type == QShaderDescription::SamplerCube ? dummyCubeTexture : dummyTexture; |
459 | bindings.addTexture(binding: var.binding, stage: RENDERER_VISIBILITY_ALL, tex: t, sampler: dummySampler); |
460 | } |
461 | } |
462 | } |
463 | } |
464 | |
465 | static void setupCubeShadowCameras(const QSSGRenderLight *inLight, float shadowMapFar, QSSGRenderCamera inCameras[6]) |
466 | { |
467 | Q_ASSERT(inLight != nullptr); |
468 | Q_ASSERT(inLight->type != QSSGRenderLight::Type::DirectionalLight); |
469 | |
470 | // setup light matrix |
471 | quint32 mapRes = inLight->m_shadowMapRes; |
472 | QRectF theViewport(0.0f, 0.0f, (float)mapRes, (float)mapRes); |
473 | static const QQuaternion rotOfs[6] { |
474 | QQuaternion::fromEulerAngles(pitch: 0.f, yaw: qRadiansToDegrees(radians: -QSSG_HALFPI), roll: qRadiansToDegrees(radians: QSSG_PI)), |
475 | QQuaternion::fromEulerAngles(pitch: 0.f, yaw: qRadiansToDegrees(radians: QSSG_HALFPI), roll: qRadiansToDegrees(radians: QSSG_PI)), |
476 | QQuaternion::fromEulerAngles(pitch: qRadiansToDegrees(radians: QSSG_HALFPI), yaw: 0.f, roll: 0.f), |
477 | QQuaternion::fromEulerAngles(pitch: qRadiansToDegrees(radians: -QSSG_HALFPI), yaw: 0.f, roll: 0.f), |
478 | QQuaternion::fromEulerAngles(pitch: 0.f, yaw: qRadiansToDegrees(radians: QSSG_PI), roll: qRadiansToDegrees(radians: -QSSG_PI)), |
479 | QQuaternion::fromEulerAngles(pitch: 0.f, yaw: 0.f, roll: qRadiansToDegrees(radians: QSSG_PI)), |
480 | }; |
481 | |
482 | const QVector3D inLightPos = inLight->getGlobalPos(); |
483 | constexpr QVector3D lightPivot = QVector3D(0, 0, 0); |
484 | |
485 | for (int i = 0; i < 6; ++i) { |
486 | inCameras[i].parent = nullptr; |
487 | inCameras[i].clipNear = 1.0f; |
488 | inCameras[i].clipFar = shadowMapFar; |
489 | inCameras[i].fov = qDegreesToRadians(degrees: 90.f); |
490 | inCameras[i].localTransform = QSSGRenderNode::calculateTransformMatrix(position: inLightPos, scale: QSSGRenderNode::initScale, pivot: lightPivot, rotation: rotOfs[i]); |
491 | inCameras[i].calculateGlobalVariables(inViewport: theViewport); |
492 | } |
493 | |
494 | /* |
495 | if ( inLight->type == RenderLightTypes::Point ) return; |
496 | |
497 | QVector3D viewDirs[6]; |
498 | QVector3D viewUp[6]; |
499 | QMatrix3x3 theDirMatrix( inLight->m_GlobalTransform.getUpper3x3() ); |
500 | |
501 | viewDirs[0] = theDirMatrix.transform( QVector3D( 1.f, 0.f, 0.f ) ); |
502 | viewDirs[2] = theDirMatrix.transform( QVector3D( 0.f, -1.f, 0.f ) ); |
503 | viewDirs[4] = theDirMatrix.transform( QVector3D( 0.f, 0.f, 1.f ) ); |
504 | viewDirs[0].normalize(); viewDirs[2].normalize(); viewDirs[4].normalize(); |
505 | viewDirs[1] = -viewDirs[0]; |
506 | viewDirs[3] = -viewDirs[2]; |
507 | viewDirs[5] = -viewDirs[4]; |
508 | |
509 | viewUp[0] = viewDirs[2]; |
510 | viewUp[1] = viewDirs[2]; |
511 | viewUp[2] = viewDirs[5]; |
512 | viewUp[3] = viewDirs[4]; |
513 | viewUp[4] = viewDirs[2]; |
514 | viewUp[5] = viewDirs[2]; |
515 | |
516 | for (int i = 0; i < 6; ++i) |
517 | { |
518 | inCameras[i].LookAt( inLightPos, viewUp[i], inLightPos + viewDirs[i] ); |
519 | inCameras[i].CalculateGlobalVariables( theViewport, QVector2D( theViewport.m_Width, |
520 | theViewport.m_Height ) ); |
521 | } |
522 | */ |
523 | } |
524 | |
525 | static int setupInstancing(QSSGSubsetRenderable *renderable, QSSGRhiGraphicsPipelineState *ps, QSSGRhiContext *rhiCtx, const QVector3D &cameraDirection, const QVector3D &cameraPosition) |
526 | { |
527 | // TODO: non-static so it can be used from QSSGCustomMaterialSystem::rhiPrepareRenderable()? |
528 | const bool instancing = QSSGLayerRenderData::prepareInstancing(rhiCtx, renderable, cameraDirection, cameraPosition, minThreshold: renderable->instancingLodMin, maxThreshold: renderable->instancingLodMax); |
529 | int instanceBufferBinding = 0; |
530 | if (instancing) { |
531 | auto &ia = QSSGRhiInputAssemblerStatePrivate::get(ps&: *ps); |
532 | // set up new bindings for instanced buffers |
533 | const quint32 stride = renderable->modelContext.model.instanceTable->stride(); |
534 | QVarLengthArray<QRhiVertexInputBinding, 8> bindings; |
535 | std::copy(first: ia.inputLayout.cbeginBindings(), last: ia.inputLayout.cendBindings(), result: std::back_inserter(x&: bindings)); |
536 | bindings.append(t: { stride, QRhiVertexInputBinding::PerInstance }); |
537 | instanceBufferBinding = bindings.size() - 1; |
538 | ia.inputLayout.setBindings(first: bindings.cbegin(), last: bindings.cend()); |
539 | } |
540 | return instanceBufferBinding; |
541 | } |
542 | |
543 | static void rhiPrepareResourcesForReflectionMap(QSSGRhiContext *rhiCtx, |
544 | QSSGPassKey passKey, |
545 | const QSSGLayerRenderData &inData, |
546 | QSSGReflectionMapEntry *pEntry, |
547 | QSSGRhiGraphicsPipelineState *ps, |
548 | const QSSGRenderableObjectList &sortedOpaqueObjects, |
549 | QSSGRenderCamera &inCamera, |
550 | QSSGRenderer &renderer, |
551 | QSSGRenderTextureCubeFace cubeFace) |
552 | { |
553 | using namespace RenderHelpers; |
554 | |
555 | if ((inData.layer.background == QSSGRenderLayer::Background::SkyBox && inData.layer.lightProbe) || |
556 | inData.layer.background == QSSGRenderLayer::Background::SkyBoxCubeMap) |
557 | rhiPrepareSkyBoxForReflectionMap(rhiCtx, passKey, layer&: inData.layer, inCamera, renderer, entry: pEntry, cubeFace); |
558 | |
559 | QSSGShaderFeatures features = inData.getShaderFeatures(); |
560 | // because of alteredCamera/alteredMvp below |
561 | features.set(feature: QSSGShaderFeatures::Feature::DisableMultiView, val: true); |
562 | |
563 | const auto &defaultMaterialShaderKeyProperties = inData.getDefaultMaterialPropertyTable(); |
564 | |
565 | for (const auto &handle : sortedOpaqueObjects) { |
566 | QSSGRenderableObject &inObject = *handle.obj; |
567 | |
568 | QMatrix4x4 modelViewProjection; |
569 | if (inObject.type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || inObject.type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) { |
570 | QSSGSubsetRenderable &renderable(static_cast<QSSGSubsetRenderable &>(inObject)); |
571 | const bool hasSkinning = defaultMaterialShaderKeyProperties.m_boneCount.getValue(inDataStore: renderable.shaderDescription) > 0; |
572 | modelViewProjection = hasSkinning ? pEntry->m_viewProjection |
573 | : pEntry->m_viewProjection * renderable.globalTransform; |
574 | } |
575 | |
576 | // here we pass on our own alteredCamera and alteredModelViewProjection |
577 | rhiPrepareRenderable(rhiCtx, passKey, inData, inObject, renderPassDescriptor: pEntry->m_rhiRenderPassDesc, ps, featureSet: features, samples: 1, viewCount: 1, |
578 | alteredCamera: &inCamera, alteredModelViewProjection: &modelViewProjection, cubeFace, entry: pEntry); |
579 | } |
580 | } |
581 | |
582 | static inline void addDepthTextureBindings(QSSGRhiContext *rhiCtx, |
583 | QSSGRhiShaderPipeline *shaderPipeline, |
584 | QSSGRhiShaderResourceBindingList &bindings) |
585 | { |
586 | if (shaderPipeline->depthTexture()) { |
587 | const int depthTextureBinding = shaderPipeline->bindingForTexture(name: "qt_depthTexture", hint: int(QSSGRhiSamplerBindingHints::DepthTexture)); |
588 | const int depthTextureArrayBinding = shaderPipeline->bindingForTexture(name: "qt_depthTextureArray", hint: int(QSSGRhiSamplerBindingHints::DepthTextureArray)); |
589 | if (depthTextureBinding >= 0 || depthTextureArrayBinding >= 0) { |
590 | // nearest min/mag, no mipmap |
591 | QRhiSampler *sampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Nearest, .magFilter: QRhiSampler::Nearest, .mipmap: QRhiSampler::None, |
592 | .hTiling: QRhiSampler::ClampToEdge, .vTiling: QRhiSampler::ClampToEdge, .zTiling: QRhiSampler::Repeat }); |
593 | if (depthTextureBinding >= 0) |
594 | bindings.addTexture(binding: depthTextureBinding, stage: QRhiShaderResourceBinding::FragmentStage, tex: shaderPipeline->depthTexture(), sampler); |
595 | if (depthTextureArrayBinding >= 0) |
596 | bindings.addTexture(binding: depthTextureBinding, stage: QRhiShaderResourceBinding::FragmentStage, tex: shaderPipeline->depthTexture(), sampler); |
597 | } // else ignore, not an error |
598 | } |
599 | |
600 | // SSAO texture |
601 | if (shaderPipeline->ssaoTexture()) { |
602 | const int ssaoTextureBinding = shaderPipeline->bindingForTexture(name: "qt_aoTexture", hint: int(QSSGRhiSamplerBindingHints::AoTexture)); |
603 | const int ssaoTextureArrayBinding = shaderPipeline->bindingForTexture(name: "qt_aoTextureArray", hint: int(QSSGRhiSamplerBindingHints::AoTextureArray)); |
604 | if (ssaoTextureBinding >= 0 || ssaoTextureArrayBinding >= 0) { |
605 | // linear min/mag, no mipmap |
606 | QRhiSampler *sampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Linear, .magFilter: QRhiSampler::Linear, .mipmap: QRhiSampler::None, |
607 | .hTiling: QRhiSampler::ClampToEdge, .vTiling: QRhiSampler::ClampToEdge, .zTiling: QRhiSampler::Repeat }); |
608 | if (ssaoTextureBinding >= 0) { |
609 | bindings.addTexture(binding: ssaoTextureBinding, |
610 | stage: QRhiShaderResourceBinding::FragmentStage, |
611 | tex: shaderPipeline->ssaoTexture(), sampler); |
612 | } |
613 | if (ssaoTextureArrayBinding >= 0) { |
614 | bindings.addTexture(binding: ssaoTextureArrayBinding, |
615 | stage: QRhiShaderResourceBinding::FragmentStage, |
616 | tex: shaderPipeline->ssaoTexture(), sampler); |
617 | } |
618 | } // else ignore, not an error |
619 | } |
620 | } |
621 | |
622 | static void rhiPrepareResourcesForShadowMap(QSSGRhiContext *rhiCtx, |
623 | const QSSGLayerRenderData &inData, |
624 | QSSGPassKey passKey, |
625 | QSSGShadowMapEntry *pEntry, |
626 | QSSGRhiGraphicsPipelineState *ps, |
627 | const QVector2D *depthAdjust, |
628 | const QSSGRenderableObjectList &sortedOpaqueObjects, |
629 | QSSGRenderCamera &inCamera, |
630 | bool orthographic, |
631 | QSSGRenderTextureCubeFace cubeFace, |
632 | quint32 cascadeIndex) |
633 | { |
634 | QSSGShaderFeatures featureSet; |
635 | if (orthographic) |
636 | featureSet.set(feature: QSSGShaderFeatures::Feature::OrthoShadowPass, val: true); |
637 | else |
638 | featureSet.set(feature: QSSGShaderFeatures::Feature::PerspectiveShadowPass, val: true); |
639 | |
640 | // Do note how updateUniformsForDefaultMaterial() get a single camera and a |
641 | // custom mvp; make sure multiview is disabled in the shader generator using |
642 | // the common flag, instead of it having to write logic for checking for |
643 | // OrthoShadowPoss || CubeShadowPass. |
644 | featureSet.set(feature: QSSGShaderFeatures::Feature::DisableMultiView, val: true); |
645 | |
646 | const auto cubeFaceIdx = QSSGBaseTypeHelpers::indexOfCubeFace(face: cubeFace); |
647 | const auto &defaultMaterialShaderKeyProperties = inData.getDefaultMaterialPropertyTable(); |
648 | QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(q: rhiCtx); |
649 | |
650 | for (const auto &handle : sortedOpaqueObjects) { |
651 | QSSGRenderableObject *theObject = handle.obj; |
652 | QSSG_ASSERT(theObject->renderableFlags.castsShadows(), continue); |
653 | |
654 | QSSGShaderFeatures objectFeatureSet = featureSet; |
655 | const bool isOpaqueDepthPrePass = theObject->depthWriteMode == QSSGDepthDrawMode::OpaquePrePass; |
656 | if (isOpaqueDepthPrePass) |
657 | objectFeatureSet.set(feature: QSSGShaderFeatures::Feature::OpaqueDepthPrePass, val: true); |
658 | |
659 | QSSGRhiDrawCallData *dcd = nullptr; |
660 | QMatrix4x4 modelViewProjection; |
661 | QSSGSubsetRenderable &renderable(static_cast<QSSGSubsetRenderable &>(*theObject)); |
662 | if (theObject->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || theObject->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) { |
663 | const bool hasSkinning = defaultMaterialShaderKeyProperties.m_boneCount.getValue(inDataStore: renderable.shaderDescription) > 0; |
664 | modelViewProjection = hasSkinning ? pEntry->m_lightViewProjection[cascadeIndex] |
665 | : pEntry->m_lightViewProjection[cascadeIndex] * renderable.globalTransform; |
666 | // cascadeIndex is 0..3 for directional light and 0 for the pointlight & spotlight |
667 | // cubeFaceIdx is 0 for directional & spotlight and 0..5 for the pointlight |
668 | // pEntry is unique per light and a light can only be one of directional, point, or spotlight. |
669 | const quintptr entryIdx = cascadeIndex + cubeFaceIdx + (quintptr(renderable.subset.offset) << 3); |
670 | dcd = &rhiCtxD->drawCallData(key: { .cid: passKey, .model: &renderable.modelContext.model, .entry: pEntry, .entryIdx: entryIdx }); |
671 | } |
672 | |
673 | QSSGRhiShaderResourceBindingList bindings; |
674 | QSSGRhiShaderPipelinePtr shaderPipeline; |
675 | QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(*theObject)); |
676 | if (theObject->type == QSSGSubsetRenderable::Type::DefaultMaterialMeshSubset) { |
677 | const auto &material = static_cast<const QSSGRenderDefaultMaterial &>(subsetRenderable.getMaterial()); |
678 | ps->cullMode = QSSGRhiHelpers::toCullMode(cullFaceMode: material.cullMode); |
679 | const bool blendParticles = defaultMaterialShaderKeyProperties.m_blendParticles.getValue(inDataStore: subsetRenderable.shaderDescription); |
680 | |
681 | shaderPipeline = shadersForDefaultMaterial(ps, subsetRenderable, featureSet: objectFeatureSet); |
682 | if (!shaderPipeline) |
683 | continue; |
684 | shaderPipeline->ensureCombinedUniformBuffer(ubuf: &dcd->ubuf); |
685 | char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame(); |
686 | // calls updateUni with an alteredCamera and alteredModelViewProjection |
687 | QSSGRenderCameraList cameras({ &inCamera }); |
688 | updateUniformsForDefaultMaterial(shaderPipeline&: *shaderPipeline, rhiCtx, inData, ubufData, ps, subsetRenderable, cameras, depthAdjust, alteredModelViewProjection: &modelViewProjection); |
689 | if (blendParticles) |
690 | QSSGParticleRenderer::updateUniformsForParticleModel(shaderPipeline&: *shaderPipeline, ubufData, model: &subsetRenderable.modelContext.model, offset: subsetRenderable.subset.offset); |
691 | dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame(); |
692 | if (blendParticles) |
693 | QSSGParticleRenderer::prepareParticlesForModel(shaderPipeline&: *shaderPipeline, rhiCtx, bindings, model: &subsetRenderable.modelContext.model); |
694 | } else if (theObject->type == QSSGSubsetRenderable::Type::CustomMaterialMeshSubset) { |
695 | const auto &material = static_cast<const QSSGRenderCustomMaterial &>(subsetRenderable.getMaterial()); |
696 | ps->cullMode = QSSGRhiHelpers::toCullMode(cullFaceMode: material.m_cullMode); |
697 | |
698 | QSSGCustomMaterialSystem &customMaterialSystem(*subsetRenderable.renderer->contextInterface()->customMaterialSystem().get()); |
699 | shaderPipeline = customMaterialSystem.shadersForCustomMaterial(ps, material, renderable&: subsetRenderable, defaultMaterialShaderKeyProperties: inData.getDefaultMaterialPropertyTable(), featureSet: objectFeatureSet); |
700 | if (!shaderPipeline) |
701 | continue; |
702 | shaderPipeline->ensureCombinedUniformBuffer(ubuf: &dcd->ubuf); |
703 | char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame(); |
704 | // inCamera is the shadow camera, not the same as inData.renderedCameras |
705 | QSSGRenderCameraList cameras({ &inCamera }); |
706 | customMaterialSystem.updateUniformsForCustomMaterial(shaderPipeline&: *shaderPipeline, rhiCtx, inData, ubufData, ps, material, renderable&: subsetRenderable, |
707 | cameras, depthAdjust, alteredModelViewProjection: &modelViewProjection); |
708 | dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame(); |
709 | } |
710 | |
711 | if (theObject->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || theObject->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) { |
712 | |
713 | QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps&: *ps, pipeline: shaderPipeline.get()); |
714 | auto &ia = QSSGRhiInputAssemblerStatePrivate::get(ps&: *ps); |
715 | ia = subsetRenderable.subset.rhi.ia; |
716 | const QSSGRenderCameraDataList &cameraDatas(*inData.renderedCameraData); |
717 | int instanceBufferBinding = setupInstancing(renderable: &subsetRenderable, ps, rhiCtx, cameraDirection: cameraDatas[0].direction, cameraPosition: cameraDatas[0].position); |
718 | QSSGRhiHelpers::bakeVertexInputLocations(ia: &ia, shaders: *shaderPipeline, instanceBufferBinding); |
719 | |
720 | |
721 | bindings.addUniformBuffer(binding: 0, stage: RENDERER_VISIBILITY_ALL, buf: dcd->ubuf); |
722 | |
723 | // Depth and SSAO textures, in case a custom material's shader code does something with them. |
724 | addDepthTextureBindings(rhiCtx, shaderPipeline: shaderPipeline.get(), bindings); |
725 | |
726 | if (isOpaqueDepthPrePass) { |
727 | addOpaqueDepthPrePassBindings(rhiCtx, |
728 | shaderPipeline: shaderPipeline.get(), |
729 | renderableImage: subsetRenderable.firstImage, |
730 | bindings, |
731 | isCustomMaterialMeshSubset: (theObject->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset)); |
732 | } |
733 | |
734 | // There is no screen texture at this stage. But the shader from a |
735 | // custom material may rely on it, and an object with that material |
736 | // can end up in the shadow map's object list. So bind a dummy |
737 | // texture then due to the lack of other options. |
738 | const int screenTextureBinding = shaderPipeline->bindingForTexture(name: "qt_screenTexture", hint: int(QSSGRhiSamplerBindingHints::ScreenTexture)); |
739 | const int screenTextureArrayBinding = shaderPipeline->bindingForTexture(name: "qt_screenTextureArray", hint: int(QSSGRhiSamplerBindingHints::ScreenTextureArray)); |
740 | if (screenTextureBinding >= 0 || screenTextureArrayBinding >= 0) { |
741 | QRhiSampler *sampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Nearest, .magFilter: QRhiSampler::Nearest, .mipmap: QRhiSampler::None, |
742 | .hTiling: QRhiSampler::Repeat, .vTiling: QRhiSampler::Repeat, .zTiling: QRhiSampler::Repeat }); |
743 | if (screenTextureBinding >= 0) { |
744 | QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch(); |
745 | QRhiTexture *dummyTexture = rhiCtx->dummyTexture(flags: {}, rub: resourceUpdates); |
746 | rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates); |
747 | bindings.addTexture(binding: screenTextureBinding, |
748 | stage: QRhiShaderResourceBinding::FragmentStage, |
749 | tex: dummyTexture, sampler); |
750 | } |
751 | if (screenTextureArrayBinding >= 0) { |
752 | QRhiResourceUpdateBatch *resourceUpdates = rhiCtx->rhi()->nextResourceUpdateBatch(); |
753 | QRhiTexture *dummyTexture = rhiCtx->dummyTexture(flags: {}, rub: resourceUpdates, size: QSize(64, 64), fillColor: Qt::black, arraySize: inData.layer.viewCount); |
754 | rhiCtx->commandBuffer()->resourceUpdate(resourceUpdates); |
755 | bindings.addTexture(binding: screenTextureArrayBinding, |
756 | stage: QRhiShaderResourceBinding::FragmentStage, |
757 | tex: dummyTexture, sampler); |
758 | } |
759 | } |
760 | |
761 | // Skinning |
762 | if (QRhiTexture *boneTexture = inData.getBonemapTexture(modelContext: subsetRenderable.modelContext)) { |
763 | int binding = shaderPipeline->bindingForTexture(name: "qt_boneTexture"); |
764 | if (binding >= 0) { |
765 | QRhiSampler *boneSampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Nearest, |
766 | .magFilter: QRhiSampler::Nearest, |
767 | .mipmap: QRhiSampler::None, |
768 | .hTiling: QRhiSampler::ClampToEdge, |
769 | .vTiling: QRhiSampler::ClampToEdge, |
770 | .zTiling: QRhiSampler::Repeat |
771 | }); |
772 | bindings.addTexture(binding, |
773 | stage: QRhiShaderResourceBinding::VertexStage, |
774 | tex: boneTexture, |
775 | sampler: boneSampler); |
776 | } |
777 | } |
778 | |
779 | // Morphing |
780 | auto *targetsTexture = subsetRenderable.subset.rhi.targetsTexture; |
781 | if (targetsTexture) { |
782 | int binding = shaderPipeline->bindingForTexture(name: "qt_morphTargetTexture"); |
783 | if (binding >= 0) { |
784 | QRhiSampler *targetsSampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Nearest, |
785 | .magFilter: QRhiSampler::Nearest, |
786 | .mipmap: QRhiSampler::None, |
787 | .hTiling: QRhiSampler::ClampToEdge, |
788 | .vTiling: QRhiSampler::ClampToEdge, |
789 | .zTiling: QRhiSampler::ClampToEdge |
790 | }); |
791 | bindings.addTexture(binding, stage: QRhiShaderResourceBinding::VertexStage, tex: subsetRenderable.subset.rhi.targetsTexture, sampler: targetsSampler); |
792 | } |
793 | } |
794 | |
795 | QRhiShaderResourceBindings *srb = rhiCtxD->srb(bindings); |
796 | subsetRenderable.rhiRenderData.shadowPass.pipeline = rhiCtxD->pipeline(ps: *ps, rpDesc: pEntry->m_rhiRenderPassDesc[cascadeIndex], srb); |
797 | subsetRenderable.rhiRenderData.shadowPass.srb[cubeFaceIdx] = srb; |
798 | } |
799 | } |
800 | } |
801 | |
802 | static void fillTargetBlend(QRhiGraphicsPipeline::TargetBlend *targetBlend, QSSGRenderDefaultMaterial::MaterialBlendMode materialBlend) |
803 | { |
804 | // Assuming default values in the other TargetBlend fields |
805 | switch (materialBlend) { |
806 | case QSSGRenderDefaultMaterial::MaterialBlendMode::Screen: |
807 | targetBlend->srcColor = QRhiGraphicsPipeline::SrcAlpha; |
808 | targetBlend->dstColor = QRhiGraphicsPipeline::One; |
809 | targetBlend->srcAlpha = QRhiGraphicsPipeline::One; |
810 | targetBlend->dstAlpha = QRhiGraphicsPipeline::One; |
811 | break; |
812 | case QSSGRenderDefaultMaterial::MaterialBlendMode::Multiply: |
813 | targetBlend->srcColor = QRhiGraphicsPipeline::DstColor; |
814 | targetBlend->dstColor = QRhiGraphicsPipeline::Zero; |
815 | targetBlend->srcAlpha = QRhiGraphicsPipeline::One; |
816 | targetBlend->dstAlpha = QRhiGraphicsPipeline::One; |
817 | break; |
818 | default: |
819 | // Use SourceOver for everything else |
820 | targetBlend->srcColor = QRhiGraphicsPipeline::SrcAlpha; |
821 | targetBlend->dstColor = QRhiGraphicsPipeline::OneMinusSrcAlpha; |
822 | targetBlend->srcAlpha = QRhiGraphicsPipeline::One; |
823 | targetBlend->dstAlpha = QRhiGraphicsPipeline::OneMinusSrcAlpha; |
824 | break; |
825 | } |
826 | } |
827 | |
828 | void RenderHelpers::rhiPrepareRenderable(QSSGRhiContext *rhiCtx, |
829 | QSSGPassKey passKey, |
830 | const QSSGLayerRenderData &inData, |
831 | QSSGRenderableObject &inObject, |
832 | QRhiRenderPassDescriptor *renderPassDescriptor, |
833 | QSSGRhiGraphicsPipelineState *ps, |
834 | QSSGShaderFeatures featureSet, |
835 | int samples, |
836 | int viewCount, |
837 | QSSGRenderCamera *alteredCamera, |
838 | QMatrix4x4 *alteredModelViewProjection, |
839 | QSSGRenderTextureCubeFace cubeFace, |
840 | QSSGReflectionMapEntry *entry) |
841 | { |
842 | const auto &defaultMaterialShaderKeyProperties = inData.getDefaultMaterialPropertyTable(); |
843 | |
844 | switch (inObject.type) { |
845 | case QSSGRenderableObject::Type::DefaultMaterialMeshSubset: |
846 | { |
847 | QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(inObject)); |
848 | |
849 | if ((cubeFace == QSSGRenderTextureCubeFaceNone) && subsetRenderable.reflectionProbeIndex >= 0 && subsetRenderable.renderableFlags.testFlag(flag: QSSGRenderableObjectFlag::ReceivesReflections)) |
850 | featureSet.set(feature: QSSGShaderFeatures::Feature::ReflectionProbe, val: true); |
851 | |
852 | if ((cubeFace != QSSGRenderTextureCubeFaceNone)) { |
853 | // Disable tonemapping for the reflection pass |
854 | featureSet.disableTonemapping(); |
855 | } |
856 | |
857 | if (subsetRenderable.renderableFlags.rendersWithLightmap()) |
858 | featureSet.set(feature: QSSGShaderFeatures::Feature::Lightmap, val: true); |
859 | |
860 | const auto &shaderPipeline = shadersForDefaultMaterial(ps, subsetRenderable, featureSet); |
861 | if (shaderPipeline) { |
862 | // Unlike the subsetRenderable (which is allocated per frame so is |
863 | // not persistent in any way), the model reference is persistent in |
864 | // the sense that it references the model node in the scene graph. |
865 | // Combined with the layer node (multiple View3Ds may share the |
866 | // same scene!), this is suitable as a key to get the uniform |
867 | // buffers that were used with the rendering of the same model in |
868 | // the previous frame. |
869 | QSSGRhiShaderResourceBindingList bindings; |
870 | const auto &modelNode = subsetRenderable.modelContext.model; |
871 | const bool blendParticles = defaultMaterialShaderKeyProperties.m_blendParticles.getValue(inDataStore: subsetRenderable.shaderDescription); |
872 | |
873 | |
874 | // NOTE: |
875 | // - entryIdx should 0 for QSSGRenderTextureCubeFaceNone. |
876 | // In all other cases the entryIdx is a combination of the cubeface idx and the subset offset, where the lower bits |
877 | // are the cubeface idx. |
878 | const auto cubeFaceIdx = QSSGBaseTypeHelpers::indexOfCubeFace(face: cubeFace); |
879 | const quintptr entryIdx = quintptr(cubeFace != QSSGRenderTextureCubeFaceNone) * (cubeFaceIdx + (quintptr(subsetRenderable.subset.offset) << 3)); |
880 | // If there's an entry we merge that with the address of the material |
881 | const auto entryPartA = reinterpret_cast<quintptr>(&subsetRenderable.material); |
882 | const auto entryPartB = reinterpret_cast<quintptr>(entry); |
883 | const void *entryId = reinterpret_cast<const void *>(entryPartA ^ entryPartB); |
884 | |
885 | QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(q: rhiCtx); |
886 | QSSGRhiDrawCallData &dcd = rhiCtxD->drawCallData(key: { .cid: passKey, .model: &modelNode, .entry: entryId, .entryIdx: entryIdx }); |
887 | |
888 | shaderPipeline->ensureCombinedUniformBuffer(ubuf: &dcd.ubuf); |
889 | char *ubufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame(); |
890 | if (alteredCamera) { |
891 | Q_ASSERT(alteredModelViewProjection); |
892 | QSSGRenderCameraList cameras({ alteredCamera }); |
893 | updateUniformsForDefaultMaterial(shaderPipeline&: *shaderPipeline, rhiCtx, inData, ubufData, ps, subsetRenderable, cameras, depthAdjust: nullptr, alteredModelViewProjection); |
894 | } else { |
895 | Q_ASSERT(!alteredModelViewProjection); |
896 | updateUniformsForDefaultMaterial(shaderPipeline&: *shaderPipeline, rhiCtx, inData, ubufData, ps, subsetRenderable, cameras: inData.renderedCameras, depthAdjust: nullptr, alteredModelViewProjection: nullptr); |
897 | } |
898 | |
899 | if (blendParticles) |
900 | QSSGParticleRenderer::updateUniformsForParticleModel(shaderPipeline&: *shaderPipeline, ubufData, model: &subsetRenderable.modelContext.model, offset: subsetRenderable.subset.offset); |
901 | dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame(); |
902 | |
903 | if (blendParticles) |
904 | QSSGParticleRenderer::prepareParticlesForModel(shaderPipeline&: *shaderPipeline, rhiCtx, bindings, model: &subsetRenderable.modelContext.model); |
905 | |
906 | // Skinning |
907 | if (QRhiTexture *boneTexture = inData.getBonemapTexture(modelContext: subsetRenderable.modelContext)) { |
908 | int binding = shaderPipeline->bindingForTexture(name: "qt_boneTexture"); |
909 | if (binding >= 0) { |
910 | QRhiSampler *boneSampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Nearest, |
911 | .magFilter: QRhiSampler::Nearest, |
912 | .mipmap: QRhiSampler::None, |
913 | .hTiling: QRhiSampler::ClampToEdge, |
914 | .vTiling: QRhiSampler::ClampToEdge, |
915 | .zTiling: QRhiSampler::Repeat |
916 | }); |
917 | bindings.addTexture(binding, |
918 | stage: QRhiShaderResourceBinding::VertexStage, |
919 | tex: boneTexture, |
920 | sampler: boneSampler); |
921 | } |
922 | } |
923 | // Morphing |
924 | auto *targetsTexture = subsetRenderable.subset.rhi.targetsTexture; |
925 | if (targetsTexture) { |
926 | int binding = shaderPipeline->bindingForTexture(name: "qt_morphTargetTexture"); |
927 | if (binding >= 0) { |
928 | QRhiSampler *targetsSampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Nearest, |
929 | .magFilter: QRhiSampler::Nearest, |
930 | .mipmap: QRhiSampler::None, |
931 | .hTiling: QRhiSampler::ClampToEdge, |
932 | .vTiling: QRhiSampler::ClampToEdge, |
933 | .zTiling: QRhiSampler::ClampToEdge |
934 | }); |
935 | bindings.addTexture(binding, stage: QRhiShaderResourceBinding::VertexStage, tex: subsetRenderable.subset.rhi.targetsTexture, sampler: targetsSampler); |
936 | } |
937 | } |
938 | |
939 | ps->samples = samples; |
940 | ps->viewCount = viewCount; |
941 | |
942 | const auto &material = static_cast<const QSSGRenderDefaultMaterial &>(subsetRenderable.getMaterial()); |
943 | ps->cullMode = QSSGRhiHelpers::toCullMode(cullFaceMode: material.cullMode); |
944 | fillTargetBlend(targetBlend: &ps->targetBlend, materialBlend: material.blendMode); |
945 | |
946 | auto &ia = QSSGRhiInputAssemblerStatePrivate::get(ps&: *ps); |
947 | |
948 | ia = subsetRenderable.subset.rhi.ia; |
949 | const QSSGRenderCameraDataList &cameraDatas(*inData.renderedCameraData); |
950 | QVector3D cameraDirection = cameraDatas[0].direction; |
951 | if (alteredCamera) |
952 | cameraDirection = alteredCamera->getScalingCorrectDirection(); |
953 | QVector3D cameraPosition = cameraDatas[0].position; |
954 | if (alteredCamera) |
955 | cameraPosition = alteredCamera->getGlobalPos(); |
956 | int instanceBufferBinding = setupInstancing(renderable: &subsetRenderable, ps, rhiCtx, cameraDirection, cameraPosition); |
957 | QSSGRhiHelpers::bakeVertexInputLocations(ia: &ia, shaders: *shaderPipeline, instanceBufferBinding); |
958 | |
959 | bindings.addUniformBuffer(binding: 0, stage: RENDERER_VISIBILITY_ALL, buf: dcd.ubuf, offset: 0, size: shaderPipeline->ub0Size()); |
960 | |
961 | if (shaderPipeline->isLightingEnabled()) { |
962 | bindings.addUniformBuffer(binding: 1, stage: RENDERER_VISIBILITY_ALL, buf: dcd.ubuf, |
963 | offset: shaderPipeline->ub0LightDataOffset(), |
964 | size: shaderPipeline->ub0LightDataSize()); |
965 | |
966 | if (shaderPipeline->shadowMapCount() > 0) { |
967 | bindings.addUniformBuffer(binding: 2, stage: RENDERER_VISIBILITY_ALL, buf: dcd.ubuf, |
968 | offset: shaderPipeline->ub0ShadowDataOffset(), |
969 | size: shaderPipeline->ub0ShadowDataSize()); |
970 | } |
971 | } |
972 | |
973 | // Texture maps |
974 | QSSGRenderableImage *renderableImage = subsetRenderable.firstImage; |
975 | while (renderableImage) { |
976 | const char *samplerName = QSSGMaterialShaderGenerator::getSamplerName(type: renderableImage->m_mapType); |
977 | const int samplerHint = int(renderableImage->m_mapType); |
978 | int samplerBinding = shaderPipeline->bindingForTexture(name: samplerName, hint: samplerHint); |
979 | if (samplerBinding >= 0) { |
980 | QRhiTexture *texture = renderableImage->m_texture.m_texture; |
981 | if (samplerBinding >= 0 && texture) { |
982 | const bool mipmapped = texture->flags().testFlag(flag: QRhiTexture::MipMapped); |
983 | QSSGRhiSamplerDescription samplerDesc = { |
984 | .minFilter: QSSGRhiHelpers::toRhi(op: renderableImage->m_imageNode.m_minFilterType), |
985 | .magFilter: QSSGRhiHelpers::toRhi(op: renderableImage->m_imageNode.m_magFilterType), |
986 | .mipmap: mipmapped ? QSSGRhiHelpers::toRhi(op: renderableImage->m_imageNode.m_mipFilterType) : QRhiSampler::None, |
987 | .hTiling: QSSGRhiHelpers::toRhi(tiling: renderableImage->m_imageNode.m_horizontalTilingMode), |
988 | .vTiling: QSSGRhiHelpers::toRhi(tiling: renderableImage->m_imageNode.m_verticalTilingMode), |
989 | .zTiling: QSSGRhiHelpers::toRhi(tiling: renderableImage->m_imageNode.m_depthTilingMode) |
990 | }; |
991 | rhiCtx->checkAndAdjustForNPoT(texture, samplerDescription: &samplerDesc); |
992 | QRhiSampler *sampler = rhiCtx->sampler(samplerDescription: samplerDesc); |
993 | bindings.addTexture(binding: samplerBinding, stage: RENDERER_VISIBILITY_ALL, tex: texture, sampler); |
994 | } |
995 | } // else this is not necessarily an error, e.g. having metalness/roughness maps with metalness disabled |
996 | renderableImage = renderableImage->m_nextImage; |
997 | } |
998 | |
999 | if (shaderPipeline->isLightingEnabled()) { |
1000 | // Shadow map textures |
1001 | const int shadowMapCount = shaderPipeline->shadowMapCount(); |
1002 | QVarLengthArray<QSize, 4> usedTextureArraySizes; |
1003 | for (int i = 0; i < shadowMapCount; ++i) { |
1004 | QSSGRhiShadowMapProperties &shadowMapProperties(shaderPipeline->shadowMapAt(index: i)); |
1005 | const QByteArray &name(shadowMapProperties.shadowMapTextureUniformName); |
1006 | if (shadowMapProperties.cachedBinding < 0) |
1007 | shadowMapProperties.cachedBinding = shaderPipeline->bindingForTexture(name); |
1008 | if (shadowMapProperties.cachedBinding < 0) { |
1009 | qWarning(msg: "No combined image sampler for shadow map texture '%s'", name.data()); |
1010 | continue; |
1011 | } |
1012 | |
1013 | // Re-use same texture array if already created |
1014 | if (shadowMapProperties.shadowMapTexture->flags() & QRhiTexture::TextureArray) { |
1015 | if (usedTextureArraySizes.contains(t: shadowMapProperties.shadowMapTexture->pixelSize())) |
1016 | continue; |
1017 | usedTextureArraySizes.append(t: shadowMapProperties.shadowMapTexture->pixelSize()); |
1018 | } |
1019 | |
1020 | QRhiTexture *texture = shadowMapProperties.shadowMapTexture; |
1021 | QRhiSampler *sampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Linear, .magFilter: QRhiSampler::Linear, .mipmap: QRhiSampler::None, |
1022 | .hTiling: QRhiSampler::ClampToEdge, .vTiling: QRhiSampler::ClampToEdge, .zTiling: QRhiSampler::Repeat }); |
1023 | Q_ASSERT(texture && sampler); |
1024 | bindings.addTexture(binding: shadowMapProperties.cachedBinding, stage: QRhiShaderResourceBinding::FragmentStage, |
1025 | tex: texture, sampler); |
1026 | } |
1027 | |
1028 | // Prioritize reflection texture over Light Probe texture because |
1029 | // reflection texture also contains the irradiance and pre filtered |
1030 | // values for the light probe. |
1031 | if (featureSet.isSet(feature: QSSGShaderFeatures::Feature::ReflectionProbe)) { |
1032 | int reflectionSampler = shaderPipeline->bindingForTexture(name: "qt_reflectionMap"); |
1033 | QRhiSampler *sampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Linear, .magFilter: QRhiSampler::Linear, .mipmap: QRhiSampler::Linear, |
1034 | .hTiling: QRhiSampler::ClampToEdge, .vTiling: QRhiSampler::ClampToEdge, .zTiling: QRhiSampler::Repeat }); |
1035 | QRhiTexture* reflectionTexture = inData.getReflectionMapManager()->reflectionMapEntry(probeIdx: subsetRenderable.reflectionProbeIndex)->m_rhiPrefilteredCube; |
1036 | if (reflectionSampler >= 0 && reflectionTexture) |
1037 | bindings.addTexture(binding: reflectionSampler, stage: QRhiShaderResourceBinding::FragmentStage, tex: reflectionTexture, sampler); |
1038 | } else if (shaderPipeline->lightProbeTexture()) { |
1039 | int binding = shaderPipeline->bindingForTexture(name: "qt_lightProbe", hint: int(QSSGRhiSamplerBindingHints::LightProbe)); |
1040 | if (binding >= 0) { |
1041 | auto tiling = shaderPipeline->lightProbeTiling(); |
1042 | QRhiSampler *sampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Linear, .magFilter: QRhiSampler::Linear, .mipmap: QRhiSampler::Linear, // enables mipmapping |
1043 | .hTiling: QSSGRhiHelpers::toRhi(tiling: tiling.first), .vTiling: QSSGRhiHelpers::toRhi(tiling: tiling.second), .zTiling: QRhiSampler::Repeat }); |
1044 | bindings.addTexture(binding, stage: QRhiShaderResourceBinding::FragmentStage, |
1045 | tex: shaderPipeline->lightProbeTexture(), sampler); |
1046 | } else { |
1047 | qWarning(msg: "Could not find sampler for lightprobe"); |
1048 | } |
1049 | } |
1050 | |
1051 | // Screen Texture |
1052 | if (shaderPipeline->screenTexture()) { |
1053 | const int screenTextureBinding = shaderPipeline->bindingForTexture(name: "qt_screenTexture", hint: int(QSSGRhiSamplerBindingHints::ScreenTexture)); |
1054 | const int screenTextureArrayBinding = shaderPipeline->bindingForTexture(name: "qt_screenTextureArray", hint: int(QSSGRhiSamplerBindingHints::ScreenTextureArray)); |
1055 | if (screenTextureBinding >= 0 || screenTextureArrayBinding >= 0) { |
1056 | // linear min/mag, mipmap filtering depends on the |
1057 | // texture, with SCREEN_TEXTURE there are no mipmaps, but |
1058 | // once SCREEN_MIP_TEXTURE is seen the texture (the same |
1059 | // one) has mipmaps generated. |
1060 | QRhiSampler::Filter mipFilter = shaderPipeline->screenTexture()->flags().testFlag(flag: QRhiTexture::MipMapped) |
1061 | ? QRhiSampler::Linear : QRhiSampler::None; |
1062 | QRhiSampler *sampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Linear, .magFilter: QRhiSampler::Linear, .mipmap: mipFilter, |
1063 | .hTiling: QRhiSampler::Repeat, .vTiling: QRhiSampler::Repeat, .zTiling: QRhiSampler::Repeat }); |
1064 | if (screenTextureBinding >= 0) { |
1065 | bindings.addTexture(binding: screenTextureBinding, |
1066 | stage: QRhiShaderResourceBinding::FragmentStage, |
1067 | tex: shaderPipeline->screenTexture(), sampler); |
1068 | } |
1069 | if (screenTextureArrayBinding >= 0) { |
1070 | bindings.addTexture(binding: screenTextureArrayBinding, |
1071 | stage: QRhiShaderResourceBinding::FragmentStage, |
1072 | tex: shaderPipeline->screenTexture(), sampler); |
1073 | } |
1074 | } // else ignore, not an error |
1075 | } |
1076 | |
1077 | if (shaderPipeline->lightmapTexture()) { |
1078 | int binding = shaderPipeline->bindingForTexture(name: "qt_lightmap", hint: int(QSSGRhiSamplerBindingHints::LightmapTexture)); |
1079 | if (binding >= 0) { |
1080 | QRhiSampler *sampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Linear, .magFilter: QRhiSampler::Linear, .mipmap: QRhiSampler::None, |
1081 | .hTiling: QRhiSampler::ClampToEdge, .vTiling: QRhiSampler::ClampToEdge, .zTiling: QRhiSampler::Repeat }); |
1082 | bindings.addTexture(binding, |
1083 | stage: QRhiShaderResourceBinding::FragmentStage, |
1084 | tex: shaderPipeline->lightmapTexture(), sampler); |
1085 | } // else ignore, not an error |
1086 | } |
1087 | } |
1088 | |
1089 | // Depth and SSAO textures |
1090 | addDepthTextureBindings(rhiCtx, shaderPipeline: shaderPipeline.get(), bindings); |
1091 | |
1092 | // Instead of always doing a QHash find in srb(), store the binding |
1093 | // list and the srb object in the per-model+material |
1094 | // QSSGRhiUniformBufferSet. While this still needs comparing the |
1095 | // binding list, to see if something has changed, it results in |
1096 | // significant gains with lots of models in the scene (because the |
1097 | // srb hash table becomes large then, so avoiding the lookup as |
1098 | // much as possible is helpful) |
1099 | QRhiShaderResourceBindings *&srb = dcd.srb; |
1100 | bool srbChanged = false; |
1101 | if (!srb || bindings != dcd.bindings) { |
1102 | srb = rhiCtxD->srb(bindings); |
1103 | rhiCtxD->releaseCachedSrb(bindings&: dcd.bindings); |
1104 | dcd.bindings = bindings; |
1105 | srbChanged = true; |
1106 | } |
1107 | |
1108 | if (cubeFace != QSSGRenderTextureCubeFaceNone) |
1109 | subsetRenderable.rhiRenderData.reflectionPass.srb[cubeFaceIdx] = srb; |
1110 | else |
1111 | subsetRenderable.rhiRenderData.mainPass.srb = srb; |
1112 | |
1113 | const auto pipelineKey = QSSGGraphicsPipelineStateKey::create(state: *ps, rpDesc: renderPassDescriptor, srb); |
1114 | if (dcd.pipeline |
1115 | && !srbChanged |
1116 | && dcd.renderTargetDescriptionHash == pipelineKey.extra.renderTargetDescriptionHash // we have the hash code anyway, use it to early out upon mismatch |
1117 | && dcd.renderTargetDescription == pipelineKey.renderTargetDescription |
1118 | && dcd.ps == *ps) |
1119 | { |
1120 | if (cubeFace != QSSGRenderTextureCubeFaceNone) |
1121 | subsetRenderable.rhiRenderData.reflectionPass.pipeline = dcd.pipeline; |
1122 | else |
1123 | subsetRenderable.rhiRenderData.mainPass.pipeline = dcd.pipeline; |
1124 | } else { |
1125 | if (cubeFace != QSSGRenderTextureCubeFaceNone) { |
1126 | subsetRenderable.rhiRenderData.reflectionPass.pipeline = rhiCtxD->pipeline(key: pipelineKey, |
1127 | rpDesc: renderPassDescriptor, |
1128 | srb); |
1129 | dcd.pipeline = subsetRenderable.rhiRenderData.reflectionPass.pipeline; |
1130 | } else { |
1131 | subsetRenderable.rhiRenderData.mainPass.pipeline = rhiCtxD->pipeline(key: pipelineKey, |
1132 | rpDesc: renderPassDescriptor, |
1133 | srb); |
1134 | dcd.pipeline = subsetRenderable.rhiRenderData.mainPass.pipeline; |
1135 | } |
1136 | dcd.renderTargetDescriptionHash = pipelineKey.extra.renderTargetDescriptionHash; |
1137 | dcd.renderTargetDescription = pipelineKey.renderTargetDescription; |
1138 | dcd.ps = *ps; |
1139 | } |
1140 | } |
1141 | break; |
1142 | } |
1143 | case QSSGRenderableObject::Type::CustomMaterialMeshSubset: |
1144 | { |
1145 | QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(inObject)); |
1146 | const QSSGRenderCustomMaterial &material = static_cast<const QSSGRenderCustomMaterial &>(subsetRenderable.getMaterial()); |
1147 | QSSGCustomMaterialSystem &customMaterialSystem(*subsetRenderable.renderer->contextInterface()->customMaterialSystem().get()); |
1148 | |
1149 | featureSet.set(feature: QSSGShaderFeatures::Feature::LightProbe, val: inData.layer.lightProbe || material.m_iblProbe); |
1150 | |
1151 | if ((cubeFace == QSSGRenderTextureCubeFaceNone) && subsetRenderable.reflectionProbeIndex >= 0 && subsetRenderable.renderableFlags.testFlag(flag: QSSGRenderableObjectFlag::ReceivesReflections)) |
1152 | featureSet.set(feature: QSSGShaderFeatures::Feature::ReflectionProbe, val: true); |
1153 | |
1154 | if (cubeFace != QSSGRenderTextureCubeFaceNone) { |
1155 | // Disable tonemapping for the reflection pass |
1156 | featureSet.disableTonemapping(); |
1157 | } |
1158 | |
1159 | if (subsetRenderable.renderableFlags.rendersWithLightmap()) |
1160 | featureSet.set(feature: QSSGShaderFeatures::Feature::Lightmap, val: true); |
1161 | |
1162 | customMaterialSystem.rhiPrepareRenderable(ps, passKey, renderable&: subsetRenderable, featureSet, |
1163 | material, layerData: inData, renderPassDescriptor, samples, viewCount, |
1164 | camera: alteredCamera, cubeFace, modelViewProjection: alteredModelViewProjection, entry); |
1165 | break; |
1166 | } |
1167 | case QSSGRenderableObject::Type::Particles: |
1168 | { |
1169 | QSSGParticlesRenderable &particleRenderable(static_cast<QSSGParticlesRenderable &>(inObject)); |
1170 | const auto &shaderPipeline = shadersForParticleMaterial(ps, particleRenderable); |
1171 | if (shaderPipeline) { |
1172 | QSSGParticleRenderer::rhiPrepareRenderable(shaderPipeline&: *shaderPipeline, passKey, rhiCtx, ps, renderable&: particleRenderable, inData, renderPassDescriptor, samples, viewCount, |
1173 | alteredCamera, cubeFace, entry); |
1174 | } |
1175 | break; |
1176 | } |
1177 | } |
1178 | } |
1179 | |
1180 | void RenderHelpers::rhiRenderRenderable(QSSGRhiContext *rhiCtx, |
1181 | const QSSGRhiGraphicsPipelineState &state, |
1182 | QSSGRenderableObject &object, |
1183 | bool *needsSetViewport, |
1184 | QSSGRenderTextureCubeFace cubeFace) |
1185 | { |
1186 | switch (object.type) { |
1187 | case QSSGRenderableObject::Type::DefaultMaterialMeshSubset: |
1188 | { |
1189 | QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(object)); |
1190 | |
1191 | QRhiGraphicsPipeline *ps = subsetRenderable.rhiRenderData.mainPass.pipeline; |
1192 | QRhiShaderResourceBindings *srb = subsetRenderable.rhiRenderData.mainPass.srb; |
1193 | |
1194 | if (cubeFace != QSSGRenderTextureCubeFaceNone) { |
1195 | const auto cubeFaceIdx = QSSGBaseTypeHelpers::indexOfCubeFace(face: cubeFace); |
1196 | ps = subsetRenderable.rhiRenderData.reflectionPass.pipeline; |
1197 | srb = subsetRenderable.rhiRenderData.reflectionPass.srb[cubeFaceIdx]; |
1198 | } |
1199 | |
1200 | if (!ps || !srb) |
1201 | return; |
1202 | |
1203 | QRhiBuffer *vertexBuffer = subsetRenderable.subset.rhi.vertexBuffer->buffer(); |
1204 | QRhiBuffer *indexBuffer = subsetRenderable.subset.rhi.indexBuffer ? subsetRenderable.subset.rhi.indexBuffer->buffer() : nullptr; |
1205 | |
1206 | QRhiCommandBuffer *cb = rhiCtx->commandBuffer(); |
1207 | // QRhi optimizes out unnecessary binding of the same pipline |
1208 | cb->setGraphicsPipeline(ps); |
1209 | cb->setShaderResources(srb); |
1210 | |
1211 | if (*needsSetViewport) { |
1212 | cb->setViewport(state.viewport); |
1213 | if (state.flags.testFlag(flag: QSSGRhiGraphicsPipelineState::Flag::UsesScissor)) |
1214 | cb->setScissor(state.scissor); |
1215 | *needsSetViewport = false; |
1216 | } |
1217 | |
1218 | QRhiCommandBuffer::VertexInput vertexBuffers[2]; |
1219 | int vertexBufferCount = 1; |
1220 | vertexBuffers[0] = QRhiCommandBuffer::VertexInput(vertexBuffer, 0); |
1221 | quint32 instances = 1; |
1222 | if ( subsetRenderable.modelContext.model.instancing()) { |
1223 | instances = subsetRenderable.modelContext.model.instanceCount(); |
1224 | // If the instance count is 0, the bail out before trying to do any |
1225 | // draw calls. Making an instanced draw call with a count of 0 is invalid |
1226 | // for Metal and likely other API's as well. |
1227 | // It is possible that the particale system may produce 0 instances here |
1228 | if (instances == 0) |
1229 | return; |
1230 | vertexBuffers[1] = QRhiCommandBuffer::VertexInput(subsetRenderable.instanceBuffer, 0); |
1231 | vertexBufferCount = 2; |
1232 | } |
1233 | Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderCall); |
1234 | if (state.flags.testFlag(flag: QSSGRhiGraphicsPipelineState::Flag::UsesStencilRef)) |
1235 | cb->setStencilRef(state.stencilRef); |
1236 | if (indexBuffer) { |
1237 | cb->setVertexInput(startBinding: 0, bindingCount: vertexBufferCount, bindings: vertexBuffers, indexBuf: indexBuffer, indexOffset: 0, indexFormat: subsetRenderable.subset.rhi.indexBuffer->indexFormat()); |
1238 | cb->drawIndexed(indexCount: subsetRenderable.subset.lodCount(lodLevel: subsetRenderable.subsetLevelOfDetail), instanceCount: instances, firstIndex: subsetRenderable.subset.lodOffset(lodLevel: subsetRenderable.subsetLevelOfDetail)); |
1239 | QSSGRHICTX_STAT(rhiCtx, drawIndexed(subsetRenderable.subset.lodCount(subsetRenderable.subsetLevelOfDetail), instances)); |
1240 | } else { |
1241 | cb->setVertexInput(startBinding: 0, bindingCount: vertexBufferCount, bindings: vertexBuffers); |
1242 | cb->draw(vertexCount: subsetRenderable.subset.count, instanceCount: instances, firstVertex: subsetRenderable.subset.offset); |
1243 | QSSGRHICTX_STAT(rhiCtx, draw(subsetRenderable.subset.count, instances)); |
1244 | } |
1245 | Q_QUICK3D_PROFILE_END_WITH_IDS(QQuick3DProfiler::Quick3DRenderCall, (subsetRenderable.subset.count | quint64(instances) << 32), |
1246 | QVector<int>({subsetRenderable.modelContext.model.profilingId, |
1247 | subsetRenderable.material.profilingId})); |
1248 | break; |
1249 | } |
1250 | case QSSGRenderableObject::Type::CustomMaterialMeshSubset: |
1251 | { |
1252 | QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(object)); |
1253 | QSSGCustomMaterialSystem &customMaterialSystem(*subsetRenderable.renderer->contextInterface()->customMaterialSystem().get()); |
1254 | customMaterialSystem.rhiRenderRenderable(rhiCtx, renderable&: subsetRenderable, needsSetViewport, cubeFace, state); |
1255 | break; |
1256 | } |
1257 | case QSSGRenderableObject::Type::Particles: |
1258 | { |
1259 | QSSGParticlesRenderable &renderable(static_cast<QSSGParticlesRenderable &>(object)); |
1260 | QSSGParticleRenderer::rhiRenderRenderable(rhiCtx, renderable, needsSetViewport, cubeFace, state); |
1261 | break; |
1262 | } |
1263 | } |
1264 | } |
1265 | |
1266 | void RenderHelpers::rhiRenderShadowMap(QSSGRhiContext *rhiCtx, |
1267 | QSSGPassKey passKey, |
1268 | QSSGRhiGraphicsPipelineState &ps, |
1269 | QSSGRenderShadowMap &shadowMapManager, |
1270 | const QSSGRenderCamera &camera, |
1271 | QSSGRenderCamera *debugCamera, |
1272 | const QSSGShaderLightList &globalLights, |
1273 | const QSSGRenderableObjectList &sortedOpaqueObjects, |
1274 | QSSGRenderer &renderer, |
1275 | const QSSGBounds3 &castingObjectsBox, |
1276 | const QSSGBounds3 &receivingObjectsBox) |
1277 | { |
1278 | const QSSGLayerRenderData &layerData = *QSSGLayerRenderData::getCurrent(renderer); |
1279 | |
1280 | static const auto rhiRenderOneShadowMap = [](QSSGRhiContext *rhiCtx, |
1281 | QSSGRhiGraphicsPipelineState *ps, |
1282 | const QSSGRenderableObjectList &sortedOpaqueObjects, |
1283 | int cubeFace) { |
1284 | QRhiCommandBuffer *cb = rhiCtx->commandBuffer(); |
1285 | bool needsSetViewport = true; |
1286 | |
1287 | for (const auto &handle : sortedOpaqueObjects) { |
1288 | QSSGRenderableObject *theObject = handle.obj; |
1289 | QSSG_ASSERT(theObject->renderableFlags.castsShadows(), continue); |
1290 | if (theObject->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || theObject->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) { |
1291 | QSSGSubsetRenderable *renderable(static_cast<QSSGSubsetRenderable *>(theObject)); |
1292 | |
1293 | QRhiBuffer *vertexBuffer = renderable->subset.rhi.vertexBuffer->buffer(); |
1294 | QRhiBuffer *indexBuffer = renderable->subset.rhi.indexBuffer |
1295 | ? renderable->subset.rhi.indexBuffer->buffer() |
1296 | : nullptr; |
1297 | |
1298 | // Ideally we shouldn't need to deal with this, as only "valid" objects should be processed at this point. |
1299 | if (!renderable->rhiRenderData.shadowPass.pipeline) |
1300 | continue; |
1301 | |
1302 | Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderCall); |
1303 | |
1304 | cb->setGraphicsPipeline(renderable->rhiRenderData.shadowPass.pipeline); |
1305 | |
1306 | QRhiShaderResourceBindings *srb = renderable->rhiRenderData.shadowPass.srb[cubeFace]; |
1307 | cb->setShaderResources(srb); |
1308 | |
1309 | if (needsSetViewport) { |
1310 | cb->setViewport(ps->viewport); |
1311 | needsSetViewport = false; |
1312 | } |
1313 | |
1314 | QRhiCommandBuffer::VertexInput vertexBuffers[2]; |
1315 | int vertexBufferCount = 1; |
1316 | vertexBuffers[0] = QRhiCommandBuffer::VertexInput(vertexBuffer, 0); |
1317 | quint32 instances = 1; |
1318 | if (renderable->modelContext.model.instancing()) { |
1319 | instances = renderable->modelContext.model.instanceCount(); |
1320 | vertexBuffers[1] = QRhiCommandBuffer::VertexInput(renderable->instanceBuffer, 0); |
1321 | vertexBufferCount = 2; |
1322 | } |
1323 | if (indexBuffer) { |
1324 | cb->setVertexInput(startBinding: 0, bindingCount: vertexBufferCount, bindings: vertexBuffers, indexBuf: indexBuffer, indexOffset: 0, indexFormat: renderable->subset.rhi.indexBuffer->indexFormat()); |
1325 | cb->drawIndexed(indexCount: renderable->subset.count, instanceCount: instances, firstIndex: renderable->subset.offset); |
1326 | QSSGRHICTX_STAT(rhiCtx, drawIndexed(renderable->subset.count, instances)); |
1327 | } else { |
1328 | cb->setVertexInput(startBinding: 0, bindingCount: vertexBufferCount, bindings: vertexBuffers); |
1329 | cb->draw(vertexCount: renderable->subset.count, instanceCount: instances, firstVertex: renderable->subset.offset); |
1330 | QSSGRHICTX_STAT(rhiCtx, draw(renderable->subset.count, instances)); |
1331 | } |
1332 | Q_QUICK3D_PROFILE_END_WITH_IDS(QQuick3DProfiler::Quick3DRenderCall, (renderable->subset.count | quint64(instances) << 32), |
1333 | QVector<int>({renderable->modelContext.model.profilingId, |
1334 | renderable->material.profilingId})); |
1335 | } |
1336 | } |
1337 | }; |
1338 | |
1339 | QRhi *rhi = rhiCtx->rhi(); |
1340 | QRhiCommandBuffer *cb = rhiCtx->commandBuffer(); |
1341 | |
1342 | // We need to deal with a clip depth range of [0, 1] or |
1343 | // [-1, 1], depending on the graphics API underneath. |
1344 | QVector2D depthAdjust; // (d + depthAdjust[0]) * depthAdjust[1] = d mapped to [0, 1] |
1345 | if (rhi->isClipDepthZeroToOne()) { |
1346 | // d is [0, 1] so no need for any mapping |
1347 | depthAdjust[0] = 0.0f; |
1348 | depthAdjust[1] = 1.0f; |
1349 | } else { |
1350 | // d is [-1, 1] |
1351 | depthAdjust[0] = 1.0f; |
1352 | depthAdjust[1] = 0.5f; |
1353 | } |
1354 | |
1355 | QSSGDebugDrawSystem *debugDrawSystem = renderer.contextInterface()->debugDrawSystem().get(); |
1356 | const bool drawDirectionalLightShadowBoxes = layerData.layer.drawDirectionalLightShadowBoxes; |
1357 | const bool drawShadowCastingBounds = layerData.layer.drawShadowCastingBounds; |
1358 | const bool drawShadowReceivingBounds = layerData.layer.drawShadowReceivingBounds; |
1359 | const bool drawCascades = layerData.layer.drawCascades; |
1360 | const bool drawSceneCascadeIntersection = layerData.layer.drawSceneCascadeIntersection; |
1361 | const bool disableShadowCameraUpdate = layerData.layer.disableShadowCameraUpdate; |
1362 | |
1363 | if (drawShadowCastingBounds) |
1364 | ShadowmapHelpers::addDebugBox(boxUnsorted: castingObjectsBox.toQSSGBoxPointsNoEmptyCheck(), color: QColorConstants::Red, debugDrawSystem); |
1365 | if (drawShadowReceivingBounds) |
1366 | ShadowmapHelpers::addDebugBox(boxUnsorted: receivingObjectsBox.toQSSGBoxPointsNoEmptyCheck(), color: QColorConstants::Green, debugDrawSystem); |
1367 | |
1368 | // Create shadow map for each light in the scene |
1369 | for (int i = 0, ie = globalLights.size(); i != ie; ++i) { |
1370 | if (!globalLights[i].shadows || globalLights[i].light->m_fullyBaked) |
1371 | continue; |
1372 | |
1373 | QSSGShadowMapEntry *pEntry = shadowMapManager.shadowMapEntry(lightIdx: i); |
1374 | if (!pEntry) |
1375 | continue; |
1376 | |
1377 | const auto &light = globalLights[i].light; |
1378 | Q_ASSERT(pEntry->m_rhiDepthStencil[0]); |
1379 | if (pEntry->m_rhiDepthTextureArray) { |
1380 | const QSize size = pEntry->m_rhiDepthTextureArray->pixelSize(); |
1381 | ps.viewport = QRhiViewport(0, 0, float(size.width()), float(size.height())); |
1382 | |
1383 | Q_ASSERT(light->type == QSSGRenderLight::Type::DirectionalLight || light->type == QSSGRenderLight::Type::SpotLight); |
1384 | |
1385 | // This is just a way to store the old camera so we can use it for debug |
1386 | // drawing. There are probably cleaner ways to do this |
1387 | if (!disableShadowCameraUpdate && debugCamera) { |
1388 | debugCamera->clipNear = camera.clipNear; |
1389 | debugCamera->clipFar = camera.clipFar; |
1390 | debugCamera->projection = camera.projection; |
1391 | debugCamera->globalTransform = camera.globalTransform; |
1392 | } |
1393 | |
1394 | QVarLengthArray<std::unique_ptr<QSSGRenderCamera>, 4> cascades; |
1395 | if (light->type == QSSGRenderLight::Type::DirectionalLight) { |
1396 | const float pcfRadius = light->m_softShadowQuality == QSSGRenderLight::SoftShadowQuality::Hard ? 0.f : light->m_pcfFactor; |
1397 | const float clipNear = camera.clipNear; |
1398 | const float clipFar = qMin(a: light->m_shadowMapFar, b: camera.clipFar); |
1399 | const float clipRange = clipFar - clipNear; |
1400 | cascades = setupCascadingCamerasForShadowMap(inCamera: disableShadowCameraUpdate ? *debugCamera : camera, |
1401 | inLight: light, |
1402 | shadowMapResolution: size.width(), |
1403 | pcfRadius, |
1404 | clipNear, |
1405 | clipFar, |
1406 | castingObjectsBox, |
1407 | receivingObjectsBox, |
1408 | debugDrawSystem, |
1409 | drawCascades, |
1410 | drawSceneCascadeIntersection); |
1411 | |
1412 | // Write the split distances from value 0 in the z-axis of the eye view-space |
1413 | pEntry->m_csmSplits[0] = clipNear + clipRange * (light->m_csmNumSplits > 0 ? light->m_csmSplit1 : 1.0f); |
1414 | pEntry->m_csmSplits[1] = clipNear + clipRange * (light->m_csmNumSplits > 1 ? light->m_csmSplit2 : 1.0f); |
1415 | pEntry->m_csmSplits[2] = clipNear + clipRange * (light->m_csmNumSplits > 2 ? light->m_csmSplit3 : 1.0f); |
1416 | pEntry->m_csmSplits[3] = clipNear + clipRange * 1.0f; |
1417 | pEntry->m_shadowMapFar = clipFar; |
1418 | } else if (light->type == QSSGRenderLight::Type::SpotLight) { |
1419 | auto spotlightCamera = std::make_unique<QSSGRenderCamera>(args: QSSGRenderCamera::Type::PerspectiveCamera); |
1420 | spotlightCamera->fov = qDegreesToRadians(degrees: light->m_coneAngle * 2.0f); |
1421 | spotlightCamera->clipNear = 1.0f; |
1422 | spotlightCamera->clipFar = light->m_shadowMapFar; |
1423 | const QVector3D lightDir = light->getDirection(); |
1424 | const QVector3D lightPos = light->getGlobalPos() - lightDir * spotlightCamera->clipNear; |
1425 | const QVector3D lightPivot = light->pivot; |
1426 | const QVector3D forward = lightDir.normalized(); |
1427 | const QVector3D right = qFuzzyCompare(p1: qAbs(t: forward.y()), p2: 1.0f) |
1428 | ? QVector3D::crossProduct(v1: forward, v2: QVector3D(1, 0, 0)).normalized() |
1429 | : QVector3D::crossProduct(v1: forward, v2: QVector3D(0, 1, 0)).normalized(); |
1430 | const QVector3D up = QVector3D::crossProduct(v1: right, v2: forward).normalized(); |
1431 | spotlightCamera->localTransform = QSSGRenderNode::calculateTransformMatrix(position: lightPos, |
1432 | scale: QSSGRenderNode::initScale, |
1433 | pivot: lightPivot, |
1434 | rotation: QQuaternion::fromDirection(direction: forward, up)); |
1435 | QRectF theViewport(0.0f, 0.0f, (float)light->m_shadowMapRes, (float)light->m_shadowMapRes); |
1436 | spotlightCamera->calculateGlobalVariables(inViewport: theViewport); |
1437 | cascades.push_back(t: std::move(spotlightCamera)); |
1438 | pEntry->m_shadowMapFar = light->m_shadowMapFar; |
1439 | } else { |
1440 | Q_UNREACHABLE(); |
1441 | } |
1442 | |
1443 | memset(s: pEntry->m_csmActive, c: 0, n: sizeof(pEntry->m_csmActive)); |
1444 | |
1445 | for (int cascadeIndex = 0; cascadeIndex < cascades.length(); cascadeIndex++) { |
1446 | const auto &cascadeCamera = cascades[cascadeIndex]; |
1447 | if (!cascadeCamera) |
1448 | continue; |
1449 | pEntry->m_csmActive[cascadeIndex] = 1.f; |
1450 | cascadeCamera->calculateViewProjectionMatrix(outMatrix&: pEntry->m_lightViewProjection[cascadeIndex]); |
1451 | pEntry->m_lightView = cascadeCamera->globalTransform.inverted(); // pre-calculate this for the material |
1452 | const bool isOrtho = cascadeCamera->type == QSSGRenderGraphObject::Type::OrthographicCamera; |
1453 | rhiPrepareResourcesForShadowMap(rhiCtx, inData: layerData, passKey, pEntry, ps: &ps, depthAdjust: &depthAdjust, sortedOpaqueObjects, inCamera&: *cascadeCamera, orthographic: isOrtho, cubeFace: QSSGRenderTextureCubeFaceNone, cascadeIndex); |
1454 | // Render into the 2D texture pEntry->m_rhiDepthMap, using |
1455 | // pEntry->m_rhiDepthStencil as the (throwaway) depth/stencil buffer. |
1456 | QRhiTextureRenderTarget *rt = pEntry->m_rhiRenderTargets[cascadeIndex]; |
1457 | cb->beginPass(rt, colorClearValue: Qt::white, depthStencilClearValue: { 1.0f, 0 }, resourceUpdates: nullptr, flags: rhiCtx->commonPassFlags()); |
1458 | Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass); |
1459 | QSSGRHICTX_STAT(rhiCtx, beginRenderPass(rt)); |
1460 | rhiRenderOneShadowMap(rhiCtx, &ps, sortedOpaqueObjects, 0); |
1461 | cb->endPass(); |
1462 | QSSGRHICTX_STAT(rhiCtx, endRenderPass()); |
1463 | |
1464 | if (drawDirectionalLightShadowBoxes) { |
1465 | QMatrix4x4 viewProjection(Qt::Uninitialized); |
1466 | cascadeCamera->calculateViewProjectionMatrix(outMatrix&: viewProjection); |
1467 | ShadowmapHelpers::addDirectionalLightDebugBox(box: computeFrustumBounds(projection: viewProjection), debugDrawSystem); |
1468 | } |
1469 | } |
1470 | Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QByteArrayLiteral("shadow_map")); |
1471 | } else { |
1472 | Q_ASSERT(pEntry->m_rhiDepthCube); |
1473 | const QSize size = pEntry->m_rhiDepthCube->pixelSize(); |
1474 | ps.viewport = QRhiViewport(0, 0, float(size.width()), float(size.height())); |
1475 | |
1476 | QSSGRenderCamera theCameras[6] { QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera}, |
1477 | QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera}, |
1478 | QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera}, |
1479 | QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera}, |
1480 | QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera}, |
1481 | QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera} }; |
1482 | const float shadowMapFar = qMax<float>(a: 2.0f, b: light->m_shadowMapFar); |
1483 | setupCubeShadowCameras(inLight: light, shadowMapFar, inCameras: theCameras); |
1484 | pEntry->m_lightView = QMatrix4x4(); |
1485 | pEntry->m_shadowMapFar = shadowMapFar; |
1486 | |
1487 | const bool swapYFaces = !rhi->isYUpInFramebuffer(); |
1488 | for (const auto face : QSSGRenderTextureCubeFaces) { |
1489 | theCameras[quint8(face)].calculateViewProjectionMatrix(outMatrix&: pEntry->m_lightViewProjection[0]); |
1490 | pEntry->m_lightCubeView[quint8(face)] = theCameras[quint8(face)].globalTransform.inverted(); // pre-calculate this for the material |
1491 | |
1492 | rhiPrepareResourcesForShadowMap(rhiCtx, |
1493 | inData: layerData, |
1494 | passKey, |
1495 | pEntry, |
1496 | ps: &ps, |
1497 | depthAdjust: &depthAdjust, |
1498 | sortedOpaqueObjects, |
1499 | inCamera&: theCameras[quint8(face)], |
1500 | orthographic: false, |
1501 | cubeFace: face, |
1502 | cascadeIndex: 0); |
1503 | } |
1504 | |
1505 | for (const auto face : QSSGRenderTextureCubeFaces) { |
1506 | // Render into one face of the cubemap texture pEntry->m_rhiDephCube, using |
1507 | // pEntry->m_rhiDepthStencil as the (throwaway) depth/stencil buffer. |
1508 | |
1509 | QSSGRenderTextureCubeFace outFace = face; |
1510 | // FACE S T GL |
1511 | // +x -z, -y right |
1512 | // -x +z, -y left |
1513 | // +y +x, +z top |
1514 | // -y +x, -z bottom |
1515 | // +z +x, -y front |
1516 | // -z -x, -y back |
1517 | // FACE S T D3D |
1518 | // +x -z, +y right |
1519 | // -x +z, +y left |
1520 | // +y +x, -z bottom |
1521 | // -y +x, +z top |
1522 | // +z +x, +y front |
1523 | // -z -x, +y back |
1524 | if (swapYFaces) { |
1525 | // +Y and -Y faces get swapped (D3D, Vulkan, Metal). |
1526 | // See shadowMapping.glsllib. This is complemented there by reversing T as well. |
1527 | if (outFace == QSSGRenderTextureCubeFace::PosY) |
1528 | outFace = QSSGRenderTextureCubeFace::NegY; |
1529 | else if (outFace == QSSGRenderTextureCubeFace::NegY) |
1530 | outFace = QSSGRenderTextureCubeFace::PosY; |
1531 | } |
1532 | QRhiTextureRenderTarget *rt = pEntry->m_rhiRenderTargets[quint8(outFace)]; |
1533 | cb->beginPass(rt, colorClearValue: Qt::white, depthStencilClearValue: { 1.0f, 0 }, resourceUpdates: nullptr, flags: rhiCtx->commonPassFlags()); |
1534 | QSSGRHICTX_STAT(rhiCtx, beginRenderPass(rt)); |
1535 | Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass); |
1536 | rhiRenderOneShadowMap(rhiCtx, &ps, sortedOpaqueObjects, quint8(face)); |
1537 | cb->endPass(); |
1538 | QSSGRHICTX_STAT(rhiCtx, endRenderPass()); |
1539 | Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QSSG_RENDERPASS_NAME("shadow_cube", 0, outFace)); |
1540 | } |
1541 | } |
1542 | } |
1543 | } |
1544 | |
1545 | void RenderHelpers::rhiRenderReflectionMap(QSSGRhiContext *rhiCtx, |
1546 | QSSGPassKey passKey, |
1547 | const QSSGLayerRenderData &inData, |
1548 | QSSGRhiGraphicsPipelineState *ps, |
1549 | QSSGRenderReflectionMap &reflectionMapManager, |
1550 | const QVector<QSSGRenderReflectionProbe *> &reflectionProbes, |
1551 | const QSSGRenderableObjectList &reflectionPassObjects, |
1552 | QSSGRenderer &renderer) |
1553 | { |
1554 | QRhi *rhi = rhiCtx->rhi(); |
1555 | QRhiCommandBuffer *cb = rhiCtx->commandBuffer(); |
1556 | |
1557 | const bool renderSkybox = (inData.layer.background == QSSGRenderLayer::Background::SkyBox || |
1558 | inData.layer.background == QSSGRenderLayer::Background::SkyBoxCubeMap) |
1559 | && rhiCtx->rhi()->isFeatureSupported(feature: QRhi::TexelFetch); |
1560 | |
1561 | for (int i = 0, ie = reflectionProbes.size(); i != ie; ++i) { |
1562 | QSSGReflectionMapEntry *pEntry = reflectionMapManager.reflectionMapEntry(probeIdx: i); |
1563 | if (!pEntry) |
1564 | continue; |
1565 | |
1566 | if (!pEntry->m_needsRender) |
1567 | continue; |
1568 | |
1569 | if (reflectionProbes[i]->refreshMode == QSSGRenderReflectionProbe::ReflectionRefreshMode::FirstFrame && pEntry->m_rendered) |
1570 | continue; |
1571 | |
1572 | if (reflectionProbes[i]->texture) |
1573 | continue; |
1574 | |
1575 | Q_ASSERT(pEntry->m_rhiDepthStencil); |
1576 | Q_ASSERT(pEntry->m_rhiCube); |
1577 | |
1578 | const QSize size = pEntry->m_rhiCube->pixelSize(); |
1579 | ps->viewport = QRhiViewport(0, 0, float(size.width()), float(size.height())); |
1580 | |
1581 | QSSGRenderCamera theCameras[6] { QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera}, |
1582 | QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera}, |
1583 | QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera}, |
1584 | QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera}, |
1585 | QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera}, |
1586 | QSSGRenderCamera{QSSGRenderCamera::Type::PerspectiveCamera} }; |
1587 | setupCubeReflectionCameras(inProbe: reflectionProbes[i], inCameras: theCameras); |
1588 | const bool swapYFaces = !rhi->isYUpInFramebuffer(); |
1589 | for (const auto face : QSSGRenderTextureCubeFaces) { |
1590 | const auto cubeFaceIdx = QSSGBaseTypeHelpers::indexOfCubeFace(face); |
1591 | theCameras[cubeFaceIdx].calculateViewProjectionMatrix(outMatrix&: pEntry->m_viewProjection); |
1592 | |
1593 | rhiPrepareResourcesForReflectionMap(rhiCtx, passKey, inData, pEntry, ps, |
1594 | sortedOpaqueObjects: reflectionPassObjects, inCamera&: theCameras[cubeFaceIdx], renderer, cubeFace: face); |
1595 | } |
1596 | QRhiRenderPassDescriptor *renderPassDesc = nullptr; |
1597 | for (auto face : QSSGRenderTextureCubeFaces) { |
1598 | if (pEntry->m_timeSlicing == QSSGRenderReflectionProbe::ReflectionTimeSlicing::IndividualFaces) |
1599 | face = pEntry->m_timeSliceFace; |
1600 | |
1601 | QSSGRenderTextureCubeFace outFace = face; |
1602 | // Faces are swapped similarly to shadow maps due to differences in backends |
1603 | // Prefilter step handles correcting orientation differences in the final render |
1604 | if (swapYFaces) { |
1605 | if (outFace == QSSGRenderTextureCubeFace::PosY) |
1606 | outFace = QSSGRenderTextureCubeFace::NegY; |
1607 | else if (outFace == QSSGRenderTextureCubeFace::NegY) |
1608 | outFace = QSSGRenderTextureCubeFace::PosY; |
1609 | } |
1610 | QRhiTextureRenderTarget *rt = pEntry->m_rhiRenderTargets[quint8(outFace)]; |
1611 | cb->beginPass(rt, colorClearValue: reflectionProbes[i]->clearColor, depthStencilClearValue: { 1.0f, 0 }, resourceUpdates: nullptr, flags: rhiCtx->commonPassFlags()); |
1612 | QSSGRHICTX_STAT(rhiCtx, beginRenderPass(rt)); |
1613 | Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderPass); |
1614 | |
1615 | if (renderSkybox && pEntry->m_skyBoxSrbs[quint8(face)]) { |
1616 | const auto &shaderCache = renderer.contextInterface()->shaderCache(); |
1617 | const bool isSkyBox = inData.layer.background == QSSGRenderLayer::Background::SkyBox; |
1618 | const auto &shaderPipeline = isSkyBox ? shaderCache->getBuiltInRhiShaders().getRhiSkyBoxShader(tonemapMode: QSSGRenderLayer::TonemapMode::None, isRGBE: inData.layer.skyBoxIsRgbe8, viewCount: 1) |
1619 | : shaderCache->getBuiltInRhiShaders().getRhiSkyBoxCubeShader(viewCount: 1); |
1620 | Q_ASSERT(shaderPipeline); |
1621 | QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps&: *ps, pipeline: shaderPipeline.get()); |
1622 | QRhiShaderResourceBindings *srb = pEntry->m_skyBoxSrbs[quint8(face)]; |
1623 | if (!renderPassDesc) |
1624 | renderPassDesc = rt->newCompatibleRenderPassDescriptor(); |
1625 | rt->setRenderPassDescriptor(renderPassDesc); |
1626 | isSkyBox ? renderer.rhiQuadRenderer()->recordRenderQuad(rhiCtx, ps, srb, rpDesc: renderPassDesc, flags: {}) |
1627 | : renderer.rhiCubeRenderer()->recordRenderCube(rhiCtx, ps, srb, rpDesc: renderPassDesc, flags: {}); |
1628 | } |
1629 | |
1630 | bool needsSetViewport = true; |
1631 | for (const auto &handle : reflectionPassObjects) |
1632 | rhiRenderRenderable(rhiCtx, state: *ps, object&: *handle.obj, needsSetViewport: &needsSetViewport, cubeFace: face); |
1633 | |
1634 | cb->endPass(); |
1635 | QSSGRHICTX_STAT(rhiCtx, endRenderPass()); |
1636 | Q_QUICK3D_PROFILE_END_WITH_STRING(QQuick3DProfiler::Quick3DRenderPass, 0, QSSG_RENDERPASS_NAME("reflection_cube", 0, outFace)); |
1637 | |
1638 | if (pEntry->m_timeSlicing == QSSGRenderReflectionProbe::ReflectionTimeSlicing::IndividualFaces) |
1639 | break; |
1640 | } |
1641 | if (renderPassDesc) |
1642 | renderPassDesc->deleteLater(); |
1643 | |
1644 | pEntry->renderMips(rhiCtx); |
1645 | |
1646 | if (pEntry->m_timeSlicing == QSSGRenderReflectionProbe::ReflectionTimeSlicing::IndividualFaces) |
1647 | pEntry->m_timeSliceFace = QSSGBaseTypeHelpers::next(face: pEntry->m_timeSliceFace); // Wraps |
1648 | |
1649 | if (reflectionProbes[i]->refreshMode == QSSGRenderReflectionProbe::ReflectionRefreshMode::FirstFrame) |
1650 | pEntry->m_rendered = true; |
1651 | |
1652 | reflectionProbes[i]->hasScheduledUpdate = false; |
1653 | pEntry->m_needsRender = false; |
1654 | } |
1655 | } |
1656 | |
1657 | bool RenderHelpers::rhiPrepareAoTexture(QSSGRhiContext *rhiCtx, |
1658 | const QSize &size, |
1659 | QSSGRhiRenderableTexture *renderableTex, |
1660 | quint8 viewCount) |
1661 | { |
1662 | QRhi *rhi = rhiCtx->rhi(); |
1663 | bool needsBuild = false; |
1664 | |
1665 | if (!renderableTex->texture) { |
1666 | QRhiTexture::Flags flags = QRhiTexture::RenderTarget; |
1667 | // the ambient occlusion texture is always non-msaa, even if multisampling is used in the main pass |
1668 | if (viewCount <= 1) |
1669 | renderableTex->texture = rhi->newTexture(format: QRhiTexture::RGBA8, pixelSize: size, sampleCount: 1, flags); |
1670 | else |
1671 | renderableTex->texture = rhi->newTextureArray(format: QRhiTexture::RGBA8, arraySize: viewCount, pixelSize: size, sampleCount: 1, flags); |
1672 | needsBuild = true; |
1673 | } else if (renderableTex->texture->pixelSize() != size) { |
1674 | renderableTex->texture->setPixelSize(size); |
1675 | needsBuild = true; |
1676 | } |
1677 | |
1678 | if (needsBuild) { |
1679 | if (!renderableTex->texture->create()) { |
1680 | qWarning(msg: "Failed to build ambient occlusion texture (size %dx%d)", size.width(), size.height()); |
1681 | renderableTex->reset(); |
1682 | return false; |
1683 | } |
1684 | renderableTex->resetRenderTarget(); |
1685 | QRhiTextureRenderTargetDescription desc; |
1686 | QRhiColorAttachment colorAttachment(renderableTex->texture); |
1687 | colorAttachment.setMultiViewCount(viewCount); |
1688 | desc.setColorAttachments({ colorAttachment }); |
1689 | renderableTex->rt = rhi->newTextureRenderTarget(desc); |
1690 | renderableTex->rt->setName(QByteArrayLiteral("Ambient occlusion")); |
1691 | renderableTex->rpDesc = renderableTex->rt->newCompatibleRenderPassDescriptor(); |
1692 | renderableTex->rt->setRenderPassDescriptor(renderableTex->rpDesc); |
1693 | if (!renderableTex->rt->create()) { |
1694 | qWarning(msg: "Failed to build render target for ambient occlusion texture"); |
1695 | renderableTex->reset(); |
1696 | return false; |
1697 | } |
1698 | } |
1699 | |
1700 | return true; |
1701 | } |
1702 | |
1703 | void RenderHelpers::rhiRenderAoTexture(QSSGRhiContext *rhiCtx, |
1704 | QSSGPassKey passKey, |
1705 | QSSGRenderer &renderer, |
1706 | QSSGRhiShaderPipeline &shaderPipeline, |
1707 | QSSGRhiGraphicsPipelineState &ps, |
1708 | const QSSGAmbientOcclusionSettings &ao, |
1709 | const QSSGRhiRenderableTexture &rhiAoTexture, |
1710 | const QSSGRhiRenderableTexture &rhiDepthTexture, |
1711 | const QSSGRenderCamera &camera) |
1712 | { |
1713 | QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(q: rhiCtx); |
1714 | |
1715 | // no texelFetch in GLSL <= 120 and GLSL ES 100 |
1716 | if (!rhiCtx->rhi()->isFeatureSupported(feature: QRhi::TexelFetch)) { |
1717 | QRhiCommandBuffer *cb = rhiCtx->commandBuffer(); |
1718 | // just clear and stop there |
1719 | cb->beginPass(rt: rhiAoTexture.rt, colorClearValue: Qt::white, depthStencilClearValue: { 1.0f, 0 }); |
1720 | QSSGRHICTX_STAT(rhiCtx, beginRenderPass(rhiAoTexture.rt)); |
1721 | cb->endPass(); |
1722 | QSSGRHICTX_STAT(rhiCtx, endRenderPass()); |
1723 | return; |
1724 | } |
1725 | |
1726 | QSSGRhiGraphicsPipelineStatePrivate::setShaderPipeline(ps, pipeline: &shaderPipeline); |
1727 | |
1728 | const float R2 = ao.aoDistance * ao.aoDistance * 0.16f; |
1729 | const QSize textureSize = rhiAoTexture.texture->pixelSize(); |
1730 | const float rw = float(textureSize.width()); |
1731 | const float rh = float(textureSize.height()); |
1732 | const float fov = camera.verticalFov(aspectRatio: rw / rh); |
1733 | const float tanHalfFovY = tanf(x: 0.5f * fov * (rh / rw)); |
1734 | const float invFocalLenX = tanHalfFovY * (rw / rh); |
1735 | |
1736 | const QVector4D aoProps(ao.aoStrength * 0.01f, ao.aoDistance * 0.4f, ao.aoSoftness * 0.02f, ao.aoBias); |
1737 | const QVector4D aoProps2(float(ao.aoSamplerate), (ao.aoDither) ? 1.0f : 0.0f, 0.0f, 0.0f); |
1738 | const QVector4D aoScreenConst(1.0f / R2, rh / (2.0f * tanHalfFovY), 1.0f / rw, 1.0f / rh); |
1739 | const QVector4D uvToEyeConst(2.0f * invFocalLenX, -2.0f * tanHalfFovY, -invFocalLenX, tanHalfFovY); |
1740 | const QVector2D cameraProps(camera.clipNear, camera.clipFar); |
1741 | |
1742 | // layout(std140, binding = 0) uniform buf { |
1743 | // vec4 aoProperties; |
1744 | // vec4 aoProperties2; |
1745 | // vec4 aoScreenConst; |
1746 | // vec4 uvToEyeConst; |
1747 | // vec2 cameraProperties; |
1748 | |
1749 | const int UBUF_SIZE = 72; |
1750 | QSSGRhiDrawCallData &dcd(rhiCtxD->drawCallData(key: { .cid: passKey, .model: nullptr, .entry: nullptr, .entryIdx: 0 })); |
1751 | if (!dcd.ubuf) { |
1752 | dcd.ubuf = rhiCtx->rhi()->newBuffer(type: QRhiBuffer::Dynamic, usage: QRhiBuffer::UniformBuffer, size: UBUF_SIZE); |
1753 | dcd.ubuf->create(); |
1754 | } |
1755 | |
1756 | char *ubufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame(); |
1757 | memcpy(dest: ubufData, src: &aoProps, n: 16); |
1758 | memcpy(dest: ubufData + 16, src: &aoProps2, n: 16); |
1759 | memcpy(dest: ubufData + 32, src: &aoScreenConst, n: 16); |
1760 | memcpy(dest: ubufData + 48, src: &uvToEyeConst, n: 16); |
1761 | memcpy(dest: ubufData + 64, src: &cameraProps, n: 8); |
1762 | dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame(); |
1763 | |
1764 | QRhiSampler *sampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Nearest, .magFilter: QRhiSampler::Nearest, .mipmap: QRhiSampler::None, |
1765 | .hTiling: QRhiSampler::ClampToEdge, .vTiling: QRhiSampler::ClampToEdge, .zTiling: QRhiSampler::Repeat }); |
1766 | QSSGRhiShaderResourceBindingList bindings; |
1767 | bindings.addUniformBuffer(binding: 0, stage: RENDERER_VISIBILITY_ALL, buf: dcd.ubuf); |
1768 | // binding 1 is either a sampler2D or sampler2DArray, matching |
1769 | // rhiDepthTexture.texture, no special casing needed here |
1770 | bindings.addTexture(binding: 1, stage: QRhiShaderResourceBinding::FragmentStage, tex: rhiDepthTexture.texture, sampler); |
1771 | QRhiShaderResourceBindings *srb = rhiCtxD->srb(bindings); |
1772 | |
1773 | renderer.rhiQuadRenderer()->prepareQuad(rhiCtx, maybeRub: nullptr); |
1774 | renderer.rhiQuadRenderer()->recordRenderQuadPass(rhiCtx, ps: &ps, srb, rt: rhiAoTexture.rt, flags: {}); |
1775 | } |
1776 | |
1777 | bool RenderHelpers::rhiPrepareScreenTexture(QSSGRhiContext *rhiCtx, |
1778 | const QSize &size, |
1779 | bool wantsMips, |
1780 | QSSGRhiRenderableTexture *renderableTex, |
1781 | quint8 viewCount) |
1782 | { |
1783 | QRhi *rhi = rhiCtx->rhi(); |
1784 | bool needsBuild = false; |
1785 | QRhiTexture::Flags flags = QRhiTexture::RenderTarget; |
1786 | if (wantsMips) |
1787 | flags |= QRhiTexture::MipMapped | QRhiTexture::UsedWithGenerateMips; |
1788 | |
1789 | if (!renderableTex->texture) { |
1790 | // always non-msaa, even if multisampling is used in the main pass |
1791 | if (viewCount <= 1) |
1792 | renderableTex->texture = rhi->newTexture(format: QRhiTexture::RGBA8, pixelSize: size, sampleCount: 1, flags); |
1793 | else |
1794 | renderableTex->texture = rhi->newTextureArray(format: QRhiTexture::RGBA8, arraySize: viewCount, pixelSize: size, sampleCount: 1, flags); |
1795 | needsBuild = true; |
1796 | } else if (renderableTex->texture->pixelSize() != size) { |
1797 | renderableTex->texture->setPixelSize(size); |
1798 | needsBuild = true; |
1799 | } |
1800 | |
1801 | if (!renderableTex->depthStencil && !renderableTex->depthTexture) { |
1802 | if (viewCount <= 1) |
1803 | renderableTex->depthStencil = rhi->newRenderBuffer(type: QRhiRenderBuffer::DepthStencil, pixelSize: size); |
1804 | else |
1805 | renderableTex->depthTexture = rhi->newTextureArray(format: QRhiTexture::D24S8, arraySize: viewCount, pixelSize: size, sampleCount: 1, flags: QRhiTexture::RenderTarget); |
1806 | needsBuild = true; |
1807 | } else { |
1808 | if (renderableTex->depthStencil && renderableTex->depthStencil->pixelSize() != size) { |
1809 | renderableTex->depthStencil->setPixelSize(size); |
1810 | needsBuild = true; |
1811 | } else if (renderableTex->depthTexture && renderableTex->depthTexture->pixelSize() != size) { |
1812 | renderableTex->depthTexture->setPixelSize(size); |
1813 | needsBuild = true; |
1814 | } |
1815 | } |
1816 | |
1817 | if (needsBuild) { |
1818 | if (!renderableTex->texture->create()) { |
1819 | qWarning(msg: "Failed to build screen texture (size %dx%d)", size.width(), size.height()); |
1820 | renderableTex->reset(); |
1821 | return false; |
1822 | } |
1823 | if (renderableTex->depthStencil && !renderableTex->depthStencil->create()) { |
1824 | qWarning(msg: "Failed to build depth-stencil buffer for screen texture (size %dx%d)", |
1825 | size.width(), size.height()); |
1826 | renderableTex->reset(); |
1827 | return false; |
1828 | } else if (renderableTex->depthTexture && !renderableTex->depthTexture->create()) { |
1829 | qWarning(msg: "Failed to build depth-stencil texture array (multiview) for screen texture (size %dx%d)", |
1830 | size.width(), size.height()); |
1831 | renderableTex->reset(); |
1832 | return false; |
1833 | } |
1834 | renderableTex->resetRenderTarget(); |
1835 | QRhiTextureRenderTargetDescription desc; |
1836 | QRhiColorAttachment colorAttachment(renderableTex->texture); |
1837 | colorAttachment.setMultiViewCount(viewCount); |
1838 | desc.setColorAttachments({ colorAttachment }); |
1839 | if (renderableTex->depthStencil) |
1840 | desc.setDepthStencilBuffer(renderableTex->depthStencil); |
1841 | else if (renderableTex->depthTexture) |
1842 | desc.setDepthTexture(renderableTex->depthTexture); |
1843 | renderableTex->rt = rhi->newTextureRenderTarget(desc); |
1844 | renderableTex->rt->setName(QByteArrayLiteral("Screen texture")); |
1845 | renderableTex->rpDesc = renderableTex->rt->newCompatibleRenderPassDescriptor(); |
1846 | renderableTex->rt->setRenderPassDescriptor(renderableTex->rpDesc); |
1847 | if (!renderableTex->rt->create()) { |
1848 | qWarning(msg: "Failed to build render target for screen texture"); |
1849 | renderableTex->reset(); |
1850 | return false; |
1851 | } |
1852 | } |
1853 | |
1854 | return true; |
1855 | } |
1856 | |
1857 | void RenderHelpers::rhiPrepareGrid(QSSGRhiContext *rhiCtx, QSSGPassKey passKey, QSSGRenderLayer &layer, QSSGRenderCameraList &cameras, QSSGRenderer &renderer) |
1858 | { |
1859 | QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(q: rhiCtx); |
1860 | QRhiCommandBuffer *cb = rhiCtx->commandBuffer(); |
1861 | cb->debugMarkBegin(QByteArrayLiteral("Quick3D prepare grid")); |
1862 | |
1863 | QSSGRhiShaderResourceBindingList bindings; |
1864 | |
1865 | int uniformBinding = 0; |
1866 | const int ubufSize = cameras.count() >= 2 ? 276 : 148; |
1867 | |
1868 | QSSGRhiDrawCallData &dcd(rhiCtxD->drawCallData(key: { .cid: passKey, .model: nullptr, .entry: nullptr, .entryIdx: 0 })); // Change to Grid? |
1869 | |
1870 | QRhi *rhi = rhiCtx->rhi(); |
1871 | if (!dcd.ubuf) { |
1872 | dcd.ubuf = rhi->newBuffer(type: QRhiBuffer::Dynamic, usage: QRhiBuffer::UniformBuffer, size: ubufSize); |
1873 | dcd.ubuf->create(); |
1874 | } |
1875 | |
1876 | // Param |
1877 | const float nearF = cameras[0]->clipNear; |
1878 | const float farF = cameras[0]->clipFar; |
1879 | const float scale = layer.gridScale; |
1880 | const quint32 gridFlags = layer.gridFlags; |
1881 | |
1882 | const float yFactor = rhi->isYUpInNDC() ? 1.0f : -1.0f; |
1883 | |
1884 | quint32 ubufOffset = 0; |
1885 | char *ubufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame(); |
1886 | |
1887 | for (qsizetype viewIdx = 0; viewIdx < cameras.count(); ++viewIdx) { |
1888 | QMatrix4x4 viewProj(Qt::Uninitialized); |
1889 | cameras[viewIdx]->calculateViewProjectionMatrix(outMatrix&: viewProj); |
1890 | QMatrix4x4 invViewProj = viewProj.inverted(); |
1891 | quint32 viewDataOffset = ubufOffset; |
1892 | memcpy(dest: ubufData + viewDataOffset + viewIdx * 64, src: viewProj.constData(), n: 64); |
1893 | viewDataOffset += 64 * cameras.count(); |
1894 | memcpy(dest: ubufData + viewDataOffset + viewIdx * 64, src: invViewProj.constData(), n: 64); |
1895 | } |
1896 | ubufOffset += (64 + 64) * cameras.count(); |
1897 | |
1898 | memcpy(dest: ubufData + ubufOffset, src: &nearF, n: 4); |
1899 | ubufOffset += 4; |
1900 | memcpy(dest: ubufData + ubufOffset, src: &farF, n: 4); |
1901 | ubufOffset += 4; |
1902 | memcpy(dest: ubufData + ubufOffset, src: &scale, n: 4); |
1903 | ubufOffset += 4; |
1904 | memcpy(dest: ubufData + ubufOffset, src: &yFactor, n: 4); |
1905 | ubufOffset += 4; |
1906 | memcpy(dest: ubufData + ubufOffset, src: &gridFlags, n: 4); |
1907 | |
1908 | dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame(); |
1909 | |
1910 | bindings.addUniformBuffer(binding: uniformBinding, stage: RENDERER_VISIBILITY_ALL, buf: dcd.ubuf); |
1911 | |
1912 | layer.gridSrb = rhiCtxD->srb(bindings); |
1913 | renderer.rhiQuadRenderer()->prepareQuad(rhiCtx, maybeRub: nullptr); |
1914 | |
1915 | cb->debugMarkEnd(); |
1916 | } |
1917 | |
1918 | static void rhiPrepareSkyBox_helper(QSSGRhiContext *rhiCtx, |
1919 | QSSGPassKey passKey, |
1920 | QSSGRenderLayer &layer, |
1921 | QSSGRenderCameraList &cameras, |
1922 | QSSGRenderer &renderer, |
1923 | QSSGReflectionMapEntry *entry = nullptr, |
1924 | QSSGRenderTextureCubeFace cubeFace = QSSGRenderTextureCubeFaceNone) |
1925 | { |
1926 | QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(q: rhiCtx); |
1927 | const bool cubeMapMode = layer.background == QSSGRenderLayer::Background::SkyBoxCubeMap; |
1928 | const QSSGRenderImageTexture lightProbeTexture = |
1929 | cubeMapMode ? renderer.contextInterface()->bufferManager()->loadRenderImage(image: layer.skyBoxCubeMap, inMipMode: QSSGBufferManager::MipModeDisable) |
1930 | : renderer.contextInterface()->bufferManager()->loadRenderImage(image: layer.lightProbe, inMipMode: QSSGBufferManager::MipModeBsdf); |
1931 | const bool hasValidTexture = lightProbeTexture.m_texture != nullptr; |
1932 | if (hasValidTexture) { |
1933 | if (cubeFace == QSSGRenderTextureCubeFaceNone) |
1934 | layer.skyBoxIsRgbe8 = lightProbeTexture.m_flags.isRgbe8(); |
1935 | |
1936 | QSSGRhiShaderResourceBindingList bindings; |
1937 | |
1938 | QRhiSampler *sampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Linear, |
1939 | .magFilter: QRhiSampler::Linear, |
1940 | .mipmap: cubeMapMode ? QRhiSampler::None : QRhiSampler::Linear, // cube map doesn't have mipmaps |
1941 | .hTiling: QRhiSampler::Repeat, |
1942 | .vTiling: QRhiSampler::ClampToEdge, |
1943 | .zTiling: QRhiSampler::Repeat }); |
1944 | int samplerBinding = 1; //the shader code is hand-written, so we don't need to look that up |
1945 | const quint32 ubufSize = cameras.count() >= 2 ? 416 : 240; // same ubuf layout for both skybox and skyboxcube |
1946 | bindings.addTexture(binding: samplerBinding, |
1947 | stage: QRhiShaderResourceBinding::FragmentStage, |
1948 | tex: lightProbeTexture.m_texture, sampler); |
1949 | |
1950 | const auto cubeFaceIdx = QSSGBaseTypeHelpers::indexOfCubeFace(face: cubeFace); |
1951 | const quintptr entryIdx = quintptr(cubeFace != QSSGRenderTextureCubeFaceNone) * cubeFaceIdx; |
1952 | QSSGRhiDrawCallData &dcd = rhiCtxD->drawCallData(key: { .cid: passKey, .model: nullptr, .entry: entry, .entryIdx: entryIdx }); |
1953 | |
1954 | QRhi *rhi = rhiCtx->rhi(); |
1955 | if (!dcd.ubuf) { |
1956 | dcd.ubuf = rhi->newBuffer(type: QRhiBuffer::Dynamic, usage: QRhiBuffer::UniformBuffer, size: ubufSize); |
1957 | dcd.ubuf->create(); |
1958 | } |
1959 | |
1960 | float adjustY = rhi->isYUpInNDC() ? 1.0f : -1.0f; |
1961 | const float exposure = layer.lightProbeSettings.probeExposure; |
1962 | // orientation |
1963 | const QMatrix3x3 &rotationMatrix(layer.lightProbeSettings.probeOrientation); |
1964 | const float blurAmount = layer.skyboxBlurAmount; |
1965 | const float maxMipLevel = float(lightProbeTexture.m_mipmapCount - 2); |
1966 | |
1967 | const QVector4D skyboxProperties = { |
1968 | adjustY, |
1969 | exposure, |
1970 | blurAmount, |
1971 | maxMipLevel |
1972 | }; |
1973 | |
1974 | char *ubufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame(); |
1975 | quint32 ubufOffset = 0; |
1976 | // skyboxProperties |
1977 | memcpy(dest: ubufData + ubufOffset, src: &skyboxProperties, n: 16); |
1978 | ubufOffset += 16; |
1979 | // orientation |
1980 | memcpy(dest: ubufData + ubufOffset, src: rotationMatrix.constData(), n: 12); |
1981 | ubufOffset += 16; |
1982 | memcpy(dest: ubufData + ubufOffset, src: (char *)rotationMatrix.constData() + 12, n: 12); |
1983 | ubufOffset += 16; |
1984 | memcpy(dest: ubufData + ubufOffset, src: (char *)rotationMatrix.constData() + 24, n: 12); |
1985 | ubufOffset += 16; |
1986 | |
1987 | for (qsizetype viewIdx = 0; viewIdx < cameras.count(); ++viewIdx) { |
1988 | const QMatrix4x4 &inverseProjection = cameras[viewIdx]->projection.inverted(); |
1989 | const QMatrix4x4 &viewMatrix = cameras[viewIdx]->globalTransform; |
1990 | QMatrix4x4 viewProjection(Qt::Uninitialized); // For cube mode |
1991 | cameras[viewIdx]->calculateViewProjectionWithoutTranslation(near: 0.1f, far: 5.0f, outMatrix&: viewProjection); |
1992 | |
1993 | quint32 viewDataOffset = ubufOffset; |
1994 | memcpy(dest: ubufData + viewDataOffset + viewIdx * 64, src: viewProjection.constData(), n: 64); |
1995 | viewDataOffset += cameras.count() * 64; |
1996 | memcpy(dest: ubufData + viewDataOffset + viewIdx * 64, src: inverseProjection.constData(), n: 64); |
1997 | viewDataOffset += cameras.count() * 64; |
1998 | memcpy(dest: ubufData + viewDataOffset + viewIdx * 48, src: viewMatrix.constData(), n: 48); |
1999 | } |
2000 | dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame(); |
2001 | |
2002 | bindings.addUniformBuffer(binding: 0, stage: RENDERER_VISIBILITY_ALL, buf: dcd.ubuf); |
2003 | |
2004 | if (cubeFace != QSSGRenderTextureCubeFaceNone) { |
2005 | const auto cubeFaceIdx = QSSGBaseTypeHelpers::indexOfCubeFace(face: cubeFace); |
2006 | entry->m_skyBoxSrbs[cubeFaceIdx] = rhiCtxD->srb(bindings); |
2007 | } else { |
2008 | layer.skyBoxSrb = rhiCtxD->srb(bindings); |
2009 | } |
2010 | |
2011 | if (cubeMapMode) |
2012 | renderer.rhiCubeRenderer()->prepareCube(rhiCtx, maybeRub: nullptr); |
2013 | else |
2014 | renderer.rhiQuadRenderer()->prepareQuad(rhiCtx, maybeRub: nullptr); |
2015 | } |
2016 | } |
2017 | |
2018 | void RenderHelpers::rhiPrepareSkyBox(QSSGRhiContext *rhiCtx, |
2019 | QSSGPassKey passKey, |
2020 | QSSGRenderLayer &layer, |
2021 | QSSGRenderCameraList &cameras, |
2022 | QSSGRenderer &renderer) |
2023 | { |
2024 | QRhiCommandBuffer *cb = rhiCtx->commandBuffer(); |
2025 | cb->debugMarkBegin(QByteArrayLiteral("Quick3D prepare skybox")); |
2026 | |
2027 | rhiPrepareSkyBox_helper(rhiCtx, passKey, layer, cameras, renderer); |
2028 | |
2029 | cb->debugMarkEnd(); |
2030 | } |
2031 | |
2032 | void RenderHelpers::rhiPrepareSkyBoxForReflectionMap(QSSGRhiContext *rhiCtx, |
2033 | QSSGPassKey passKey, |
2034 | QSSGRenderLayer &layer, |
2035 | QSSGRenderCamera &inCamera, |
2036 | QSSGRenderer &renderer, |
2037 | QSSGReflectionMapEntry *entry, |
2038 | QSSGRenderTextureCubeFace cubeFace) |
2039 | { |
2040 | QRhiCommandBuffer *cb = rhiCtx->commandBuffer(); |
2041 | cb->debugMarkBegin(QByteArrayLiteral("Quick3D prepare skybox for reflection cube map")); |
2042 | |
2043 | QSSGRenderCameraList cameras({ &inCamera }); |
2044 | rhiPrepareSkyBox_helper(rhiCtx, passKey, layer, cameras, renderer, entry, cubeFace); |
2045 | |
2046 | cb->debugMarkEnd(); |
2047 | } |
2048 | |
2049 | bool RenderHelpers::rhiPrepareDepthPass(QSSGRhiContext *rhiCtx, |
2050 | QSSGPassKey passKey, |
2051 | const QSSGRhiGraphicsPipelineState &basePipelineState, |
2052 | QRhiRenderPassDescriptor *rpDesc, |
2053 | QSSGLayerRenderData &inData, |
2054 | const QSSGRenderableObjectList &sortedOpaqueObjects, |
2055 | const QSSGRenderableObjectList &sortedTransparentObjects, |
2056 | int samples, |
2057 | int viewCount) |
2058 | { |
2059 | static const auto rhiPrepareDepthPassForObject = [](QSSGRhiContext *rhiCtx, |
2060 | QSSGPassKey passKey, |
2061 | QSSGLayerRenderData &inData, |
2062 | QSSGRenderableObject *obj, |
2063 | QRhiRenderPassDescriptor *rpDesc, |
2064 | QSSGRhiGraphicsPipelineState *ps) { |
2065 | QSSGRhiShaderPipelinePtr shaderPipeline; |
2066 | QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(q: rhiCtx); |
2067 | |
2068 | const bool isOpaqueDepthPrePass = obj->depthWriteMode == QSSGDepthDrawMode::OpaquePrePass; |
2069 | QSSGShaderFeatures featureSet; |
2070 | featureSet.set(feature: QSSGShaderFeatures::Feature::DepthPass, val: true); |
2071 | if (isOpaqueDepthPrePass) |
2072 | featureSet.set(feature: QSSGShaderFeatures::Feature::OpaqueDepthPrePass, val: true); |
2073 | |
2074 | QSSGRhiDrawCallData *dcd = nullptr; |
2075 | if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) { |
2076 | QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(*obj)); |
2077 | const void *modelNode = &subsetRenderable.modelContext.model; |
2078 | dcd = &rhiCtxD->drawCallData(key: { .cid: passKey, .model: modelNode, .entry: &subsetRenderable.material, .entryIdx: 0 }); |
2079 | } |
2080 | |
2081 | if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset) { |
2082 | QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(*obj)); |
2083 | const auto &material = static_cast<const QSSGRenderDefaultMaterial &>(subsetRenderable.getMaterial()); |
2084 | ps->cullMode = QSSGRhiHelpers::toCullMode(cullFaceMode: material.cullMode); |
2085 | |
2086 | shaderPipeline = shadersForDefaultMaterial(ps, subsetRenderable, featureSet); |
2087 | if (shaderPipeline) { |
2088 | shaderPipeline->ensureCombinedUniformBuffer(ubuf: &dcd->ubuf); |
2089 | char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame(); |
2090 | updateUniformsForDefaultMaterial(shaderPipeline&: *shaderPipeline, rhiCtx, inData, ubufData, ps, subsetRenderable, cameras: inData.renderedCameras, depthAdjust: nullptr, alteredModelViewProjection: nullptr); |
2091 | dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame(); |
2092 | } else { |
2093 | return false; |
2094 | } |
2095 | } else if (obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) { |
2096 | QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(*obj)); |
2097 | |
2098 | const auto &customMaterial = static_cast<const QSSGRenderCustomMaterial &>(subsetRenderable.getMaterial()); |
2099 | |
2100 | ps->cullMode = QSSGRhiHelpers::toCullMode(cullFaceMode: customMaterial.m_cullMode); |
2101 | |
2102 | QSSGCustomMaterialSystem &customMaterialSystem(*subsetRenderable.renderer->contextInterface()->customMaterialSystem().get()); |
2103 | shaderPipeline = customMaterialSystem.shadersForCustomMaterial(ps, material: customMaterial, renderable&: subsetRenderable, defaultMaterialShaderKeyProperties: inData.getDefaultMaterialPropertyTable(), featureSet); |
2104 | |
2105 | if (shaderPipeline) { |
2106 | shaderPipeline->ensureCombinedUniformBuffer(ubuf: &dcd->ubuf); |
2107 | char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame(); |
2108 | customMaterialSystem.updateUniformsForCustomMaterial(shaderPipeline&: *shaderPipeline, rhiCtx, inData, ubufData, ps, material: customMaterial, renderable&: subsetRenderable, |
2109 | cameras: inData.renderedCameras, depthAdjust: nullptr, alteredModelViewProjection: nullptr); |
2110 | dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame(); |
2111 | } else { |
2112 | return false; |
2113 | } |
2114 | } |
2115 | |
2116 | // the rest is common, only relying on QSSGSubsetRenderableBase, not the subclasses |
2117 | if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) { |
2118 | QSSGSubsetRenderable &subsetRenderable(static_cast<QSSGSubsetRenderable &>(*obj)); |
2119 | auto &ia = QSSGRhiInputAssemblerStatePrivate::get(ps&: *ps); |
2120 | ia = subsetRenderable.subset.rhi.ia; |
2121 | |
2122 | const QSSGRenderCameraDataList &cameraDatas(*inData.renderedCameraData); |
2123 | int instanceBufferBinding = setupInstancing(renderable: &subsetRenderable, ps, rhiCtx, cameraDirection: cameraDatas[0].direction, cameraPosition: cameraDatas[0].position); |
2124 | QSSGRhiHelpers::bakeVertexInputLocations(ia: &ia, shaders: *shaderPipeline, instanceBufferBinding); |
2125 | |
2126 | QSSGRhiShaderResourceBindingList bindings; |
2127 | bindings.addUniformBuffer(binding: 0, stage: RENDERER_VISIBILITY_ALL, buf: dcd->ubuf); |
2128 | |
2129 | // Depth and SSAO textures, in case a custom material's shader code does something with them. |
2130 | addDepthTextureBindings(rhiCtx, shaderPipeline: shaderPipeline.get(), bindings); |
2131 | |
2132 | if (isOpaqueDepthPrePass) { |
2133 | addOpaqueDepthPrePassBindings(rhiCtx, |
2134 | shaderPipeline: shaderPipeline.get(), |
2135 | renderableImage: subsetRenderable.firstImage, |
2136 | bindings, |
2137 | isCustomMaterialMeshSubset: (obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset)); |
2138 | } |
2139 | |
2140 | // Skinning |
2141 | if (QRhiTexture *boneTexture = inData.getBonemapTexture(modelContext: subsetRenderable.modelContext)) { |
2142 | int binding = shaderPipeline->bindingForTexture(name: "qt_boneTexture"); |
2143 | if (binding >= 0) { |
2144 | QRhiSampler *boneSampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Nearest, |
2145 | .magFilter: QRhiSampler::Nearest, |
2146 | .mipmap: QRhiSampler::None, |
2147 | .hTiling: QRhiSampler::ClampToEdge, |
2148 | .vTiling: QRhiSampler::ClampToEdge, |
2149 | .zTiling: QRhiSampler::Repeat |
2150 | }); |
2151 | bindings.addTexture(binding, |
2152 | stage: QRhiShaderResourceBinding::VertexStage, |
2153 | tex: boneTexture, |
2154 | sampler: boneSampler); |
2155 | } |
2156 | } |
2157 | |
2158 | // Morphing |
2159 | auto *targetsTexture = subsetRenderable.subset.rhi.targetsTexture; |
2160 | if (targetsTexture) { |
2161 | int binding = shaderPipeline->bindingForTexture(name: "qt_morphTargetTexture"); |
2162 | if (binding >= 0) { |
2163 | QRhiSampler *targetsSampler = rhiCtx->sampler(samplerDescription: { .minFilter: QRhiSampler::Nearest, |
2164 | .magFilter: QRhiSampler::Nearest, |
2165 | .mipmap: QRhiSampler::None, |
2166 | .hTiling: QRhiSampler::ClampToEdge, |
2167 | .vTiling: QRhiSampler::ClampToEdge, |
2168 | .zTiling: QRhiSampler::ClampToEdge |
2169 | }); |
2170 | bindings.addTexture(binding, stage: QRhiShaderResourceBinding::VertexStage, tex: subsetRenderable.subset.rhi.targetsTexture, sampler: targetsSampler); |
2171 | } |
2172 | } |
2173 | |
2174 | QRhiShaderResourceBindings *srb = rhiCtxD->srb(bindings); |
2175 | |
2176 | subsetRenderable.rhiRenderData.depthPrePass.pipeline = rhiCtxD->pipeline(ps: *ps, |
2177 | rpDesc, |
2178 | srb); |
2179 | subsetRenderable.rhiRenderData.depthPrePass.srb = srb; |
2180 | } |
2181 | |
2182 | return true; |
2183 | }; |
2184 | |
2185 | // Phase 1 (prepare) for the Z prepass or the depth texture generation. |
2186 | // These renders opaque (Z prepass), or opaque and transparent (depth |
2187 | // texture), objects with depth test/write enabled, and color write |
2188 | // disabled, using a very simple set of shaders. |
2189 | |
2190 | QSSGRhiGraphicsPipelineState ps = basePipelineState; // viewport and others are filled out already |
2191 | // We took a copy of the pipeline state since we do not want to conflict |
2192 | // with what rhiPrepare() collects for its own use. So here just change |
2193 | // whatever we need. |
2194 | |
2195 | ps.samples = samples; |
2196 | ps.viewCount = viewCount; |
2197 | ps.flags |= { QSSGRhiGraphicsPipelineState::Flag::DepthTestEnabled, QSSGRhiGraphicsPipelineState::Flag::DepthWriteEnabled }; |
2198 | ps.targetBlend.colorWrite = {}; |
2199 | |
2200 | for (const QSSGRenderableObjectHandle &handle : sortedOpaqueObjects) { |
2201 | if (!rhiPrepareDepthPassForObject(rhiCtx, passKey, inData, handle.obj, rpDesc, &ps)) |
2202 | return false; |
2203 | } |
2204 | |
2205 | for (const QSSGRenderableObjectHandle &handle : sortedTransparentObjects) { |
2206 | if (!rhiPrepareDepthPassForObject(rhiCtx, passKey, inData, handle.obj, rpDesc, &ps)) |
2207 | return false; |
2208 | } |
2209 | |
2210 | return true; |
2211 | } |
2212 | |
2213 | void RenderHelpers::rhiRenderDepthPass(QSSGRhiContext *rhiCtx, |
2214 | const QSSGRhiGraphicsPipelineState &pipelineState, |
2215 | const QSSGRenderableObjectList &sortedOpaqueObjects, |
2216 | const QSSGRenderableObjectList &sortedTransparentObjects, |
2217 | bool *needsSetViewport) |
2218 | { |
2219 | static const auto rhiRenderDepthPassForImp = [](QSSGRhiContext *rhiCtx, |
2220 | const QSSGRhiGraphicsPipelineState &pipelineState, |
2221 | const QSSGRenderableObjectList &objects, |
2222 | bool *needsSetViewport) { |
2223 | for (const auto &oh : objects) { |
2224 | QSSGRenderableObject *obj = oh.obj; |
2225 | |
2226 | // casts to SubsetRenderableBase so it works for both default and custom materials |
2227 | if (obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) { |
2228 | QRhiCommandBuffer *cb = rhiCtx->commandBuffer(); |
2229 | QSSGSubsetRenderable *subsetRenderable(static_cast<QSSGSubsetRenderable *>(obj)); |
2230 | |
2231 | QRhiBuffer *vertexBuffer = subsetRenderable->subset.rhi.vertexBuffer->buffer(); |
2232 | QRhiBuffer *indexBuffer = subsetRenderable->subset.rhi.indexBuffer |
2233 | ? subsetRenderable->subset.rhi.indexBuffer->buffer() |
2234 | : nullptr; |
2235 | |
2236 | QRhiGraphicsPipeline *ps = subsetRenderable->rhiRenderData.depthPrePass.pipeline; |
2237 | if (!ps) |
2238 | return; |
2239 | |
2240 | QRhiShaderResourceBindings *srb = subsetRenderable->rhiRenderData.depthPrePass.srb; |
2241 | if (!srb) |
2242 | return; |
2243 | |
2244 | Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderCall); |
2245 | cb->setGraphicsPipeline(ps); |
2246 | cb->setShaderResources(srb); |
2247 | |
2248 | if (*needsSetViewport) { |
2249 | cb->setViewport(pipelineState.viewport); |
2250 | *needsSetViewport = false; |
2251 | } |
2252 | |
2253 | QRhiCommandBuffer::VertexInput vertexBuffers[2]; |
2254 | int vertexBufferCount = 1; |
2255 | vertexBuffers[0] = QRhiCommandBuffer::VertexInput(vertexBuffer, 0); |
2256 | quint32 instances = 1; |
2257 | if (subsetRenderable->modelContext.model.instancing()) { |
2258 | instances = subsetRenderable->modelContext.model.instanceCount(); |
2259 | vertexBuffers[1] = QRhiCommandBuffer::VertexInput(subsetRenderable->instanceBuffer, 0); |
2260 | vertexBufferCount = 2; |
2261 | } |
2262 | |
2263 | if (indexBuffer) { |
2264 | cb->setVertexInput(startBinding: 0, bindingCount: vertexBufferCount, bindings: vertexBuffers, indexBuf: indexBuffer, indexOffset: 0, indexFormat: subsetRenderable->subset.rhi.indexBuffer->indexFormat()); |
2265 | cb->drawIndexed(indexCount: subsetRenderable->subset.count, instanceCount: instances, firstIndex: subsetRenderable->subset.offset); |
2266 | QSSGRHICTX_STAT(rhiCtx, drawIndexed(subsetRenderable->subset.count, instances)); |
2267 | } else { |
2268 | cb->setVertexInput(startBinding: 0, bindingCount: vertexBufferCount, bindings: vertexBuffers); |
2269 | cb->draw(vertexCount: subsetRenderable->subset.count, instanceCount: instances, firstVertex: subsetRenderable->subset.offset); |
2270 | QSSGRHICTX_STAT(rhiCtx, draw(subsetRenderable->subset.count, instances)); |
2271 | } |
2272 | Q_QUICK3D_PROFILE_END_WITH_IDS(QQuick3DProfiler::Quick3DRenderCall, (subsetRenderable->subset.count | quint64(instances) << 32), |
2273 | QVector<int>({subsetRenderable->modelContext.model.profilingId, |
2274 | subsetRenderable->material.profilingId})); |
2275 | } |
2276 | } |
2277 | }; |
2278 | |
2279 | rhiRenderDepthPassForImp(rhiCtx, pipelineState, sortedOpaqueObjects, needsSetViewport); |
2280 | rhiRenderDepthPassForImp(rhiCtx, pipelineState, sortedTransparentObjects, needsSetViewport); |
2281 | } |
2282 | |
2283 | bool RenderHelpers::rhiPrepareDepthTexture(QSSGRhiContext *rhiCtx, |
2284 | const QSize &size, |
2285 | QSSGRhiRenderableTexture *renderableTex, |
2286 | quint8 viewCount) |
2287 | { |
2288 | QRhi *rhi = rhiCtx->rhi(); |
2289 | bool needsBuild = false; |
2290 | |
2291 | if (!renderableTex->texture) { |
2292 | QRhiTexture::Format format = QRhiTexture::D32F; |
2293 | if (!rhi->isTextureFormatSupported(format)) |
2294 | format = QRhiTexture::D16; |
2295 | if (!rhi->isTextureFormatSupported(format)) |
2296 | qWarning(msg: "Depth texture not supported"); |
2297 | if (viewCount <= 1) |
2298 | renderableTex->texture = rhiCtx->rhi()->newTexture(format, pixelSize: size, sampleCount: 1, flags: QRhiTexture::RenderTarget); |
2299 | else |
2300 | renderableTex->texture = rhiCtx->rhi()->newTextureArray(format, arraySize: viewCount, pixelSize: size, sampleCount: 1, flags: QRhiTexture::RenderTarget); |
2301 | needsBuild = true; |
2302 | } else if (renderableTex->texture->pixelSize() != size) { |
2303 | renderableTex->texture->setPixelSize(size); |
2304 | needsBuild = true; |
2305 | } |
2306 | |
2307 | if (needsBuild) { |
2308 | if (!renderableTex->texture->create()) { |
2309 | qWarning(msg: "Failed to build depth texture (size %dx%d, format %d)", |
2310 | size.width(), size.height(), int(renderableTex->texture->format())); |
2311 | renderableTex->reset(); |
2312 | return false; |
2313 | } |
2314 | renderableTex->resetRenderTarget(); |
2315 | QRhiTextureRenderTargetDescription rtDesc; |
2316 | rtDesc.setDepthTexture(renderableTex->texture); |
2317 | renderableTex->rt = rhi->newTextureRenderTarget(desc: rtDesc); |
2318 | renderableTex->rt->setName(QByteArrayLiteral("Depth texture")); |
2319 | renderableTex->rpDesc = renderableTex->rt->newCompatibleRenderPassDescriptor(); |
2320 | renderableTex->rt->setRenderPassDescriptor(renderableTex->rpDesc); |
2321 | if (!renderableTex->rt->create()) { |
2322 | qWarning(msg: "Failed to build render target for depth texture"); |
2323 | renderableTex->reset(); |
2324 | return false; |
2325 | } |
2326 | } |
2327 | |
2328 | return true; |
2329 | } |
2330 | |
2331 | QT_END_NAMESPACE |
2332 |
Definitions
- QSSG_PI
- QSSG_HALFPI
- RENDERER_VISIBILITY_ALL
- shadersForDefaultMaterial
- shadersForParticleMaterial
- updateUniformsForDefaultMaterial
- calculateSortedObjectBounds
- computeFrustumBounds
- sliceFrustum
- computeShadowCameraFromFrustum
- setupCascadingCamerasForShadowMap
- setupCubeReflectionCameras
- addOpaqueDepthPrePassBindings
- setupCubeShadowCameras
- setupInstancing
- rhiPrepareResourcesForReflectionMap
- addDepthTextureBindings
- rhiPrepareResourcesForShadowMap
- fillTargetBlend
- rhiPrepareRenderable
- rhiRenderRenderable
- rhiRenderShadowMap
- rhiRenderReflectionMap
- rhiPrepareAoTexture
- rhiRenderAoTexture
- rhiPrepareScreenTexture
- rhiPrepareGrid
- rhiPrepareSkyBox_helper
- rhiPrepareSkyBox
- rhiPrepareSkyBoxForReflectionMap
- rhiPrepareDepthPass
- rhiRenderDepthPass
Start learning QML with our Intro Training
Find out more