Введение

Создание и настройка проекта

• Создать новый пустой проект приложения на C#;
• Подключить к нему сборки System и System.Drawing;
• Через NuGet или вручную с сайта www.opentk.com скачать и подключить библиотеку OpenTK.

Создание окна OpenTK

using OpenTK;
using OpenTK.Graphics;

namespace OpenGLTutorial
{
    public sealed class Window : GameWindow
    {
        // Размер окна 800x600, заголовок "OpenGL Tutorial"
        // Версия OpenGL 4.0
        // Без поддержки deprecated-функциональности
        // Остальное оставим по умолчанию
        public Window() : base(800, 600, GraphicsMode.Default, "OpenGL Tutorial", GameWindowFlags.Default, DisplayDevice.Default, 4, 0, GraphicsContextFlags.ForwardCompatible) { }

        public static void Main()
        {
            // Создаём и запускаем окно
            using (var window = new Window())
                window.Run(60);
        }
    }
}

• Назначить цвет очистки окна;
• Задать область окна, в которой будет происходить отрисовка;
• В методе отрисовки очищать окно и переключать буферы.

// Вызывается при первоначальной загрузке
protected override void OnLoad(EventArgs e)
{
	GL.ClearColor(Color4.Black); // Зададим цвет очистки окна
}

// Вызывается при изменение размеров окна
protected override void OnResize(EventArgs e)
{
	GL.Viewport(0, 0, Width, Height); // Зададим область перерисовки размером со всё окно
}

// Вызывается при отрисовке очередного кадра
protected override void OnRenderFrame(FrameEventArgs e)
{
	GL.Clear(ClearBufferMask.ColorBufferBit); // Очищаем буфер цвета
	// Тут будет распологаться основной код отрисовки
	SwapBuffers(); // Переключаем задний и передний буферы
}

Вывод полигона на экран

• создающие различные объекты OpenGL (текстуры, шейдеры, буферы...) и возвращающие их идентификатор;
• удаляющие объекты по их идентификатору и освобождающие занятые ими ресурсы;
• изменяющие параметры объектов по идентификатору;
• делающие некоторый объект текущим и изменяющие параметры текущего объекта некоторого вида.

• Vertex Buffer Object (VBO) – хранит данные о вершинах;
• Vertex Array Object (VAO) – хранит данные о формате вершин, к нему присоединяет один или несколько VBO;
• Shader – представляет собой подпрограмму на языке GLSL, выполняемую на GPU;
• Shader Program – объединяет несколько шейдеров в шейдерную программу.

Vertex Buffer Object

int GL.GenBuffer() // Создаёт новый VBO и возвращает его идентификатор.
void GL.DeleteBuffer(int handle) // Удаляет VBO по идентификатору.

void GL.BindBuffer(BufferTarget bufferTarget, int handle) // Делает указанный VBO текущим.
// Это означает, что все идущие далее функции, предназначенные для работы с VBO и не принимающие явно идентификатор – будут относиться к данному VBO.
// Параметр bufferTarget задаёт тип VBO, сейчас нам будет нужен только BufferTarget.ArrayBuffer.

void GL.BufferData<T>(BufferTarget bufferTarget, IntPtr length, T[] data, BufferUsageHint hint) // Заполняет данными текущий VBO указанного типа.
// Параметр length – длина данных в байтах;
// hint – подсказывает OpenGL, каким образом расположить данные в памяти.
// Массив data не должен быть пуст, иначе произойдёт ошибка.

public sealed class VBO : IDisposable
{
    private const int InvalidHandle = -1;

    public int Handle { get; private set; } // Идентификатор VBO
    public BufferTarget Type { get; private set; } // Тип VBO

    public VBO(BufferTarget type = BufferTarget.ArrayBuffer)
    {
        Type = type;
        AcquireHandle();
    }

    // Создаёт новый VBO и сохраняет его идентификатор в свойство Handle
    private void AcquireHandle()
    { 
        Handle = GL.GenBuffer();
    }

    // Делает данный VBO текущим
    public void Use()
    {
        GL.BindBuffer(Type, Handle);
    }

    // Заполняет VBO массивом data
    public void SetData<T>(T[] data) where T : struct
    {
        if (data.Length == 0)
            throw new ArgumentException("Массив должен содержать хотя бы один элемент", "data");

        Use();
        GL.BufferData(Type, (IntPtr)(data.Length * Marshal.SizeOf(typeof(T))), data, BufferUsageHint.StaticDraw);
    }

    // Освобождает занятые данным VBO ресурсы
    private void ReleaseHandle()
    {
        if (Handle == InvalidHandle)
            return;

        GL.DeleteBuffer(Handle);

        Handle = InvalidHandle;
    }

    public void Dispose()
    {
        ReleaseHandle();
        GC.SuppressFinalize(this);
    }

