source: branches/HeuristicLab.BinPacking/PackingPlanVisualizations/3D/PackingGame.cs @ 13497

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2015 Joseph Helm and Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Drawing.Printing;
using System.Windows.Forms;
using SharpDX;
using SharpDX.Direct3D11;
using SharpDX.Toolkit;
using SharpDX.Toolkit.Graphics;
using SharpDX.Toolkit.Input;

using ButtonStateDX = SharpDX.Toolkit.Input.ButtonState;


namespace PackingPlanVisualizations {
  public class PackingGame : Game {


    #region Global Private Variables
    private GraphicsDeviceManager graphicsDeviceManager;
    private PackingPlan3D control;
    private Matrix worldMatrix;
    private Matrix viewMatrix;
    private Matrix projectionMatrix;
    private float zoom = 50;
    private int selectedItemIndex = -1;

    private BasicEffect basicEffect;
    private Color backgroundColor { get; set; }

    private CenteredContainer container;
    private MouseManager Mouse;
    #endregion Global Private Variables

    protected override void Dispose(bool disposeManagedResources) {
      control.disposedByGame = true;
      base.Dispose(disposeManagedResources);
      control.disposedByGame = false;
    }


    public PackingGame(PackingPlan3D control)
      : base() {
      this.control = control;
      graphicsDeviceManager = new GraphicsDeviceManager(this);
      graphicsDeviceManager.PreferMultiSampling = true;
      graphicsDeviceManager.PreparingDeviceSettings +=
        (object sender, PreparingDeviceSettingsEventArgs e) => {
          e.GraphicsDeviceInformation.PresentationParameters.MultiSampleCount = MSAALevel.X4;          
          return;
        };
      var controlColor = Color.White; // System.Drawing.SystemColors.Control;
      backgroundColor = new Color(controlColor.R, controlColor.G, controlColor.B, controlColor.A);

      Mouse = new MouseManager(this);
    }

    public void SetSize(int width, int height) {

      graphicsDeviceManager.PreferredBackBufferHeight = height;
      graphicsDeviceManager.PreferredBackBufferWidth = width;
    }



    public void InitializeContainer(BasicCuboidShape containerShape) {
      container = new CenteredContainer(containerShape);
    }
    public void InitializeContainer(float width, float height, float depth) {
      InitializeContainer(new BasicCuboidShape(new Vector3(width, height, depth), -1));
    }

    public void AddItemToContainer(float width, float height, float depth, float x, float y, float z, int index, int material) {
      container.AddPackingItem(new Vector3(width, height, depth), new Vector3(x, y, z), index, material);
    }

    public void SelectItem(int itemIndex) {
      selectedItemIndex = itemIndex;
    }
    public void UnselectItem() {
      selectedItemIndex = -1;
    }


