source: branches/HeuristicLab.Problems.GaussianProcessTuning/ILNumerics.2.14.4735.573/Drawing/Platform/OpenGL/ILGLU.cs @ 10903

///
///    This file is part of ILNumerics Community Edition.
///
///    ILNumerics Community Edition - high performance computing for applications.
///    Copyright (C) 2006 - 2012 Haymo Kutschbach, http://ilnumerics.net
///
///    ILNumerics Community Edition is free software: you can redistribute it and/or modify
///    it under the terms of the GNU General Public License version 3 as published by
///    the Free Software Foundation.
///
///    ILNumerics Community Edition 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 ILNumerics Community Edition. See the file License.txt in the root
///    of your distribution package. If not, see <http://www.gnu.org/licenses/>.
///
///    In addition this software uses the following components and/or licenses: 
///
///    =================================================================================
///    The Open Toolkit Library License
///    
///    Copyright (c) 2006 - 2009 the Open Toolkit library.
///    
///    Permission is hereby granted, free of charge, to any person obtaining a copy
///    of this software and associated documentation files (the "Software"), to deal
///    in the Software without restriction, including without limitation the rights to 
///    use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
///    the Software, and to permit persons to whom the Software is furnished to do
///    so, subject to the following conditions:
///
///    The above copyright notice and this permission notice shall be included in all
///    copies or substantial portions of the Software.
///
///    =================================================================================
///    

using System; 
using OpenTK; 
using OpenTK.Graphics; 
using OpenTK.Math; 
using ILNumerics;
using ILNumerics.Drawing; 

/// <summary>
/// This is a managed replacement for the OpenGL utilities library
/// </summary>
public partial class ILGLU {
  
  /// <summary>
  /// Looks at eye, target, top and moveOffset.
  /// </summary>
  /// <param name='eye'>
  /// Position of camera
  /// </param>
  /// <param name='target'>
  /// Point the camera aims at
  /// </param>
  /// <param name='top'>
  /// 'up' vector of the camera
  /// </param>
  /// <param name='moveOffset'>
  /// offset for moving the whole scene slightly out of center
  /// </param>
  /// <remarks>Reference: http://www.opengl.org/sdk/docs/man/xhtml/gluLookAt.xml </remarks>
  public static void LookAt (ILPoint3Df eye, ILPoint3Df target, ILPoint3Df top, ILPoint3Df moveOffset)
  {
    ILPoint3Df f = ILPoint3Df.normalize(target - eye);
      ILPoint3Df s = ILPoint3Df.cross(f, top);
      ILPoint3Df u = ILPoint3Df.cross(s, f);
    // todo: cache this temp matrix! 
      double[] tmpMat = new double[16]; 
      tmpMat[0] = s.X;  tmpMat[4] = s.Y;  tmpMat[8] = s.Z;  tmpMat[12] = 0;
      tmpMat[1] = u.X;  tmpMat[5] = u.Y;  tmpMat[9] = u.Z;  tmpMat[13] = 0;
      tmpMat[2] = -f.X;   tmpMat[6] = -f.Y;   tmpMat[10] = -f.Z;  tmpMat[14] = 0;
      tmpMat[3] = 0;    tmpMat[7] = 0;    tmpMat[11] = 0;     tmpMat[15] = 1;
      GL.MultMatrix(tmpMat); 
      s = moveOffset - eye; 
      GL.Translate( s.X,s.Y,s.Z);
  }
  
