src/glcontext.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * Copyright 2023 Mike Becker. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include "ascension/glcontext.h"
#include "ascension/error.h"

#include <cx/printf.h>

#include <GL/glew.h>

static void asc_gl_debug_callback(
        GLenum source, GLenum type, GLuint id, GLenum severity,
        GLsizei length, const GLchar* message,
        const void* userParam
) {
    cxmutstr buf = cx_asprintf(
            "source = %d, id = %u, type = %d, severity= %d, message = %.*s",
            source, id, type, severity, length, message);
    if (type == GL_DEBUG_TYPE_ERROR) {
        asc_error(buf.ptr);
    } else {
        asc_dprintf("GL debug: %.*s", (int)buf.length, buf.ptr);
    }
    cx_strfree(&buf);
}

static int asc_primitives_init(AscGLContext *context) {
    asc_dprintf("Create primitives for the GL context of active window.");
    asc_mesh_allocate_buffers(context->primitives, ASC_PRIMITIVE_COUNT);

    asc_primitives_init_plane(&context->primitives[ASC_PRIMITIVE_PLANE_IDX]);
    // TODO: more primitives

    return asc_error_catch_all_gl();
}

static void asc_primitives_destroy(AscGLContext *context) {
    asc_dprintf("Destroy primitives in GL context of active window.");
    asc_mesh_free_buffers((AscMesh*)&context->primitives, sizeof(context->primitives) / sizeof(AscMesh));
}

static int asc_shader_initialize_predefined(AscGLContext *ctx) {
    int ret = 0;
    ret |= asc_shader_sprite_init(&ctx->shader.sprite);
    ret |= asc_error_catch_all_gl();
    return ret;
}

static void asc_shader_destroy_predefined(AscGLContext *ctx) {
    asc_shader_program_destroy(&ctx->shader.sprite.program);
}

static int asc_texture_initialize_predefined(AscGLContext *ctx) {
    asc_texture_init_rectangle(ctx->textures_rect, ASC_TEXTURE_RECT_COUNT);
    asc_texture_init_2d(ctx->textures_2d, ASC_TEXTURE_2D_COUNT);

    // Create a 1x1 surface with 32-bit RGBA format
    SDL_Surface* white1x1 = SDL_CreateRGBSurface(
        0, 1, 1, 32,
        0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF);
    if (white1x1 == NULL) {
        // TODO: merge error messages once asc_error allows formatting
        asc_error("Failed to create surface");
        asc_error(SDL_GetError());
        return 1;
    }
    SDL_FillRect(white1x1, NULL, 0xFFFFFFFF);

    // Initialize the empty textures with the white surface
    asc_texture_from_surface(&ctx->textures_rect[ASC_TEXTURE_RECT_EMPTY_1X1_IDX], white1x1);
    asc_texture_from_surface(&ctx->textures_2d[ASC_TEXTURE_2D_EMPTY_1X1_IDX], white1x1);

    return asc_error_catch_all_gl();
}

static void asc_texture_destroy_predefined(AscGLContext *ctx) {
    asc_texture_destroy(ctx->textures_rect, ASC_TEXTURE_RECT_COUNT);
    asc_texture_destroy(ctx->textures_2d, ASC_TEXTURE_2D_COUNT);
}

bool asc_gl_context_initialize(
        AscGLContext *ctx,
        SDL_Window *window,
        AscGLContextSettings const *settings
) {
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, settings->gl_major_version);
    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, settings->gl_minor_version);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, settings->depth_size);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
    ctx->glctx = SDL_GL_CreateContext(window);
    if (ctx->glctx == NULL) return false;
    ctx->window = window;

    glewExperimental = GL_TRUE;
    GLenum err = glewInit();
    if (err == GLEW_OK) {
        SDL_GL_SetSwapInterval(settings->vsync);

        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        glEnable(GL_DEBUG_OUTPUT);
        glDebugMessageCallback(asc_gl_debug_callback, NULL);

        if (asc_primitives_init(ctx)) {
            asc_error("Creating primitive meshes failed");
            SDL_GL_DeleteContext(ctx->glctx);
            return false;
        }

        if (asc_shader_initialize_predefined(ctx)) {
            asc_error("Initializing predefined shaders failed");
            SDL_GL_DeleteContext(ctx->glctx);
            return false;
        }

        if (asc_texture_initialize_predefined(ctx)) {
            asc_error("Initializing predefined textures failed");
            return false;
        }

        return true;
    } else {
        asc_error(glewGetErrorString(err));
        SDL_GL_DeleteContext(ctx->glctx);
        return false;
    }
}

void asc_gl_context_destroy(AscGLContext *ctx) {
    if (ctx->glctx == NULL) return;
    SDL_GL_MakeCurrent(ctx->window, ctx->glctx);

    asc_texture_destroy_predefined(ctx);
    asc_shader_destroy_predefined(ctx);
    asc_primitives_destroy(ctx);

    // destroy the GL context and the window
    SDL_GL_DeleteContext(ctx->glctx);
    ctx->glctx = NULL;
}