qssgrhiparticles.cpp

++ // Copyright (C) 2021 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

++ // Qt-Security score:significant reason:default

++

++

++ #include "qssgrhiparticles_p.h"

++ #include "qssgrhicontext_p.h"

++

++ #include <qfloat16.h>

++

++ #include <QtQuick3DUtils/private/qssgutils_p.h>

++

++ #include <QtQuick3DRuntimeRender/private/qssgrenderer_p.h>

++ #include <QtQuick3DRuntimeRender/private/qssgrendercamera_p.h>

++ #include <QtQuick3DRuntimeRender/private/qssglayerrenderdata_p.h>

++ #include <QtQuick3DRuntimeRender/private/qssgrenderhelpers_p.h>

++ #include <QtQuick3DRuntimeRender/private/qssgshaderresourcemergecontext_p.h>

++

++ #include <ssg/qssgrendercontextcore.h>

++ #include "qssgrendershadercodegenerator_p.h"

++

++ #include "qtquick3d_tracepoints_p.h"

++

++ QT_BEGIN_NAMESPACE

++

++ static const QRhiShaderResourceBinding::StageFlags VISIBILITY_ALL =

++         QRhiShaderResourceBinding::VertexStage | QRhiShaderResourceBinding::FragmentStage;

++

++ struct ParticleLightData

++ {

++     QVector4D pointLightPos[4];

++     float pointLightConstantAtt[4] = {1.0f, 1.0f, 1.0f, 1.0f};

++     float pointLightLinearAtt[4] = {0.0f};

++     float pointLightQuadAtt[4] = {0.0f};

++     QVector4D pointLightColor[4];

++     QVector4D spotLightPos[4];

++     float spotLightConstantAtt[4] = {1.0f, 1.0f, 1.0f, 1.0f};

++     float spotLightLinearAtt[4] = {0.0f};

++     float spotLightQuadAtt[4] = {0.0f};

++     QVector4D spotLightColor[4];

++     QVector4D spotLightDir[4];

++     float spotLightConeAngle[4] = {0.0f};

++     float spotLightInnerConeAngle[4] = {0.0f};

++ };

++

++ static bool s_shaderCacheEnabled = true;

++ void QSSGParticleRenderer::setShaderCacheEnabled(bool enabled)

++ {

++     s_shaderCacheEnabled = enabled;

++ }

++

++ void QSSGParticleRenderer::updateUniformsForParticles(const QSSGLayerRenderData &inData,

++                                                       QSSGRhiShaderPipeline &shaders,

++                                                       QSSGRhiContext *rhiCtx,

++                                                       char *ubufData,

++                                                       QSSGParticlesRenderable &renderable,

++                                                       const QSSGRenderCameraList &cameras)

++ {

++     const QMatrix4x4 clipSpaceCorrMatrix = rhiCtx->rhi()->clipSpaceCorrMatrix();

++

++     QSSGRhiShaderPipeline::CommonUniformIndices &cui = shaders.commonUniformIndices;

++

++     const int viewCount = cameras.count();

++

++     // Pull the camera transforms from the render data once.

++     QMatrix4x4 camGlobalTransforms[2] { QMatrix4x4{Qt::Uninitialized}, QMatrix4x4{Qt::Uninitialized} };

++     if (viewCount < 2) {

++         camGlobalTransforms[0] = inData.getGlobalTransform(*cameras[0]);

++     } else {

++         for (size_t viewIndex = 0; viewIndex != std::size(camGlobalTransforms); ++viewIndex)

++             camGlobalTransforms[viewIndex] = inData.getGlobalTransform(*cameras[viewIndex]);

++     }

++

++     if (viewCount < 2) {

++         const QMatrix4x4 projection = clipSpaceCorrMatrix * cameras[0]->projection;

++         shaders.setUniform(ubufData, "qt_projectionMatrix", projection.constData(), 16 * sizeof(float), &cui.projectionMatrixIdx);

++         const QMatrix4x4 viewMatrix = camGlobalTransforms[0].inverted();

++         shaders.setUniform(ubufData, "qt_viewMatrix", viewMatrix.constData(), 16 * sizeof(float), &cui.viewMatrixIdx);

++     } else {

++         QVarLengthArray<QMatrix4x4, 2> projectionMatrices(viewCount);

++         QVarLengthArray<QMatrix4x4, 2> viewMatrices(viewCount);

++         for (int viewIndex = 0; viewIndex < viewCount; ++viewIndex) {

++             projectionMatrices[viewIndex] = clipSpaceCorrMatrix * cameras[viewIndex]->projection;

++             viewMatrices[viewIndex] = camGlobalTransforms[viewIndex].inverted();

++         }

++         shaders.setUniformArray(ubufData, "qt_projectionMatrix", projectionMatrices.constData(), viewCount, QSSGRenderShaderValue::Matrix4x4, &cui.projectionMatrixIdx);

++         shaders.setUniformArray(ubufData, "qt_viewMatrix", viewMatrices.constData(), viewCount, QSSGRenderShaderValue::Matrix4x4, &cui.viewMatrixIdx);

++     }

++

++     const QMatrix4x4 &modelMatrix = renderable.globalTransform;

++     shaders.setUniform(ubufData, "qt_modelMatrix", modelMatrix.constData(), 16 * sizeof(float), &cui.modelMatrixIdx);

++

++     const QVector2D camProperties(cameras[0]->clipPlanes);

++     shaders.setUniform(ubufData, "qt_cameraProperties", &camProperties, 2 * sizeof(float), &cui.cameraPropertiesIdx);

++

++     QVector2D oneOverSize = QVector2D(1.0f, 1.0f);

++     auto &particleBuffer = renderable.particles.m_particleBuffer;

++     const quint32 particlesPerSlice = particleBuffer.particlesPerSlice();

++     oneOverSize = QVector2D(1.0f / particleBuffer.size().width(), 1.0f / particleBuffer.size().height());

++     shaders.setUniform(ubufData, "qt_oneOverParticleImageSize", &oneOverSize, 2 * sizeof(float));

++     shaders.setUniform(ubufData, "qt_countPerSlice", &particlesPerSlice, 1 * sizeof(quint32));

++

++     // Global opacity of the particles node

++     shaders.setUniform(ubufData, "qt_opacity", &renderable.opacity, 1 * sizeof(float));

++

++     float blendImages = renderable.particles.m_blendImages ? 1.0f : 0.0f;

++     float imageCount = float(renderable.particles.m_spriteImageCount);

++     float ooImageCount = 1.0f / imageCount;

++

++     QVector4D spriteConfig(imageCount, ooImageCount, 0.0f, blendImages);

++     shaders.setUniform(ubufData, "qt_spriteConfig", &spriteConfig, 4 * sizeof(float));

++

++     const float billboard = renderable.particles.m_billboard ? 1.0f : 0.0f;

++     shaders.setUniform(ubufData, "qt_billboard", &billboard, 1 * sizeof(float));

++

++     // Lights

++     QVector3D theLightAmbientTotal;

++     bool hasLights = !renderable.particles.m_lights.isEmpty();

++     int pointLight = 0;

++     int spotLight = 0;

++     if (hasLights) {

++         ParticleLightData lightData;

++         auto &lights = renderable.lights;

++         for (quint32 lightIdx = 0, lightEnd = lights.size();

++              lightIdx < lightEnd && lightIdx < QSSG_MAX_NUM_LIGHTS; ++lightIdx) {

++             QSSGRenderLight *theLight(lights[lightIdx].light);

++             // Ignore lights which are not specified for the particle

++             if (!renderable.particles.m_lights.contains(theLight))

++                 continue;

++

++             const QMatrix4x4 lightGlobalTransform = inData.getGlobalTransform(*theLight);

++

++             if (theLight->type == QSSGRenderLight::Type::DirectionalLight) {

++                 theLightAmbientTotal += theLight->m_diffuseColor * theLight->m_brightness;

++             } else if (theLight->type == QSSGRenderLight::Type::PointLight && pointLight < 4) {

++                 lightData.pointLightColor[pointLight] = QVector4D(theLight->m_diffuseColor * theLight->m_brightness, 1.0f);

++                 lightData.pointLightPos[pointLight] = QVector4D(QSSGRenderNode::getGlobalPos(lightGlobalTransform), 1.0f);

++                 lightData.pointLightConstantAtt[pointLight] = QSSGUtils::aux::translateConstantAttenuation(theLight->m_constantFade);

++                 lightData.pointLightLinearAtt[pointLight] = QSSGUtils::aux::translateLinearAttenuation(theLight->m_linearFade);

++                 lightData.pointLightQuadAtt[pointLight] = QSSGUtils::aux::translateQuadraticAttenuation(theLight->m_quadraticFade);

++                 pointLight++;

++             } else if (theLight->type == QSSGRenderLight::Type::SpotLight && spotLight < 4) {

++                 lightData.spotLightColor[spotLight] = QVector4D(theLight->m_diffuseColor * theLight->m_brightness, 1.0f);

++                 lightData.spotLightPos[spotLight] = QVector4D(QSSGRenderNode::getGlobalPos(lightGlobalTransform), 1.0f);

++                 lightData.spotLightDir[spotLight] = QVector4D(lights[lightIdx].direction, 0.0f);

++                 lightData.spotLightConstantAtt[spotLight] = QSSGUtils::aux::translateConstantAttenuation(theLight->m_constantFade);

++                 lightData.spotLightLinearAtt[spotLight] = QSSGUtils::aux::translateLinearAttenuation(theLight->m_linearFade);

++                 lightData.spotLightQuadAtt[spotLight] = QSSGUtils::aux::translateQuadraticAttenuation(theLight->m_quadraticFade);

++                 float coneAngle = theLight->m_coneAngle;

++                 // Inner cone angle must always be < cone angle, to not have possible undefined behavior for shader smoothstep

++                 float innerConeAngle = std::min(theLight->m_innerConeAngle, coneAngle - 0.01f);

++                 lightData.spotLightConeAngle[spotLight] = qDegreesToRadians(coneAngle);

++                 lightData.spotLightInnerConeAngle[spotLight] = qDegreesToRadians(innerConeAngle);

++                 spotLight++;

++             }

++             theLightAmbientTotal += theLight->m_ambientColor;

++         }

++         // Copy light data

++         int lightOffset = shaders.offsetOfUniform("lightData");

++         if (lightOffset >= 0)

++             memcpy(ubufData + lightOffset, &lightData, sizeof(ParticleLightData));

++     }

++     shaders.setUniform(ubufData, "qt_light_ambient_total", &theLightAmbientTotal, 3 * sizeof(float), &cui.light_ambient_totalIdx);

++     int enablePointLights = pointLight > 0 ? 1 : 0;

++     int enableSpotLights = spotLight > 0 ? 1 : 0;

++     shaders.setUniform(ubufData, "qt_pointLights", &enablePointLights, sizeof(int));

++     shaders.setUniform(ubufData, "qt_spotLights", &enableSpotLights, sizeof(int));

++

++     // Line particle uniform

++     int segmentCount = particleBuffer.segments();

++     if (segmentCount) {

++         shaders.setUniform(ubufData, "qt_lineSegmentCount", &segmentCount, sizeof(int));

++         float alphaFade = renderable.particles.m_alphaFade;

++         float sizeModifier = renderable.particles.m_sizeModifier;

++         float texcoordScale = renderable.particles.m_texcoordScale;

++         auto image = renderable.firstImage;

++         if (image && image->m_texture.m_texture) {

++             const auto size = image->m_texture.m_texture->pixelSize();

++             texcoordScale *= float(size.height()) / float(size.width());

++         }

++         shaders.setUniform(ubufData, "qt_alphaFade", &alphaFade, sizeof(float));

++         shaders.setUniform(ubufData, "qt_sizeModifier", &sizeModifier, sizeof(float));

++         shaders.setUniform(ubufData, "qt_texcoordScale", &texcoordScale, sizeof(float));

++     }

++

++ #ifdef QSSG_OIT_USE_BUFFERS

++     shaders.setOITImages((QRhiTexture*)inData.oitRenderContext.aBuffer,

++                          (QRhiTexture*)inData.oitRenderContext.auxBuffer,

++                          (QRhiTexture*)inData.oitRenderContext.counterBuffer);

++     if (inData.oitRenderContext.aBuffer) {

++         int abufWidth = 0;

++         int listNodeCount = inData.layer.oitNodeCount;

++ #else

++     const QSSGRhiRenderableTexture *abuf = inData.getRenderResult(QSSGRenderResult::Key::ABufferImage);

++     const QSSGRhiRenderableTexture *aux = inData.getRenderResult(QSSGRenderResult::Key::AuxiliaryImage);

++     const QSSGRhiRenderableTexture *counter = inData.getRenderResult(QSSGRenderResult::Key::CounterImage);

++     shaders.setOITImages(abuf->texture, aux->texture, counter->texture);

++     if (abuf->texture) {

++         int abufWidth = RenderHelpers::rhiCalculateABufferSize(inData.layer.oitNodeCount);

++         int listNodeCount = abufWidth * abufWidth;

++ #endif

++         shaders.setUniform(ubufData, "qt_ABufImageWidth", &abufWidth, sizeof(int), &cui.abufImageWidth);

++         shaders.setUniform(ubufData, "qt_listNodeCount", &listNodeCount, sizeof(int), &cui.listNodeCount);

++         int viewSize[2] = {inData.layerPrepResult.textureDimensions().width(), inData.layerPrepResult.textureDimensions().height()};

++         shaders.setUniform(ubufData, "qt_viewSize", viewSize, sizeof(int) * 2, &cui.viewSize);

++         int samples = rhiCtx->mainPassSampleCount();

++         shaders.setUniform(ubufData, "qt_samples", &samples, sizeof(int), &cui.samples);

++     }

++

++ }

++

++ void QSSGParticleRenderer::updateUniformsForParticleModel(QSSGRhiShaderPipeline &shaderPipeline,

++                                                           char *ubufData,

++                                                           const QSSGRenderModel *model,

++                                                           quint32 offset)

++ {

++     auto &particleBuffer = *model->particleBuffer;

++     const quint32 particlesPerSlice = particleBuffer.particlesPerSlice();

++     const QVector2D oneOverSize = QVector2D(1.0f / particleBuffer.size().width(), 1.0f / particleBuffer.size().height());

++     shaderPipeline.setUniform(ubufData, "qt_oneOverParticleImageSize", &oneOverSize, 2 * sizeof(float));

++     shaderPipeline.setUniform(ubufData, "qt_countPerSlice", &particlesPerSlice, sizeof(quint32));

++     const QMatrix4x4 &particleMatrix = model->particleMatrix;

++     shaderPipeline.setUniform(ubufData, "qt_particleMatrix", &particleMatrix, 16 * sizeof(float));

++     shaderPipeline.setUniform(ubufData, "qt_particleIndexOffset", &offset, sizeof(quint32));

++ }

++

++ static void fillTargetBlend(QRhiGraphicsPipeline::TargetBlend &targetBlend, QSSGRenderParticles::BlendMode mode)

++ {

++     switch (mode) {

++     case QSSGRenderParticles::BlendMode::Screen:

++         targetBlend.srcColor = QRhiGraphicsPipeline::SrcAlpha;

++         targetBlend.dstColor = QRhiGraphicsPipeline::One;

++         targetBlend.srcAlpha = QRhiGraphicsPipeline::One;

++         targetBlend.dstAlpha = QRhiGraphicsPipeline::One;

++         break;

++     case QSSGRenderParticles::BlendMode::Multiply:

++         targetBlend.srcColor = QRhiGraphicsPipeline::DstColor;

++         targetBlend.dstColor = QRhiGraphicsPipeline::Zero;

++         targetBlend.srcAlpha = QRhiGraphicsPipeline::One;

++         targetBlend.dstAlpha = QRhiGraphicsPipeline::One;

++         break;

++     default:

++         // Source over as default

++         targetBlend.srcColor = QRhiGraphicsPipeline::SrcAlpha;

++         targetBlend.dstColor = QRhiGraphicsPipeline::OneMinusSrcAlpha;

++         targetBlend.srcAlpha = QRhiGraphicsPipeline::One;

++         targetBlend.dstAlpha = QRhiGraphicsPipeline::OneMinusSrcAlpha;

++         break;

++

++     }

++ }

++

++ static void sortParticles(const QSSGLayerRenderData &renderData, QByteArray &result, QList<QSSGRhiSortData> &sortData,

++                           const QSSGParticleBuffer &buffer, const QSSGRenderParticles &particles,

++                           const QVector3D &cameraDirection, bool animatedParticles)

++ {

++     const QMatrix4x4 &modelMatrix = renderData.getGlobalTransform(particles);

++     const QMatrix4x4 &invModelMatrix = modelMatrix.inverted();

++     QVector3D dir = invModelMatrix.map(cameraDirection);

++     QVector3D n = dir.normalized();

++     const auto segments = buffer.segments();

++     auto particleCount = buffer.particleCount();

++     const bool lineParticles = segments > 0;

++     if (lineParticles)

++         particleCount /= segments;

++     sortData.resize(particleCount);

++     sortData.fill({});

++

++     const auto srcParticlePointer = [](int line, int segment, int sc, int ss, int pps, const char *source) -> const QSSGLineParticle * {

++         int pi = (line * sc + segment) / pps;

++         int i = (line * sc + segment) % pps;

++         const QSSGLineParticle *sp = reinterpret_cast<const QSSGLineParticle *>(source + pi * ss);

++         return sp + i;

++     };

++

++     // create sort data

++     {

++         const auto slices = buffer.sliceCount();

++         const auto ss = buffer.sliceStride();

++         const auto pps = buffer.particlesPerSlice();

++

++         QSSGRhiSortData *dst = sortData.data();

++         const char *source = buffer.pointer();

++         const char *begin = source;

++         int i = 0;

++         if (lineParticles) {

++             for (i = 0; i < particleCount; i++) {

++                 QSSGRhiSortData lineData;

++                 const QSSGLineParticle *lineBegin = srcParticlePointer(i, 0, segments, ss, pps, source);

++                 lineData.indexOrOffset = i;

++                 lineData.d = QVector3D::dotProduct(lineBegin->position, n);

++                 for (int j = 1; j < buffer.segments(); j++) {

++                     const QSSGLineParticle *p = srcParticlePointer(i, j, segments, ss, pps, source);

++                     lineData.d = qMin(lineData.d, QVector3D::dotProduct(p->position, n));

++                 }

++                 *dst++ = lineData;

++             }

++         } else if (animatedParticles) {

++             for (int s = 0; s < slices; s++) {

++                 const QSSGParticleAnimated *sp = reinterpret_cast<const QSSGParticleAnimated *>(source);

++                 for (int p = 0; p < pps && i < particleCount; p++) {

++                     *dst = { QVector3D::dotProduct(sp->position, n), int(reinterpret_cast<const char *>(sp) - begin)};

++                     sp++;

++                     dst++;

++                     i++;

++                 }

++                 source += ss;

++             }

++         } else {

++             for (int s = 0; s < slices; s++) {

++                 const QSSGParticleSimple *sp = reinterpret_cast<const QSSGParticleSimple *>(source);

++                 for (int p = 0; p < pps && i < particleCount; p++) {

++                     *dst = { QVector3D::dotProduct(sp->position, n), int(reinterpret_cast<const char *>(sp) - begin)};

++                     sp++;

++                     dst++;

++                     i++;

++                 }

++                 source += ss;

++             }

++         }

++     }

++

++     // sort

++     result.resize(buffer.bufferSize());

++     std::sort(sortData.begin(), sortData.end(), [](const QSSGRhiSortData &a, const QSSGRhiSortData &b){

++         return a.d > b.d;

++     });

++

++     auto copyParticles = [&](QByteArray &dst, const QList<QSSGRhiSortData> &data, const QSSGParticleBuffer &buffer) {

++         const auto slices = buffer.sliceCount();

++         const auto ss = buffer.sliceStride();

++         const auto pps = buffer.particlesPerSlice();

++         const QSSGRhiSortData *sdata = data.data();

++         char *dest = dst.data();

++         const char *source = buffer.pointer();

++         int i = 0;

++         if (lineParticles) {

++             int seg = 0;

++             for (int s = 0; s < slices; s++) {

++                 QSSGLineParticle *dp = reinterpret_cast<QSSGLineParticle *>(dest);

++                 for (int p = 0; p < pps && i < particleCount; p++) {

++                     *dp = *srcParticlePointer(sdata->indexOrOffset, seg, segments, ss, pps, source);

++                     dp++;

++                     seg++;

++                     if (seg == segments) {

++                         sdata++;

++                         i++;

++                         seg = 0;

++                     }

++                 }

++                 dest += ss;

++             }

++         } else if (animatedParticles) {

++             for (int s = 0; s < slices; s++) {

++                 QSSGParticleAnimated *dp = reinterpret_cast<QSSGParticleAnimated *>(dest);

++                 for (int p = 0; p < pps && i < particleCount; p++) {

++                     *dp = *reinterpret_cast<const QSSGParticleAnimated *>(source + sdata->indexOrOffset);

++                     dp++;

++                     sdata++;

++                     i++;

++                 }

++                 dest += ss;

++             }

++         } else {

++             for (int s = 0; s < slices; s++) {

++                 QSSGParticleSimple *dp = reinterpret_cast<QSSGParticleSimple *>(dest);

++                 for (int p = 0; p < pps && i < particleCount; p++) {

++                     *dp = *reinterpret_cast<const QSSGParticleSimple *>(source + sdata->indexOrOffset);

++                     dp++;

++                     sdata++;

++                     i++;

++                 }

++                 dest += ss;

++             }

++         }

++     };

++

++     // write result

++     copyParticles(result, sortData, buffer);

++ }

++

++ static QByteArray convertParticleData(QByteArray &dest, const QByteArray &data, bool convert)

++ {

++     if (!convert)

++         return data;

++     int count = data.size() / 4;

++     if (dest.size() != count * 2)

++         dest.resize(2 * count);

++     qFloatToFloat16(reinterpret_cast<qfloat16 *>(dest.data()), reinterpret_cast<const float *>(data.constData()), count);

++     return dest;

++ }

++

++ void QSSGParticleRenderer::rhiPrepareRenderable(QSSGRhiShaderPipeline &shaderPipeline,

++                                                 QSSGPassKey passKey,

++                                                 QSSGRhiContext *rhiCtx,

++                                                 QSSGRhiGraphicsPipelineState *ps,

++                                                 QSSGParticlesRenderable &renderable,

++                                                 const QSSGLayerRenderData &inData,

++                                                 QRhiRenderPassDescriptor *renderPassDescriptor,

++                                                 int samples,

++                                                 int viewCount,

++                                                 QSSGRenderCamera *alteredCamera,

++                                                 QSSGRenderTextureCubeFace cubeFace,

++                                                 QSSGReflectionMapEntry *entry,

++                                                 bool oit)

++ {

++     const void *node = &renderable.particles;

++     const bool needsConversion = !rhiCtx->rhi()->isTextureFormatSupported(QRhiTexture::RGBA32F);

++

++     const auto cubeFaceIdx = QSSGBaseTypeHelpers::indexOfCubeFace(cubeFace);

++     QSSGRhiDrawCallData &dcd = QSSGRhiContextPrivate::get(rhiCtx)->drawCallData({ passKey, node, nullptr, entry,

++                                                                                   cubeFaceIdx });

++     shaderPipeline.ensureUniformBuffer(&dcd.ubuf);

++

++     char *ubufData = dcd.ubuf->beginFullDynamicBufferUpdateForCurrentFrame();

++     if (!alteredCamera) {

++         updateUniformsForParticles(inData, shaderPipeline, rhiCtx, ubufData, renderable, inData.renderedCameras);

++     } else {

++         QSSGRenderCameraList cameras({ alteredCamera });

++         updateUniformsForParticles(inData, shaderPipeline, rhiCtx, ubufData, renderable, cameras);

++     }

++     dcd.ubuf->endFullDynamicBufferUpdateForCurrentFrame();

++

++     QSSGRhiParticleData &particleData = QSSGRhiContextPrivate::get(rhiCtx)->particleData(&renderable.particles);

++     const QSSGParticleBuffer &particleBuffer = renderable.particles.m_particleBuffer;

++     int particleCount = particleBuffer.particleCount();

++     if (particleData.texture == nullptr || particleData.particleCount != particleCount) {

++         QSize size(particleBuffer.size());

++         if (!particleData.texture) {

++             particleData.texture = rhiCtx->rhi()->newTexture(needsConversion ? QRhiTexture::RGBA16F : QRhiTexture::RGBA32F, size);

++             particleData.texture->create();

++         } else {

++             particleData.texture->setPixelSize(size);

++             particleData.texture->create();

++         }

++         particleData.particleCount = particleCount;

++     }

++

++     bool sortingChanged = particleData.sorting != renderable.particles.m_depthSorting;

++     if (sortingChanged && !renderable.particles.m_depthSorting) {

++         particleData.sortData.clear();

++         particleData.sortedData.clear();

++     }

++     particleData.sorting = renderable.particles.m_depthSorting;

++

++     QByteArray uploadData;

++

++     if (renderable.particles.m_depthSorting) {

++         bool animatedParticles = renderable.particles.m_featureLevel == QSSGRenderParticles::FeatureLevel::Animated;

++         if (!alteredCamera) {

++             sortParticles(inData, particleData.sortedData, particleData.sortData, particleBuffer, renderable.particles, inData.renderedCameraData.value()[0].direction, animatedParticles);

++         } else {

++             const QMatrix4x4 globalTransform = inData.getGlobalTransform(*alteredCamera);

++             sortParticles(inData, particleData.sortedData, particleData.sortData, particleBuffer, renderable.particles, QSSGRenderNode::getScalingCorrectDirection(globalTransform), animatedParticles);

++         }

++         uploadData = convertParticleData(particleData.convertData, particleData.sortedData, needsConversion);

++     } else {

++         uploadData = convertParticleData(particleData.convertData, particleBuffer.data(), needsConversion);

++     }

++

++     QRhiResourceUpdateBatch *rub = rhiCtx->rhi()->nextResourceUpdateBatch();

++     QRhiTextureSubresourceUploadDescription upload;

++     upload.setData(uploadData);

++     QRhiTextureUploadDescription uploadDesc(QRhiTextureUploadEntry(0, 0, upload));

++     rub->uploadTexture(particleData.texture, uploadDesc);

++     rhiCtx->commandBuffer()->resourceUpdate(rub);

++

++     auto &ia = QSSGRhiInputAssemblerStatePrivate::get(*ps);

++     ia.topology = QRhiGraphicsPipeline::TriangleStrip;

++     ia.inputLayout = QRhiVertexInputLayout();

++     ia.inputs.clear();

++

++     ps->samples = samples;

++     ps->viewCount = viewCount;

++     ps->cullMode = QRhiGraphicsPipeline::None;

++

++     if (inData.orderIndependentTransparencyEnabled == false) {

++         if (renderable.renderableFlags.hasTransparency())

++             fillTargetBlend(ps->targetBlend[0], renderable.particles.m_blendMode);

++         else

++             ps->targetBlend[0] = QRhiGraphicsPipeline::TargetBlend();

++     }

++

++     QSSGRhiShaderResourceBindingList bindings;

++     bindings.addUniformBuffer(0, VISIBILITY_ALL, dcd.ubuf, 0, shaderPipeline.ub0Size());

++

++     // Texture maps

++     // we only have one image

++     QSSGRenderableImage *renderableImage = renderable.firstImage;

++

++     int samplerBinding = shaderPipeline.bindingForTexture("qt_sprite");

++     if (samplerBinding >= 0) {

++         QRhiTexture *texture = renderableImage ? renderableImage->m_texture.m_texture : nullptr;

++         if (samplerBinding >= 0 && texture) {

++             const bool mipmapped = texture->flags().testFlag(QRhiTexture::MipMapped);

++             QRhiSampler *sampler = rhiCtx->sampler({ QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_minFilterType),

++                                                      QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_magFilterType),

++                                                      mipmapped ? QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_mipFilterType) : QRhiSampler::None,

++                                                      QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_horizontalTilingMode),

++                                                      QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_verticalTilingMode),

++                                                      QSSGRhiHelpers::toRhi(renderableImage->m_imageNode.m_depthTilingMode)

++                                                    });

