budnhead/NHEngine/OpenGLWindow.cs

using System;
using System.Drawing;
using System.Collections.Generic;

using OpenTK.Graphics;
using OpenTK.Graphics.OpenGL;
using OpenTK;

using org.niclasundharald.engine;
using org.niclasundharald.engine.graphics;
using org.niclasundharald.engine.graphics.primitives;

namespace nhengine
{

	public class OpenGLWindow : GameWindow
	{
		private Point mouseCapturePosition;
		private bool mouseCaptured;

		private float arcUpDown,
					arcLeftRight;

		private	Vector3	lookAt;
		private float	lookDistance;

		private Cube cube,
		c1, c2, c3;


		GLCamera	sceneCamera;
		GLScene		scene;

		public OpenGLWindow()
			:base(800, 600,
			      GraphicsMode.Default, 
			      "nhEngine", 
			      GameWindowFlags.Default, 
			      DisplayDevice.Default, 
			      3, 3,
			      GraphicsContextFlags.ForwardCompatible)
		{
			VSync = VSyncMode.On;
			sceneCamera = new GLCamera();
			scene = new GLScene(sceneCamera);
		}

		protected override void OnLoad(EventArgs e)
		{
			base.OnLoad(e);
			GL.ClearColor(0.05f, 0.05f, 0.05f, 0.0f);
			GL.Enable(EnableCap.DepthTest);
			GL.Enable(EnableCap.Normalize);
			GL.Enable(EnableCap.Blend);
			GL.BlendFunc(BlendingFactorSrc.SrcAlpha,BlendingFactorDest.OneMinusSrcAlpha);

			cube = new Cube(new Vector3(0,0,150), 16.0f);
			c1 = new Cube(new Vector3(16,0,150), 8.0f);
			c2 = new Cube(new Vector3(0,150,150), 8.0f);
			c3 = new Cube(new Vector3(175,175,150), 8.0f);

			lookAt = new Vector3(0,0,128.0f);
			lookDistance = 2048;
			arcUpDown = MathHelper.PiOver6;
			arcLeftRight = MathHelper.PiOver4;

//			sceneCamera.Position = new Vector3(1000,-1000,1000);
//			sceneCamera.View = new Vector3(0f,1.0f,0.0f);
			sceneCamera.Top = new Vector3(0,0,1);
			sceneCamera.setFoV(MathHelper.PiOver4);

			setupCamera();

			scene.RootObject.addChild( cube );
			scene.RootObject.addChild( c1 );
			scene.RootObject.addChild( c2 );
			scene.RootObject.addChild( c3 );

		}

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

			GL.Viewport(ClientRectangle.X, ClientRectangle.Y, ClientRectangle.Width, ClientRectangle.Height);
			sceneCamera.setViewport(ClientRectangle.Width, ClientRectangle.Height);
		}

		protected override void OnRenderFrame(FrameEventArgs e)
		{
			base.OnRenderFrame(e);
			GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

			scene.draw();

			SwapBuffers();

			Title = string.Format("{0:F}/s {1:F}/s [{2:F}s]", RenderFrequency,UpdateFrequency,UpdatePeriod);
		}

		protected override void OnUpdateFrame(FrameEventArgs e)
		{
			base.OnUpdateFrame(e);
			Matrix4 m4 = Matrix4.CreateRotationZ(MathHelper.Pi / 90.0f);

			cube.Rotation = m4 * cube.Rotation;
			c1.Position = (m4.Inverted() * new Vector4(c1.Position)).Xyz;
			c2.Rotation = (m4 * c2.Rotation);
			c3.Position = (m4 * new Vector4(c3.Position)).Xyz;


			Actor.updateAll( (float)UpdatePeriod );
		}

		private void captureMouse(){
			mouseCapturePosition = new Point(Mouse.X, Mouse.Y);
			mouseCaptured = true;
			CursorVisible = false;
		}

		private void releaseMouse(){
			mouseCaptured = false;
			CursorVisible = true;
		}

