using System;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.WindowsMobile.DirectX;
using Microsoft.WindowsMobile.DirectX.Direct3D;

namespace Microsoft.Samples.MD3DM
{
	// The main class for this sample
	public class CreateDevice : Form
	{
		// The global variables for this project
		Device device = null;

		// CreateDevice here

		//InitializeGraphics here

		//Render here

		//OnPaint here

		// OnPaintBackground here

		// OnKeyPress here

		// Main here

}
}

	public CreateDevice()
	{
		// Set the caption
		this.Text = "Hello World";
		this.MinimizeBox = false;
}

public bool InitializeGraphics()
	{
		try
		{
			// Set up the D3D parameters
			PresentParameters presentParams = new
PresentParameters();

			// Causes the display to appear in a window rather than
			// full screen
			presentParams.Windowed = true;

			// When a new frame is swapped to the front buffer,
			// the old frame will be discarded
			presentParams.SwapEffect = SwapEffect.Discard;

			// The first parameter of 0 indicates that the Device
object
			// should use the system's physical adapter. The second
parameter 
			// identifies the device type. When working with D3DM,
the only 
			// supported device type is the default. The third
parameter is a 
			// reference to the current form which will be doing
the 
			// rendering.The forth parameter, CreateFlags, allows
you to set 
			// various options for the device. The final parameter,

			// presentParams, contains the details about how the
image will 
			// be displayed in the render area, what buffers it
will use, and 
			// the formats it will have. 
			device = new Device(0, DeviceType.Default, this,
				CreateFlags.None, presentParams);
	}
		catch (DirectXException)
		{
			return false;
	}
		return true;
}

private void Render()
{
		if (device != null)
		{
			//Clear the back buffer to a blue color 
			device.Clear(ClearFlags.Target, Color.Blue,
					1.0f, 0);
			//Begin the scene
			device.BeginScene();

			// Rendering of the scene objects can happen here

			//End the scene
			device.EndScene();
			device.Present();
	}
}
	

protected override void OnPaint(PaintEventArgs e)
	{
		// Render on painting
		this.Render();

		// Render again
		this.Invalidate();
}

	protected override void OnPaintBackground(PaintEventArgs e)
	{
		// Do nothing to ensure that the rendering area is not
overdrawn
}

	protected override void OnKeyPress(KeyPressEventArgs e)
	{
		// Esc was pressed
		if ((int)(byte)e.KeyChar == (int)Keys.Escape)
		this.Close();
}

	static void Main()
	{
		CreateDevice frm = new CreateDevice();

		// Initialize Direct3D
		if (!frm.InitializeGraphics())
		{
			MessageBox.Show("Could not initialize Direct3D. " +
				"This tutorial will exit.");
			return;
	}

		Application.Run(frm);
}

VertexBuffer vertexBuffer = null;
PresentParameters presentParams = new PresentParameters();

		this.Text = "Spinning Tringle";

presentParams.Windowed = true;
presentParams.SwapEffect = SwapEffect.Discard;
device = new Device(0, DeviceType.Default, this,
					CreateFlags.None, presentParams);
device.DeviceReset += new EventHandler(this.OnResetDevice);
this.OnCreateDevice(device, null);
this.OnResetDevice(device, null);

	void OnCreateDevice(object sender, EventArgs e)
	{
		Pool vertexBufferPool;
		Caps caps;
		Device dev = (Device)sender;
		// Get the device capabilities
		caps = dev.DeviceCaps;

		if (caps.SurfaceCaps.SupportsVidVertexBuffer)
			vertexBufferPool = Pool.VideoMemory;
		else
			vertexBufferPool = Pool.SystemMemory;

		// Now create the VertexBuffer
		vertexBuffer = new VertexBuffer(
			typeof(CustomVertex.PositionColored), 3, dev, 0,
			CustomVertex.PositionColored.Format, vertexBufferPool);
		vertexBuffer.Created += new EventHandler(
			this.OnCreateVertexBuffer);
		this.OnCreateVertexBuffer(vertexBuffer, null);
}

	void OnResetDevice(object sender, EventArgs e)
	{
		Device dev = (Device)sender;
		// Turn off culling, so you see the front and back of the
triangle
		dev.RenderState.CullMode = Cull.None;
		// Turn off D3D lighting because you are providing your own
vertex
		// colors
		dev.RenderState.Lighting = false;
}

	void OnCreateVertexBuffer(object sender, EventArgs e)
	{
		VertexBuffer vb = (VertexBuffer)sender;
		CustomVertex.PositionColored[] verts =
			 (CustomVertex.PositionColored[])vb.Lock(0, 0);
		verts[0].X = -1.0f;
		verts[0].Y = -1.0f;
		verts[0].Z = 0.0f;
		verts[0].Color =
System.Drawing.Color.DarkGoldenrod.ToArgb();

		verts[1].X = 1.0f;
		verts[1].Y = -1.0f;
		verts[1].Z = 0.0f;
		verts[1].Color =
System.Drawing.Color.MediumOrchid.ToArgb();

		verts[2].X = 0.0f;
		verts[2].Y = 1.0f;
		verts[2].Z = 0.0f;
		verts[2].Color = System.Drawing.Color.Cornsilk.ToArgb();
		vb.Unlock();
}

