Ir al contenido

publicidad

Foto

Alpha Blending XNA 3.1


Este tema ha sido archivado. Esto significa que no puedes responder en este tema.
13 respuestas en este tema

  • Ollydbg

  • Bahamut

  • vida restante: 100%
  • Registrado: 05 sep 2008
  • Mensajes: 6.259
#1

Escrito 19 febrero 2011 - 22:38

Intentaré ser breve.

Tengo este background:
Imagen Enviada

Y estos 2 sprites (en formato png):
Imagen Enviada
Imagen Enviada

Quiero conseguir este resultado:
Imagen Enviada

Pero no consigo hacerlo y lo único que me sale es esto:
Imagen Enviada

Saludos.

  • Btc

  • Valefor

  • vida restante: 100%
  • Registrado: 15 oct 2007
  • Mensajes: 1.932
#2

Escrito 20 febrero 2011 - 22:35

Si es estático, puedes crear una imagen que una esas tres y tenga el resto del fondo que necesitas negro. Si es dinámico, ni idea.

Un saludo, Btc

EDITO: si es dinámico como supongo, tal vez esto pueda ayudarte:

http://blogs.msdn.co...ing-part-1.aspx

Las partes 2 y 3 del tutorial tienen igual url pero cambiando el 1 por 2 y 3, si no me equivoco ;)

  • The_Hans

  • Anima

  • vida restante: 100%
  • Registrado: 27 ene 2004
  • Mensajes: 7.490
#3

Escrito 21 febrero 2011 - 14:26

Pásate a XNA 4.0. el 3.1 está obsoleto y abandonado :P

En cuanto a la pregunta no sé exactamente lo que quieres hacer y encima las operaciones alpha siempre se me atascan :$

  • mopois

  • GRANDIS SUPERNUS

  • vida restante: 100%
  • Registrado: 24 sep 2003
  • Mensajes: 34.259
#4

Escrito 21 febrero 2011 - 14:48

Pásate a XNA 4.0. el 3.1 está obsoleto y abandonado :P

En cuanto a la pregunta no sé exactamente lo que quieres hacer y encima las operaciones alpha siempre se me atascan :$


Cambia mucha cosita en cuanto al dibujo de sprites según he visto...

Yo llevo un tiempo haciendo una cosilla y me una pereza... ¿Hay que cambiar mucho del código? ¿Algún tutorial en condiciones? Igual el tema da para otro hilo por no desviar este...

Imagen Enviada



  • gotenx

  • Bahamut

  • vida restante: 100%
  • Registrado: 13 ene 2008
  • Mensajes: 4.253
#5

Escrito 21 febrero 2011 - 16:13

Pásate a XNA 4.0. el 3.1 está obsoleto y abandonado :P

En cuanto a la pregunta no sé exactamente lo que quieres hacer y encima las operaciones alpha siempre se me atascan :$


Cambia mucha cosita en cuanto al dibujo de sprites según he visto...

Yo llevo un tiempo haciendo una cosilla y me una pereza... ¿Hay que cambiar mucho del código? ¿Algún tutorial en condiciones? Igual el tema da para otro hilo por no desviar este...


Yo estoy siguiendo un libro del 3 para el 4 y la verdad es que no cambia mucho.
Aunque la verdad, prefiriría un libro del 4 para salir de dudas.

  • Ollydbg

  • Bahamut

  • vida restante: 100%
  • Registrado: 05 sep 2008
  • Mensajes: 6.259
#6

Escrito 21 febrero 2011 - 20:26

Ante todo gracias por las respuestas.
Ya he conseguido (bueno, yo no, desde aquí gracias a blau, Javi y TheBigO, al cesar lo que es del cesar, las cosas claras y el chocolate espeso y desde aquí gracias por la ayuda :) hacerlo mediante un pixel shader pasándole dos texturas , una del background y otra textura con la composición de todas las "luces". El resultado de lo que quería conseguir es lo que mostré en la 3ª imagen del post anterior.
El problema que estaba teniendo es que no utilizaba correctamente los Texture2D, el lugar de ser "negros" tenian que ser "blancos" sobre un fondo totalmente transparente, para así lograr que cuando dibujase las "luces" no se solapasen unas con otras.

El tema está en que ahora furula bien:

Imagen Enviada


Puedo tener todas las "luces" que quiera que ya no se solapan (tal y como había puesto en mi post anterior)

Sobre el XNA 4.0 estoy a la espera de instalarme el Visual Studio 2010 Professional, ya que actualmente uso Visual Studio 2008 Professional y "paso" de andar instalando la versión "Express" ya que tarde o temprano instalaré la versión 2010 que utilizo en el trabajo todos los días.

De todas formas me "repatea" que anden cambiando cosas de una versión a otra. Ya pasó lo mismo cuando hace tiempo usaba XNA 2.0.
Las cosas que tenía no funcionaban para XNA 3.0 y había que hacer bastantes cambios para portar algo de la 2.0 a la 3.0
Y ahora vuelve a pasar lo mismo. Hay código que no se puede portar "fácilmente" de la versión 3.0/3.1 a la 4.0 (sobre todo en el tema de los pixel shaders)

Ya podían mantener un poco la compatibilidad, digo yo!. Entiendo que la 4.0 tiene mejoras sobre la 3.0/3.1 y que la 3.0/3.1 las tiene sobre la 2.0 y que la 2.0 la tiene sobre la 1.0, pero j**der!!, que les habría costado mantener la compatibilidad "hacia atrás"?

