выбор мыши в opengl с использованием `gluUnProject`

Вот как я бы написал PointToLineDistance3D:

static float PointToLineDistance3D(const Vector3 &a, const Vector3 &b, const Vector3 &point){   
    Vector3 lineDirection = Vector3::normalize(b - a), pointDirection = point - a;
    float t = Vector3::dot(pointDirection,lineDirection);
    Vector3 projection = a + (lineDirection * t);

   float ShortestDistance = (projection - point).length();
   return ShortestDistance;
}

Я сделал предположение, что:

• класс Vector3 имеет метод length с очевидным значением,
• есть оператор * для масштабирования векторов,
• есть также функция normalize, которая возвращает... нормализованный вектор (это также можно сделать методом, позволяющим избежать создания дополнительного объекта).

Идея состоит в том, чтобы вычислить проекцию point на луч, а затем вычислить расстояние между projection и point. Как видите, алгоритм немного отличается от вашей реализации, особенно при вычислении t. Возможно, именно в этом заключается ваша проблема.

Чтобы протестировать приведенный выше код, я написал с его помощью небольшую программу, которая строит стену из кубов 3x3 в плоскости XY, центр стены — <0,0,0>. Мне удалось заставить его работать без проблем, даже при перемещении камеры. Единственная проблема была в отношении системы координат мыши, которая идет сверху вниз (т.е. t_координата Y мыши увеличивается вниз_), которая противоположна естественной оси Y OpenGL. Для компиляции и запуска требуется библиотека SDL.

#include <iostream>

#include <GL/gl.h>
#include <GL/glu.h>
#include <SDL/SDL.h>
#include <unistd.h>

#include <Vector3.h>

#define WIDTH 800
#define HEIGHT 600

GLuint box;
int highlight[2]; // position of the cube in the wall
const float cube_width = 5.0; 

Vector3 position(0,0,-25); // camera position

// build the cube display list
void setup_cube(){

  const float w = cube_width;

  float w0 = -w, h0 = -w, w1 = w, h1 = w;

  box = glGenLists(1);
  glNewList(box, GL_COMPILE);
    glBegin(GL_QUAD_STRIP);
      glVertex3f(w0, h1, w0);
      glVertex3f(w0, h0, w0 );
      glVertex3f(w1, h1, w0 );
      glVertex3f(w1, h0, w0 );
      glVertex3f(w1, h1, w1 );
      glVertex3f(w1, h0, w1 );
      glVertex3f(w0, h1, w1 );
      glVertex3f(w0, h0, w1 );
    glEnd();
    glBegin(GL_QUAD_STRIP);
      glVertex3f(w1, h1, w0 );
      glVertex3f(w1, h1, w1 );
      glVertex3f(w0, h1, w0 );
      glVertex3f(w0, h1, w1 );
      glVertex3f(w0, h0, w0 );
      glVertex3f(w0, h0, w1 );
      glVertex3f(w1, h0, w0 );
      glVertex3f(w1, h0, w1 );
    glEnd();
  glEndList();
}

void setup_scene(){

  float r = WIDTH / HEIGHT;

  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glFrustum( -r, r, -1, 1, 1, 1024);

  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();

  glTranslatef(position[0],position[1],position[2]);

  glEnable(GL_CULL_FACE);
  glEnable(GL_DEPTH_TEST);
}

void draw_scene(){

  const float w = cube_width;
  int i = 0, j = 0;

  for (int i = -1; i < 2; i++) {
    for (int j = -1; j < 2; j++) {
      float x = w * 2 * i,  y = w * 2 * j;

      if (highlight[0] == i && highlight[1] == j)
         glColor3f(0.0, 1.0, 0.0);
      else 
         glColor3f(1.0, 0.0, 0.0);

      glPushMatrix ();
         glTranslatef(x,y,0);
         glCallList(box);
      glPopMatrix ();
    }
  }
}

void aim(float xm, float ym_){

  const float w = cube_width;
  float ym = HEIGHT - ym_;

  GLdouble model[16];
  GLdouble proj[16];
  GLint view[16];

  glGetDoublev(GL_MODELVIEW_MATRIX, model);
  glGetDoublev(GL_PROJECTION_MATRIX, proj);
  glGetIntegerv(GL_VIEWPORT, view);
  highlight[0] = -5;
  highlight[1] = -5;

  for (int i = -1; i < 2; i++) {
    for (int j = -1; j < 2; j++) {
      float x = w * 2 * i, y = w * 2 * j;
      double ox, oy, oz;
      Vector3 centre(x,y,0);
      gluUnProject(xm, ym, 0, model, proj, view, &ox, &oy, &oz);
      Vector3 p0(ox,oy,oz);
      gluUnProject(xm, ym, 1, model, proj, view, &ox, &oy, &oz);
      Vector3 p1(ox,oy,oz);
      float d = PointToLineDistance(p0,p1,centre);
      if (d < w) {
        highlight[0] = i;
        highlight[1] = j;
        return;
      }
    }
  }
}

int main(){

  SDL_Surface *screen;

  SDL_Init(SDL_INIT_VIDEO);

  SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
  SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 5 );
  SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );
  SDL_GL_SetAttribute( SDL_GL_DEPTH_SIZE, 16 );
  SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );

  if ( (screen=SDL_SetVideoMode( WIDTH, HEIGHT, 32, SDL_OPENGL )) == NULL ) {
    SDL_Quit();
    return -1;
  }

  setup_cube();

  while (1) {
    SDL_Event event;
    setup_scene();

    while(SDL_PollEvent(&event)){
      switch(event.type){
      case SDL_MOUSEMOTION:
        aim(event.motion.x, event.motion.y);
        break;
      case SDL_KEYDOWN: 
        {
          switch (event.key.keysym.sym){
          case SDLK_ESCAPE:
            SDL_Quit();
            exit(1);
          case SDLK_LEFT:
            position.add(Vector3(1,0,0));
            break;
          case SDLK_RIGHT:
            position.sub(Vector3(1,0,0));
            break;
          case SDLK_UP:
            position.add(Vector3(0,0,1));
            break;
          case SDLK_DOWN:
            position.sub(Vector3(0,0,1));
            break;
          case SDLK_PAGEDOWN:
            position.add(Vector3(0,1,0));
            break;
          case SDLK_PAGEUP:
            position.sub(Vector3(0,1,0));
            break;
          }
        }
      default:
        break;
      }
    }
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    draw_scene();
    SDL_GL_SwapBuffers();
    usleep(10);
  }

  return 0;
}

Перечисленный выше источник корректно отображает куб, на который наведен указатель мыши. Можно перемещаться с помощью стрелок и клавиш страницы вверх/вниз.