device.SetStreamSource(0, vertexBuffer, 0);
device.DrawPrimitives(PrimitiveType.TriangleList, 0, 1);

private void SetupMatrices()
	 {
		// For the world matrix, you will rotate the object about
		// the y-axis. Set up the rotation matrix to generate 1
full 
		// rotation (2*PI radians) every 1000 ms. To avoid the loss
of
		// precision inherent in very high floating point numbers,
the
		// system time is modulated by the rotation period before
		// conversion to a radian angle.
		int iTime = Environment.TickCount % 1000;
		float fAngle = iTime * (2.0f * (float)Math.PI) / 1000.0f;
		device.Transform.World = Matrix.RotationY(fAngle);

		// Set up the view matrix. A view matrix can be defined
given
		// an eye point, a point to look at, and a direction for
which
		// way is up. In this code, you set the eye five units back
along the
		// z-axis and up three units, look at the origin, and
define
		// "up" to be in the y-direction.
		device.Transform.View = Matrix.LookAtLH(
			new Vector3(0.0f, 3.0f, -5.0f),
			new Vector3(0.0f, 0.0f, 0.0f),
			new Vector3(0.0f, 1.0f, 0.0f));

		// For the projection matrix, you set up a perspective
transform
		// (which transforms geometry from three-dimensional view
space to 
		// two-dimensional viewport
		// space, with a perspective divide that makes objects
smaller in
		// the distance). To build a perpsective transform, you
need the
		// field of view (1/4 pi is common),
		// the aspect ratio, and the near and far clipping planes
		// (which define at what distances geometry should be no
longer
		// be rendered).
		device.Transform.Projection =
			Matrix.PerspectiveFovLH((float)Math.PI / 4,
			1.0f, 1.0f, 100.0f);
}

SetupMatrices();

using System;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.WindowsMobile.DirectX;
using Microsoft.WindowsMobile.DirectX.Direct3D;
using System.Reflection;

namespace Microsoft.Samples.MD3DM
{
	public class Meshes : Form
	{
		// The D3D rendering device
		Device device = null;

		// The mesh object in the system
		Mesh mesh = null;

		// Materials for the mesh
		Material[] meshMaterials;

		// Textures for the mesh
		Texture[] meshTextures;

		// The display parameters for drawing a D3D window
		PresentParameters presentParams = new PresentParameters();

		//InitializeGraphics here

//Add OnDeviceReset

//SetupMatrices here

//Render here

//OnPaint here

//OnPaintBackGround here

//OnKeyPress here

//OnResize here

//Main here
}
}

bool InitializeGraphics()
	 {
		try
		{
			// Draw the graphics inside a standard window
			presentParams.Windowed = true;

			// Discard the current frame when drawing a new one
			presentParams.SwapEffect = SwapEffect.Discard;

			// Create a 16-bit depth buffer 
			presentParams.EnableAutoDepthStencil = true;
			presentParams.AutoDepthStencilFormat = DepthFormat.D16;

			// Create the D3D device
			device = new Device(0, DeviceType.Default, this,
				CreateFlags.None, presentParams);
			device.DeviceReset += new System.EventHandler(
				this.OnResetDevice);
			this.OnResetDevice(device, null);
	}
		catch (Exception)
		{
			return false;
	}

		return true;
}

