Function Simulate

engine/particle/src/particle.cpp:1570–1629

    }

    void Simulate(Instance* instance, Emitter* emitter, EmitterPrototype* prototype, dmParticleDDF::Emitter* ddf, float dt)
    {
        DM_PROFILE(__FUNCTION__);

        dmArray<Particle>& particles = emitter->m_Particles;
        EvaluateParticleProperties(emitter, prototype->m_ParticleProperties, ddf, dt);
        float emitter_t = dmMath::Select(-ddf->m_Duration, 0.0f, emitter->m_Timer / ddf->m_Duration);
        float scale = 1.0f;
        if (ddf->m_Space == EMISSION_SPACE_WORLD)
            scale = instance->m_WorldTransform.GetScale();
        // Apply modifiers
        uint32_t modifier_count = prototype->m_Modifiers.Size();
        for (uint32_t i = 0; i < modifier_count; ++i)
        {
            ModifierPrototype* modifier = &prototype->m_Modifiers[i];
            dmParticleDDF::Modifier* modifier_ddf = &ddf->m_Modifiers[i];
            switch (modifier_ddf->m_Type)
            {
            case dmParticleDDF::MODIFIER_TYPE_ACCELERATION:
                {
                    Quat rotation = CalculateModifierRotation(instance, ddf, modifier_ddf);
                    ApplyAcceleration(particles, modifier->m_Properties, rotation, scale, emitter_t, dt);
                }
                break;
            case dmParticleDDF::MODIFIER_TYPE_DRAG:
                {
                    Quat rotation = CalculateModifierRotation(instance, ddf, modifier_ddf);
                    ApplyDrag(particles, modifier->m_Properties, modifier_ddf, rotation, emitter_t, dt);
                }
                break;
            case dmParticleDDF::MODIFIER_TYPE_RADIAL:
                {
                    Point3 position = CalculateModifierPosition(instance, ddf, modifier_ddf);
                    ApplyRadial(particles, modifier->m_Properties, position, scale, emitter_t, dt);
                }
                break;
            case dmParticleDDF::MODIFIER_TYPE_VORTEX:
                {
                    Point3 position = CalculateModifierPosition(instance, ddf, modifier_ddf);
                    Quat rotation = CalculateModifierRotation(instance, ddf, modifier_ddf);
                    ApplyVortex(particles, modifier->m_Properties, position, rotation, scale, emitter_t, dt);
                }
                break;
            }
        }
        uint32_t particle_count = particles.Size();
        for (uint32_t i = 0; i < particle_count; ++i)
        {
            Particle* p = &particles[i];
            // NOTE This velocity integration has a larger error than normal since we don't use the velocity at the
            // beginning of the frame, but it's ok since particle movement does not need to be very exact
            p->SetPosition(p->GetPosition() + p->m_Velocity * dt);

            p->m_Scale[0] += p->m_Scale[0] * p->m_StretchFactorX;
            if (!ddf->m_StretchWithVelocity)
                p->m_Scale[1] += p->m_Scale[1] * p->m_StretchFactorY;
            else
                p->m_Scale[1] += p->m_Scale[1] * p->m_StretchFactorY * length(p->m_Velocity) * STRETCH_SCALING;