trunk/visLU/Engine.cs

Go to the documentation of this file.

#region Using Statements
using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
using Microsoft.Xna.Framework.Net;
using Microsoft.Xna.Framework.Storage;
using visLU2.Effects;
#endregion

namespace visLU2
{
    class Engine : Microsoft.Xna.Framework.DrawableGameComponent
    {
        #region Variables
        //##########################################################################################

        private Game game;
        private GraphicsDevice device;
        private SpriteBatch spriteBatch;
        private SpriteFont spriteBatchFont;

        //private Data input;
        private FlowData flowData;
        private RenderTarget2D sceneTarget;
        private Camera[] cameras;
        private Viewport viewport;
       
        //__________________________________________________________________________________________
        #endregion

        #region Properties
        #endregion

        #region Constructor





        public Engine(Game _game) : base(_game)
        {
            game = _game;
            
            cameras = Game.Services.GetService(typeof(Camera[])) as Camera[];
            if (cameras == null)
                throw new InvalidOperationException("Camera  Service not found.");

            //flowData = new FlowData(GameProperties.Instance.dataDir + GameProperties.Instance.dataFilename, _game);
            GameProperties.Instance.engineState = new EngineState(false, false, false, false);

            Console.WriteLine("ENGINE STARTED");

        }
        #endregion

        #region Methods
        //##########################################################################################

        #region Initialize()
        //-----------------------------------INITIALIZE()-------------------------------------------

        public override void Initialize()
        {

            spriteBatch = Game.Services.GetService(typeof(SpriteBatch)) as SpriteBatch;
            if (spriteBatch == null)
                throw new InvalidOperationException("SpriteBatch Service not found"); 

            device = Game.GraphicsDevice;

            //init cameras

            //cameras[0] -> 3d view
            //cameras[0].CameraPosition = new Vector3(1.5f, 1.5f, 2.0f);
            //cameras[0].CameraTarget = GameProperties.Instance.dataOrigin;
            //cameras[0].CameraUpVector = Vector3.Left;
            #region debug
            //cameras[0].CameraPosition = new Vector3(0.0f, 0.0f, 5.0f); 
            //cameras[0].CameraTarget = new Vector3(0.0f, 0.0f, 0.0f);
            #endregion

            //cameras[1] -> top view
            //cameras[1].CameraPosition = new Vector3(0.0f, 2.0f, 0.0f);
            //cameras[1].CameraTarget = GameProperties.Instance.dataOrigin;
            //cameras[1].CameraUpVector = Vector3.UnitZ;

            //cameras[2] -> side view
            //cameras[2].CameraPosition = new Vector3(2.0f, 0.0f, 0.0f);
            //cameras[2].CameraTarget = GameProperties.Instance.dataOrigin;
            //cameras[2].CameraUpVector = Vector3.Up;

            //cameras[3] -> front view
            cameras[3].CameraPosition = new Vector3(0.0f, 0.0f, 1.0f);
            cameras[3].CameraTarget = GameProperties.Instance.dataOrigin;
            cameras[3].CameraUpVector = Vector3.Up;
            
            base.Initialize();
        }
        //__________________________________________________________________________________________
        #endregion

        #region LoadContent()
        //-----------------------------------LOAD_CONTENT()-----------------------------------------
        protected override void LoadContent()
        {
            spriteBatchFont = Game.Content.Load<SpriteFont>("Fonts\\spriteFont1");

            viewport = GraphicsDevice.Viewport;
            GameProperties.Instance.XNAViewport = viewport; //: resize when in form resized

            //texture filter
            initializeTextureFilter();

            //define RenderTarget
            //device.PresentationParameters.MultiSampleType = MultiSampleType.NonMaskable;
            device.PresentationParameters.MultiSampleType = device.DepthStencilBuffer.MultiSampleType;
            sceneTarget = (RenderTarget2D)device.GetRenderTarget(0);  
            //device.PresentationParameters.BackBufferHeight, 1, device.PresentationParameters.BackBufferFormat); 
            base.LoadContent();

        }


        //__________________________________________________________________________________________
        #endregion

        #region UnloadContent()
        //-----------------------------------UNLOAD_CONTENT()---------------------------------------

        protected override void UnloadContent()
        {
            // TODO: Unload any non ContentManager content here
            base.UnloadContent();
        }

        //__________________________________________________________________________________________
        #endregion

        #region Update()
        //-----------------------------------UPDATE()-----------------------------------------------