void OnResetDevice(object sender, EventArgs e)
	{
		string[] textureFilenames = null;

		Device dev = (Device)sender;

		// Turn on the zbuffer
		dev.RenderState.ZBufferEnable = true;

		// Turn on ambient lighting 
		dev.RenderState.Ambient = System.Drawing.Color.White;

		// Turn on perspective correction for textures.
		// This provides a more accurate visual at the cost
		// of a small performance overhead
		dev.RenderState.TexturePerspective = true;

		// Load the mesh from the specified file.
		//Note Project1 refers to the defalut namespace
		mesh = MeshLoader.LoadMesh(device,
		 
Assembly.GetExecutingAssembly().GetManifestResourceStream(
			"Lab3.Tiger.md3dm"), MeshFlags.SystemMemory,
			out meshMaterials, out textureFilenames);


		// Extract the material properties and texture names
		meshTextures = new Texture[meshMaterials.Length];
		for (int i = 0; i < meshMaterials.Length; i++)
		{

			// Set the ambient color for the material
			// (D3DX does not do this)
			meshMaterials[i].Ambient = meshMaterials[i].Diffuse;

			// Create the texture
			meshTextures[i] = TextureLoader.FromStream(dev,
				 
Assembly.GetExecutingAssembly().GetManifestResourceStream(
					"Lab3." + textureFilenames[i]));
}
}

void SetupMatrices()
	{
		// For the world matrix, you will just leave it as the
identity
		device.Transform.World =
			Matrix.RotationY(Environment.TickCount / 1000.0f);

		// Set up the view matrix. A view matrix can be defined
given
		// an eye point, a point to look at, and a direction for
which
		// way is up. In this code, you set the eye five units back
along the
		// z-axis and up three units, look at the origin, and
define
		// "up" to be in the y-direction.
		device.Transform.View = Matrix.LookAtLH(
			new Vector3(0.0f, 2.0f, -3.0f),
			new Vector3(0.0f, 0.0f, 0.0f),
			new Vector3(0.0f, 1.0f, 0.0f));

		// For the projection matrix, you set up a perspective
		// transform (which transforms geometry from
three-dimensional view 
		// space to two-dimensional
		// viewport space, with a perspective divide that makes
objects 
		// smaller in the distance). To build a perpsective
transform,
		// you need the field of view (1/4 pi is common), the
aspect
		// ratio, and the near and far clipping planes (which
define at
		// what distances geometry should be no longer be
rendered).
		device.Transform.Projection =
			Matrix.PerspectiveFovLH((float)(Math.PI / 4), 1.0f,
1.0f,
			100.0f);
}

private void Render()
	 {
		if (device == null)
			return;

		//Clear the back buffer to a blue color 
		device.Clear(ClearFlags.Target | ClearFlags.ZBuffer,
			System.Drawing.Color.Blue, 1.0f, 0);
		//Begin the scene
		device.BeginScene();
		// Set up the world, view, and projection matrices
		SetupMatrices();

		// Meshes are divided into subsets; one for each material.
		// Render them in a loop
		for (int i = 0; i < meshMaterials.Length; i++)
		{
			// Set the material and texture for this subset
			device.Material = meshMaterials[i];
			device.SetTexture(0, meshTextures[i]);

			// Draw the mesh subset
			mesh.DrawSubset(i);
	}

		//End the scene
		device.EndScene();
		device.Present();
}

	protected override void
OnPaint(System.Windows.Forms.PaintEventArgs e)
	{
		// Render the mesh to the screen
		Render();

		// Invalidating the window will cause it to be redrawn in
		// the future
		Invalidate();
}

	protected override void OnPaintBackground(
		System.Windows.Forms.PaintEventArgs e)
	{
		// Doing nothing ensures the background will never overdraw
		// the previous rendering
}

	protected override void OnKeyPress(KeyPressEventArgs e)
	{
		// If ESC was pressed, then shut down
		if ((int)e.KeyChar == (int) Keys.Escape)
			this.Close();
}

	protected override void OnResize(EventArgs e)
	{
		base.OnResize(e);
}

static void Main()
	{
		Meshes meshForm = new Meshes();

		// Initialize Direct3D
		if (!meshForm.InitializeGraphics())
		{
			MessageBox.Show("Could not initialize Direct3D. " +
				"This tutorial will exit.");
			return;
	}

		// Run the form
		try
		{
			Application.Run(meshForm);
	}
		catch (Exception e)
		{
			MessageBox.Show("An error occured and this sample needs
" +
				" to  close:" + e.Message);
	}
}

using System;
using Microsoft.WindowsMobile.DirectX;
using Microsoft.WindowsMobile.DirectX.Direct3D;

