[Examples] Add forward-compatible OpenGL 3.0 example

using System;
using System.Diagnostics;
using OpenTK;
using OpenTK.Graphics;
using OpenTK.Math;
using System.IO;
 
namespace OpenGL3
{
    public class HelloGL3: GameWindow
    {
        string vertexShaderSource = @"
            #version 130
 
            precision highp float;
 
            uniform mat4 projection_matrix;
            uniform mat4 modelview_matrix;
 
            in vec3 in_position;
            in vec3 in_normal;
 
            out vec3 normal;
 
            void main(void)
            {
              //not a proper transformation if modelview_matrix specifies scaling
              normal = (modelview_matrix * vec4(in_normal, 0)).xyz;
 
              gl_Position = projection_matrix * modelview_matrix * vec4(in_position, 1);
            }";
 
        string fragmentShaderSource = @"
            #version 130
 
            precision highp float;
 
            const vec3 ambient = vec3(0.1, 0.1, 0.1);
            const vec3 lightVecNormalized = normalize(vec3(0.5, 0.5, 2));
            const vec3 lightColor = vec3(0.9, 0.9, 0.7);
 
            in vec3 normal;
 
            out vec4 out_frag_color;
 
            void main(void)
            {
              float diffuse = clamp(dot(lightVecNormalized, normalize(normal)), 0.0, 1.0);
              out_frag_color = vec4(ambient + diffuse * lightColor, 1.0);
            }";
 
        int vertexShaderHandle,
            fragmentShaderHandle,
            shaderProgramHandle,
            modelviewMatrixLocation,
            projectionMatrixLocation,
            vaoHandle,
            positionVboHandle,
            normalVboHandle;
 
        Vector3[] positionVboData = new Vector3[]{
            new Vector3(-1.0f, -1.0f,  1.0f),
            new Vector3( 1.0f, -1.0f,  1.0f),
            new Vector3( 1.0f,  1.0f,  1.0f),
            new Vector3(-1.0f,  1.0f,  1.0f),
            new Vector3(-1.0f, -1.0f, -1.0f),
            new Vector3( 1.0f, -1.0f, -1.0f), 
            new Vector3( 1.0f,  1.0f, -1.0f),
            new Vector3(-1.0f,  1.0f, -1.0f) };
 
        int[] indicesVboData = new int[]{
             // front face
                0, 1, 2, 2, 3, 0,
                // top face
                3, 2, 6, 6, 7, 3,
                // back face
                7, 6, 5, 5, 4, 7,
                // left face
                4, 0, 3, 3, 7, 4,
                // bottom face
                0, 1, 5, 5, 4, 0,
                // right face
                1, 5, 6, 6, 2, 1, };
 
        Matrix4 projectionMatrix, modelviewMatrix;
 
        public HelloGL3()
            : base( 640, 480,
            new GraphicsMode( new ColorFormat( 8, 8, 8, 8 ), 16 ), "OpenGL 3 Example", 0,
            DisplayDevice.Default, 3, 0,
            GraphicsContextFlags.ForwardCompatible | GraphicsContextFlags.Debug )
        {}
 
        public override void OnLoad(EventArgs e)
        {
 	        base.OnLoad(e);
 
            // Create shaders
            vertexShaderHandle = GL.CreateShader( ShaderType.VertexShader );
            fragmentShaderHandle = GL.CreateShader( ShaderType.FragmentShader );
 
            GL.ShaderSource( vertexShaderHandle, vertexShaderSource );
            GL.ShaderSource( fragmentShaderHandle, fragmentShaderSource );
 
            GL.CompileShader( vertexShaderHandle );
            GL.CompileShader( fragmentShaderHandle );
 
            // Create program
            shaderProgramHandle = GL.CreateProgram();
 
            GL.AttachShader( shaderProgramHandle, vertexShaderHandle );
            GL.AttachShader( shaderProgramHandle, fragmentShaderHandle );
 
            GL.LinkProgram( shaderProgramHandle );
 
            string programInfoLog;
            GL.GetProgramInfoLog( shaderProgramHandle, out programInfoLog );
            Debug.WriteLine( programInfoLog );
 
            GL.UseProgram( shaderProgramHandle );
 
            // Set matrices
            float aspectRatio = ClientSize.Height / ( float )( ClientSize.Width );
            projectionMatrix = Matrix4.Frustum( -1, 1, -aspectRatio, aspectRatio, 1, 100 );
            modelviewMatrix = CreateModelview( Vector3.UnitX, 0.5f, new Vector3( 0, 0, -4 ) );
 
            projectionMatrixLocation = GL.GetUniformLocation( shaderProgramHandle, "projection_matrix" );
            modelviewMatrixLocation = GL.GetUniformLocation( shaderProgramHandle, "modelview_matrix" );
 
            GL.UniformMatrix4( projectionMatrixLocation, false, ref projectionMatrix );
            GL.UniformMatrix4( modelviewMatrixLocation, false, ref modelviewMatrix );
 
            // Create vertex arrays
            GL.GenVertexArrays( 1, out vaoHandle );
            GL.BindVertexArray( vaoHandle );
 
            GL.GenBuffers( 1, out positionVboHandle );
            GL.BindBuffer( BufferTarget.ArrayBuffer, positionVboHandle );
            GL.BufferData<Vector3>( BufferTarget.ArrayBuffer,
                new IntPtr( positionVboData.Length * Vector3.SizeInBytes ),
                positionVboData, BufferUsageHint.StaticDraw );
 
            GL.GenBuffers( 1, out normalVboHandle );
            GL.BindBuffer( BufferTarget.ArrayBuffer, normalVboHandle );
            GL.BufferData<Vector3>( BufferTarget.ArrayBuffer,
                new IntPtr( positionVboData.Length * Vector3.SizeInBytes ),
                positionVboData, BufferUsageHint.StaticDraw );
 
            GL.EnableVertexAttribArray( 0 );
            GL.EnableVertexAttribArray( 1 );
 
            GL.VertexAttribPointer( 0, 3, VertexAttribPointerType.Float, true, Vector3.SizeInBytes, 0 );
            GL.VertexAttribPointer( 1, 3, VertexAttribPointerType.Float, true, Vector3.SizeInBytes, 0 );
 
            GL.BindAttribLocation( shaderProgramHandle, 0, "in_position" );
            GL.BindAttribLocation( shaderProgramHandle, 1, "in_normal" );
 
            // Other state
            GL.Enable( EnableCap.DepthTest );
            GL.ClearColor( System.Drawing.Color.MidnightBlue );
        }
 
        public Matrix4 CreateModelview( Vector3 rotationAxis, float angle, Vector3 translate )
        {
            return Matrix4.Rotate( rotationAxis, angle ) * Matrix4.CreateTranslation( translate );
        }
 
        protected override void OnUpdateFrame( FrameEventArgs e )
        {
            modelviewMatrix = Matrix4.RotateY( 0.03f ) * modelviewMatrix;
            GL.UniformMatrix4( modelviewMatrixLocation, false, ref modelviewMatrix );
 
            if( Keyboard[ OpenTK.Input.Key.Escape ] )
                Exit();
        }
 
        protected override void OnRenderFrame( FrameEventArgs e )
        {
            GL.Viewport( 0, 0, Width, Height );
            GL.Clear( ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit );
 
            GL.DrawElements( BeginMode.Triangles, indicesVboData.Length,
                DrawElementsType.UnsignedInt, indicesVboData );
 
            GL.Flush();
            SwapBuffers();
        }
    }
 
    public class Program
    {
        [STAThread]
        public static void Main()
        {
            using( HelloGL3 win = new HelloGL3() )
            {
                string version = GL.GetString( StringName.Version );
                if( version.StartsWith( "3.0" ) ) win.Run();
                else Debug.WriteLine( "Requested OpenGL version not available." );
            }
        }
    }
}