glonkers/renderer.c

#define GL_GLEXT_PROTOTYPES
#include <stdio.h>
#include <string.h>
#include <GL/gl.h>
#include <stdlib.h>
#include "renderer.h"
#include "stb_image.h"


/// returns 0 if failed.
GLuint compile_shader(GLuint type, const char *src) {
    GLuint id = glCreateShader(type);
    glShaderSource(id, 1, &src, 0);
    glCompileShader(id);

    int result;
    glGetShaderiv(id, GL_COMPILE_STATUS, &result);
    if (result == GL_FALSE) {
        int length;
        glGetShaderiv(id, GL_INFO_LOG_LENGTH, &result);
        char *message = alloca(length * sizeof(char));
        glGetShaderInfoLog(id, length, &length, message);
        fprintf(stderr, "failed to compile %s shader\n", type == GL_VERTEX_SHADER ? "vertex" : "fragment");
        fprintf(stderr, "%s\n", message);
        glDeleteShader(id);
        return 0;
    }

    return id;
}

const char *vertex_shader_src =
"#version 300 es\n"
"\n"
"layout(location = 0) in vec2 aPos;\n"
"\n"
"void main() {\n"
"    gl_Position = vec4(aPos, 0.0, 1.0);\n"
"}\n";

const char *fragment_header_src = 
"#version 300 es\n"
"precision highp float;\n"
"precision highp int;\n"
"precision lowp sampler2D;\n"
"precision lowp samplerCube;\n"
"layout(location = 0) out vec4 color;\n"
"uniform vec2 iResolution;\n"
"uniform float iTime;\n"
"uniform int iFrame;\n"
"uniform sampler2D iChannel0;\n"
"uniform sampler2D iChannel1;\n"
"uniform sampler2D iChannel2;\n"
"uniform sampler2D iChannel3;\n"
"void mainImage(out vec4 fragColor, in vec2 fragCoord);\n"
"void main() {\n"
"   mainImage(color, gl_FragCoord.xy);\n"
"}\n"
"\n";

/// returns 0 if failed.
GLuint create_shader(const char *fragment_src) {
    GLuint program = glCreateProgram();
    GLuint vertex_shader = compile_shader(GL_VERTEX_SHADER, vertex_shader_src);
    GLuint fragment_shader = compile_shader(GL_FRAGMENT_SHADER, fragment_src);
    if (!((fragment_shader == 0) || (vertex_shader == 0))) {
        glAttachShader(program, vertex_shader);
        glAttachShader(program, fragment_shader);
        glLinkProgram(program);
        glValidateProgram(program);
        glDeleteShader(vertex_shader);
        glDeleteShader(fragment_shader);
        return program;
    } else {
        return 0;
    }
}

GLuint load_shader(const char *path) {
    FILE *handle = fopen(path, "r");
    if (handle == NULL) {
        fprintf(stderr, "failed to open shader file: '%s'\n", path);
        exit(1);
    }

    fseek(handle, 0L, SEEK_END);
    long file_length = ftell(handle);
    fseek(handle, 0L, SEEK_SET);

    long header_length = strlen(fragment_header_src);
    long length = header_length + file_length;

    char *string = malloc((length + 1) * sizeof(char));

    // Copy header.
    strcpy(string, fragment_header_src);

    if (!fread(string + header_length, sizeof(char), file_length, handle)) {
        fprintf(stderr, "failed to read shader file\n");
        exit(1);
    }

    // I love C
    string[length] = '\0';
    fclose(handle);

    GLuint shader = create_shader(string);

    //if (shader == 0) {
    //    // print file
    //    int line_count = 1;
    //    printf("%i\t", line_count);
    //    line_count++;
    //    for (int i = 0; i < length; i++) {
    //        printf("%c", string[i]);
    //        if (string[i] == '\n') {
    //            printf("%i\t", line_count);
    //            line_count++;
    //        }
    //    }
    //    printf("\n");
    //}

    free(string);
    return shader;
}

