Alpha ops con spritebatch para conseguir luces en 2D

[Hans]

Tengo una textura completamente negra que cubre toda la pantalla y esta otra:



* En el navegador se ve blanco pero el círculo interior es una transparencia en degradado.


Lo que quiero es que a la negra se le reste la transparencia de la otra para simular una luz pero yo y las alpha ops somos archienemigos. A ser posible con spritebatchs. ¿Alguna idea? :P

Ni siquiera sé si la imagen circular es la que tiene que ser xDD



pd.- Tiene que ser compatible con phone, así que no sirven shaders.

[XÑA]

Es decir, quieres utilizar esto como un efecto de luz, que la zona blanca se vea más iluminado ¿no?

Pues a ver

FinalColor = SourceBlend*Color1 + DestinationBlend*Color2

Color1 es el sprite que vas a pintar, y color2 el backbuffer

Por ejemplo, el más normal es este:

FinalColor=SrcAlpha*SourceBlend + InvSrcAlpha*DestinationBlend

El rollo es que este es el que debería haber por defecto, y el que había antes de XNA 4.0. Con 4.0 ahora es Additive...

Si quieres el Alpha de toda la vida, sólo tienes que poner esto:

            spriteBatch.Begin(SpriteSortMode.Deferred, BlendState.NonPremultiplied);

pintas la textura negra de fondo, y luego la textura con el círculo y debería funcionar.

[Hans]

Pos no me funciona :$

[Hans]

No sé si me he explicado bien. El objetivo es obtener un resultado parecido a esto mezclando las dos imagenes (la segunda en varios puntos a la vez)




Y lo blanco es en realidad transparente.

[blau]

Ahi tienes la solucion, ;)

http://www.dotnetclubs.com/forums/t/3230.aspx

EDIT: O a lo mejor no, pq creo que esta en xna 3.1, pero a lo mejor te da una pista ;)

[Hans]

Esa solución la puso el otro día Ollydbg en el foro de meristation (ya comentó que le habías ayudado :P). Lo malo es que utiliza un custom shader y eso en WP7 no está permitido, así que no me vale T_T

[XÑA]

FinalColor=SrcAlpha*SourceBlend + InvSrcAlpha*DestinationBlend

Tu lo quieres al reves, si el Alpha es 0, que se vea 0, y si es 1, que se vea el fono

FinalColor=InvSrcAlpha*SourceBlend + SrcAlpha*DestinationBlend
;)

[Hans]

Al final he conseguido lo que buscaba (casi idéntico resultado al que ha puesto Blau) usando sólo alpha ops y calculando todas las zonas iluminadas usando un rendetarget2D. De paso he añadido color y ya que estaba me he creado un motor de iluminación 2D la mar de majo, donde se pueden poner tantas luces como te de la gana con las formas que te de la gana, intensidad y tamaños variables y que además se mezclan entre ellas bastante bien. Cuando pueda pondré capturas.

Lo mejor de todo es que no usa custom shaders, así que es compatible con WP7 y apenas ha bajado el rendimiento en un escenario con cerca de 30 focos.

[Hans]

Os pongo la explicación de lo que he hecho, sin custom shaders :P

Primero, necesitamos texturas de luz como estas (en el navegador web parecerá que el círculo central es blanco pero en realidad es un transparente):




La idea principal es un fondo negro a pantalla completa y dibujarlo y luego dibujar cada luz en la posición deseada con el tamaño deseado y la intensidad deseada utilizando alpha ops concretas. Todo esto se dibuja en un render target que se guarda y más adelante se utiliza para dibujar encima de la escena final. Además, para dar color a las luces cojo la textura, la clono en otra e invierto la clonada de tal manera que los negros pasen a ser las transparencias y las transparencias pasen a ser blanco. Luego basta con dibujar la textura nueva usando los parámetros de intensidad, tamaño y posición de la luz y aplicando un diffuse concreto para darle el color deseado al blanco original.


Os pongo la clase cLuz, la clase cManejadorIluminacion y la clase fondoConCustomDraw2DParaLucesDeColores, las tengo sin documentar porque las hice antes de ayer y no he tenido tiempo. Tampoco hay que ser experto para entenderlo y mis funciones tienen nombres muy claros. Está un poco mezclado entre castellano e inglés porque aquí sólo lo uso yo. Hay cosas que os sobran (por ejemplo lo de la niebla, es sólo algo que estoy añadiendo) o que no encontraréis (por ejemplo referencias a mis propias librerías, el código no funciona tal cual copiar y pegar).


