Selection/Picking

        static int[] selectBuffer = new int[128 * 4];
 
        public static int SelectAt(int x, int y)
        {
            int selectedId = -1;
 
            GL.SelectBuffer(128 * 4, selectBuffer);
            GL.RenderMode(RenderingMode.Select);
            GL.InitNames();
            GL.PushName(0);
 
            GL.MatrixMode(MatrixMode.Projection);
            GL.PushMatrix();
            GL.LoadIdentity();
 
            int[] viewport = new int[4];
            GL.GetInteger(GetPName.Viewport, viewport);
 
            Glu.PickMatrix(x, y, 0.01f, 0.01f, viewport);
 
            GL.Ortho(0, viewport[2], 0, viewport[3], -1.0, 1.0);
 
            Draw();
 
            GL.Flush();
 
            int hits = GL.RenderMode(RenderingMode.Render);
            uint closest = uint.MaxValue;
 
            for (int i = 0; i < hits; i++)
            {
                uint distance = (uint)selectBuffer[i * 4 + 1];
 
                if (closest >= distance)
                {
                    closest = distance;
                    selectedId = (int)selectBuffer[i * 4 + 3];
                }
            }
 
            return selectedId;
        }

            GL.Ortho(0, viewport[2], 0, viewport[3], -1.0, 1.0);

            // Setup your projection matrix here (Copied from Resize function)
            Glu.Perspective(25.0, (double)width / (double)height, 1.0, 15.0);
            GL.Translate(0.0f, 0.0f, -4.0f);
 
            GL.MatrixMode(MatrixMode.Modelview);

