Quote:

OpenGL is taught in the schools because it also works on Linux.

No, it is because OpenGL is decent (unlike DirectX). And secondly, also works on many other systems (unlike DirectX).

I suggest to search for GLSL and demo scene. All the other bits you assume yourself. No offense is meant to anyone.

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

#include <GL/glew.h>
#include <GL/glfw.h>

#include "load_shaders.h"

static const float gVertexBufferData = 
        -1.0f,-1.0f,0.0f,
         1.0f,-1.0f,0.0f,
         0.0f, 1.0f,0.0f
;

int mainint argc,char **argv 
        
        ifglfwInit==GL_FALSE 
                fprintfstderr,"Failed to initialze GLFW";
                return -1;
        
        
        glfwOpenWindowHintGLFW_FSAA_SAMPLES,4;
        glfwOpenWindowHintGLFW_OPENGL_VERSION_MAJOR,3;
        glfwOpenWindowHintGLFW_OPENGL_VERSION_MINOR,3;
        glfwOpenWindowHintGLFW_OPENGL_PROFILE,GLFW_OPENGL_CORE_PROFILE;

        ifglfwOpenWindow800,600,0,0,0,0,32,0,GLFW_WINDOW==GL_FALSE 
                fprintfstderr,"Failed to open GLFW window";
                glfwTerminate;
                return -1;
        

        glewExperimental = true;
        ifglewInit!=GLEW_OK 
                fprintfstderr,"Failed to initialize Glew";
                glfwTerminate;
                return -1;
        

        glfwSetWindowTitle"Simple Shader";

        glfwEnableGLFW_STICKY_KEYS;

        glClearColor0.0f,0.0f,0.4f,0.0f;

        // create vertex array object
        GLuint vertexArrayObj;
        glGenVertexArrays1,&vertexArrayObj;
        glBindVertexArrayvertexArrayObj;

        // create vertex buffer object
        GLuint vertexBufferObj;
        glGenBuffers1,&vertexBufferObj;
        glBindBufferGL_ARRAY_BUFFER,vertexBufferObj;
        glBufferDataGL_ARRAY_BUFFER,sizeofgVertexBufferData,gVertexBufferData,GL_STATIC_DRAW;
        
        GLuint programID;
        ifprogramID=LoadShaders"SimpleVertexShader.vertexshader","SimpleFragmentShader.fragmentshader"==0 
                fprintfstderr,"Error at LoadShader func";
                return -1;
        

        do 
                glClearGL_COLOR_BUFFER_BIT;
                
                glUseProgramprogramID;

                glEnableVertexAttribArray0;
                glVertexAttribPointer0,3,GL_FLOAT,GL_FALSE,0,0;
                glDrawArraysGL_TRIANGLES,0,3;
                glDisableVertexAttribArray0;

                glfwSwapBuffers;
        
        whileglfwGetKeyGLFW_KEY_ESC!=GLFW_PRESS && glfwGetWindowParamGLFW_OPENED;


        glfwTerminate;

        glDeleteBuffers1,&vertexBufferObj;
        glDeleteVertexArrays1,&vertexArrayObj;

        return 0;


    

#ifndef LOADSHADERS
#define LOADSHADERS

extern GLuint LoadShadersconst char *vertexShaderFile,const char *fragmentShaderFile;

#endif

    

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

#include <GL/glew.h>
#include <GL/glfw.h>

#include "load_shaders.h"

static char * ReadShaderFileconst char *fileName 
        FILE *shaderStream = NULL;

        ifshaderStream = fopenfileName,"r"==NULL 
                fprintfstderr,"Can't open shader file";
                return NULL;
        
        long int pos = ftellshaderStream;
        fseekshaderStream,pos,SEEK_END;
        long int len = ftellshaderStream;
        fseekshaderStream,pos,SEEK_SET;
        
        char *shaderCode = NULL;
        ifshaderCode = malloclen*sizeofchar==NULL 
                fprintfstderr,"Can't allocate memory for the shader code";
                fcloseshaderStream;
                return NULL;
        
        
        unsigned int i = 0;
        char c;
        whilec = charfgetcshaderStream!=EOF 
                shaderCodei = c;
                i++;
        
        shaderCodei = 0;
        
        fcloseshaderStream;

        return shaderCode;