La función Generate del manejador se usa antes de dibujar el resto de la escena (yo la tengo antes del Clean principal). Tb debéis tener en cuenta que yo utilizo esto con sistema de cámaras que enfonca a planos en 3D, no utiliza la parte 2D del framework. Sin embargo las luces las calculo y las dibujo usando la parte 2D (igual que el sistema de partículas), es decir un spritebatch. De ahí que a la hora de dibujar las luces haga una transformación respecto a la cámara y se la pase al spritebatch usando un basicEffect.



manejadorIluminacion.cs

Código [Seleccionar] Expand

#define SHOW_DEBUG_OFF

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Content;


namespace SistemaJosemaNamespace
{
   public class cManejadorIluminacion2D : cFondo
   {
       public const int NUM_LIGTH_TYPES = 9;
       const int MAX_LUCES = 40;

       cBaseExtendida dBaseExtendida;

       static BlendState blendState = new BlendState();

       cFondo fondoNieblaTrasero;
       cFondo fondoNieblaDelantero;

       cFondo fondoNegro;
       List<cLight2D> static_listaLuces = new List<cLight2D>();
       List<cLight2D> dinamic_listaLucesActivadas = new List<cLight2D>();

       RenderTarget2D renderTarget;

#if SHOW_DEBUG_ON
       cFondo fondoDebug;
#endif


       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       /// <summary>
       /// Constructor
       /// </summary>
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       public cManejadorIluminacion2D(cBaseExtendida dBaseExtendida)
           : base(dBaseExtendida, "invisible", new Vector2(512, -384), new Vector2(1024, 768), cPrefijo.cTipoPrefijo.neutro_neutro)
       {
           this.dBaseExtendida = dBaseExtendida;
           dBaseExtendida.ManejadorIluminacion2D = this;

           // generar las texturas de color a partir de las texturas de luz
           for (int i = 0; i < NUM_LIGTH_TYPES; i++)
           {
               dBaseExtendida.LoadTextureInDictionaryDirectDandoTexturaySuNombreManualmente("luzColorManual_" + (i + 1).ToString(), dBaseExtendida.Utils.GenerateTotalInverseTexture2D(dBase.GetTexture("luz_" + (i + 1).ToString())));
           }

#if SHOW_DEBUG_ON
           fondoDebug = new cFondo(dBaseExtendida, "luzColorManual_1", new Vector2(200, -200), new Vector2(150, 150), cPrefijo.cTipoPrefijo.neutro_neutro);
#endif

           fondoNieblaTrasero = new cFondo(dBaseExtendida, "blanco", new Vector2(512, -384), 2 * new Vector2(1024, 768), cPrefijo.cTipoPrefijo.neutro_neutro);
           fondoNieblaTrasero.Fading = 0;

           fondoNieblaDelantero = new cFondo(dBaseExtendida, "blanco", new Vector2(512, -384), 2 * new Vector2(1024, 768), cPrefijo.cTipoPrefijo.neutro_neutro);

           fondoNegro = new cFondo(dBaseExtendida, "negro", new Vector2(512, -384), 2 * new Vector2(1024, 768), cPrefijo.cTipoPrefijo.neutro_neutro);

           for (int i = 0; i < MAX_LUCES; i++)
           {
               static_listaLuces.Add(new cLight2D(dBaseExtendida, "luz_1", new Vector2(512, -384), 330 * Vector2.One, cPrefijo.cTipoPrefijo.neutro_neutro));
               static_listaLuces[i].DiffuseColor = Color.Blue.ToVector3();
           }

#if WINDOWS
           renderTarget = new RenderTarget2D(dBase.Game.GraphicsDevice, dBase.Game.GraphicsDevice.PresentationParameters.BackBufferWidth, dBase.Game.GraphicsDevice.PresentationParameters.BackBufferHeight);
#endif

#if XBOX
           renderTarget = new RenderTarget2D(dBase.Game.GraphicsDevice, 512, 512);
#endif

#if WINDOWS_PHONE
           renderTarget = new RenderTarget2D(dBase.Game.GraphicsDevice, 256, 256);
#endif
       }
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       /// <summary>
       /// Reset
       /// </summary>
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       public void Reset()
       {
           dinamic_listaLucesActivadas.Clear();
           for (int i = 0; i < static_listaLuces.Count; i++) static_listaLuces[i].Reset();
       }
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       /// <summary>
       /// ActivarLuz
       /// </summary>
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       public void ActivarLuz(cPlano3D planoAsociado, Vector2 sca1, Vector2 sca2, Vector2 offset, Color color, String tipo, float intensityA, float intensityB, float timeVariation, float speed, bool detras)
       {
           int ind = dinamic_listaLucesActivadas.Count;
           if ((ind + 1) >= MAX_LUCES) throw new Exception("MAX_LUCES es " + MAX_LUCES.ToString() + " > " + ind.ToString());

           dinamic_listaLucesActivadas.Add(static_listaLuces[ind]);
           static_listaLuces[ind].Activar(planoAsociado, sca1, sca2, offset, tipo, color, intensityA, intensityB, timeVariation, speed, detras);
       }
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       /// <summary>
       /// Generate
       /// </summary>
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       public void Generate()
       {
           if (dBaseExtendida.GlobalIlumination2D < 1)
           {
               dBase.Game.GraphicsDevice.Clear(Color.White);

               dBase.Game.GraphicsDevice.SetRenderTarget(renderTarget);

               fondoNegro.Draw();

               for (int i = 0; i < dinamic_listaLucesActivadas.Count; i++) dinamic_listaLucesActivadas[i].Generate();

               dBase.Game.GraphicsDevice.SetRenderTarget(null);

               this.ForceTextureForVideo(renderTarget);
           }
       }
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       /// <summary>
       /// Update
       /// </summary>
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       public void Update()
       {
           fondoNieblaDelantero.Fading = dBaseExtendida.GlobalFog2D;

           if (dBaseExtendida.GlobalIlumination2D < 1)
           {
               for (int i = 0; i < dinamic_listaLucesActivadas.Count; i++) dinamic_listaLucesActivadas[i].Update();
           }
       }
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       /// <summary>
       /// DrawfondoColorDetrasDeTodo
       /// </summary>
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       public void DrawfondoColorDetrasDeTodo()
       {
           if (dBaseExtendida.GlobalIlumination2D < 1)
           {
               for (int i = 0; i < dinamic_listaLucesActivadas.Count; i++) dinamic_listaLucesActivadas[i].DrawfondoColorDetrasDeTodo();
           }
       }
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       /// <summary>
       /// DrawfondoColorDelanteDeTodo
       /// </summary>
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       public void DrawfondoColorDelanteDeTodo()
       {
           fondoNieblaTrasero.Draw();

           if (dBaseExtendida.GlobalIlumination2D < 1)
           {
               for (int i = 0; i < dinamic_listaLucesActivadas.Count; i++) dinamic_listaLucesActivadas[i].DrawfondoColorDelanteDeTodo();
           }
       }
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       /// <summary>
       /// Draw
       /// </summary>
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
       public override void Draw()
       {
           fondoNieblaDelantero.Draw();

           if (dBaseExtendida.GlobalIlumination2D < 1)
           {
               //for (int i = 0; i < dinamic_listaLucesActivadas.Count; i++) dinamic_listaLucesActivadas[i].Draw();

               base.Fading = (1 - dBaseExtendida.GlobalIlumination2D);
               base.Draw();
           }

#if SHOW_DEBUG_ON
           fondoDebug.Draw();
#endif
       }
   }
}

