examples/storage/01-user/user.c - external/github.com/libsdl-org/SDL - Git at Google

 /*
  * This example code creates an SDL window and renderer, and waits for the user
  * to click on the window. By default, the window color is blue; When storage
  * succeeds, the window turns green, if it fails the window turns red and the
  * error message is logged. Left clicking will save a game, all other clicks
  * will load a game.
  *
  * The primary goal is to show how to handle save data without blocking the main
  * thread, while also making sure to keep the storage handle open for as little
  * as possible; many platforms do not allow keeping user storage open for long
  * periods of time so you _must_ be sure to only have user storage open when you
  * are absolutely 100% ready to interact with the storage handle.
  *
  * This code is public domain. Feel free to use it for any purpose!
  */

 #define SDL_MAIN_USE_CALLBACKS 1  /* use the callbacks instead of main() */
 #include <SDL3/SDL.h>
 #include <SDL3/SDL_main.h>

 /* This is the list of steps that will occur as part of saving or loading a game */
 typedef enum savestate_t
 {
     SAVE_STATE_UNSTARTED, /* blue */
     SAVE_STATE_PROCESSING_GAME_WORLD, /* yellow */
     SAVE_STATE_PREPARING_STORAGE, /* cyan */
     SAVE_STATE_PROCESSING_STORAGE_FILE, /* magenta */
     SAVE_STATE_FINAL_CHECK /* green if success, red if failed */
 } savestate_t;

 SDL_AtomicInt current_save_state;

 /* During the final check, this indicates success or failure */
 static int save_result = -1;

 /* This is the thread that handles the majority of save operations */
 static SDL_Thread *save_thread = NULL;

 /* Opening storage is itself an async operation, so the thread will have some waiting to do */
 static SDL_Semaphore *storage_ready = NULL;

 /* This is the handle for the user's filesystem */
 static SDL_Storage *save_storage = NULL;

 #define SAVE_FILE_NAME "save.sav"

 /* This function pretends to serialize a fictional game world, then starts
  * opening the filesystem to write the serialized data
  */
 static int SDLCALL WriteSaveData(void *data)
 {
     Uint64 game_world; /* to keep things simple, let's just pretend that an entire game fits in 64-bits */
     bool write_result;

     SDL_SetAtomicInt(&current_save_state, SAVE_STATE_PROCESSING_GAME_WORLD);

     /* again, let's just pretend that an entire game fits in 64-bits */
     game_world = SDL_GetPerformanceCounter();

     /* now that save data is ready to go, we can start opening the filesystem */
     save_storage = SDL_OpenUserStorage("libsdl", "User Storage Example", 0);
     if (save_storage == NULL) {
         SDL_SetAtomicInt(&current_save_state, SAVE_STATE_FINAL_CHECK);
         return -1;
     }
     SDL_SetAtomicInt(&current_save_state, SAVE_STATE_PREPARING_STORAGE);

     /* the main thread will eventually signal to us that storage is ready */
     SDL_WaitSemaphore(storage_ready);

     /* the save data can now be written to the storage device */
     write_result = SDL_WriteStorageFile(save_storage, SAVE_FILE_NAME, &game_world, sizeof(game_world));

     /* regardless of what happened above, we've reached the end of the routine */
     SDL_CloseStorage(save_storage);
     SDL_SetAtomicInt(&current_save_state, SAVE_STATE_FINAL_CHECK);

     if (!write_result) {
         return -1;
     }
     return 0;
 }

 /* This function opens the filesystem to read a save file, then deserializes the
  * data into fictional game world data
  */
 static int SDLCALL ReadSaveData(void *data)
 {
     Uint64 game_world; /* to keep things simple, let's just pretend that an entire game fits in 64-bits */
     Uint64 save_len;
     bool read_result;

     /* start by preparing the filesystem for reading */
     save_storage = SDL_OpenUserStorage("libsdl", "User Storage Example", 0);
     if (save_storage == NULL) {
         SDL_SetAtomicInt(&current_save_state, SAVE_STATE_FINAL_CHECK);
         return -1;
     }
     SDL_SetAtomicInt(&current_save_state, SAVE_STATE_PREPARING_STORAGE);

     /* the main thread will eventually signal to us that storage is ready */
     SDL_WaitSemaphore(storage_ready);

     read_result = SDL_GetStorageFileSize(save_storage, SAVE_FILE_NAME, &save_len);
     if (!read_result) {
         SDL_CloseStorage(save_storage);
         SDL_SetAtomicInt(&current_save_state, SAVE_STATE_FINAL_CHECK);
         SDL_Log("Save data was not found");
         return -1;
     } else if (save_len != sizeof(game_world)) {
         SDL_CloseStorage(save_storage);
         SDL_SetAtomicInt(&current_save_state, SAVE_STATE_FINAL_CHECK);
         SDL_Log("Save data size is incorrect, was the file corrupted?");
         return -1;
     }

     /* once we've read the file in, the storage handle is no longer needed */
     read_result = SDL_ReadStorageFile(save_storage, SAVE_FILE_NAME, &game_world, sizeof(game_world));
     SDL_CloseStorage(save_storage);

     SDL_SetAtomicInt(&current_save_state, SAVE_STATE_PROCESSING_GAME_WORLD);

     if (read_result) {
         /* again, let's just pretend that an entire game fits in 64-bits */
         SDL_Log("Game World loaded, value was %" SDL_PRIu64, game_world);
     }

     /* regardless of what happened above, we've reached the end of the routine */
     SDL_SetAtomicInt(&current_save_state, SAVE_STATE_FINAL_CHECK);

     if (!read_result) {
         return -1;
     }
     return 0;
 }

 /* We will use this renderer to draw into this window every frame. */
 static SDL_Window *window = NULL;
 static SDL_Renderer *renderer = NULL;

 /* This function runs once at startup. */
 SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
 {
     SDL_SetAppMetadata("User Storage Example", "1.0", "com.example.storage-user");

     if (!SDL_Init(SDL_INIT_VIDEO)) {
         SDL_Log("Couldn't initialize SDL: %s", SDL_GetError());
         return SDL_APP_FAILURE;
     }

     if (!SDL_CreateWindowAndRenderer("examples/storage/user", 640, 480, 0, &window, &renderer)) {
         SDL_Log("Couldn't create window/renderer: %s", SDL_GetError());
         return SDL_APP_FAILURE;
     }

     /* initialize the default save state */
     SDL_SetAtomicInt(&current_save_state, SAVE_STATE_UNSTARTED);
     storage_ready = SDL_CreateSemaphore(0);

     return SDL_APP_CONTINUE;  /* carry on with the program! */
 }

 /* This function runs when a new event (mouse input, keypresses, etc) occurs. */
 SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event)
 {
     if (event->type == SDL_EVENT_QUIT) {
         return SDL_APP_SUCCESS;  /* end the program, reporting success to the OS. */
     } else if (event->type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
         if (save_thread != NULL) {
             SDL_Log("Ignoring interaction, save/load is in progress");
         } else {
             /* once the thread starts, it will update this to the first "real" state */
             SDL_SetAtomicInt(&current_save_state, SAVE_STATE_UNSTARTED);
             if (event->button.button == 1) {
                 save_thread = SDL_CreateThread(WriteSaveData, "Save Write Thread", NULL);
             } else {
                 save_thread = SDL_CreateThread(ReadSaveData, "Save Read Thread", NULL);
             }
         }
     }
     return SDL_APP_CONTINUE;  /* carry on with the program! */
 }

 /* This function runs once per frame, and is the heart of the program. */
 SDL_AppResult SDL_AppIterate(void *appstate)
 {
     float red, green, blue;
     int save_state = SDL_GetAtomicInt(&current_save_state);

     /* the main thread does not have to do much other than help the thread wait
      * for storage to be ready and read the result when the thread is finished
      */
     if (save_state == SAVE_STATE_PREPARING_STORAGE) {
         if (SDL_StorageReady(save_storage)) {
             SDL_SetAtomicInt(&current_save_state, SAVE_STATE_PROCESSING_STORAGE_FILE);
             SDL_SignalSemaphore(storage_ready);
         }
     } else if (save_state == SAVE_STATE_FINAL_CHECK) {
         if (save_thread != NULL) {
             SDL_WaitThread(save_thread, &save_result);
             save_thread = NULL;
             if (save_result == 0) {
                 SDL_Log("Save/Load complete!");
             } else {
                 SDL_Log("Save/Load failed: %s", SDL_GetError());
             }
         }
     }

     /* set the draw color based on the state of the save system */
     switch (save_state)
     {
     case SAVE_STATE_UNSTARTED:
         red = 0.0f;
         green = 0.0f;
         blue = 1.0f;
         break;
     case SAVE_STATE_PROCESSING_GAME_WORLD:
         red = 1.0f;
         green = 1.0f;
         blue = 0.0f;
         break;
     case SAVE_STATE_PREPARING_STORAGE:
         red = 0.0f;
         green = 1.0f;
         blue = 1.0f;
         break;
     case SAVE_STATE_PROCESSING_STORAGE_FILE:
         red = 1.0f;
         green = 0.0f;
         blue = 1.0f;
         break;
     case SAVE_STATE_FINAL_CHECK:
         if (save_result == 0) {
             red = 0.0f;
             green = 1.0f;
         } else {
             red = 1.0f;
             green = 0.0f;
         }
         blue = 0.0f;
         break;
     default:
         red = 0.0f;
         green = 0.0f;
         blue = 0.0f;
         SDL_assert(!"Unrecognized save state");
         break;
     }
     SDL_SetRenderDrawColorFloat(renderer, red, green, blue, SDL_ALPHA_OPAQUE_FLOAT);  /* new color, full alpha. */

     /* clear the window to the draw color. */
     SDL_RenderClear(renderer);

     /* put the newly-cleared rendering on the screen. */
     SDL_RenderPresent(renderer);

     return SDL_APP_CONTINUE;  /* carry on with the program! */
 }

 /* This function runs once at shutdown. */
 void SDL_AppQuit(void *appstate, SDL_AppResult result)
 {
     /* If saving/loading is still in progress, force the thread not to wait */
     SDL_SignalSemaphore(storage_ready);
     SDL_WaitThread(save_thread, NULL);
     SDL_DestroySemaphore(storage_ready);

     /* SDL will clean up the window/renderer for us. */
 }
	/*
	* This example code creates an SDL window and renderer, and waits for the user
	* to click on the window. By default, the window color is blue; When storage
	* succeeds, the window turns green, if it fails the window turns red and the
	* error message is logged. Left clicking will save a game, all other clicks
	* will load a game.
	*
	* The primary goal is to show how to handle save data without blocking the main
	* thread, while also making sure to keep the storage handle open for as little
	* as possible; many platforms do not allow keeping user storage open for long
	* periods of time so you _must_ be sure to only have user storage open when you
	* are absolutely 100% ready to interact with the storage handle.
	*
	* This code is public domain. Feel free to use it for any purpose!
	*/

	#define SDL_MAIN_USE_CALLBACKS 1 /* use the callbacks instead of main() */
	#include <SDL3/SDL.h>
	#include <SDL3/SDL_main.h>

	/* This is the list of steps that will occur as part of saving or loading a game */
	typedef enum savestate_t
	{
	SAVE_STATE_UNSTARTED, /* blue */
	SAVE_STATE_PROCESSING_GAME_WORLD, /* yellow */
	SAVE_STATE_PREPARING_STORAGE, /* cyan */
	SAVE_STATE_PROCESSING_STORAGE_FILE, /* magenta */
	SAVE_STATE_FINAL_CHECK /* green if success, red if failed */
	} savestate_t;

	SDL_AtomicInt current_save_state;

	/* During the final check, this indicates success or failure */
	static int save_result = -1;

	/* This is the thread that handles the majority of save operations */
	static SDL_Thread *save_thread = NULL;

	/* Opening storage is itself an async operation, so the thread will have some waiting to do */
	static SDL_Semaphore *storage_ready = NULL;

	/* This is the handle for the user's filesystem */
	static SDL_Storage *save_storage = NULL;

	#define SAVE_FILE_NAME "save.sav"

	/* This function pretends to serialize a fictional game world, then starts
	* opening the filesystem to write the serialized data
	*/
	static int SDLCALL WriteSaveData(void *data)
	{
	Uint64 game_world; /* to keep things simple, let's just pretend that an entire game fits in 64-bits */
	bool write_result;

	SDL_SetAtomicInt(&current_save_state, SAVE_STATE_PROCESSING_GAME_WORLD);

	/* again, let's just pretend that an entire game fits in 64-bits */
	game_world = SDL_GetPerformanceCounter();

	/* now that save data is ready to go, we can start opening the filesystem */
	save_storage = SDL_OpenUserStorage("libsdl", "User Storage Example", 0);
	if (save_storage == NULL) {
	SDL_SetAtomicInt(&current_save_state, SAVE_STATE_FINAL_CHECK);
	return -1;
	}
	SDL_SetAtomicInt(&current_save_state, SAVE_STATE_PREPARING_STORAGE);

	/* the main thread will eventually signal to us that storage is ready */
	SDL_WaitSemaphore(storage_ready);

	/* the save data can now be written to the storage device */
	write_result = SDL_WriteStorageFile(save_storage, SAVE_FILE_NAME, &game_world, sizeof(game_world));

	/* regardless of what happened above, we've reached the end of the routine */
	SDL_CloseStorage(save_storage);
	SDL_SetAtomicInt(&current_save_state, SAVE_STATE_FINAL_CHECK);

	if (!write_result) {
	return -1;
	}
	return 0;
	}

	/* This function opens the filesystem to read a save file, then deserializes the
	* data into fictional game world data
	*/
	static int SDLCALL ReadSaveData(void *data)
	{
	Uint64 game_world; /* to keep things simple, let's just pretend that an entire game fits in 64-bits */
	Uint64 save_len;
	bool read_result;

	/* start by preparing the filesystem for reading */
	save_storage = SDL_OpenUserStorage("libsdl", "User Storage Example", 0);
	if (save_storage == NULL) {
	SDL_SetAtomicInt(&current_save_state, SAVE_STATE_FINAL_CHECK);
	return -1;
	}
	SDL_SetAtomicInt(&current_save_state, SAVE_STATE_PREPARING_STORAGE);

	/* the main thread will eventually signal to us that storage is ready */
	SDL_WaitSemaphore(storage_ready);

	read_result = SDL_GetStorageFileSize(save_storage, SAVE_FILE_NAME, &save_len);
	if (!read_result) {
	SDL_CloseStorage(save_storage);
	SDL_SetAtomicInt(&current_save_state, SAVE_STATE_FINAL_CHECK);
	SDL_Log("Save data was not found");
	return -1;
	} else if (save_len != sizeof(game_world)) {
	SDL_CloseStorage(save_storage);
	SDL_SetAtomicInt(&current_save_state, SAVE_STATE_FINAL_CHECK);
	SDL_Log("Save data size is incorrect, was the file corrupted?");
	return -1;
	}

	/* once we've read the file in, the storage handle is no longer needed */
	read_result = SDL_ReadStorageFile(save_storage, SAVE_FILE_NAME, &game_world, sizeof(game_world));
	SDL_CloseStorage(save_storage);

	SDL_SetAtomicInt(&current_save_state, SAVE_STATE_PROCESSING_GAME_WORLD);

	if (read_result) {
	/* again, let's just pretend that an entire game fits in 64-bits */
	SDL_Log("Game World loaded, value was %" SDL_PRIu64, game_world);
	}

	/* regardless of what happened above, we've reached the end of the routine */
	SDL_SetAtomicInt(&current_save_state, SAVE_STATE_FINAL_CHECK);

	if (!read_result) {
	return -1;
	}
	return 0;
	}

	/* We will use this renderer to draw into this window every frame. */
	static SDL_Window *window = NULL;
	static SDL_Renderer *renderer = NULL;

	/* This function runs once at startup. */
	SDL_AppResult SDL_AppInit(void *appstate, int argc, char argv[])
	{
	SDL_SetAppMetadata("User Storage Example", "1.0", "com.example.storage-user");

	if (!SDL_Init(SDL_INIT_VIDEO)) {
	SDL_Log("Couldn't initialize SDL: %s", SDL_GetError());
	return SDL_APP_FAILURE;
	}

	if (!SDL_CreateWindowAndRenderer("examples/storage/user", 640, 480, 0, &window, &renderer)) {
	SDL_Log("Couldn't create window/renderer: %s", SDL_GetError());
	return SDL_APP_FAILURE;
	}

	/* initialize the default save state */
	SDL_SetAtomicInt(&current_save_state, SAVE_STATE_UNSTARTED);
	storage_ready = SDL_CreateSemaphore(0);

	return SDL_APP_CONTINUE; /* carry on with the program! */
	}

	/* This function runs when a new event (mouse input, keypresses, etc) occurs. */
	SDL_AppResult SDL_AppEvent(void appstate, SDL_Event event)
	{
	if (event->type == SDL_EVENT_QUIT) {
	return SDL_APP_SUCCESS; /* end the program, reporting success to the OS. */
	} else if (event->type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
	if (save_thread != NULL) {
	SDL_Log("Ignoring interaction, save/load is in progress");
	} else {
	/* once the thread starts, it will update this to the first "real" state */
	SDL_SetAtomicInt(&current_save_state, SAVE_STATE_UNSTARTED);
	if (event->button.button == 1) {
	save_thread = SDL_CreateThread(WriteSaveData, "Save Write Thread", NULL);
	} else {
	save_thread = SDL_CreateThread(ReadSaveData, "Save Read Thread", NULL);
	}
	}
	}
	return SDL_APP_CONTINUE; /* carry on with the program! */
	}

	/* This function runs once per frame, and is the heart of the program. */
	SDL_AppResult SDL_AppIterate(void *appstate)
	{
	float red, green, blue;
	int save_state = SDL_GetAtomicInt(&current_save_state);

	/* the main thread does not have to do much other than help the thread wait
	* for storage to be ready and read the result when the thread is finished
	*/
	if (save_state == SAVE_STATE_PREPARING_STORAGE) {
	if (SDL_StorageReady(save_storage)) {
	SDL_SetAtomicInt(&current_save_state, SAVE_STATE_PROCESSING_STORAGE_FILE);
	SDL_SignalSemaphore(storage_ready);
	}
	} else if (save_state == SAVE_STATE_FINAL_CHECK) {
	if (save_thread != NULL) {
	SDL_WaitThread(save_thread, &save_result);
	save_thread = NULL;
	if (save_result == 0) {
	SDL_Log("Save/Load complete!");
	} else {
	SDL_Log("Save/Load failed: %s", SDL_GetError());
	}
	}
	}

	/* set the draw color based on the state of the save system */
	switch (save_state)
	{
	case SAVE_STATE_UNSTARTED:
	red = 0.0f;
	green = 0.0f;
	blue = 1.0f;
	break;
	case SAVE_STATE_PROCESSING_GAME_WORLD:
	red = 1.0f;
	green = 1.0f;
	blue = 0.0f;
	break;
	case SAVE_STATE_PREPARING_STORAGE:
	red = 0.0f;
	green = 1.0f;
	blue = 1.0f;
	break;
	case SAVE_STATE_PROCESSING_STORAGE_FILE:
	red = 1.0f;
	green = 0.0f;
	blue = 1.0f;
	break;
	case SAVE_STATE_FINAL_CHECK:
	if (save_result == 0) {
	red = 0.0f;
	green = 1.0f;
	} else {
	red = 1.0f;
	green = 0.0f;
	}
	blue = 0.0f;
	break;
	default:
	red = 0.0f;
	green = 0.0f;
	blue = 0.0f;
	SDL_assert(!"Unrecognized save state");
	break;
	}
	SDL_SetRenderDrawColorFloat(renderer, red, green, blue, SDL_ALPHA_OPAQUE_FLOAT); /* new color, full alpha. */

	/* clear the window to the draw color. */
	SDL_RenderClear(renderer);

	/* put the newly-cleared rendering on the screen. */
	SDL_RenderPresent(renderer);

	return SDL_APP_CONTINUE; /* carry on with the program! */
	}

	/* This function runs once at shutdown. */
	void SDL_AppQuit(void *appstate, SDL_AppResult result)
	{
	/* If saving/loading is still in progress, force the thread not to wait */
	SDL_SignalSemaphore(storage_ready);
	SDL_WaitThread(save_thread, NULL);
	SDL_DestroySemaphore(storage_ready);

	/* SDL will clean up the window/renderer for us. */
	}