move engine to shared lib

hiisi/CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.21)
+project(HiisiEngine)
+
+add_library(hiisi-engine SHARED
+  hiisi.h
+  hiisi.cpp)
+
+set_property(TARGET hiisi-engine PROPERTY POSITION_INDEPENDENT_CODE ON)
+set_property(TARGET hiisi-engine PROPERTY LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR})
+
+target_link_libraries(hiisi-engine PRIVATE
+  SDL3::SDL3)

hiisi/hiisi.cpp

@@ -0,0 +1,108 @@
+#include "hiisi.h"
+
+#define SDL_MAIN_USE_CALLBACKS 1  /* use the callbacks instead of main() */
+#include <SDL3/SDL.h>
+
+/* We will use this renderer to draw into this window every frame. */
+static SDL_Window *window = NULL;
+static SDL_Renderer *renderer = NULL;
+
+#define WINDOW_WIDTH 1280
+#define WINDOW_HEIGHT 720
+
+/* This function runs once at startup. */
+int init(void *appstate, int argc, char *argv[])
+{
+    SDL_SetAppMetadata("Hiisi Engine", "0.0.1", "me.kitemoonsche.hiisi-engine");
+
+    if (!SDL_Init(SDL_INIT_VIDEO)) {
+        SDL_Log("Couldn't initialize SDL: %s", SDL_GetError());
+        return SDL_APP_FAILURE;
+    }
+
+    if (!SDL_CreateWindowAndRenderer("Hiisi Engine", WINDOW_WIDTH, WINDOW_HEIGHT, 0, &window, &renderer)) {
+        SDL_Log("Couldn't create window/renderer: %s", SDL_GetError());
+        return SDL_APP_FAILURE;
+    }
+
+    return SDL_APP_CONTINUE;  /* carry on with the program! */
+}
+
+/* This function runs when a new event (mouse input, keypresses, etc) occurs. */
+int event(void *appstate)
+{
+    SDL_Event event;
+    while (SDL_PollEvent(&event)) {
+        if (event.type == SDL_EVENT_QUIT) {
+            return 0;  /* end the program, reporting success to the OS. */
+        }
+    }
+    return 1;  /* carry on with the program! */
+}
+
+/* This function runs once per frame, and is the heart of the program. */
+int iterate(void *appstate)
+{
+    SDL_FRect rects[16];
+    const Uint64 now = SDL_GetTicks();
+    int i;
+
+    /* we'll have the rectangles grow and shrink over a few seconds. */
+    const float direction = ((now % 2000) >= 1000) ? 1.0f : -1.0f;
+    const float scale = ((float) (((int) (now % 1000)) - 500) / 500.0f) * direction;
+
+    /* as you can see from this, rendering draws over whatever was drawn before it. */
+    SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);  /* black, full alpha */
+    SDL_RenderClear(renderer);  /* start with a blank canvas. */
+
+    /* Rectangles are comprised of set of X and Y coordinates, plus width and
+       height. (0, 0) is the top left of the window, and larger numbers go
+       down and to the right. This isn't how geometry works, but this is
+       pretty standard in 2D graphics. */
+
+    /* Let's draw a single rectangle (square, really). */
+    rects[0].x = rects[0].y = 100;
+    rects[0].w = rects[0].h = 100 + (100 * scale);
+    SDL_SetRenderDrawColor(renderer, 255, 0, 0, SDL_ALPHA_OPAQUE);  /* red, full alpha */
+    SDL_RenderRect(renderer, &rects[0]);
+
+    /* Now let's draw several rectangles with one function call. */
+    for (i = 0; i < 3; i++) {
+        const float size = (i+1) * 50.0f;
+        rects[i].w = rects[i].h = size + (size * scale);
+        rects[i].x = (WINDOW_WIDTH - rects[i].w) / 2;  /* center it. */
+        rects[i].y = (WINDOW_HEIGHT - rects[i].h) / 2;  /* center it. */
+    }
+    SDL_SetRenderDrawColor(renderer, 0, 255, 0, SDL_ALPHA_OPAQUE);  /* green, full alpha */
+    SDL_RenderRects(renderer, rects, 3);  /* draw three rectangles at once */
+
+    /* those were rectangle _outlines_, really. You can also draw _filled_ rectangles! */
+    rects[0].x = 400;
+    rects[0].y = 50;
+    rects[0].w = 100 + (100 * scale);
+    rects[0].h = 50 + (50 * scale);
+    SDL_SetRenderDrawColor(renderer, 0, 0, 255, SDL_ALPHA_OPAQUE);  /* blue, full alpha */
+    SDL_RenderFillRect(renderer, &rects[0]);
+
+    /* ...and also fill a bunch of rectangles at once... */
+    for (i = 0; i < SDL_arraysize(rects); i++) {
+        const float w = (float) (WINDOW_WIDTH / SDL_arraysize(rects));
+        const float h = i * 8.0f;
+        rects[i].x = i * w;
+        rects[i].y = WINDOW_HEIGHT - h;
+        rects[i].w = w;
+        rects[i].h = h;
+    }
+    SDL_SetRenderDrawColor(renderer, 255, 255, 255, SDL_ALPHA_OPAQUE);  /* white, full alpha */
+    SDL_RenderFillRects(renderer, rects, SDL_arraysize(rects));
+
+    SDL_RenderPresent(renderer);  /* put it all on the screen! */
+
+    return SDL_APP_CONTINUE;  /* carry on with the program! */
+}
+
+/* This function runs once at shutdown. */
+void quit(void *appstate)
+{
+    /* SDL will clean up the window/renderer for us. */
+}

