ParticleSystem.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
 
namespace Jypeli.Effects
{
    public enum BlendMode
    {
        Alpha,
        Additive
    }
 
 
    public class ParticleSystem : GameObject
    {
        private Random random = new Random();
 
        // Lista efektin partikkeleille
        private LinkedList<Particle> particles;
 
        // Jono efektin vapaille partikkeleille
        private Queue<Particle> freeParticles;
 
        public Image ParticleImage { get; set; }
 
        public Image OuterParticleImage { get; set; }
 
        // Perivien luokkien täytyy määrittää nämä muuttujat
        #region Subclass variables
 
        public double MinScale { get; set; }
 
        public double MaxScale { get; set; }
 
        public double ScaleAmount { get; set; }
 
        public double MinVelocity { get; set; }
        public double MaxVelocity { get; set; }
 
        public double MinLifetime { get; set; }
        
        public double MaxLifetime { get; set; }
 
        public double MinAcceleration { get; set; }
 
        public double MaxAcceleration { get; set; }
 
        public double MinRotationSpeed { get; set; }
 
        public double MaxRotationSpeed { get; set; }
 
        public double MinRotation { get; set; }
 
        public double MaxRotation { get; set; }
 
        public double AlphaAmount { get; set; }
 
        #endregion
 
        public BlendMode BlendMode { get; set; }
 
        public Boolean IgnoreWind { get; set; }
 
        private Boolean visible = true;
        private Boolean fadeIn = false;
        private Boolean fadeOut = false;
        private double originalAlpha = 1.0;
        private double fadeTime = 0.0;
        private double fadeTimePassed = 0.0;
 
        public void FadeIn(double timeInSeconds)
        {
            if (!visible)
            {
                fadeTimePassed = 0.0;
                fadeIn = true;
                fadeTime = timeInSeconds;
            }
        }
 
        public void FadeOut(double TimeInSeconds)
        {
            if (visible)
            {
                originalAlpha = AlphaAmount;
                fadeTimePassed = 0.0;
                fadeOut = true;
                fadeTime = TimeInSeconds;
            }
        }
        public ParticleSystem(Image particleImage, int maxAmountOfParticles)
            : base(0, 0)
        {
            this.ParticleImage = particleImage;
            AlphaAmount = 1.0;
            IgnoreWind = false;
            BlendMode = BlendMode.Alpha;
 
            IsUpdated = true;
            InitializeParticles();
 
            particles = new LinkedList<Particle>();
            freeParticles = new Queue<Particle>(maxAmountOfParticles);
            for (int i = 0; i < maxAmountOfParticles; i++)
            {
                freeParticles.Enqueue(new Particle());
            }
        }
 
        protected virtual void InitializeParticles()
        {
        }
 
        public void AddEffect(double x, double y, int numberOfParticles)
        {
            AddEffect(new Vector(x, y), numberOfParticles);
        }
 
        public void AddEffect(Vector position, Angle angle, int numberOfParticles)
        {
            for (int i = 0; i < numberOfParticles && freeParticles.Count > 0; i++)
            {
                Particle p = freeParticles.Dequeue();
                particles.AddLast(p);
                InitializeParticle(p, position, angle);
            }
        }
 
        public void AddEffect(Vector position, int numberOfParticles)
        {
            for (int i = 0; i < numberOfParticles && freeParticles.Count > 0; i++)
            {
                Particle p = freeParticles.Dequeue();
                particles.AddLast(p);
                InitializeParticle(p, position);
            }
        }
 
        protected virtual Vector GiveRandomDirection()
        {
            double angle = random.NextDouble() * MathHelper.TwoPi;
            return new Vector(Math.Cos(angle), Math.Sin(angle));
        }
 
        protected virtual void InitializeParticle(Particle p, Vector position)
        {
            Vector direction = GiveRandomDirection();
 
            double scale = RandomGen.NextDouble(MinScale, MaxScale);
            double rotation = RandomGen.NextDouble(MinRotation, MaxRotation);
            double velocity = RandomGen.NextDouble(MinVelocity, MaxVelocity);
            double lifetime = RandomGen.NextDouble(MinLifetime, MaxLifetime);
            double acceleration = RandomGen.NextDouble(MinAcceleration, MaxAcceleration);
            double rotationSpeed = RandomGen.NextDouble(MinRotationSpeed, MaxRotationSpeed);
 
            p.Initialize(position, scale, rotation, rotationSpeed, velocity * direction, acceleration * direction, lifetime);
        }
 
        protected virtual void InitializeParticle(Particle p, Vector position, Angle angle)
        {
            Vector direction = GiveRandomDirection();
 
            double rotation = angle.Degrees;
            double scale = RandomGen.NextDouble(MinScale, MaxScale);
            double velocity = RandomGen.NextDouble(MinVelocity, MaxVelocity);
            double lifetime = RandomGen.NextDouble(MinLifetime, MaxLifetime);
            double acceleration = RandomGen.NextDouble(MinAcceleration, MaxAcceleration);
            double rotationSpeed = RandomGen.NextDouble(MinRotationSpeed, MaxRotationSpeed);
 
            p.Initialize(position, scale, rotation, rotationSpeed, velocity * direction, acceleration * direction, lifetime);
        }
 