++             bindings.addTexture(samplerBinding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);

++         } else {

++             QRhiResourceUpdateBatch *rub = rhiCtx->rhi()->nextResourceUpdateBatch();

++             QRhiTexture *texture = rhiCtx->dummyTexture({}, rub, QSize(4, 4), Qt::white);

++             rhiCtx->commandBuffer()->resourceUpdate(rub);

++             QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest,

++                                                      QRhiSampler::Nearest,

++                                                      QRhiSampler::None,

++                                                      QRhiSampler::ClampToEdge,

++                                                      QRhiSampler::ClampToEdge,

++                                                      QRhiSampler::Repeat

++                                                    });

++             bindings.addTexture(samplerBinding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);

++         }

++     }

++

++     samplerBinding = shaderPipeline.bindingForTexture("qt_particleTexture");

++     if (samplerBinding >= 0) {

++         QRhiTexture *texture = particleData.texture;

++         if (samplerBinding >= 0 && texture) {

++             QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest,

++                                                      QRhiSampler::Nearest,

++                                                      QRhiSampler::None,

++                                                      QRhiSampler::ClampToEdge,

++                                                      QRhiSampler::ClampToEdge,

++                                                      QRhiSampler::Repeat

++                                                    });

++             bindings.addTexture(samplerBinding, QRhiShaderResourceBinding::VertexStage, texture, sampler);

