Final commit pre C++

src/file/assetmanager.c

@@ -31,13 +31,14 @@ assetmanagerloaderdefinition_t ASSET_MANAGER_LOADERS[] = {
 };
 
 
-void assetManagerInit(assetmanager_t *manager) {
+void assetManagerInit(assetmanager_t *manager, savemanager_t *save) {
   threadInit(&manager->thread, &_assetManagerThread);
   manager->thread.user = manager;
   manager->itemCount = 0;
   manager->finished = false;
   manager->holderCount = 0;
   manager->running = false;
+  manager->save = save;
 }
 
 float assetManagerProgressGet(assetmanager_t *manager) {

src/file/assetmanager.h

@@ -13,6 +13,7 @@
 #include "loaders/shader.h"
 #include "loaders/texture.h"
 #include "asset.h"
+#include "../save/save.h"
 
 // Constants
 extern assetmanagerloaderdefinition_t ASSET_MANAGER_LOADERS[];
@@ -22,7 +23,7 @@ extern assetmanagerloaderdefinition_t ASSET_MANAGER_LOADERS[];
  * 
  * @param manager Manager to initialize.
  */
-void assetManagerInit(assetmanager_t *manager);
+void assetManagerInit(assetmanager_t *manager, savemanager_t *save);
 
 /**
  * Gets the progress of the asset manager as a representation of 0-1 as a % that

src/file/loaders/scaledtexture.c

@@ -8,16 +8,21 @@
 #include "scaledtexture.h"
 
 assetmanageritem_t * assetManagerLoadScaledTexture(
-  assetmanager_t *manager, assetmanagerowner_t owner,
-  char *path, char *file, uint8_t scale
+  assetmanager_t *manager, assetmanagerowner_t owner, char *path, char *file
 ) {
   assetmanageritem_t *item;
   texturescale_t *st;
+  uint8_t scale;
   char buffer[ASSET_MANAGER_ITEM_NAME_MAX];
-  
-  sprintf(buffer, "%s/%s_%u", path, file, scale);
+
+  // Get the scale
+  scale = saveManagerGetUint8(manager->save, SAVE_KEY_TEXTURE_SCALE);
+
+  // Generate a key
+  sprintf(buffer, "%s/%s", path, file);
   item = assetManagerItemGet(manager, buffer);
-  
+
+  // Already loaded?
   if(item == NULL) {
     item = assetManagerItemAdd(manager, buffer);
     item->type = ASSET_MANAGER_TYPE_SCALED_TEXTURE;
@@ -121,3 +126,51 @@ bool _assetManagerLoaderScaledTextureDispose(assetmanageritem_t *item) {
   textureDispose(&item->data.scaledTexture.texture);
   return true;
 }
+
+bool _assetManagerLoaderScaledTextureResize(
+  assetmanager_t *manager, assetmanageritem_t *item, uint8_t scale
+) {
+  // Check if we need to update
+  if(item->data.scaledTexture.scale == scale) return true;
+
+  // Are we in the middle of an async load? If so then we gotta do some jank
+  while(item->state == ASSET_MANAGER_STATE_ASYNC_LOADING) {
+    threadSleep(0.1f);
+  }
+  
+  // Are we async loaded but sync pending?
+  if(item->state == ASSET_MANAGER_STATE_ASYNC_DONE) {
+    // We are async done but pending sync loading. Free the texture data since
+    // it will be re-malloced later on.
+    free(item->data.scaledTexture.data);
+  } else if(item->state == ASSET_MANAGER_STATE_SYNC_DONE) {
+    // We are already loaded, free the texture
+    if(!_assetManagerLoaderScaledTextureDispose(item)) return false;
+  }
+  
+  // Update scale.
+  item->data.scaledTexture.scale = scale;
+
+  // Immediately requeue a texture re-load
+  if(!_assetManagerLoaderScaledTextureAsync(item)) return false;
+
+  // And regenerate the texture synchronously.
+  if(!_assetManagerLoaderScaledTextureSync(item)) return false;
+
+  // Finally, mark texture as loaded (since it is)
+  item->state = ASSET_MANAGER_STATE_SYNC_DONE;
+  return true;
+}
+
+void assetManagerScaledTextureRescaleAll(assetmanager_t *manager) {
+  uint8_t i, scale;
+
+  // Get the new scale
+  scale = saveManagerGetUint8(manager->save, SAVE_KEY_TEXTURE_SCALE);
+
+  // Rescale each texture. This is, unfortunately, blocking for now.
+  for(i = 0; i < manager->itemCount; i++) {
+    if(manager->items[i].type != ASSET_MANAGER_TYPE_SCALED_TEXTURE) continue;
+    _assetManagerLoaderScaledTextureResize(manager, manager->items + i, scale);
+  }
+}

src/file/loaders/scaledtexture.h

@@ -9,6 +9,7 @@
 #include "item.h"
 #include "../xml.h"
 #include "../asset.h"
+#include "../../save/save.h"
 
 /**
  * Load the given texture scale for a scaled texture.
@@ -17,14 +18,33 @@
  * @param owner Owner ID requesting to load this resource.
  * @param path Path of the texture size sets
  * @param file Name of the texture that was generated.
- * @param scale Scale to load.
  * @return A pointer to the asset manager item for tracking.
  */
 assetmanageritem_t * assetManagerLoadScaledTexture(
-  assetmanager_t *manager, assetmanagerowner_t owner,
-  char *path, char *file, uint8_t scale
+  assetmanager_t *manager, assetmanagerowner_t owner, char *path, char *file
 );
 
 bool _assetManagerLoaderScaledTextureAsync(assetmanageritem_t *item);
 bool _assetManagerLoaderScaledTextureSync(assetmanageritem_t *item);
-bool _assetManagerLoaderScaledTextureDispose(assetmanageritem_t *item);
+bool _assetManagerLoaderScaledTextureDispose(assetmanageritem_t *item);
+
+/**
+ * Private method to resize a texture after it has been loaded.
+ * 
+ * @param manager 
+ * @param item 
+ * @param scale 
+ * @return true 
+ * @return false 
+ */
+bool _assetManagerLoaderScaledTextureResize(
+  assetmanager_t *manager, assetmanageritem_t *item, uint8_t scale
+);
+
+/**
+ * Method that when called will scan the asset manager and find any scaled
+ * textures that need resizing, and resize them.
+ * 
+ * @param manager Manager to check against.
+ */
+void assetManagerScaledTextureRescaleAll(assetmanager_t *manager);

src/file/types/common.h

@@ -8,11 +8,13 @@
 #pragma once
 #include "../../libs.h"
 #include "../../engine/thread.h"
+#include "../../save/save.h"
 #include "texture.h"
 #include "font.h"
 #include "shader.h"
 #include "scaledtexture.h"
 
+
 #define ASSET_MANAGER_ITEMS_MAX 64
 #define ASSET_MANAGER_ITEM_NAME_MAX 96
 #define ASSET_MANAGER_HOLDERS_MAX 8
@@ -69,6 +71,8 @@ typedef struct {
 // Manager
 typedef struct {
   thread_t thread;
+  savemanager_t *save;
+
   bool finished;
   bool running;