        public override void Update(GameTime gameTime)
        {
 
            //load data
            if (GameProperties.Instance.engineState.loadData)
            {
                flowData = null;
                flowData = new FlowData(GameProperties.Instance.dataDir + GameProperties.Instance.dataFilename, GameProperties.Instance.relativePath, game);
                flowData.Initialize();
               
                #region set camera position and zoom in respect to the data set
                
                float boundary = Math.Max(flowData.BoundaryLength.X, flowData.BoundaryLength.Y);
                float zoom = Math.Min(Game.Window.ClientBounds.Height / boundary, Game.Window.ClientBounds.Width / boundary);

                float camPosX = flowData.BoundaryLength.X * 0.5f + flowData.BoundaryMin.X;
                float camPosY = flowData.BoundaryLength.Y * 0.5f + flowData.BoundaryMin.Y;

                GameProperties.Instance.cameraPosition.Z = zoom;
                GameProperties.Instance.cameraPosition.X = camPosX;
                GameProperties.Instance.cameraPosition.Y = camPosY;

                cameras[3].Zoom = zoom;
                cameras[3].CameraPosition = new Vector3(camPosX, camPosY, 0.0001f);
                cameras[3].CameraTarget = new Vector3(camPosX, camPosY, 0.0f);

                #endregion
                flowData.Camera = cameras[3];
                GameProperties.Instance.engineState.updateCamera = true;
                GameProperties.Instance.engineState.loadData = false;
                GameProperties.Instance.engineState.updateData = true;
                GameProperties.Instance.engineState.drawData = true;
                GameProperties.Instance.activeTab = ActiveTab.Default;
                GameProperties.Instance.updateGuiForm = true;
                GameProperties.Instance.dataLoaded = true;
            }

            //set camera
            if (GameProperties.Instance.engineState.updateCamera)
            {
                #region depricated
                /*int currentView;
                switch (GameProperties.Instance.viewMode)
                {
                    case ViewMode.VolView: //single 3d view

                        currentView = 0;
                        break;

                    case ViewMode.TopView: //single top view
                        currentView = 1;
                        break;

                    case ViewMode.SideView: //single side view
                        currentView = 2;
                        break;

                    case ViewMode.FrontView: //single front view
                        currentView = 3;
                        break;

                    default:
                        currentView = 0;
                        break;

                }*/
                #endregion

                //set parameters to draw the correct scene view
                GameProperties.Instance.engineState.updateCamera = false;

            }

            //update input 
            if (GameProperties.Instance.dataLoaded && GameProperties.Instance.engineState.updateData)
            {
                flowData.Update(gameTime);
                GameProperties.Instance.engineState.updateData = false;
            }

            base.Update(gameTime);
        }

        //__________________________________________________________________________________________
        #endregion

        #region Draw()
        //-----------------------------------DRAW()-------------------------------------------------

        public override void Draw(GameTime gameTime)
        {
           
            if (GameProperties.Instance.dataLoaded && GameProperties.Instance.engineState.drawData)
            {
                device.RenderState.DepthBufferEnable = true;
                device.RenderState.DepthBufferWriteEnable = true;
                // turn Backface Culling off
                device.RenderState.CullMode = CullMode.None;
                device.SetRenderTarget(0, sceneTarget);

                try
                {
                    device.Clear(Color.Black);
                    device.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.Black, 1.0f, 0);
                }
                catch (Exception e)
                {
                    Console.WriteLine(e);
                }

                //draw view mode
                //drawText(gameTime);
                //draw input 
                //input.Draw(gameTime);
                //RenderScene(gameTime);

                flowData.Draw(gameTime);
                GameProperties.Instance.engineState.drawData = false;
            }

            base.Draw(gameTime);

        }

        #region Draw Scene
        /*private void RenderScene(GameTime gameTime)
        {
           

            device.SetRenderTarget(0, sceneTarget);
            try
            {
                device.Clear(Color.Black);
                device.Clear(ClearOptions.Target | ClearOptions.DepthBuffer, Color.Black, 1.0f, 0);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }

            
            input.Draw(gameTime);
              

            #region depricated
            //set camera
            int currentView;
            switch (GameProperties.Instance.viewMode)
            {
                case ViewMode.VolView: //single 3d view

                    currentView = 0;
                    break;

                case ViewMode.TopView: //single top view
                    currentView = 1;
                    break;

                case ViewMode.SideView: //single side view
                    currentView = 2;
                    break;

                case ViewMode.FrontView: //single front view
                    currentView = 3;
                    break;

                default:
                    currentView = 0;
                    break;

            }

            //set parameters to draw the correct scene view
            input.Camera = cameras[currentView];
            input.CurrentCamera = currentView;
            //input.shader.SetEffectParameter(cameras[currentView].ViewProjection);
            #endregion

        } */