Renderer new_renderer(char **textures, int texture_count) {
    const char *version_str = (const char *)glGetString(GL_VERSION);
    const char *renderer_str = (const char *)glGetString(GL_RENDERER);

    glEnable(GL_DEPTH_TEST);

    // buffers
    // Load the vertex data
    GLfloat vertices[] = {
        -1.0, 1.0,
        -1.0, -1.0,
        1.0, -1.0,

        1.0, -1.0,
        1.0, 1.0,
        -1.0, 1.0,
    };
    GLuint vao, vbo;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER,
                 sizeof(vertices),
                 vertices,
                 GL_STATIC_DRAW);
    
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(
        0,              // location
        2,              // vec2
        GL_FLOAT,
        GL_FALSE,
        0,
        (void *)0
    );

    Renderer renderer;
    renderer.texture_count = texture_count;

    // textures
    for (int i = 0; i < texture_count; i++) {
        glGenTextures(1, &renderer.textures[i]);
        glBindTexture(GL_TEXTURE_2D, renderer.textures[i]);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        int width, height, nr_channels;
        unsigned char *data = stbi_load(textures[i], &width, &height, &nr_channels, 0);
        if (data) {
            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
            glGenerateMipmap(GL_TEXTURE_2D);
        }
        else {
            fprintf(stderr, "failed to load texture %d\n", i);
        }
        stbi_image_free(data);
    }

    renderer.shader_path = "";
    renderer.shader = 0;
    renderer.vao = vao;
    renderer.frame_nr = 0;
    return renderer;
}

int shader_file_was_modified(Renderer *state) {
    struct stat buf;
    stat(state->shader_path, &buf);
    int modified = buf.st_mtime != state->shader_file_modified.st_mtime;
    if (modified) {
        state->shader_file_modified = buf;
    }
    return modified;
}

/// shader_path cannot be NULL.
void render(Renderer *state, int w, int h, double time, char *shader_path, int reload_shader) {
    int m = shader_file_was_modified(state);
    if (m || reload_shader || strcmp(state->shader_path, shader_path)) {
        state->shader = load_shader(shader_path);
        state->shader_path = shader_path;
    }

    state->frame_nr++;

    // Rendorrrr
    glViewport(0, 0, w, h);

    glClearColor(0.8f, 0.3f, 0.3f, 1.0f);  // Dark gray background
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // Shader parameters.
    glUseProgram(state->shader);

    // Bind texture
    for (int i = 0; i < state->texture_count; i++) {
        switch (i) {
            case 0:
                glActiveTexture(GL_TEXTURE0);
                glBindTexture(GL_TEXTURE_2D, state->textures[i]);
                glUniform1i(glGetUniformLocation(state->shader, "iChannel0"), i);
                break;
            case 1:
                glActiveTexture(GL_TEXTURE1);
                glBindTexture(GL_TEXTURE_2D, state->textures[i]);
                glUniform1i(glGetUniformLocation(state->shader, "iChannel1"), i);
                break;
            case 2:
                glActiveTexture(GL_TEXTURE2);
                glBindTexture(GL_TEXTURE_2D, state->textures[i]);
                glUniform1i(glGetUniformLocation(state->shader, "iChannel2"), i);
                break;
            case 3:
                glActiveTexture(GL_TEXTURE3);
                glBindTexture(GL_TEXTURE_2D, state->textures[i]);
                glUniform1i(glGetUniformLocation(state->shader, "iChannel3"), i);
                break;
            default:
                fprintf(stderr, "texture index > 3 not allowed\n");
                exit(1);
                break;
        }
    }

    int uniform_iResolution = glGetUniformLocation(state->shader, "iResolution");
    glUniform2f(uniform_iResolution, w, h);

    int uniform_iTime = glGetUniformLocation(state->shader, "iTime");
    glUniform1f(uniform_iTime, (float)time);

    int uniform_iFrame = glGetUniformLocation(state->shader, "iFrame");
    glUniform1i(uniform_iFrame, state->frame_nr);

    glBindVertexArray(state->vao);
    glDrawArrays(GL_TRIANGLES, 0, 6);
}