14#include <QtQuick3DUtils/private/qssgassert_p.h>
16#include <QtCore/qbitarray.h>
30 auto &
renderer(subsetRenderable.renderer);
34 return shaderPipeline;
40 const auto &
renderer(particleRenderable.renderer);
41 const auto &shaderCache =
renderer->contextInterface()->shaderCache();
42 auto featureLevel = particleRenderable.particles.m_featureLevel;
43 const auto &shaderPipeline = shaderCache->getBuiltInRhiShaders().getRhiParticleShader(featureLevel, ps->
viewCount);
46 return shaderPipeline;
59 const auto &
renderer(subsetRenderable.renderer);
62 if (alteredModelViewProjection)
63 alteredMvpList[0] = *alteredModelViewProjection;
65 const auto &modelNode = subsetRenderable.modelContext.model;
66 QRhiTexture *lightmapTexture = inData.getLightmapTexture(subsetRenderable.modelContext);
68 const QMatrix4x4 &localInstanceTransform(modelNode.localInstanceTransform);
69 const QMatrix4x4 &globalInstanceTransform(modelNode.globalInstanceTransform);
70 const QMatrix4x4 &modelMatrix(modelNode.usesBoneTexture() ?
QMatrix4x4() : subsetRenderable.globalTransform);
76 subsetRenderable.material,
77 subsetRenderable.shaderDescription,
78 inData.getDefaultMaterialPropertyTable(),
80 alteredModelViewProjection ? alteredMvpList : subsetRenderable.modelContext.modelViewProjections,
81 subsetRenderable.modelContext.normalMatrix,
84 localInstanceTransform,
85 globalInstanceTransform,
87 subsetRenderable.firstImage,
88 subsetRenderable.opacity,
90 subsetRenderable.lights,
91 subsetRenderable.reflectionProbe,
92 subsetRenderable.renderableFlags.receivesShadows(),
93 subsetRenderable.renderableFlags.receivesReflections(),
103 for (
const auto handles : { &sortedOpaqueObjects, &sortedTransparentObjects }) {
110 if (
obj.renderableFlags.castsShadows())
111 boundsCasting.include(
obj.globalBounds);
112 if (
obj.renderableFlags.receivesShadows())
113 boundsReceiving.include(
obj.globalBounds);
116 return { boundsCasting.toQSSGBoxPointsNoEmptyCheck(), boundsReceiving.toQSSGBoxPointsNoEmptyCheck() };
122 for (
int i = 1;
i < 8; ++
i) {
123 center += vertices[
i];
125 return center * 0.125f;
131 for (
int i = 0;
i < 8; ++
i) {
143 inCamera.calculateViewProjectionMatrix(viewProjection);
145 bool invertible =
false;
159 quint32 mapRes = 1 << inProbe->reflectionMapRes;
160 QRectF theViewport(0.0f, 0.0f, (
float)mapRes, (
float)mapRes);
170 const QVector3D inProbePos = inProbe->getGlobalPos();
171 const QVector3D inProbePivot = inProbe->pivot;
173 for (
int i = 0;
i < 6; ++
i) {
174 inCameras[
i].parent =
nullptr;
175 inCameras[
i].clipNear = 1.0f;
176 inCameras[
i].clipFar = qMax<float>(2.0f, 10000.0f);
180 inCameras[
i].calculateGlobalVariables(theViewport);
193 quint32 mapRes = inLight->m_shadowMapRes;
194 QRectF theViewport(0.0f, 0.0f, (
float)mapRes, (
float)mapRes);
195 theCamera.clipNear = 1.0f;
196 theCamera.clipFar = inLight->m_shadowMapFar;
198 QVector3D inLightPos = inLight->getGlobalPos();
199 QVector3D inLightDir = inLight->getDirection();
202 inLightPos -= inLightDir * inCamera.clipNear;
204 theCamera.parent =
nullptr;
206 if (inLight->type == QSSGRenderLight::Type::DirectionalLight) {
207 Q_ASSERT(theCamera.type == QSSGRenderCamera::Type::OrthographicCamera);
223 if (sceneCastingBounds.isFinite() && boundsReceiving.isFinite()
224 && sceneCastingBounds.extents().lengthSquared() < frustumBounds.extents().lengthSquared()) {
235 const float aLength = sceneCastingBounds.dimensions().z();
236 const float bLength = boundsReceiving.dimensions().z();
243 const float d = bCenter - aCenter;
246 const float a0 = 0.f;
247 const float a1 = aLength;
248 const float b0 = (aLength * 0.5f) +
d - (bLength * 0.5f);
249 const float b1 = (aLength * 0.5f) +
d + (bLength * 0.5f);
252 const float ap0 =
qMin(
a0, b0);
253 const float ap1 =
qMax(
a1, b1);
255 const float length = ap1 - ap0;
257 const float c = (ap1 + ap0) * 0.5f;
260 const float move =
c - aLength * 0.5f;
262 center = center + forward * move;
263 finalDims = sceneCastingBounds.dimensions();
267 finalDims = frustumBounds.dimensions();
275 theViewport.setHeight(finalDims.y());
276 theViewport.setWidth(finalDims.x());
277 theCamera.clipNear = -0.5f * finalDims.z();
278 theCamera.clipFar = 0.5f * finalDims.z();
280 }
else if (inLight->type == QSSGRenderLight::Type::PointLight) {
284 theCamera.calculateGlobalVariables(theViewport);
291 bool isCustomMaterialMeshSubset =
false)
294 return mapType == QSSGRenderableImage::Type::BaseColor ||
295 mapType == QSSGRenderableImage::Type::Diffuse ||
296 mapType == QSSGRenderableImage::Type::Translucency ||
297 mapType == QSSGRenderableImage::Type::Opacity;
300 while (renderableImage) {
301 const auto mapType = renderableImage->m_mapType;
302 if (imageAffectsAlpha(mapType)) {
304 const int samplerHint = int(mapType);
305 int samplerBinding = shaderPipeline->
bindingForTexture(samplerName, samplerHint);
306 if (samplerBinding >= 0) {
308 if (samplerBinding >= 0 &&
texture) {
321 renderableImage = renderableImage->m_nextImage;
324 if (isCustomMaterialMeshSubset) {
325 QVector<QShaderDescription::InOutVariable> samplerVars =
328 auto it = std::find_if(samplerVars.cbegin(), samplerVars.cend(),
330 if (
it == samplerVars.
cend())
331 samplerVars.append(
var);
334 int maxSamplerBinding = -1;
336 maxSamplerBinding =
qMax(maxSamplerBinding,
var.binding);
345 QBitArray samplerBindingsSpecified(maxSamplerBinding + 1);
347 if (maxSamplerBinding >= 0) {
350 for (
int i = 0;
i < customTexCount; ++
i) {
353 if (samplerBinding >= 0) {
354 samplerBindingsSpecified.setBit(samplerBinding);
373 if (!samplerBindingsSpecified.testBit(
var.binding)) {
384 Q_ASSERT(inLight->type != QSSGRenderLight::Type::DirectionalLight);
387 quint32 mapRes = inLight->m_shadowMapRes;
388 QRectF theViewport(0.0f, 0.0f, (
float)mapRes, (
float)mapRes);
398 const QVector3D inLightPos = inLight->getGlobalPos();
399 const QVector3D inLightPivot = inLight->pivot;
401 for (
int i = 0;
i < 6; ++
i) {
402 inCameras[
i].parent =
nullptr;
403 inCameras[
i].clipNear = 1.0f;
404 inCameras[
i].clipFar = qMax<float>(2.0f, inLight->m_shadowMapFar);
407 inCameras[
i].calculateGlobalVariables(theViewport);
445 int instanceBufferBinding = 0;
449 const quint32 stride = renderable->modelContext.model.instanceTable->stride();
450 QVarLengthArray<QRhiVertexInputBinding, 8> bindings;
451 std::copy(ia.inputLayout.cbeginBindings(), ia.inputLayout.cendBindings(), std::back_inserter(bindings));
453 instanceBufferBinding = bindings.size() - 1;
454 ia.inputLayout.setBindings(bindings.cbegin(), bindings.cend());
456 return instanceBufferBinding;
473 rhiPrepareSkyBoxForReflectionMap(rhiCtx, passKey, inData.layer, inCamera,
renderer, pEntry, cubeFace);
479 const auto &defaultMaterialShaderKeyProperties = inData.getDefaultMaterialPropertyTable();
481 for (
const auto &
handle : sortedOpaqueObjects) {
485 if (inObject.type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || inObject.type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
487 const bool hasSkinning = defaultMaterialShaderKeyProperties.m_boneCount.getValue(renderable.shaderDescription) > 0;
488 modelViewProjection = hasSkinning ? pEntry->m_viewProjection
489 : pEntry->m_viewProjection * renderable.globalTransform;
493 rhiPrepareRenderable(rhiCtx, passKey, inData, inObject, pEntry->m_rhiRenderPassDesc, ps, features, 1, 1,
494 &inCamera, &modelViewProjection, cubeFace, pEntry);
505 if (depthTextureBinding >= 0 || depthTextureArrayBinding >= 0) {
509 if (depthTextureBinding >= 0)
511 if (depthTextureArrayBinding >= 0)
520 if (ssaoTextureBinding >= 0 || ssaoTextureArrayBinding >= 0) {
524 if (ssaoTextureBinding >= 0) {
529 if (ssaoTextureArrayBinding >= 0) {
562 const auto &defaultMaterialShaderKeyProperties = inData.getDefaultMaterialPropertyTable();
565 for (
const auto &
handle : sortedOpaqueObjects) {
567 QSSG_ASSERT(theObject->renderableFlags.castsShadows(),
continue);
571 if (isOpaqueDepthPrePass)
577 if (theObject->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || theObject->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
578 const bool hasSkinning = defaultMaterialShaderKeyProperties.m_boneCount.getValue(renderable.shaderDescription) > 0;
579 modelViewProjection = hasSkinning ? pEntry->m_lightVP
580 : pEntry->m_lightVP * renderable.globalTransform;
582 dcd = &rhiCtxD->drawCallData({ passKey, &renderable.modelContext.model,
589 if (theObject->type == QSSGSubsetRenderable::Type::DefaultMaterialMeshSubset) {
592 const bool blendParticles = defaultMaterialShaderKeyProperties.m_blendParticles.getValue(subsetRenderable.shaderDescription);
597 shaderPipeline->ensureCombinedMainLightsUniformBuffer(&dcd->ubuf);
598 char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
604 dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
607 }
else if (theObject->type == QSSGSubsetRenderable::Type::CustomMaterialMeshSubset) {
611 QSSGCustomMaterialSystem &customMaterialSystem(*subsetRenderable.renderer->contextInterface()->customMaterialSystem().get());
612 shaderPipeline = customMaterialSystem.
shadersForCustomMaterial(ps, material, subsetRenderable, inData.getDefaultMaterialPropertyTable(), objectFeatureSet);
615 shaderPipeline->ensureCombinedMainLightsUniformBuffer(&dcd->ubuf);
616 char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
620 cameras, depthAdjust, &modelViewProjection);
621 dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
624 if (theObject->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || theObject->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
628 ia = subsetRenderable.subset.rhi.ia;
639 if (isOpaqueDepthPrePass) {
641 shaderPipeline.get(),
642 subsetRenderable.firstImage,
644 (theObject->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset));
653 if (screenTextureBinding >= 0 || screenTextureArrayBinding >= 0) {
656 if (screenTextureBinding >= 0) {
664 if (screenTextureArrayBinding >= 0) {
668 bindings.
addTexture(screenTextureArrayBinding,
675 subsetRenderable.rhiRenderData.shadowPass.pipeline = rhiCtxD->pipeline(*ps,
676 pEntry->m_rhiRenderPassDesc,
678 subsetRenderable.rhiRenderData.shadowPass.srb[cubeFaceIdx] = srb;
686 switch (materialBlend) {
723 const auto &defaultMaterialShaderKeyProperties = inData.getDefaultMaterialPropertyTable();
725 switch (inObject.type) {
726 case QSSGRenderableObject::Type::DefaultMaterialMeshSubset:
738 if (subsetRenderable.renderableFlags.rendersWithLightmap())
742 if (shaderPipeline) {
751 const auto &modelNode = subsetRenderable.modelContext.model;
752 const bool blendParticles = defaultMaterialShaderKeyProperties.m_blendParticles.getValue(subsetRenderable.shaderDescription);
762 const auto entryPartA =
reinterpret_cast<quintptr>(&subsetRenderable.material);
764 const void *entryId =
reinterpret_cast<const void *
>(entryPartA ^ entryPartB);
767 QSSGRhiDrawCallData &dcd = rhiCtxD->drawCallData({ passKey, &modelNode, entryId, entryIdx });
769 shaderPipeline->ensureCombinedMainLightsUniformBuffer(&dcd.ubuf);
772 Q_ASSERT(alteredModelViewProjection);
776 Q_ASSERT(!alteredModelViewProjection);
782 dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame();
788 if (
QRhiTexture *boneTexture = inData.getBonemapTexture(subsetRenderable.modelContext)) {
789 int binding = shaderPipeline->bindingForTexture(
"qt_boneTexture");
805 auto *targetsTexture = subsetRenderable.subset.rhi.targetsTexture;
806 if (targetsTexture) {
807 int binding = shaderPipeline->bindingForTexture(
"qt_morphTargetTexture");
829 ia = subsetRenderable.subset.rhi.ia;
831 QVector3D cameraDirection = cameraDatas[0].direction;
833 cameraDirection = alteredCamera->getScalingCorrectDirection();
834 QVector3D cameraPosition = cameraDatas[0].position;
836 cameraPosition = alteredCamera->getGlobalPos();
837 int instanceBufferBinding =
setupInstancing(&subsetRenderable, ps, rhiCtx, cameraDirection, cameraPosition);
842 if (shaderPipeline->isLightingEnabled()) {
844 shaderPipeline->ub0LightDataOffset(),
845 shaderPipeline->ub0LightDataSize());
850 while (renderableImage) {
852 const int samplerHint = int(renderableImage->m_mapType);
853 int samplerBinding = shaderPipeline->bindingForTexture(samplerName, samplerHint);
854 if (samplerBinding >= 0) {
856 if (samplerBinding >= 0 &&
texture) {
871 renderableImage = renderableImage->m_nextImage;
874 if (shaderPipeline->isLightingEnabled()) {
876 const int shadowMapCount = shaderPipeline->shadowMapCount();
877 for (
int i = 0;
i < shadowMapCount; ++
i) {
883 const QByteArray &
name(shadowMapProperties.shadowMapTextureUniformName);
884 if (shadowMapProperties.cachedBinding < 0)
885 shadowMapProperties.cachedBinding = shaderPipeline->bindingForTexture(
name);
886 if (shadowMapProperties.cachedBinding < 0) {
887 qWarning(
"No combined image sampler for shadow map texture '%s'",
name.data());
898 int reflectionSampler = shaderPipeline->bindingForTexture(
"qt_reflectionMap");
901 QRhiTexture* reflectionTexture = inData.getReflectionMapManager()->reflectionMapEntry(subsetRenderable.reflectionProbeIndex)->m_rhiPrefilteredCube;
902 if (reflectionSampler >= 0 && reflectionTexture)
904 }
else if (shaderPipeline->lightProbeTexture()) {
907 auto tiling = shaderPipeline->lightProbeTiling();
911 shaderPipeline->lightProbeTexture(),
sampler);
913 qWarning(
"Could not find sampler for lightprobe");
918 if (shaderPipeline->screenTexture()) {
921 if (screenTextureBinding >= 0 || screenTextureArrayBinding >= 0) {
930 if (screenTextureBinding >= 0) {
933 shaderPipeline->screenTexture(),
sampler);
935 if (screenTextureArrayBinding >= 0) {
936 bindings.
addTexture(screenTextureArrayBinding,
938 shaderPipeline->screenTexture(),
sampler);
943 if (shaderPipeline->lightmapTexture()) {
950 shaderPipeline->lightmapTexture(),
sampler);
966 bool srbChanged =
false;
967 if (!srb || bindings != dcd.bindings) {
968 srb = rhiCtxD->srb(bindings);
969 dcd.bindings = bindings;
974 subsetRenderable.rhiRenderData.reflectionPass.srb[cubeFaceIdx] = srb;
976 subsetRenderable.rhiRenderData.mainPass.srb = srb;
981 && dcd.renderTargetDescriptionHash == pipelineKey.extra.renderTargetDescriptionHash
982 && dcd.renderTargetDescription == pipelineKey.renderTargetDescription
986 subsetRenderable.rhiRenderData.reflectionPass.pipeline = dcd.pipeline;
988 subsetRenderable.rhiRenderData.mainPass.pipeline = dcd.pipeline;
991 subsetRenderable.rhiRenderData.reflectionPass.pipeline = rhiCtxD->pipeline(pipelineKey,
992 renderPassDescriptor,
994 dcd.pipeline = subsetRenderable.rhiRenderData.reflectionPass.pipeline;
996 subsetRenderable.rhiRenderData.mainPass.pipeline = rhiCtxD->pipeline(pipelineKey,
997 renderPassDescriptor,
999 dcd.pipeline = subsetRenderable.rhiRenderData.mainPass.pipeline;
1001 dcd.renderTargetDescriptionHash = pipelineKey.extra.renderTargetDescriptionHash;
1002 dcd.renderTargetDescription = pipelineKey.renderTargetDescription;
1008 case QSSGRenderableObject::Type::CustomMaterialMeshSubset:
1012 QSSGCustomMaterialSystem &customMaterialSystem(*subsetRenderable.renderer->contextInterface()->customMaterialSystem().get());
1024 if (subsetRenderable.renderableFlags.rendersWithLightmap())
1028 material, inData, renderPassDescriptor,
samples, viewCount,
1029 alteredCamera, cubeFace, alteredModelViewProjection,
entry);
1032 case QSSGRenderableObject::Type::Particles:
1036 if (shaderPipeline) {
1038 alteredCamera, cubeFace,
entry);
1048 bool *needsSetViewport,
1051 switch (
object.
type) {
1052 case QSSGRenderableObject::Type::DefaultMaterialMeshSubset:
1061 ps = subsetRenderable.rhiRenderData.reflectionPass.pipeline;
1062 srb = subsetRenderable.rhiRenderData.reflectionPass.srb[cubeFaceIdx];
1068 QRhiBuffer *vertexBuffer = subsetRenderable.subset.
rhi.vertexBuffer->buffer();
1069 QRhiBuffer *indexBuffer = subsetRenderable.subset.
rhi.indexBuffer ? subsetRenderable.subset.rhi.indexBuffer->buffer() :
nullptr;
1073 cb->setGraphicsPipeline(ps);
1074 cb->setShaderResources(srb);
1076 if (*needsSetViewport) {
1077 cb->setViewport(
state.viewport);
1079 cb->setScissor(
state.scissor);
1080 *needsSetViewport =
false;
1087 if ( subsetRenderable.modelContext.model.instancing()) {
1088 instances = subsetRenderable.modelContext.model.instanceCount();
1100 cb->setStencilRef(
state.stencilRef);
1102 cb->setVertexInput(0,
vertexBufferCount, vertexBuffers, indexBuffer, 0, subsetRenderable.subset.
rhi.indexBuffer->indexFormat());
1103 cb->drawIndexed(subsetRenderable.subset.lodCount(subsetRenderable.subsetLevelOfDetail), instances, subsetRenderable.subset.lodOffset(subsetRenderable.subsetLevelOfDetail));
1104 QSSGRHICTX_STAT(rhiCtx, drawIndexed(subsetRenderable.subset.lodCount(subsetRenderable.subsetLevelOfDetail), instances));
1107 cb->draw(subsetRenderable.subset.count, instances, subsetRenderable.subset.offset);
1111 QVector<int>({subsetRenderable.modelContext.model.profilingId,
1112 subsetRenderable.material.profilingId}));
1115 case QSSGRenderableObject::Type::CustomMaterialMeshSubset:
1118 QSSGCustomMaterialSystem &customMaterialSystem(*subsetRenderable.renderer->contextInterface()->customMaterialSystem().get());
1122 case QSSGRenderableObject::Type::Particles:
1144 static const auto rhiRenderOneShadowMap = [](
QSSGRhiContext *rhiCtx,
1149 bool needsSetViewport =
true;
1151 for (
const auto &
handle : sortedOpaqueObjects) {
1153 QSSG_ASSERT(theObject->renderableFlags.castsShadows(),
continue);
1154 if (theObject->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset || theObject->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
1157 QRhiBuffer *vertexBuffer = renderable->subset.
rhi.vertexBuffer->buffer();
1158 QRhiBuffer *indexBuffer = renderable->subset.
rhi.indexBuffer
1159 ? renderable->subset.rhi.indexBuffer->buffer()
1163 if (!renderable->rhiRenderData.shadowPass.pipeline)
1168 cb->setGraphicsPipeline(renderable->rhiRenderData.shadowPass.pipeline);
1171 cb->setShaderResources(srb);
1173 if (needsSetViewport) {
1175 needsSetViewport =
false;
1182 if (renderable->modelContext.model.instancing()) {
1183 instances = renderable->modelContext.model.instanceCount();
1188 cb->setVertexInput(0,
vertexBufferCount, vertexBuffers, indexBuffer, 0, renderable->subset.
rhi.indexBuffer->indexFormat());
1189 cb->drawIndexed(renderable->subset.count, instances, renderable->subset.offset);
1190 QSSGRHICTX_STAT(rhiCtx, drawIndexed(renderable->subset.count, instances));
1193 cb->draw(renderable->subset.count, instances, renderable->subset.offset);
1197 QVector<int>({renderable->modelContext.model.profilingId,
1198 renderable->material.profilingId}));
1208 bool orthographic) {
1212 if (!pEntry->m_rhiBlurRenderTarget0 || !pEntry->m_rhiBlurRenderTarget1)
1217 QRhiTexture *
map = orthographic ? pEntry->m_rhiDepthMap : pEntry->m_rhiDepthCube;
1218 QRhiTexture *workMap = orthographic ? pEntry->m_rhiDepthCopy : pEntry->m_rhiCubeCopy;
1222 const auto &shaderCache =
renderer.contextInterface()->shaderCache();
1224 const auto &blurXPipeline = orthographic ? shaderCache->getBuiltInRhiShaders().getRhiOrthographicShadowBlurXShader()
1225 : shaderCache->getBuiltInRhiShaders().getRhiCubemapShadowBlurXShader();
1251 flipY.
data()[5] = -1.0f;
1252 float cameraProperties[2] = { shadowFilter, shadowMapFar };
1253 char *ubufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
1254 memcpy(ubufData, flipY.constData(), 64);
1255 memcpy(ubufData + 64, cameraProperties, 8);
1256 dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame();
1267 QSSGRhiQuadRenderer::Flags quadFlags;
1270 renderer.rhiQuadRenderer()->prepareQuad(rhiCtx,
nullptr);
1271 renderer.rhiQuadRenderer()->recordRenderQuadPass(rhiCtx, &ps, srb, pEntry->m_rhiBlurRenderTarget0, quadFlags);
1275 const auto &blurYPipeline = orthographic ? shaderCache->getBuiltInRhiShaders().getRhiOrthographicShadowBlurYShader()
1276 : shaderCache->getBuiltInRhiShaders().getRhiCubemapShadowBlurYShader();
1284 srb = rhiCtxD->srb(bindings);
1286 renderer.rhiQuadRenderer()->prepareQuad(rhiCtx,
nullptr);
1287 renderer.rhiQuadRenderer()->recordRenderQuadPass(rhiCtx, &ps, srb, pEntry->m_rhiBlurRenderTarget1, quadFlags);
1298 depthAdjust[0] = 0.0f;
1299 depthAdjust[1] = 1.0f;
1302 depthAdjust[0] = 1.0f;
1303 depthAdjust[1] = 0.5f;
1307 for (
int i = 0, ie = globalLights.
size();
i != ie; ++
i) {
1308 if (!globalLights[
i].shadows || globalLights[
i].light->m_fullyBaked)
1315 Q_ASSERT(pEntry->m_rhiDepthStencil);
1316 const bool orthographic = pEntry->m_rhiDepthMap && pEntry->m_rhiDepthCopy;
1318 const QSize size = pEntry->m_rhiDepthMap->pixelSize();
1321 const auto &light = globalLights[
i].light;
1322 const auto cameraType = (light->type == QSSGRenderLight::Type::DirectionalLight) ? QSSGRenderCamera::Type::OrthographicCamera : QSSGRenderCamera::Type::CustomCamera;
1325 theCamera.calculateViewProjectionMatrix(pEntry->m_lightVP);
1326 pEntry->m_lightView = theCamera.globalTransform.inverted();
1337 rhiRenderOneShadowMap(rhiCtx, &ps, sortedOpaqueObjects, 0);
1343 rhiBlurShadowMap(rhiCtx, pEntry,
renderer, globalLights[
i].light->m_shadowFilter, globalLights[
i].light->m_shadowMapFar,
true);
1346 Q_ASSERT(pEntry->m_rhiDepthCube && pEntry->m_rhiCubeCopy);
1347 const QSize size = pEntry->m_rhiDepthCube->pixelSize();
1361 theCameras[
quint8(
face)].calculateViewProjectionMatrix(pEntry->m_lightVP);
1399 rhiRenderOneShadowMap(rhiCtx, &ps, sortedOpaqueObjects,
quint8(
face));
1406 rhiBlurShadowMap(rhiCtx, pEntry,
renderer, globalLights[
i].light->m_shadowFilter, globalLights[
i].light->m_shadowMapFar,
false);
1417 const QVector<QSSGRenderReflectionProbe *> &reflectionProbes,
1428 for (
int i = 0, ie = reflectionProbes.size();
i != ie; ++
i) {
1433 if (!pEntry->m_needsRender)
1442 Q_ASSERT(pEntry->m_rhiDepthStencil);
1445 const QSize size = pEntry->m_rhiCube->pixelSize();
1458 theCameras[cubeFaceIdx].calculateViewProjectionMatrix(pEntry->m_viewProjection);
1461 reflectionPassObjects, theCameras[cubeFaceIdx],
renderer,
face);
1466 face = pEntry->m_timeSliceFace;
1478 cb->beginPass(rt, reflectionProbes[
i]->clearColor, { 1.0f, 0 },
nullptr, rhiCtx->
commonPassFlags());
1482 if (renderSkybox && pEntry->m_skyBoxSrbs[
quint8(
face)]) {
1483 const auto &shaderCache =
renderer.contextInterface()->shaderCache();
1486 : shaderCache->getBuiltInRhiShaders().getRhiSkyBoxCubeShader(1);
1490 if (!renderPassDesc)
1493 isSkyBox ?
renderer.rhiQuadRenderer()->recordRenderQuad(rhiCtx, ps, srb, renderPassDesc, {})
1494 :
renderer.rhiCubeRenderer()->recordRenderCube(rhiCtx, ps, srb, renderPassDesc, {});
1497 bool needsSetViewport =
true;
1498 for (
const auto &
handle : reflectionPassObjects)
1509 renderPassDesc->deleteLater();
1511 pEntry->renderMips(rhiCtx);
1517 pEntry->m_rendered =
true;
1519 reflectionProbes[
i]->hasScheduledUpdate =
false;
1520 pEntry->m_needsRender =
false;
1527 bool needsBuild =
false;
1529 if (!renderableTex->texture) {
1537 }
else if (renderableTex->texture->pixelSize() !=
size) {
1543 if (!renderableTex->texture->create()) {
1544 qWarning(
"Failed to build ambient occlusion texture (size %dx%d)",
size.width(),
size.height());
1545 renderableTex->reset();
1548 renderableTex->resetRenderTarget();
1552 desc.setColorAttachments({ colorAttachment });
1555 renderableTex->rpDesc = renderableTex->rt->newCompatibleRenderPassDescriptor();
1556 renderableTex->rt->setRenderPassDescriptor(renderableTex->rpDesc);
1557 if (!renderableTex->rt->create()) {
1558 qWarning(
"Failed to build render target for ambient occlusion texture");
1559 renderableTex->reset();
1592 const float R2 = ao.aoDistance * ao.aoDistance * 0.16f;
1594 const float rw = float(textureSize.
width());
1595 const float rh = float(textureSize.
height());
1596 const float fov =
camera.verticalFov(rw / rh);
1597 const float tanHalfFovY = tanf(0.5f * fov * (rh / rw));
1598 const float invFocalLenX = tanHalfFovY * (rw / rh);
1600 const QVector4D aoProps(ao.aoStrength * 0.01f, ao.aoDistance * 0.4f, ao.aoSoftness * 0.02f, ao.aoBias);
1601 const QVector4D aoProps2(
float(ao.aoSamplerate), (ao.aoDither) ? 1.0f : 0.0f, 0.0f, 0.0f);
1602 const QVector4D aoScreenConst(1.0f / R2, rh / (2.0f * tanHalfFovY), 1.0f / rw, 1.0f / rh);
1603 const QVector4D uvToEyeConst(2.0f * invFocalLenX, -2.0f * tanHalfFovY, -invFocalLenX, tanHalfFovY);
1620 char *ubufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
1621 memcpy(ubufData, &aoProps, 16);
1622 memcpy(ubufData + 16, &aoProps2, 16);
1623 memcpy(ubufData + 32, &aoScreenConst, 16);
1624 memcpy(ubufData + 48, &uvToEyeConst, 16);
1625 memcpy(ubufData + 64, &cameraProps, 8);
1626 dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame();
1637 renderer.rhiQuadRenderer()->prepareQuad(rhiCtx,
nullptr);
1638 renderer.rhiQuadRenderer()->recordRenderQuadPass(rhiCtx, &ps, srb, rhiAoTexture.
rt, {});
1644 bool needsBuild =
false;
1649 if (!renderableTex->texture) {
1656 }
else if (renderableTex->texture->pixelSize() !=
size) {
1661 if (!renderableTex->depthStencil && !renderableTex->depthTexture) {
1668 if (renderableTex->depthStencil && renderableTex->depthStencil->pixelSize() !=
size) {
1671 }
else if (renderableTex->depthTexture && renderableTex->depthTexture->pixelSize() !=
size) {
1672 renderableTex->depthTexture->setPixelSize(
size);
1678 if (!renderableTex->texture->create()) {
1679 qWarning(
"Failed to build screen texture (size %dx%d)",
size.width(),
size.height());
1680 renderableTex->reset();
1683 if (renderableTex->depthStencil && !renderableTex->depthStencil->create()) {
1684 qWarning(
"Failed to build depth-stencil buffer for screen texture (size %dx%d)",
1686 renderableTex->reset();
1688 }
else if (renderableTex->depthTexture && !renderableTex->depthTexture->create()) {
1689 qWarning(
"Failed to build depth-stencil texture array (multiview) for screen texture (size %dx%d)",
1691 renderableTex->reset();
1694 renderableTex->resetRenderTarget();
1698 desc.setColorAttachments({ colorAttachment });
1699 if (renderableTex->depthStencil)
1700 desc.setDepthStencilBuffer(renderableTex->depthStencil);
1701 else if (renderableTex->depthTexture)
1702 desc.setDepthTexture(renderableTex->depthTexture);
1705 renderableTex->rpDesc = renderableTex->rt->newCompatibleRenderPassDescriptor();
1706 renderableTex->rt->setRenderPassDescriptor(renderableTex->rpDesc);
1707 if (!renderableTex->rt->create()) {
1708 qWarning(
"Failed to build render target for screen texture");
1709 renderableTex->reset();
1725 int uniformBinding = 0;
1726 const int ubufSize = cameras.
count() >= 2 ? 276 : 148;
1737 const float nearF = cameras[0]->clipNear;
1738 const float farF = cameras[0]->clipFar;
1742 const float yFactor = rhi->
isYUpInNDC() ? 1.0f : -1.0f;
1745 char *ubufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
1747 for (
qsizetype viewIdx = 0; viewIdx < cameras.
count(); ++viewIdx) {
1749 cameras[viewIdx]->calculateViewProjectionMatrix(viewProj);
1751 quint32 viewDataOffset = ubufOffset;
1752 memcpy(ubufData + viewDataOffset + viewIdx * 64, viewProj.constData(), 64);
1753 viewDataOffset += 64 * cameras.
count();
1754 memcpy(ubufData + viewDataOffset + viewIdx * 64, invViewProj.constData(), 64);
1756 ubufOffset += (64 + 64) * cameras.
count();
1758 memcpy(ubufData + ubufOffset, &nearF, 4);
1760 memcpy(ubufData + ubufOffset, &farF, 4);
1762 memcpy(ubufData + ubufOffset, &
scale, 4);
1764 memcpy(ubufData + ubufOffset, &yFactor, 4);
1766 memcpy(ubufData + ubufOffset, &gridFlags, 4);
1768 dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame();
1772 layer.gridSrb = rhiCtxD->srb(bindings);
1773 renderer.rhiQuadRenderer()->prepareQuad(rhiCtx,
nullptr);
1791 const bool hasValidTexture = lightProbeTexture.
m_texture !=
nullptr;
1792 if (hasValidTexture) {
1804 int samplerBinding = 1;
1805 const quint32 ubufSize = cameras.
count() >= 2 ? 416 : 240;
1820 float adjustY = rhi->
isYUpInNDC() ? 1.0f : -1.0f;
1821 const float exposure =
layer.lightProbeSettings.probeExposure;
1823 const QMatrix3x3 &rotationMatrix(
layer.lightProbeSettings.probeOrientation);
1824 const float blurAmount =
layer.skyboxBlurAmount;
1825 const float maxMipLevel = float(lightProbeTexture.
m_mipmapCount - 2);
1834 char *ubufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
1837 memcpy(ubufData + ubufOffset, &skyboxProperties, 16);
1840 memcpy(ubufData + ubufOffset, rotationMatrix.constData(), 12);
1842 memcpy(ubufData + ubufOffset, (
char *)rotationMatrix.constData() + 12, 12);
1844 memcpy(ubufData + ubufOffset, (
char *)rotationMatrix.constData() + 24, 12);
1847 for (
qsizetype viewIdx = 0; viewIdx < cameras.
count(); ++viewIdx) {
1848 const QMatrix4x4 &inverseProjection = cameras[viewIdx]->projection.inverted();
1849 const QMatrix4x4 &viewMatrix = cameras[viewIdx]->globalTransform;
1851 cameras[viewIdx]->calculateViewProjectionWithoutTranslation(0.1f, 5.0f, viewProjection);
1853 quint32 viewDataOffset = ubufOffset;
1854 memcpy(ubufData + viewDataOffset + viewIdx * 64, viewProjection.
constData(), 64);
1855 viewDataOffset += cameras.
count() * 64;
1856 memcpy(ubufData + viewDataOffset + viewIdx * 64, inverseProjection.constData(), 64);
1857 viewDataOffset += cameras.
count() * 64;
1858 memcpy(ubufData + viewDataOffset + viewIdx * 48, viewMatrix.constData(), 48);
1860 dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame();
1866 entry->m_skyBoxSrbs[cubeFaceIdx] = rhiCtxD->srb(bindings);
1868 layer.skyBoxSrb = rhiCtxD->srb(bindings);
1872 renderer.rhiCubeRenderer()->prepareCube(rhiCtx,
nullptr);
1874 renderer.rhiQuadRenderer()->prepareQuad(rhiCtx,
nullptr);
1919 static const auto rhiPrepareDepthPassForObject = [](
QSSGRhiContext *rhiCtx,
1931 if (isOpaqueDepthPrePass)
1935 if (
obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset ||
obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
1937 const void *modelNode = &subsetRenderable.modelContext.model;
1938 dcd = &rhiCtxD->drawCallData({ passKey, modelNode, &subsetRenderable.material, 0 });
1941 if (
obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset) {
1947 if (shaderPipeline) {
1948 shaderPipeline->ensureCombinedMainLightsUniformBuffer(&dcd->ubuf);
1949 char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
1951 dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
1955 }
else if (
obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
1962 QSSGCustomMaterialSystem &customMaterialSystem(*subsetRenderable.renderer->contextInterface()->customMaterialSystem().get());
1963 shaderPipeline = customMaterialSystem.
shadersForCustomMaterial(ps, customMaterial, subsetRenderable, inData.getDefaultMaterialPropertyTable(), featureSet);
1965 if (shaderPipeline) {
1966 shaderPipeline->ensureCombinedMainLightsUniformBuffer(&dcd->ubuf);
1967 char *ubufData = dcd->ubuf->beginFullDynamicBufferUpdateForCurrentFrame();
1969 inData.renderedCameras,
nullptr,
nullptr);
1970 dcd->ubuf->endFullDynamicBufferUpdateForCurrentFrame();
1977 if (
obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset ||
obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
1980 ia = subsetRenderable.subset.rhi.ia;
1992 if (isOpaqueDepthPrePass) {
1994 shaderPipeline.get(),
1995 subsetRenderable.firstImage,
1997 (
obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset));
2002 subsetRenderable.rhiRenderData.depthPrePass.pipeline = rhiCtxD->pipeline(*ps,
2005 subsetRenderable.rhiRenderData.depthPrePass.srb = srb;
2027 if (!rhiPrepareDepthPassForObject(rhiCtx, passKey, inData,
handle.obj, rpDesc, &ps))
2032 if (!rhiPrepareDepthPassForObject(rhiCtx, passKey, inData,
handle.obj, rpDesc, &ps))
2043 bool *needsSetViewport)
2045 static const auto rhiRenderDepthPassForImp = [](
QSSGRhiContext *rhiCtx,
2048 bool *needsSetViewport) {
2049 for (
const auto &oh : objects) {
2053 if (
obj->type == QSSGRenderableObject::Type::DefaultMaterialMeshSubset ||
obj->type == QSSGRenderableObject::Type::CustomMaterialMeshSubset) {
2057 QRhiBuffer *vertexBuffer = subsetRenderable->subset.
rhi.vertexBuffer->buffer();
2058 QRhiBuffer *indexBuffer = subsetRenderable->subset.
rhi.indexBuffer
2059 ? subsetRenderable->subset.rhi.indexBuffer->buffer()
2071 cb->setGraphicsPipeline(ps);
2072 cb->setShaderResources(srb);
2074 if (*needsSetViewport) {
2076 *needsSetViewport =
false;
2083 if (subsetRenderable->modelContext.model.instancing()) {
2084 instances = subsetRenderable->modelContext.model.instanceCount();
2090 cb->setVertexInput(0,
vertexBufferCount, vertexBuffers, indexBuffer, 0, subsetRenderable->subset.
rhi.indexBuffer->indexFormat());
2091 cb->drawIndexed(subsetRenderable->subset.count, instances, subsetRenderable->subset.offset);
2092 QSSGRHICTX_STAT(rhiCtx, drawIndexed(subsetRenderable->subset.count, instances));
2095 cb->draw(subsetRenderable->subset.count, instances, subsetRenderable->subset.offset);
2099 QVector<int>({subsetRenderable->modelContext.model.profilingId,
2100 subsetRenderable->material.profilingId}));
2105 rhiRenderDepthPassForImp(rhiCtx, pipelineState, sortedOpaqueObjects, needsSetViewport);
2106 rhiRenderDepthPassForImp(rhiCtx, pipelineState, sortedTransparentObjects, needsSetViewport);
2112 bool needsBuild =
false;
2114 if (!renderableTex->texture) {
2119 qWarning(
"Depth texture not supported");
2126 }
else if (renderableTex->texture->pixelSize() !=
size) {
2132 if (!renderableTex->texture->create()) {
2133 qWarning(
"Failed to build depth texture (size %dx%d, format %d)",
2134 size.width(),
size.height(),
int(renderableTex->texture->format()));
2135 renderableTex->reset();
2138 renderableTex->resetRenderTarget();
2143 renderableTex->rpDesc = renderableTex->rt->newCompatibleRenderPassDescriptor();
2144 renderableTex->rt->setRenderPassDescriptor(renderableTex->rpDesc);
2145 if (!renderableTex->rt->create()) {
2146 qWarning(
"Failed to build render target for depth texture");
2147 renderableTex->reset();
The QMatrix4x4 class represents a 4x4 transformation matrix in 3D space.
float * data()
Returns a pointer to the raw data of this matrix.
QMatrix4x4 inverted(bool *invertible=nullptr) const
Returns the inverse of this matrix.
const float * constData() const
Returns a constant pointer to the raw data of this matrix.
The QQuaternion class represents a quaternion consisting of a vector and scalar.
\inmodule QtCore\reentrant
virtual char * beginFullDynamicBufferUpdateForCurrentFrame()
virtual bool create()=0
Creates the corresponding native graphics resources.
void resourceUpdate(QRhiResourceUpdateBatch *resourceUpdates)
Sometimes committing resource updates is necessary or just more convenient without starting a render ...
QPair< QRhiBuffer *, quint32 > VertexInput
Synonym for QPair<QRhiBuffer *, quint32>.
void setRenderPassDescriptor(QRhiRenderPassDescriptor *desc)
Sets the QRhiRenderPassDescriptor desc for use with this render target.
void setName(const QByteArray &name)
Sets a name for the object.
Filter
Specifies the minification, magnification, or mipmap filtering.
void setDepthTexture(QRhiTexture *texture)
Sets the texture for depth-stencil.
virtual QRhiRenderPassDescriptor * newCompatibleRenderPassDescriptor()=0
Format
Specifies the texture format.
void setPixelSize(const QSize &sz)
Sets the texture size, specified in pixels, to sz.
\inmodule QtGuiPrivate \inheaderfile rhi/qrhi.h
QRhiBuffer * newBuffer(QRhiBuffer::Type type, QRhiBuffer::UsageFlags usage, quint32 size)
bool isClipDepthZeroToOne() const
bool isTextureFormatSupported(QRhiTexture::Format format, QRhiTexture::Flags flags={}) const
QRhiTexture * newTextureArray(QRhiTexture::Format format, int arraySize, const QSize &pixelSize, int sampleCount=1, QRhiTexture::Flags flags={})
QMatrix4x4 clipSpaceCorrMatrix() const
bool isYUpInFramebuffer() const
bool isFeatureSupported(QRhi::Feature feature) const
QRhiRenderBuffer * newRenderBuffer(QRhiRenderBuffer::Type type, const QSize &pixelSize, int sampleCount=1, QRhiRenderBuffer::Flags flags={}, QRhiTexture::Format backingFormatHint=QRhiTexture::UnknownFormat)
QRhiTextureRenderTarget * newTextureRenderTarget(const QRhiTextureRenderTargetDescription &desc, QRhiTextureRenderTarget::Flags flags={})
QRhiTexture * newTexture(QRhiTexture::Format format, const QSize &pixelSize, int sampleCount=1, QRhiTexture::Flags flags={})
QRhiResourceUpdateBatch * nextResourceUpdateBatch()
static constexpr QSSGRenderTextureCubeFace next(QSSGRenderTextureCubeFace face)
static constexpr QSSGRenderTextureCubeFaceT indexOfCubeFace(QSSGRenderTextureCubeFace face) noexcept
Class representing 3D range or axis aligned bounding box.
void include(const QVector3D &v)
expands the volume to include v
void updateUniformsForCustomMaterial(QSSGRhiShaderPipeline &shaderPipeline, QSSGRhiContext *rhiCtx, const QSSGLayerRenderData &inData, char *ubufData, QSSGRhiGraphicsPipelineState *ps, const QSSGRenderCustomMaterial &material, QSSGSubsetRenderable &renderable, const QSSGRenderCameraList &cameras, const QVector2D *depthAdjust, const QMatrix4x4 *alteredModelViewProjection)
void rhiRenderRenderable(QSSGRhiContext *rhiCtx, QSSGSubsetRenderable &renderable, bool *needsSetViewport, QSSGRenderTextureCubeFace cubeFace, const QSSGRhiGraphicsPipelineState &state)
QSSGRhiShaderPipelinePtr shadersForCustomMaterial(QSSGRhiGraphicsPipelineState *ps, const QSSGRenderCustomMaterial &material, QSSGSubsetRenderable &renderable, const QSSGShaderDefaultMaterialKeyProperties &defaultMaterialShaderKeyProperties, const QSSGShaderFeatures &featureSet)
void rhiPrepareRenderable(QSSGRhiGraphicsPipelineState *ps, QSSGPassKey passKey, QSSGSubsetRenderable &renderable, const QSSGShaderFeatures &featureSet, const QSSGRenderCustomMaterial &material, const QSSGLayerRenderData &layerData, QRhiRenderPassDescriptor *renderPassDescriptor, int samples, int viewCount, QSSGRenderCamera *camera=nullptr, QSSGRenderTextureCubeFace cubeFace=QSSGRenderTextureCubeFaceNone, QMatrix4x4 *modelViewProjection=nullptr, QSSGReflectionMapEntry *entry=nullptr)
static QSSGGraphicsPipelineStateKey create(const QSSGRhiGraphicsPipelineState &state, const QRhiRenderPassDescriptor *rpDesc, const QRhiShaderResourceBindings *srb)
static QSSGLayerRenderData * getCurrent(const QSSGRenderer &renderer)
static bool prepareInstancing(QSSGRhiContext *rhiCtx, QSSGSubsetRenderable *renderable, const QVector3D &cameraDirection, const QVector3D &cameraPosition, float minThreshold, float maxThreshold)
static void updateUniformsForParticleModel(QSSGRhiShaderPipeline &shaderPipeline, char *ubufData, const QSSGRenderModel *model, quint32 offset)
static void rhiPrepareRenderable(QSSGRhiShaderPipeline &shaderPipeline, QSSGPassKey passKey, QSSGRhiContext *rhiCtx, QSSGRhiGraphicsPipelineState *ps, QSSGParticlesRenderable &renderable, const QSSGLayerRenderData &inData, QRhiRenderPassDescriptor *renderPassDescriptor, int samples, int viewCount, QSSGRenderCamera *alteredCamera=nullptr, QSSGRenderTextureCubeFace cubeFace=QSSGRenderTextureCubeFaceNone, QSSGReflectionMapEntry *entry=nullptr)
static void rhiRenderRenderable(QSSGRhiContext *rhiCtx, QSSGParticlesRenderable &renderable, bool *needsSetViewport, QSSGRenderTextureCubeFace cubeFace, const QSSGRhiGraphicsPipelineState &state)
static void prepareParticlesForModel(QSSGRhiShaderPipeline &shaderPipeline, QSSGRhiContext *rhiCtx, QSSGRhiShaderResourceBindingList &bindings, const QSSGRenderModel *model)
QSSGReflectionMapEntry * reflectionMapEntry(int probeIdx)
QSSGShadowMapEntry * shadowMapEntry(int lightIdx)
static QSSGRhiShaderPipelinePtr getShaderPipelineForDefaultMaterial(QSSGRenderer &renderer, QSSGSubsetRenderable &inRenderable, const QSSGShaderFeatures &inFeatureSet)
static QSSGRhiContextPrivate * get(QSSGRhiContext *q)
int mainPassViewCount() const
Returns the multiview count used in the main render pass.
QRhiCommandBuffer * commandBuffer() const
QRhiTexture * dummyTexture(QRhiTexture::Flags flags, QRhiResourceUpdateBatch *rub, const QSize &size=QSize(64, 64), const QColor &fillColor=Qt::black, int arraySize=0)
void checkAndAdjustForNPoT(QRhiTexture *texture, QSSGRhiSamplerDescription *samplerDescription)
Adjusts samplerDescription's tiling and filtering modes based on the pixel size of texture.
QRhiCommandBuffer::BeginPassFlags commonPassFlags() const
QRhiSampler * sampler(const QSSGRhiSamplerDescription &samplerDescription)
QRhiGraphicsPipeline::CullMode cullMode
QRhiGraphicsPipeline::TargetBlend targetBlend
QRhiTexture * ssaoTexture() const
const QRhiShaderStage * fragmentStage() const
QRhiTexture * depthTexture() const
int bindingForTexture(const char *name, int hint=-1)
int extraTextureCount() const
const QRhiShaderStage * vertexStage() const
const QSSGRhiTexture & extraTextureAt(int index) const
void addUniformBuffer(int binding, QRhiShaderResourceBinding::StageFlags stage, QRhiBuffer *buf, int offset=0, int size=0)
void addTexture(int binding, QRhiShaderResourceBinding::StageFlags stage, QRhiTexture *tex, QRhiSampler *sampler)
const_iterator cend() const noexcept
QList< InOutVariable > combinedImageSamplers() const
QShaderDescription description() const
constexpr int height() const noexcept
Returns the height.
constexpr int width() const noexcept
Returns the width.
constexpr size_type size() const noexcept
The QVector2D class represents a vector or vertex in 2D space.
The QVector3D class represents a vector or vertex in 3D space.
QVector3D normalized() const noexcept
Returns the normalized unit vector form of this vector.
constexpr float y() const noexcept
Returns the y coordinate of this point.
static constexpr float dotProduct(QVector3D v1, QVector3D v2) noexcept
Returns the dot product of v1 and v2.
static constexpr QVector3D crossProduct(QVector3D v1, QVector3D v2) noexcept
Returns the cross-product of vectors v1 and v2, which is normal to the plane spanned by v1 and v2.
The QVector4D class represents a vector or vertex in 4D space.
QMap< QString, QString > map
[6]
QSet< QString >::iterator it
QRhiGraphicsPipeline::CullMode toCullMode(QSSGCullFaceMode cullFaceMode)
void bakeVertexInputLocations(QSSGRhiInputAssemblerState *ia, const QSSGRhiShaderPipeline &shaders, int instanceBufferBinding)
QRhiSampler::Filter toRhi(QSSGRenderTextureFilterOp op)
Combined button and popup list for selecting options.
constexpr Initialization Uninitialized
void rhiPrepareGrid(QSSGRhiContext *rhiCtx, QSSGPassKey passKey, QSSGRenderLayer &layer, QSSGRenderCameraList &cameras, QSSGRenderer &renderer)
bool rhiPrepareScreenTexture(QSSGRhiContext *rhiCtx, const QSize &size, bool wantsMips, QSSGRhiRenderableTexture *renderableTex)
void rhiPrepareSkyBoxForReflectionMap(QSSGRhiContext *rhiCtx, QSSGPassKey passKey, QSSGRenderLayer &layer, QSSGRenderCamera &inCamera, QSSGRenderer &renderer, QSSGReflectionMapEntry *entry, QSSGRenderTextureCubeFace cubeFace)
void rhiRenderAoTexture(QSSGRhiContext *rhiCtx, QSSGPassKey passKey, QSSGRenderer &renderer, QSSGRhiShaderPipeline &shaderPipeline, QSSGRhiGraphicsPipelineState &ps, const QSSGAmbientOcclusionSettings &ao, const QSSGRhiRenderableTexture &rhiAoTexture, const QSSGRhiRenderableTexture &rhiDepthTexture, const QSSGRenderCamera &camera)
std::pair< QSSGBoxPoints, QSSGBoxPoints > calculateSortedObjectBounds(const QSSGRenderableObjectList &sortedOpaqueObjects, const QSSGRenderableObjectList &sortedTransparentObjects)
bool rhiPrepareAoTexture(QSSGRhiContext *rhiCtx, const QSize &size, QSSGRhiRenderableTexture *renderableTex)
bool rhiPrepareDepthTexture(QSSGRhiContext *rhiCtx, const QSize &size, QSSGRhiRenderableTexture *renderableTex)
Q_QUICK3DRUNTIMERENDER_EXPORT void rhiRenderRenderable(QSSGRhiContext *rhiCtx, const QSSGRhiGraphicsPipelineState &state, QSSGRenderableObject &object, bool *needsSetViewport, QSSGRenderTextureCubeFace cubeFace=QSSGRenderTextureCubeFaceNone)
void rhiRenderShadowMap(QSSGRhiContext *rhiCtx, QSSGPassKey passKey, QSSGRhiGraphicsPipelineState &ps, QSSGRenderShadowMap &shadowMapManager, const QSSGRenderCamera &camera, const QSSGShaderLightList &globalLights, const QSSGRenderableObjectList &sortedOpaqueObjects, QSSGRenderer &renderer, const QSSGBoxPoints &castingObjectsBox, const QSSGBoxPoints &receivingObjectsBox)
bool rhiPrepareDepthPass(QSSGRhiContext *rhiCtx, QSSGPassKey passKey, const QSSGRhiGraphicsPipelineState &basePipelineState, QRhiRenderPassDescriptor *rpDesc, QSSGLayerRenderData &inData, const QSSGRenderableObjectList &sortedOpaqueObjects, const QSSGRenderableObjectList &sortedTransparentObjects, int samples, int viewCount)
void rhiPrepareSkyBox(QSSGRhiContext *rhiCtx, QSSGPassKey passKey, QSSGRenderLayer &layer, QSSGRenderCameraList &cameras, QSSGRenderer &renderer)
Q_QUICK3DRUNTIMERENDER_EXPORT void rhiPrepareRenderable(QSSGRhiContext *rhiCtx, QSSGPassKey passKey, const QSSGLayerRenderData &inData, QSSGRenderableObject &inObject, QRhiRenderPassDescriptor *renderPassDescriptor, QSSGRhiGraphicsPipelineState *ps, QSSGShaderFeatures featureSet, int samples, int viewCount, QSSGRenderCamera *alteredCamera=nullptr, QMatrix4x4 *alteredModelViewProjection=nullptr, QSSGRenderTextureCubeFace cubeFace=QSSGRenderTextureCubeFaceNone, QSSGReflectionMapEntry *entry=nullptr)
void rhiRenderReflectionMap(QSSGRhiContext *rhiCtx, QSSGPassKey passKey, const QSSGLayerRenderData &inData, QSSGRhiGraphicsPipelineState *ps, QSSGRenderReflectionMap &reflectionMapManager, const QVector< QSSGRenderReflectionProbe * > &reflectionProbes, const QSSGRenderableObjectList &reflectionPassObjects, QSSGRenderer &renderer)
void rhiRenderDepthPass(QSSGRhiContext *rhiCtx, const QSSGRhiGraphicsPipelineState &ps, const QSSGRenderableObjectList &sortedOpaqueObjects, const QSSGRenderableObjectList &sortedTransparentObjects, bool *needsSetViewport)
static const int UBUF_SIZE
#define QByteArrayLiteral(str)
bool qFuzzyCompare(qfloat16 p1, qfloat16 p2) noexcept
constexpr float qRadiansToDegrees(float radians)
constexpr float qDegreesToRadians(float degrees)
constexpr const T & qMin(const T &a, const T &b)
constexpr const T & qMax(const T &a, const T &b)
constexpr T qAbs(const T &t)
GLsizei const GLfloat * v
[13]
GLuint64 GLenum void * handle
GLenum GLuint GLintptr GLsizeiptr size
[1]
GLenum GLuint GLenum GLsizei length
const void GLsizei GLsizei stride
GLint GLsizei GLsizei GLenum format
GLfixed GLfixed GLint GLint GLfixed points
GLenum GLenum GLenum GLenum GLenum scale
const void GLsizei GLsizei GLint vertexBufferCount
#define Q_QUICK3D_PROFILE_START(Type)
#define QSSG_RENDERPASS_NAME(passName, level, face)
#define Q_QUICK3D_PROFILE_END_WITH_STRING(Type, Payload, Str)
#define Q_QUICK3D_PROFILE_END_WITH_IDS(Type, Payload, POIDs)
static qreal position(const QQuickItem *item, QQuickAnchors::Anchor anchorLine)
#define QSSG_ASSERT(cond, action)
std::array< QVector3D, 8 > QSSGBoxPoints
QSSGDataView< T > toDataView(const T &type)
std::array< QMatrix4x4, 2 > QSSGRenderMvpArray
static constexpr QSSGRenderTextureCubeFace QSSGRenderTextureCubeFaces[]
QSSGRenderTextureCubeFace
constexpr QSSGRenderTextureCubeFace QSSGRenderTextureCubeFaceNone
#define QSSGRHICTX_STAT(ctx, f)
std::shared_ptr< QSSGRhiShaderPipeline > QSSGRhiShaderPipelinePtr
SSL_CTX int(* cb)(SSL *ssl, unsigned char **out, unsigned char *outlen, const unsigned char *in, unsigned int inlen, void *arg)
unsigned long long quint64
static void rhiPrepareSkyBox_helper(QSSGRhiContext *rhiCtx, QSSGPassKey passKey, QSSGRenderLayer &layer, QSSGRenderCameraList &cameras, QSSGRenderer &renderer, QSSGReflectionMapEntry *entry=nullptr, QSSGRenderTextureCubeFace cubeFace=QSSGRenderTextureCubeFaceNone)
static QSSGBounds3 calculateShadowCameraBoundingBox(const QSSGBoxPoints &points, const QVector3D &forward, const QVector3D &up, const QVector3D &right)
static const QRhiShaderResourceBinding::StageFlags RENDERER_VISIBILITY_ALL
static QT_BEGIN_NAMESPACE constexpr float QSSG_PI
static void setupCameraForShadowMap(const QSSGRenderCamera &inCamera, const QSSGRenderLight *inLight, QSSGRenderCamera &theCamera, const QSSGBoxPoints &castingBox, const QSSGBoxPoints &receivingBox)
static void setupCubeReflectionCameras(const QSSGRenderReflectionProbe *inProbe, QSSGRenderCamera inCameras[6])
static void rhiPrepareResourcesForReflectionMap(QSSGRhiContext *rhiCtx, QSSGPassKey passKey, const QSSGLayerRenderData &inData, QSSGReflectionMapEntry *pEntry, QSSGRhiGraphicsPipelineState *ps, const QSSGRenderableObjectList &sortedOpaqueObjects, QSSGRenderCamera &inCamera, QSSGRenderer &renderer, QSSGRenderTextureCubeFace cubeFace)
static QVector3D calcCenter(const QSSGBoxPoints &vertices)
static void updateUniformsForDefaultMaterial(QSSGRhiShaderPipeline &shaderPipeline, QSSGRhiContext *rhiCtx, const QSSGLayerRenderData &inData, char *ubufData, QSSGRhiGraphicsPipelineState *ps, QSSGSubsetRenderable &subsetRenderable, const QSSGRenderCameraList &cameras, const QVector2D *depthAdjust, const QMatrix4x4 *alteredModelViewProjection)
static void addDepthTextureBindings(QSSGRhiContext *rhiCtx, QSSGRhiShaderPipeline *shaderPipeline, QSSGRhiShaderResourceBindingList &bindings)
static void addOpaqueDepthPrePassBindings(QSSGRhiContext *rhiCtx, QSSGRhiShaderPipeline *shaderPipeline, QSSGRenderableImage *renderableImage, QSSGRhiShaderResourceBindingList &bindings, bool isCustomMaterialMeshSubset=false)
static constexpr float QSSG_HALFPI
static QSSGRhiShaderPipelinePtr shadersForDefaultMaterial(QSSGRhiGraphicsPipelineState *ps, QSSGSubsetRenderable &subsetRenderable, const QSSGShaderFeatures &featureSet)
static QSSGRhiShaderPipelinePtr shadersForParticleMaterial(QSSGRhiGraphicsPipelineState *ps, QSSGParticlesRenderable &particleRenderable)
static void rhiPrepareResourcesForShadowMap(QSSGRhiContext *rhiCtx, const QSSGLayerRenderData &inData, QSSGPassKey passKey, QSSGShadowMapEntry *pEntry, QSSGRhiGraphicsPipelineState *ps, const QVector2D *depthAdjust, const QSSGRenderableObjectList &sortedOpaqueObjects, QSSGRenderCamera &inCamera, bool orthographic, QSSGRenderTextureCubeFace cubeFace)
static void setupCubeShadowCameras(const QSSGRenderLight *inLight, QSSGRenderCamera inCameras[6])
static QSSGBoxPoints computeFrustumBounds(const QSSGRenderCamera &inCamera)
static int setupInstancing(QSSGSubsetRenderable *renderable, QSSGRhiGraphicsPipelineState *ps, QSSGRhiContext *rhiCtx, const QVector3D &cameraDirection, const QVector3D &cameraPosition)
static void fillTargetBlend(QRhiGraphicsPipeline::TargetBlend *targetBlend, QSSGRenderDefaultMaterial::MaterialBlendMode materialBlend)
myFilter draw(painter, QPoint(0, 0), originalPixmap)
QSvgRenderer * renderer
[0]
static const char * getSamplerName(QSSGRenderableImage::Type type)
static void setRhiMaterialProperties(const QSSGRenderContextInterface &, QSSGRhiShaderPipeline &shaders, char *ubufData, QSSGRhiGraphicsPipelineState *inPipelineState, const QSSGRenderGraphObject &inMaterial, const QSSGShaderDefaultMaterialKey &inKey, const QSSGShaderDefaultMaterialKeyProperties &inProperties, const QSSGRenderCameraList &inCameras, const QSSGRenderMvpArray &inModelViewProjections, const QMatrix3x3 &inNormalMatrix, const QMatrix4x4 &inGlobalTransform, const QMatrix4x4 &clipSpaceCorrMatrix, const QMatrix4x4 &localInstanceTransform, const QMatrix4x4 &globalInstanceTransform, const QSSGDataView< float > &inMorphWeights, QSSGRenderableImage *inFirstImage, float inOpacity, const QSSGLayerRenderData &inRenderProperties, const QSSGShaderLightListView &inLights, const QSSGShaderReflectionProbe &reflectionProbe, bool receivesShadows, bool receivesReflections, const QVector2D *shadowDepthAdjust, QRhiTexture *lightmapTexture)
QSSGRenderImage * m_iblProbe
QSSGCullFaceMode cullMode
QSSGRenderImageTextureFlags m_flags
static constexpr QVector3D initScale
static QMatrix4x4 calculateTransformMatrix(QVector3D position, QVector3D scale, QVector3D pivot, QQuaternion rotation)
static void setShaderPipeline(QSSGRhiGraphicsPipelineState &ps, const QSSGRhiShaderPipeline *pipeline)
QRhiTextureRenderTarget * rt
\variable QSSGRhiGraphicsPipelineState::depthFunc
constexpr bool isSet(Feature feature) const
void set(Feature feature, bool val)
void disableTonemapping()