    protected override void Initialize() {
      base.Initialize();
      InitializeWorld();
      previousMouseState = Mouse.GetState();
      Console.WriteLine("Initial bounds:" + Window.ClientBounds);
      this.Window.IsMouseVisible = true;
    }
    private void InitializeWorld() {
      #region Matrix-Initialization
      worldMatrix = Matrix.Identity;

      viewMatrix = Matrix.LookAtLH(
          new Vector3(0, 10, zoom),
          Vector3.Zero,
          Vector3.UnitY);

      projectionMatrix = Matrix.PerspectiveFovLH(
          (float)Math.PI / 6.0f,
          (float)GraphicsDevice.BackBuffer.Width /
          (float)GraphicsDevice.BackBuffer.Height,
          1.0f, 1000.0f);
      #endregion Matrix-Initialization

      #region Effect and Color
      //Effect initialization
      basicEffect = new BasicEffect(GraphicsDevice);
      basicEffect.World = worldMatrix;
      basicEffect.View = viewMatrix;
      basicEffect.Projection = projectionMatrix;

      //Primitive color
      basicEffect.AmbientLightColor = new Vector3(0.1f, 0.1f, 0.1f);
      basicEffect.DiffuseColor = new Vector4(1.0f, 1.0f, 1.0f, 1.0f);
      basicEffect.SpecularColor = new Vector3(0.25f, 0.25f, 0.25f);
      basicEffect.SpecularPower = 5.0f;
      basicEffect.Alpha = 1.0f;
      basicEffect.VertexColorEnabled = true;
      #endregion Effect-World and Color

      #region World lighting
      basicEffect.LightingEnabled = true;

      basicEffect.PreferPerPixelLighting = true;

      if (basicEffect.LightingEnabled) {
        basicEffect.DirectionalLight0.Enabled = true; // enable each light individually
        if (basicEffect.DirectionalLight0.Enabled) {
          // x direction
          basicEffect.DirectionalLight0.DiffuseColor = new Vector3(1, 1, 1); // range is 0 to 1
          basicEffect.DirectionalLight0.Direction = Vector3.Normalize(new Vector3(-1, 0, 0));
          // points from the light to the origin of the scene
          basicEffect.DirectionalLight0.SpecularColor = Vector3.One;
        }

        basicEffect.DirectionalLight1.Enabled = true;
        if (basicEffect.DirectionalLight1.Enabled) {
          // y direction
          basicEffect.DirectionalLight1.DiffuseColor = new Vector3(1, 1, 1);
          basicEffect.DirectionalLight1.Direction = Vector3.Normalize(new Vector3(0, -1, 0));
          basicEffect.DirectionalLight1.SpecularColor = Vector3.One;
        }

        basicEffect.DirectionalLight2.Enabled = true;
        if (basicEffect.DirectionalLight2.Enabled) {
          // z direction
          basicEffect.DirectionalLight2.DiffuseColor = new Vector3(1, 1, 1);
          basicEffect.DirectionalLight2.Direction = Vector3.Normalize(new Vector3(0, 0, -1));
          basicEffect.DirectionalLight2.SpecularColor = Vector3.One;
        }
      }
      #endregion World lighting

      #region Transparency

      BlendStateDescription blendStateDescription = new SharpDX.Direct3D11.BlendStateDescription();
      blendStateDescription.RenderTarget[0].IsBlendEnabled = true;
      blendStateDescription.RenderTarget[0].SourceBlend = BlendOption.SourceAlpha;
      blendStateDescription.RenderTarget[0].DestinationBlend = BlendOption.InverseSourceAlpha;
      blendStateDescription.RenderTarget[0].BlendOperation = BlendOperation.Add;
      blendStateDescription.RenderTarget[0].SourceAlphaBlend = BlendOption.One;
      blendStateDescription.RenderTarget[0].DestinationAlphaBlend = BlendOption.Zero;
      blendStateDescription.RenderTarget[0].AlphaBlendOperation = BlendOperation.Add;
      blendStateDescription.RenderTarget[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
      SharpDX.Toolkit.Graphics.BlendState blendState = SharpDX.Toolkit.Graphics.BlendState.New(GraphicsDevice, blendStateDescription);
      GraphicsDevice.SetBlendState(blendState);

      #endregion
    }


    protected override void LoadContent() {

    }

    protected override void Draw(GameTime gameTime) {
      GraphicsDevice.Clear(backgroundColor);

      worldMatrix =
        Matrix.RotationY(MathUtil.DegreesToRadians(-currentViewAngle.X * control.Width / 4)) *
        Matrix.RotationX(MathUtil.DegreesToRadians(currentViewAngle.Y * control.Height / 4));
      basicEffect.World = worldMatrix;

      viewMatrix = Matrix.LookAtLH(
          new Vector3(0, zoom, zoom),
          Vector3.Zero,
          Vector3.UnitY);
      basicEffect.View = viewMatrix;

      foreach (EffectPass pass in basicEffect.CurrentTechnique.Passes) {
        pass.Apply();

        if (container != null) {
          if (container.PackingItems.Count == 0)
            container.Container.RenderShapeTrianglesAndLines(GraphicsDevice);
          else {
            container.Container.RenderShapeLines(GraphicsDevice, new Color(0, 0, 0));
            var selectedItem = container.PackingItems.Find(x => x.ShapeID == selectedItemIndex);
            foreach (BasicCuboidShape item in container.PackingItems) {
              if (selectedItem == null || selectedItemIndex == item.ShapeID) {
                item.RenderShapeLines(GraphicsDevice);
                item.RenderShapeTriangles(GraphicsDevice);
              } else
                item.RenderShapeLines(GraphicsDevice, new Color(0, 0, 0));
            }
          }
        }
      }

      base.Draw(gameTime);
    }

    protected override void Update(GameTime gameTime) {
      ComputeMouseHandling();
      base.Update(gameTime);
    }
    #region Mouse-Handling Variables
    private MouseState previousMouseState;
    private Vector2 mousePositionOnBtnDown;
    private Vector2 viewAngleOnBtnRelease;
    private Vector2 currentViewAngle = new Vector2(0, 0);
    #endregion Mouse-Handling Variables
    private void ComputeMouseHandling() {
      MouseState mouseState = Mouse.GetState();

      ComputeLeftMouseBtnHandling(mouseState);
      ComputeMouseWheelHandling(mouseState);

      previousMouseState = mouseState;
    }
    private void ComputeLeftMouseBtnHandling(MouseState mouseState) {
      //Left btn pressed
      if (mouseState.LeftButton.Down && (previousMouseState.LeftButton.Pressed || previousMouseState.LeftButton.Down)) {
        currentViewAngle = new Vector2(
          viewAngleOnBtnRelease.X + mouseState.X - mousePositionOnBtnDown.X,
          viewAngleOnBtnRelease.Y + mouseState.Y - mousePositionOnBtnDown.Y);
      }

      //Left btn freshly pressed ==> ONLICK-EVENT
      else if (mouseState.LeftButton.Pressed && !(previousMouseState.LeftButton.Pressed || previousMouseState.LeftButton.Down)) {
        mousePositionOnBtnDown = new Vector2(mouseState.X, mouseState.Y);
      }

      //Left btn freshly released ==> ONRELEASE-EVENT
      else if (mouseState.LeftButton.Released && !previousMouseState.LeftButton.Released) {
        viewAngleOnBtnRelease = currentViewAngle;
      }
    }
    private void ComputeMouseWheelHandling(MouseState mouseState) {
      int curr = mouseState.WheelDelta;
      if (curr < 0 && zoom > 1) {
        zoom++;
      } else if (curr > 0 && zoom < 300) {
        zoom--;
      }
    }

  }
}