		protected override void OnMouseMove(OpenTK.Input.MouseMoveEventArgs e)
		{
			if (mouseCaptured){
				Point delta = new Point(e.X - mouseCapturePosition.X, e.Y - mouseCapturePosition.Y);
				onMouseCapturedMove(delta);
				mouseCapturePosition = e.Position;
			}
		}

		protected virtual void onMouseCapturedMove(Point delta){
            rotateLeftRight(((float)delta.X) / 20.0f);
            rotateUpDown(((float)delta.Y) / 20.0f);
		}

		protected override void OnMouseDown(OpenTK.Input.MouseButtonEventArgs e)
		{
			switch (e.Button){
				case OpenTK.Input.MouseButton.Left:
					break;		
				case OpenTK.Input.MouseButton.Right:
					captureMouse();
					break;		
			}
		}

		protected override void OnMouseUp(OpenTK.Input.MouseButtonEventArgs e)
		{
			releaseMouse();
		}

		protected override void OnMouseWheel(OpenTK.Input.MouseWheelEventArgs e)
		{
			lookDistance *= 1.0f - ( e.DeltaPrecise / 16 );
			MathHelper.Clamp( lookDistance, 512, 8192 );
			setupCamera();
		}

		protected override void OnKeyPress(KeyPressEventArgs e)
		{
		}

		protected override void OnKeyDown(OpenTK.Input.KeyboardKeyEventArgs e)
		{
			switch (e.Key){
				case OpenTK.Input.Key.Up:
					rotateUpDown(-MathHelper.Pi / 180.0f);
					break;
				case OpenTK.Input.Key.Down:
                    rotateUpDown(MathHelper.Pi / 180.0f);
					break;
				case OpenTK.Input.Key.Left:
					rotateLeftRight(MathHelper.Pi / 90.0f);
					break;
				case OpenTK.Input.Key.Right:
					rotateLeftRight(-MathHelper.Pi / 90.0f);
					break;
				case OpenTK.Input.Key.W:
					walk(e.Shift ? 50.0f : 5.0f);
					break;
				case OpenTK.Input.Key.S:
					walk(e.Shift ? -50.0f : -5.0f);
					break;
				case OpenTK.Input.Key.A:
					strafe(e.Shift ? -50.0f : -5.0f);
					break;
				case OpenTK.Input.Key.D:
					strafe(e.Shift ? 50.0f : 5.0f);
					break;

				case OpenTK.Input.Key.Space:
					fireBallistic();
					break;
					
			}	
		}

		private void fireBallistic(){
			Console.WriteLine("Fire Ballistic...");
			BallisticActor ba = new BallisticActor(0);

			ba.Position = BootStrap.instance().SquaredMap.ground(new Vector2(10,10));
			ba.Velocity = new Vector3(1,1,1);// + (Matrix4.CreateRotationZ(arcLeftRight) * Vector4.UnitY).Xyz;
			ba.Velocity.Normalize();
			ba.Velocity *= 50;
		}


		public void rotateUpDown(float arc)
		{
			arcUpDown += arc;
			arcUpDown = MathHelper.Clamp(arcUpDown,MathHelper.Pi / 8,MathHelper.PiOver2-0.00001f);
			setupCamera();
		}
		public void rotateLeftRight(float arc)
		{
			arcLeftRight += arc;
			arcLeftRight %= MathHelper.TwoPi;
			setupCamera();
		}
		
		public void walk(float distance){
			lookAt += (new Vector3(sceneCamera.View.Xy)).Normalized() * distance;
			setupCamera();
		}

		public void strafe(float distance){
			lookAt += Vector3.Cross(new Vector3(sceneCamera.View.Xy),Vector3.UnitZ).Normalized() * distance;
			setupCamera();
		}

		protected override void OnKeyUp(OpenTK.Input.KeyboardKeyEventArgs e)
		{
		}

		private void setupCamera(){
			Vector3 view = (Matrix4.CreateRotationZ(arcLeftRight) * Matrix4.CreateRotationX(arcUpDown) * Vector4.UnitY).Xyz;
			view.Normalize();

			Vector3 pos = lookAt - (view * lookDistance);

			sceneCamera.View = view;
			sceneCamera.Position = pos;
		}

		public GLScene Scene {
			get { return this.scene; }
		}


	}
}