awesome!!!

src/textures.c

@@ -0,0 +1,357 @@
+#include "textures.h"
+#include "config.h"
+#include "util.h"
+
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_image.h>
+#include <physfs.h>
+#include <physfsrwops.h>
+#include <stb_ds.h>
+#include <stb_rect_pack.h>
+
+#include <limits.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+
+static SDL_Surface *image_to_surface(char *path) {
+    SDL_RWops *handle = PHYSFSRWOPS_openRead(path);
+    if (handle == NULL)
+        goto fail;
+    
+    SDL_Surface *result = IMG_Load_RW(handle, true);
+    if (result == NULL)
+        goto fail;
+
+    SDL_SetSurfaceBlendMode(result, SDL_BLENDMODE_NONE);
+    SDL_SetSurfaceRLE(result, true);
+
+    return result;
+
+fail:
+    CRY(path, "Failed to load image. Aborting...");
+    die_abruptly();
+}
+
+
+/* adds a new, blank atlas surface to the cache */
+static void add_new_atlas(struct texture_cache *cache) {
+    SDL_PixelFormat *native_format =
+        SDL_AllocFormat(SDL_GetWindowPixelFormat(cache->window));
+
+    /* the window format won't have an alpha channel, so we figure this out */
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+    uint32_t a_mask = 0x000000FF;
+#else 
+    uint32_t a_mask = 0xFF000000;
+#endif
+
+    SDL_Surface *new_atlas = SDL_CreateRGBSurface(0,
+                                                  TEXTURE_ATLAS_SIZE,
+                                                  TEXTURE_ATLAS_SIZE,
+                                                  TEXTURE_ATLAS_BIT_DEPTH,
+                                                  native_format->Rmask,
+                                                  native_format->Gmask,
+                                                  native_format->Bmask,
+                                                  a_mask);
+    SDL_FreeFormat(native_format);
+
+    SDL_SetSurfaceRLE(new_atlas, true);
+    arrput(cache->atlas_surfaces, new_atlas);
+    
+    SDL_Texture *new_atlas_texture =
+        SDL_CreateTextureFromSurface(cache->renderer, new_atlas); 
+    arrput(cache->atlas_textures, new_atlas_texture);
+}
+
+
+static void recreate_current_atlas_texture(struct texture_cache *cache) {
+    /* TODO: figure out if SDL_UpdateTexture alone is faster than blitting */
+    SDL_Surface *atlas_surface = cache->atlas_surfaces[cache->atlas_index];
+
+    /* clear */
+    SDL_FillRect(atlas_surface, NULL, 0);
+
+    /* blit the texture surfaces onto the atlas */
+    for (size_t i = 0; i < shlenu(cache->hash); ++i) {
+        if (cache->hash[i].value.atlas_index != cache->atlas_index)
+            continue;
+
+        SDL_BlitSurface(cache->hash[i].value.data,
+                        NULL,
+                        atlas_surface,
+                        &cache->hash[i].value.srcrect);
+    }
+
+    /* texturize it! */
+    SDL_LockSurface(atlas_surface);
+    SDL_UpdateTexture(cache->atlas_textures[cache->atlas_index],
+                      NULL,
+                      atlas_surface->pixels,
+                      atlas_surface->pitch);
+    SDL_UnlockSurface(atlas_surface);
+}
+
+
+/* uses the textures currently in the cache to create an array of stbrp_rects */
+static stbrp_rect *create_rects_from_cache(struct texture_cache *cache) {
+    stbrp_rect *rects = NULL;
+    for (size_t i = 0; i < shlenu(cache->hash); ++i) {
+        SDL_Surface *surface_data = cache->hash[i].value.data;
+        stbrp_rect new_rect = {
+            .w = surface_data->w,
+            .h = surface_data->h,
+        };
+
+        arrput(rects, new_rect);
+    }
+    return rects;
+}
+
+
+/* returns an array which contains a _copy_ of every unpacked rect in rects. */
+/* each of these copies will have their original index in rects saved in */
+/* their `id` field, which is an int. */
+static stbrp_rect *filter_unpacked_rects(stbrp_rect *rects) {
+    stbrp_rect *unpacked_rects = NULL;
+    for (size_t i = 0; i < arrlenu(rects); ++i) {
+        /* already packed */
+        if (rects[i].was_packed)
+            continue;
+
+        arrput(unpacked_rects, rects[i]);
+        /* stb_rect_pack mercifully gives you a free userdata int */
+        /* the index is saved there so the original array can be updated later */
+        unpacked_rects[arrlenu(unpacked_rects)-1].id = (int)i;
+    }
+    return unpacked_rects;
+}
+
+
+/* updates the original rects array with the data from packed_rects */
+/* returns true if all rects were packed successfully */
+static bool update_rects(struct texture_cache *cache, stbrp_rect *rects, stbrp_rect *packed_rects) {
+    /* !!! do not grow either of the arrays !!! */
+    /* the reallocation will try to reassign the array pointer, to no effect. */
+    /* see stb_ds.h */
+    bool packed_all = true;
+    
+    for (size_t i = 0; i < arrlenu(packed_rects); ++i) {
+        /* we can check if any rects failed to be packed right here */
+        /* it's not ideal, but it avoids another iteration */
+        if (!packed_rects[i].was_packed) {
+            packed_all = false;
+            continue;
+        }
+
+        rects[packed_rects[i].id] = packed_rects[i];
+        /* while the order of the elements in the hash map is unknown to us, */
+        /* their equivalents in `rects` are in that same (unknown) order, which means */
+        /* we can use the index we had saved to find the original texture struct */
+        cache->hash[packed_rects[i].id].value.atlas_index = cache->atlas_index;
+    }
+
+    return packed_all;
+}
+
+
+/* updates the atlas location of every rect in the cache */
+static void update_texture_rects_in_atlas(struct texture_cache *cache, stbrp_rect *rects) {
+    for (size_t i = 0; i < arrlenu(rects); ++i) {
+        cache->hash[i].value.srcrect = (SDL_Rect) {
+            .x = rects[i].x,
+            .y = rects[i].y,
+            .w = rects[i].w,
+            .h = rects[i].h,
+        };
+    }
+}
+
+
+void textures_cache_init(struct texture_cache *cache, SDL_Window *window) {
+    cache->window = window;
+    cache->renderer = SDL_GetRenderer(window);
+    sh_new_arena(cache->hash);
+    sh_new_arena(cache->loner_hash);
+
+    cache->node_buffer = cmalloc(sizeof *cache->node_buffer * TEXTURE_ATLAS_SIZE);
+
+    add_new_atlas(cache);
+    recreate_current_atlas_texture(cache);
+}
+
+
+void textures_cache_deinit(struct texture_cache *cache) {
+    /* free atlas textures */
+    for (size_t i = 0; i < arrlenu(cache->atlas_textures); ++i) {
+        SDL_DestroyTexture(cache->atlas_textures[i]);
+    }
+    arrfree(cache->atlas_textures);
+
+    /* free atlas surfaces */
+    for (size_t i = 0; i < arrlenu(cache->atlas_surfaces); ++i) {
+        SDL_FreeSurface(cache->atlas_surfaces[i]);
+    }
+    arrfree(cache->atlas_surfaces);
+
+    /* free cache hashes */
+    for (size_t i = 0; i < shlenu(cache->hash); ++i) {
+        SDL_FreeSurface(cache->hash[i].value.data);
+    }
+    shfree(cache->hash);
+
+    for (size_t i = 0; i < shlenu(cache->loner_hash); ++i) {
+        SDL_FreeSurface(cache->loner_hash[i].value.data);
+    }
+    shfree(cache->loner_hash);
+
+    free(cache->node_buffer);
+}
+
+
+void textures_dump_atlases(struct texture_cache *cache) {
+    PHYSFS_mkdir("/dump");
+
+    const char string_template[] = "/dump/atlas%zd.png";
+    char buf[2048]; /* larger than will ever be necessary */
+
+    size_t i = 0;
+    for (; i < arrlenu(cache->atlas_surfaces); ++i) {
+        snprintf(buf, sizeof buf, string_template, i);
+
+        SDL_RWops *handle = PHYSFSRWOPS_openWrite(buf);
+
+        if (handle == NULL) {
+            CRY("Texture atlas dump failed.", "File could not be opened");
+            return;
+        }
+
+        IMG_SavePNG_RW(cache->atlas_surfaces[i], handle, true);
+        log_info("Dumped atlas %s", buf);
+    }
+    
+    size_t num_loners = shlenu(cache->loner_hash);
+    log_info("%zd atlases dumped. %zd loners left undumped.", i, num_loners);
+}
+
+
+void textures_load(struct texture_cache *cache, char *path) {
+    /* no need to do anything if it was loaded already */
+    if (shgeti(cache->hash, path) >= 0 || shgeti(cache->loner_hash, path) >= 0)
+        return;
+
+    SDL_Surface *surface = image_to_surface(path);
+    struct texture new_texture;
+    new_texture.data = surface;
+
+    /* it's a "loner texture," it doesn't fit in an atlas so it's not in one */
+    if (surface->w > TEXTURE_ATLAS_SIZE || surface->h > TEXTURE_ATLAS_SIZE) {
+        new_texture.loner_data = SDL_CreateTextureFromSurface(cache->renderer, surface); 
+        new_texture.atlas_index = -1;
+        shput(cache->loner_hash, path, new_texture);
+    } else {
+        new_texture.atlas_index = cache->atlas_index;
+        shput(cache->hash, path, new_texture);
+        cache->is_dirty = true;
+    }
+}
+
+
+void textures_update_current_atlas(struct texture_cache *cache) {
+    /* this function makes a lot more sense if you read stb_rect_pack.h */
+    stbrp_context pack_ctx; /* target info */
+    stbrp_init_target(&pack_ctx,
+                      TEXTURE_ATLAS_SIZE,
+                      TEXTURE_ATLAS_SIZE,
+                      cache->node_buffer,
+                      TEXTURE_ATLAS_SIZE);
+
+    stbrp_rect *rects = create_rects_from_cache(cache);
+
+    /* we have to keep packing, and creating atlases if necessary, */
+    /* until all rects have been packed. */
+    /* ideally, this will not iterate more than once. */
+    bool textures_remaining = true;
+    while (textures_remaining) {
+        stbrp_rect *rects_to_pack = filter_unpacked_rects(rects);
+        stbrp_pack_rects(&pack_ctx, rects_to_pack, (int)arrlen(rects_to_pack));
+
+        textures_remaining = !update_rects(cache, rects, rects_to_pack);
+        arrfree(rects_to_pack); /* got what we needed */
+
+        /* some textures couldn't be packed */
+        if (textures_remaining) {
+            update_texture_rects_in_atlas(cache, rects);
+            recreate_current_atlas_texture(cache);
+
+            /* need a new atlas for next time */
+            add_new_atlas(cache);
+            ++cache->atlas_index;
+        }
+    };
+
+    update_texture_rects_in_atlas(cache, rects);
+    recreate_current_atlas_texture(cache);
+
+    cache->is_dirty = false;
+    
+    arrfree(rects);
+}
+
+
+SDL_Rect textures_get_srcrect(struct texture_cache *cache, char *path) {
+    struct texture_cache_item *texture = shgetp_null(cache->hash, path);
+    if (texture == NULL) {
+        CRY("Texture lookup failed.",
+            "Tried to get texture that isn't loaded.");
+        return (SDL_Rect){ 0, 0, 0, 0 };
+    }
+    return texture->value.srcrect;
+}
+
+
+int textures_get_atlas_index(struct texture_cache *cache, char *path) {
+    struct texture_cache_item *texture = shgetp_null(cache->hash, path);
+
+    /* it might be a loner texture */
+    if (texture == NULL) {
+        texture = shgetp_null(cache->loner_hash, path);
+
+        /* never mind it's just not there at all */
+        if (texture == NULL) {
+            CRY("Texture atlas index lookup failed.",
+                "Tried to get atlas index of texture that isn't loaded.");
+            return INT_MIN;
+        }
+    }
+
+    return texture->value.atlas_index;
+}
+
+
+SDL_Texture *textures_get_atlas(struct texture_cache *cache, int index) {
+    /* out of bounds */
+    if (arrlen(cache->atlas_textures) < index + 1 || index < 0)
+        return NULL;
+
+    return cache->atlas_textures[index];
+}
+
+
+SDL_Texture *textures_get_loner(struct texture_cache *cache, char *path) {
+    struct texture_cache_item *texture = shgetp_null(cache->loner_hash, path);
+
+    if (texture == NULL) {
+        CRY("Loner texture lookup failed.",
+            "Tried to get texture that isn't loaded.");
+        return NULL;
+    }
+
+    return texture->value.loner_data;
+}
+
+
+size_t textures_get_num_atlases(struct texture_cache *cache) {
+    return cache->atlas_index + 1;    
+}