C# OpenGL.Create方法代码示例

        /// <summary>
        /// Initializes a new instance of the <see cref="ApplicationState"/> class.
        /// </summary>
        private ApplicationState()
        {
            //  Create the OpenGL instance.
            OpenGL = new OpenGL();

            //  Initialise the OpenGL instance.
            OpenGL.Create(RenderContextType.FBO,
                800, 600, 24, null);
        }

        public void Initialize(IntPtr handle, Viewport viewport)
        {
            this.viewport = viewport;

            gl = new OpenGL();
            gl.Create(RenderContextType.NativeWindow, viewport.Width, viewport.Height, 32, handle);
            gl.MakeCurrent();

            ShaderManager.Initialize(gl);
            MaterialManager.Initialize(gl);

            renderer = new Renderer();
            renderer.Initialize(gl);

            camera = new PerspectiveCamera();
            camera.LocalTranslate(new Vector(0, 0, 3));

            var mesh = new Mesh(gl, MeshType.Points);
            mesh.AddBuffer(
                new Buffer<Point>(gl,
                    new Point(-2, -2, 0),
                    new Point(-1, -1, 0),
                    new Point( 0,  0, 0),
                    new Point( 1, -1, 0),
                    new Point( 2, -2, 0)));

            scene = new Scene();
            scene.Add(camera);

            for (int j = -10; j < 10; j++)
            for (int i = -10; i < 10; i++)
            {
                var e = new PhysicalEntity(mesh, MaterialManager.GetMaterial("Voxels"));
                e.GlobalTranslate(Vector.UnitZ * -5 * i);
                e.GlobalTranslate(Vector.UnitX * -5 * j);
                scene.Add(e);
            }

            gl.MakeNothingCurrent();
        }

 private bool createRenderContext(OpenGL gl, int width, int height)
 {
     return gl.Create(
     OpenGLVersion.OpenGL3_3,
     RenderContextType.FBO,
     width,
     height,
     32,
     null);
 }

        /// <summary>
        /// Call this function to iniatilise a scene loaded from a file.
        /// </summary>
        /// <param name="ctrl">The OpenGLCtrl.</param>
        /// <param name="sceneType">The scene type.</param>
        public virtual void IntialiseFromSerial(int width, int height, SceneType sceneType)
        {
            //	Create OpenGL.
            gl = new OpenGL();
            gl.Create(width, height);

            //	Find out how many lights OpenGL can support.
            int [] umaxlights = new int[1];
            gl.GetInteger(OpenGL.MAX_LIGHTS, umaxlights);

            //	Re-create as many openGL lights as we can.
            for(uint u = 0; u < umaxlights[0]; u++)
            {
                if(u < Lights.Count)
                {
                    Light light = lights[(int)u];
                    light.GLCode = OpenGL.LIGHT0 + u;
                }
            }

            //	Re-create all the quadrics
            foreach(Quadric quadric in quadrics)
                quadric.Create(gl);

            //	Set the scene type.
            SetSceneType(sceneType);

            //	Initialise stock drawing.
            gl.InitialiseStockDrawing();

            //	Set the Scene OpenGL for the quadrics.
            Quadric.SceneOpenGL = OpenGL;
        }

        /// <summary>
        /// Create device and renderbuffer, initialize NV_DX_interop and start rendering.
        /// </summary>
        private void StartRendering()
        {
            _gl = new OpenGL();

            _hwnd = new HwndSource(0, 0, 0, 0, 0, "test", IntPtr.Zero).Handle;

            _gl.Create(SharpGL.Version.OpenGLVersion.OpenGL2_1, RenderContextType.HiddenWindow, 1, 1, 32, _hwnd);

            //  Set the most basic OpenGL styles.
            _gl.ShadeModel(OpenGL.GL_SMOOTH);
            _gl.ClearColor(0.0f, 0.0f, 0.0f, 1.0f);
            _gl.ClearDepth(1.0f);

            _gl.Enable(OpenGL.GL_BLEND);
            _gl.Disable(OpenGL.GL_DEPTH_TEST);

            _gl.Enable(OpenGL.GL_TEXTURE_2D);
            _gl.TexEnv(OpenGL.GL_TEXTURE_ENV, OpenGL.GL_TEXTURE_ENV_MODE, OpenGL.GL_REPLACE);

            _gl.BlendFunc(OpenGL.GL_SRC_ALPHA, OpenGL.GL_ONE_MINUS_SRC_ALPHA);

            //_gl.Enable(OpenGL.GL_MULTISAMPLE);
            //_gl.Enable(OpenGL.GL_MULTISAMPLE_ARB);

            _gl.Hint(0x8534, OpenGL.GL_FASTEST);

            ResizeRendering();

            // leverage the Rendering event of WPF's composition target to
            // update the custom D3D scene
            CompositionTarget.Rendering += OnRenderOpenGL;

            if (GLInitialize != null)
                GLInitialize(this, new EventArgs());
        }

        /// <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;
//.........这里部分代码省略.........

 //private ShaderProgram _program;
 // private ShaderProgram _flatprogram;
 public OpenGLRenderer()
 {
     Name = "OpenGL";
     GL = new OpenGL();
     GL.Create(RenderContextType.FBO, 1, 1, 32, null);
 }