        public override void Update(Time time)
        {
            double t = time.SinceLastUpdate.TotalSeconds;
 
            LinkedListNode<Particle> node = particles.First;
            while (node != null)
            {
                Particle p = node.Value;
                if (p.Alive)
                {
                    p.Update(t);
                    node = node.Next;
                }
                else
                {
                    freeParticles.Enqueue(p);
                    LinkedListNode<Particle> previous = node;
                    node = node.Next;
                    particles.Remove(previous);
                }
            }
            if (fadeOut)
            {
                AlphaAmount = Math.Min(1 - fadeTimePassed / fadeTime, originalAlpha);
                fadeTimePassed += t;
                if (fadeTime <= fadeTimePassed)
                {
                    AlphaAmount = 0.0;
                    fadeOut = false;
                    visible = false;
                }
            }
            if (fadeIn)
            {
                AlphaAmount = Math.Min(fadeTimePassed / fadeTime, originalAlpha);
                fadeTimePassed += t;
                if (fadeTime <= fadeTimePassed)
                {
                    AlphaAmount = originalAlpha;
                    fadeIn = false;
                    visible = true;
                }
            }
 
            base.Update(time);
        }
 
 
        static readonly Vector2 textureTopLeft = new Vector2(0.0f, 0.0f);
        static readonly Vector2 textureBottomLeft = new Vector2(0.0f, 1.0f);
        static readonly Vector2 textureTopRight = new Vector2(1.0f, 0.0f);
        static readonly Vector2 textureBottomRight = new Vector2(1.0f, 1.0f);
 
        static readonly Vector3 topLeft = new Vector3(-0.5f, 0.5f, 0);
        static readonly Vector3 bottomLeft = new Vector3(-0.5f, -0.5f, 0);
        static readonly Vector3 topRight = new Vector3(0.5f, 0.5f, 0);
        static readonly Vector3 bottomRight = new Vector3(0.5f, -0.5f, 0);
 
        static readonly VertexPositionTexture[] vertices =
        {
            // Triangle 1
            new VertexPositionTexture(topLeft, textureTopLeft),
            new VertexPositionTexture(bottomLeft, textureBottomLeft),
            new VertexPositionTexture(topRight, textureTopRight),
 
            // Triangle 2
            new VertexPositionTexture(bottomLeft, textureBottomLeft),
            new VertexPositionTexture(bottomRight, textureBottomRight),
            new VertexPositionTexture(topRight, textureTopRight),
        };
 
        private static BlendState ToXnaBlendState(BlendMode mode)
        {
            switch (mode)
            {
                case BlendMode.Alpha:
                    return BlendState.AlphaBlend;
                case BlendMode.Additive:
                    return BlendState.Additive;
                default:
                    return BlendState.AlphaBlend;
            }
        }
 
        internal void Draw(Matrix worldMatrix)
        {
            var device = Game.GraphicsDevice;
            var effect = Graphics.BasicTextureEffect;
 
            Texture2D texture = ParticleImage.XNATexture;
 
            device.RasterizerState = RasterizerState.CullClockwise;
            device.SamplerStates[0] = SamplerState.LinearClamp;
            device.BlendState = ToXnaBlendState(BlendMode);
            
            effect.Texture = texture;
            effect.CurrentTechnique.Passes[0].Apply();
 
            if (OuterParticleImage == null)
            {
                foreach (Particle p in particles)
                {
                    double nTime = p.Lifetime.TotalMilliseconds / p.MaxLifetime.TotalMilliseconds;
                    double alpha = 4 * nTime * (1 - nTime) * AlphaAmount;
                    float scale = (float)(p.Scale * (.75f + .25f * nTime * ScaleAmount));
 
                    Matrix matrix =
                        Matrix.CreateScale(scale * texture.Width / texture.Height, scale, 1f)
                        * Matrix.CreateRotationZ((float)p.Rotation)
                        * Matrix.CreateTranslation((float)p.Position.X, (float)p.Position.Y, 0f)
                        * worldMatrix
                        ;
 
                    effect.Alpha = (float)alpha;
                    effect.World = matrix;
                    effect.CurrentTechnique.Passes[0].Apply();
 
                    device.DrawUserPrimitives<VertexPositionTexture>(PrimitiveType.TriangleList, vertices, 0, 2);
                }
            }
            else
            {
                Texture2D outerTexture = OuterParticleImage.XNATexture;
 
                foreach (Particle p in particles)
                {
                    double nTime = p.Lifetime.TotalMilliseconds / p.MaxLifetime.TotalMilliseconds;
                    double alpha = 4 * nTime * (1 - nTime) * AlphaAmount;
                    float scale = (float)(p.Scale * (.75f + .25f * nTime * ScaleAmount));
 
                    Matrix matrix =
                        Matrix.CreateScale(scale, scale, 1f)
                        * Matrix.CreateRotationZ((float)p.Rotation)
                        * Matrix.CreateTranslation((float)p.Position.X, (float)p.Position.Y, 0f)
                        * worldMatrix
                        ;
                    Matrix matrix2 =
                        Matrix.CreateScale(0.65f, 0.65f, 1f)
                        * matrix;
 
                    effect.Texture = texture;
                    effect.Alpha = (float)alpha;
                    effect.World = matrix;
                    effect.CurrentTechnique.Passes[0].Apply();
 
                    device.DrawUserPrimitives<VertexPositionTexture>(PrimitiveType.TriangleList, vertices, 0, 2);
 
                    effect.Texture = outerTexture;
                    effect.World = matrix2;
                    effect.CurrentTechnique.Passes[0].Apply();
 
                    device.DrawUserPrimitives<VertexPositionTexture>(PrimitiveType.TriangleList, vertices, 0, 2);
                }
            }
        }
    }
}