  /// <summary>
  /// Get the screen coords of a point from world space coords
  /// </summary>
  /// <param name='worldCoords'>
  /// World coords.
  /// </param>
  /// <param name='mm'>
  /// Modelview matrix (as 1d double vector) 
  /// </param>
  /// <param name='pm'>
  /// Projection matrix (as 1d double vector)
  /// </param>
  /// <param name='vm'>
  /// View matrix (as 1d double vector) 
  /// </param>
  /// <param name='screen'>
  /// [Output] point with screen coords (and a z value, see OpenGL man pages)
  /// </param>
  /// <remarks>Reference: http://www.opengl.org/sdk/docs/man/xhtml/gluProject.xml </remarks>
  public static void Project(ILPoint3Df worldCoords, double[] mm, double[] pm, int[] vm, out ILPoint3Df screen) {
    screen = new ILPoint3Df(); 
    screen.X = (float)((pm[0] * mm[00] + pm[4] * mm[01] + pm[8] * mm[02] + pm[12] * mm[03]) * worldCoords.X 
          +(pm[0] * mm[04] + pm[4] * mm[05] + pm[8] * mm[06] + pm[12] * mm[07]) * worldCoords.Y 
          +(pm[0] * mm[08] + pm[4] * mm[09] + pm[8] * mm[10] + pm[12] * mm[11]) * worldCoords.Z 
          +(pm[0] * mm[12] + pm[4] * mm[13] + pm[8] * mm[14] + pm[12] * mm[15]));  
    
    screen.Y = (float)((pm[1] * mm[00] + pm[5] * mm[01] + pm[9] * mm[02] + pm[13] * mm[03]) * worldCoords.X 
          +(pm[1] * mm[04] + pm[5] * mm[05] + pm[9] * mm[06] + pm[13] * mm[07]) * worldCoords.Y 
          +(pm[1] * mm[08] + pm[5] * mm[09] + pm[9] * mm[10] + pm[13] * mm[11]) * worldCoords.Z 
          +(pm[1] * mm[12] + pm[5] * mm[13] + pm[9] * mm[14] + pm[13] * mm[15]));  

    screen.Z = (float)((pm[2] * mm[00] + pm[6] * mm[01] + pm[10] * mm[02] + pm[14] * mm[03]) * worldCoords.X 
          +(pm[2] * mm[04] + pm[6] * mm[05] + pm[10] * mm[06] + pm[14] * mm[07]) * worldCoords.Y 
          +(pm[2] * mm[08] + pm[6] * mm[09] + pm[10] * mm[10] + pm[14] * mm[11]) * worldCoords.Z 
          +(pm[2] * mm[12] + pm[6] * mm[13] + pm[10] * mm[14] + pm[14] * mm[15]));  
    
    screen.X = vm[0] + (vm[2] * (screen.X + 1f)) / 2f; 
    screen.Y = vm[1] + (vm[3] * (screen.Y + 1f)) / 2f; 
    screen.Z = (screen.Z + 1) / 2; 
  }
  
  /// <summary>
  /// Convert screen coordinates into world coordinates
  /// </summary>
  /// <param name='screen'>
  /// Screen coordinates X,Y (and Z: see the OpenGL manual)
  /// </param>
  /// <param name='mm'>
  /// Modelview matrix
  /// </param>
  /// <param name='pm'>
  /// Projection matrix
  /// </param>
  /// <param name='vm'>
  /// View matrix
  /// </param>
  /// <param name='world'>
  /// [Output] World coordinates
  /// </param>
  /// <remarks>Reference: http://www.opengl.org/sdk/docs/man/xhtml/gluUnProject.xml </remarks>
  public static void UnProject(ILPoint3Df screen, double[] mm, double[] pm, int[] vm, out ILPoint3Df world) {
    Matrix4 p = new Matrix4 (new Vector4((float)pm[0],(float)pm[4],(float)pm[8],(float)pm[12]),
                 new Vector4((float)pm[1],(float)pm[5],(float)pm[9],(float)pm[13]),
                 new Vector4((float)pm[2],(float)pm[6],(float)pm[10],(float)pm[14]),
                 new Vector4((float)pm[3],(float)pm[7],(float)pm[11],(float)pm[15])); 
    
    Matrix4 m = new Matrix4 (new Vector4((float)mm[0],(float)mm[4],(float)mm[8],(float)mm[12]),
                 new Vector4((float)mm[1],(float)mm[5],(float)mm[9],(float)mm[13]),
                 new Vector4((float)mm[2],(float)mm[6],(float)mm[10],(float)mm[14]),
                 new Vector4((float)mm[3],(float)mm[7],(float)mm[11],(float)mm[15])); 
    
    Vector4 normScreen = new Vector4(
        2f * ( screen.X - vm[0]) / vm[2] - 1f,
        2f * ( screen.Y - vm[1]) / vm[3] - 1f,
        2f * screen.Z - 1f,
        1); 
    Matrix4 p_m = Matrix4.Mult(p, m); 
    Matrix4 inv_mp = Matrix4.Invert( p_m ); 
    
    world.X = inv_mp.Row0.X*normScreen.X+inv_mp.Row0.Y*normScreen.Y+inv_mp.Row0.Z*normScreen.Z+inv_mp.Row0.W;
    world.Y = inv_mp.Row1.X*normScreen.X+inv_mp.Row1.Y*normScreen.Y+inv_mp.Row1.Z*normScreen.Z+inv_mp.Row1.W; 
    world.Z = inv_mp.Row2.X*normScreen.X+inv_mp.Row2.Y*normScreen.Y+inv_mp.Row2.Z*normScreen.Z+inv_mp.Row2.W;
    
  }
}