Code:


## Instalacija osnovnih razvojnih komponenti
sudo apt install cmake libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev xorg-dev

## Instalacija GLFW biblioteke (prevodi i primere iz ./examples/*)
git clone https://github.com/glfw/glfw
cd glfw/
mkdir build && cd build
cmake ..
make
sudo make install

## Pokretanje primera 
cd examples
./triangle-opengl

Code:

//triangle-opengl.c 
//========================================================================
// OpenGL triangle example
// Copyright (c) Camilla Löwy <[email protected]>
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would
//    be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not
//    be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source
//    distribution.
//
//========================================================================

#include <glad/gl.h>
#define GLFW_INCLUDE_NONE
#include <GLFW/glfw3.h>

#include "linmath.h"

#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>

typedef struct Vertex
{
    vec2 pos;
    vec3 col;
} Vertex;

static const Vertex vertices[3] =
{
    { { -0.6f, -0.4f }, { 1.f, 0.f, 0.f } },
    { {  0.6f, -0.4f }, { 0.f, 1.f, 0.f } },
    { {   0.f,  0.6f }, { 0.f, 0.f, 1.f } }
};

static const char* vertex_shader_text =
"#version 330\n"
"uniform mat4 MVP;\n"
"in vec3 vCol;\n"
"in vec2 vPos;\n"
"out vec3 color;\n"
"void main()\n"
"{\n"
"    gl_Position = MVP * vec4(vPos, 0.0, 1.0);\n"
"    color = vCol;\n"
"}\n";

static const char* fragment_shader_text =
"#version 330\n"
"in vec3 color;\n"
"out vec4 fragment;\n"
"void main()\n"
"{\n"
"    fragment = vec4(color, 1.0);\n"
"}\n";

static void error_callback(int error, const char* description)
{
    fprintf(stderr, "Error: %s\n", description);
}

static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
        glfwSetWindowShouldClose(window, GLFW_TRUE);
}

int main(void)
{
    glfwSetErrorCallback(error_callback);

    if (!glfwInit())
        exit(EXIT_FAILURE);

    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    GLFWwindow* window = glfwCreateWindow(640, 480, "OpenGL Triangle", NULL, NULL);
    if (!window)
    {
        glfwTerminate();
        exit(EXIT_FAILURE);
    }

    glfwSetKeyCallback(window, key_callback);

    glfwMakeContextCurrent(window);
    gladLoadGL(glfwGetProcAddress);
    glfwSwapInterval(1);

    // NOTE: OpenGL error checks have been omitted for brevity

    GLuint vertex_buffer;
    glGenBuffers(1, &vertex_buffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    const GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertex_shader, 1, &vertex_shader_text, NULL);
    glCompileShader(vertex_shader);

    const GLuint fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragment_shader, 1, &fragment_shader_text, NULL);
    glCompileShader(fragment_shader);

    const GLuint program = glCreateProgram();
    glAttachShader(program, vertex_shader);
    glAttachShader(program, fragment_shader);
    glLinkProgram(program);

    const GLint mvp_location = glGetUniformLocation(program, "MVP");
    const GLint vpos_location = glGetAttribLocation(program, "vPos");
    const GLint vcol_location = glGetAttribLocation(program, "vCol");

    GLuint vertex_array;
    glGenVertexArrays(1, &vertex_array);
    glBindVertexArray(vertex_array);
    glEnableVertexAttribArray(vpos_location);
    glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE,
                          sizeof(Vertex), (void*) offsetof(Vertex, pos));
    glEnableVertexAttribArray(vcol_location);
    glVertexAttribPointer(vcol_location, 3, GL_FLOAT, GL_FALSE,
                          sizeof(Vertex), (void*) offsetof(Vertex, col));

    while (!glfwWindowShouldClose(window))
    {
        int width, height;
        glfwGetFramebufferSize(window, &width, &height);
        const float ratio = width / (float) height;

        glViewport(0, 0, width, height);
        glClear(GL_COLOR_BUFFER_BIT);

        mat4x4 m, p, mvp;
        mat4x4_identity(m);
        mat4x4_rotate_Z(m, m, (float) glfwGetTime());
        mat4x4_ortho(p, -ratio, ratio, -1.f, 1.f, 1.f, -1.f);
        mat4x4_mul(mvp, p, m);

        glUseProgram(program);
        glUniformMatrix4fv(mvp_location, 1, GL_FALSE, (const GLfloat*) &mvp);
        glBindVertexArray(vertex_array);
        glDrawArrays(GL_TRIANGLES, 0, 3);

        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwDestroyWindow(window);

    glfwTerminate();
    exit(EXIT_SUCCESS);
}

Code:

~/.../general/red_triangle >>> cat a00.asm                                                                                                                                                                                 
format elf64

include '../../glfw.inc'
include '../../glew.inc'

section '.text' executable

