update hiload

.gitignore

@@ -1,5 +1,7 @@
 # Hiisi
 build/
+compile_commands.json
+.cache/
 
 # ---> Emacs
 # -*- mode: gitignore; -*-
@@ -30,5 +32,3 @@ tramp
 .idea
 *.log
 tmp/
-
-build/

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "3rd/SDL"]
 	path = 3rd/SDL
 	url = https://github.com/libsdl-org/SDL.git
+[submodule "hiload"]
+	path = hiload
+	url = git@git.kitemoonsche.me:schme/hiload.git

CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.21)
+project(Hiisi)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_CXX_STANDARD 17)
+
+add_subdirectory(3rd/SDL EXCLUDE_FROM_ALL)
+add_subdirectory(hiload)
+add_subdirectory(hiisi)
+
+add_executable(hiisi-run
+  hiisi/main.cpp)
+
+target_link_libraries(hiisi-run hiisi-engine hiload)

README.md

@@ -1,3 +1,14 @@
 # Hiisi
 
-One more Hiisi-engine
+One more Hiisi-engine.
+
+```bash
+git clone --recurse-submodules -j8 git@git.kitemoonsche.me:schme/Hiisi.git
+```
+
+## Build
+
+```bash
+cmake -B build -S . -G Ninja
+cmake --build build
+```

hiisi/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.21)
+project(HiisiEngine)
+
+add_library(hiisi-engine SHARED
+  hiisi.h
+  hiisi.cpp)
+
+target_compile_options(hiisi-engine PRIVATE "-Wall" "-Wextra" "-Wpedantic")
+
+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 SDL3::SDL3-shared)

hiisi/hiisi.cpp

@@ -0,0 +1,118 @@
+#include "hiisi.h"
+
+#define SDL_MAIN_USE_CALLBACKS 1 /* use the callbacks instead of main() */
+#include <SDL3/SDL.h>
+
+#define WINDOW_WIDTH 1280
+#define WINDOW_HEIGHT 720
+
+/* This function runs once at startup. */
+int HiisiEngine::init(int argc, char *argv[]) {
+    (void)argc;
+    (void)argv;
+
+    SDL_SetAppMetadata("Hiisi Engine", "0.0.1", "me.kitemoonsche.hiisi-engine");
+
+    SDL_Window *window = 0;
+    SDL_Renderer *renderer = 0;
+
+    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;
+    }
+
+    _window = window;
+    _renderer = renderer;
+
+    return SDL_APP_CONTINUE; /* carry on with the program! */
+}
+
+/* This function runs when a new event (mouse input, keypresses, etc) occurs. */
+int HiisiEngine::event() {
+    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 HiisiEngine::iterate() {
+    SDL_Renderer *renderer = (SDL_Renderer *)_renderer;
+    SDL_FRect rects[16];
+    const Uint64 now = SDL_GetTicks();
+    size_t 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, 250, 0, 255,
+                           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) * 500.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, 255, 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, 50, 25, 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, 25, 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 HiisiEngine::quit() { /* SDL will clean up the window/renderer for us. */
+}

hiisi/hiisi.h

@@ -0,0 +1,17 @@
+#ifndef HIISI_H_
+#define HIISI_H_
+
+class HiisiEngine {
+  public:
+    int init(int argc, char *argv[]);
+    int event();
+    int iterate();
+    void quit();
+
+  private:
+    void *_window = 0;
+    void *_renderer = 0;
+    void *_module = 0;
+};
+
+#endif // HIISI_H_

hiisi/main.cpp

@@ -0,0 +1,37 @@
+#include "hiisi.h"
+
+#include "hiload.h"
+
+#include <assert.h>
+#include <atomic>
+#include <dlfcn.h>
+#include <link.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char **argv) {
+
+    /* Hiload hotreloader is compiled as a shared library, these are the
+     * only required changes for the code to successfully reload  */
+
+    // Init hiload
+    const char *himodules[] = {"", "libhiisi-engine.so"};
+    hi_init(2, himodules);
+
+    HiisiEngine hiisi;
+
+    hiisi.init(argc, argv);
+    while (hiisi.event()) {
+        hiisi.iterate();
+
+        // Reload changes
+        hi_reload();
+    }
+
+    hiisi.quit();
+
+    // Deinit hiload
+    hi_deinit();
+    return 0;
+}