        //__________________________________________________________________________________________
        #endregion

        private void drawText(GameTime gameTime)
        {
            GraphicsDevice.RenderState.DepthBufferEnable = false;
            GraphicsDevice.RenderState.DepthBufferWriteEnable = false;
            spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Deferred, SaveStateMode.SaveState);

            switch ((int)GameProperties.Instance.viewMode)
            {
                case 0:
                    spriteBatch.DrawString(spriteBatchFont, ("3D View"),
                    new Vector2(50, 50), Color.Silver);
                    break;
                case 1:
                    spriteBatch.DrawString(spriteBatchFont, ("Top View"),
                    new Vector2(50, 50), Color.Silver);
                    break;
                case 2:
                    spriteBatch.DrawString(spriteBatchFont, ("Side View"),
                    new Vector2(50, 50), Color.Silver);
                    break;
                case 3:
                    spriteBatch.DrawString(spriteBatchFont, ("Front View"),
                    new Vector2(50,50), Color.Silver);
                    break;
                default:
                    spriteBatch.DrawString(spriteBatchFont, ("3d View"),
                    new Vector2(50, 50), Color.Silver);
                    break;
            }

            spriteBatch.End();
            GraphicsDevice.RenderState.DepthBufferEnable = true;
            GraphicsDevice.RenderState.DepthBufferWriteEnable = true;
        }
        //__________________________________________________________________________________________
        #endregion

        #region additional Methods
        //##########################################################################################


        #region Initialize Texture Filter



        private void initializeTextureFilter()
        {
            /*

                device.SamplerStates[0].MipFilter = TextureFilter.Linear;
                Console.WriteLine("using Linear MipFilter");
                device.SamplerStates[0].MinFilter = TextureFilter.Linear;
                Console.WriteLine("using Linear MinFilter");
                device.SamplerStates[0].MagFilter = TextureFilter.Linear;
                Console.WriteLine("using Linear MagFilter");
             */

            
            if (device.GraphicsDeviceCapabilities.
                TextureFilterCapabilities.SupportsMipMapLinear == true)
            {
                device.SamplerStates[0].MipFilter = TextureFilter.Linear;
                Console.WriteLine("using Linear MipFilter");
            }

            if (device.GraphicsDeviceCapabilities.
                TextureFilterCapabilities.SupportsMinifyAnisotropic == true)
            {
                device.SamplerStates[0].MinFilter = TextureFilter.Anisotropic;
                Console.WriteLine("using Anisotropic MinFilter");
            }
            else if (device.GraphicsDeviceCapabilities.
                TextureFilterCapabilities.SupportsMinifyLinear == true)
            {
                device.SamplerStates[0].MinFilter = TextureFilter.Linear;
                Console.WriteLine("using Linear MinFilter");
            }

            if (device.GraphicsDeviceCapabilities.
                TextureFilterCapabilities.SupportsMagnifyAnisotropic == true)
            {
                device.SamplerStates[0].MagFilter = TextureFilter.Anisotropic;
                Console.WriteLine("using Anisotropic MagFilter");
            }
            else if (device.GraphicsDeviceCapabilities.
                TextureFilterCapabilities.SupportsMagnifyLinear == true)
            {
                device.SamplerStates[0].MagFilter = TextureFilter.Linear;
                Console.WriteLine("using Linear MagFilter");
            }
            
        }

        #endregion

        private void ActivateAlphaBlending()
        {
            device.RenderState.AlphaBlendEnable = true;
            device.RenderState.SourceBlend = Blend.SourceAlpha;
            device.RenderState.DestinationBlend = Blend.InverseSourceAlpha;
        }

        private void DeactivateAlphaBlending()
        {
            device.RenderState.AlphaBlendEnable = false;
            device.RenderState.SourceBlend = Blend.One;
            device.RenderState.DestinationBlend = Blend.Zero;
        }

        private void setNonTextureFilter()
        {
            device.SamplerStates[0].MipFilter = TextureFilter.None;
            device.SamplerStates[0].MinFilter = TextureFilter.None;
            device.SamplerStates[0].MagFilter = TextureFilter.None;
        }


        //__________________________________________________________________________________________

        #endregion        

  
       #endregion
    }
}