diff options
Diffstat (limited to 'src/particles')
32 files changed, 930 insertions, 183 deletions
diff --git a/src/particles/particles.qrc b/src/particles/particles.qrc index ad44cf406e..c7102b9aa5 100644 --- a/src/particles/particles.qrc +++ b/src/particles/particles.qrc @@ -16,5 +16,16 @@ <file>shaders/customparticletemplate_core.vert</file> <file>shaders/imageparticle_core.frag</file> <file>shaders/imageparticle_core.vert</file> + + <file>shaders_ng/imageparticle_simple.vert.qsb</file> + <file>shaders_ng/imageparticle_simple.frag.qsb</file> + <file>shaders_ng/imageparticle_tabled.vert.qsb</file> + <file>shaders_ng/imageparticle_tabled.frag.qsb</file> + <file>shaders_ng/imageparticle_deformed.vert.qsb</file> + <file>shaders_ng/imageparticle_deformed.frag.qsb</file> + <file>shaders_ng/imageparticle_sprite.vert.qsb</file> + <file>shaders_ng/imageparticle_sprite.frag.qsb</file> + <file>shaders_ng/imageparticle_colored.vert.qsb</file> + <file>shaders_ng/imageparticle_colored.frag.qsb</file> </qresource> </RCC> diff --git a/src/particles/qquickcustomaffector.cpp b/src/particles/qquickcustomaffector.cpp index ccb00eeba2..5e2133dfaf 100644 --- a/src/particles/qquickcustomaffector.cpp +++ b/src/particles/qquickcustomaffector.cpp @@ -38,9 +38,9 @@ ****************************************************************************/ #include "qquickcustomaffector_p.h" -#include <private/qv8engine_p.h> #include <private/qqmlengine_p.h> #include <private/qqmlglobal_p.h> +#include <private/qjsvalue_p.h> #include <QQmlEngine> #include <QDebug> QT_BEGIN_NAMESPACE @@ -103,7 +103,7 @@ QQuickCustomAffector::QQuickCustomAffector(QQuickItem *parent) : bool QQuickCustomAffector::isAffectConnected() { - IS_SIGNAL_CONNECTED(this, QQuickCustomAffector, affectParticles, (QQmlV4Handle,qreal)); + IS_SIGNAL_CONNECTED(this, QQuickCustomAffector, affectParticles, (const QJSValue &, qreal)); } void QQuickCustomAffector::affectSystem(qreal dt) @@ -156,23 +156,26 @@ void QQuickCustomAffector::affectSystem(qreal dt) for (int i=0; i<toAffect.size(); i++) array->put(i, (v = toAffect[i]->v4Value(m_system))); - if (dt >= simulationCutoff || dt <= simulationDelta) { + const auto doAffect = [&](qreal dt) { affectProperties(toAffect, dt); - emit affectParticles(QQmlV4Handle(array), dt); + QJSValue particles; + QJSValuePrivate::setValue(&particles, v4, array); + emit affectParticles(particles, dt); + }; + + if (dt >= simulationCutoff || dt <= simulationDelta) { + doAffect(dt); } else { int realTime = m_system->timeInt; m_system->timeInt -= dt * 1000.0; while (dt > simulationDelta) { m_system->timeInt += simulationDelta * 1000.0; dt -= simulationDelta; - affectProperties(toAffect, simulationDelta); - emit affectParticles(QQmlV4Handle(array), simulationDelta); + doAffect(simulationDelta); } m_system->timeInt = realTime; - if (dt > 0.0) { - affectProperties(toAffect, dt); - emit affectParticles(QQmlV4Handle(array), dt); - } + if (dt > 0.0) + doAffect(dt); } foreach (QQuickParticleData* d, toAffect) @@ -230,7 +233,7 @@ bool QQuickCustomAffector::affectParticle(QQuickParticleData *d, qreal dt) return changed; } -void QQuickCustomAffector::affectProperties(const QList<QQuickParticleData*> particles, qreal dt) +void QQuickCustomAffector::affectProperties(const QList<QQuickParticleData*> &particles, qreal dt) { foreach (QQuickParticleData* d, particles) if ( affectParticle(d, dt) ) diff --git a/src/particles/qquickcustomaffector_p.h b/src/particles/qquickcustomaffector_p.h index c1745798c3..5b1ea55659 100644 --- a/src/particles/qquickcustomaffector_p.h +++ b/src/particles/qquickcustomaffector_p.h @@ -108,7 +108,7 @@ public: Q_SIGNALS: - void affectParticles(QQmlV4Handle particles, qreal dt); + void affectParticles(const QJSValue &particles, qreal dt); void positionChanged(QQuickDirection * arg); @@ -156,7 +156,7 @@ protected: bool affectParticle(QQuickParticleData *d, qreal dt) override; private: - void affectProperties(const QList<QQuickParticleData*> particles, qreal dt); + void affectProperties(const QList<QQuickParticleData*> &particles, qreal dt); QQuickDirection * m_position; QQuickDirection * m_velocity; QQuickDirection * m_acceleration; diff --git a/src/particles/qquickcustomparticle.cpp b/src/particles/qquickcustomparticle.cpp index 85056dffa9..91fd63302a 100644 --- a/src/particles/qquickcustomparticle.cpp +++ b/src/particles/qquickcustomparticle.cpp @@ -413,7 +413,7 @@ void QQuickCustomParticle::buildData(QQuickOpenGLShaderEffectNode *rootNode) for (int shaderType = 0; shaderType < Key::ShaderTypeCount; ++shaderType) { for (int i = 0; i < m_common.uniformData[shaderType].size(); ++i) { if (m_common.uniformData[shaderType].at(i).name == "qt_Timestamp") - m_common.uniformData[shaderType][i].value = qVariantFromValue(m_lastTime); + m_common.uniformData[shaderType][i].value = QVariant::fromValue(m_lastTime); } } m_common.updateMaterial(rootNode, static_cast<QQuickOpenGLShaderEffectMaterial *>(rootNode->material()), diff --git a/src/particles/qquickimageparticle.cpp b/src/particles/qquickimageparticle.cpp index 9f87297b22..4ce8186c7c 100644 --- a/src/particles/qquickimageparticle.cpp +++ b/src/particles/qquickimageparticle.cpp @@ -1,6 +1,6 @@ -/**************************************************************************** +/**************************************************************************** ** -** Copyright (C) 2016 The Qt Company Ltd. +** Copyright (C) 2019 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the QtQuick module of the Qt Toolkit. @@ -41,7 +41,6 @@ #include <private/qsgadaptationlayer_p.h> #include <private/qquickitem_p.h> #include <QtQuick/qsgnode.h> -#include <QtQuick/qsgtexturematerial.h> #include <QtQuick/qsgtexture.h> #include <QFile> #include <QRandomGenerator> @@ -52,17 +51,19 @@ #include <QOpenGLFunctions> #include <QSGRendererInterface> #include <QtQuick/private/qsgshadersourcebuilder_p.h> -#include <QtQuick/private/qsgtexture_p.h> +#include <QtQuick/private/qsgplaintexture_p.h> #include <private/qqmlglobal_p.h> #include <QtQml/qqmlinfo.h> #include <cmath> +#include <QtGui/private/qrhi_p.h> QT_BEGIN_NAMESPACE -//TODO: Make it larger on desktop? Requires fixing up shader code with the same define +// Must match the shader code #define UNIFORM_ARRAY_SIZE 64 const qreal CONV = 0.017453292519943295; + class ImageMaterialData { public: @@ -85,13 +86,10 @@ class ImageMaterialData QSizeF animSheetSize; }; -class TabledMaterialData : public ImageMaterialData {}; -class TabledMaterial : public QSGSimpleMaterialShader<TabledMaterialData> +class TabledMaterialShader : public QSGMaterialShader { - QSG_DECLARE_SIMPLE_SHADER(TabledMaterial, TabledMaterialData) - public: - TabledMaterial() + TabledMaterialShader() { QSGShaderSourceBuilder builder; const bool isES = QOpenGLContext::currentContext()->isOpenGLES(); @@ -122,36 +120,47 @@ public: const char *vertexShader() const override { return m_vertex_code.constData(); } const char *fragmentShader() const override { return m_fragment_code.constData(); } - QList<QByteArray> attributes() const override { - return QList<QByteArray>() << "vPosTex" << "vData" << "vVec" - << "vColor" << "vDeformVec" << "vRotation"; - }; + char const *const *attributeNames() const override + { + static const char *const attr[] = { "vPosTex", "vData", "vVec", "vColor", "vDeformVec", "vRotation", nullptr }; + return attr; + } void initialize() override { - QSGSimpleMaterialShader<TabledMaterialData>::initialize(); program()->bind(); program()->setUniformValue("_qt_texture", 0); program()->setUniformValue("colortable", 1); glFuncs = QOpenGLContext::currentContext()->functions(); + m_matrix_id = program()->uniformLocation("qt_Matrix"); + m_opacity_id = program()->uniformLocation("qt_Opacity"); m_timestamp_id = program()->uniformLocation("timestamp"); m_entry_id = program()->uniformLocation("entry"); m_sizetable_id = program()->uniformLocation("sizetable"); m_opacitytable_id = program()->uniformLocation("opacitytable"); } - void updateState(const TabledMaterialData* d, const TabledMaterialData*) override { + void updateState(const RenderState &renderState, QSGMaterial *mat, QSGMaterial *) override { + ImageMaterialData *state = static_cast<ImageMaterial *>(mat)->state(); + + if (renderState.isMatrixDirty()) + program()->setUniformValue(m_matrix_id, renderState.combinedMatrix()); + if (renderState.isOpacityDirty() && m_opacity_id >= 0) + program()->setUniformValue(m_opacity_id, renderState.opacity()); + glFuncs->glActiveTexture(GL_TEXTURE1); - d->colorTable->bind(); + state->colorTable->bind(); glFuncs->glActiveTexture(GL_TEXTURE0); - d->texture->bind(); + state->texture->bind(); - program()->setUniformValue(m_timestamp_id, (float) d->timestamp); - program()->setUniformValue(m_entry_id, (float) d->entry); - program()->setUniformValueArray(m_sizetable_id, (const float*) d->sizeTable, UNIFORM_ARRAY_SIZE, 1); - program()->setUniformValueArray(m_opacitytable_id, (const float*) d->opacityTable, UNIFORM_ARRAY_SIZE, 1); + program()->setUniformValue(m_timestamp_id, (float) state->timestamp); + program()->setUniformValue(m_entry_id, (float) state->entry); + program()->setUniformValueArray(m_sizetable_id, (const float*) state->sizeTable, UNIFORM_ARRAY_SIZE, 1); + program()->setUniformValueArray(m_opacitytable_id, (const float*) state->opacityTable, UNIFORM_ARRAY_SIZE, 1); } + int m_matrix_id; + int m_opacity_id; int m_entry_id; int m_timestamp_id; int m_sizetable_id; @@ -161,13 +170,91 @@ public: QOpenGLFunctions* glFuncs; }; -class DeformableMaterialData : public ImageMaterialData {}; -class DeformableMaterial : public QSGSimpleMaterialShader<DeformableMaterialData> +class TabledMaterialRhiShader : public QSGMaterialRhiShader +{ +public: + TabledMaterialRhiShader() + { + setShaderFileName(VertexStage, QStringLiteral(":/particles/shaders_ng/imageparticle_tabled.vert.qsb")); + setShaderFileName(FragmentStage, QStringLiteral(":/particles/shaders_ng/imageparticle_tabled.frag.qsb")); + } + + bool updateUniformData(RenderState &renderState, QSGMaterial *newMaterial, QSGMaterial *) override + { + QByteArray *buf = renderState.uniformData(); + Q_ASSERT(buf->size() >= 80 + 2 * (UNIFORM_ARRAY_SIZE * 4 * 4)); + + if (renderState.isMatrixDirty()) { + const QMatrix4x4 m = renderState.combinedMatrix(); + memcpy(buf->data(), m.constData(), 64); + } + + if (renderState.isOpacityDirty()) { + const float opacity = renderState.opacity(); + memcpy(buf->data() + 64, &opacity, 4); + } + + ImageMaterialData *state = static_cast<ImageMaterial *>(newMaterial)->state(); + + float entry = float(state->entry); + memcpy(buf->data() + 68, &entry, 4); + + float timestamp = float(state->timestamp); + memcpy(buf->data() + 72, ×tamp, 4); + + float *p = reinterpret_cast<float *>(buf->data() + 80); + for (int i = 0; i < UNIFORM_ARRAY_SIZE; ++i) { + *p = state->sizeTable[i]; + p += 4; + } + p = reinterpret_cast<float *>(buf->data() + 80 + (UNIFORM_ARRAY_SIZE * 4 * 4)); + for (int i = 0; i < UNIFORM_ARRAY_SIZE; ++i) { + *p = state->opacityTable[i]; + p += 4; + } + + return true; + } + + void updateSampledImage(RenderState &renderState, int binding, QSGTexture **texture, + QSGMaterial *newMaterial, QSGMaterial *) override + { + ImageMaterialData *state = static_cast<ImageMaterial *>(newMaterial)->state(); + if (binding == 2) { + state->colorTable->updateRhiTexture(renderState.rhi(), renderState.resourceUpdateBatch()); + *texture = state->colorTable; + } else if (binding == 1) { + state->texture->updateRhiTexture(renderState.rhi(), renderState.resourceUpdateBatch()); + *texture = state->texture; + } + } +}; + +class TabledMaterial : public ImageMaterial { - QSG_DECLARE_SIMPLE_SHADER(DeformableMaterial, DeformableMaterialData) +public: + TabledMaterial() { setFlag(SupportsRhiShader, true); } + QSGMaterialShader *createShader() const override { + if (flags().testFlag(RhiShaderWanted)) + return new TabledMaterialRhiShader; + else + return new TabledMaterialShader; + } + QSGMaterialType *type() const override { return &m_type; } + + ImageMaterialData *state() override { return &m_state; } +private: + static QSGMaterialType m_type; + ImageMaterialData m_state; +}; + +QSGMaterialType TabledMaterial::m_type; + +class DeformableMaterialShader : public QSGMaterialShader +{ public: - DeformableMaterial() + DeformableMaterialShader() { QSGShaderSourceBuilder builder; const bool isES = QOpenGLContext::currentContext()->isOpenGLES(); @@ -196,27 +283,38 @@ public: const char *vertexShader() const override { return m_vertex_code.constData(); } const char *fragmentShader() const override { return m_fragment_code.constData(); } - QList<QByteArray> attributes() const override { - return QList<QByteArray>() << "vPosTex" << "vData" << "vVec" - << "vColor" << "vDeformVec" << "vRotation"; - }; + char const *const *attributeNames() const override + { + static const char *const attr[] = { "vPosTex", "vData", "vVec", "vColor", "vDeformVec", "vRotation", nullptr }; + return attr; + } void initialize() override { - QSGSimpleMaterialShader<DeformableMaterialData>::initialize(); program()->bind(); program()->setUniformValue("_qt_texture", 0); glFuncs = QOpenGLContext::currentContext()->functions(); + m_matrix_id = program()->uniformLocation("qt_Matrix"); + m_opacity_id = program()->uniformLocation("qt_Opacity"); m_timestamp_id = program()->uniformLocation("timestamp"); m_entry_id = program()->uniformLocation("entry"); } - void updateState(const DeformableMaterialData* d, const DeformableMaterialData*) override { - d->texture->bind(); + void updateState(const RenderState &renderState, QSGMaterial *mat, QSGMaterial *) override { + ImageMaterialData *state = static_cast<ImageMaterial *>(mat)->state(); + + if (renderState.isMatrixDirty()) + program()->setUniformValue(m_matrix_id, renderState.combinedMatrix()); + if (renderState.isOpacityDirty() && m_opacity_id >= 0) + program()->setUniformValue(m_opacity_id, renderState.opacity()); + + state->texture->bind(); - program()->setUniformValue(m_timestamp_id, (float) d->timestamp); - program()->setUniformValue(m_entry_id, (float) d->entry); + program()->setUniformValue(m_timestamp_id, (float) state->timestamp); + program()->setUniformValue(m_entry_id, (float) state->entry); } + int m_matrix_id; + int m_opacity_id; int m_entry_id; int m_timestamp_id; QByteArray m_vertex_code; @@ -224,13 +322,77 @@ public: QOpenGLFunctions* glFuncs; }; -class SpriteMaterialData : public ImageMaterialData {}; -class SpriteMaterial : public QSGSimpleMaterialShader<SpriteMaterialData> +class DeformableMaterialRhiShader : public QSGMaterialRhiShader { - QSG_DECLARE_SIMPLE_SHADER(SpriteMaterial, SpriteMaterialData) +public: + DeformableMaterialRhiShader() + { + setShaderFileName(VertexStage, QStringLiteral(":/particles/shaders_ng/imageparticle_deformed.vert.qsb")); + setShaderFileName(FragmentStage, QStringLiteral(":/particles/shaders_ng/imageparticle_deformed.frag.qsb")); + } + bool updateUniformData(RenderState &renderState, QSGMaterial *newMaterial, QSGMaterial *) override + { + QByteArray *buf = renderState.uniformData(); + Q_ASSERT(buf->size() >= 80 + 2 * (UNIFORM_ARRAY_SIZE * 4 * 4)); + + if (renderState.isMatrixDirty()) { + const QMatrix4x4 m = renderState.combinedMatrix(); + memcpy(buf->data(), m.constData(), 64); + } + + if (renderState.isOpacityDirty()) { + const float opacity = renderState.opacity(); + memcpy(buf->data() + 64, &opacity, 4); + } + + ImageMaterialData *state = static_cast<ImageMaterial *>(newMaterial)->state(); + + float entry = float(state->entry); + memcpy(buf->data() + 68, &entry, 4); + + float timestamp = float(state->timestamp); + memcpy(buf->data() + 72, ×tamp, 4); + + return true; + } + + void updateSampledImage(RenderState &renderState, int binding, QSGTexture **texture, + QSGMaterial *newMaterial, QSGMaterial *) override + { + ImageMaterialData *state = static_cast<ImageMaterial *>(newMaterial)->state(); + if (binding == 1) { + state->texture->updateRhiTexture(renderState.rhi(), renderState.resourceUpdateBatch()); + *texture = state->texture; + } + } +}; + +class DeformableMaterial : public ImageMaterial +{ public: - SpriteMaterial() + DeformableMaterial() { setFlag(SupportsRhiShader, true); } + QSGMaterialShader *createShader() const override { + if (flags().testFlag(RhiShaderWanted)) + return new DeformableMaterialRhiShader; + else + return new DeformableMaterialShader; + } + QSGMaterialType *type() const override { return &m_type; } + + ImageMaterialData *state() override { return &m_state; } + +private: + static QSGMaterialType m_type; + ImageMaterialData m_state; +}; + +QSGMaterialType DeformableMaterial::m_type; + +class SpriteMaterialShader : public QSGMaterialShader +{ +public: + SpriteMaterialShader() { QSGShaderSourceBuilder builder; const bool isES = QOpenGLContext::currentContext()->isOpenGLES(); @@ -263,17 +425,20 @@ public: const char *vertexShader() const override { return m_vertex_code.constData(); } const char *fragmentShader() const override { return m_fragment_code.constData(); } - QList<QByteArray> attributes() const override { - return QList<QByteArray>() << "vPosTex" << "vData" << "vVec" - << "vColor" << "vDeformVec" << "vRotation" << "vAnimData" << "vAnimPos"; + char const *const *attributeNames() const override + { + static const char *const attr[] = { "vPosTex", "vData", "vVec", "vColor", "vDeformVec", "vRotation", + "vAnimData", "vAnimPos", nullptr }; + return attr; } void initialize() override { - QSGSimpleMaterialShader<SpriteMaterialData>::initialize(); program()->bind(); program()->setUniformValue("_qt_texture", 0); program()->setUniformValue("colortable", 1); glFuncs = QOpenGLContext::currentContext()->functions(); + m_matrix_id = program()->uniformLocation("qt_Matrix"); + m_opacity_id = program()->uniformLocation("qt_Opacity"); //Don't actually expose the animSheetSize in the shader, it's currently only used for CPU calculations. m_timestamp_id = program()->uniformLocation("timestamp"); m_entry_id = program()->uniformLocation("entry"); @@ -281,20 +446,29 @@ public: m_opacitytable_id = program()->uniformLocation("opacitytable"); } - void updateState(const SpriteMaterialData* d, const SpriteMaterialData*) override { + void updateState(const RenderState &renderState, QSGMaterial *mat, QSGMaterial *) override { + ImageMaterialData *state = static_cast<ImageMaterial *>(mat)->state(); + + if (renderState.isMatrixDirty()) + program()->setUniformValue(m_matrix_id, renderState.combinedMatrix()); + if (renderState.isOpacityDirty() && m_opacity_id >= 0) + program()->setUniformValue(m_opacity_id, renderState.opacity()); + glFuncs->glActiveTexture(GL_TEXTURE1); - d->colorTable->bind(); + state->colorTable->bind(); // make sure we end by setting GL_TEXTURE0 as active texture glFuncs->glActiveTexture(GL_TEXTURE0); - d->texture->bind(); + state->texture->bind(); - program()->setUniformValue(m_timestamp_id, (float) d->timestamp); - program()->setUniformValue(m_entry_id, (float) d->entry); - program()->setUniformValueArray(m_sizetable_id, (const float*) d->sizeTable, 64, 1); - program()->setUniformValueArray(m_opacitytable_id, (const float*) d->opacityTable, UNIFORM_ARRAY_SIZE, 1); + program()->setUniformValue(m_timestamp_id, (float) state->timestamp); + program()->setUniformValue(m_entry_id, (float) state->entry); + program()->setUniformValueArray(m_sizetable_id, (const float*) state->sizeTable, 64, 1); + program()->setUniformValueArray(m_opacitytable_id, (const float*) state->opacityTable, UNIFORM_ARRAY_SIZE, 1); } + int m_matrix_id; + int m_opacity_id; int m_timestamp_id; int m_entry_id; int m_sizetable_id; @@ -304,13 +478,91 @@ public: QOpenGLFunctions* glFuncs; }; -class ColoredMaterialData : public ImageMaterialData {}; -class ColoredMaterial : public QSGSimpleMaterialShader<ColoredMaterialData> +class SpriteMaterialRhiShader : public QSGMaterialRhiShader { - QSG_DECLARE_SIMPLE_SHADER(ColoredMaterial, ColoredMaterialData) +public: + SpriteMaterialRhiShader() + { + setShaderFileName(VertexStage, QStringLiteral(":/particles/shaders_ng/imageparticle_sprite.vert.qsb")); + setShaderFileName(FragmentStage, QStringLiteral(":/particles/shaders_ng/imageparticle_sprite.frag.qsb")); + } + + bool updateUniformData(RenderState &renderState, QSGMaterial *newMaterial, QSGMaterial *) override + { + QByteArray *buf = renderState.uniformData(); + Q_ASSERT(buf->size() >= 80 + 2 * (UNIFORM_ARRAY_SIZE * 4 * 4)); + + if (renderState.isMatrixDirty()) { + const QMatrix4x4 m = renderState.combinedMatrix(); + memcpy(buf->data(), m.constData(), 64); + } + + if (renderState.isOpacityDirty()) { + const float opacity = renderState.opacity(); + memcpy(buf->data() + 64, &opacity, 4); + } + ImageMaterialData *state = static_cast<ImageMaterial *>(newMaterial)->state(); + + float entry = float(state->entry); + memcpy(buf->data() + 68, &entry, 4); + + float timestamp = float(state->timestamp); + memcpy(buf->data() + 72, ×tamp, 4); + + float *p = reinterpret_cast<float *>(buf->data() + 80); + for (int i = 0; i < UNIFORM_ARRAY_SIZE; ++i) { + *p = state->sizeTable[i]; + p += 4; + } + p = reinterpret_cast<float *>(buf->data() + 80 + (UNIFORM_ARRAY_SIZE * 4 * 4)); + for (int i = 0; i < UNIFORM_ARRAY_SIZE; ++i) { + *p = state->opacityTable[i]; + p += 4; + } + + return true; + } + + void updateSampledImage(RenderState &renderState, int binding, QSGTexture **texture, + QSGMaterial *newMaterial, QSGMaterial *) override + { + ImageMaterialData *state = static_cast<ImageMaterial *>(newMaterial)->state(); + if (binding == 2) { + state->colorTable->updateRhiTexture(renderState.rhi(), renderState.resourceUpdateBatch()); + *texture = state->colorTable; + } else if (binding == 1) { + state->texture->updateRhiTexture(renderState.rhi(), renderState.resourceUpdateBatch()); + *texture = state->texture; + } + } +}; + +class SpriteMaterial : public ImageMaterial +{ public: - ColoredMaterial() + SpriteMaterial() { setFlag(SupportsRhiShader, true); } + QSGMaterialShader *createShader() const override { + if (flags().testFlag(RhiShaderWanted)) + return new SpriteMaterialRhiShader; + else + return new SpriteMaterialShader; + } + QSGMaterialType *type() const override { return &m_type; } + + ImageMaterialData *state() override { return &m_state; } + +private: + static QSGMaterialType m_type; + ImageMaterialData m_state; +}; + +QSGMaterialType SpriteMaterial::m_type; + +class ColoredMaterialShader : public QSGMaterialShader +{ +public: + ColoredMaterialShader() { QSGShaderSourceBuilder builder; const bool isES = QOpenGLContext::currentContext()->isOpenGLES(); @@ -337,8 +589,23 @@ public: const char *vertexShader() const override { return m_vertex_code.constData(); } const char *fragmentShader() const override { return m_fragment_code.constData(); } + char const *const *attributeNames() const override + { + static const char *const attr[] = { "vPos", "vData", "vVec", "vColor", nullptr }; + return attr; + } + + void initialize() override { + program()->bind(); + program()->setUniformValue("_qt_texture", 0); + glFuncs = QOpenGLContext::currentContext()->functions(); + m_matrix_id = program()->uniformLocation("qt_Matrix"); + m_opacity_id = program()->uniformLocation("qt_Opacity"); + m_timestamp_id = program()->uniformLocation("timestamp"); + m_entry_id = program()->uniformLocation("entry"); + } + void activate() override { - QSGSimpleMaterialShader<ColoredMaterialData>::activate(); #if !defined(QT_OPENGL_ES_2) && !defined(Q_OS_WIN) glEnable(GL_POINT_SPRITE); glEnable(GL_VERTEX_PROGRAM_POINT_SIZE); @@ -346,33 +613,28 @@ public: } void deactivate() override { - QSGSimpleMaterialShader<ColoredMaterialData>::deactivate(); #if !defined(QT_OPENGL_ES_2) && !defined(Q_OS_WIN) glDisable(GL_POINT_SPRITE); glDisable(GL_VERTEX_PROGRAM_POINT_SIZE); #endif } - QList<QByteArray> attributes() const override { - return QList<QByteArray>() << "vPos" << "vData" << "vVec" << "vColor"; - } + void updateState(const RenderState &renderState, QSGMaterial *mat, QSGMaterial *) override { + ImageMaterialData *state = static_cast<ImageMaterial *>(mat)->state(); - void initialize() override { - QSGSimpleMaterialShader<ColoredMaterialData>::initialize(); - program()->bind(); - program()->setUniformValue("_qt_texture", 0); - glFuncs = QOpenGLContext::currentContext()->functions(); - m_timestamp_id = program()->uniformLocation("timestamp"); - m_entry_id = program()->uniformLocation("entry"); - } + if (renderState.isMatrixDirty()) + program()->setUniformValue(m_matrix_id, renderState.combinedMatrix()); + if (renderState.isOpacityDirty() && m_opacity_id >= 0) + program()->setUniformValue(m_opacity_id, renderState.opacity()); - void updateState(const ColoredMaterialData* d, const ColoredMaterialData*) override { - d->texture->bind(); + state->texture->bind(); - program()->setUniformValue(m_timestamp_id, (float) d->timestamp); - program()->setUniformValue(m_entry_id, (float) d->entry); + program()->setUniformValue(m_timestamp_id, (float) state->timestamp); + program()->setUniformValue(m_entry_id, (float) state->entry); } + int m_matrix_id; + int m_opacity_id; int m_timestamp_id; int m_entry_id; QByteArray m_vertex_code; @@ -380,13 +642,77 @@ public: QOpenGLFunctions* glFuncs; }; -class SimpleMaterialData : public ImageMaterialData {}; -class SimpleMaterial : public QSGSimpleMaterialShader<SimpleMaterialData> +class ColoredMaterialRhiShader : public QSGMaterialRhiShader +{ +public: + ColoredMaterialRhiShader() + { + setShaderFileName(VertexStage, QStringLiteral(":/particles/shaders_ng/imageparticle_colored.vert.qsb")); + setShaderFileName(FragmentStage, QStringLiteral(":/particles/shaders_ng/imageparticle_colored.frag.qsb")); + } + + bool updateUniformData(RenderState &renderState, QSGMaterial *newMaterial, QSGMaterial *) override + { + QByteArray *buf = renderState.uniformData(); + Q_ASSERT(buf->size() >= 80 + 2 * (UNIFORM_ARRAY_SIZE * 4 * 4)); + + if (renderState.isMatrixDirty()) { + const QMatrix4x4 m = renderState.combinedMatrix(); + memcpy(buf->data(), m.constData(), 64); + } + + if (renderState.isOpacityDirty()) { + const float opacity = renderState.opacity(); + memcpy(buf->data() + 64, &opacity, 4); + } + + ImageMaterialData *state = static_cast<ImageMaterial *>(newMaterial)->state(); + + float entry = float(state->entry); + memcpy(buf->data() + 68, &entry, 4); + + float timestamp = float(state->timestamp); + memcpy(buf->data() + 72, ×tamp, 4); + + return true; + } + + void updateSampledImage(RenderState &renderState, int binding, QSGTexture **texture, + QSGMaterial *newMaterial, QSGMaterial *) override + { + ImageMaterialData *state = static_cast<ImageMaterial *>(newMaterial)->state(); + if (binding == 1) { + state->texture->updateRhiTexture(renderState.rhi(), renderState.resourceUpdateBatch()); + *texture = state->texture; + } + } +}; + +class ColoredMaterial : public ImageMaterial { - QSG_DECLARE_SIMPLE_SHADER(SimpleMaterial, SimpleMaterialData) +public: + ColoredMaterial() { setFlag(SupportsRhiShader, true); } + QSGMaterialShader *createShader() const override { + if (flags().testFlag(RhiShaderWanted)) + return new ColoredMaterialRhiShader; + else + return new ColoredMaterialShader; + } + QSGMaterialType *type() const override { return &m_type; } + ImageMaterialData *state() override { return &m_state; } + +private: + static QSGMaterialType m_type; + ImageMaterialData m_state; +}; + +QSGMaterialType ColoredMaterial::m_type; + +class SimpleMaterialShader : public QSGMaterialShader +{ public: - SimpleMaterial() + SimpleMaterialShader() { QSGShaderSourceBuilder builder; const bool isES = QOpenGLContext::currentContext()->isOpenGLES(); @@ -411,8 +737,23 @@ public: const char *vertexShader() const override { return m_vertex_code.constData(); } const char *fragmentShader() const override { return m_fragment_code.constData(); } + char const *const *attributeNames() const override + { + static const char *const attr[] = { "vPos", "vData", "vVec", nullptr }; + return attr; + } + + void initialize() override { + program()->bind(); + program()->setUniformValue("_qt_texture", 0); + glFuncs = QOpenGLContext::currentContext()->functions(); + m_matrix_id = program()->uniformLocation("qt_Matrix"); + m_opacity_id = program()->uniformLocation("qt_Opacity"); + m_timestamp_id = program()->uniformLocation("timestamp"); + m_entry_id = program()->uniformLocation("entry"); + } + void activate() override { - QSGSimpleMaterialShader<SimpleMaterialData>::activate(); #if !defined(QT_OPENGL_ES_2) && !defined(Q_OS_WIN) glEnable(GL_POINT_SPRITE); glEnable(GL_VERTEX_PROGRAM_POINT_SIZE); @@ -420,33 +761,28 @@ public: } void deactivate() override { - QSGSimpleMaterialShader<SimpleMaterialData>::deactivate(); #if !defined(QT_OPENGL_ES_2) && !defined(Q_OS_WIN) glDisable(GL_POINT_SPRITE); glDisable(GL_VERTEX_PROGRAM_POINT_SIZE); #endif } - QList<QByteArray> attributes() const override { - return QList<QByteArray>() << "vPos" << "vData" << "vVec"; - } + void updateState(const RenderState &renderState, QSGMaterial *mat, QSGMaterial *) override { + ImageMaterialData *state = static_cast<ImageMaterial *>(mat)->state(); - void initialize() override { - QSGSimpleMaterialShader<SimpleMaterialData>::initialize(); - program()->bind(); - program()->setUniformValue("_qt_texture", 0); - glFuncs = QOpenGLContext::currentContext()->functions(); - m_timestamp_id = program()->uniformLocation("timestamp"); - m_entry_id = program()->uniformLocation("entry"); - } + if (renderState.isMatrixDirty()) + program()->setUniformValue(m_matrix_id, renderState.combinedMatrix()); + if (renderState.isOpacityDirty() && m_opacity_id >= 0) + program()->setUniformValue(m_opacity_id, renderState.opacity()); - void updateState(const SimpleMaterialData* d, const SimpleMaterialData*) override { - d->texture->bind(); + state->texture->bind(); - program()->setUniformValue(m_timestamp_id, (float) d->timestamp); - program()->setUniformValue(m_entry_id, (float) d->entry); + program()->setUniformValue(m_timestamp_id, (float) state->timestamp); + program()->setUniformValue(m_entry_id, (float) state->entry); } + int m_matrix_id; + int m_opacity_id; int m_timestamp_id; int m_entry_id; QByteArray m_vertex_code; @@ -454,6 +790,73 @@ public: QOpenGLFunctions* glFuncs; }; +class SimpleMaterialRhiShader : public QSGMaterialRhiShader +{ +public: + SimpleMaterialRhiShader() + { + setShaderFileName(VertexStage, QStringLiteral(":/particles/shaders_ng/imageparticle_simple.vert.qsb")); + setShaderFileName(FragmentStage, QStringLiteral(":/particles/shaders_ng/imageparticle_simple.frag.qsb")); + } + + bool updateUniformData(RenderState &renderState, QSGMaterial *newMaterial, QSGMaterial *) override + { + QByteArray *buf = renderState.uniformData(); + Q_ASSERT(buf->size() >= 80 + 2 * (UNIFORM_ARRAY_SIZE * 4 * 4)); + + if (renderState.isMatrixDirty()) { + const QMatrix4x4 m = renderState.combinedMatrix(); + memcpy(buf->data(), m.constData(), 64); + } + + if (renderState.isOpacityDirty()) { + const float opacity = renderState.opacity(); + memcpy(buf->data() + 64, &opacity, 4); + } + + ImageMaterialData *state = static_cast<ImageMaterial *>(newMaterial)->state(); + + float entry = float(state->entry); + memcpy(buf->data() + 68, &entry, 4); + + float timestamp = float(state->timestamp); + memcpy(buf->data() + 72, ×tamp, 4); + + return true; + } + + void updateSampledImage(RenderState &renderState, int binding, QSGTexture **texture, + QSGMaterial *newMaterial, QSGMaterial *) override + { + ImageMaterialData *state = static_cast<ImageMaterial *>(newMaterial)->state(); + if (binding == 1) { + state->texture->updateRhiTexture(renderState.rhi(), renderState.resourceUpdateBatch()); + *texture = state->texture; + } + } +}; + +class SimpleMaterial : public ImageMaterial +{ +public: + SimpleMaterial() { setFlag(SupportsRhiShader, true); } + QSGMaterialShader *createShader() const override { + if (flags().testFlag(RhiShaderWanted)) + return new SimpleMaterialRhiShader; + else + return new SimpleMaterialShader; + } + QSGMaterialType *type() const override { return &m_type; } + + ImageMaterialData *state() override { return &m_state; } + +private: + static QSGMaterialType m_type; + ImageMaterialData m_state; +}; + +QSGMaterialType SimpleMaterial::m_type; + void fillUniformArrayFromImage(float* array, const QImage& img, int size) { if (img.isNull()){ @@ -727,6 +1130,8 @@ QQuickImageParticle::QQuickImageParticle(QQuickItem* parent) , m_debugMode(false) , m_entryEffect(Fade) , m_startedImageLoading(0) + , m_rhi(nullptr) + , m_apiChecked(false) { setFlag(ItemHasContents); } @@ -1003,7 +1408,7 @@ void QQuickImageParticle::setEntryEffect(EntryEffect arg) if (m_entryEffect != arg) { m_entryEffect = arg; if (m_material) - getState<ImageMaterialData>(m_material)->entry = (qreal) m_entryEffect; + getState(m_material)->entry = (qreal) m_entryEffect; emit entryEffectChanged(arg); } } @@ -1227,7 +1632,7 @@ void QQuickImageParticle::buildParticleNodes(QSGNode** passThrough) void QQuickImageParticle::finishBuildParticleNodes(QSGNode** node) { - if (!QOpenGLContext::currentContext()) + if (!m_rhi && !QOpenGLContext::currentContext()) return; if (m_count * 4 > 0xffff) { @@ -1274,28 +1679,38 @@ void QQuickImageParticle::finishBuildParticleNodes(QSGNode** node) } } } + + if (!m_rhi) { // the RHI may be backed by GL but these checks should be obsolete in any case #ifdef Q_OS_WIN - if (perfLevel < Deformable) //QTBUG-24540 , point sprite 'extension' isn't working on windows. - perfLevel = Deformable; + if (perfLevel < Deformable) //QTBUG-24540 , point sprite 'extension' isn't working on windows. + perfLevel = Deformable; #endif #ifdef Q_OS_MAC - // OS X 10.8.3 introduced a bug in the AMD drivers, for at least the 2011 macbook pros, - // causing point sprites who read gl_PointCoord in the frag shader to come out as - // green-red blobs. - const GLubyte *glVendor = QOpenGLContext::currentContext()->functions()->glGetString(GL_VENDOR); - if (perfLevel < Deformable && glVendor && strstr((char *) glVendor, "ATI")) { - perfLevel = Deformable; - } + // macOS 10.8.3 introduced a bug in the AMD drivers, for at least the 2011 macbook pros, + // causing point sprites who read gl_PointCoord in the frag shader to come out as + // green-red blobs. + const GLubyte *glVendor = QOpenGLContext::currentContext()->functions()->glGetString(GL_VENDOR); + if (perfLevel < Deformable && glVendor && strstr((char *) glVendor, "ATI")) { + perfLevel = Deformable; + } #endif #ifdef Q_OS_LINUX - // Nouveau drivers can potentially freeze a machine entirely when taking the point-sprite path. - const GLubyte *glVendor = QOpenGLContext::currentContext()->functions()->glGetString(GL_VENDOR); - if (perfLevel < Deformable && glVendor && strstr((const char *) glVendor, "nouveau")) - perfLevel = Deformable; + // Nouveau drivers can potentially freeze a machine entirely when taking the point-sprite path. + const GLubyte *glVendor = QOpenGLContext::currentContext()->functions()->glGetString(GL_VENDOR); + if (perfLevel < Deformable && glVendor && strstr((const char *) glVendor, "nouveau")) + perfLevel = Deformable; #endif + } else { + // Points with a size other than 1 are an optional feature with QRhi + // because some of the underlying APIs have no support for this. + // Therefore, avoid the point sprite path with APIs like Direct3D. + if (perfLevel < Deformable && !m_rhi->isFeatureSupported(QRhi::VertexShaderPointSize)) + perfLevel = Deformable; + } + if (perfLevel >= Colored && !m_color.isValid()) m_color = QColor(Qt::white);//Hidden default, but different from unset @@ -1311,6 +1726,7 @@ void QQuickImageParticle::finishBuildParticleNodes(QSGNode** node) bool imageLoaded = false; switch (perfLevel) {//Fallthrough intended case Sprites: + { if (!m_spriteEngine) { qWarning() << "ImageParticle: No sprite engine..."; //Sprite performance mode with static image is supported, but not advised @@ -1321,16 +1737,19 @@ void QQuickImageParticle::finishBuildParticleNodes(QSGNode** node) return; imageLoaded = true; } - m_material = SpriteMaterial::createMaterial(); + m_material = new SpriteMaterial; + ImageMaterialData *state = getState(m_material); if (imageLoaded) - getState<ImageMaterialData>(m_material)->texture = QSGPlainTexture::fromImage(image); - getState<ImageMaterialData>(m_material)->animSheetSize = QSizeF(image.size() / image.devicePixelRatioF()); + state->texture = QSGPlainTexture::fromImage(image); + state->animSheetSize = QSizeF(image.size() / image.devicePixelRatioF()); if (m_spriteEngine) m_spriteEngine->setCount(m_count); + } Q_FALLTHROUGH(); case Tabled: + { if (!m_material) - m_material = TabledMaterial::createMaterial(); + m_material = new TabledMaterial; if (m_colorTable) { if (m_colorTable->pix.isReady()) @@ -1357,21 +1776,29 @@ void QQuickImageParticle::finishBuildParticleNodes(QSGNode** node) colortable = QImage(1,1,QImage::Format_ARGB32_Premultiplied); colortable.fill(Qt::white); } - getState<ImageMaterialData>(m_material)->colorTable = QSGPlainTexture::fromImage(colortable); - fillUniformArrayFromImage(getState<ImageMaterialData>(m_material)->sizeTable, sizetable, UNIFORM_ARRAY_SIZE); - fillUniformArrayFromImage(getState<ImageMaterialData>(m_material)->opacityTable, opacitytable, UNIFORM_ARRAY_SIZE); + ImageMaterialData *state = getState(m_material); + state->colorTable = QSGPlainTexture::fromImage(colortable); + fillUniformArrayFromImage(state->sizeTable, sizetable, UNIFORM_ARRAY_SIZE); + fillUniformArrayFromImage(state->opacityTable, opacitytable, UNIFORM_ARRAY_SIZE); + } Q_FALLTHROUGH(); case Deformable: + { if (!m_material) - m_material = DeformableMaterial::createMaterial(); + m_material = new DeformableMaterial; + } Q_FALLTHROUGH(); case Colored: + { if (!m_material) - m_material = ColoredMaterial::createMaterial(); + m_material = new ColoredMaterial; + } Q_FALLTHROUGH(); default://Also Simple + { if (!m_material) - m_material = SimpleMaterial::createMaterial(); + m_material = new SimpleMaterial; + ImageMaterialData *state = getState(m_material); if (!imageLoaded) { if (!m_image || !m_image->pix.isReady()) { if (m_image) @@ -1379,14 +1806,15 @@ void QQuickImageParticle::finishBuildParticleNodes(QSGNode** node) delete m_material; return; } - //getState<ImageMaterialData>(m_material)->texture //TODO: Shouldn't this be better? But not crash? + //state->texture //TODO: Shouldn't this be better? But not crash? // = QQuickItemPrivate::get(this)->sceneGraphContext()->textureForFactory(m_imagePix.textureFactory()); - getState<ImageMaterialData>(m_material)->texture = QSGPlainTexture::fromImage(m_image->pix.image()); + state->texture = QSGPlainTexture::fromImage(m_image->pix.image()); } - getState<ImageMaterialData>(m_material)->texture->setFiltering(QSGTexture::Linear); - getState<ImageMaterialData>(m_material)->entry = (qreal) m_entryEffect; + state->texture->setFiltering(QSGTexture::Linear); + state->entry = (qreal) m_entryEffect; m_material->setFlag(QSGMaterial::Blending | QSGMaterial::RequiresFullMatrix); } + } m_nodes.clear(); for (auto groupId : groupIds()) { @@ -1419,14 +1847,23 @@ void QQuickImageParticle::finishBuildParticleNodes(QSGNode** node) node->setFlag(QSGNode::OwnsGeometry); node->setGeometry(g); if (perfLevel <= Colored){ - g->setDrawingMode(GL_POINTS); - if (m_debugMode){ - GLfloat pointSizeRange[2]; - QOpenGLContext::currentContext()->functions()->glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, pointSizeRange); - qDebug() << "Using point sprites, GL_ALIASED_POINT_SIZE_RANGE " <<pointSizeRange[0] << ":" << pointSizeRange[1]; + g->setDrawingMode(QSGGeometry::DrawPoints); + if (m_debugMode) { + if (m_rhi) { + qDebug("Using point sprites"); + } else { +#if QT_CONFIG(opengl) + GLfloat pointSizeRange[2]; + QOpenGLContext::currentContext()->functions()->glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE, pointSizeRange); + qDebug() << "Using point sprites, GL_ALIASED_POINT_SIZE_RANGE " <<pointSizeRange[0] << ":" << pointSizeRange[1]; +#else + qDebug("Using point sprites"); +#endif + } } - }else - g->setDrawingMode(GL_TRIANGLES); + } else { + g->setDrawingMode(QSGGeometry::DrawTriangles); + } for (int p=0; p < count; ++p) commit(groupId, p);//commit sets geometry for the node, has its own perfLevel switch @@ -1467,16 +1904,34 @@ void QQuickImageParticle::finishBuildParticleNodes(QSGNode** node) update(); } -static inline bool isOpenGL(QSGRenderContext *rc) -{ - QSGRendererInterface *rif = rc->sceneGraphContext()->rendererInterface(rc); - return !rif || rif->graphicsApi() == QSGRendererInterface::OpenGL; -} - QSGNode *QQuickImageParticle::updatePaintNode(QSGNode *node, UpdatePaintNodeData *) { - if (!node && !isOpenGL(QQuickItemPrivate::get(this)->sceneGraphRenderContext())) - return nullptr; + if (!m_apiChecked || m_windowChanged) { + m_apiChecked = true; + m_windowChanged = false; + + QSGRenderContext *rc = QQuickItemPrivate::get(this)->sceneGraphRenderContext(); + QSGRendererInterface *rif = rc->sceneGraphContext()->rendererInterface(rc); + if (!rif) + return nullptr; + + QSGRendererInterface::GraphicsApi api = rif->graphicsApi(); + const bool isDirectOpenGL = api == QSGRendererInterface::OpenGL; + const bool isRhi = QSGRendererInterface::isApiRhiBased(api); + + if (!node && !isDirectOpenGL && !isRhi) + return nullptr; + + if (isRhi) + m_rhi = static_cast<QRhi *>(rif->getResource(m_window, QSGRendererInterface::RhiResource)); + else + m_rhi = nullptr; + + if (isRhi && !m_rhi) { + qWarning("Failed to query QRhi, particles disabled"); + return nullptr; + } + } if (m_pleaseReset){ // Cannot just destroy the node and then return null (in case image @@ -1555,7 +2010,7 @@ void QQuickImageParticle::prepareNextFrame(QSGNode **node) case Colored: case Simple: default: //Also Simple - getState<ImageMaterialData>(m_material)->timestamp = time; + getState(m_material)->timestamp = time; break; } foreach (QSGGeometryNode* node, m_nodes) @@ -1564,6 +2019,7 @@ void QQuickImageParticle::prepareNextFrame(QSGNode **node) void QQuickImageParticle::spritesUpdate(qreal time) { + ImageMaterialData *state = getState(m_material); // Sprite progression handled CPU side, so as to have per-frame control. for (auto groupId : groupIds()) { for (QQuickParticleData* mainDatum : qAsConst(m_system->groupData[groupId]->data)) { @@ -1601,7 +2057,7 @@ void QQuickImageParticle::spritesUpdate(qreal time) } if (m_spriteEngine->sprite(spriteIdx)->reverse())//### Store this in datum too? frameAt = (datum->frameCount - 1) - frameAt; - QSizeF sheetSize = getState<ImageMaterialData>(m_material)->animSheetSize; + QSizeF sheetSize = state->animSheetSize; qreal y = datum->animY / sheetSize.height(); qreal w = datum->animWidth / sheetSize.width(); qreal h = datum->animHeight / sheetSize.height(); @@ -1700,6 +2156,7 @@ void QQuickImageParticle::initialize(int gIdx, int pIdx) writeTo->animHeight = m_spriteEngine->spriteHeight(spriteIdx); } } else { + ImageMaterialData *state = getState(m_material); QQuickParticleData* writeTo = getShadowDatum(datum); writeTo->animT = datum->t; writeTo->frameCount = 1; @@ -1708,8 +2165,8 @@ void QQuickImageParticle::initialize(int gIdx, int pIdx) writeTo->animIdx = 0; writeTo->animT = 0; writeTo->animX = writeTo->animY = 0; - writeTo->animWidth = getState<ImageMaterialData>(m_material)->animSheetSize.width(); - writeTo->animHeight = getState<ImageMaterialData>(m_material)->animSheetSize.height(); + writeTo->animWidth = state->animSheetSize.width(); + writeTo->animHeight = state->animSheetSize.height(); } Q_FALLTHROUGH(); case Tabled: diff --git a/src/particles/qquickimageparticle_p.h b/src/particles/qquickimageparticle_p.h index e9ac56d64e..45eb73b86c 100644 --- a/src/particles/qquickimageparticle_p.h +++ b/src/particles/qquickimageparticle_p.h @@ -1,6 +1,6 @@ /**************************************************************************** ** -** Copyright (C) 2016 The Qt Company Ltd. +** Copyright (C) 2019 The Qt Company Ltd. ** Contact: https://www.qt.io/licensing/ ** ** This file is part of the QtQuick module of the Qt Toolkit. @@ -37,8 +37,8 @@ ** ****************************************************************************/ -#ifndef ULTRAPARTICLE_H -#define ULTRAPARTICLE_H +#ifndef QQUICKIMAGEPARTICLE_P_H +#define QQUICKIMAGEPARTICLE_P_H // // W A R N I N G @@ -50,21 +50,25 @@ // // We mean it. // + #include "qquickparticlepainter_p.h" #include "qquickdirection_p.h" #include <private/qquickpixmapcache_p.h> #include <QQmlListProperty> -#include <QtQuick/qsgsimplematerial.h> #include <QtGui/qcolor.h> +#include <QtQuick/qsgmaterial.h> QT_BEGIN_NAMESPACE class ImageMaterialData; class QSGGeometryNode; +class QSGMaterial; class QQuickSprite; class QQuickStochasticEngine; +class QRhi; + struct SimpleVertex { float x; float y; @@ -153,6 +157,12 @@ struct Vertices { Vertex v4; }; +class ImageMaterial : public QSGMaterial +{ +public: + virtual ImageMaterialData *state() = 0; +}; + class QQuickImageParticle : public QQuickParticlePainter { Q_OBJECT @@ -440,14 +450,17 @@ private: } } - template<class MaterialData> - static MaterialData* getState(QSGMaterial* m) { - return static_cast<QSGSimpleMaterial<MaterialData> *>(m)->state(); + ImageMaterialData *getState(QSGMaterial *m) { + return static_cast<ImageMaterial *>(m)->state(); } + EntryEffect m_entryEffect; Status m_status; int m_startedImageLoading; + QRhi *m_rhi; + bool m_apiChecked; }; QT_END_NAMESPACE -#endif // ULTRAPARTICLE_H + +#endif // QQUICKIMAGEPARTICLE_P_H diff --git a/src/particles/qquickitemparticle.cpp b/src/particles/qquickitemparticle.cpp index a171fc3288..fc28864746 100644 --- a/src/particles/qquickitemparticle.cpp +++ b/src/particles/qquickitemparticle.cpp @@ -238,13 +238,13 @@ void QQuickItemParticle::reset() // delete all managed items which had their logical particles cleared // but leave it alone if the logical particle is maintained - QSet<QQuickItem*> lost = QSet<QQuickItem*>::fromList(m_managed); + QSet<QQuickItem*> lost = QSet<QQuickItem*>(m_managed.cbegin(), m_managed.cend()); for (auto groupId : groupIds()) { for (QQuickParticleData* d : qAsConst(m_system->groupData[groupId]->data)) { lost.remove(d->delegate); } } - m_deletables.append(lost.toList()); + m_deletables.append(lost.values()); //TODO: This doesn't yet handle calling detach on taken particles in the system reset case processDeletables(); } diff --git a/src/particles/qquickmaskextruder.cpp b/src/particles/qquickmaskextruder.cpp index 4c5d9e9d88..2ce3650743 100644 --- a/src/particles/qquickmaskextruder.cpp +++ b/src/particles/qquickmaskextruder.cpp @@ -68,14 +68,14 @@ QQuickMaskExtruder::QQuickMaskExtruder(QObject *parent) : { } -void QQuickMaskExtruder::setSource(QUrl arg) +void QQuickMaskExtruder::setSource(const QUrl &arg) { if (m_source != arg) { m_source = arg; m_lastHeight = -1;//Trigger reset m_lastWidth = -1; - emit sourceChanged(arg); + emit sourceChanged(m_source); startMaskLoading(); } } diff --git a/src/particles/qquickmaskextruder_p.h b/src/particles/qquickmaskextruder_p.h index 0fc0331db8..bbb61b0d28 100644 --- a/src/particles/qquickmaskextruder_p.h +++ b/src/particles/qquickmaskextruder_p.h @@ -73,10 +73,10 @@ public: Q_SIGNALS: - void sourceChanged(QUrl arg); + void sourceChanged(const QUrl &arg); public Q_SLOTS: - void setSource(QUrl arg); + void setSource(const QUrl &arg); private Q_SLOTS: void startMaskLoading(); diff --git a/src/particles/qquickparticleemitter.cpp b/src/particles/qquickparticleemitter.cpp index f154446484..c0d9fa941d 100644 --- a/src/particles/qquickparticleemitter.cpp +++ b/src/particles/qquickparticleemitter.cpp @@ -40,6 +40,7 @@ #include "qquickparticleemitter_p.h" #include <private/qqmlengine_p.h> #include <private/qqmlglobal_p.h> +#include <private/qjsvalue_p.h> #include <QRandomGenerator> QT_BEGIN_NAMESPACE @@ -258,7 +259,7 @@ QQuickParticleEmitter::~QQuickParticleEmitter() bool QQuickParticleEmitter::isEmitConnected() { - IS_SIGNAL_CONNECTED(this, QQuickParticleEmitter, emitParticles, (QQmlV4Handle)); + IS_SIGNAL_CONNECTED(this, QQuickParticleEmitter, emitParticles, (const QJSValue &)); } void QQuickParticleEmitter::reclaculateGroupId() const @@ -497,7 +498,9 @@ void QQuickParticleEmitter::emitWindow(int timeStamp) for (int i=0; i<toEmit.size(); i++) array->put(i, (v = toEmit[i]->v4Value(m_system))); - emitParticles(QQmlV4Handle(array));//A chance for arbitrary JS changes + QJSValue particles; + QJSValuePrivate::setValue(&particles, v4, array); + emit emitParticles(particles);//A chance for arbitrary JS changes } m_last_emission = pt; diff --git a/src/particles/qquickparticleemitter_p.h b/src/particles/qquickparticleemitter_p.h index 4f7e12da44..64b9bcef32 100644 --- a/src/particles/qquickparticleemitter_p.h +++ b/src/particles/qquickparticleemitter_p.h @@ -135,7 +135,7 @@ public: void setVelocityFromMovement(qreal s); void componentComplete() override; Q_SIGNALS: - void emitParticles(QQmlV4Handle particles); + void emitParticles(const QJSValue &particles); void particlesPerSecondChanged(qreal); void particleDurationChanged(int); void enabledChanged(bool); diff --git a/src/particles/qquickparticlepainter.cpp b/src/particles/qquickparticlepainter.cpp index e762b3ae1d..78e11fafcf 100644 --- a/src/particles/qquickparticlepainter.cpp +++ b/src/particles/qquickparticlepainter.cpp @@ -70,6 +70,7 @@ QQuickParticlePainter::QQuickParticlePainter(QQuickItem *parent) , m_count(0) , m_pleaseReset(true) , m_window(nullptr) + , m_windowChanged(false) , m_groupIdsNeedRecalculation(false) { } @@ -80,6 +81,7 @@ void QQuickParticlePainter::itemChange(ItemChange change, const ItemChangeData & if (m_window) disconnect(m_window, SIGNAL(sceneGraphInvalidated()), this, SLOT(sceneGraphInvalidated())); m_window = data.window; + m_windowChanged = true; if (m_window) connect(m_window, SIGNAL(sceneGraphInvalidated()), this, SLOT(sceneGraphInvalidated()), Qt::DirectConnection); } diff --git a/src/particles/qquickparticlepainter_p.h b/src/particles/qquickparticlepainter_p.h index ac14a18103..16fc6b6f45 100644 --- a/src/particles/qquickparticlepainter_p.h +++ b/src/particles/qquickparticlepainter_p.h @@ -141,6 +141,7 @@ protected: QPointF m_systemOffset; QQuickWindow *m_window; + bool m_windowChanged; private: // methods void recalculateGroupIds() const; diff --git a/src/particles/qquickparticlesystem.cpp b/src/particles/qquickparticlesystem.cpp index 1499df0360..14ffc67324 100644 --- a/src/particles/qquickparticlesystem.cpp +++ b/src/particles/qquickparticlesystem.cpp @@ -523,7 +523,7 @@ void QQuickParticleData::clone(const QQuickParticleData& other) animationOwner = other.animationOwner; } -QQmlV4Handle QQuickParticleData::v4Value(QQuickParticleSystem* particleSystem) +QV4::ReturnedValue QQuickParticleData::v4Value(QQuickParticleSystem* particleSystem) { if (!v8Datum) v8Datum = new QQuickV4ParticleData(qmlEngine(particleSystem)->handle(), this, particleSystem); diff --git a/src/particles/qquickparticlesystem_p.h b/src/particles/qquickparticlesystem_p.h index 73351fb99a..1e34086b0c 100644 --- a/src/particles/qquickparticlesystem_p.h +++ b/src/particles/qquickparticlesystem_p.h @@ -59,8 +59,9 @@ #include <private/qquicksprite_p.h> #include <QAbstractAnimation> #include <QtQml/qqml.h> -#include <private/qv8engine_p.h> //For QQmlV4Handle #include <private/qv4util_p.h> +#include <private/qv4global_p.h> +#include <private/qv4staticvalue_p.h> #include "qtquickparticlesglobal_p.h" QT_BEGIN_NAMESPACE @@ -333,7 +334,7 @@ public: float curSize(QQuickParticleSystem *particleSystem) const; void clone(const QQuickParticleData& other);//Not =, leaves meta-data like index - QQmlV4Handle v4Value(QQuickParticleSystem *particleSystem); + QV4::ReturnedValue v4Value(QQuickParticleSystem *particleSystem); void extendLife(float time, QQuickParticleSystem *particleSystem); static inline Q_DECL_CONSTEXPR float EPSILON() Q_DECL_NOTHROW { return 0.001f; } diff --git a/src/particles/qquicktrailemitter.cpp b/src/particles/qquicktrailemitter.cpp index ca3ebbd4ec..102dc7bd2e 100644 --- a/src/particles/qquicktrailemitter.cpp +++ b/src/particles/qquicktrailemitter.cpp @@ -40,6 +40,7 @@ #include "qquicktrailemitter_p.h" #include <private/qqmlengine_p.h> #include <private/qqmlglobal_p.h> +#include <private/qjsvalue_p.h> #include <QRandomGenerator> #include <cmath> QT_BEGIN_NAMESPACE @@ -127,7 +128,8 @@ QQuickTrailEmitter::QQuickTrailEmitter(QQuickItem *parent) : bool QQuickTrailEmitter::isEmitFollowConnected() { - IS_SIGNAL_CONNECTED(this, QQuickTrailEmitter, emitFollowParticles, (QQmlV4Handle,QQmlV4Handle)); + IS_SIGNAL_CONNECTED(this, QQuickTrailEmitter, emitFollowParticles, + (const QJSValue &, const QJSValue &)); } void QQuickTrailEmitter::recalcParticlesPerSecond(){ @@ -275,10 +277,12 @@ void QQuickTrailEmitter::emitWindow(int timeStamp) for (int i=0; i<toEmit.size(); i++) array->put(i, (v = toEmit[i]->v4Value(m_system))); + QJSValue particles; + QJSValuePrivate::setValue(&particles, v4, array); if (isEmitFollowConnected()) - emitFollowParticles(QQmlV4Handle(array), d->v4Value(m_system));//A chance for many arbitrary JS changes + emit emitFollowParticles(particles, QJSValue(v4, d->v4Value(m_system)));//A chance for many arbitrary JS changes else if (isEmitConnected()) - emitParticles(QQmlV4Handle(array));//A chance for arbitrary JS changes + emit emitParticles(particles);//A chance for arbitrary JS changes } m_lastEmission[d->index] = pt; } diff --git a/src/particles/qquicktrailemitter_p.h b/src/particles/qquicktrailemitter_p.h index 99464436ba..22b96afd25 100644 --- a/src/particles/qquicktrailemitter_p.h +++ b/src/particles/qquicktrailemitter_p.h @@ -100,7 +100,7 @@ public: } Q_SIGNALS: - void emitFollowParticles(QQmlV4Handle particles, QQmlV4Handle followed); + void emitFollowParticles(const QJSValue &particles, const QJSValue &followed); void particlesPerParticlePerSecondChanged(int arg); diff --git a/src/particles/qquickv4particledata.cpp b/src/particles/qquickv4particledata.cpp index 42b30f0472..459797f977 100644 --- a/src/particles/qquickv4particledata.cpp +++ b/src/particles/qquickv4particledata.cpp @@ -290,7 +290,7 @@ struct QV4ParticleData : public QV4::Object DEFINE_OBJECT_VTABLE(QV4ParticleData); -class QV4ParticleDataDeletable : public QV8Engine::Deletable +class QV4ParticleDataDeletable : public QV4::ExecutionEngine::Deletable { public: QV4ParticleDataDeletable(QV4::ExecutionEngine *engine); @@ -528,9 +528,9 @@ QQuickV4ParticleData::~QQuickV4ParticleData() { } -QQmlV4Handle QQuickV4ParticleData::v4Value() const +QV4::ReturnedValue QQuickV4ParticleData::v4Value() const { - return QQmlV4Handle(m_v4Value.value()); + return m_v4Value.value(); } QT_END_NAMESPACE diff --git a/src/particles/qquickv4particledata_p.h b/src/particles/qquickv4particledata_p.h index 3d682ab297..e41700f7c2 100644 --- a/src/particles/qquickv4particledata_p.h +++ b/src/particles/qquickv4particledata_p.h @@ -51,7 +51,6 @@ // We mean it. // -#include <private/qv8engine_p.h> #include <private/qv4persistent_p.h> #include <private/qv4value_p.h> @@ -63,7 +62,7 @@ class QQuickV4ParticleData { public: QQuickV4ParticleData(QV4::ExecutionEngine*, QQuickParticleData*, QQuickParticleSystem *system); ~QQuickV4ParticleData(); - QQmlV4Handle v4Value() const; + QV4::ReturnedValue v4Value() const; private: QV4::PersistentValue m_v4Value; }; diff --git a/src/particles/shaders_ng/compile.bat b/src/particles/shaders_ng/compile.bat new file mode 100755 index 0000000000..2376d5bf6d --- /dev/null +++ b/src/particles/shaders_ng/compile.bat @@ -0,0 +1,53 @@ +::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: +:: +:: Copyright (C) 2019 The Qt Company Ltd. +:: Contact: https://www.qt.io/licensing/ +:: +:: This file is part of the QtQuick module of the Qt Toolkit. +:: +:: $QT_BEGIN_LICENSE:LGPL$ +:: Commercial License Usage +:: Licensees holding valid commercial Qt licenses may use this file in +:: accordance with the commercial license agreement provided with the +:: Software or, alternatively, in accordance with the terms contained in +:: a written agreement between you and The Qt Company. For licensing terms +:: and conditions see https://www.qt.io/terms-conditions. For further +:: information use the contact form at https://www.qt.io/contact-us. +:: +:: GNU Lesser General Public License Usage +:: Alternatively, this file may be used under the terms of the GNU Lesser +:: General Public License version 3 as published by the Free Software +:: Foundation and appearing in the file LICENSE.LGPL3 included in the +:: packaging of this file. Please review the following information to +:: ensure the GNU Lesser General Public License version 3 requirements +:: will be met: https://www.gnu.org/licenses/lgpl-3.0.html. +:: +:: GNU General Public License Usage +:: Alternatively, this file may be used under the terms of the GNU +:: General Public License version 2.0 or (at your option) the GNU General +:: Public license version 3 or any later version approved by the KDE Free +:: Qt Foundation. The licenses are as published by the Free Software +:: Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 +:: included in the packaging of this file. Please review the following +:: information to ensure the GNU General Public License requirements will +:: be met: https://www.gnu.org/licenses/gpl-2.0.html and +:: https://www.gnu.org/licenses/gpl-3.0.html. +:: +:: $QT_END_LICENSE$ +:: +::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + +qsb -b --glsl "150,120,100 es" --hlsl 50 --msl 12 -o imageparticle_simple.vert.qsb imageparticle.vert +qsb --glsl "150,120,100 es" --hlsl 50 --msl 12 -o imageparticle_simple.frag.qsb imageparticle.frag + +qsb -DTABLE -DDEFORM -DCOLOR -b --glsl "150,120,100 es" --hlsl 50 --msl 12 -o imageparticle_tabled.vert.qsb imageparticle.vert +qsb -DTABLE -DDEFORM -DCOLOR --glsl "150,120,100 es" --hlsl 50 --msl 12 -o imageparticle_tabled.frag.qsb imageparticle.frag + +qsb -DDEFORM -DCOLOR -b --glsl "150,120,100 es" --hlsl 50 --msl 12 -o imageparticle_deformed.vert.qsb imageparticle.vert +qsb -DDEFORM -DCOLOR --glsl "150,120,100 es" --hlsl 50 --msl 12 -o imageparticle_deformed.frag.qsb imageparticle.frag + +qsb -DSPRITE -DTABLE -DDEFORM -DCOLOR -b --zorder-loc 8 --glsl "150,120,100 es" --hlsl 50 --msl 12 -o imageparticle_sprite.vert.qsb imageparticle.vert +qsb -DSPRITE -DTABLE -DDEFORM -DCOLOR --glsl "150,120,100 es" --hlsl 50 --msl 12 -o imageparticle_sprite.frag.qsb imageparticle.frag + +qsb -DCOLOR -b --glsl "150,120,100 es" --hlsl 50 --msl 12 -o imageparticle_colored.vert.qsb imageparticle.vert +qsb -DCOLOR --glsl "150,120,100 es" --hlsl 50 --msl 12 -o imageparticle_colored.frag.qsb imageparticle.frag diff --git a/src/particles/shaders_ng/imageparticle.frag b/src/particles/shaders_ng/imageparticle.frag new file mode 100644 index 0000000000..cefb7d2d75 --- /dev/null +++ b/src/particles/shaders_ng/imageparticle.frag @@ -0,0 +1,55 @@ +#version 440 + +#if defined(TABLE) +layout(location = 0) in vec2 tt; +#endif + +#if defined(SPRITE) +layout(location = 1) in vec4 fTexS; +#elif defined(DEFORM) +layout(location = 1) in vec2 fTex; +#endif + +#if defined(COLOR) +layout(location = 2) in vec4 fColor; +#else +layout(location = 2) in float fFade; +#endif + +layout(location = 0) out vec4 fragColor; + +layout(std140, binding = 0) uniform buf { + mat4 matrix; + float opacity; + float entry; + float timestamp; + float sizetable[64]; + float opacitytable[64]; +} ubuf; + +layout(binding = 1) uniform sampler2D _qt_texture; + +#if defined(TABLE) || defined(SPRITE) +layout(binding = 2) uniform sampler2D colortable; +#endif + +void main() +{ +#if defined(SPRITE) + fragColor = mix(texture(_qt_texture, fTexS.xy), texture(_qt_texture, fTexS.zw), tt.y) + * fColor + * texture(colortable, tt) + * ubuf.opacity; +#elif defined(TABLE) + fragColor = texture(_qt_texture, fTex) + * fColor + * texture(colortable, tt) + * ubuf.opacity; +#elif defined(DEFORM) + fragColor = texture(_qt_texture, fTex) * fColor * ubuf.opacity; +#elif defined(COLOR) + fragColor = texture(_qt_texture, gl_PointCoord) * fColor * ubuf.opacity; +#else + fragColor = texture(_qt_texture, gl_PointCoord) * fFade * ubuf.opacity; +#endif +} diff --git a/src/particles/shaders_ng/imageparticle.vert b/src/particles/shaders_ng/imageparticle.vert new file mode 100644 index 0000000000..870139452b --- /dev/null +++ b/src/particles/shaders_ng/imageparticle.vert @@ -0,0 +1,145 @@ +#version 440 + +layout(location = 1) in vec4 vData; // x = time, y = lifeSpan, z = size, w = endSize +layout(location = 2) in vec4 vVec; // x,y = constant velocity, z,w = acceleration + +#if defined(DEFORM) +layout(location = 0) in vec4 vPosTex; +#else +layout(location = 0) in vec2 vPos; +#endif + +#if defined(COLOR) +layout(location = 3) in vec4 vColor; +#endif + +#if defined(DEFORM) +layout(location = 4) in vec4 vDeformVec; // x,y x unit vector; z,w = y unit vector +layout(location = 5) in vec3 vRotation; // x = radians of rotation, y = rotation velocity, z = bool autoRotate +#endif + +#if defined(SPRITE) +layout(location = 6) in vec3 vAnimData; // w,h(premultiplied of anim), interpolation progress +layout(location = 7) in vec4 vAnimPos; // x,y, x,y (two frames for interpolation) +#endif + +#if defined(TABLE) +layout(location = 0) out vec2 tt; //y is progress if Sprite mode +#endif + +#if defined(SPRITE) +layout(location = 1) out vec4 fTexS; +#elif defined(DEFORM) +layout(location = 1) out vec2 fTex; +#endif + +#if defined(COLOR) +layout(location = 2) out vec4 fColor; +#else +layout(location = 2) out float fFade; +#endif + +layout(std140, binding = 0) uniform buf { + mat4 matrix; + float opacity; + float entry; + float timestamp; + float sizetable[64]; + float opacitytable[64]; +} ubuf; + +out gl_PerVertex { vec4 gl_Position; float gl_PointSize; }; + +void main() +{ + float t = (ubuf.timestamp - vData.x) / vData.y; + if (t < 0. || t > 1.) { +#if defined(DEFORM) + gl_Position = ubuf.matrix * vec4(vPosTex.x, vPosTex.y, 0., 1.); +#else + gl_PointSize = 0.; +#endif + } else { +#if defined(SPRITE) + tt.y = vAnimData.z; + + // Calculate frame location in texture + fTexS.xy = vAnimPos.xy + vPosTex.zw * vAnimData.xy; + + // Next frame is also passed, for interpolation + fTexS.zw = vAnimPos.zw + vPosTex.zw * vAnimData.xy; + +#elif defined(DEFORM) + fTex = vPosTex.zw; +#endif + float currentSize = mix(vData.z, vData.w, t * t); + float fade = 1.; + float fadeIn = min(t * 10., 1.); + float fadeOut = 1. - clamp((t - 0.75) * 4.,0., 1.); + +#if defined(TABLE) + currentSize = currentSize * ubuf.sizetable[int(floor(t*64.))]; + fade = fade * ubuf.opacitytable[int(floor(t*64.))]; +#endif + + if (ubuf.entry == 1.) + fade = fade * fadeIn * fadeOut; + else if (ubuf.entry == 2.) + currentSize = currentSize * fadeIn * fadeOut; + + if (currentSize <= 0.) { +#if defined(DEFORM) + gl_Position = ubuf.matrix * vec4(vPosTex.x, vPosTex.y, 0., 1.); +#else + gl_PointSize = 0.; +#endif + } else { + if (currentSize < 3.) // Sizes too small look jittery as they move + currentSize = 3.; + + vec2 pos; +#if defined(DEFORM) + float rotation = vRotation.x + vRotation.y * t * vData.y; + if (vRotation.z == 1.0) { + vec2 curVel = vVec.zw * t * vData.y + vVec.xy; + if (length(curVel) > 0.) + rotation += atan(curVel.y, curVel.x); + } + vec2 trigCalcs = vec2(cos(rotation), sin(rotation)); + vec4 deform = vDeformVec * currentSize * (vPosTex.zzww - 0.5); + vec4 rotatedDeform = deform.xxzz * trigCalcs.xyxy; + rotatedDeform = rotatedDeform + (deform.yyww * trigCalcs.yxyx * vec4(-1.,1.,-1.,1.)); + /* The readable version: + vec2 xDeform = vDeformVec.xy * currentSize * (vTex.x-0.5); + vec2 yDeform = vDeformVec.zw * currentSize * (vTex.y-0.5); + vec2 xRotatedDeform; + xRotatedDeform.x = trigCalcs.x*xDeform.x - trigCalcs.y*xDeform.y; + xRotatedDeform.y = trigCalcs.y*xDeform.x + trigCalcs.x*xDeform.y; + vec2 yRotatedDeform; + yRotatedDeform.x = trigCalcs.x*yDeform.x - trigCalcs.y*yDeform.y; + yRotatedDeform.y = trigCalcs.y*yDeform.x + trigCalcs.x*yDeform.y; + */ + pos = vPosTex.xy + + rotatedDeform.xy + + rotatedDeform.zw + + vVec.xy * t * vData.y // apply velocity + + 0.5 * vVec.zw * pow(t * vData.y, 2.); // apply acceleration +#else + pos = vPos + + vVec.xy * t * vData.y // apply velocity vector.. + + 0.5 * vVec.zw * pow(t * vData.y, 2.); + gl_PointSize = currentSize; +#endif + gl_Position = ubuf.matrix * vec4(pos.x, pos.y, 0, 1); + +#if defined(COLOR) + fColor = vColor * fade; +#else + fFade = fade; +#endif +#if defined(TABLE) + tt.x = t; +#endif + } + } +} diff --git a/src/particles/shaders_ng/imageparticle_colored.frag.qsb b/src/particles/shaders_ng/imageparticle_colored.frag.qsb Binary files differnew file mode 100644 index 0000000000..7ae640d224 --- /dev/null +++ b/src/particles/shaders_ng/imageparticle_colored.frag.qsb diff --git a/src/particles/shaders_ng/imageparticle_colored.vert.qsb b/src/particles/shaders_ng/imageparticle_colored.vert.qsb Binary files differnew file mode 100644 index 0000000000..0e2938b72c --- /dev/null +++ b/src/particles/shaders_ng/imageparticle_colored.vert.qsb diff --git a/src/particles/shaders_ng/imageparticle_deformed.frag.qsb b/src/particles/shaders_ng/imageparticle_deformed.frag.qsb Binary files differnew file mode 100644 index 0000000000..fa9d9d35bb --- /dev/null +++ b/src/particles/shaders_ng/imageparticle_deformed.frag.qsb diff --git a/src/particles/shaders_ng/imageparticle_deformed.vert.qsb b/src/particles/shaders_ng/imageparticle_deformed.vert.qsb Binary files differnew file mode 100644 index 0000000000..65092d5b26 --- /dev/null +++ b/src/particles/shaders_ng/imageparticle_deformed.vert.qsb diff --git a/src/particles/shaders_ng/imageparticle_simple.frag.qsb b/src/particles/shaders_ng/imageparticle_simple.frag.qsb Binary files differnew file mode 100644 index 0000000000..a5874cba24 --- /dev/null +++ b/src/particles/shaders_ng/imageparticle_simple.frag.qsb diff --git a/src/particles/shaders_ng/imageparticle_simple.vert.qsb b/src/particles/shaders_ng/imageparticle_simple.vert.qsb Binary files differnew file mode 100644 index 0000000000..da815d7e19 --- /dev/null +++ b/src/particles/shaders_ng/imageparticle_simple.vert.qsb diff --git a/src/particles/shaders_ng/imageparticle_sprite.frag.qsb b/src/particles/shaders_ng/imageparticle_sprite.frag.qsb Binary files differnew file mode 100644 index 0000000000..778550344b --- /dev/null +++ b/src/particles/shaders_ng/imageparticle_sprite.frag.qsb diff --git a/src/particles/shaders_ng/imageparticle_sprite.vert.qsb b/src/particles/shaders_ng/imageparticle_sprite.vert.qsb Binary files differnew file mode 100644 index 0000000000..45b21ace8a --- /dev/null +++ b/src/particles/shaders_ng/imageparticle_sprite.vert.qsb diff --git a/src/particles/shaders_ng/imageparticle_tabled.frag.qsb b/src/particles/shaders_ng/imageparticle_tabled.frag.qsb Binary files differnew file mode 100644 index 0000000000..c5dcc2c68f --- /dev/null +++ b/src/particles/shaders_ng/imageparticle_tabled.frag.qsb diff --git a/src/particles/shaders_ng/imageparticle_tabled.vert.qsb b/src/particles/shaders_ng/imageparticle_tabled.vert.qsb Binary files differnew file mode 100644 index 0000000000..ea42607570 --- /dev/null +++ b/src/particles/shaders_ng/imageparticle_tabled.vert.qsb |