title: Modern OpenGL: Object picking (C#, OpenTK)
body: <p>I am trying to implement object picking in OpenGL using C# and OpenTK. I have written a class for this purpose based on two sources:</p>
  
  <p><a href="https://stackoverflow.com/questions/30719957/opengl-ray-casting-picking-account-for-objects-transform">OpenGL ray casting (picking): account for object&#39;s transform</a></p>
  
  <p><a href="https://www.bfilipek.com/2012/06/select-mouse-opengl.html" rel="nofollow noreferrer">https://www.bfilipek.com/2012/06/select-mouse-opengl.html</a></p>
  
  <p>Currently my code is only for calculating the distance of the mouse pointer from an arbitrary test coordinate of (0,0,0), but once working it would not take much to iterate through objects in a scene to find a match.</p>
  
  <p>The method is to define a ray underneath the mouse pointer between the near and far clipping planes. Then find the point on that ray which is closest to the point being tested and return the distance between the two. This should be zero when the mouse pointer is directly over (0,0,0) and increase as it moves away in any direction.</p>
  
  <p>Can anyone help troubleshoot this? It executes without errors but the distance being returned clearly isn't correct. I understand the principles but not the finer points of the calculations.</p>
  
  <p>Although I have found various examples online which <em>almost</em> do it, they are generally in a different language or framework and/or use deprecated methods and/or are incomplete or not working.</p>
  
  <pre><code>public class ObjectPicker{
  
      public static float DistanceFromPoint(Point mouseLocation, Vector3 testPoint, Matrix4 modelView, Matrix4 projection)
      {
          Vector3 near = UnProject(new Vector3(mouseLocation.X, mouseLocation.Y, 0), modelView, projection); // start of ray
          Vector3 far = UnProject(new Vector3(mouseLocation.X, mouseLocation.Y, 1), modelView, projection); // end of ray
          Vector3 pt = ClosestPoint(near, far, testPoint); // find point on ray which is closest to test point
          return Vector3.Distance(pt, testPoint); // return the distance
      }
      private static Vector3 ClosestPoint(Vector3 A, Vector3 B, Vector3 P) 
      {
          Vector3 AB = B - A;
          float ab_square = Vector3.Dot(AB, AB);
          Vector3 AP = P - A;
          float ap_dot_ab = Vector3.Dot(AP, AB);
          // t is a projection param when we project vector AP onto AB 
          float t = ap_dot_ab / ab_square;
          // calculate the closest point 
          Vector3 Q = A + Vector3.Multiply(AB, t); 
          return Q; 
      }   
      private static Vector3 UnProject(Vector3 screen, Matrix4 modelView, Matrix4 projection)
      {
          int[] viewport = new int[4];
          OpenTK.Graphics.OpenGL.GL.GetInteger(OpenTK.Graphics.OpenGL.GetPName.Viewport, viewport);
  
          Vector4 pos = new Vector4();
  
          // Map x and y from window coordinates, map to range -1 to 1 
          pos.X = (screen.X - (float)viewport[0]) / (float)viewport[2] * 2.0f - 1.0f;
          pos.Y = 1 - (screen.Y - (float)viewport[1]) / (float)viewport[3] * 2.0f;
          pos.Z = screen.Z * 2.0f - 1.0f;
          pos.W = 1.0f;
  
          Vector4 pos2 = Vector4.Transform( pos, Matrix4.Invert(modelView) * projection );
          Vector3 pos_out = new Vector3(pos2.X, pos2.Y, pos2.Z);
  
          return pos_out / pos2.W;
      }
  }
  </code></pre>
  
  <p>It is called like this:</p>
  
  <pre><code>    private void GlControl1_MouseMove(object sender, MouseEventArgs e)
      {
  
          float dist = ObjectPicker.DistanceFromPoint(new Point(e.X,e.Y), new Vector3(0,0,0), model, projection);
          this.Text = dist.ToString(); // display in window caption for debugging
  
      }
  </code></pre>
  
  <p>I know how the matrices are being passed in (as per above code). I'm fairly sure that the contents of those matrices must be correct, since the rendering works fine, and I can rotate/zoom successfully. This is the vertex shader FWIW:</p>
  
  <pre><code>        string vertexShaderSource =
              "# version 330 core\n" +
              "layout(location = 0) in vec3 aPos;" +
              "layout(location = 1) in vec3 aNormal;" +
              "uniform mat4 model;    " +
              "uniform mat4 view;" +
              "uniform mat4 projection;" +
              "out vec3 FragPos;" +
              "out vec3 Normal;" +
              "void main()" +
              "{" +
              "gl_Position = projection * view * model * vec4(aPos, 1.0);" +
              "FragPos = vec3(model * vec4(aPos, 1.0));" +
              "Normal = vec3(model * vec4(aNormal, 1.0))";
              "}";
  </code></pre>
  
  <p>I use an implementation of Arcball for rotation. Zooming is done using a translation, like this:</p>
  
  <pre><code>private void glControl1_MouseWheel(object sender, System.Windows.Forms.MouseEventArgs e)
      {
          zoom += (float)e.Delta / 240;
          view = Matrix4.CreateTranslation(0.0f, 0.0f, zoom);
          SetMatrix4(Handle, "view", view);
          glControl1.Invalidate();
      }
  </code></pre>