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 main(int argc,char **argv) {
        
        if(glfwInit()==GL_FALSE) {
                fprintf(stderr,"Failed to initialze GLFW");
                return -1;
        }
        
        glfwOpenWindowHint(GLFW_FSAA_SAMPLES,4);
        glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR,3);
        glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR,3);
        glfwOpenWindowHint(GLFW_OPENGL_PROFILE,GLFW_OPENGL_CORE_PROFILE);

        if(glfwOpenWindow(800,600,0,0,0,0,32,0,GLFW_WINDOW)==GL_FALSE) {
                fprintf(stderr,"Failed to open GLFW window");
                glfwTerminate();
                return -1;
        }

        glewExperimental = true;
        if(glewInit()!=GLEW_OK) {
                fprintf(stderr,"Failed to initialize Glew");
                glfwTerminate();
                return -1;
        }

        glfwSetWindowTitle("Simple Shader");

        glfwEnable(GLFW_STICKY_KEYS);

        glClearColor(0.0f,0.0f,0.4f,0.0f);

        // create vertex array object
        GLuint vertexArrayObj;
        glGenVertexArrays(1,&vertexArrayObj);
        glBindVertexArray(vertexArrayObj);

        // create vertex buffer object
        GLuint vertexBufferObj;
        glGenBuffers(1,&vertexBufferObj);
        glBindBuffer(GL_ARRAY_BUFFER,vertexBufferObj);
        glBufferData(GL_ARRAY_BUFFER,sizeof(gVertexBufferData),gVertexBufferData,GL_STATIC_DRAW);
        
        GLuint programID;
        if((programID=LoadShaders("SimpleVertexShader.vertexshader","SimpleFragmentShader.fragmentshader"))==0) {
                fprintf(stderr,"Error at LoadShader func");
                return -1;
        }

        do {
                glClear(GL_COLOR_BUFFER_BIT);
                
                glUseProgram(programID);

                glEnableVertexAttribArray(0);
                glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,0,0);
                glDrawArrays(GL_TRIANGLES,0,3);
                glDisableVertexAttribArray(0);

                glfwSwapBuffers();
        }
        while(glfwGetKey(GLFW_KEY_ESC)!=GLFW_PRESS && glfwGetWindowParam(GLFW_OPENED));


        glfwTerminate();

        glDeleteBuffers(1,&vertexBufferObj);
        glDeleteVertexArrays(1,&vertexArrayObj);

        return 0;
}

    

#ifndef LOADSHADERS
#define LOADSHADERS

extern GLuint LoadShaders(const 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 * ReadShaderFile(const char *fileName) {
        FILE *shaderStream = NULL;

        if((shaderStream = fopen(fileName,"r"))==NULL) {
                fprintf(stderr,"Can't open shader file");
                return NULL;
        }
        long int pos = ftell(shaderStream);
        fseek(shaderStream,pos,SEEK_END);
        long int len = ftell(shaderStream);
        fseek(shaderStream,pos,SEEK_SET);
        
        char *shaderCode = NULL;
        if((shaderCode = malloc(len*sizeof(char)))==NULL) {
                fprintf(stderr,"Can't allocate memory for the shader code");
                fclose(shaderStream);
                return NULL;
        }
        
        unsigned int i = 0;
        char c;
        while((c = (char)fgetc(shaderStream))!=EOF) {
                shaderCode[i] = c;
                i++;
        }
        shaderCode[i] = 0;
        
        fclose(shaderStream);

        return shaderCode;
}

GLuint LoadShaders(const char *vertexShaderFile,const char *fragmentShaderFile) {
        
        // read vertex shader
        char *vertexShaderCode = NULL;
        if((vertexShaderCode = (ReadShaderFile(vertexShaderFile)))==NULL) {
                fprintf(stderr,"Can't read vertex shader file");
                return 0;
        }

        // read fragment shader
        char *fragmentShaderCode = NULL;
        if((fragmentShaderCode = (ReadShaderFile(fragmentShaderFile)))==NULL) {
                fprintf(stderr,"Can't read fragment shader file");
                return 0;
        }
        
        char const *vertexPtr = vertexShaderCode;
        // compile vertex shader
        printf("Compiling shader : %s\n",vertexShaderFile);
        GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
        glShaderSource(vertexShaderID,1,&vertexPtr,NULL);
        glCompileShader(vertexShaderID);
        
        GLint result = GL_FALSE;
        // check vertex shader
        glGetShaderiv(vertexShaderID,GL_COMPILE_STATUS,&result);
        if(result==GL_FALSE) {
                fprintf(stderr,"Error compiling vertex shader\n");
                free(vertexShaderCode);
                return 0;
        }
        
        char const *fragmentPtr = fragmentShaderCode;
        // compile fragment shader
        printf("Compiling shader : %s\n",fragmentShaderFile);
        GLuint fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
        glShaderSource(fragmentShaderID,1,&fragmentPtr,NULL);
        glCompileShader(fragmentShaderID);

        // check fragment shader
        glGetShaderiv(fragmentShaderID,GL_COMPILE_STATUS,&result);
        if(result==GL_FALSE) {
                fprintf(stderr,"Error compiling fragment shader\n");
                free(fragmentShaderCode);
                return 0;
        }

        // linking program
        printf("Linking program\n");
        GLuint programID = glCreateProgram();
        glAttachShader(programID,vertexShaderID);
        glAttachShader(programID,fragmentShaderID);
        glLinkProgram(programID);
    
        // check program
        glGetProgramiv(programID,GL_LINK_STATUS,&result);
        if(result==GL_FALSE) {
                fprintf(stderr,"Error linkinig shaders\n");
                free(vertexShaderCode);
                free(fragmentShaderCode);
                glDeleteShader(vertexShaderID);
                glDeleteShader(fragmentShaderID);
                return 0;
        }
        
        free(vertexShaderCode);
        free(fragmentShaderCode);

        glDeleteShader(vertexShaderID);
        glDeleteShader(fragmentShaderID);
        
        return programID;
}

    

#version 330 core

// Input vertex data
layout(location = 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 = vec3(1,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 = vec4(0.0,0.0,1.0,1.0); }  ',0   
  align 8 
  _fshader_ptr dq _fshader