/// <summary>
/// Método que reproduce un sonido de trueno aleatorio.
/// </summary>
public static void ReproducirTrueno()
{
if (Utiles.iAleatorio() % 2 == 0)
{
SonidoTrueno1.play();
}
else
{
SonidoTrueno2.play();
}
}
public static void Procesar()
{
// si el barco toca la moneda, la muevo de lugar y le doy puntos
if (DetectarColision(Moneda.BoundingBox, Barco.mesh.BoundingBox))
{
Sonidos.Moneda();
Puntos++;
Moneda.Position = new Vector3(Utiles.fAleatorio(-1000, 1000), 0, Utiles.fAleatorio(-1000, 1000));
GuiController.Instance.Logger.log("toco la moneda!\nnueva posicion:" + Moneda.Position);
}
Render();
}
public static void Cargar()
{
// Cargar terreno y textura
terrain = new TgcSimpleTerrain();
string heightmap = GuiController.Instance.ExamplesMediaDir + "Heighmaps\\" + "HeightmapHawaii.jpg";
string textura = Utiles.TexturasDir("IslaTextura.png");
Vector3 PosicionIsla = new Vector3(0, 0, 0);
PosicionIsla.Y = -Oceano.AplicarCPUShader(PosicionIsla).Y - 100;
terrain.AlphaBlendEnable = false;
terrain.loadHeightmap(heightmap, 100, 5f, PosicionIsla);
terrain.loadTexture(textura);
}
/// <summary>
/// Método que maneja las teclas presionadas.
/// </summary>
private static void Teclado()
{
Barco.DerechaIzquierda = 0;
Barco.AceleraFrena = 0;
// Propulsión y freno del Barco
if (GuiController.Instance.D3dInput.keyDown(Microsoft.DirectX.DirectInput.Key.UpArrow))
{
Barco.AceleraFrena = 1;
}
if (GuiController.Instance.D3dInput.keyDown(Microsoft.DirectX.DirectInput.Key.DownArrow))
{
Barco.AceleraFrena = -1;
}
// Timón del Barco
if (GuiController.Instance.D3dInput.keyDown(Microsoft.DirectX.DirectInput.Key.LeftArrow))
{
Barco.DerechaIzquierda = -1;
}
if (GuiController.Instance.D3dInput.keyDown(Microsoft.DirectX.DirectInput.Key.RightArrow))
{
Barco.DerechaIzquierda = 1;
}
// Guarda las texturas a archivo
if (GuiController.Instance.D3dInput.keyDown(Microsoft.DirectX.DirectInput.Key.F12))
{
TextureLoader.Save(Utiles.DebugDir("surf_refraction.png"), ImageFileFormat.Png, Oceano.surf_refraction);
TextureLoader.Save(Utiles.DebugDir("surf_reflection.png"), ImageFileFormat.Png, Oceano.surf_reflection);
TextureLoader.Save(Utiles.DebugDir("PerlinNoiseHeightmap1.png"), ImageFileFormat.Png, Oceano.textPerlinNoise1);
TextureLoader.Save(Utiles.DebugDir("PerlinNoiseHeightmap2.png"), ImageFileFormat.Png, Oceano.textPerlinNoise2);
TextureLoader.Save(Utiles.DebugDir("RenderTarget.png"), ImageFileFormat.Png, Postprocesador.RenderTargetPostprocesado);
}
// Distancia de Camara
if (GuiController.Instance.D3dInput.keyDown(Microsoft.DirectX.DirectInput.Key.Add))
{
float fMultiplicadorDistancia = GuiController.Instance.ElapsedTime * 1000;
GuiController.Instance.ThirdPersonCamera.OffsetForward -= fMultiplicadorDistancia;
}
if (GuiController.Instance.D3dInput.keyDown(Microsoft.DirectX.DirectInput.Key.Subtract))
{
float fMultiplicadorDistancia = GuiController.Instance.ElapsedTime * 1000;
if (GuiController.Instance.ThirdPersonCamera.OffsetForward <= fMultiplicadorDistancia)
{
GuiController.Instance.ThirdPersonCamera.OffsetForward += fMultiplicadorDistancia;
}
}
}
public static void Cargar()
{
SpriteDrawer = new Drawer2D();
AnimatedSprite = new TgcAnimatedSprite(Utiles.TexturasDir("moneda_sprite.png"), new Size(32, 32), 16, 10);
AnimatedSprite.Position = new Vector2(GuiController.Instance.Panel3d.Width - 32 * 2, 0);
Puntos2d = new TgcText2d();
Puntos2d.Text = Puntos.ToString();
Puntos2d.Color = Color.Yellow;
Puntos2d.Align = TgcText2d.TextAlign.RIGHT;
Puntos2d.Position = new Point(GuiController.Instance.Panel3d.Width - 32, 0);
Puntos2d.Size = new Size(30, 20);
Puntos2d.changeFont(new System.Drawing.Font("Sans-serif ", 15, FontStyle.Bold));
}
public static void Cargar()
{
for (int i = 0; i < 50; i++)
{
ParticleEmitter Emisor = new ParticleEmitter(Utiles.TexturasDir("lluvia.png"), Utiles.iAleatorio(50, 100));
float Viento = Utiles.fAleatorio(50, 100);
Emisor.Speed = new Vector3(Viento, -Utiles.fAleatorio(50, 100), Viento);
Emisor.Dispersion = Utiles.iAleatorio(10, 100);
Emisor.MinSizeParticle = Utiles.fAleatorio(5, 10);
Emisor.MaxSizeParticle = Utiles.fAleatorio(10, 30);
Emisor.CreationFrecuency = Utiles.fAleatorio(0.01f, 0.5f);
Emisor.ParticleTimeToLive = Utiles.fAleatorio(5, 10);
Emisor.Distancia = Utiles.fAleatorio(0.5f, 1);
Emisores.Add(Emisor);
}
}
/// <summary>
/// Crea el SkyDome.
/// </summary>
public static void Cargar()
{
Textura = TextureLoader.FromCubeFile(GuiController.Instance.D3dDevice, Utiles.TexturasDir("cubemap-evul.dds"));
VerticesBuffer = new VertexBuffer(typeof(CustomVertex.PositionNormalTextured), NivelDeDetalle * NivelDeDetalle * CustomVertex.PositionNormalTextured.StrideSize, GuiController.Instance.D3dDevice, Usage.WriteOnly, CustomVertex.PositionNormalTextured.Format, Pool.Default);
Vertices = new CustomVertex.PositionNormalTextured[NivelDeDetalle * NivelDeDetalle];
for (int v = 0; v < NivelDeDetalle; v++)
{
for (int u = 0; u < NivelDeDetalle; u++)
{
// Alpha es el desplazamiento horizontal
float al = (float)(-2.0f * Math.PI * ((float)u / (NivelDeDetalle - 1.0f)));
// Theta es el desplazamiento vertical
float th = (float)(0.6f * Math.PI * ((float)v / (NivelDeDetalle - 1.0f)));
// Armo los vertices para el domo
Vertices[v * NivelDeDetalle + u].X = (float)(Math.Sin(th) * Math.Sin(al));
Vertices[v * NivelDeDetalle + u].Y = (float)Math.Cos(th);
Vertices[v * NivelDeDetalle + u].Z = (float)(Math.Sin(th) * Math.Cos(al));
}
}
VerticesBuffer.SetData(Vertices, 0, LockFlags.None);
IndicesBuffer = new IndexBuffer(typeof(int), sizeof(int) * 6 * (NivelDeDetalle - 1) * (NivelDeDetalle - 1), GuiController.Instance.D3dDevice, Usage.WriteOnly, Pool.Default);
int[] Indices = new int[sizeof(int) * 6 * (NivelDeDetalle - 1) * (NivelDeDetalle - 1)];
int i = 0;
for (int v = 0; v < NivelDeDetalle - 1; v++)
{
for (int u = 0; u < NivelDeDetalle - 1; u++)
{
// Triangulo 1 |/
Indices[i++] = v * NivelDeDetalle + u;
Indices[i++] = v * NivelDeDetalle + u + 1;
Indices[i++] = (v + 1) * NivelDeDetalle + u;
// Triangulo 2 /|
Indices[i++] = (v + 1) * NivelDeDetalle + u;
Indices[i++] = v * NivelDeDetalle + u + 1;
Indices[i++] = (v + 1) * NivelDeDetalle + u + 1;
}
}
IndicesBuffer.SetData(Indices, 0, LockFlags.None);
// Carga el Effect para el SkyDome.
Shader = Utiles.CargarShaderConTechnique("skybox.fx");
}
/// <summary>
/// Método que carga un shader con una Technique particular.
/// Si la Technique especificada es null, le asigna la primer Technique valida que encuentre.
/// </summary>
/// <param name="Nombre">Nombre del archivo shader.</param>
/// <param name="Technique">Nombre de la technique.</param>
/// <returns>Effect con el shader cargado.</returns>
public static Effect CargarShaderConTechnique(string Nombre, string Technique)
{
try
{
//using TgcViewer.Utils.Shaders.
Effect shader = TgcShaders.loadEffect(Utiles.ShadersDir(Nombre));
shader.Technique = shader.FindNextValidTechnique(Technique);
GuiController.Instance.Logger.log("Shader '" + Nombre + "' cargado con Technique: '" + shader.GetTechniqueDescription(shader.Technique).Name + "'");
return(shader);
}
catch (Exception ex)
{
GuiController.Instance.Logger.log(ex.Message);
throw new Exception("Fallo la carga del shader", ex);
}
}
/// <summary>
/// Método que carga los sonidos inicialmente.
/// </summary>
public static void Cargar()
{
Mp3Player = GuiController.Instance.Mp3Player;
Mp3Player.FileName = Utiles.SonidosDir("Hans Zimmer - Drink up me hearties yo ho.mp3");
RuidoAmbienteOceano = new TgcStaticSound();
RuidoAmbienteOceano.loadSound(Utiles.SonidosDir("Oceano.wav"));
RuidoAmbienteSubmarino = new TgcStaticSound();
RuidoAmbienteSubmarino.loadSound(Utiles.SonidosDir("Submarino.wav"));
SonidoTrueno1 = new TgcStaticSound();
SonidoTrueno1.loadSound(Utiles.SonidosDir("Trueno01.wav"));
SonidoTrueno2 = new TgcStaticSound();
SonidoTrueno2.loadSound(Utiles.SonidosDir("Trueno02.wav"));
SuperMarioCoin = new TgcStaticSound();
SuperMarioCoin.loadSound(Utiles.SonidosDir("SuperMarioBros - Coin.wav"));
}
public static void Render()
{
if (!ParametrosDeConfiguracion.RenderLluvia)
{
return;
}
Vector3 Posicion = GuiController.Instance.CurrentCamera.getPosition();
Vector3 LookAt = GuiController.Instance.CurrentCamera.getLookAt();
Posicion.Y += Utiles.fAleatorio(50, 100);/* +(LookAt - Posicion).LengthSq() * 100;*/
foreach (var Emisor in Emisores)
{
Posicion.X = LookAt.X + Utiles.fAleatorio(-100, 100);
Posicion.Z = LookAt.Z + Utiles.fAleatorio(-100, 100);
Emisor.Position = Posicion;
Emisor.render();
}
}
/// <summary>
/// Método para cargar los elementos que hacen al juego
/// </summary>
public static void Cargar()
{
// Crear loader
TgcSceneLoader loader = new TgcSceneLoader();
// Cargar mesh
TgcScene Scene = loader.loadSceneFromFile(Utiles.MeshesDir("Moneda\\Moneda-TgcScene.xml"));
Moneda = Scene.Meshes[0];
Moneda.Position = new Vector3(10, 0, 10);
Moneda.AutoTransformEnable = false;
// Como va a estar flotando agrando el bounding box en el eje y
Vector3 PMax = Moneda.BoundingBox.PMax + new Vector3(0, 100f, 0);
Vector3 PMin = Moneda.BoundingBox.PMin + new Vector3(0, -100f, 0);
Moneda.BoundingBox = new TgcBoundingBox(PMax, PMin);
ContadorMonedas.Cargar();
}
/// <summary>
/// Renderizar el SkyDome.
/// </summary>
public static void Render()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
Matrix fvproj = Utiles.ViewMatrix();
// pisa la distancia para d=(0,0,0)
fvproj.M41 = 0;
fvproj.M42 = 0;
fvproj.M43 = 0;
fvproj = fvproj * Utiles.ProjMatrix();
// Cargamos vertices e indices
d3dDevice.SetStreamSource(0, VerticesBuffer, 0, CustomVertex.PositionNormalTextured.StrideSize);
d3dDevice.VertexFormat = CustomVertex.PositionNormalTextured.Format;
d3dDevice.Indices = IndicesBuffer;
// Cargamos parametros en el shader
Shader.SetValue("mViewProj", fvproj);
Shader.SetValue("sun_alfa", ParametrosDeConfiguracion.Sol.PosAlpha);
Shader.SetValue("sun_theta", ParametrosDeConfiguracion.Sol.PosTheta);
Shader.SetValue("sun_shininess", 4 * ParametrosDeConfiguracion.Sol.Shininess);
Shader.SetValue("sun_strength", ParametrosDeConfiguracion.Sol.Strength);
Shader.SetValue("EnvironmentMap", Textura);
Shader.SetValue("noche", ParametrosDeConfiguracion.EsDeNoche);
Shader.SetValue("rayo", Rayo.Activo);
Shader.SetValue("zfar", Radio);
// Aplico el effect
Shader.Begin(FX.None);
Shader.BeginPass(0);
// Dibujo el domo en base a los indicies.
d3dDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, NivelDeDetalle * NivelDeDetalle, 0, 2 * (NivelDeDetalle - 1) * (NivelDeDetalle - 1));
// Fin del effect
Shader.EndPass();
Shader.End();
}
/// <summary>
/// Crear un emisor de particulas
/// </summary>
/// <param name="texturePath">textura a utilizar</param>
/// <param name="particlesCount">cantidad maxima de particlas a generar</param>
public ParticleEmitter(string texturePath, int particlesCount)
{
Device device = GuiController.Instance.D3dDevice;
//valores default
enabled = true;
playing = true;
random = new Random(0);
creationFrecuency = 1.0f;
particleTimeToLive = 5.0f;
minSizeParticle = 0.25f;
maxSizeParticle = 0.5f;
dispersion = 100;
speed = new Vector3(1, 1, 1) * Utiles.fAleatorio(1, 10);
particleVertexArray = new Particle.ParticleVertex[1];
vertexDeclaration = new VertexDeclaration(device, Particle.ParticleVertexElements);
position = new Vector3(0, 0, 0);
this.particlesCount = particlesCount;
this.particles = new Particle[particlesCount];
this.particlesAlive = new ColaDeParticulas(particlesCount);
this.particlesDead = new Stack <Particle>(particlesCount);
//Creo todas las particulas. Inicialmente estan todas muertas.
for (int i = 0; i < particlesCount; i++)
{
this.particles[i] = new Particle();
this.particlesDead.Push(this.particles[i]);
}
//Cargo la textura que tendra cada particula
this.texture = TgcTexture.createTexture(device, texturePath);
Distancia = 1.0f;
}
public static void LoadEmbarcacion(string Embarcacion)
{
// el pato y el submarino quedaron en beta nomás...
// la canoa anda bien
// Crear loader
TgcSceneLoader loader = new TgcSceneLoader();
//Cargar mesh
TgcScene scene = loader.loadSceneFromFile(Utiles.MeshesDir(Embarcacion + "\\" + Embarcacion + "-TgcScene.xml"));
mesh = scene.Meshes[0];
mesh.Position = new Vector3(0, 1, 100);
mesh.AutoTransformEnable = false;
EmbarcacionActual = Embarcacion;
// Calcular dimensiones
Vector3 BoundingBoxSize = mesh.BoundingBox.calculateSize();
LargoBote = Math.Abs(BoundingBoxSize.Z);
AnchoBote = Math.Abs(BoundingBoxSize.X);
AltoBote = Math.Abs(BoundingBoxSize.Y);
}
public static void Cargar()
{
TgcSceneLoader loader = new TgcSceneLoader();
//Cargar mesh
TgcScene scene = loader.loadSceneFromFile(Utiles.MeshesDir("Faro\\Faro-TgcScene.xml"));
MeshFaro = scene.Meshes[0];
MeshFaro.Position = Isla.PosicionCima;
PosicionLuz = Isla.PosicionCima;
PosicionLuz.Y += MeshFaro.BoundingBox.calculateSize().Y;
DireccionLuz = Oceano.AplicarCPUShader(new Vector3(1000, 0, 500)) - PosicionLuz;
Luz = new Light();
Luz.Direction = DireccionLuz;
Luz.AmbientColor = new ColorValue(1f, 0f, 0f, 1f);;
Luz.Diffuse = Color.FromArgb(new ColorValue(2f, 2f, 2f, 1f).ToArgb());
Luz.Ambient = Color.FromArgb(new ColorValue(1f, 1f, 1f, 1f).ToArgb());
Luz.Specular = Color.FromArgb(new ColorValue(1f, 1f, 1f, 1f).ToArgb());
Luz.Attenuation0 = 0.01f;
Luz.Type = LightType.Point;
}
/// <summary>
/// Metodo que carga los valores necesarios para inicializar el Oceano.
/// </summary>
public static void Cargar()
{
Device d3dDevice = GuiController.Instance.D3dDevice;
// Creo la textura de reflexion
surf_reflection = new Texture(d3dDevice, GuiController.Instance.Panel3d.Width, GuiController.Instance.Panel3d.Height, 1, Usage.RenderTarget, Format.A32B32G32R32F, Pool.Default);
// Creo la textura de refraccion
surf_refraction = new Texture(d3dDevice, GuiController.Instance.Panel3d.Width, GuiController.Instance.Panel3d.Height, 1, Usage.RenderTarget, Format.A32B32G32R32F, Pool.Default);
// Cargo la textura de fresnel (relación entre los campos eléctricos transmitido y reflejado) "fresnel_water_sRGB.bmp"
surf_fresnel = TextureLoader.FromFile(d3dDevice, Utiles.TexturasDir("fresnel_water_sRGB.bmp"));
// Carga el shader del movimiento del oceano
PerlinShader = Utiles.CargarShaderConTechnique("perlin.fx");
// Cargar informacion de vertices: (X,Y,Z) + coord textura
_vertices = new CustomVertex.PositionNormalTextured[CANTIDAD_DE_VERTICES];
int i = 0;
for (int x = -RADIO; x <= RADIO; x++)
{
for (int z = -RADIO; z <= RADIO; z++)
{
_vertices[i++] = new CustomVertex.PositionNormalTextured(
new Vector3(x * DISTANCIA_ENTRE_VERTICES, ParametrosDeConfiguracion.Agua.NivelDelMar, z * DISTANCIA_ENTRE_VERTICES),
_normal,
((float)(x + RADIO) / ((float)LARGO - 1)),
((float)(z + RADIO) / ((float)LARGO - 1))
);
}
}
;
// Creamos el VertexBuffer
_vertexBuffer = new VertexBuffer(typeof(CustomVertex.PositionNormalTextured), CANTIDAD_DE_VERTICES, d3dDevice, Usage.Dynamic | Usage.WriteOnly, CustomVertex.PositionNormalTextured.Format, Pool.Default);
// Almacenar información en VertexBuffer
_vertexBuffer.SetData(_vertices, 0, LockFlags.None);
//Creo el quadTree para este terreno
QuadTree.Cargar(_pos.X, _pos.Z, TAMAÑO, GuiController.Instance.D3dDevice);
// creo los indices para el IndexBuffer usando un array de int
// Son por 3 vertices por triangulo y son 2 triangulos
for (int z = 0; z < LARGO - 1; z++)
{
for (int x = 0; x < LARGO - 1; x++)
{
var lista = new List <int>();
//Primer Triangulo
lista.Add(x + z * LARGO);
lista.Add(x + 1 + z * LARGO);
lista.Add(x + LARGO + 1 + z * LARGO);
//Segundo Triangulo
lista.Add(x + LARGO + 1 + z * LARGO);
lista.Add(x + LARGO + z * LARGO);
lista.Add(x + z * LARGO);
//Cargo los indices en los nodos del QuadTree
QuadTree.AgregarIndices(lista);
}
}
;
//LOD I
for (int z = 0; z < LARGO - 1; z = z + 2)
{
for (int x = 0; x < LARGO - 1; x = x + 2)
{
var lista = new List <int>();
//Primer Triangulo
lista.Add(x + z * LARGO);
lista.Add(x + 2 + z * LARGO);
lista.Add(x + 2 * LARGO + 2 + z * LARGO);
//Segundo Triangulo
lista.Add(x + 2 * LARGO + 2 + z * LARGO);
lista.Add(x + 2 * LARGO + z * LARGO);
lista.Add(x + z * LARGO);
//Cargo los indices en los nodos del QuadTree
QuadTree.AgregarLODI(lista);
}
}
;
//LOD II
for (int z = 0; z < LARGO - 1; z = z + 4)
{
for (int x = 0; x < LARGO - 1; x = x + 4)
{
var lista = new List <int>();
//Primer Triangulo
lista.Add(x + z * LARGO);
lista.Add(x + 4 + z * LARGO);
lista.Add(x + 4 * LARGO + 4 + z * LARGO);
//Segundo Triangulo
lista.Add(x + 4 * LARGO + 4 + z * LARGO);
lista.Add(x + 4 * LARGO + z * LARGO);
lista.Add(x + z * LARGO);
//Cargo los indices en los nodos del QuadTree
QuadTree.AgregarLODII(lista);
}
}
;
// Genera los heightmaps entre los que interpola la superficie, se generan para 2,4 y 8 octavas para poder usar
// las diferentes configuraciones cambiando los Modifiers.
// 2 ocatavas (ruido fuerte).
// perlin 1
textPerlinNoise1_2Octavas = PerlinNoise.GetNuevoHeightmap(Oceano.LARGO, Oceano.LARGO, 2, out PerlinNoise1_2Octavas);
textPerlinNoise2_2Octavas = PerlinNoise.GetNuevoHeightmap(Oceano.LARGO, Oceano.LARGO, 2, out PerlinNoise2_2Octavas);
// 4 ocatavas (ruido normal).
textPerlinNoise1_4Octavas = PerlinNoise.GetNuevoHeightmap(Oceano.LARGO, Oceano.LARGO, 4, out PerlinNoise1_4Octavas);
textPerlinNoise2_4Octavas = PerlinNoise.GetNuevoHeightmap(Oceano.LARGO, Oceano.LARGO, 4, out PerlinNoise2_4Octavas);
// 8 octavas (ruido suave).
textPerlinNoise1_8Octavas = PerlinNoise.GetNuevoHeightmap(Oceano.LARGO, Oceano.LARGO, 8, out PerlinNoise1_8Octavas);
textPerlinNoise2_8Octavas = PerlinNoise.GetNuevoHeightmap(Oceano.LARGO, Oceano.LARGO, 8, out PerlinNoise2_8Octavas);
// Carga los valores iniciales de la Matriz de Perlin Noise.
PerlinNoise1 = PerlinNoise1_8Octavas;
PerlinNoise2 = PerlinNoise2_8Octavas;
// Carga los valores iniciales de la textura que se usara como Heightmap y Normalmap para la superficie del oceano.
textPerlinNoise1 = textPerlinNoise1_8Octavas;
textPerlinNoise2 = textPerlinNoise2_8Octavas;
// Peso (alpha) para interpolar, usa el InterpoladorVaiven para ir alterandolo.
interpoladorPerlinNoiseHeightmaps = new InterpoladorVaiven();
interpoladorPerlinNoiseHeightmaps.Min = 0;
interpoladorPerlinNoiseHeightmaps.Max = 1;
interpoladorPerlinNoiseHeightmaps.Speed = 0.5f;
//guardar el stencil inicial
//g_depthstencil = d3dDevice.DepthStencilSurface;
}
/// <summary>
/// Render del oceano y su shader.
/// </summary>
public static void Render()
{
if (!ParametrosDeConfiguracion.RenderOceano)
{
return;
}
Device d3dDevice = GuiController.Instance.D3dDevice;
bool culling = ParametrosDeConfiguracion.VerFrustumCulling;
if (culling)
{
// cargo la camara fps para hacer el culling en base al frustum de esa camara
GuiController.Instance.ThirdPersonCamera.Enable = false;
GuiController.Instance.FpsCamera.Enable = true;
GuiController.Instance.FpsCamera.setCamera(Barco.mesh.Position, Barco.vDireccion * GuiController.Instance.Frustum.FarPlane.D);
GuiController.Instance.CurrentCamera.updateCamera();
GuiController.Instance.CurrentCamera.updateViewMatrix(d3dDevice);
GuiController.Instance.Frustum.updateVolume(d3dDevice.Transform.View, d3dDevice.Transform.Projection);
}
// Especificar formato de triangulos
d3dDevice.VertexFormat = CustomVertex.PositionNormalTextured.Format;
d3dDevice.SetStreamSource(0, _vertexBuffer, 0);
// Almacenar información en IndexBuffer
var listaIndices = QuadTree.IndiceVerticesVisibles();
var cantidadDeIndices = listaIndices.Count;
if (cantidadDeIndices != 0)
{
var indexBuffer = new IndexBuffer(typeof(int), sizeof(int) * cantidadDeIndices, d3dDevice, Usage.Dynamic | Usage.WriteOnly, Pool.Default);
indexBuffer.SetData(listaIndices.ToArray(), 0, LockFlags.None);
d3dDevice.Indices = indexBuffer;
}
if (culling)
{
// vuelvo a cargar la camara en 3ra persona
GuiController.Instance.ThirdPersonCamera.Enable = true;
GuiController.Instance.FpsCamera.Enable = false;
GuiController.Instance.CurrentCamera.updateCamera();
GuiController.Instance.CurrentCamera.updateViewMatrix(d3dDevice);
}
// Cargamos parametros en el shader
// Matrices de transformacion para pasar de world a clip space
PerlinShader.SetValue("world", GuiController.Instance.D3dDevice.Transform.World);
PerlinShader.SetValue("view", GuiController.Instance.D3dDevice.Transform.View);
PerlinShader.SetValue("proj", GuiController.Instance.D3dDevice.Transform.Projection);
// Propiedades del Sol (posicion, shiness, strength)
PerlinShader.SetValue("sun_vec", new Vector4(Sol.Posicion.X, Sol.Posicion.Y, Sol.Posicion.Z, 0.0f));
PerlinShader.SetValue("sun_shininess", 4 * ParametrosDeConfiguracion.Sol.Shininess);
PerlinShader.SetValue("sun_strength", ParametrosDeConfiguracion.Sol.Strength);
// Valores de Enviroment Mapping
PerlinShader.SetValue("reflrefr_offset", ParametrosDeConfiguracion.Agua.ReflRefrOffset);
PerlinShader.SetValue("LODbias", ParametrosDeConfiguracion.p_fLODbias);
Vector3 posCamara = GuiController.Instance.CurrentCamera.getPosition();
PerlinShader.SetValue("view_position", new Vector4(posCamara.X, posCamara.Y, posCamara.Z, 1));
PerlinShader.SetValue("EnvironmentMap", SkyDome.Textura);
PerlinShader.SetValue("FresnelMap", surf_fresnel);
PerlinShader.SetValue("Refractionmap", surf_refraction);
PerlinShader.SetValue("Reflectionmap", surf_reflection);
// Dimensiones del Oceano
PerlinShader.SetValue("radio", RADIO);
PerlinShader.SetValue("largo", LARGO);
PerlinShader.SetValue("dev", DISTANCIA_ENTRE_VERTICES);
// periodo del día, para saber si reflejar el sol o la luna
PerlinShader.SetValue("noche", ParametrosDeConfiguracion.EsDeNoche);
// Caso particular para placas que no tengan texture lookup de
// cualquier textura se usa el formato particular A32B32G32R32F.
if (ParametrosDeConfiguracion.TexturaA32B32G32R32F)
{
textPerlinNoise1 = TextureLoader.FromFile(d3dDevice, Utiles.TexturasDir("PerlinNoiseHeightmap1.png"), 0, 0, 1, 0,
Format.A32B32G32R32F, Pool.Managed, Filter.Point, Filter.Point, Color.Black.ToArgb());
textPerlinNoise2 = TextureLoader.FromFile(d3dDevice, Utiles.TexturasDir("PerlinNoiseHeightmap2.png"), 0, 0, 1, 0,
Format.A32B32G32R32F, Pool.Managed, Filter.Point, Filter.Point, Color.Black.ToArgb());
}
else
{
// Setea las texturas de acuerdo a las octavas seleccionadas en el combo.
switch (ParametrosDeConfiguracion.Agua.Octavas)
{
case 2:
textPerlinNoise1 = textPerlinNoise1_2Octavas;
textPerlinNoise2 = textPerlinNoise2_2Octavas;
PerlinNoise1 = PerlinNoise1_2Octavas;
PerlinNoise2 = PerlinNoise2_2Octavas;
break;
case 4:
textPerlinNoise1 = textPerlinNoise1_4Octavas;
textPerlinNoise2 = textPerlinNoise2_4Octavas;
PerlinNoise1 = PerlinNoise1_4Octavas;
PerlinNoise2 = PerlinNoise2_4Octavas;
break;
case 8:
textPerlinNoise1 = textPerlinNoise1_8Octavas;
textPerlinNoise2 = textPerlinNoise2_8Octavas;
PerlinNoise1 = PerlinNoise1_8Octavas;
PerlinNoise2 = PerlinNoise2_8Octavas;
break;
}
}
// Texturas que representan los heightmaps
PerlinShader.SetValue("perlinNoise1", textPerlinNoise1);
PerlinShader.SetValue("perlinNoise2", textPerlinNoise2);
// Parametros para el movimiento del oceano
Desplazamiento += GuiController.Instance.ElapsedTime;
PerlinShader.SetValue("desplazamiento", Desplazamiento);
PerlinShader.SetValue("maxHeightSuperficial", ParametrosDeConfiguracion.Agua.AlturaSuperficieal);
PerlinShader.SetValue("amplitud", ParametrosDeConfiguracion.Agua.Amplitud);
PerlinShader.SetValue("frecuencia", ParametrosDeConfiguracion.Agua.Frecuencia);
PerlinShader.SetValue("smallvalue", ParametrosDeConfiguracion.Agua.DistanciaEntreNormales);
// Niebla
PerlinShader.SetValue("FogActiva", ParametrosDeConfiguracion.Niebla);
ColorValue fogcolor = Utiles.CamaraSumergida ? ColorValue.FromColor(ParametrosDeConfiguracion.Agua.Color) : ColorValue.FromColor(Color.DarkGray);
PerlinShader.SetValue("FogColor", fogcolor);
PerlinShader.SetValue("FogStart", Niebla.START);
PerlinShader.SetValue("FogEnd", Niebla.END);
// Colorear el oceano bajo la moneda
Vector4 moneda_pos = new Vector4(Juego.Moneda.Position.X, Juego.Moneda.Position.Y, Juego.Moneda.Position.Z, 1);
PerlinShader.SetValue("moneda_pos", moneda_pos);
// Posicion de la isla para atenuacion de las olas
PerlinShader.SetValue("isla_pos", new Vector4(Isla.Posicion.X, Isla.Posicion.Y, Isla.Posicion.Z, 1));
// Parametro de animacion del movimiento superficial
// para interpolar entre los dos heightmaps de perlin noise
interpoladorPerlinNoiseHeightmaps.update();
PerlinShader.SetValue("alpha", interpoladorPerlinNoiseHeightmaps.Current);
// Aplico el effect
if (ParametrosDeConfiguracion.Shader)
{
PerlinShader.Begin(FX.None);
PerlinShader.BeginPass(0);
}
// Dibuja la superficie
d3dDevice.DrawIndexedPrimitives(PrimitiveType.TriangleList, 0, 0, CANTIDAD_DE_VERTICES, 0, cantidadDeIndices / 3);
// Fin del effect
if (ParametrosDeConfiguracion.Shader)
{
PerlinShader.EndPass();
PerlinShader.End();
}
}
