hoper journal

#light

#I @"C:\Program Files\XNA\v2.0\References\Windows\x86"

#r "Microsoft.Xna.Framework.dll"
#r "Microsoft.Xna.Framework.Game.dll"

open Microsoft.Xna.Framework
open Microsoft.Xna.Framework.Graphics
open System

type XNAGame = class
  inherit Game as base

  val mutable graphics : GraphicsDeviceManager

  new() as this =
      {
          graphics = null
      }
      then
          this.graphics <- new GraphicsDeviceManager(this)

  override this.Draw(gameTime) =
      let gd = this.graphics.GraphicsDevice
      gd.Clear(Color.CornflowerBlue)
  end

let Main() =
  let game = new XNAGame()
  game.Run()

[<STAThread>]
do Main()

@if "%_echo%"=="" echo off
setlocal

..\..\..\bin\fsc.exe xna.fs
if ERRORLEVEL 1 goto Exit

:Exit
pause
xna.exe
endlocal

exit /b %ERRORLEVEL%

//Estas variables representan las matrices de posición de nuestro objeto
//la matriz de nuestra camara, y nuestra proyección
float4x4 World;
float4x4 View;
float4x4 Projection;


//Esta estructura indica que es lo que va a tomar el shader
//En este caso solo tomara la posición del vértice, podemos agregar
//las coordenadas de textura, normales, colores, etc.
struct VertexShaderInput
{
   float4 Position : POSITION0;
};

//Esto es muy parecido a la estructura de entrada, pero aquí­ especificamos
//que queremos que devuelva nuestro método
struct VertexShaderOutput
{
   float4 Position : POSITION0;
};

//Esta función es nuestro vertex shader
VertexShaderOutput VertexShaderFunction(VertexShaderInput input)
{
   VertexShaderOutput output;
  
 //Sólo aplicaremos una sencilla transormación
   float4 worldPosition = mul(input.Position, World);
   float4 viewPosition = mul(worldPosition, View);
   output.Position = mul(viewPosition, Projection);

   return output;
}

//Esta función es nuestro pixel shader
float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
 //Aquí­ especificamos que queremos que para todo pí­xel
       //que se dibuje lo pinte de color rojo :)
 //podemos por ejemplo regresar el valor de una textura respecto
       //a la coordenada actual
   return float4( 1, 0, 0, 1);
}

//Aqui especificamos nuestras técnicas
//un archivo fx puede tener varias técnicas
technique Technique1
{
 //Para cada pasada especificamos que funciones vamos a llamar
 //y ademas debemos de decirle bajo que perfil se compilarán
   pass Pass1
   {
       VertexShader = compile vs_1_1 VertexShaderFunction();
       PixelShader = compile ps_1_1 PixelShaderFunction();
   }
} 

Model _model;
Effect _effect;

        protected override void LoadContent()
       {
           // Create a new SpriteBatch, which can be used to draw textures.
           spriteBatch = new SpriteBatch(GraphicsDevice);

           _model = Content.Load<Model>("model");
           _effect = Content.Load<Effect>("Effect1");

           ///Esto va a quitarle el efecto actual al modelo y establecera el que
           ///le estamos asignando
           foreach (ModelMesh mesh in _model.Meshes)
               foreach (ModelMeshPart part in mesh.MeshParts)
                   part.Effect = _effect;

           // TODO: use this.Content to load your game content here
       }
       protected override void Draw(GameTime gameTime)
       {
           graphics.GraphicsDevice.Clear(Color.CornflowerBlue);
          
           float aspectRatio = graphics.GraphicsDevice.Viewport.Width /
graphics.GraphicsDevice.Viewport.Height;


           //Definimos la tecnica
           _effect.CurrentTechnique = _effect.Techniques["Technique1"];

           _effect.Parameters["World"].SetValue
(Matrix.CreateWorld(Vector3.Zero, Vector3.Forward, Vector3.Up));
           _effect.Parameters["View"].SetValue
(Matrix.CreateLookAt(new Vector3(0.0f, 5.0f, -10.0f), Vector3.Zero, Vector3.Up));
           _effect.Parameters["Projection"].SetValue
(Matrix.CreatePerspectiveFieldOfView(MathHelper.ToRadians(45.0f),
                                        aspectRatio, 1.0f, 10000.0f));
          
           //Actualizamos el shader
           _effect.CommitChanges();

           foreach (ModelMesh mesh in _model.Meshes)
               foreach (Effect effect in mesh.Effects)
                   mesh.Draw();


           base.Draw(gameTime);
       }