namespace SpriteLab
{
	public class TileSet
	{
		private Texture texture;
		//Returns the sprite texture
		public Texture Texture
		{
			get
			{
				return texture;
		}
	}
		private int xOrigin;
		//Returns the x starting location
		public int XOrigin
		{
			get
			{
				return xOrigin;
		}
	}
		private int yOrigin;
		//Returns the y starting location
		public int YOrigin
		{
			get
			{
				return yOrigin;
		}
	}
		private int numberFrameRows;
		//Returns the number of frames in a row
		public int NumberFrameRows
		{
			get
			{
				return numberFrameRows;
		}
	}
		private int numberFrameColumns;
		//Returns the number of frames in a column
		public int NumberFrameColumns
		{
			get
			{
				return numberFrameColumns;
		}
	}
		private int xExtent;
		//Returns the x coordinate for the center of the sprite 
		public int ExtentX
		{
			get
			{
				return xExtent;
		}
	}

		private int yExtent;
		//Returns the y coordinate for the center of the sprite 
		public int ExtentY
		{
			get
			{
				return yExtent;
		}
	}

		//Class constructor
		public TileSet(Texture tex, int StartX, int StartY, int
RowCount, int ColumnCount, int xWidth, int yHeight)
		{
			xOrigin = StartX;
			yOrigin = StartY;
			xExtent = xWidth;
			yExtent = yHeight;
			numberFrameRows = RowCount;
			numberFrameColumns = ColumnCount;
			texture = tex;
	}
}
}

using System;
using System.Drawing;
using System.Windows.Forms;
using Microsoft.WindowsMobile.DirectX;
using Microsoft.WindowsMobile.DirectX.Direct3D;
using System.Reflection;

namespace SpriteLab
{
	// The main class for this sample
	public class CreateDevice : Form
	{
		// Global variables for this project
		Device device = null;   //MD3DM Device
		Texture texture = null; //Sprite bmp
		Rectangle tilePosition; //Location of tile
		TileSet tileSet = null; //Local TileSet
		Sprite sprite; 	//Sprite Varible 
		Int16 countX = 0;  //Count to Track Columes of Tiles
		Int16 countY = 0;  //Count to Track Rows of Tiles
		Vector3 spritePosition = new Vector3(50, 50, 0); //Start
Location of Sprite
		Vector3 spriteCenter = new Vector3(0, 0, 0);  //Sprite
Center, 0,0,0 
		Vector2 spriteVelocity = new Vector2(1, 1); // x,y
velocity
  float scale = 1; 		//Configure Scale for screen size

  //Implementation here

}
}

public CreateDevice()
		{
			// Set the caption
			this.Text = "Sprite Sample";
			this.MinimizeBox = false;
// Add Key Event Handler here
	}

public bool InitializeGraphics()
		{
			try
			{
				// Set up the D3D parameters
				PresentParameters presentParams = new
PresentParameters();

				// Causes the display to appear in a window rather
than
				// full screen
				presentParams.Windowed = true;

				// When a new frame is swapped to the front buffer,
				// the old frame will be discarded
				presentParams.SwapEffect = SwapEffect.Discard;

			// The first parameter of 0 indicates that the Device
object
			// should use the system's physical adapter. The second
parameter 
			// identifies the device type. When working with D3DM,
the only 
			// supported device type is the default. The third
parameter is a 
			// reference to the current form which will be doing
the 
			// rendering.The forth parameter, CreateFlags, allows
you to set 
			// various options for the device. The final parameter,

			// presentParams, contains the details about how the
image will 
			// be displayed in the render area, what buffers it
will use, and 
			// the formats it will have. 
		device = new Device(0, DeviceType.Default, this,
CreateFlags.None, presentParams);
				device.DeviceReset += new EventHandler(
					this.OnResetDevice);
				this.OnResetDevice(device, null);
		}
			catch (DirectXException)
			{
				return false;
		}
			return true;
	}