[Hans]

luz.cs

Código [Seleccionar] Expand

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Content;


namespace SistemaJosemaNamespace
{
    public class cLight2D : cFondo
    {
        public const float INFINITE_TIME_VARIATION = 999999;

        cBaseExtendida dBaseExtendida;

        static BasicEffect basicEffect = null;
        static BlendState blendState = new BlendState();
        Vector3 mainPosition = Vector3.Zero;

        cFondoConCustomDraw2DParaLucesDeColores fondoColor;
        cPlano3D PlanoAsociado;

        float intensityA = 1;
        float intensityB = 1;
        float timeVariation = 1;

        cSpline splineIntensidad;
        float intensidadActual = 0;

        cSpline splineScala;
        Vector2 scalaActual = Vector2.One;

        float speed = 1;
        bool Detras = true;


        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Constructor
        /// </summary>
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        public cLight2D(cBaseExtendida dBaseExtendida, String textureName, Vector2 pos, Vector2 sca, cPrefijo.cTipoPrefijo tipoPrefijo)
            : base(dBaseExtendida, textureName, Vector2.Zero, sca, tipoPrefijo)
        {
            this.dBaseExtendida = dBaseExtendida;

            blendState.AlphaSourceBlend = Blend.Zero;
            blendState.ColorSourceBlend = blendState.AlphaSourceBlend;
            blendState.AlphaDestinationBlend = Blend.SourceColor;
            blendState.ColorDestinationBlend = blendState.AlphaDestinationBlend;

            if (basicEffect == null)
            {
                basicEffect = new BasicEffect(dBase.Game.GraphicsDevice)
                {
                    TextureEnabled = true,
                    VertexColorEnabled = false,
                };
            }

            fondoColor = new cFondoConCustomDraw2DParaLucesDeColores(dBaseExtendida, "luzColorManual_1", Vector2.Zero, this.Scale2D, cPrefijo.cTipoPrefijo.neutro_neutro);
            fondoColor.DiffuseColor = Color.Yellow.ToVector3();
            fondoColor.Fading = 0.5f;

            splineIntensidad = new cSpline(dBase);
            splineIntensidad.AddPoint2D(Vector2.One, false);
            splineIntensidad.AddPoint2D(Vector2.One, true);

            splineScala = new cSpline(dBase);
            splineScala.AddPoint2D(Vector2.One, false);
            splineScala.AddPoint2D(Vector2.One, true);
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Activar
        /// </summary>
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        public void Activar(cPlano3D plano3DAsociado, Vector2 sca1, Vector2 sca2, Vector2 offset, String tipo, Color diffuseColor, float intensityA, float intensityB, float timeVariation, float speed, bool detras)
        {
            this.intensityA = intensityA;
            this.intensityB = intensityB;
            this.timeVariation = timeVariation;
            this.speed = speed;
            this.Detras = detras;

            splineIntensidad.Clear();
            splineIntensidad.AddPoint2D(intensityB * Vector2.One, false);
            splineIntensidad.AddPoint2D(intensityA * Vector2.One, false);
            splineIntensidad.AddPoint2D(intensityA * Vector2.One, false);
            splineIntensidad.AddPoint2D(intensityB * Vector2.One, true);
            splineIntensidad.Restart();
            splineIntensidad.Update(100 * speed);

            splineScala.Clear();
            splineScala.AddPoint2D(sca2 * Vector2.One, false);
            splineScala.AddPoint2D(sca1 * Vector2.One, false);
            splineScala.AddPoint2D(sca1 * Vector2.One, false);
            splineScala.AddPoint2D(sca2 * Vector2.One, true);
            splineScala.Restart();
            splineScala.Update(100 * speed);

            this.DiffuseColor = diffuseColor.ToVector3();
            this.PlanoAsociado = plano3DAsociado;
            this.Position2D = offset;
            this.Scale2D = splineScala.GetActualPoint2D();
            fondoColor.Scale2D = splineScala.GetActualPoint2D();
            TextureName = "luz_" + tipo;
            fondoColor.TextureName = "luzColorManual_" + tipo;
            fondoColor.DiffuseColor = diffuseColor.ToVector3();
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// MainPosition
        /// </summary>
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        public Vector3 MainPosition
        {
            set { mainPosition = value; }
            get { return mainPosition; }
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Reset
        /// </summary>
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        public void Reset()
        {
            splineIntensidad.Clear();
            splineIntensidad.AddPoint2D(Vector2.One, false);
            splineIntensidad.AddPoint2D(Vector2.One, true);
            splineIntensidad.Restart();

            splineScala.Clear();
            splineScala.AddPoint2D(Vector2.One, false);
            splineScala.AddPoint2D(Vector2.One, true);
            splineScala.Restart();

            Detras = true;
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Generate
        /// </summary>
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        public void Generate()
        {
            if (dibujarEsteFrame)
            {
                // para que mire a la camara, no funciona excesivamente bien (descartado pero guardado aqui por si acaso se necesita en el futuro)
                // enlace al blog con todo http://blogs.msdn.com/b/shawnhar/archive/2011/01/12/spritebatch-billboards-in-a-3d-world.aspx

                basicEffect.World = Matrix.CreateScale(1, -1.33f, 1) * Matrix.CreateTranslation(mainPosition);
                basicEffect.View = dBase.Camera.ViewMatrix;
                basicEffect.Projection = dBase.Camera.ProjectionMatrix;
                basicEffect.DiffuseColor = Vector3.One;
                basicEffect.Alpha = 1;

                // tell sprite batch to begin, using the spriteBlendMode specified in
                // initializeConstants
                //dBase.SpriteBatch.Begin(SpriteSortMode.Deferred, blendState);
                dBase.SpriteBatch.Begin(SpriteSortMode.Deferred, blendState, null, null, null, basicEffect);

                if (Mirror) dBase.SpriteBatch.Draw(texture, destinationRect, null, color, Rotation2D, origin, SpriteEffects.FlipHorizontally, 0);
                else dBase.SpriteBatch.Draw(texture, destinationRect, null, color, Rotation2D, origin, SpriteEffects.None, 0);

                dBase.SpriteBatch.End();
            }
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Update
        /// </summary>
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        public virtual void Update()
        {
            mainPosition = PlanoAsociado.Position;
            this.Rotation2D = -PlanoAsociado.PlaneRotation;

            intensidadActual = splineIntensidad.GetActualPoint().X;
            //if (intensidadActual > PlanoAsociado.LuzMaxima) intensidadActual = PlanoAsociado.LuzMaxima;
            fondoColor.MaxFading = intensidadActual;

            scalaActual = splineScala.GetActualPoint2D() * PlanoAsociado.LuzMaxima;
            this.Scale2D = scalaActual / cBase.RelacionResBase;

            fondoColor.Fading = (1 - dBaseExtendida.GlobalIlumination2D);
            fondoColor.DiffuseColor = this.DiffuseColor;
            fondoColor.Scale2D = this.Scale2D;
            fondoColor.MainPosition = this.mainPosition;
            fondoColor.Rotation2D = this.Rotation2D;

            splineScala.Update(speed);
            splineIntensidad.Update(speed);
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// DrawfondoColorDetrasDeTodo
        /// </summary>
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        public void DrawfondoColorDetrasDeTodo()
        {
            if (dibujarEsteFrame && Detras) fondoColor.Draw();
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// DrawfondoColorDelanteDeTodo
        /// </summary>
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        public void DrawfondoColorDelanteDeTodo()
        {
            if (dibujarEsteFrame && !Detras) fondoColor.Draw();
        }
    }
}



fondoConCustomDraw2DParaLucesDeColores.cs

Código [Seleccionar] Expand

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Content;


namespace SistemaJosemaNamespace
{
    public class cFondoConCustomDraw2DParaLucesDeColores : cFondo
    {
        static BasicEffect basicEffect = null;
        Vector3 mainPosition = Vector3.Zero;

        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Constructor
        /// </summary>
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        public cFondoConCustomDraw2DParaLucesDeColores(cBase dBase, String textureName, Vector2 pos, Vector2 sca, cPrefijo.cTipoPrefijo tipoPrefijo)
            : base(dBase, textureName, Vector2.Zero, sca, tipoPrefijo)
        {
            if (basicEffect == null)
            {
                basicEffect = new BasicEffect(dBase.Game.GraphicsDevice)
                {
                    TextureEnabled = true,
                    VertexColorEnabled = false,
                };
            }
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// MainPosition
        /// </summary>
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        public Vector3 MainPosition
        {
            set { mainPosition = value; }
            get { return mainPosition; }
        }
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>
        /// Draw
        /// </summary>
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
        public override void Draw()
        {
            if (dibujarEsteFrame)
            {
                // para que mire a la camara, no funciona excesivamente bien (descartado pero guardado aqui por si acaso se necesita en el futuro)
                // enlace al blog con todo http://blogs.msdn.com/b/shawnhar/archive/2011/01/12/spritebatch-billboards-in-a-3d-world.aspx

                basicEffect.World = Matrix.CreateScale(1, -1.33f, 1) * Matrix.CreateTranslation(mainPosition);
                basicEffect.View = dBase.Camera.ViewMatrix;
                basicEffect.Projection = dBase.Camera.ProjectionMatrix;
                basicEffect.DiffuseColor = DiffuseColor;
                basicEffect.Alpha = Fading;

                // tell sprite batch to begin, using the spriteBlendMode specified in
                // initializeConstants
                //dBase.SpriteBatch.Begin(SpriteSortMode.Deferred, blendState);
                dBase.SpriteBatch.Begin(SpriteSortMode.Immediate, BlendState.NonPremultiplied, null, null, null, basicEffect);

                if (Mirror) dBase.SpriteBatch.Draw(texture, destinationRect, null, color, Rotation2D, origin, SpriteEffects.FlipHorizontally, 0);
                else dBase.SpriteBatch.Draw(texture, destinationRect, null, color, Rotation2D, origin, SpriteEffects.None, 0);

                dBase.SpriteBatch.End();
            }
        }
    }
}

[Vicente]

Dios que dolor de corazón ver cosas como cLight en C# :p

[Hans]

¿Por? :P

[Vicente]

Porque el código en C# no debería escribirse así, ni usar notación húngara en las variables, ni esas cabeceras raras :p Si miras el Framework nada está hecho así.

Hay unas guías por parte de Microsoft para este tipo de cosas (las Design Guidelines for Class Library Developers), con una sección específica para como poner nombres:

http://msdn.microsoft.com/en-us/library/ms229002.aspx

Por ejemplo, una regla dice :p

"Do not give class names a prefix (such as the letter C).
Interfaces, which should begin with the letter I, are the exception to this rule."

Y luego lo de tener variables y tal en castellano, ya cuestión de gustos personales (a mi no me gusta mezclar idiomas en el código, pero vamos, eso ya es personal).

[Hans]

Hombre, M$ no es precísamente un ejemplo de buena programación cuando absolutamente todo lo que hacen tiene bugs a cascoporro y mensajes de error absurdos como ERROR EN EL ERROR (verídico, lo vi el otro día en un Windows Server xDD) He visto decenas de ejemplos escritos en C# teóricamente "bien escritos" y es un supuesto estandar bastante decente pero tb bastante sucio para leer, con variables desperdigadas por cualquier sitio y el tag #region molestando a la lectura todo el rato. Si es que sólo hay que coger cualquier ejemplo del creators para ver un desorden absoluto en el código, y eso que lo hacen quienes más saben.

Por no hablar de que seguir el estandar de una compañía que es incapaz de seguir ni el de HTML se me antoja raro

Poner c delante de mis nombres de clase me sirven para diferenciar mis clases de las de cualquiera, en todos los ejemplos que he visto las llaman exactamente igual pero sin la c,con lo cual a primera vista sería incapaz de decir si son mías o de Espinete. Además, si algún día tuviera que cambiar el nombre a las clases casi bastaría con hacer un reemplazar de "class c" por "class"xDD

Las cabeceras las uso prácticamente para separar funciones (no necesito documentar un código que sólo leo yo y que apenas tiene 3 meses), ya que con el nombre de las mismas y de las variables se sobreentiende siempre lo que hacen el 99% de las veces (una función que se llama GenerarExplosionParaMatarABichoAzul hace eso, no creo que nadie no lo entienda). En c++ lo tengo todo documentado perfectamente para un motor de documentación del que no recuerdo el nombre porque no lo ha usado nadie para leer nada (ni yo, vaya pérdida de tiempo xDD)

Además, según el manual del buen usuario de C# no hay que usar mucho métodos virtuales y sobreescribirlos y yo lo hago todo el rato, sobreescribiendo funciones hasta 5 veces, para reutiliza todo lo posible. De hecho programo prácticamente como si lo hiciera en C++, sin hacer puñetero caso al garbage collector ni a nada parecido y saco más rendimiento que el 99% de la gente que usa XNA.

Soy un chico C# malo  >:D



pd.- Lo de mezclar idiomas es por vaguería, normalmente lo pongo todo en inglés :P

[Vicente]

Esas guías son las que sigue el propio Framework de .NET, y las que intenta seguir la gente que quiere ser una buena persona en el mundo de C#. Hay incluso herramientas específicas para esto (StyleCop, FxCop) que te ayudan a corregir estos errores. Si no las quieres seguir porque MS también hace cosas mal, pues tu mismo :p

Sobre lo de que escribes C# como si fuera C++, eso estaba muy claro después de ver el código que has puesto :p Pero sobre lo de que le sacas más rendimiento que la gente que conoce C# de verdad, ni de coña :) Por mucho que C# y C++ se parezcan, son lenguajes diferentes, y si quieres aprovecharlo al máximo, piensa en C#.

Este post de Reed Copsey dice lo mismo pero lo explica bastante mejor:

http://reedcopsey.com/2009/05/20/just-keep-repeating-c-is-not-java-c-is-not-c/