Mercurial > hg > ascension / file revision

/*
 * 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/core.h"
#include "ascension/utils.h"

#include <cx/linked_list.h>
#include <cx/printf.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);
}

AscContext asc_context;

// forward declarations
static void asc_window_destroy_impl(AscWindow* window);

void asc_context_initialize(void) {
    if (asc_test_flag(asc_context.flags, ASC_FLAG_INITILIZED))
        return;
    asc_clear_flag(&asc_context.flags, ASC_FLAG_HAS_ERROR);

    // initialize error buffer
    cxBufferInit(
            &asc_context.error_buffer,
            NULL,
            256,
            NULL,
            CX_BUFFER_AUTO_EXTEND
    );

    // initialize lists
    asc_context.windows = cxLinkedListCreateSimple(CX_STORE_POINTERS);
    asc_context.windows->simple_destructor =
            (cx_destructor_func)asc_window_destroy_impl;

    // initialize SDL
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        asc_error(SDL_GetError());
    } else {
        if (TTF_Init() < 0) {
            asc_error(TTF_GetError());
        }
    }
    SDL_ClearError();
    asc_set_flag(&asc_context.flags, ASC_FLAG_INITILIZED);
    asc_dprintf("Ascension context initialized.");
}

void asc_context_destroy(void) {
    // destroy lists
    cxListDestroy(asc_context.windows);

    // quit SDL
    if (TTF_WasInit())
        TTF_Quit();
    SDL_Quit();

    // destroy the error buffer
    cxBufferDestroy(&asc_context.error_buffer);
    asc_context.flags = 0;
    asc_dprintf("Ascension context destroyed.");
}

void asc_error_cchar(char const* text) {
    asc_error_cxstr(cx_str(text));
}

void asc_error_cuchar(unsigned char const* text) {
    asc_error_cxstr(cx_str((char const*)text));
}

void asc_error_cxstr(cxstring text) {
    if (text.length == 0) return;

    // write error to debug output
    asc_dprintf("ERROR: %*.s", (int)text.length, text.ptr);

    // write error to buffer
    CxBuffer* buf = &asc_context.error_buffer;
    cxBufferWrite(text.ptr, 1, text.length, buf);
    cxBufferPut(buf, '\n');

    asc_set_flag(&asc_context.flags, ASC_FLAG_HAS_ERROR);
}

bool asc_has_error(void) {
    return asc_test_flag(asc_context.flags, ASC_FLAG_HAS_ERROR);
}

char const* asc_get_error(void) {
    // we zero-terminate the current buffer contents before providing them
    cxBufferPut(&asc_context.error_buffer, 0);
    --asc_context.error_buffer.pos;
    --asc_context.error_buffer.size;
    return asc_context.error_buffer.space;
}

void asc_clear_error(void) {
    cxBufferClear(&asc_context.error_buffer);
    asc_clear_flag(&asc_context.flags, ASC_FLAG_HAS_ERROR);
}

static void asc_event_window_resized(Uint32 id, Sint32 width, Sint32 height) {
    CxIterator iter = cxListIterator(asc_context.windows);
    cx_foreach(AscWindow*, w, iter) {
        if (w->id == id) {
            w->width = width;
            w->height = height;
            return;
        }
    }
}

bool asc_loop_next(void) {
    // dispatch SDL events
    SDL_Event event;
    while (SDL_PollEvent(&event)) {
        switch (event.type) {
        case SDL_QUIT:return false;
        case SDL_WINDOWEVENT: {
            if (event.window.type == SDL_WINDOWEVENT_RESIZED)
                asc_event_window_resized(
                        event.window.windowID,
                        event.window.data1,
                        event.window.data2
                );
            break;
        }
        case SDL_KEYDOWN:
            // TODO: remove this code and implement key press map instead
            if (event.key.keysym.sym == SDLK_ESCAPE)
                return false;
            break;
        case SDL_KEYUP:
            // TODO: implement key press map
            break;
        }
    }

    // sync the windows
    CxMutIterator windows = cxListMutIterator(asc_context.windows);
    cx_foreach(AscWindow*, w, windows) {
        asc_window_sync(w);
    }
    return true;
}

void asc_window_settings_init_defaults(AscWindowSettings* settings) {
    settings->depth_size = 24;
    settings->vsync = 1;
    settings->width = 800;
    settings->height = 600;
    settings->fullscreen = 0;
    settings->gl_major_version = 3;
    settings->gl_minor_version = 3;
    settings->title = "Ascended Window";
}

void asc_window_initialize(AscWindow* window, AscWindowSettings const* settings) {
    Uint32 flags = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN;
    flags |= settings->fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : SDL_WINDOW_RESIZABLE;

    window->window = SDL_CreateWindow(
            settings->title,
            SDL_WINDOWPOS_CENTERED,
            SDL_WINDOWPOS_CENTERED,
            settings->width,
            settings->height,
            flags
    );
    if (window->window == NULL) {
        asc_error(SDL_GetError());
        return;
    }

    window->id = SDL_GetWindowID(window->window);
    SDL_GetWindowSize(window->window, &window->width, &window->height);

    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);
    window->glctx = SDL_GL_CreateContext(window->window);
    if (window->glctx == NULL) {
        asc_dprintf("Creating GL context failed for window %u", window->id);
    } else {
        glewExperimental = GL_TRUE;
        GLenum err = glewInit();
        if (err == GLEW_OK) {
            SDL_GL_SetSwapInterval(settings->vsync);
            glEnable(GL_DEPTH_TEST);
            glEnable(GL_BLEND);
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
            glEnable(GL_DEBUG_OUTPUT);
            glDebugMessageCallback(asc_gl_debug_callback, NULL);
            asc_dprintf("Window %u initialized", window->id);
            cxListAdd(asc_context.windows, window);
            return;
        } else {
            asc_error(glewGetErrorString(err));
        }
    }

    // cleanup on error
    if (window->glctx != NULL) {
        SDL_GL_DeleteContext(window->glctx);
    }
    window->glctx = NULL;
    SDL_DestroyWindow(window->window);
    window->window = NULL;
    window->id = 0;
}

void asc_window_destroy_impl(AscWindow* window) {
    // destory the GL context and the window
    if (window->glctx != NULL) {
        SDL_GL_DeleteContext(window->glctx);
    }
    if (window->window != NULL) {
        SDL_DestroyWindow(window->window);
    }

    // clean the data
    asc_dprintf("Window %u and its OpenGL context destroyed.", window->id);
    memset(window, 0, sizeof(AscWindow));
}

void asc_window_destroy(AscWindow* window) {
    // find the window in the context and remove it
    bool found = false;
    CxMutIterator iter = cxListMutIterator(asc_context.windows);
    cx_foreach(AscWindow*, w, iter) {
        if (w == window) {
            found = true;
            cxIteratorFlagRemoval(iter);
        }
    }
    if (!found) asc_window_destroy_impl(window);
}

void asc_window_sync(AscWindow const* window) {
    SDL_GL_MakeCurrent(window->window, window->glctx);
    SDL_GL_SwapWindow(window->window);
    glViewport(0, 0, window->width, window->height);
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}