Anterior | Índice | Siguiente
Capítulo 8: Partículas - Un emitidor básico
Lenguaje: C#
Para: VS2005 / VS2008 / SharpDevelop 2.2
Por Dark-N: hernaldog@gmail.com
Visita mi Blog


http://darknromhacking.com

Ir a Parte 2 | Ir a Parte 3


Objetivo: Aprender a usar los diferentes sistemas de Partículas. En este capítulo, un emitidor básico.

Nota: Para todo el tópico de partículas use el código libre hecho por uno de los programadores de SDL.Net Rob Loach.

Las partículas son objetos reales que se renderean en pantalla. Pueden ser cualquier cosa, un Surface, una imagen, un pixel, etc. En general nunca se muestran solas, sino que se usan en conjunto para simular explosiones o efectos gráficos de tornados, o lluvia por ejemplo. Las partículas derivan de la clase Particles.

Un dato, tengo entendido que esta clase Particles solo está disponible para SDL.Net 6.0 en adelante.

Veremos ahora 3 tipos de sistemas de partículas disponibles como son:
  • ParticleRectangleEmitter: Emitidor rectangular de particulas, es como un chorro de partículas arrojadas.
  • ParticleCircleEmitter: partículas que giran o salen disparadas en torno a un centro. Visiblemente son como fuegos artificiales.
  • AnimatedSprite: Son sprites (una imagen por ejemplo) que la trabajamos como una Partícula.
  • ParticlePixel: Es un pixel que se usa como una partícula. Visiblemente se ve como un punto que se mueve. No tiene mucha gracia si no se le aplica un Modificador que la haga mas interesante.

    En esta primera parte usaremos solo ParticleRectangleEmitter, en las siguientes partes usaremos el resto.

    Los Modificadores son Clases especiales usadas por la clase Particle que cambian las partículas en tiempo real. Por ejemplo hay manipuladores para que al acerca el mouse a la partícula, esta se le quiera pegar, como si usáramos un imán. Hay otro manipulador que hace que las partículas revoten con menos gravedad si haces alguna acción con el mouse o teclado.
    Sin Modificadores las partículas serían muy toscas en su representación gráfica, además los manipuladores permiten hacer un efecto visual más completo.

    La forma de uso del manipulador es:

    miParticula.Manipulators.Add( clase manipulador grav);
    
    Ejemplo:
    
    ParticleGravity grav = new ParticleGravity(0.5f); //Clase manipuladora de la la gravedad
    particles.Manipulators.Add(grav);
    


    Ahora vamos por lo principal, los Namespaces que incluiremos son:
    using SdlDotNet.Particles;
    using SdlDotNet.Particles.Emitters;
    using SdlDotNet.Particles.Manipulators;
    

    Lo segundo es crear como variables globales una variable que englobará todas nuestras partículas y otra que represente el emitidor:
    ParticleSystem particles = new ParticleSystem();
    ParticleRectangleEmitter emit;
    

    Luego en inicialización definimos las propiedades de la partícula:
    emit = new ParticleRectangleEmitter(particles);
    emit.Frequency = 50000; // emitira 100000 particulas por cada 1000 updates.
    emit.LifeFullMin = 20;
    emit.LifeFullMax = 50;
    emit.LifeMin = 10;
    emit.LifeMax = 30;
    emit.DirectionMin = -2;
    emit.DirectionMax = -1;
    emit.ColorMin = Color.DarkBlue; // el rango de colores
    emit.ColorMax = Color.LightBlue;
    emit.SpeedMin = 5; //tiene distintas velocidades
    emit.SpeedMax = 20;
    emit.MaxSize = new SizeF(5, 5);  //el rango de tamaño de las particulas
    emit.MinSize = new SizeF(1, 1);
    emit.X = Video.Screen.Width/2;   //aquí situamos la emisión, al centro abajo
    emit.Y = Video.Screen.Height;
    

    Agregamos manipuladores a las partículas:
  • ParticleGravity: permite darle gravedad vertical a las partículas, de esta forma cuando rebotan, lo hacen más lento.
  • ParticleFriction: estable una fricción para que la partícula se mueva más lenta. Se carga un número de punto flotante de 32 bits. Por ejemplo 0.5f.
  • ParticleBoundary: establece lo marcos donde vivirá la partícula, en este caso será toda la pantalla (Video.Screen.Size)

    ParticleGravity grav = new ParticleGravity(0.5f);
    particles.Manipulators.Add(grav); // Gravedad de 0.5f
    particles.Manipulators.Add(new ParticleFriction(0.1f)); // partículas mas lentas
    particles.Manipulators.Add(new ParticleBoundary(SdlDotNet.Graphics.Video.Screen.Size));
    

    Finalmente el evento Tick debe tener el Update y Render para la Clase que creamos que representa las partículas y para la clase que representa nuetro emitidor. Por lo tanto quedaría así:
    private void Tick(object sender, TickEventArgs e)
    {
    	// actualizamos todas las particulas
    	particles.Update();
    	emit.Target.Update();
    
    	// se pinta toda la escena
    	Video.Screen.Fill(Color.Black);
    
    	// pintamos las particulas
    	particles.Render(Video.Screen);
    	emit.Target.Render(Video.Screen);    
    
    	Video.Screen.Update();
    }
    



    Código fuente de está sección (VS2005/V2008):

    using System;
    using System.IO;
    using System.Drawing;
    
    using SdlDotNet.Particles;
    using SdlDotNet.Particles.Emitters;
    using SdlDotNet.Particles.Manipulators;
    using SdlDotNet.Graphics.Sprites;
    using SdlDotNet.Core;
    using SdlDotNet.Input;
    using SdlDotNet.Graphics;
    
    namespace EjemploParticulas
    {
    
    public class Ejemplo1 : IDisposable
    {
        //creamos el sistema de partículas
        ParticleSystem particles = new ParticleSystem();
    
        // creamos un emitidor que lanzará particulas
        ParticleRectangleEmitter emit;
        
    
        public Ejemplo1()
        {            
            Video.WindowIcon();
            Video.WindowCaption = "SDL.NET - Emitidor de Particulas";
            Video.SetVideoMode(400, 300);
            Events.KeyboardDown += new EventHandler < KeyboardEventArgs > (this.KeyboardDown);
            Events.Fps = 30;
            Events.Tick += new EventHandler < TickEventArgs >(this.Tick);
            Events.Quit += new EventHandler < QuitEventArgs >(this.Quit);
        }
    
    
        public void Go()
        {            
            emit = new ParticleRectangleEmitter(particles);
            emit.Frequency = 50000; // emitira 100000 particulas por cada 1000 updates.
            emit.LifeFullMin = 20;
            emit.LifeFullMax = 50;
            emit.LifeMin = 10;
            emit.LifeMax = 30;
            emit.DirectionMin = -2;
            emit.DirectionMax = -1;
            emit.ColorMin = Color.DarkBlue; // es de 2 colores
            emit.ColorMax = Color.LightBlue;
            emit.SpeedMin = 5; //tiene distintas velocidades
            emit.SpeedMax = 20;
            emit.MaxSize = new SizeF(5, 5);  //las particulas tienen distito tamaño
            emit.MinSize = new SizeF(1, 1);
            emit.X = Video.Screen.Width/2;  //aquí situamos la emisión, al centro abajo
            emit.Y = Video.Screen.Height;
    
            // agregamos manipuladores de las particulas
            ParticleGravity grav = new ParticleGravity(0.5f);
            particles.Manipulators.Add(grav); // Gravedad de 0.5f
            particles.Manipulators.Add(new ParticleFriction(0.1f)); // particulas mas lentas
            particles.Manipulators.Add(new ParticleBoundary(SdlDotNet.Graphics.Video.Screen.Size));
    
            Events.Run();
        }
    
    
        [STAThread]
        public static void Main()
        {
            Ejemplo1 particula = new Ejemplo1();
            particula.Go();
        }
    
        
        private void Tick(object sender, TickEventArgs e)
        {
            // actualizamos todas las particulas
            particles.Update();
            emit.Target.Update();
    
            // se pinta toda la escena
            Video.Screen.Fill(Color.Black);
            particles.Render(Video.Screen);
            emit.Target.Render(Video.Screen);    
    
            Video.Screen.Update();
            
        }
    
        private void KeyboardDown(object sender, KeyboardEventArgs e)
        {
            if (e.Key == Key.Escape)
            {
                Events.QuitApplication();
            }            
        }
    
        private void Quit(object sender, QuitEventArgs e)
        {
            Events.QuitApplication();
        }
        
    
        #region IDisposable Members
    
        private bool disposed;
    
        /// < summary >
        /// Destroy object
        /// 
        public void Dispose()
        {
            this.Dispose(true);
            GC.SuppressFinalize(this);
        }
    
        /// < summary >
        /// Destroy object
        /// 
        public void Close()
        {
            Dispose();
        }
    
        /// < summary >
        /// Destroy object
        /// 
        ~Ejemplo1()
        {
            Dispose(false);
        }
        /// < summary >
        /// 
        /// 
        /// < param name="disposing" >
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {                
                this.disposed = true;
            }
        }
    
        #endregion
    }
    }
    

    Una vez codificado, si al compilar no arroja errores, debe aparecerte algo como esto:



    Bajar proyecto para SharpDevelop 2.2 (lo siento, esta vez no lo hice en VS.NET ;) aquí.

    Ir a Parte 2 | Ir a Parte 3


    Anterior | Índice | Siguiente
    Volver a Página Principal

    blog comments powered by Disqus
    2003 - 2018    La Web de Dark-N