Render: Meshes as VFX particles #1060

engine/includes/components/effectrender.h

@@ -32,15 +32,10 @@ class ENGINE_EXPORT EffectRender : public Renderable {
     static void effectUpdated(int state, void *ptr);
 
 private:
-    std::vector<float> m_emitterData;
-
-    std::vector<float> m_particleData;
-
-    std::vector<float> m_renderData;
-
-    std::vector<int32_t> m_offsets;
+    VisualEffect::Buffers m_data;
 
     VisualEffect *m_effect;
+
 };
 
 #endif // EFFECTRENDER_H

engine/includes/editor/viewport/tasks/debugrender.h

@@ -45,8 +45,8 @@ class DebugRender : public PipelineTask {
             for(auto &it : m_buffers) {
                 it.second->setTexture("mainTexture", m_context->textureBuffer(it.first));
 
-                float width = 0.5f;
-                float height = 0.5f;
+                float width = 1.0f;
+                float height = 1.0f;
 
                 Matrix4 m;
                 m.scale(Vector3(width, height, 1.0f));

engine/includes/pipelinetask.h

@@ -15,7 +15,7 @@ class ENGINE_EXPORT PipelineTask : public Object {
     PipelineTask();
     ~PipelineTask();
 
-    void setContext(PipelineContext *context);
+    virtual void setContext(PipelineContext *context);
 
     virtual void analyze(World *world);
     virtual void exec();

engine/includes/pipelinetasks/ambientocclusion.h

@@ -22,6 +22,8 @@ class AmbientOcclusion : public PipelineTask {
 
     void setInput(int index, Texture *texture) override;
 
+    void setContext(PipelineContext *context) override;
+
 protected:
     float m_radius;
     float m_bias;

engine/includes/resources/material.h

@@ -206,6 +206,8 @@ class ENGINE_EXPORT Material : public Resource {
     int proprity() const;
     void setPriority(int proprity);
 
+    int uniformSize() const;
+
     int layers() const;
 
     virtual MaterialInstance *createInstance(SurfaceType type = SurfaceType::Static);

engine/includes/resources/visualeffect.h

@@ -22,6 +22,8 @@ class ENGINE_EXPORT VisualEffect : public Resource {
         int32_t offset;
     };
 
+    typedef std::vector<float> FloatData;
+
     struct Operator {
         int32_t op;
 
@@ -33,34 +35,48 @@ class ENGINE_EXPORT VisualEffect : public Resource {
 
         std::vector<Argument> arguments;
 
-        std::vector<float> constData;
+        FloatData constData;
+    };
+
+    struct Buffers {
+        FloatData system;
+        FloatData emitter;
+        FloatData particles;
+
+        std::vector<FloatData> render;
+
+        int instances = 0;
+    };
+
+    struct Renderable {
+        Material::SurfaceType type;
+
+        Mesh *mesh;
+
+        Material *material;
+    };
+
+    enum SystemAttributes {
+        DeltaTime = 0
     };
 
     enum EmitterAttributes {
         EmitterAge = 0,
-        DeltaTime,
-        AliveParticles,
-        SpawnRate,
         SpawnCounter,
-        LastAttribute
+        Transform
     };
 
 public:
     VisualEffect();
 
-    void update(std::vector<float> &emitter, std::vector<float> &particles, std::vector<float> &render);
+    void update(Buffers &buffers);
 
     int capacity() const;
     void setCapacity(int capacity);
 
-    Mesh *mesh() const;
-    void setMesh(Mesh *mesh);
-
-    Material *material() const;
-    void setMaterial(Material *material);
+    int renderablesCount();
 
-    float spawnRate() const;
-    void setSpawnRate(float rate);
+    const Renderable *renderable(int index) const;
 
     bool local() const;
     void setLocal(bool local);
@@ -71,43 +87,46 @@ class ENGINE_EXPORT VisualEffect : public Resource {
     bool continous() const;
     void setContinous(bool continuous);
 
+    int systemStride() const;
+    int emitterStride() const;
     int particleStride() const;
-    int renderableStride() const;
 
     AABBox bound() const;
 
     void loadUserData(const VariantMap &data) override;
 
 protected:
-    std::vector<Operator> m_spawnOperations;
-    std::vector<Operator> m_updateOperations;
+    std::vector<Operator> m_emitterSpawnOperations;
+    std::vector<Operator> m_emitterUpdateOperations;
+    std::vector<Operator> m_particleSpawnOperations;
+    std::vector<Operator> m_particleUpdateOperations;
     std::vector<Operator> m_renderOperations;
 
-    AABBox m_aabb;
+    std::vector<Renderable> m_renderables;
 
-    Mesh *m_mesh;
+    AABBox m_aabb;
 
-    Material *m_material;
+    int m_capacity;
 
-    float m_spawnRate;
+    int m_systemStride;
 
-    int m_capacity;
+    int m_emitterStride;
 
     int m_particleStride;
 
-    int m_renderableStride;
-
     bool m_gpu;
 
     bool m_local;
 
     bool m_continous;
 
 private:
-    void apply(std::vector<Operator> &operations, std::vector<float> &emitter, std::vector<float> &particle, std::vector<float> &render, int stage) const;
+    void apply(std::vector<Operator> &operations, Buffers &buffers, int particle = 0, int render = 0, int stride = 0) const;
 
     void loadOperations(const VariantList &list, std::vector<Operator> &operations);
 
+    void loadRenderables(const VariantList &list);
+
 };
 
 #endif // VISUALEFFECT_H

engine/src/components/effectrender.cpp

@@ -42,55 +42,29 @@ void EffectRender::update() {
     \internal
 */
 void EffectRender::deltaUpdate(float dt) {
-    if(m_effect && isEnabled()) {
-        Camera *camera = Camera::current();
-        if(camera == nullptr || m_materials.empty()) {
-            return;
-        }
-
-        float &emitterAge = m_emitterData[VisualEffect::EmitterAge];
-        float &deltaTime = m_emitterData[VisualEffect::DeltaTime];
-
-        deltaTime = dt;
+    if(m_effect && isEnabled() && !m_materials.empty()) {
+        m_data.system[VisualEffect::DeltaTime] = dt;
 
+        float &emitterAge = m_data.emitter[VisualEffect::EmitterAge];
         if(m_effect->continous() || emitterAge > 0.0f) {
-            float &emitterSpawnCounter = m_emitterData[VisualEffect::SpawnCounter];
-
-            emitterSpawnCounter += m_effect->spawnRate() * deltaTime;
+            Matrix4 *t = reinterpret_cast<Matrix4 *>(&m_data.emitter[VisualEffect::Transform]);
+            *t = transform()->worldTransform();
 
-            if(emitterAge > 0.0f) {
-                emitterAge -= dt;
-            }
-        }
+            m_effect->update(m_data);
 
-        m_effect->update(m_emitterData, m_particleData, m_renderData);
+            for(int i = 0; i < m_materials.size(); i++) {
+                m_materials[i]->setInstanceCount(m_data.instances);
 
-        int32_t count = static_cast<int32_t>(m_emitterData[VisualEffect::AliveParticles]);
-        if(m_effect->local()) {
-            Matrix4 world(transform()->worldTransform());
-
-            int32_t stride = m_effect->renderableStride();
-            for(int32_t i = 0; i < count; i++) {
-                int index = i * stride;
-                Vector3 p(world * Vector3(m_renderData[index + 12], m_renderData[index + 13], m_renderData[index + 14]));
-                m_renderData[index + 12] = p.x;
-                m_renderData[index + 13] = p.y;
-                m_renderData[index + 14] = p.z;
+                memcpy(m_materials[i]->rawUniformBuffer().data(), m_data.render[i].data(), m_data.render[i].size());
             }
         }
-
-        MaterialInstance *instance = m_materials.front();
-        instance->setInstanceCount(count);
-
-        memcpy(instance->rawUniformBuffer().data(), m_renderData.data(), m_renderData.size());
     }
 }
 /*!
     \internal
 */
 Mesh *EffectRender::meshToDraw(int instance) const {
-    A_UNUSED(instance);
-    return m_effect ? m_effect->mesh() : nullptr;
+    return m_effect ? m_effect->renderable(instance)->mesh : nullptr;
 }
 /*!
     Returns a ParticleEffect assigned to the this component.
@@ -128,41 +102,40 @@ AABBox EffectRender::localBound() const {
 */
 void EffectRender::effectUpdated(int state, void *ptr) {
     if(state == Resource::Ready) {
-        EffectRender *p = static_cast<EffectRender *>(ptr);
+        EffectRender *render = static_cast<EffectRender *>(ptr);
 
         // Update materials
-        for(auto it : p->m_materials) {
+        for(auto it : render->m_materials) {
             delete it;
         }
-        p->m_materials.clear();
-
-        int capacity = p->m_effect->capacity();
+        render->m_materials.clear();
 
-        if(p->m_effect->material()) {
-            MaterialInstance *instance = p->m_effect->material()->createInstance(Material::Billboard);
-
-            instance->setInstanceCount(capacity);
-
-            p->m_materials.push_back(instance);
-        }
+        int capacity = render->m_effect->capacity();
 
+        // Update system buffer
+        render->m_data.system.resize(render->m_effect->systemStride());
         // Update emitter buffer
-        p->m_emitterData.resize(VisualEffect::LastAttribute);
+        render->m_data.emitter.resize(render->m_effect->emitterStride());
         // Update particles buffer
-        p->m_particleData.resize(capacity * p->m_effect->particleStride());
+        render->m_data.particles.resize(capacity * render->m_effect->particleStride());
+
+        render->m_data.render.resize(render->m_effect->renderablesCount());
+        for(int i = 0; i < render->m_effect->renderablesCount(); i++) {
+            const VisualEffect::Renderable *renderable = render->m_effect->renderable(i);
+            if(renderable) {
+                MaterialInstance *instance = nullptr;
 
-        int renderableStride = p->m_effect->renderableStride();
-        p->m_renderData.resize(capacity * renderableStride);
+                Material *m = renderable->material;
+                if(m) {
+                    instance = m->createInstance(renderable->type);
 
-        Vector4 colorID(CommandBuffer::idToColor(p->actor()->uuid()));
+                    instance->setInstanceCount(capacity);
 
-        for(int i = 0; i < capacity; i++) {
-            int r = i * renderableStride;
+                    render->m_data.render[i].resize(capacity * (m->uniformSize() / sizeof(float)));
+                }
 
-            p->m_renderData[r + 3] = colorID.x;
-            p->m_renderData[r + 7] = colorID.y;
-            p->m_renderData[r + 11] = colorID.z;
-            p->m_renderData[r + 15] = colorID.w;
+                render->m_materials.push_back(instance);
+            }
         }
     }
 }

engine/src/pipelinetasks/ambientocclusion.cpp

@@ -54,10 +54,10 @@ AmbientOcclusion::AmbientOcclusion() :
         ptr[i].z = 0.0f;
         ptr[i].w = 0.0f;
 
-        ptr[i].normalize();
+        //ptr[i].normalize();
     }
 
-    m_aoTexture->setFormat(Texture::R8);
+    m_aoTexture->setFormat(Texture::RGBA8);
     m_aoTexture->setFlags(Texture::Render);
 
     m_aoTarget->setColorAttachment(0, m_aoTexture);
@@ -187,3 +187,9 @@ void AmbientOcclusion::resize(int32_t width, int32_t height) {
 void AmbientOcclusion::setInput(int index, Texture *texture) {
     m_outputs.front().second = texture;
 }
+
+void AmbientOcclusion::setContext(PipelineContext *context) {
+    PipelineTask::setContext(context);
+
+    m_context->addTextureBuffer(m_aoTexture);
+}

engine/src/resources/material.cpp

@@ -349,6 +349,13 @@ bool Material::wireframe() const {
 void Material::setWireframe(bool wireframe) {
     m_wireframe = wireframe;
 }
+/*!
+    Returns size uniform buffer for single instance.
+    This value can be used as stride for instances.
+*/
+int Material::uniformSize() const {
+    return m_uniformSize;
+}
 /*!
     Returns layers that supported by this material.
 */

engine/src/resources/mesh.cpp

@@ -90,10 +90,18 @@ Material *Mesh::defaultMaterial(int sub) const {
 */
 void Mesh::setDefaultMaterial(Material *material, int sub) {
     if(sub < m_defaultMaterials.size()) {
+        if(m_defaultMaterials[sub]) {
+            m_defaultMaterials[sub]->decRef();
+        }
+
         m_defaultMaterials[sub] = material;
     } else {
         m_defaultMaterials.push_back(material);
     }
+
+    if(material) {
+        material->incRef();
+    }
 }
 /*!
     Returns an array of mesh indices for the particular Mesh.