++         }

++     }

++

++     samplerBinding = shaderPipeline.bindingForTexture("qt_colorTable");

++     if (samplerBinding >= 0) {

++         bool hasTexture = false;

++         if (renderable.colorTable) {

++             QRhiTexture *texture = renderable.colorTable->m_texture.m_texture;

++             if (texture) {

++                 hasTexture = true;

++                 QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest,

++                                                          QRhiSampler::Nearest,

++                                                          QRhiSampler::None,

++                                                          QRhiSampler::ClampToEdge,

++                                                          QRhiSampler::ClampToEdge,

++                                                          QRhiSampler::Repeat

++                                                        });

++                 bindings.addTexture(samplerBinding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);

++             }

++         }

++

++         if (!hasTexture) {

++             QRhiResourceUpdateBatch *rub = rhiCtx->rhi()->nextResourceUpdateBatch();

++             QRhiTexture *texture = rhiCtx->dummyTexture({}, rub, QSize(4, 4), Qt::white);

++             rhiCtx->commandBuffer()->resourceUpdate(rub);

++             QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest,

++                                                      QRhiSampler::Nearest,

++                                                      QRhiSampler::None,

++                                                      QRhiSampler::ClampToEdge,

++                                                      QRhiSampler::ClampToEdge,

++                                                      QRhiSampler::Repeat

++                                                    });