Ya me veo que ahora haces algo para la 4.0 y dentro de un par de años (o menos), sacan la 5.0 y todo lo que has hecho ya no "vale pa ná" :S

Saludos.

  • Ollydbg

  • Bahamut

  • vida restante: 100%
  • Registrado: 05 sep 2008
  • Mensajes: 6.259
#7

Escrito 21 febrero 2011 - 20:33

Ops doble post

#8

Escrito 21 febrero 2011 - 22:14

Ya podían mantener un poco la compatibilidad, digo yo!. Entiendo que la 4.0 tiene mejoras sobre la 3.0/3.1 y que la 3.0/3.1 las tiene sobre la 2.0 y que la 2.0 la tiene sobre la 1.0, pero j**der!!, que les habría costado mantener la compatibilidad "hacia atrás"?

Ya me veo que ahora haces algo para la 4.0 y dentro de un par de años (o menos), sacan la 5.0 y todo lo que has hecho ya no "vale pa ná" :S

Saludos.


Esos cambios han sido debidos a cambios profundos en la arquitectura de XNA para hacerlo compatible con PC, XBOX y Windows Phone 7. Cuando tienes algo hecho en 3.1 y no es compatible con 4.0 jode, pero ya te digo yo que los cambios son para mejor, y por experiencia propia pasar algo ya hecho de 3.1 a 4.0 son solo un par de dias y bucear por internet y los foros de creatos.

Un saludo

  • Ollydbg

  • Bahamut

  • vida restante: 100%
  • Registrado: 05 sep 2008
  • Mensajes: 6.259
#9

Escrito 24 febrero 2011 - 23:48

Bueno, aquí el resultado después de depurar mínimamente el código y añadirle alguna opción para interactuar con la demo.

http://www.youtube.com/watch?v=rZf9O9jF8fM

"Sólo" me ha llevado 1 año conseguir hacer este efecto (mirar la fecha del post :) )

Para dentro de otro año quizás ya se mueva el pj y todo X-D X-D X-D

Por cierto, si alguien quiere el código (VB.net 2008 + XNA 3.1), /w me

Saludos.

  • Flunky

  • Odin

  • vida restante: 100%
  • Registrado: 10 nov 2008
  • Mensajes: 1.395
#10

Escrito 25 febrero 2011 - 10:47

Que chulo queda, ¿Dónde se puede ver el código?

Gracias.
Saludos.

  • The_Hans

  • Anima

  • vida restante: 100%
  • Registrado: 27 ene 2004
  • Mensajes: 7.490
#11

Escrito 01 marzo 2011 - 16:33

He mirado el código y por desgracia usa custom shaders, por lo que no es compatible con WP7. ¿Alguna manera de conseguir lo mismo sin shaders? :P

  • Ollydbg

  • Bahamut

  • vida restante: 100%
  • Registrado: 05 sep 2008
  • Mensajes: 6.259
#12

Escrito 01 marzo 2011 - 19:18

Pues ni idea chico.
Yo aún no me he metido con XNA 4.0 y menos aún algo para Windows Phone 7. No sabría que decirte :(

Saludos.

  • The_Hans

  • Anima

  • vida restante: 100%
  • Registrado: 27 ene 2004
  • Mensajes: 7.490
#13

Escrito 02 marzo 2011 - 22:38

Al final he conseguido lo que buscaba (casi idéntico resultado al que ha puesto Ollydbg) 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.

Gracias de todas formas, Ollydbg :wink:

  • The_Hans

  • Anima

  • vida restante: 100%
  • Registrado: 27 ene 2004
  • Mensajes: 7.490
#14

Escrito 04 marzo 2011 - 10:44

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):

Imagen Enviada


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

[code:1]#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 static_listaLuces = new List();
List dinamic_listaLucesActivadas = new List();

RenderTarget2D renderTarget;

#if SHOW_DEBUG_ON
cFondo fondoDebug;
#endif


////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Constructor
///

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Reset
///

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public void Reset()
{
dinamic_listaLucesActivadas.Clear();
for (int i = 0; i < static_listaLuces.Count; i++) static_listaLuces[i].Reset();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// ActivarLuz
///

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Generate
///

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Update
///

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public void Update()
{
fondoNieblaDelantero.Fading = dBaseExtendida.GlobalFog2D;

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

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public void DrawfondoColorDelanteDeTodo()
{
fondoNieblaTrasero.Draw();

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

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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
}
}
}[/code]




luz.cs

[code:1]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;


////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Constructor
///

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Activar
///

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// MainPosition
///

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public Vector3 MainPosition
{
set { mainPosition = value; }
get { return mainPosition; }
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Reset
///

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Generate
///

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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.co...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();
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Update
///

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// DrawfondoColorDetrasDeTodo
///

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public void DrawfondoColorDetrasDeTodo()
{
if (dibujarEsteFrame && Detras) fondoColor.Draw();
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// DrawfondoColorDelanteDeTodo
///

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public void DrawfondoColorDelanteDeTodo()
{
if (dibujarEsteFrame && !Detras) fondoColor.Draw();
}
}
}[/code]



fondoConCustomDraw2DParaLucesDeColores.cs

[code:1]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;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Constructor
///

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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,
};
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// MainPosition
///

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public Vector3 MainPosition
{
set { mainPosition = value; }
get { return mainPosition; }
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// Draw
///

////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////
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.co...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();
}
}
}
}[/code]


Este tema ha sido archivado. Esto significa que no puedes responder en este tema.
publicidad