nimrod opengl test

import glfw
import opengl
import strutils
import typeinfo

## -------------------------------------------------------------------------------

var
    running : bool = true
    frameCount: int = 0
    lastTime: float = 0.0
    lastFPSTime: float = 0.0
    currentTime: float = 0.0
    frameRate: int = 0
    frameDelta: float = 0.0

    windowW: int = 640
    windowH: int = 480

    vshaderID: int
    fshaderID: int
    shaderProg: int

    vertexPosAttrLoc: int

    pMatrixUniLoc: int
    mvMatrixUniLoc: int

    mvMatrix: array[0..15, float32] = [1.0'f32, 0.0'f32, 0.0'f32, 0.0'f32, 0.0'f32, 1.0'f32, 0.0'f32, 0.0'f32, 0.0'f32, 0.0'f32, 1.0'f32, 0.0'f32, 0.0'f32, 0.0'f32, 0.0'f32, 1.0'f32]
    pMatrix: array[0..15, float32]  = [1.0'f32, 0.0'f32, 0.0'f32, 0.0'f32, 0.0'f32, 1.0'f32, 0.0'f32, 0.0'f32, 0.0'f32, 0.0'f32, 1.0'f32, 0.0'f32, 0.0'f32, 0.0'f32, 0.0'f32, 1.0'f32]

    vbo: int

type
    ShaderType = enum
        VertexShader,
        FragmentShader


## -------------------------------------------------------------------------------

proc GenOrthoMatrix(width: int, height: int, matrix: var array[0..15, float32]) =

    matrix[0] = 2.0 / float(width)
    matrix[1] = 0.0
    matrix[2] = 0.0
    matrix[3] = 0.0

    matrix[4] = 0.0
    matrix[5] = 2.0 / float(-height)
    matrix[6] = 0.0
    matrix[7] = 0.0

    matrix[8] = 0.0
    matrix[9] = 0.0
    matrix[10] = -1.0
    matrix[11] = 0.0

    matrix[12] = -1.0
    matrix[13] = 1.0
    matrix[14] = 0.0
    matrix[15] = 1.0





proc Resize(width: int, height: int) =

    glViewport(0, 0, width, height)

    GenOrthoMatrix(width, height, pMatrix)




## -------------------------------------------------------------------------------

proc LoadShader(shaderType: ShaderType, file: string ): int =



    if shaderType == VertexShader:
        result = glCreateShader(GL_VERTEX_SHADER)

    else:
        result = glCreateShader(GL_FRAGMENT_SHADER)


    var shaderSrc = readFile(file)

    var shader = result

    var stringArray = allocCStringArray([shaderSrc])

    glShaderSource(shader, 1 , stringArray, nil)

    deallocCStringArray(stringArray)

    glCompileShader(shader)

    var compileResult = -1

    glGetShaderiv(shader, GL_COMPILE_STATUS, addr(compileResult))

    if compileResult != GL_TRUE:
        result = -1

## ---------------------------------------------------------------------


proc InitializeGL() =


    glClearColor(0.1,0.1,0.1,1.0)
    glClearDepth(1.0)
    glEnable(GL_BLEND)
    glDisable(GL_DEPTH_TEST)


## ---------------------------------------------------------------------

proc InitializeShaders() =

    vshaderID = LoadShader(ShaderType.VertexShader, "vertexshader.vert")
    fshaderID = LoadShader(ShaderType.FragmentShader, "fragshader.frag")

    if vshaderID == -1 or fshaderID == -1:
        quit("Error compiling shaders!")

    shaderProg = glCreateProgram()

    glAttachShader(shaderProg, vshaderID)
    glAttachShader(shaderProg, fshaderID)

    glLinkProgram(shaderProg)

    var linkStatus = -1

    glGetProgramiv(shaderProg, GL_LINK_STATUS, addr(linkStatus))

    if linkStatus != GL_TRUE:
        quit("Error linking shader program!")

    glUseProgram(shaderProg)

    vertexPosAttrLoc = glGetAttribLocation(shaderProg, "aVertexPosition")

    glEnableVertexAttribArray(vertexPosAttrLoc)

    pMatrixUniLoc = glGetUniformLocation(shaderProg, "uPMatrix")
    mvMatrixUniLoc = glGetUniformLocation(shaderProg, "uMVMatrix")


## -----------------------------------------------------------------------------

proc InitializeBuffers() =

    glGenBuffers(1, addr(vbo))

    glBindBuffer(GL_ARRAY_BUFFER, vbo)

    var vertices = [0.0, 1.0, 0.0, -1.0, -1.0, 0.0, 1.0, -1.0, 0.0]

    glBufferData(GL_ARRAY_BUFFER, sizeof(GL_FLOAT) * vertices.len, addr(vertices[0]), GL_STATIC_DRAW)


## -------------------------------------------------------------------------------

proc SetMatrixUniforms() =
    glUniformMatrix4fv(pMatrixUniLoc, 16, false, addr(pMatrix[0]))
    glUniformMatrix4fv(mvMatrixUniLoc, 16, false, addr(mvMatrix[0]))



## -------------------------------------------------------------------------------

proc Initialize() =

    if Init() == 0:
        write(stdout, "Could not initialize GLFW! \n")

    OpenWindowHint(GLFW_WINDOW_NO_RESIZE, GL_TRUE)

    if OpenWindow(cint(windowW), cint(windowH), 0, 0, 0, 0, 0, 0, GLFW_WINDOW) == 0:
        Terminate()


    SwapInterval(0)

    openglInit()

    InitializeGL()


    Resize(windowW, windowH)

    lastTime = GetTime()
    lastFPSTime = lastTime



    InitializeShaders()

    InitializeBuffers()



## -------------------------------------------------------------------------------
proc Update() =

    currentTime = GetTime()

    frameDelta = currentTime - lastTime

    lastTime = currentTime






## --------------------------------------------------------------------------------

proc Render() =

    glClear(GL_COLOR_BUFFER_BIT)

    glBindBuffer(GL_ARRAY_BUFFER, vbo)

    glVertexAttribPointer(vertexPosAttrLoc, 3, cGL_FLOAT, false, 0, nil)

    SetMatrixUniforms()

    glDrawArrays(GL_TRIANGLES, 0, 3)

    SwapBuffers()



## --------------------------------------------------------------------------------

proc Run() =

    while running:

        Update()

        Render()

        running = GetKey(GLFW_KEY_ESC) == GLFW_RELEASE and
                  GetWindowParam(GLFW_OPENED) == GL_TRUE


## ==============================================================================



Initialize()

Run()

Terminate()