main.kai

#library "libc"
#import github("vdka/gl")
#import github("vdka/glfw")
#import github("kai-language/stdlib")

#foreign libc {
    printf :: (fmt: *u8, args: #cvargs ..any) -> i32

    exit :: (exitcode: i32) -> void
}


panic :: fn(msg: string) -> void {
    printf(msg.raw)
    exit(1)
}

//glfwErrorCallback :: fn(error: i32, desc: *u8) -> void {
//    printf("Error code %d:\n\t%s\n", error, desc)
//}

initGlfw :: fn() -> *glfw.Window, bool {
    //glfw.SetErrorCallback(&glfwErrorCallback)

    if glfw.Init() == 0 {
        return nil, false
    }

    glfw.WindowHint(glfw.SAMPLES, 4)
    glfw.WindowHint(glfw.CONTEXT_VERSION_MAJOR, 3)
    glfw.WindowHint(glfw.CONTEXT_VERSION_MINOR, 3)
    glfw.WindowHint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
    glfw.WindowHint(glfw.OPENGL_FORWARD_COMPAT, 1)

    window := glfw.CreateWindow(1280, 720, "Kai GLFW example".raw, nil, nil)
    if window == nil {
        panic("Asdfklasjdf")
        return nil, false
    }

    glfw.MakeContextCurrent(window)

    return window, true
}

loadShaders :: fn() -> u32 {
    vertex_shader_source := "
        #version 330 core

        layout(location = 0) in vec3 vertexPosition;

        uniform mat4 MVP;

        out vec3 pos;

        void main() {
            gl_Position = MVP * vec4(vertexPosition, 1.0);
            pos = vertexPosition.xyz;
        }
    "
    fragment_shader_source := "
        #version 330 core

        in vec3 pos;
        out vec4 color;

        uniform float time;
    
        void main() {
            
            color = vec4(pos.xy, 0.5 + 0.5 * sin(time), 1.0);
        }
    "

    vertex_shader_length := cast(i32) vertex_shader_source.len
    fragment_shader_length := cast(i32) fragment_shader_source.len

    vertex_shader_id := gl.CreateShader(gl.VERTEX_SHADER)
    fragment_shader_id := gl.CreateShader(gl.FRAGMENT_SHADER)

    gl.ShaderSource(vertex_shader_id, 1, &vertex_shader_source.raw, &vertex_shader_length)
    gl.ShaderSource(fragment_shader_id, 1, &fragment_shader_source.raw, &fragment_shader_length)

    gl.CompileShader(vertex_shader_id)
    gl.CompileShader(fragment_shader_id)

    program := gl.CreateProgram()
    gl.AttachShader(program, vertex_shader_id)
    gl.AttachShader(program, fragment_shader_id)
    gl.LinkProgram(program)

    gl.DeleteShader(vertex_shader_id)
    gl.DeleteShader(fragment_shader_id)

    return program
}

createBuffers :: fn() -> u32, u32, u32 {
    vao: u32
    gl.GenVertexArrays(1, &vao)
    gl.BindVertexArray(vao)

    // a 2x2x2 cube, using triangle strips and indices
    cubeVertices := [..]f32 {
        -1.0, -1.0,  1.0,
         1.0, -1.0,  1.0,
        -1.0,  1.0,  1.0,
         1.0,  1.0,  1.0,
        -1.0, -1.0, -1.0,
         1.0, -1.0, -1.0,
        -1.0,  1.0, -1.0,
         1.0,  1.0, -1.0,
    }

    cubeIndices := [..]u16{
        // TRIANGLE_STRIP, 14 indices = 12 triangles
        0, 1, 2, 3, 7, 1, 5, 4, 7, 6, 2, 4, 0, 1,
    }

    vbo: u32
    gl.GenBuffers(1, &vbo)
    gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
    gl.BufferData(gl.ARRAY_BUFFER, 96, cast(rawptr) &cubeVertices[0], gl.STATIC_DRAW)

    gl.EnableVertexAttribArray(0)
    gl.VertexAttribPointer(0, 3, gl.FLOAT, gl.FALSE, 0, nil)

    ebo: u32
    gl.GenBuffers(1, &ebo)
    gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, ebo)
    gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, 28, cast(rawptr) &cubeIndices[0], gl.STATIC_DRAW)

    return vao, vbo, ebo
}

main :: fn () -> void {
    window, success := initGlfw()
    if !success
        panic("Error with window creation!\n")

    gl.init(cast((*u8) -> rawptr) glfw.GetProcAddress)

    program := loadShaders()

    vao, vbo, ebo := createBuffers()

    // timings
    tPrev := glfw.GetTime()
    frame := 0

    res := [2]f32{1280, 720}

    p := stdlib.perspective(0.785, 1.77, 0.1, 100.0)

    pos := [vec 3]f32 { 4, 3, 3 }
    lookPos := [vec 3]f32 { 0, 0, 0 }
    up := [vec 3]f32 { 0, 1, 0 }

    v := stdlib.look_at(pos, lookPos, up)

    m := stdlib.identity_mat() 

    gl.Enable(gl.DEPTH_TEST);
    gl.ClearColor(0.2, 0.3, 0.4, 1.0);
    for glfw.WindowShouldClose(window) == glfw.FALSE {

        tNow := glfw.GetTime()
        dt := cast(f32) (tNow - tPrev)
        tPrev = tNow

        glfw.PollEvents()

        if glfw.GetKey(window, glfw.KEY_ESCAPE) == glfw.TRUE
            break
        
        MV  := stdlib.mul(v, m)
        MVP := stdlib.mul(p, MV)
 
        // Drawing
        gl.Clear(cast(u32) gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);

        gl.UseProgram(program)
        gl.UniformMatrix4fv(gl.GetUniformLocation(program, "MVP".raw), 1, gl.FALSE, &MVP[0][0])
        gl.Uniform1f(gl.GetUniformLocation(program, "time".raw), cast(f32) glfw.GetTime())
        //gl.Uniform2f(gl.GetUniformLocation(program, "resolution".raw), 1280, 720)

        gl.BindVertexArray(vao)
        gl.DrawElements(gl.TRIANGLE_STRIP, 14, gl.UNSIGNED_SHORT, nil)

        glfw.SwapBuffers(window)
    }
    glfw.Terminate()
    printf("Exiting!\n".raw)
}