public main
extrn glfwInit
extrn glfwOpenWindowHint
extrn glfwOpenWindow
extrn glfwTerminate
extrn glfwSetWindowTitle
extrn glfwEnable
extrn glewInit
extrn glewExperimental
extrn glClearColor
extrn glClear
extrn glfwSwapBuffers
extrn glfwGetKey
extrn glfwGetWindowParam
extrn glGenVertexArrays
extrn glBindVertexArray
extrn glGenBuffers
extrn glBindBuffer
extrn glBufferData
extrn glUseProgram
extrn glEnableVertexAttribArray
extrn glDisableVertexAttribArray
extrn glVertexAttribPointer
extrn glDrawArrays
extrn glDeleteBuffers
extrn glDeleteVertexArrays
extrn glDeleteProgram

extrn fprintf
extrn stderr
extrn stdout

extrn loadShaders

main:
    push rbp
    mov rbp,rsp
    sub rsp,24
    vertexArrayID equ rbp-8
    programID equ rbp-16
    vertexBuffer equ rbp-24
    
    call glfwInit
    test rax,rax
    mov rsi,errmsg1
    jz error_exit

    mov rsi,4
    mov rdi,GLFW_FSAA_SAMPLES
    call glfwOpenWindowHint

    mov rsi,3
    mov rdi,GLFW_OPENGL_VERSION_MAJOR
    call glfwOpenWindowHint

    mov rsi,3
    mov rdi,GLFW_OPENGL_VERSION_MINOR
    call glfwOpenWindowHint

    mov rsi,GLFW_OPENGL_CORE_PROFILE
    mov rdi,GLFW_OPENGL_PROFILE
    call glfwOpenWindowHint

    sub rsp,3*8
    mov qword[rsp+8*2],GLFW_WINDOW
    mov qword[rsp+8*1],0
    mov qword[rsp+8*0],32
    xor r9,r9
    xor r8,r8
    xor rcx,rcx
    xor rdx,rdx
    mov rsi,768
    mov rdi,1024
    call glfwOpenWindow
    add rsp,3*8
    mov rsi,errmsg2
    jz error_exit

    mov byte[glewExperimental],GL_TRUE
    call glewInit
    cmp rax,GLEW_OK
    mov rsi,errmsg3
    jne error_exit

    mov rdi,title
    call glfwSetWindowTitle

    mov rdi,GLFW_STICKY_KEYS
    call glfwEnable
    
    mov eax,0.4f
    xorps xmm3,xmm3
    movd xmm2,eax
    xorps xmm1,xmm1
    xorps xmm0,xmm0
    call glClearColor

    lea rsi,[vertexArrayID]
    mov rdi,1
    call glGenVertexArrays
    mov rdi,[vertexArrayID]
    call glBindVertexArray

    lea rsi,[fragment_fname]
    lea rdi,[vertex_fname]
    call loadShaders
    mov [programID],rax
    
    lea rsi,[vertexBuffer]
    mov rdi,1
    call glGenBuffers
    mov rsi,[vertexBuffer]
    mov rdi,GL_ARRAY_BUFFER
    call glBindBuffer
    mov rcx,GL_STATIC_DRAW
    mov rdx,vertex_buffer_data
    mov rsi,12*4
    mov rdi,GL_ARRAY_BUFFER
    call glBufferData
.L0:
    mov rdi,GL_COLOR_BUFFER_BIT
    call glClear

    mov rdi,[programID]
    call glUseProgram

    mov rdi,0
    call glEnableVertexAttribArray

    mov rsi,[vertexBuffer]
    mov rdi,GL_ARRAY_BUFFER
    call glBindBuffer
    
    mov r9,0
    mov r8,0
    mov rcx,GL_FALSE
    mov rdx,GL_FLOAT
    mov rsi,3
    mov rdi,0
    call glVertexAttribPointer
    
    mov rdx,3
    mov rsi,0
    mov rdi,GL_TRIANGLES
    call glDrawArrays

    mov rdi,0
    call glDisableVertexAttribArray
    
    call glfwSwapBuffers

    mov rdi,GLFW_KEY_ESC
    call glfwGetKey
    cmp rax,GLFW_PRESS
    je .L1
    mov rdi,GLFW_OPENED
    call glfwGetWindowParam
    jnz .L0
.L1:
    call glfwTerminate
    
    lea rsi,[vertexBuffer]
    mov rdi,1
    call glDeleteBuffers
    
    lea rsi,[vertexArrayID]
    mov rdi,1
    call glDeleteVertexArrays

    mov rdi,[programID]
    call glDeleteProgram

    xor eax,eax    
    mov rsp,rbp
    pop rbp
    ret

error_exit:
    xor eax,eax
    mov rdi,[stderr]
    call fprintf
    mov rax,-1
    mov rsp,rbp
    pop rbp
    ret

section '.data' writeable
errmsg1 db 'Failed to initialize glfw library.',0xa,0
errmsg2 db 'Failed to open Window.',0xa,0
errmsg3 db 'Failed to initialize glew library.',0xa,0
title db 'First Triangle',0
vertex_fname db 'SimpleVertexShader.vertexshader',0
fragment_fname db 'SimpleFragmentShader.fragmentshader',0
align 4
vertex_buffer_data dd -1.0f, -1.0f, 0.0f
           dd  1.0f, -1.0f, 0.0f
           dd 0.0f,  1.0f, 0.0f