C# OpenGL.Viewport方法代碼示例

        public virtual void ViewResized(OpenGL gl, double actualWidth, double actualHeight)
        {
            var viewPortWidth = (float)actualWidth * _performanceScaleValue;
            var viewPortHeight = (float)actualHeight * _performanceScaleValue;

            ViewPortSize = new Size((int)actualWidth, (int)actualHeight);
            SceneSize = new Size((int)viewPortWidth, (int)viewPortHeight);

            // Create a projection matrix for the scene with the screen size.
            Projection.SetFrustum((float)viewPortWidth, (float)viewPortHeight);

            gl.SetDimensions((int)++viewPortWidth, (int)++viewPortHeight);
            gl.Viewport(0, 0, (int)++viewPortWidth, (int)++viewPortHeight);
        }

        //Handles the Resized event of the openGLControl1 control
        private void Resized(ref OpenGL gl, double Width, double Height)
        {
            //  Set the projection matrix.
            gl.MatrixMode(OpenGL.GL_PROJECTION);

            //  Load the identity.
            gl.LoadIdentity();

            if (!TexturesInitialised)
            {
                gl.Ortho(-1, 1, -1, 1, -1, 1);
            }
            else
            {
                gl.Ortho(0, gImage1.Width, gImage1.Height, 0, -1, 1);
            }
            gl.MatrixMode(OpenGL.GL_MODELVIEW);
            gl.Disable(OpenGL.GL_DEPTH_TEST);

            //  Create a perspective transformation.
            gl.Perspective(45.0f, (double)Width / (double)Height, 1.0, 1000.0);
            gl.Viewport(0, 0, (int)Width, (int)Height);
            //  Use the 'look at' helper function to position and aim the camera.
            gl.LookAt(-5, 5, -5, 0, 0, 0, 0, 1, 0);

            //  Set the modelview matrix.
            gl.MatrixMode(OpenGL.GL_MODELVIEW);
        }

        /// <summary>
        /// Source: http://www.opengl-tutorial.org/miscellaneous/clicking-on-objects/picking-with-an-opengl-hack/
        /// It's recommended to read the source before using this algorithm.
        /// </summary>
        /// <param name="scene">The OpenGLScene.</param>
        /// <param name="point">The 2D point.</param>
        /// <param name="models">The drawn models.</param>
        /// <param name="performanceScaleValue">A factor that affects performance by scaling the size of the temperory viewport.</param>
        /// <returns>The model on this location or null.</returns>
        public static int GetModelAtPointHack(Point point, IEnumerable<ElementAndTransformation> models, 
            int[] viewport, ModelView modelview, Projection projection, Normal normal, float performanceScaleValue = 1)
        {
            return -1; // TODO

            int id = -1;

            int width = (int)(viewport[2] * performanceScaleValue);
            int height = (int)(viewport[3] * performanceScaleValue);
            int x = (int)(point.X * performanceScaleValue);
            int y = height - (int)(point.Y * performanceScaleValue);

            #region create a temperory gl to prevent flickering
            OpenGL gl = new OpenGL();

            // Create OpenGL.
            var openGLVersion = OpenGLVersion.OpenGL2_1;
            var renderContextType = RenderContextType.FBO;
            gl.Create(openGLVersion, renderContextType, 1, 1, 32, null);
            // Set the dimensions and viewport.
            gl.SetDimensions(width, height);
            gl.Viewport(0, 0, width, height);

            // Make GL current.
            gl.MakeCurrent();

            gl.Enable(OpenGL.GL_DEPTH_TEST);
            //gl.Clear(OpenGL.GL_DEPTH_CLEAR_VALUE);

            #endregion create a temperory gl to prevent flickering

            // Initialize the shader for our new GL.
            //var esp = Shaders.LoadSimpleShader(gl);
            //var idxModelTransformation = new List<Tuple<int, int>>(); // Item1 = idx in models; Item2 = idx of model.Transformations

            //var buffersToBeRemoved = new List<uint>();

            //esp.UseProgram(gl, () =>
            //{
            //    // Set the matrices.
            //    esp.ApplyMVPNMatrices(gl, modelview, projection, normal);

            //    var curModelId = 0;

            //    // render models, using a temperory color
            //    for (int i = 0; i < models.Count(); )
            //    {
            //        var model = models.ElementAt(i);

            //        // Extract the color. Since we don't need the i in this loop anymore, we can use it to set the color.
            //        i++; // We don't want to use 0 for the color, so we increment it already. ( = black)
            //        var col = new ColorF(Convert.ToUInt32(i*20));
            //        esp.ApplyMaterial(gl, new Material() { Ambient = col });

            //        // Use the transformation in the model, else use the identity matrix (I do this to override previous transformations)
            //        if (model.Transformation != null)
            //            esp.ApplyTransformationMatrix(gl, model.Transformation.ResultMatrix);
            //        else
            //            esp.ApplyTransformationMatrix(gl, mat4.identity());

            //        var createdBuffers = OGLVisualSceneElementBase.GenerateAndDrawOnce(gl, (OGLVisualSceneElementBase)model.SceneElement); // model.Render(gl, RenderMode.HitTest);
            //        buffersToBeRemoved.AddRange(createdBuffers);
            //    }
            //});
            //esp.Dispose();

            //// Wait for GPU to finish.
            //gl.Flush();
            //gl.Finish();

            //gl.PixelStore(OpenGL.GL_UNPACK_ALIGNMENT, 1);

            //uint format = OpenGL.GL_RGBA;
            //uint type = OpenGL.GL_UNSIGNED_BYTE;

            //byte[] data = new byte[40];
            //gl.ReadPixels(x, y, 1, 1, format, type, data);

            //// Delete the created buffers.
            //gl.DeleteBuffers(buffersToBeRemoved.Count, buffersToBeRemoved.ToArray());

            //// Remove the temperory gl from memory.
            //gl.RenderContextProvider.Dispose();

            //// Get color id from pixel data.
            //id = data[0] + data[1] * 255 + data[2] * 65025; // id = r + g * 255 + b * 255².

            //// if the pixel is black, then there was nothing selected.
            //if (id == 0)
            //{
            //    return -1;
//.........這裏部分代碼省略.........