    ~VBO()
    {
        // При вызове финализатора контекст OpenGL может уже не существовать и попытка выполнить GL.DeleteBuffer приведёт к ошибке
        if (GraphicsContext.CurrentContext != null && !GraphicsContext.CurrentContext.IsDisposed)
            ReleaseHandle();
    }
}

meshVbo = new VBO();
meshVbo.SetData(new[] {
    0.0f,  0.5f,   1.0f, 0.0f, 0.0f,
   -0.5f, -0.5f,   0.0f, 1.0f, 0.0f,
    0.5f, -0.5f,   0.0f, 0.0f, 1.0f
});

[StructLayout(LayoutKind.Sequential)]
public struct Vertex
{
    public float X, Y;
    public float R, G, B;

    public Vertex(float x, float y, Color4 color)
    {
        X = x; Y = y;
        R = color.R; G = color.G; B = color.B;
    }
}

meshVbo.SetData(new[] {
    new Vertex( 0.0f,  0.5f, Color4.Red),
    new Vertex(-0.5f, -0.5f, Color4.Green),
    new Vertex( 0.5f, -0.5f, Color4.Blue)
});

Vertex Array Object

int GL.GenVertexArray() // Создаёт VAO.
void GL.DeleteVertexArray(int handle) // Удаляет VAO.
void GL.BindVertexArray(int handle) // Делает VAO текущим.

void GL.DrawArrays(PrimitiveType type, int start, int count) // Производит отрисовку геометрии из текущего VAO.
// Параметр type задаёт, какими примитивами производится отрисовка, как правило, это PrimitiveType.Triangles.
// Параметры start и count задают диапазон отображаемых вершин – это позволяет хранить несколько мешей в одном VAO.

void GL.EnableVertexAttribArray(int index) // Включает использование вершинного атрибута под номером index.

void GL.VertexAttribPointer(int index, int elementsPerVertex, VertexAttribPointerType pointerType, bool normalized, int stride, int offset) // Прикрепляет текущий VBO к текущему VAO и задаёт параметры вершинного атрибута index.
// Параметр elementsPerVertex задаёт, какое количество элементов данного атрибута приходится на одну вершину;
// pointerType – тип элементов данного атрибута, обычно это VertexAttribPointerType.Float;
// stride – размер описания одной вершины в данном VBO в байтах, а offset – смещение данного атрибута в описание вершины в данном VBO в байтах.

public sealed class VAO : IDisposable
{
    private const int InvalidHandle = -1;

    public int Handle { get; private set; }
    public int VertexCount { get; private set; } // Число вершин для отрисовки

    public VAO(int vertexCount)
    {
        VertexCount = vertexCount;
        AcquireHandle();
    }

    private void AcquireHandle()
    {
        Handle = GL.GenVertexArray();
    }

    public void Use()
    {
        GL.BindVertexArray(Handle);
    }

    public void AttachVBO(int index, VBO vbo, int elementsPerVertex, VertexAttribPointerType pointerType, int stride, int offset)
    {
        Use();
        vbo.Use();
        GL.EnableVertexAttribArray(index);
        GL.VertexAttribPointer(index, elementsPerVertex, pointerType, false, stride, offset);
    }

    public void Draw()
    {
        Use();
        GL.DrawArrays(PrimitiveType.Triangles, 0, VertexCount);
    }

    private void ReleaseHandle()
    {
        if (Handle == InvalidHandle)
            return;

        GL.DeleteVertexArray(Handle);

        Handle = InvalidHandle;
    }

    public void Dispose()
    {
        ReleaseHandle();
        GC.SuppressFinalize(this);
    }

    ~VAO()
    {
        if (GraphicsContext.CurrentContext != null && !GraphicsContext.CurrentContext.IsDisposed)
            ReleaseHandle();
    }
}

meshVao = new VAO(3); // 3 вершины
meshVao.AttachVBO(0, meshVbo, 2, VertexAttribPointerType.Float, 5 * sizeof(float), 0); // Нулевой атрибут вершины – позиция, у неё 2 компонента типа float
meshVao.AttachVBO(1, meshVbo, 3, VertexAttribPointerType.Float, 5 * sizeof(float), 2 * sizeof(float)); // Первый атрибут вершины – цвет, у него 3 компонента типа float

Shader Program

int GL.CreateProgram() // Создаёт объект шейдерной программы.
void GL.UseProgram(int handle) // Использует данную шейдерную программу для отрисовки.
void GL.DeleteProgram(int handle) // Удаляет шейдерную программу.

int GL.CreateShader(ShaderType  type) // Создаёт шейдер указанного типа, типом может быть, к примеру, ShaderType.VertexShader или ShaderType.FragmentShader.
void GL.DeleteShader(int handle) // Удаляет шейдер.

void GL.ShaderSource(int handle, string source) // Назначает исходный код шейдеру.
void GL.CompileShader(int handle) // Компилирует шейдер.

