public override void OnUpdate(float deltaTime, Particle *arrayPtr, int length)
        {
            if (ParticleEngine.NativeEnabled)
            {
                return;
            }

            Particle *tail = arrayPtr + length;

            switch (transitionType)
            {
            case TransitionType.Constant: {
                for (Particle *particle = arrayPtr; particle < tail; particle++)
                {
                    particle->SpriteRotation += start * deltaTime;
                }
            } break;

            case TransitionType.Lerp: {
                for (Particle *particle = arrayPtr; particle < tail; particle++)
                {
                    float angleDelta = ParticleMath.Lerp(
                        start,
                        end,
                        particle->TimeAlive / particle->InitialLife);

                    particle->SpriteRotation += angleDelta * deltaTime;
                }
            } break;

            case TransitionType.Curve: {
                for (Particle *particle = arrayPtr; particle < tail; particle++)
                {
                    particle->SpriteRotation += curve.Evaluate(particle->TimeAlive / particle->InitialLife) * deltaTime;
                }
            } break;

            case TransitionType.RandomConstant: {
                for (Particle *particle = arrayPtr; particle < tail; particle++)
                {
                    particle->SpriteRotation += Between(start, end, rand[particle->ID]) * deltaTime;
                }
            } break;

            case TransitionType.RandomCurve: {
                for (Particle *particle = arrayPtr; particle < tail; particle++)
                {
                    particle->SpriteRotation += curve.Evaluate(rand[particle->ID]) * deltaTime;
                }
            } break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Esempio n. 2
0
        public override void OnUpdate(float deltaTime, Particle *arrayPtr, int length)
        {
            if (ParticleEngine.NativeEnabled)
            {
                return;
            }

            Particle *tail = arrayPtr + length;
            int       i    = 0;

            switch (transitionType)
            {
            case Transition.Lerp: {
                for (Particle *particle = arrayPtr; particle < tail; particle++, i++)
                {
                    particle->Color = new Vector4(
                        particle->Color.X,
                        particle->Color.Y,
                        particle->Color.Z,
                        ParticleMath.Lerp(startAlphas[particle->ID], end1, particle->TimeAlive / particle->InitialLife));
                }
            } break;

            case Transition.Curve: {
                for (Particle *particle = arrayPtr; particle < tail; particle++)
                {
                    float lifeRatio = particle->TimeAlive / particle->InitialLife;
                    particle->Color = new Vector4(
                        particle->Color.X,
                        particle->Color.Y,
                        particle->Color.Z,
                        curve.Evaluate(lifeRatio));
                }
            } break;

            case Transition.RandomLerp: {
                for (Particle *particle = arrayPtr; particle < tail; particle++, i++)
                {
                    particle->Color = new Vector4(
                        particle->Color.X,
                        particle->Color.Y,
                        particle->Color.Z,
                        ParticleMath.Lerp(startAlphas[particle->ID], randEndAlphas[particle->ID], particle->TimeAlive / particle->InitialLife));
                }
            } break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Esempio n. 3
0
        public override void OnUpdate(float deltaTime, Particle *arrayPtr, int length)
        {
            if (ParticleEngine.NativeEnabled)
            {
                return;
            }

            Particle *tail = arrayPtr + length;

            switch (transitionType)
            {
            case Transition.Lerp: {
                for (Particle *particle = arrayPtr; particle < tail; particle++)
                {
                    float velocity = ParticleMath.Lerp(start, end, particle->TimeAlive / particle->InitialLife);
                    particle->Speed = AbsoluteValue
                            ? velocity
                            : particle->Speed + (velocity * deltaTime);
                }
            } break;

            case Transition.Curve: {
                for (Particle *particle = arrayPtr; particle < tail; particle++)
                {
                    float velocity = curve.Evaluate(particle->TimeAlive / particle->InitialLife);
                    particle->Speed = AbsoluteValue
                            ? velocity
                            : particle->Speed + (velocity * deltaTime);
                }
            } break;

            case Transition.RandomCurve: {
                for (Particle *particle = arrayPtr; particle < tail; particle++)
                {
                    float velocity = curve.Evaluate(rand[particle->ID]);
                    particle->Speed = AbsoluteValue
                            ? velocity
                            : particle->Speed + (velocity * deltaTime);
                }
            } break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Esempio n. 4
0
        public override void OnUpdate(float deltaTime, Particle *arrayPtr, int length)
        {
            Particle *tail = arrayPtr + length;
            int       i    = 0;

            switch (transitionType)
            {
            case Transition.Lerp: {
                for (Particle *particle = arrayPtr; particle < tail; particle++, i++)
                {
                    particle->Color = new Vector4(
                        ParticleMath.Lerp(startHues[i], end1, particle->TimeAlive / particle->InitialLife),
                        particle->Color.Y,
                        particle->Color.Z,
                        particle->Color.W);
                }
            } break;

            case Transition.Curve: {
                for (Particle *particle = arrayPtr; particle < tail; particle++)
                {
                    float lifeRatio = particle->TimeAlive / particle->InitialLife;
                    particle->Color = new Vector4(
                        curve.Evaluate(lifeRatio),
                        particle->Color.Y,
                        particle->Color.Z,
                        particle->Color.W);
                }
            } break;

            case Transition.RandomLerp: {
                for (Particle *particle = arrayPtr; particle < tail; particle++, i++)
                {
                    particle->Color = new Vector4(
                        ParticleMath.Lerp(startHues[i], randEndHues[i], particle->TimeAlive / particle->InitialLife),
                        particle->Color.Y,
                        particle->Color.Z,
                        particle->Color.W);
                }
            } break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }