Не могу запустить OpenGL ES 3.0 в Xamarin - Xamarin

using System;
using Android.App;
using Android.Content;
using Android.Runtime;
using Android.Views;
using Android.Widget;
using Android.OS;
using Android.Content.PM;
 
namespace GraphicsEngine
{
    [Activity(Label = "GraphicsEngine",
        MainLauncher = true,
        Icon = "@drawable/icon",
        ConfigurationChanges = ConfigChanges.Orientation | ConfigChanges.KeyboardHidden
#if __ANDROID_11__
        ,HardwareAccelerated=false
#endif
        )]
    public class MainActivity : Activity
    {
        GraphicsEngine view;
 
        protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate(bundle);
 
            // Create our OpenGL view, and display it
            view = new GraphicsEngine(this);
            SetContentView(view);
        }
 
        protected override void OnPause()
        {
            base.OnPause();
            view.Pause();
        }
 
        protected override void OnResume()
        {
            base.OnResume();
            view.Resume();
        }
    }
}

using System;
using OpenTK;
using OpenTK.Graphics;
using OpenTK.Graphics.ES30; //ES11;
using OpenTK.Platform;
using OpenTK.Platform.Android;
using Android.Views;
using Android.Content;
using Android.Util;
 
namespace GraphicsEngine
{
    partial class GraphicsEngine : AndroidGameView
    {
        public GraphicsEngine(Context context) : base(context)
        {
            //GLContextVersion = GLContextVersion.Gles3_0;
            ContextRenderingApi = GLVersion.ES3;
        }
 
        // This gets called when the drawing surface is ready
        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
 
            // Run the render loop
            Run();
        }
 
        // This method is called everytime the context needs
        // to be recreated. Use it to set any egl-specific settings
        // prior to context creation
        //
        // In this particular case, we demonstrate how to set
        // the graphics mode and fallback in case the device doesn't
        // support the defaults
        protected override void CreateFrameBuffer()
        {
            // the default GraphicsMode that is set consists of (16, 16, 0, 0, 2, false)
            try
            {
                Log.Verbose("GLCube", "Loading with default settings");
                
                // if you don't call this, the context won't be created
                base.CreateFrameBuffer();                
                return;
            }
            catch (Exception ex)
            {
                Log.Verbose("GLCube", "{0}", ex);
            }
 
            // this is a graphics setting that sets everything to the lowest mode possible so
            // the device returns a reliable graphics setting.
            try
            {
                Log.Verbose("GLCube", "Loading with custom Android settings (low mode)");
                GraphicsMode = new AndroidGraphicsMode(0, 0, 0, 0, 0, false);
 
                // if you don't call this, the context won't be created
                Init();
                base.CreateFrameBuffer();
                
                return;
            }
            catch (Exception ex)
            {
                Log.Verbose("GLCube", "{0}", ex);
            }
            throw new Exception("Can't load egl, aborting");
        }
    }
}

using System;
using OpenTK;
using OpenTK.Graphics;
using OpenTK.Graphics.ES30; //ES11;
using OpenTK.Platform;
using OpenTK.Platform.Android;
using Android.Views;
using Android.Content;
using Android.Util;
 
namespace GraphicsEngine
{
    partial class GraphicsEngine
    {
        int mainProgrammObject = 0;
 
        bool Init()
        {
 
            int vertexShader, fragmentShader;
            int programObject;
            int linked;
 
            vertexShader = LoadShader(All.VertexShader, vShaderStr);
            fragmentShader = LoadShader(All.FragmentShader, fShaderStr);
 
            programObject = GL.CreateProgram();
 
            if (programObject == 0)
                return false;
 
            GL.AttachShader(programObject, vertexShader);
            GL.AttachShader(programObject, fragmentShader);
 
            GL.LinkProgram(programObject);
 
            GL.GetProgram(programObject, All.LinkStatus, out linked);
 
            if (linked == 0)
            {
                int infoLen = 0;
                GL.GetProgram(programObject, All.InfoLogLength, out infoLen);
                if (infoLen > 1)
                {
                    //Здесь нужен код для просмотра сообщения об ошибке вроде этого:
 
                    //char* infoLog = malloc(sizeof(char) * infoLen);
                    //glGetProgramInfoLog(programObject, infoLen, NULL, infoLog);
                    //esLogMessage("Error linking program:\n%s\n", infoLog);
                    //free(infoLog);
                }
 
                GL.DeleteProgram(programObject);
                return false;
            }
 
            mainProgrammObject = programObject;
            GL.ClearColor(0.0f, 0.0f, 0.0f, 0.0f);
            return true;
        }
 
        int LoadShader(All type, string[] source)
        {
            int shader;
            int compiled;
 
            shader = GL.CreateShader(type);
 
            if (shader == 0)
                return 0;
 
            int[] len = new int[source.Length];
            for (int i = 0; i < source.Length; i++)
            {
                len[i] = source[i].Length;
            }
            
            GL.ShaderSource( shader, 1, source, (int[])null);
            GL.CompileShader(shader);
 
            GL.GetShader(shader, All.CompileStatus, out compiled);
            if (compiled == (int)All.False)
            {
                int infoLen;
                GL.GetShader(shader, All.InfoLogLength, out infoLen);
 
                if (infoLen > 1)
                {
                    //Здесь нужен код для просмотра сообщения об ошибке вроде этого:
 
                    //char* infoLog = malloc(sizeof(char) * infoLen);
                    //glGetShaderInfoLog(shader, infoLen, NULL, infoLog);
                    //esLogMessage ( "Error compiling shader:\n%s\n", infoLog );
                    //free(infoLog);
                    
                    System.Text.StringBuilder error = new System.Text.StringBuilder(infoLen);
                    GL.GetShaderInfoLog(shader, infoLen, (int[])null, error);
                    string s = error.ToString();
 
                    string ss = GL.GetString(All.ShadingLanguageVersion);
                    string ss2 = GL.GetString(All.Version);
 
                }
 
                GL.DeleteShader(shader);
                return 0;
            }
 
            return shader;
        }
 
        // This gets called on each frame render
        protected override void OnRenderFrame(FrameEventArgs e)
        {
            base.OnRenderFrame(e);
 
            float[] vVertices =
            {
                0.0f, 0.5f, 0.0f,
                -0.5f, -0.5f, 0.0f,
                0.5f, -0.5f, 0.0f
            };
 
            GL.Viewport(0, 0, 500, 500);
            GL.Clear(ClearBufferMask.ColorBufferBit);
            GL.UseProgram(mainProgrammObject);
            GL.VertexAttribPointer(0, 3, All.Float, false, 0, vVertices);
            GL.EnableVertexAttribArray(0);
 
            GL.DrawArrays(All.Triangles, 0, 3);
            
 
            //GL.MatrixMode(All.Projection);
            //GL.LoadIdentity();
            //GL.Ortho(-1.0f, 1.0f, -1.5f, 1.5f, -1.0f, 1.0f);
            //GL.MatrixMode(All.Modelview);
            //GL.Rotate(3.0f, 0.0f, 0.0f, 1.0f);
 
            //GL.ClearColor(0.5f, 0.5f, 0.5f, 1.0f);
            //GL.Clear((uint)All.ColorBufferBit);
 
            //GL.VertexPointer(2, All.Float, 0, square_vertices);
            //GL.EnableClientState(All.VertexArray);
            //GL.ColorPointer(4, All.UnsignedByte, 0, square_colors);
            //GL.EnableClientState(All.ColorArray);
 
            //GL.DrawArrays(All.TriangleStrip, 0, 4);
 
            //SwapBuffers();
        }
 
        string[] vShaderStr = {
            "#version 300 es                          \n",
            "layout(location = 0) in vec4 vPosition;  \n",
            "void main()                              \n",
            "{                                        \n",
            "   gl_Position = vPosition;              \n",
            "}                                        \n"
        };
 
        string[] fShaderStr = {
            "#version 300 es                              \n",
            "precision mediump float;                     \n",
            "out vec4 fragColor;                          \n",
            "void main()                                  \n",
            "{                                            \n",
            "   fragColor = vec4 ( 1.0, 0.0, 0.0, 1.0 );  \n",
            "}                                            \n"
        };
 
    }
}