void GL.GetShader(int handle, ShaderParameter.CompileStatus, out compileStatus) // Позволяет получить в переменную compileStatus статус компиляции шейдера. Если он равен нулю, значит что-то не так.
string GL.GetShaderInfoLog(int handle) // Возвращает строку, содержащую конкретную информацию об ошибке компиляции.

void GL.AttachShader(int handle, int shaderHandle) // Прикрепляет шейдер shaderHandle к шейдерной программе handle.
void GL.LinkProgram(int handle) // Линкует шейдерную программу.
void GL.GetProgram(int handle, GetProgramParameterName.LinkStatus, out int linkStatus) // По аналогии с GL.GetShader позволяет получить в переменную linkStatus статус линковки шейдерной программы.
string GL.GetProgramInfoLog(int handle) // Возвращает информацию об ошибке.

public sealed class Shader : IDisposable
{
    private const int InvalidHandle = -1;

    public int Handle { get; private set; }
    public ShaderType Type { get; private set; }

    public Shader(ShaderType type)
    {
        Type = type;
        AcquireHandle();
    }

    private void AcquireHandle()
    {
        Handle = GL.CreateShader(Type);
    }

    public void Compile(string source)
    {
        GL.ShaderSource(Handle, source);
        GL.CompileShader(Handle);

        int compileStatus;
        GL.GetShader(Handle, ShaderParameter.CompileStatus, out compileStatus);

        // Если произошла ошибка, выведем сообщение
        if (compileStatus == 0)
            Console.WriteLine(GL.GetShaderInfoLog(Handle));
    }

    private void ReleaseHandle()
    {
        if (Handle == InvalidHandle)
            return;

        GL.DeleteShader(Handle);

        Handle = InvalidHandle;
    }

    public void Dispose()
    {
        ReleaseHandle();
        GC.SuppressFinalize(this);
    }

    ~Shader()
    {
        if (GraphicsContext.CurrentContext != null && !GraphicsContext.CurrentContext.IsDisposed)
            ReleaseHandle();
    }
}

public sealed class ShaderProgram : IDisposable
{
    private const int InvalidHandle = -1;

    public int Handle { get; private set; }

    public ShaderProgram()
    {
        AcquireHandle();
    }

    private void AcquireHandle()
    {
        Handle = GL.CreateProgram();
    }

    public void AttachShader(Shader shader)
    {
        GL.AttachShader(Handle, shader.Handle);
    }

    public void Link()
    {
        GL.LinkProgram(Handle);

        int linkStatus;
        GL.GetProgram(Handle, GetProgramParameterName.LinkStatus, out linkStatus);

        if (linkStatus == 0)
            Console.WriteLine(GL.GetProgramInfoLog(Handle));
    }

    public void Use()
    {
        GL.UseProgram(Handle);
    }

    private void ReleaseHandle()
    {
        if (Handle == InvalidHandle)
            return;

        GL.DeleteProgram(Handle);

        Handle = InvalidHandle;
    }

    public void Dispose()
    {
        ReleaseHandle();
        GC.SuppressFinalize(this);
    }

    ~ShaderProgram()
    {
        if (GraphicsContext.CurrentContext != null && !GraphicsContext.CurrentContext.IsDisposed)
            ReleaseHandle();
    }
}

shaderProgram = new ShaderProgram();

using (var vertexShader = new Shader(ShaderType.VertexShader))
using (var fragmentShader = new Shader(ShaderType.FragmentShader))
{
	vertexShader.Compile(@"
#version 400 // Версия GLSL

layout(location = 0) in vec2 Position; // Нулевой входной вершинный атрибут из VBO/VAO
layout(location = 1) in vec3 Color; // Первый входной вершинный атрибут из VBO/VAO

out vec3 fragColor; // Выход вершинного шейдера, передаваемый в фрагментный шейдер

void main()
{
    gl_Position = vec4(Position, 0.0, 1.0); // Позицию вершины дополняем до четырёхмерного вектора нулём по глубине и единицей в четвёртой компоненте, и записываем в специальную встроенную переменную gl_Position
    fragColor = Color; // Цвет передаём в фрагментный шейдер как есть. Указанные для вершин чистые цвета будут интерполированы по всему полигону, образуя плавные переходы
}
");

	fragmentShader.Compile(@"
#version 400

in vec3 fragColor; // Вход из вершинного шейдера

layout(location = 0) out vec4 outColor; // Нулевой выход фрагментного шейдера – в буфер цвета

void main()
{
    outColor = vec4(fragColor, 1.0); // Дополняем цвет до четырёхмерного вектора единицей. Тут четвёртый компонент – прозрачность
}
");

	shaderProgram.AttachShader(vertexShader);
	shaderProgram.AttachShader(fragmentShader);
	shaderProgram.Link();
}

Заключение

• Документация по OpenGL4;
• Документация по OpenTK.