diff -r 7e1196d551ff -r 302971e8599b src/window.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/window.c Wed Nov 01 20:09:49 2023 +0100 @@ -0,0 +1,200 @@ +/* + * 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/window.h" + +#include +#include + +#include + +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 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->dimensions.width = width; + w->dimensions.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->dimensions.width = 800; + settings->dimensions.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->dimensions.width, + settings->dimensions.height, + flags + ); + if (window->window == NULL) { + asc_error(SDL_GetError()); + return; + } + + window->id = SDL_GetWindowID(window->window); + SDL_GetWindowSize(window->window, + &window->dimensions.width, + &window->dimensions.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->dimensions.width, window->dimensions.height); + glClearColor(0.0f, 0.0f, 0.0f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); +}