void OnResetDevice(object sender, EventArgs e)
		{
			Device dev = (Device)sender;
			//Create sprite object on device
			sprite = new Sprite(dev);
			//Get the donuts resource out of the assembly and
assign to
			//texture
			//Default parameters for TextureLoader.FromStream 
//(device, stream,D3DX.Default, D3DX.Default, D3DX.Default, 
// D3DX.Default, Usage.None, Format.Unknown,
// Pool.VideoMemory,(Filter)D3DX.Default, (Filter)D3DX.Default, 0)
			//Load texture from the resource, and set the color
black as the
			//alpha blended color
			texture = TextureLoader.FromStream(dev,
Assembly.GetExecutingAssembly()
.GetManifestResourceStream("Lab4.donuts.bmp"), 
D3DX.Default, D3DX.Default, D3DX.Default, D3DX.Default, 
Usage.None, Format.Unknown, Pool.VideoMemory, (Filter)D3DX.Default,
(Filter)D3DX.Default, Color.Black.ToArgb());
			//Configure TileSet to the size of tile in bmp
			tileSet = new TileSet(texture, 0, 0, 6, 5, 32, 32);
			//Set tilePosition including the offset to the center
of the 
			//sprite
			tilePosition = new Rectangle(tileSet.XOrigin, 
tileSet.YOrigin, tileSet.ExtentX * 2, tileSet.ExtentY * 2);

			//Add a call to Calcualte Scale here
	}

private void Render()
		{

			//Clear the back buffer to a blue color 
			device.Clear(ClearFlags.Target,
System.Drawing.Color.BlueViolet,
				1.0f, 0);

			//Begin the scene
			device.BeginScene();

			sprite.Begin(SpriteFlags.AlphaBlend);

//Add transform here 

		
			//Draw a sprite at the current position 
			sprite.Draw(tileSet.Texture, tilePosition, 
spriteCenter, spritePosition, Color.White.ToArgb());
			sprite.End();


			//End the scene
			device.EndScene();
			device.Present();

			//rotateSprite code here
		
			//moveSprite code here
		 
}

// Called to repaint the window
		protected override void OnPaint(PaintEventArgs e)
		{
			// Render on painting
			this.Render();

			// Render again
			this.Invalidate();
	}

		// Called to repaint the window's background
		protected override void OnPaintBackground(PaintEventArgs e)
		{
			// Do nothing to ensure that the rendering area is not
overdrawn
	}


		static void Main()
		{
			CreateDevice frm = new CreateDevice();

			// Initialize Direct3D
			if (!frm.InitializeGraphics())
			{
				MessageBox.Show("Could not initialize Direct3D. " +
					"This tutorial will exit.");
				return;
		}

			Application.Run(frm);
	}

 private void rotateSprite()
		{
			//Change the count to move to the next sprite tile
			if (++countX > 4)
			{
				countX = 0;
				if (++countY > 5)
				{
					countY = 0;
			}
		}
			//Set the coordinates for the current tile
			tilePosition.X = tileSet.XOrigin + (countX *
tileSet.ExtentX * 2);
			tilePosition.Y = tileSet.YOrigin + (countY *
tileSet.ExtentY * 2);
	}

rotateSprite();

		private void moveSprite()
		{
		
			//Add collision logic here

			//Advance sprite by adding to its position the velocity
		 
			spritePosition.X += spriteVelocity.X;
			spritePosition.Y += spriteVelocity.Y;

//Add calculate sprite center here
		
	}

moveSprite();

private void CreateDevice_KeyDown(object sender, KeyEventArgs e)
		{
			//Use rocker to modify the velocity 
			if ((e.KeyCode == System.Windows.Forms.Keys.Up))
			{
				// Rocker Up
				// Up
				spriteVelocity.Y -= 1;
		}
			if ((e.KeyCode == System.Windows.Forms.Keys.Down))
			{
				// Rocker Down
				// Down
				spriteVelocity.Y += 1;

		}
			if ((e.KeyCode == System.Windows.Forms.Keys.Left))
			{
				// Left
				spriteVelocity.X -= 1;
		}
			if ((e.KeyCode == System.Windows.Forms.Keys.Right))
			{
				// Right
				spriteVelocity.X += 1 + 1;

		}

  }

this.KeyDown += new
System.Windows.Forms.KeyEventHandler(this.CreateDevice_KeyDown);

		private float calculateScale()
		{
			//Donunts.bmp is drawn for a VGA resolution. If the
device is not
			//VGA resolution, provide a scale to modify the image.
			float vgaWidth = 480;

			return this.Width / vgaWidth;
	}

scale = calculateScale();

			spriteCenter.X = spritePosition.X + tileSet.ExtentX;
			spriteCenter.Y = spritePosition.Y + tileSet.ExtentY;

sprite.Transform = Matrix.Translation(spriteCenter) *
Matrix.Scaling(scale, scale, 1.0f);