budnhead/org.budnhead/graphics/GLWindow.cs

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

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

using org.budnhead.core;
using org.budnhead.exceptions;
using org.budnhead.graphics.primitives;

namespace org.budnhead.graphics
{

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

		private float arcUpDown,
					arcLeftRight;

		private	Vector3	lookAt;
		private float	lookDistance;


		GLCamera	sceneCamera;
		Scene		scene;

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

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

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

			lookAt = new Vector3(0,0,SquaredMap.maxHeight);
			lookDistance = 2048;
			arcUpDown = MathHelper.PiOver6;
			arcLeftRight = MathHelper.PiOver4;
			sceneCamera.setFoV(MathHelper.PiOver2);

			setupCamera();
		}

		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);
		}

		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;
			} else {
			}
		}

		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:
					//markMouse(e.X,e.Y);
					break;		
				case OpenTK.Input.MouseButton.Right:
					captureMouse();
					break;		
			}
		}

		protected void markMouse(float x,float y){
			try {
				Vector3 P = sceneCamera.Position;
				Vector3 V = sceneCamera.pickRay(x,y);

				Vector3 isect = SquaredMap.activeMap.intersect(P,V);
				Vector2 tile = SquaredMap.activeMap.toTile(isect.Xy);

				SquaredMap.activeMap.highlight(tile);


			} catch (OutOfWorldException owe){
				Console.WriteLine(owe);
			}

		}

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

		protected override void OnMouseWheel(OpenTK.Input.MouseWheelEventArgs e)
		{
			lookDistance *= 1.0f - ( e.DeltaPrecise / 16 );
			lookDistance = MathHelper.Clamp( lookDistance, 4, 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;

				case OpenTK.Input.Key.Number1:
					lookAt = new Vector3(0,0,SquaredMap.maxHeight);
					arcLeftRight = 0;
					arcUpDown = MathHelper.PiOver2;
					setupCamera();
					break;
				case OpenTK.Input.Key.Number2:
					lookAt = new Vector3(0,0,SquaredMap.maxHeight);
					arcLeftRight = MathHelper.PiOver2;
					arcUpDown = MathHelper.PiOver2;
					setupCamera();
					break;
				case OpenTK.Input.Key.Number3:
					lookAt = new Vector3(0,0,SquaredMap.maxHeight);
					sceneCamera.View = new Vector3(1,1,-1);
					sceneCamera.Top = new Vector3(0,0,1);
					break;

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

			ba.Position = BootStrap.instance().SquaredMap.ground(new Vector2(10,10));
			ba.Velocity = new Vector3(0,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 / 16,MathHelper.PiOver2);
			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(){
			Matrix4 mr = (Matrix4.CreateRotationZ(arcLeftRight) * Matrix4.CreateRotationX(arcUpDown));
			Vector3 view = (mr * Vector4.UnitY).Xyz;
			Vector3 top = (mr * Vector4.UnitZ).Xyz;

			view.Normalize();
			top.Normalize();

			Vector3 pos = lookAt - (view * lookDistance);

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






/*		private void startTimers(){
			timerGraphics.Change(0,50);
			timerUpdates.Change(0,50);
		}

		private void stopTimers(){
			timerGraphics.Change(Timeout.Infinite,Timeout.Infinite);
			timerUpdates.Change(Timeout.Infinite,Timeout.Infinite);
		}
*/
	}
}