++             bindings.addTexture(samplerBinding, QRhiShaderResourceBinding::FragmentStage, texture, sampler);

++         }

++     }

++

++     if (oit && inData.layer.oitMethod == QSSGRenderLayer::OITMethod::LinkedList)

++         RenderHelpers::addAccumulatorImageBindings(&shaderPipeline, bindings);

++

++     QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);

++

++     // TODO: This is identical to other renderables. Make into a function?

++     QRhiShaderResourceBindings *&srb = dcd.srb;

++     bool srbChanged = false;

++     if (!srb || bindings != dcd.bindings) {

++         srb = rhiCtxD->srb(bindings);

++         rhiCtxD->releaseCachedSrb(dcd.bindings);

++         dcd.bindings = bindings;

++         srbChanged = true;

++     }

++

++     if (cubeFace == QSSGRenderTextureCubeFaceNone)

++         renderable.rhiRenderData.mainPass.srb = srb;

++     else

++         renderable.rhiRenderData.reflectionPass.srb[cubeFaceIdx] = srb;

++

++     const auto pipelineKey = QSSGGraphicsPipelineStateKey::create(*ps, renderPassDescriptor, srb);

++     if (dcd.pipeline

++             && !srbChanged

++             && dcd.renderTargetDescriptionHash == pipelineKey.extra.renderTargetDescriptionHash

++             && dcd.renderTargetDescription == pipelineKey.renderTargetDescription

++             && dcd.ps == *ps)

++     {

++         if (cubeFace == QSSGRenderTextureCubeFaceNone)

++             renderable.rhiRenderData.mainPass.pipeline = dcd.pipeline;

++         else

++             renderable.rhiRenderData.reflectionPass.pipeline = dcd.pipeline;

++     } else {

++         if (cubeFace == QSSGRenderTextureCubeFaceNone) {

++             renderable.rhiRenderData.mainPass.pipeline = rhiCtxD->pipeline(pipelineKey,

++                                                                            renderPassDescriptor,

++                                                                            srb);

++             dcd.pipeline = renderable.rhiRenderData.mainPass.pipeline;

++         } else {

++             renderable.rhiRenderData.reflectionPass.pipeline = rhiCtxD->pipeline(pipelineKey,

++                                                                                  renderPassDescriptor,

++                                                                                  srb);

++             dcd.pipeline = renderable.rhiRenderData.reflectionPass.pipeline;

++         }

++         dcd.renderTargetDescriptionHash = pipelineKey.extra.renderTargetDescriptionHash;

++         dcd.renderTargetDescription = pipelineKey.renderTargetDescription;

++         dcd.ps = *ps;

++     }

++ }

++

++ void QSSGParticleRenderer::prepareParticlesForModel(QSSGRhiShaderPipeline &shaderPipeline,

++                                                     QSSGRhiContext *rhiCtx,

++                                                     QSSGRhiShaderResourceBindingList &bindings,

++                                                     const QSSGRenderModel *model)

++ {

++     QSSGRhiContextPrivate *rhiCtxD = QSSGRhiContextPrivate::get(rhiCtx);

++     QSSGRhiParticleData &particleData = rhiCtxD->particleData(model);

++     const QSSGParticleBuffer &particleBuffer = *model->particleBuffer;

++     int particleCount = particleBuffer.particleCount();

++     bool update = particleBuffer.serial() != particleData.serial;

++     const bool needsConversion = !rhiCtx->rhi()->isTextureFormatSupported(QRhiTexture::RGBA32F);

++     if (particleData.texture == nullptr || particleData.particleCount != particleCount) {

++         QSize size(particleBuffer.size());

++         if (!particleData.texture) {

++             particleData.texture = rhiCtx->rhi()->newTexture(needsConversion ? QRhiTexture::RGBA16F : QRhiTexture::RGBA32F, size);

++             particleData.texture->create();

++         } else {

++             particleData.texture->setPixelSize(size);

++             particleData.texture->create();

++         }

++         particleData.particleCount = particleCount;

++         update = true;

++     }

++

++     if (update) {

++         QRhiResourceUpdateBatch *rub = rhiCtx->rhi()->nextResourceUpdateBatch();

++         QRhiTextureSubresourceUploadDescription upload;

++         upload.setData(convertParticleData(particleData.convertData, particleBuffer.data(), needsConversion));

++         QRhiTextureUploadDescription uploadDesc(QRhiTextureUploadEntry(0, 0, upload));

++         rub->uploadTexture(particleData.texture, uploadDesc);

++         rhiCtx->commandBuffer()->resourceUpdate(rub);

++     }

++     particleData.serial = particleBuffer.serial();

++     int samplerBinding = shaderPipeline.bindingForTexture("qt_particleTexture");

++     if (samplerBinding >= 0) {

++         QRhiTexture *texture = particleData.texture;

++         if (samplerBinding >= 0 && texture) {

++             QRhiSampler *sampler = rhiCtx->sampler({ QRhiSampler::Nearest,

++                                                      QRhiSampler::Nearest,

++                                                      QRhiSampler::None,

++                                                      QRhiSampler::ClampToEdge,

++                                                      QRhiSampler::ClampToEdge,

++                                                      QRhiSampler::Repeat

++                                                    });

++             bindings.addTexture(samplerBinding, QRhiShaderResourceBinding::VertexStage, texture, sampler);

++         }

++     }

++ }

++

++ static QByteArray particlesLogPrefix() { return QByteArrayLiteral("particle material pipeline-- "); }

++

++ struct ShaderGeneratorCommon

++ {

++     QSSGStageGeneratorBase *vs;

++     QSSGStageGeneratorBase *fs;

++     ShaderGeneratorCommon(QSSGProgramGenerator &gen)

++         : vs(gen.getStage(QSSGShaderGeneratorStage::Vertex)), fs(gen.getStage(QSSGShaderGeneratorStage::Fragment))

++     {

++

++     }

++     void addUniform(const QByteArray &name, const QByteArray &type)

++     {

++         vs->addUniform(name, type);

++         fs->addUniform(name, type);

++     }

++     void addUniformArray(const QByteArray &name, const QByteArray &type, quint32 size)

++     {

++         vs->addUniformArray(name, type, size);

++         fs->addUniformArray(name, type, size);

++     }

++     void addDefinition(const QByteArray &name, const QByteArray &value)

++     {

++         vs->addDefinition(name, value);

++         fs->addDefinition(name, value);

++     }

++     void addInterpolant(const QByteArray &name, const QByteArray &type)

++     {

++         vs->addOutgoing(name, type);

++         fs->addIncoming(name, type);

++     }

++     void addFlatInterpolant(const QByteArray &name, const QByteArray &type)

++     {

++         vs->addFlatOutgoing(name, type);

++         fs->addFlatIncoming(name, type);

++     }

++     void addPrefix(const QByteArray &prefix)

++     {

++         vs->addPrefix(prefix);

++         fs->addPrefix(prefix);

++     }

++ };