hiisi/hiisi.h

@@ -0,0 +1,20 @@
+#ifndef HIISI_H_
+#define HIISI_H_
+
+extern "C" {
+
+    struct Engine {
+        void *module = 0;
+        int (*init)(void *, int, char**);
+        int (*event)(void *);
+        int (*iterate)(void *);
+        void (*quit)(void *);
+    };
+
+    int init(void *appstate, int argc, char *argv[]);
+    int event(void *appstate);
+    int iterate(void *appstate);
+    void quit(void *appstate);
+
+}
+#endif // HIISI_H_

hiisi/main.cpp

@@ -0,0 +1,102 @@
+#include "hiisi.h"
+
+#include <assert.h>
+#include <elf.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <dlfcn.h>
+#include <link.h>
+
+struct app_state {};
+
+Engine load_hiisi(const char *name) {
+    void *mod = dlopen(name, RTLD_NOW);
+
+    Lmid_t list;
+    dlinfo(mod, RTLD_DI_LMID, &list);
+    printf("link-map list id: %ld\n", list);
+
+    link_map *lmap = 0;
+    dlinfo(mod, RTLD_DI_LINKMAP, &lmap);
+
+    printf("Link map:\n");
+    printf("addr: %lu\n", lmap->l_addr);
+    printf("name: %s\n", lmap->l_name);
+    printf("dynamic section: %p\n", lmap->l_ld);
+
+    char pathname[256];
+    dlinfo(mod, RTLD_DI_ORIGIN, pathname);
+    printf("path: %s\n", pathname);
+
+    /* Discover the size of the buffer that we must pass to
+       RTLD_DI_SERINFO. */
+    Dl_serinfo serinfo;
+    Dl_serinfo *sip;
+
+    if (dlinfo(mod, RTLD_DI_SERINFOSIZE, &serinfo) == -1) {
+        fprintf(stderr, "RTLD_DI_SERINFOSIZE failed: %s\n", dlerror());
+        exit(EXIT_FAILURE);
+    }
+
+    /* Allocate the buffer for use with RTLD_DI_SERINFO. */
+
+    sip = (Dl_serinfo*)malloc(serinfo.dls_size);
+    if (sip == NULL) {
+        perror("malloc");
+        exit(EXIT_FAILURE);
+    }
+
+    /* Initialize the 'dls_size' and 'dls_cnt' fields in the newly
+       allocated buffer. */
+
+    if (dlinfo(mod, RTLD_DI_SERINFOSIZE, sip) == -1) {
+        fprintf(stderr, "RTLD_DI_SERINFOSIZE failed: %s\n", dlerror());
+        exit(EXIT_FAILURE);
+    }
+
+    /* Fetch and print library search list. */
+
+    if (dlinfo(mod, RTLD_DI_SERINFO, sip) == -1) {
+        fprintf(stderr, "RTLD_DI_SERINFO failed: %s\n", dlerror());
+        exit(EXIT_FAILURE);
+    }
+
+    for (size_t j = 0; j < serinfo.dls_cnt; j++)
+        printf("dls_serpath[%zu].dls_name = %s\n",
+               j, sip->dls_serpath[j].dls_name);
+
+    Engine engine;
+    engine.module = mod;
+    *(void **)&engine.init = dlsym(mod, "init");
+    *(void **)&engine.event = dlsym(mod, "event");
+    *(void **)&engine.iterate = dlsym(mod, "iterate");
+    *(void **)&engine.quit = dlsym(mod, "quit");
+
+    assert(engine.init);
+    assert(engine.event);
+    assert(engine.iterate);
+    assert(engine.quit);
+
+    return engine;
+}
+
+int main(int argc, char **argv) {
+
+    app_state state;
+    void *state_ptr = &state;
+
+    Engine hiisi = load_hiisi("build/hiisi/libhiisi-engine.so");
+    if (!hiisi.module) {
+        printf("%s\n", dlerror());
+        return 1;
+    }
+
+    hiisi.init(&state, argc, argv);
+    while (hiisi.event(&state)) {
+        hiisi.iterate(&state);
+    }
+
+    dlclose(hiisi.module);
+
+    return 0;
+}