#region Using directives
  using System;
  using System.Collections.Generic;
  using System.Text;
  using XnaGraphicEngine.Graphics;
  using XnaGraphicEngine.Helpers;
  using XnaGraphicEngine.Game;
  using Microsoft.Xna.Framework.Graphics;
  using Texture = XnaGraphicEngine.Graphics.Texture;
  using Model = XnaGraphicEngine.Graphics.Model;
  using XnaModel = Microsoft.Xna.Framework.Graphics.Model;
  using Microsoft.Xna.Framework;
  using System.IO;
  using Microsoft.Xna.Framework.Input;
  #endregion
  
  namespace XnaGraphicEngine.Shaders
  {
  	class SimpleShader
          {
                  #region Variables
                  Effect effect = null;
                  #endregion
  
                  #region Constructor
                  public SimpleShader()
                  {
                          effect = BaseGame.Content.Load<Effect>(
                                  Path.Combine(Directories.ContentDirectory, "SimpleShader"));
                  } // SimpleShader()
                  #endregion
  
                  #region Render mesh
                  public void RenderModel(XnaModel someModel, Texture texture)
                  {
                          BaseGame.WorldMatrix =
                                  Matrix.CreateScale(0.25f, 0.25f, 0.25f);
  
                          effect.Parameters["worldViewProj"].SetValue(
                                  BaseGame.WorldMatrix *
                                  BaseGame.ViewMatrix *
                                  BaseGame.ProjectionMatrix);
                          effect.Parameters["world"].SetValue(
                                  BaseGame.WorldMatrix);
                          effect.Parameters["viewInverse"].SetValue(
                                  BaseGame.InverseViewMatrix);
                          effect.Parameters["lightDir"].SetValue(
                                  BaseGame.LightDirection);
                          effect.Parameters["diffuseTexture"].SetValue(
                                  texture.XnaTexture);
  
                          effect.Parameters["ambientColor"].SetValue(
                                  Color.Blue.ToVector4());
                          effect.Parameters["diffuseColor"].SetValue(
                                  Color.Orange.ToVector4());
                          effect.Parameters["specularColor"].SetValue(
                                  Color.Orchid.ToVector4());
  
                          // We use the VertexPositionNormalTexture vertex format in SimpleShader.fx
                          BaseGame.Device.VertexDeclaration =
                                  new VertexDeclaration(BaseGame.Device,
                                  VertexPositionNormalTexture.VertexElements);
                          //BaseGame.Device.RenderState.FillMode = FillMode.WireFrame;
  
                          if (Input.Keyboard.IsKeyDown(Keys.Space))
                                  effect.CurrentTechnique = effect.Techniques["DiffusePerPixel"];
                          else
                                  effect.CurrentTechnique = effect.Techniques["SpecularPerPixel"];
  
                          effect.Begin();
                          foreach (EffectPass pass in effect.CurrentTechnique.Passes)
                          {
                                  pass.Begin();
                                  
                                  // Render all meshes
                                  foreach (ModelMesh mesh in someModel.Meshes)
                                  {
                                          // Render all mesh parts
                                          foreach (ModelMeshPart part in mesh.MeshParts)
                                          {
                                                  // Render data our own way
                                                  BaseGame.Device.Vertices[0].SetSource(
                                                          mesh.VertexBuffer, part.StreamOffset, part.VertexStride);
                                                  BaseGame.Device.Indices = mesh.IndexBuffer;
  
                                                  // And render
                                                  BaseGame.Device.DrawIndexedPrimitives(
                                                          PrimitiveType.TriangleList,
                                                          part.BaseVertex, 0, part.NumVertices,
                                                          part.StartIndex, part.PrimitiveCount);
                                          } // foreach
                                  } // foreach
  
                                  pass.End();
                          } // for
                          effect.End();
                  } // RenderMesh(someMesh, texture)
                  #endregion
  
                  #region Unit Testing
  if DEBUG
                  public static void TestSimpleShader()
                  {
                          SimpleShader shader = null;
                          Model testModel = null;
                          Texture testTexture = null;
  
                          TestGame.Start("Test SimpleShader.fx",
                                  delegate
                                  {
                                          shader = new SimpleShader();
                                          testModel = new Model("Apple");
                                          testTexture = new Texture("Marble");
                                  },
                                  delegate
                                  {
                                          // Render model
                                          shader.RenderModel(testModel.XnaModel, testTexture);
                                  });
                  } // TestSimpleShader()
  
                  public static void TestNormalMappingShader()
                  {
                          Model testModel = null;
                          Material testMaterial = null;
  
                          TestGame.Start("TestNormalMappingShader",
                                  delegate
                                  {
                                          testModel = new Model("apple");
                                          testMaterial = new Material(
                                                  Material.DefaultAmbientColor,
                                                  Material.DefaultDiffuseColor,
                                                  Material.DefaultSpecularColor,
                                                  "Marble",
                                                  "MarbleNormal", "", "");
                                  },
                                  delegate
                                  {
                                          // Render model
                                          BaseGame.WorldMatrix = Matrix.CreateScale(0.25f, 0.25f, 0.25f);
                                          BaseGame.Device.VertexDeclaration = TangentVertex.VertexDeclaration;
  
                                          ShaderEffect.normalMapping.Render(testMaterial, "Specular20",
                                                  delegate
                                                  {
                                                          // Render all meshes
                                                          foreach (ModelMesh mesh in testModel.XnaModel.Meshes)
                                                          {
                                                                  // Render all mesh parts
                                                                  foreach (ModelMeshPart part in mesh.MeshParts)
                                                                  {
                                                                          // Render data our own way
                                                                          BaseGame.Device.Vertices[0].SetSource(
                                                                                  mesh.VertexBuffer, part.StreamOffset, part.VertexStride);
                                                                          BaseGame.Device.Indices = mesh.IndexBuffer;
  
                                                                          // And render
                                                                          BaseGame.Device.DrawIndexedPrimitives(
                                                                                  PrimitiveType.TriangleList,
                                                                                  part.BaseVertex, 0, part.NumVertices,
                                                                                  part.StartIndex, part.PrimitiveCount);
                                                                  } // foreach
                                                          } // foreach
                                                  });
                                  });
                  } // TestNormalMappingShader()
  
                  public static void TestAsteroidModel()
                  {
                          Model testModel = null;
  
                          TestGame.Start("TestNormalMappingShader",
                                  delegate
                                  {
                                          testModel = new Model("asteroid4");
                                  },
                                  delegate
                                  {
                                          // Render model
                                          testModel.Render(Matrix.CreateScale(10.25f, 10.25f, 10.25f));
                                  });
                  } // TestAsteroidModel()
  endif
                  #endregion
          } // class SimpleShader
  } // namespace XnaGraphicEngine.Shaders