bool ViewportMesh::FacesHitTest( wxPoint start, wxPoint end, ViewportManager * vm, std::list<unsigned int> &hits )
{
	unsigned int num_faces = m_mesh->GetNumFaces();

	GLuint * selection_buffer = new GLuint[ 4 * num_faces ];

	if ( !selection_buffer )
	{
		return false;
	}

	glSelectBuffer( num_faces, selection_buffer );
	glRenderMode( GL_SELECT );

	glInitNames();
	glPushName(-1);

	// The Size Of The Viewport. [0] Is <x>, [1] Is <y>, [2] Is <length>, [3] Is <width>
	GLint	viewport_size[4];
	glGetIntegerv( GL_VIEWPORT, viewport_size );

	double pick_x, pick_y;	
	double pick_w, pick_h;

	if ( start == end )
	{
		pick_x = 0.5 + double( start.x );
		pick_y = double( viewport_size[3] ) - 0.5 - double( start.y );
		pick_w = 1.0;
		pick_h = 1.0;
	}
	else
	{
		pick_x = 0.5 * double( start.x + end.x );
		pick_y = double( viewport_size[3] ) - 0.5 * double( start.y + end.y );
		pick_w = ScEng::MathD::FAbs( start.x - end.x ); 
		pick_h = ScEng::MathD::FAbs( start.y - end.y );
	}

	glMatrixMode(GL_PROJECTION);
	glPushMatrix();				
	glLoadIdentity();			
	gluPickMatrix( pick_x, pick_y, pick_w, pick_h, viewport_size );
	
	if ( vm->m_camera.perspective )
	{
		float y_view_fov = 2.0f * float( atan( tan(0.5*vm->m_camera.fov) * float(vm->m_camera.height) / float(vm->m_camera.width) ) );
		gluPerspective( GMT::RadiansToDegrees( y_view_fov ), vm->m_camera.aspect, vm->m_camera.clipping_near, vm->m_camera.clipping_far );
	}
	else
	{
		glOrtho( vm->m_camera.left, vm->m_camera.right, vm->m_camera.bottom, vm->m_camera.top, vm->m_camera.clipping_near, vm->m_camera.clipping_far );
	}

	glMatrixMode(GL_MODELVIEW);

	for ( unsigned int i_f = 0; i_f < m_mesh->GetNumFaces(); i_f++ )
	{
		glLoadName( i_f );

		glBegin(GL_POLYGON);

		for ( unsigned int i_v = 0; i_v < m_mesh->GetFaceDeg( i_f ); i_v++ )
		{
			float point[3];
			GMT::Point3D t_uv = m_mesh->GetVert( m_mesh->GetFaceVert( i_f, i_v ) ).v * m_tm;
			point[0] = t_uv.x;
			point[1] = t_uv.y;
			point[2] = t_uv.z;
			glVertex3f( point[0], point[1], point[2] );
		}

		glEnd();
	}

	glMatrixMode( GL_PROJECTION );
	glPopMatrix();				
	glMatrixMode( GL_MODELVIEW );

	unsigned int num_hits = glRenderMode( GL_RENDER );

	if ( num_hits == GL_INVALID_ENUM )
	{
		num_hits = 0;
	}

	if ( num_hits == GL_INVALID_OPERATION )
	{
		num_hits = 0;
	}

	if ( num_hits > 0 && num_hits < num_faces )
	{
		for ( unsigned int i_h = 0; i_h < num_hits; i_h++ )
		{
			GLuint min_z = selection_buffer[ 4 * i_h + 0 ];
			GLuint max_z = selection_buffer[ 4 * i_h + 1 ];
			GLuint q     = selection_buffer[ 4 * i_h + 2 ];
			GLuint hit   = selection_buffer[ 4 * i_h + 3 ];

			hits.push_back( hit );
		}
	}

	delete [] selection_buffer;

	if ( hits.empty() )
	{
		return false;
	}

	return true;
}