++

++ struct AutoFormatGenerator

++ {

++     QSSGStageGeneratorBase &gen;

++     int indent = 0;

++     AutoFormatGenerator(QSSGStageGeneratorBase &g)

++         : gen(g)

++     {

++

++     }

++     AutoFormatGenerator &operator<<(const QByteArray &data)

++     {

++         for (int i = 0; i < indent; i++)

++             gen << "    ";

++         gen << data << "\n";

++         return *this;

++     }

++     void incIndent()

++     {

++         indent++;

++     }

++     void decIndent()

++     {

++         indent--;

++         Q_ASSERT(indent >= 0);

++     }

++ };

++

++ static const char *s_lightPrefix = {

++     "struct ParticleLightData\n" \

++     "{\n"

++     "    vec4 qt_pointLightPosition[4];\n" \

++     "    vec4 qt_pointLightConstantAtt;\n" \

++     "    vec4 qt_pointLightLinearAtt;\n" \

++     "    vec4 qt_pointLightQuadAtt;\n" \

++     "    vec4 qt_pointLightColor[4];\n" \

++     "    vec4 qt_spotLightPosition[4];\n" \

++     "    vec4 qt_spotLightConstantAtt;\n" \

++     "    vec4 qt_spotLightLinearAtt;\n" \

++     "    vec4 qt_spotLightQuadAtt;\n" \

++     "    vec4 qt_spotLightColor[4];\n" \

++     "    vec4 qt_spotLightDirection[4];\n" \

++     "    vec4 qt_spotLightConeAngle;\n" \

++     "    vec4 qt_spotLightInnerConeAngle;\n" \

++     "};\n"

++ };

++

++ QSSGShaderFeatures QSSGParticleRenderer::particleShaderFeatures(const QSSGShaderFeatures& features)

++ {

++ #define COPY_FEATURE(f) ret.set(f, features.isSet(f));

++     QSSGShaderFeatures ret;

++     COPY_FEATURE(QSSGShaderFeatures::Feature::LinearTonemapping);

++     COPY_FEATURE(QSSGShaderFeatures::Feature::AcesTonemapping);

++     COPY_FEATURE(QSSGShaderFeatures::Feature::HejlDawsonTonemapping);

++     COPY_FEATURE(QSSGShaderFeatures::Feature::FilmicTonemapping);

++     COPY_FEATURE(QSSGShaderFeatures::Feature::DisableMultiView);

++ #undef COPY_FEATURE

++     return ret;

++ }

++

++ QSSGRhiShaderPipelinePtr QSSGParticleRenderer::generateRhiShaderPipeline(QSSGRenderer &renderer,

++                                                                          QSSGParticlesRenderable &inRenderable,

++                                                                          const QSSGShaderFeatures &inFeatureSet,

++                                                                          QByteArray &shaderString,

++                                                                          const QSSGShaderParticleMaterialKeyProperties &shaderKeyProperties)

++ {

++     const auto &m_contextInterface = renderer.m_contextInterface;

++     const auto &shaderCache = m_contextInterface->shaderCache();

++     const auto &shaderProgramGenerator = m_contextInterface->shaderProgramGenerator();

++     const auto &shaderLibraryManager = m_contextInterface->shaderLibraryManager();

++

++     shaderString = particlesLogPrefix();

++     QSSGShaderParticleMaterialKey theKey(inRenderable.shaderDescription);

++

++     theKey.toString(shaderString, shaderKeyProperties);

++

++     if (s_shaderCacheEnabled) {

++         if (const auto &maybePipeline = shaderCache->tryGetRhiShaderPipeline(shaderString, inFeatureSet))

++             return maybePipeline;

++

++         const QByteArray qsbcKey = QQsbCollection::EntryDesc::generateSha(shaderString, QQsbCollection::toFeatureSet(inFeatureSet));

++         // Check if there's a pre-built (offline generated) shader for available.

++         if (renderer.m_currentLayer) {

++             QQsbCollection::EntryMap &pregenEntries = renderer.m_currentLayer->m_particleShaderEntries;

++             if (pregenEntries.isEmpty()) {

++                 renderer.m_currentLayer->m_particleShaderEntries = shaderLibraryManager->getParticleShaderEntries();

++                 pregenEntries = renderer.m_currentLayer->m_particleShaderEntries;

++             }

++             if (!pregenEntries.isEmpty()) {

++                 const auto foundIt = pregenEntries.constFind(QQsbCollection::Entry(qsbcKey));

++                 if (foundIt != pregenEntries.cend())

++                     return shaderCache->newPipelineFromPregenerated(shaderString, inFeatureSet, *foundIt, inRenderable.particles);

++             }

++         }

++

++         // Try the persistent (disk-based) cache then.

++         if (const auto &maybePipeline = shaderCache->tryNewPipelineFromPersistentCache(qsbcKey, shaderString, inFeatureSet))

++             return maybePipeline;

++     }

++

++     // generate shader code

++     shaderProgramGenerator->beginProgram();

++     auto &vertex = *shaderProgramGenerator->getStage(QSSGShaderGeneratorStage::Vertex);

++     auto &fragment = *shaderProgramGenerator->getStage(QSSGShaderGeneratorStage::Fragment);

++     ShaderGeneratorCommon common(*shaderProgramGenerator);

++     const bool isSpriteLinear = shaderKeyProperties.m_isSpriteLinear.getValue(theKey);

++     const bool isColorTableLinear = shaderKeyProperties.m_isColorTableLinear.getValue(theKey);

++     const bool lighting = shaderKeyProperties.m_hasLighting.getValue(theKey);

++     const bool isMapped = shaderKeyProperties.m_isMapped.getValue(theKey);

++     const bool isLineParticle = shaderKeyProperties.m_isLineParticle.getValue(theKey);

++     const bool isAnimated = shaderKeyProperties.m_isAnimated.getValue(theKey);

++     const int viewCount = inFeatureSet.isSet(QSSGShaderFeatures::Feature::DisableMultiView)

++             ? 1 : shaderKeyProperties.m_viewCount.getValue(theKey);

++     const int oit = shaderKeyProperties.m_orderIndependentTransparency.getValue(theKey);

++     const bool oitMSAA = shaderKeyProperties.m_oitMSAA.getValue(theKey);

++

++     if (isAnimated)

++         common.addDefinition("QSSG_PARTICLES_ENABLE_ANIMATED", "1");

++     if (isLineParticle)

++         common.addDefinition("QSSG_PARTICLES_ENABLE_LINE_PARTICLE", "1");

++     if (oit)

++         common.addDefinition("QSSG_OIT_METHOD", QStringLiteral("%1").arg(oit).toUtf8());

++     if (oitMSAA)

++         common.addDefinition("QSSG_MULTISAMPLE", "1");

++

++     common.addUniform("qt_modelMatrix", "mat4");

++     if (viewCount >= 2) {

++         common.addUniformArray("qt_viewMatrix", "mat4", viewCount);

++         common.addUniformArray("qt_projectionMatrix", "mat4", viewCount);

++     } else {

++         common.addUniform("qt_viewMatrix", "mat4");

++         common.addUniform("qt_projectionMatrix", "mat4");

++     }

++     if (lighting) {

++         common.addPrefix(s_lightPrefix);

++         common.addUniform("lightData", "ParticleLightData");

++     }

++     common.addUniform("qt_spriteConfig", "vec4");

++     common.addUniform("qt_light_ambient_total", "vec3");

++     common.addUniform("qt_oneOverParticleImageSize", "vec2");

++     common.addUniform("qt_countPerSlice", "uint");

++     if (isLineParticle)

++         common.addUniform("qt_lineSegmentCount", "uint");

++     common.addUniform("qt_billboard", "float");

++     common.addUniform("qt_opacity", "float");

++     if (isLineParticle) {

++         common.addUniform("qt_alphaFade", "float");

++         common.addUniform("qt_sizeModifier", "float");

++         common.addUniform("qt_texcoordScale", "float");

++     }

++     if (lighting) {

++         common.addUniform("qt_pointLights", "bool");

++         common.addUniform("qt_spotLights", "bool");

++     }

++     if (oit == (int)QSSGRenderLayer::OITMethod::WeightedBlended) {

++         common.addUniform("qt_cameraProperties", "vec2");

++     } else if (oit == (int)QSSGRenderLayer::OITMethod::LinkedList) {

++         common.addUniform("qt_viewSize", "ivec2");

++         common.addUniform("qt_ABufImageWidth", "uint");

++         common.addUniform("qt_listNodeCount", "uint");

++ #ifdef QSSG_OIT_USE_BUFFERS

++         common.addUniform("qt_samples", "uint");

++ #endif

++     }

++

++     if (lighting)

++         vertex.addInclude("particleLighting.glsllib");

++

++     vertex.addUniform("qt_particleTexture", "sampler2D");

++

++     vertex.addInclude("particleLoading.glsllib");

++

++     common.addInterpolant("color", "vec4");

++     common.addInterpolant("spriteData", "vec2");

++     common.addInterpolant("texcoord", "vec2");

++     common.addFlatInterpolant("instanceIndex", "uint");

++     if (oit == (int)QSSGRenderLayer::OITMethod::LinkedList && viewCount >= 2)

++         common.addFlatInterpolant("v_viewIndex", "uint");

++

++     AutoFormatGenerator vg(vertex);

++     if (!isLineParticle)

++         vg << "const vec2 corners[4] = {{0.0, 0.0}, {1.0, 0.0}, {0.0, 1.0}, {1.0, 1.0}};";

++

++     // vertex shader main

++     vg << "out gl_PerVertex {"

++        << "    vec4 gl_Position;"

++        << "};";

++

++     vg << "void main() {";

++     vg.incIndent();

++     if (isLineParticle) {

++         vg << "uint segmentIndex = gl_VertexIndex / 2;"

++                << "uint particleIndex = segmentIndex + gl_InstanceIndex * qt_lineSegmentCount;";

++     } else {

++         vg << "uint particleIndex = gl_InstanceIndex;"

++                << "uint cornerIndex = gl_VertexIndex;"

++                << "vec2 corner = corners[cornerIndex];";

++     }

++     vg << "instanceIndex = particleIndex;"

++            << "Particle p = qt_loadParticle(particleIndex);";

++

++     if (isLineParticle) {

++         vg << "float side = float(mod(gl_VertexIndex, 2)) - 0.5;"

++            << "float size = p.size * qt_calcSizeFactor(segmentIndex);"

++            << "vec3 o = p.binormal * side * size;"

++            << "vec4 worldPos = qt_modelMatrix * vec4(p.position + (1.0 - qt_billboard) * o, 1.0);";

++         if (viewCount >= 2) {

++             vg << "vec4 viewPos = qt_viewMatrix[gl_ViewIndex] * worldPos;"

++                << "vec3 viewBN = (transpose(inverse(qt_viewMatrix[gl_ViewIndex] * qt_modelMatrix)) * vec4(p.binormal, 0.0)).xyz;";

++         } else {

++             vg << "vec4 viewPos = qt_viewMatrix * worldPos;"

++                << "vec3 viewBN = (transpose(inverse(qt_viewMatrix * qt_modelMatrix)) * vec4(p.binormal, 0.0)).xyz;";

++         }

++         vg << "viewBN.z = 0;"

++            << "viewBN = normalize(viewBN) * side * size;"

++            << "viewPos = viewPos + vec4(viewBN, 0.0) * qt_billboard;"

++            << "texcoord.x = p.segmentLength * qt_texcoordScale;"

++            << "texcoord.y = float(mod(gl_VertexIndex, 2));"

++            << "color = p.color;"

++            << "color.a *= qt_opacity * qt_calcAlphaFade(segmentIndex);";

++     } else {

++         vg << "mat3 rotMat = qt_fromEulerRotation(p.rotation);"

++            << "vec4 worldPos = qt_modelMatrix * vec4(p.position, 1.0);"

++            << "vec4 viewPos = worldPos;"

++            << "vec3 offset = (p.size * vec3(corner - vec2(0.5), 0.0));"

++            << "viewPos.xyz += offset * rotMat * (1.0 - qt_billboard);";

++         if (viewCount >= 2)

++             vg << "viewPos = qt_viewMatrix[gl_ViewIndex] * viewPos;";

++         else

++             vg << "viewPos = qt_viewMatrix * viewPos;";

++         vg << "viewPos.xyz += rotMat * offset * qt_billboard;"

++            << "texcoord = corner;"

++            << "color = p.color;"

++            << "color.a *= qt_opacity;";

++     }

++     if (lighting)

++         vg << "color.rgb *= qt_calcLightColor(worldPos.xyz);";

++     if (viewCount >= 2) {

++         if (oit == int(QSSGRenderLayer::OITMethod::LinkedList))

++             vg << "v_viewIndex = gl_ViewIndex;";

++         vg << "gl_Position = qt_projectionMatrix[gl_ViewIndex] * viewPos;";

++     } else {

++         vg << "gl_Position = qt_projectionMatrix * viewPos;";

++     }

++     if (isMapped)

++         vg << "spriteData.x = qt_ageToSpriteFactor(p.age);";

++     if (isAnimated)

++         vg << "spriteData.y = p.animationFrame;";

++     vg.decIndent();

++     vg << "}";

++

++     // fragment shader main

++     fragment.addInclude("tonemapping.glsllib");

++     fragment.addInclude("particleSprite.glsllib");

++     fragment.addUniform("qt_sprite", "sampler2D");

++

++     AutoFormatGenerator fg(fragment);

++

++     if (oit == int(QSSGRenderLayer::OITMethod::WeightedBlended)) {

++         fragment.addInclude("oitweightedblended.glsllib");

++         fg << "layout(location = 1) out vec4 revealageOutput;";

++     } else if (oit == int(QSSGRenderLayer::OITMethod::LinkedList)) {

++ #ifdef QSSG_OIT_USE_BUFFERS

++         fragment.addInclude("oitlinkedlist_buf.glsllib");

++         QSSGShaderResourceMergeContext::setAdditionalBufferAmount(3);

++ #else

++         fragment.addInclude("oitlinkedlist.glsllib");

++ #endif

++     }

++     if (isSpriteLinear)

++         fg << "#define spriteFunc";

++     else

++         fg << "#define spriteFunc qt_sRGBToLinear";

++     if (isMapped) {

++         fragment.addUniform("qt_colorTable", "sampler2D");

++         if (isColorTableLinear)

++             fg << "#define colorTableFunc";

++         else

++             fg << "#define colorTableFunc qt_sRGBToLinear";

++     }

++

++     fg << "vec4 qt_readSprite() {";

++     fg.incIndent();

++     if (isAnimated) {

++         fg << "vec2 coords[2];"

++            << "float factor = qt_spriteCoords(coords);"

++            << "return mix(spriteFunc(texture(qt_sprite, coords[0])), spriteFunc(texture(qt_sprite, coords[1])), factor);";

++     } else {

++         fg << "return spriteFunc(texture(qt_sprite, texcoord));";

++     }

++     fg.decIndent();

++     fg << "}";

++     fg << "vec4 qt_readColor() {";

++     fg.incIndent();

++     if (isMapped)

++         fg << "return color * colorTableFunc(texture(qt_colorTable, vec2(spriteData.x, qt_rand(vec2(instanceIndex, 0)))));";

++     else

++         fg << "return color;";

++     fg.decIndent();

++     fg << "}";

++     fg << "void main() {";

++     fg.incIndent();

++     fg << "vec4 ret = qt_readColor() * qt_readSprite();";

++     if (oit) {

++         if (oit == int(QSSGRenderLayer::OITMethod::WeightedBlended)) {

++             fg << "float z = abs(gl_FragCoord.z);"

++                << "float distWeight = qt_transparencyWeight(z, ret.a, qt_cameraProperties.y);"

++                << "fragOutput = distWeight * qt_tonemap(ret);"

++                << "revealageOutput = vec4(ret.a);";

++         } else if (oit == int(QSSGRenderLayer::OITMethod::LinkedList)) {

++ #ifdef QSSG_OIT_USE_BUFFERS

++             if (viewCount >= 2)

++                 fg << "fragOutput = qt_oitLinkedList(ret, qt_listNodeCount, qt_ABufImageWidth, qt_viewSize, v_viewIndex, qt_samples);";

++             else

++                 fg << "fragOutput = qt_oitLinkedList(ret, qt_listNodeCount, qt_ABufImageWidth, qt_viewSize, 0, qt_samples);";

++ #else

++             if (viewCount >= 2)

++                 fg << "fragOutput = qt_oitLinkedList(ret, qt_listNodeCount, qt_ABufImageWidth, qt_viewSize, v_viewIndex);";

++             else

++                 fg << "fragOutput = qt_oitLinkedList(ret, qt_listNodeCount, qt_ABufImageWidth, qt_viewSize, 0);";

++ #endif

++         }

++     } else {

++         fg << "fragOutput = qt_tonemap(ret);";

++     }

++     fg.decIndent();

++     fg << "}";

++

++

++     return shaderProgramGenerator->compileGeneratedRhiShader(shaderString,

++                                                              inFeatureSet,

++                                                              *shaderLibraryManager,

++                                                              *shaderCache,

++                                                              QSSGRhiShaderPipeline::UsedWithoutIa,

++                                                              {},

++                                                              shaderKeyProperties.m_viewCount.getValue(inRenderable.shaderDescription),

++                                                              false);

++ }