GLuint LoadShadersconst char *vertexShaderFile,const char *fragmentShaderFile 
        
        // read vertex shader
        char *vertexShaderCode = NULL;
        ifvertexShaderCode = ReadShaderFilevertexShaderFile==NULL 
                fprintfstderr,"Can't read vertex shader file";
                return 0;
        

        // read fragment shader
        char *fragmentShaderCode = NULL;
        iffragmentShaderCode = ReadShaderFilefragmentShaderFile==NULL 
                fprintfstderr,"Can't read fragment shader file";
                return 0;
        
        
        char const *vertexPtr = vertexShaderCode;
        // compile vertex shader
        printf"Compiling shader  %s\n",vertexShaderFile;
        GLuint vertexShaderID = glCreateShaderGL_VERTEX_SHADER;
        glShaderSourcevertexShaderID,1,&vertexPtr,NULL;
        glCompileShadervertexShaderID;
        
        GLint result = GL_FALSE;
        // check vertex shader
        glGetShaderivvertexShaderID,GL_COMPILE_STATUS,&result;
        ifresult==GL_FALSE 
                fprintfstderr,"Error compiling vertex shader\n";
                freevertexShaderCode;
                return 0;
        
        
        char const *fragmentPtr = fragmentShaderCode;
        // compile fragment shader
        printf"Compiling shader  %s\n",fragmentShaderFile;
        GLuint fragmentShaderID = glCreateShaderGL_FRAGMENT_SHADER;
        glShaderSourcefragmentShaderID,1,&fragmentPtr,NULL;
        glCompileShaderfragmentShaderID;

        // check fragment shader
        glGetShaderivfragmentShaderID,GL_COMPILE_STATUS,&result;
        ifresult==GL_FALSE 
                fprintfstderr,"Error compiling fragment shader\n";
                freefragmentShaderCode;
                return 0;
        

        // linking program
        printf"Linking program\n";
        GLuint programID = glCreateProgram;
        glAttachShaderprogramID,vertexShaderID;
        glAttachShaderprogramID,fragmentShaderID;
        glLinkProgramprogramID;
    
        // check program
        glGetProgramivprogramID,GL_LINK_STATUS,&result;
        ifresult==GL_FALSE 
                fprintfstderr,"Error linkinig shaders\n";
                freevertexShaderCode;
                freefragmentShaderCode;
                glDeleteShadervertexShaderID;
                glDeleteShaderfragmentShaderID;
                return 0;
        
        
        freevertexShaderCode;
        freefragmentShaderCode;

        glDeleteShadervertexShaderID;
        glDeleteShaderfragmentShaderID;
        
        return programID;


    

#version 330 core

// Input vertex data
layoutlocation = 0 in vec3 vertexPosition_modelspace;

void main

    gl_Position.xyz = vertexPosition_modelspace;
    gl_Position.w = 1.0;



    

#version 330 core

// Ouput data
out vec3 color;

void main


        // Output color = red 
        color = vec31,0,0;



    

invoke glCompileShader,vs
invoke glAttachShader,prg,vs
invoke glLinkProgram,prg
invoke glUseProgram,prg 
    

invoke glCompileShader,vs
invoke glAttachShader,prg,vs
invoke glLinkProgram,prg
invoke glUseProgram,prg
    

invoke wglGetProcAddress,"glCreateShader"
mov glCreateShader,rax
invoke wglGetProcAddress,"glCreateProgram"
mov glCreateProgram,rax
invoke wglGetProcAddress,"glShaderSource"
mov glShaderSource,rax
invoke wglGetProcAddress,"glCompileShader"
mov glCompileShader,rax
invoke wglGetProcAddress,"glAttachShader" 
mov glAttachShader,rax
invoke wglGetProcAddress,"glLinkProgram" 
mov glLinkProgram,rax
invoke wglGetProcAddress,"glUseProgram"
mov glUseProgram,rax



invoke glCreateShader, GL_FRAGMENT_SHADER
mov vs,rax
invoke glCreateProgram
mov prg,rax
invoke glShaderSource,vs,1,_fshader_ptr,0
invoke glCompileShader,vs
invoke glAttachShader,prg,vs
invoke glLinkProgram,prg
invoke glUseProgram,prg

...


glGenBuffers dq ?
glCreateShader dq ?
glCreateProgram dq ?
glShaderSource dq ?
glCompileShader dq ?
glAttachShader dq ?
glLinkProgram dq ?
glUseProgram dq ?
vs dq ?
prg dq ?


  align 1
  _fshader db 'void main gl_FragColor = vec40.0,0.0,1.0,1.0;   ',0   
  align 8 
  _fshader_ptr dq _fshader