示例#1
0
        public ParticleEmitter(ParticleData data)
        {
            if (r == null) r = new Random();

            particleData = data;
            particles = new List<Particle>();
            ngon = new nGonBuilder(Color.White);
        }
示例#2
0
        public static ParticleEmitter CreateStream(Color c, float time, float speed, float scaleMax)
        {
            ParticleData data = new ParticleData();
            data.Blend = ColorBlendMode.TimeLerp;
            data.Bounce = BounceMode.None;
            data.Colors = new Color[] { Color.White, c, Color.Black };
            data.MaxSides = 2;
            data.MinSides = 2;
            data.MaxSpeed = speed + 0.5f;
            data.MinSpeed = speed;
            data.MaxTime = time + 1;
            data.MinTime = time;
            data.Rotation = RotationMode.Direction;
            data.RotationMult = 1;
            data.Scale = ScaleMode.Time;
            data.ScaleMax = scaleMax;
            data.ScaleMin = 1;

            ParticleEmitter emitter = new ParticleEmitter(data);

            return emitter;
        }
示例#3
0
        private Particle CreateParticle(ParticleData data, Vector2 pos, float? dir = null)
        {
            Particle p = new Particle();
            p.color = particleData.Colors[0];
            p.lifetime = 0;
            p.position = pos;
            if (dir.HasValue)
                p.direction = new Vector2((float)Math.Cos(dir.Value), (float)Math.Sin(dir.Value));
            else
                p.direction = new Vector2((float)r.NextDouble() - 0.5f, (float)r.NextDouble() - 0.5f);
            p.direction.Normalize();

            p.velocity = ((float)r.NextDouble() * (data.MaxSpeed - data.MinSpeed)) + data.MinSpeed;
            p.lifespan = ((float)r.NextDouble() * (data.MaxTime - data.MinTime)) + data.MinTime;

            switch(data.Scale)
            {
                case ScaleMode.Pick:
                    if (r.NextDouble() > 0.5)
                        p.scale = data.ScaleMin;
                    else p.scale = data.ScaleMax;
                    break;
                case ScaleMode.Random:
                    p.scale = ((float)r.NextDouble() * (data.ScaleMax - data.ScaleMin)) + data.ScaleMin;
                    break;
                case ScaleMode.Time:
                    p.scale = data.ScaleMin;
                    break;
                case ScaleMode.Velocity:
                    p.scale = ((p.velocity - data.MinSpeed) / (data.MaxSpeed - data.MinSpeed)) * (data.ScaleMax - data.ScaleMin) + data.ScaleMin;
                    break;
            }

            p.sides = r.Next(data.MinSides, data.MaxSides + 1);
            p.rotation = (float)Math.Atan2(p.direction.Y, p.direction.X);

            return p;
        }
示例#4
0
            public float velocity; //velocity of the particle

            #endregion Fields

            #region Methods

            public bool Update(ParticleData data)
            {
                lifetime += Time.Delta;

                if (lifetime > lifespan)
                    return false;

                position += direction * velocity * Time.Delta;

                if (data.Bounce == BounceMode.Both || data.Bounce == BounceMode.Vertical)
                {
                    if (position.Y > Screen.Y && direction.Y > 0 ||
                        position.Y < -Screen.Y && direction.Y < 0)
                    {
                        direction.Y *= -1;
                        rotation = (float)Math.Atan2(direction.Y, direction.X);
                    }
                }
                if (data.Bounce == BounceMode.Both || data.Bounce == BounceMode.Horizontal)
                {
                    if (position.X > Screen.X && direction.X > 0 ||
                        position.X < -Screen.X && direction.X < 0)
                    {
                        direction.X *= -1;
                        rotation = (float)Math.Atan2(direction.Y, direction.X);
                    }
                }

                switch (data.Scale)
                {
                    case ScaleMode.Time:
                        scale = ((lifetime / lifespan) * (data.ScaleMax - data.ScaleMin)) + data.ScaleMin;
                        break;
                    case ScaleMode.Velocity:
                        scale = ((velocity - data.MinSpeed) / (data.MaxSpeed - data.MinSpeed)) * (data.ScaleMax - data.ScaleMin) + data.ScaleMin;
                        break;
                }
                int id = 0;
                float step = lifespan / (data.Colors.Length - 1);
                while ((id + 1) * step < lifetime) id++;

                color = Color.Lerp(data.Colors[id], data.Colors[id + 1], (lifetime - (id * step)) / step);

                return true;
            }