++

++ QSSGRhiShaderPipelinePtr QSSGParticleRenderer::getShaderPipelineParticles(QSSGRenderer &renderer,

++                                                            QSSGParticlesRenderable &inRenderable,

++                                                            const QSSGShaderFeatures &inFeatureSet)

++ {

++     const auto features = particleShaderFeatures(inFeatureSet);

++     auto *m_currentLayer = renderer.m_currentLayer;

++     QSSG_ASSERT(m_currentLayer != nullptr, return {});

++

++     auto &shaderMap = m_currentLayer->particleShaderMap;

++

++     QElapsedTimer timer;

++     timer.start();

++

++     QSSGRhiShaderPipelinePtr shaderPipeline;

++

++     // This just references inFeatureSet and inRenderable.shaderDescription -

++     // cheap to construct and is good enough for the find()

++     QSSGParticleShaderMapKey skey = QSSGParticleShaderMapKey(QByteArray(),

++                                              features,

++                                              inRenderable.shaderDescription);

++     auto it = shaderMap.find(skey);

++     if (it == shaderMap.end()) {

++         Q_TRACE_SCOPE(QSSG_generateShader);

++         Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DGenerateShader);

++         auto &shaderString = renderer.m_currentLayer->generatedShaderString;

++         shaderPipeline = QSSGParticleRenderer::generateRhiShaderPipeline(renderer, inRenderable, features, shaderString, m_currentLayer->particleMaterialShaderKeyProperties);

++         Q_QUICK3D_PROFILE_END_WITH_ID(QQuick3DProfiler::Quick3DGenerateShader, 0, inRenderable.particles.profilingId);

++         // make skey useable as a key for the QHash (makes a copy of the materialKey, instead of just referencing)

++         skey.detach();

++         // insert it no matter what, no point in trying over and over again

++         shaderMap.insert(skey, shaderPipeline);

++     } else {

++         shaderPipeline = it.value();

++     }

++

++     if (shaderPipeline != nullptr) {

++         if (m_currentLayer && !m_currentLayer->renderedCameras.isEmpty())

++             m_currentLayer->ensureCachedCameraDatas();

++     }

++

++     const auto &rhiContext = renderer.m_contextInterface->rhiContext();

++     QSSGRhiContextStats::get(*rhiContext).registerMaterialShaderGenerationTime(timer.elapsed());

++

++     return shaderPipeline;

++ }

++

++ void QSSGParticleRenderer::rhiRenderRenderable(QSSGRhiContext *rhiCtx,

++                                                QSSGParticlesRenderable &renderable,

++                                                bool *needsSetViewport,

++                                                QSSGRenderTextureCubeFace cubeFace,

++                                                const QSSGRhiGraphicsPipelineState &state)

++ {

++     QRhiGraphicsPipeline *ps = renderable.rhiRenderData.mainPass.pipeline;

++     QRhiShaderResourceBindings *srb = renderable.rhiRenderData.mainPass.srb;

++

++     if (cubeFace != QSSGRenderTextureCubeFaceNone) {

++         const auto cubeFaceIdx = QSSGBaseTypeHelpers::indexOfCubeFace(cubeFace);

++         ps = renderable.rhiRenderData.reflectionPass.pipeline;

++         srb = renderable.rhiRenderData.reflectionPass.srb[cubeFaceIdx];

++     }

++

++     if (!ps || !srb)

++         return;

++

++     Q_QUICK3D_PROFILE_START(QQuick3DProfiler::Quick3DRenderCall);

++

++     QRhiCommandBuffer *cb = rhiCtx->commandBuffer();

++     // QRhi optimizes out unnecessary binding of the same pipline

++     cb->setGraphicsPipeline(ps);

++     cb->setVertexInput(0, 0, nullptr);

++     cb->setShaderResources(srb);

++

++     if (needsSetViewport && *needsSetViewport) {

++         cb->setViewport(state.viewport);

++         *needsSetViewport = false;

++     }

++     if (renderable.particles.m_featureLevel >= QSSGRenderParticles::FeatureLevel::Line) {

++         // draw triangle strip with 2 * segmentCount vertices N times

++         int S = renderable.particles.m_particleBuffer.segments();

++         int N = renderable.particles.m_particleBuffer.particleCount() / S;

++         cb->draw(2 * S, N);

++         QSSGRHICTX_STAT(rhiCtx, draw(2 * S, N));

++         Q_QUICK3D_PROFILE_END_WITH_ID(QQuick3DProfiler::Quick3DRenderCall, (2 * S | quint64(N) << 32), renderable.particles.profilingId);

++     } else {

++         // draw triangle strip with 2 triangles N times

++         cb->draw(4, renderable.particles.m_particleBuffer.particleCount());

++         QSSGRHICTX_STAT(rhiCtx, draw(4, renderable.particles.m_particleBuffer.particleCount()));

++         Q_QUICK3D_PROFILE_END_WITH_ID(QQuick3DProfiler::Quick3DRenderCall, (4 | quint64(renderable.particles.m_particleBuffer.particleCount()) << 32), renderable.particles.profilingId);

++     }

++ }

++

++ QT_END_NAMESPACE

Revision control