mouseControl.Add(glControl);

        // PROPERTIES:
        #region Properties      
 
        // OpenGL window variables
        private OpenTK.GLControl glControl1;        
        private bool loaded = false;
 
        // data info
        private List<Vertex> ModelRenderData;
        private byte yBranchFactor = 3;
        private int iDepth = 3;
 
        // View-port Control Variables
        // mouse position variables
        private Point MousePoint1;
        private Point MousePoint2;
 
        // model rotation orientation
        private float fRotateX;
        private float fRotateY;
        private float fRotateZ = 0f;
 
        // camera position
        private float fTransX;
        private float fTransY;
 
        // zoom ratio
        private float fZoom = 45.0f;
 
 
        // Viewport object user-selection variables
        static private OpenTK.OpenGL.Enums.RenderingMode RenderMode = RenderingMode.Render;        
        static private int BUFFER_SIZE = 256;
        private ListBox lbxSelection;
 
        // Last mouse event
        private MouseEventArgs LastMouseEvent;
 
        #endregion Properties
 
 
        public MeshViewport()
        {
            ModelRenderData = new List<Vertex>();
            SetModelShape(yModelShape);
            InitializeComponent();
        }
 
 
        private void MeshViewport_Load(object sender, EventArgs e)
        {
            loaded = true;
            GL.ClearColor(Color.Black);
            SetupViewport();
        }
 
 
        private void SetupViewport()
        {
            int w = glControl1.Width;
            int h = glControl1.Height;
            int n; // indexer
 
            GL.ClearColor(0f, 0f, 0f, 1f);
 
            GL.Viewport(0, 0, w, h); // Use all of the glControl painting area
            GL.Enable(EnableCap.DepthTest);
        }
 
 
        private void glControl1_Resize(object sender, EventArgs e)
        {
            int myWidth = Width;
 
            if (!loaded)
                return;
 
            if (myWidth == 0)
                myWidth = 1;
 
            RenderMeshModel();
        }
 
 
        private void lblViewPort_Click(object sender, EventArgs e)
        {
 
        }
 
 
        // render the graphics in the viewport
        private void glControl1_Paint(object sender, PaintEventArgs e)
        {
            if (!loaded) // don't execute if not already loaded!
                return;
 
            RenderMeshModel();
        }
 
 
        // RenderMeshModel:
        //
        // This function takes all of the modeling data and renders it to the screen
        public void RenderMeshModel()
        {
            int n, m;              // indexers
            int iMPCL = 0;      // max population of current level
            int iCurrentLevelPopulation = 0; // pop of current vertex within the current level
            int iCurrentLevel = 0;           // current depth level of tree
            int[] viewport; // place to retrieve the viewport numbers
            double[] doubleArray;
 
            // Set Link Width
            GL.LineWidth(1.0f);
            //GL.RenderMode(RenderMode);
 
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
 
            GL.MatrixMode(MatrixMode.Modelview);
            GL.LoadIdentity();
 
            // Set the camera zoom
            Glu.Perspective(fZoom, 1.0, 1.0, 2048);
 
            // Set panning position
            GL.Translate(fTransX, fTransY, -500f);
 
            // Rotate the mesh model about it's own axis
            GL.Rotate(fRotateX, 1f, 0f, 0f);
            GL.Rotate(fRotateY, 0f, 1f, 0f);
            GL.Rotate(fRotateZ, 0f, 0f, 1f);
 
 
            for (n = 0; n < ModelRenderData.Count; n++)
            {
                //------------------------------------------------------------------------------------------------------------------
                // Handle which level the rendering is taking place:
 
                iCurrentLevelPopulation++;
 
                // if found to be next level
 
                if (iCurrentLevelPopulation > iMPCL)
                {
                    iCurrentLevel++; // increment to next level
                    iMPCL = (int)Math.Pow((double)yBranchFactor, (double)iCurrentLevel); // recalculate maximum population of next level
                    iCurrentLevelPopulation = 1; // reset current level population to one (1)
                }
                //------------------------------------------------------------------------------------------------------------------
 
                // DRAW PARENT-CHILD SEGMENTS:
                DrawSegment(ModelRenderData[n].GetThisVertex(), ModelRenderData[n].GetVertexParent(), 1);
 
                // DRAW LINK AND REFERENCE SEGMENTS, iterate for each link
                for (m = 0; m < ModelRenderData[n].GetVertexLinks().Count; m++)
                {
                    DrawSegment(ModelRenderData[n].GetThisVertex(), ModelRenderData[n].GetVertexLink(m).GetThisVertex(), 1);
                    DrawSegment(ModelRenderData[n].GetThisVertex(), ModelRenderData[n].GetVertexLink(m).GetThisVertex(), 2);                    
                }
 
                // DRAW NODE:
                //GL.RenderMode(RenderingMode.Render);
                GL.LoadName(n);
                DrawVertex(ModelRenderData[n].GetThisVertex(), fNodeDiameter + iCurrentLevel * fNodeDiameterStepping + 5);
            }
        }
 
 
        // This fuction will later be for drawing cones for link, reference, and parent-child relationships.
        // type: 1 for outbound connection, 2 for inbound connection
        // tpye is used to determine which direction the data stream is flowing
        private void DrawSegment(Vertex Src, Vertex Dst, byte type)
        {
            Vertex StreamSource = null;
 
            // Set color depending on the origination of the data stream
            switch (type)
            {
                case 1: StreamSource = Src; break;
                case 2: StreamSource = Dst; break;
            }
 
            // Set the color of the segment
            switch (StreamSource.GetDataStream())
            {
                case 1: GL.Color3(1.0f, 0.0f, 0.0f); break;
                case 2: GL.Color3(0.5f, 1.0f, 0.3f); break;
                case 3: GL.Color3(0.0f, 0.0f, 1.0f); break;
                case 4: GL.Color3(1.0f, 0.3f, 0.5f); break;
                case 5: GL.Color3(0.0f, 0.8f, 0.3f); break;
                case 6: GL.Color3(0.0f, 1.0f, 1.0f); break;
                case 7: GL.Color3(0.0f, 0.5f, 0.9f); break;
            }
 
            GL.Begin(BeginMode.Lines);
            GL.Vertex3(Src.GetX(), Src.GetY(), Src.GetZ());
            GL.Vertex3(Dst.GetX(), Dst.GetY(), Dst.GetZ());
            GL.End();
        }
 
 
        // This function will later be for drawing spherical verteces
        private void DrawVertex(Vertex vertex, float fSize)
        {
            switch (vertex.IsSelected())
            {
                case true: GL.Color3(1.0f, 1.0f, 1.0f); break;
                case false: GL.Color3(1.0f, 1.0f, 0.0f); break;
            }
 
            GL.PointSize(fSize);
            GL.Begin(BeginMode.Points);
            GL.Vertex3(vertex.GetX(), vertex.GetY(), vertex.GetZ());
            GL.End();
        }
 
 
        // Zoom:
        //
        // This function modifies the scaling of the mesh model object to make it appear to "zoom-in"
        //
        public void Zoom(float fZoomRatio)
        {
            if (fZoomRatio > 0)
                fZoom += 1f;
            else
                fZoom -= 1f;
 
            RenderMeshModel();
        }
 
 
        // Rotate:
        //
        // This function modifies the rotational position of the mesh model object
        // with respect to zoom ratio, implemented later.
        public void Rotate(float fX, float fY, float fZ)
        {
            // add scaler assignments
            fRotateX -= fX / (float)(Math.PI * 2);
            fRotateY += fY / (float)(Math.PI * 2);            
            fRotateZ += fZ;
 
            RenderMeshModel();
        }
 
 
        // Translate:
        //
        // THis function modifies the position of the mesh model object in 2D space, parallel to the viewport plane.
        public void Translate(int iX, int iY, int iZ)
        {
            fTransX -= (float)iX;
            fTransY += (float)iY;
 
            RenderMeshModel();
        }
 
 
        // This function repositions the model in the center of the viewport
        private void CenterModel()
        {
            fTransX = 0f;
            fTransY = 0f;
            Translate(0, 0, 0);
        }
 
 
        // This function handles the user-selection of objects on the viewport
        private void SelectAt(int iCursorX, int iCursorY)
        {
 
            int[] View = new int[4];
            int[] Buff = new int[BUFFER_SIZE];
            int n, hits;
 
            // sets the buffer to where the values will be stored for the selection data
            GL.SelectBuffer(BUFFER_SIZE, Buff);
 
            // Retrieve info about viewport
            GL.GetInteger(GetPName.Viewport, View);
 
            // Switch to selection mode
            GL.RenderMode(RenderingMode.Select);
 
            // Clear the names stack
            GL.InitNames();
 
            // Fill the names stack with one arbitrary element
            GL.PushName(0);
 
            // Modify the viewing volume, restricting selection area around the cursor
            GL.MatrixMode(MatrixMode.Projection);
            GL.PushMatrix();
            GL.LoadIdentity();
 
            // Restrict the draw to an area around the cursor
            Glu.PickMatrix(iCursorX, iCursorY, 1.0, 1.0, View);
            Glu.Perspective(fZoom, 1.0, 1.0, 2048);
 
            // Draw the objects onto the screen
            GL.MatrixMode(MatrixMode.Modelview);
 
            // Draw only the names in the stack, and fill the array
            glControl1.SwapBuffers();
            RenderMeshModel();
 
            // Restore the old matrix
            GL.MatrixMode(MatrixMode.Projection);
            GL.PopMatrix();
 
            // Get the number of object rendering within the selected area
            hits = GL.RenderMode(RenderingMode.Render);
 
            // Process hits
            for (n = 0; n < hits; n++)
            {
 
                lbxSelection.Items.Add(Buff[n * 4 + 3].ToString());
            }
        }
 
 
        private void MouseDowner(object sender, MouseEventArgs e)
        {
            int iMidX, iMidY;
            float fX, fY;
            MousePoint1.X = e.X;
            MousePoint1.Y = e.Y;
            LastMouseEvent = e;
 
            // calculate the real coordinates, making the center (0,0)
            iMidX = glControl1.Height / 2;
            iMidY = glControl1.Width / 2;
            fX = MousePoint1.X - iMidX;
            fY = MousePoint1.Y - iMidY;
 
            // Right mouse button was clicked
            if (e.Button == MouseButtons.Right)
            {
 
            }
 
            // Left mouse button clicked
            if (e.Button == MouseButtons.Left)
            {
                SelectAt(e.X, e.Y);                
            }
        }
    }
}