#4551 - remove utils (inline in rcore) and move to RL_FS macros

build.zig

@@ -196,8 +196,8 @@ fn compileRaylib(b: *std.Build, target: std.Build.ResolvedTarget, optimize: std.
         raylib.root_module.addIncludePath(b.path("src/external/glfw/include"));
     }
 
-    var c_source_files: std.ArrayList([]const u8) = try .initCapacity(b.allocator, 2);
+    var c_source_files: std.ArrayList([]const u8) = try .initCapacity(b.allocator, 1);
-    c_source_files.appendSliceAssumeCapacity(&.{ "src/rcore.c", "src/utils.c" });
+    c_source_files.appendSliceAssumeCapacity(&.{"src/rcore.c"});
 
     if (options.rshapes) {
         try c_source_files.append(b.allocator, "src/rshapes.c");

projects/VS2022/raylib/raylib.vcxproj

@@ -582,7 +582,6 @@
     <ClCompile Include="..\..\..\src\rshapes.c" />
     <ClCompile Include="..\..\..\src\rtext.c" />
     <ClCompile Include="..\..\..\src\rtextures.c" />
-    <ClCompile Include="..\..\..\src\utils.c" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\..\..\src\external\cgltf.h" />

projects/VS2022/raylib/raylib.vcxproj.filters

@@ -22,9 +22,6 @@
     <ClCompile Include="..\..\..\src\rtextures.c">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\..\src\utils.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="..\..\..\src\platforms\rcore_android.c">
       <Filter>Source Files\Platform Files</Filter>
     </ClCompile>
@@ -105,9 +102,6 @@
     <ClInclude Include="..\..\..\src\external\stb_vorbis.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="..\..\..\src\utils.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="..\..\..\src\raylib.dll.rc" />

src/CMakeLists.txt

@@ -36,7 +36,6 @@ set(raylib_sources
     rshapes.c
     rtext.c
     rtextures.c
-    utils.c
     )
 
 # <root>/cmake/GlfwImport.cmake handles the details around the inclusion of glfw

src/Makefile

@@ -658,8 +658,7 @@ endif
 OBJS = rcore.o \
        rshapes.o \
        rtextures.o \
-       rtext.o \
+       rtext.o
-       utils.o
 
 ifeq ($(TARGET_PLATFORM),PLATFORM_DESKTOP_GLFW)
     ifeq ($(USE_EXTERNAL_GLFW),FALSE)
@@ -758,7 +757,7 @@ endif
 rcore.o : platforms/*.c
 
 # Compile core module
-rcore.o : rcore.c raylib.h rlgl.h utils.h raymath.h rcamera.h rgestures.h
+rcore.o : rcore.c raylib.h rlgl.h raymath.h rcamera.h rgestures.h
 	$(CC) -c $< $(CFLAGS) $(INCLUDE_PATHS)
 
 # Compile rglfw module
@@ -770,16 +769,14 @@ rshapes.o : rshapes.c raylib.h rlgl.h
 	$(CC) -c $< $(CFLAGS) $(INCLUDE_PATHS)
 
 # Compile textures module
-rtextures.o : rtextures.c raylib.h rlgl.h utils.h
+rtextures.o : rtextures.c raylib.h rlgl.h
 	$(CC) -c $< $(CFLAGS) $(INCLUDE_PATHS)
 
 # Compile text module
-rtext.o : rtext.c raylib.h utils.h
+rtext.o : rtext.c raylib.h
 	$(CC) -c $< $(CFLAGS) $(INCLUDE_PATHS)
 
-# Compile utils module
+# utils module has been integrated into rcore
-utils.o : utils.c utils.h
-	$(CC) -c $< $(CFLAGS) $(INCLUDE_PATHS)
 
 # Compile models module
 rmodels.o : rmodels.c raylib.h rlgl.h raymath.h

src/config.h

@@ -30,7 +30,7 @@
 
 //------------------------------------------------------------------------------------
 // Module selection - Some modules could be avoided
-// Mandatory modules: rcore, rlgl, utils
+// Mandatory modules: rcore, rlgl
 //------------------------------------------------------------------------------------
 #define SUPPORT_MODULE_RSHAPES          1
 #define SUPPORT_MODULE_RTEXTURES        1

src/platforms/rcore_android.c

@@ -86,6 +86,20 @@ typedef struct {
 extern CoreData CORE;                   // Global CORE state context
 static PlatformData platform = { 0 };   // Platform specific data
 
+// Android asset manager for accessing packaged resources
+static AAssetManager *assetManager = NULL;          // Android assets manager pointer
+static const char *internalDataPath = NULL;         // Android internal data path
+
+//----------------------------------------------------------------------------------
+// Module Internal Functions Declaration
+//----------------------------------------------------------------------------------
+void InitAssetManager(AAssetManager *manager, const char *dataPath);
+FILE *android_fopen(const char *fileName, const char *mode);
+static int android_read(void *cookie, char *data, int dataSize);
+static int android_write(void *cookie, const char *data, int dataSize);
+static fpos_t android_seek(void *cookie, fpos_t offset, int whence);
+static int android_close(void *cookie);
+
 //----------------------------------------------------------------------------------
 // Local Variables Definition
 //----------------------------------------------------------------------------------
@@ -1533,4 +1547,68 @@ static void SetupFramebuffer(int width, int height)
     }
 }
 
+//----------------------------------------------------------------------------------
+// Module Internal Functions Definition: Android Asset Manager
+//----------------------------------------------------------------------------------
+
+// Initialize asset manager from android app
+void InitAssetManager(AAssetManager *manager, const char *dataPath)
+{
+    assetManager = manager;
+    internalDataPath = dataPath;
+}
+
+// Replacement for fopen()
+// REF: https://developer.android.com/ndk/reference/group/asset
+FILE *android_fopen(const char *fileName, const char *mode)
+{
+    if (mode[0] == 'w')
+    {
+        // NOTE: fopen() is mapped to android_fopen() that only grants read access to
+        // assets directory through AAssetManager but we want to also be able to
+        // write data when required using the standard stdio FILE access functions
+        // REF: https://stackoverflow.com/questions/11294487/android-writing-saving-files-from-native-code-only
+        return fopen(TextFormat("%s/%s", internalDataPath, fileName), mode);
+    }
+    else
+    {
+        // NOTE: AAsset provides access to read-only asset
+        AAsset *asset = AAssetManager_open(assetManager, fileName, AASSET_MODE_UNKNOWN);
+
+        if (asset != NULL)
+        {
+            // Get pointer to file in the assets
+            return funopen(asset, android_read, android_write, android_seek, android_close);
+        }
+        else
+        {
+            // Just do a regular open if file is not found in the assets
+            return fopen(TextFormat("%s/%s", internalDataPath, fileName), mode);
+        }
+    }
+}
+
+static int android_read(void *cookie, char *data, int dataSize)
+{
+    return AAsset_read((AAsset *)cookie, data, dataSize);
+}
+
+static int android_write(void *cookie, const char *data, int dataSize)
+{
+    TRACELOG(LOG_WARNING, "ANDROID: Failed to provide write access to APK");
+
+    return EACCES;
+}
+
+static fpos_t android_seek(void *cookie, fpos_t offset, int whence)
+{
+    return AAsset_seek((AAsset *)cookie, offset, whence);
+}
+
+static int android_close(void *cookie)
+{
+    AAsset_close((AAsset *)cookie);
+    return 0;
+}
+
 // EOF

src/raudio.c

@@ -78,7 +78,7 @@
     #if !defined(EXTERNAL_CONFIG_FLAGS)
         #include "config.h"     // Defines module configuration flags
     #endif
-    #include "utils.h"          // Required for: fopen() Android mapping
+    // TRACELOG macros are defined in raylib.h
 #endif
 
 #if defined(SUPPORT_MODULE_RAUDIO) || defined(RAUDIO_STANDALONE)

src/raylib.h

@@ -141,6 +141,98 @@
     #define RL_FREE(ptr)        free(ptr)
 #endif
 
+// File system operations abstraction
+// NOTE: Require recompiling raylib sources
+#ifndef RL_FS_FOPEN
+    #define RL_FS_FOPEN(name, mode)                     fopen(name, mode)
+#endif
+#ifndef RL_FS_FCLOSE
+    #define RL_FS_FCLOSE(stream)                        fclose(stream)
+#endif
+#ifndef RL_FS_FREAD
+    #define RL_FS_FREAD(ptr, size, count, stream)       fread(ptr, size, count, stream)
+#endif
+#ifndef RL_FS_FWRITE
+    #define RL_FS_FWRITE(ptr, size, count, stream)      fwrite(ptr, size, count, stream)
+#endif
+#ifndef RL_FS_FSEEK
+    #define RL_FS_FSEEK(stream, offset, whence)         fseek(stream, offset, whence)
+#endif
+#ifndef RL_FS_FTELL
+    #define RL_FS_FTELL(stream)                         ftell(stream)
+#endif
+#ifndef RL_FS_FPRINTF
+    #define RL_FS_FPRINTF                               fprintf
+#endif
+#ifndef RL_FS_REMOVE
+    #define RL_FS_REMOVE(name)                          remove(name)
+#endif
+#ifndef RL_FS_RENAME
+    #define RL_FS_RENAME(old, new)                      rename(old, new)
+#endif
+
+// Platform-specific directory and file system operations
+#if defined(_WIN32)
+    #ifndef RL_FS_STAT
+        #define RL_FS_STAT(path, buf)                   _stat(path, buf)
+    #endif
+    #ifndef RL_FS_ACCESS
+        #define RL_FS_ACCESS(fn)                        _access(fn, 0)
+    #endif
+    #ifndef RL_FS_CHDIR
+        #define RL_FS_CHDIR(dir)                        _chdir(dir)
+    #endif
+    #ifndef RL_FS_GETCWD
+        #define RL_FS_GETCWD(buf, size)                 _getcwd(buf, size)
+    #endif
+    #ifndef RL_FS_MKDIR
+        #define RL_FS_MKDIR(dir)                        _mkdir(dir)
+    #endif
+#else
+    #ifndef RL_FS_STAT
+        #define RL_FS_STAT(path, buf)                   stat(path, buf)
+    #endif
+    #ifndef RL_FS_ACCESS
+        #define RL_FS_ACCESS(fn)                        access(fn, F_OK)
+    #endif
+    #ifndef RL_FS_CHDIR
+        #define RL_FS_CHDIR(dir)                        chdir(dir)
+    #endif
+    #ifndef RL_FS_GETCWD
+        #define RL_FS_GETCWD(buf, size)                 getcwd(buf, size)
+    #endif
+    #ifndef RL_FS_MKDIR
+        #define RL_FS_MKDIR(dir)                        mkdir(dir, 0777)
+    #endif
+#endif
+
+// Directory operations (both Windows and POSIX)
+#ifndef RL_FS_OPENDIR
+    #define RL_FS_OPENDIR(name)                         opendir(name)
+#endif
+#ifndef RL_FS_READDIR
+    #define RL_FS_READDIR(dir)                          readdir(dir)
+#endif
+#ifndef RL_FS_CLOSEDIR
+    #define RL_FS_CLOSEDIR(dir)                         closedir(dir)
+#endif
+
+//------------------------------------------------------------------------------------
+// Logging macros
+//------------------------------------------------------------------------------------
+#if defined(SUPPORT_TRACELOG)
+    #define TRACELOG(level, ...) TraceLog(level, __VA_ARGS__)
+
+    #if defined(SUPPORT_TRACELOG_DEBUG)
+        #define TRACELOGD(...) TraceLog(LOG_DEBUG, __VA_ARGS__)
+    #else
+        #define TRACELOGD(...) (void)0
+    #endif
+#else
+    #define TRACELOG(level, ...) (void)0
+    #define TRACELOGD(...) (void)0
+#endif
+
 // NOTE: MSVC C++ compiler does not support compound literals (C99 feature)
 // Plain structures in C++ (without constructors) can be initialized with { }
 // This is called aggregate initialization (C++11 feature)

src/rcore.c

@@ -109,7 +109,7 @@
     #include "config.h"             // Defines module configuration flags
 #endif
 
-#include "utils.h"                  // Required for: TRACELOG() macros
+// TRACELOG macros are defined in raylib.h
 
 #include <stdlib.h>                 // Required for: srand(), rand(), atexit()
 #include <stdio.h>                  // Required for: sprintf() [Used in OpenURL()]
@@ -117,6 +117,10 @@
 #include <time.h>                   // Required for: time() [Used in InitTimer()]
 #include <math.h>                   // Required for: tan() [Used in BeginMode3D()], atan2f() [Used in LoadVrStereoConfig()]
 
+#if defined(PLATFORM_ANDROID)
+    #include <android/log.h>            // Required for: __android_log_vprint()
+#endif
+
 #if defined(PLATFORM_MEMORY) || defined(PLATFORM_WEB)
     #define SW_GL_FRAMEBUFFER_COPY_BGRA false
 #endif
@@ -194,24 +198,16 @@
     #define DIRENT_MALLOC RL_MALLOC
     #define DIRENT_FREE RL_FREE
 
-    #include "external/dirent.h"    // Required for: DIR, opendir(), closedir() [Used in LoadDirectoryFiles()]
+    #include "external/dirent.h"    // Required for: DIR, RL_FS_OPENDIR(), RL_FS_CLOSEDIR() [Used in LoadDirectoryFiles()]
 #else
-    #include <dirent.h>             // Required for: DIR, opendir(), closedir() [Used in LoadDirectoryFiles()]
+    #include <dirent.h>             // Required for: DIR, RL_FS_OPENDIR(), RL_FS_CLOSEDIR() [Used in LoadDirectoryFiles()]
 #endif
 
 #if defined(_WIN32)
     #include <io.h>                 // Required for: _access() [Used in FileExists()]
     #include <direct.h>             // Required for: _getch(), _chdir(), _mkdir()
-    #define GETCWD _getcwd          // NOTE: MSDN recommends not to use getcwd(), chdir()
-    #define CHDIR _chdir
-    #define MKDIR(dir) _mkdir(dir)
-    #define ACCESS(fn) _access(fn, 0)
 #else
     #include <unistd.h>             // Required for: getch(), chdir(), mkdir(), access()
-    #define GETCWD getcwd
-    #define CHDIR chdir
-    #define MKDIR(dir) mkdir(dir, 0777)
-    #define ACCESS(fn) access(fn, F_OK)
 #endif
 
 //----------------------------------------------------------------------------------
@@ -388,6 +384,13 @@ RLAPI const char *raylib_version = RAYLIB_VERSION;  // raylib version exported s
 
 CoreData CORE = { 0 };                      // Global CORE state context
 
+static int logTypeLevel = LOG_INFO;                 // Minimum log type level
+static TraceLogCallback traceLog = NULL;            // TraceLog callback function pointer
+static LoadFileDataCallback loadFileData = NULL;    // LoadFileData callback function pointer
+static SaveFileDataCallback saveFileData = NULL;    // SaveFileText callback function pointer
+static LoadFileTextCallback loadFileText = NULL;    // LoadFileText callback function pointer
+static SaveFileTextCallback saveFileText = NULL;    // SaveFileText callback function pointer
+
 #if defined(SUPPORT_SCREEN_CAPTURE)
 static int screenshotCounter = 0;           // Screenshots counter
 #endif
@@ -547,6 +550,9 @@ const char *TextFormat(const char *text, ...); // Formatting of text with variab
 #elif defined(PLATFORM_DRM)
     #include "platforms/rcore_drm.c"
 #elif defined(PLATFORM_ANDROID)
+    // Android requires custom fopen to support asset manager
+    FILE *android_fopen(const char *fileName, const char *mode);
+    #define RL_FS_FOPEN(name, mode) android_fopen(name, mode)
     #include "platforms/rcore_android.c"
 #elif defined(PLATFORM_MEMORY)
     #include "platforms/rcore_memory.c"
@@ -1856,10 +1862,387 @@ void SetConfigFlags(unsigned int flags)
     FLAG_SET(CORE.Window.flags, flags);
 }
 
+//----------------------------------------------------------------------------------
+// Module Functions Definition: Logging and Memory
+//----------------------------------------------------------------------------------
+
+// Set the current threshold (minimum) log level
+void SetTraceLogLevel(int logType)
+{
+    logTypeLevel = logType;
+}
+
+// Set custom trace log callback
+void SetTraceLogCallback(TraceLogCallback callback)
+{
+    traceLog = callback;
+}
+
+// Show trace log messages (LOG_INFO, LOG_WARNING, LOG_ERROR, LOG_DEBUG)
+void TraceLog(int logType, const char *text, ...)
+{
+#if defined(SUPPORT_TRACELOG)
+    // Message has level below current threshold, don't emit
+    if ((logType < logTypeLevel) || (text == NULL)) return;
+
+    va_list args;
+    va_start(args, text);
+
+    if (traceLog)
+    {
+        traceLog(logType, text, args);
+        va_end(args);
+        return;
+    }
+
+#if defined(PLATFORM_ANDROID)
+    switch (logType)
+    {
+        case LOG_TRACE: __android_log_vprint(ANDROID_LOG_VERBOSE, "raylib", text, args); break;
+        case LOG_DEBUG: __android_log_vprint(ANDROID_LOG_DEBUG, "raylib", text, args); break;
+        case LOG_INFO: __android_log_vprint(ANDROID_LOG_INFO, "raylib", text, args); break;
+        case LOG_WARNING: __android_log_vprint(ANDROID_LOG_WARN, "raylib", text, args); break;
+        case LOG_ERROR: __android_log_vprint(ANDROID_LOG_ERROR, "raylib", text, args); break;
+        case LOG_FATAL: __android_log_vprint(ANDROID_LOG_FATAL, "raylib", text, args); break;
+        default: break;
+    }
+#else
+    char buffer[MAX_TRACELOG_MSG_LENGTH] = { 0 };
+
+    switch (logType)
+    {
+        case LOG_TRACE: strcpy(buffer, "TRACE: "); break;
+        case LOG_DEBUG: strcpy(buffer, "DEBUG: "); break;
+        case LOG_INFO: strcpy(buffer, "INFO: "); break;
+        case LOG_WARNING: strcpy(buffer, "WARNING: "); break;
+        case LOG_ERROR: strcpy(buffer, "ERROR: "); break;
+        case LOG_FATAL: strcpy(buffer, "FATAL: "); break;
+        default: break;
+    }
+
+    unsigned int textLength = (unsigned int)strlen(text);
+    memcpy(buffer + strlen(buffer), text, (textLength < (MAX_TRACELOG_MSG_LENGTH - 12))? textLength : (MAX_TRACELOG_MSG_LENGTH - 12));
+    strcat(buffer, "\n");
+    vprintf(buffer, args);
+    fflush(stdout);
+#endif
+
+    va_end(args);
+
+    if (logType == LOG_FATAL) exit(EXIT_FAILURE);  // If fatal logging, exit program
+
+#endif  // SUPPORT_TRACELOG
+}
+
+// Internal memory allocator
+// NOTE: Initializes to zero by default
+void *MemAlloc(unsigned int size)
+{
+    void *ptr = RL_CALLOC(size, 1);
+    return ptr;
+}
+
+// Internal memory reallocator
+void *MemRealloc(void *ptr, unsigned int size)
+{
+    void *ret = RL_REALLOC(ptr, size);
+    return ret;
+}
+
+// Internal memory free
+void MemFree(void *ptr)
+{
+    RL_FREE(ptr);
+}
+
+// Set custom file data loader
+void SetLoadFileDataCallback(LoadFileDataCallback callback)
+{
+    loadFileData = callback;
+}
+
+// Set custom file data saver
+void SetSaveFileDataCallback(SaveFileDataCallback callback)
+{
+    saveFileData = callback;
+}
+
+// Set custom file text loader
+void SetLoadFileTextCallback(LoadFileTextCallback callback)
+{
+    loadFileText = callback;
+}
+
+// Set custom file text saver
+void SetSaveFileTextCallback(SaveFileTextCallback callback)
+{
+    saveFileText = callback;
+}
+
 //----------------------------------------------------------------------------------
 // Module Functions Definition: File system
 //----------------------------------------------------------------------------------
 
+// Load data from file into a buffer
+unsigned char *LoadFileData(const char *fileName, int *dataSize)
+{
+    unsigned char *data = NULL;
+    *dataSize = 0;
+
+    if (fileName != NULL)
+    {
+        if (loadFileData)
+        {
+            data = loadFileData(fileName, dataSize);
+            return data;
+        }
+#if defined(SUPPORT_STANDARD_FILEIO)
+        FILE *file = RL_FS_FOPEN(fileName, "rb");
+
+        if (file != NULL)
+        {
+            // WARNING: On binary streams SEEK_END could not be found,
+            // using fseek() and ftell() could not work in some (rare) cases
+            RL_FS_FSEEK(file, 0, SEEK_END);
+            int size = RL_FS_FTELL(file);     // WARNING: ftell() returns 'long int', maximum size returned is INT_MAX (2147483647 bytes)
+            RL_FS_FSEEK(file, 0, SEEK_SET);
+
+            if (size > 0)
+            {
+                data = (unsigned char *)RL_CALLOC(size, sizeof(unsigned char));
+
+                if (data != NULL)
+                {
+                    // NOTE: fread() returns number of read elements instead of bytes, so we read [1 byte, size elements]
+                    size_t count = RL_FS_FREAD(data, sizeof(unsigned char), size, file);
+
+                    // WARNING: fread() returns a size_t value, usually 'unsigned int' (32bit compilation) and 'unsigned long long' (64bit compilation)
+                    // dataSize is unified along raylib as a 'int' type, so, for file-sizes > INT_MAX (2147483647 bytes) we have a limitation
+                    if (count > 2147483647)
+                    {
+                        TRACELOG(LOG_WARNING, "FILEIO: [%s] File is bigger than 2147483647 bytes, avoid using LoadFileData()", fileName);
+
+                        RL_FREE(data);
+                        data = NULL;
+                    }
+                    else
+                    {
+                        *dataSize = (int)count;
+
+                        if ((*dataSize) != size) TRACELOG(LOG_WARNING, "FILEIO: [%s] File partially loaded (%i bytes out of %i)", fileName, dataSize, count);
+                        else TRACELOG(LOG_INFO, "FILEIO: [%s] File loaded successfully", fileName);
+                    }
+                }
+                else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to allocated memory for file reading", fileName);
+            }
+            else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to read file", fileName);
+
+            RL_FS_FCLOSE(file);
+        }
+        else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to open file", fileName);
+#else
+    TRACELOG(LOG_WARNING, "FILEIO: Standard file io not supported, use custom file callback");
+#endif
+    }
+    else TRACELOG(LOG_WARNING, "FILEIO: File name provided is not valid");
+
+    return data;
+}
+
+// Unload file data allocated by LoadFileData()
+void UnloadFileData(unsigned char *data)
+{
+    RL_FREE(data);
+}
+
+// Save data to file from buffer
+bool SaveFileData(const char *fileName, void *data, int dataSize)
+{
+    bool success = false;
+
+    if (fileName != NULL)
+    {
+        if (saveFileData)
+        {
+            return saveFileData(fileName, data, dataSize);
+        }
+#if defined(SUPPORT_STANDARD_FILEIO)
+        FILE *file = RL_FS_FOPEN(fileName, "wb");
+
+        if (file != NULL)
+        {
+            // WARNING: fwrite() returns a size_t value, usually 'unsigned int' (32bit compilation) and 'unsigned long long' (64bit compilation)
+            // and expects a size_t input value but as dataSize is limited to INT_MAX (2147483647 bytes), there shouldn't be a problem
+            int count = (int)RL_FS_FWRITE(data, sizeof(unsigned char), dataSize, file);
+
+            if (count == 0) TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to write file", fileName);
+            else if (count != dataSize) TRACELOG(LOG_WARNING, "FILEIO: [%s] File partially written", fileName);
+            else TRACELOG(LOG_INFO, "FILEIO: [%s] File saved successfully", fileName);
+
+            int result = RL_FS_FCLOSE(file);
+            if (result == 0) success = true;
+        }
+        else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to open file", fileName);
+#else
+    TRACELOG(LOG_WARNING, "FILEIO: Standard file io not supported, use custom file callback");
+#endif
+    }
+    else TRACELOG(LOG_WARNING, "FILEIO: File name provided is not valid");
+
+    return success;
+}
+
+// Export data to code (.h), returns true on success
+bool ExportDataAsCode(const unsigned char *data, int dataSize, const char *fileName)
+{
+    bool success = false;
+
+#ifndef TEXT_BYTES_PER_LINE
+    #define TEXT_BYTES_PER_LINE     20
+#endif
+
+    // NOTE: Text data buffer size is estimated considering raw data size in bytes
+    // and requiring 6 char bytes for every byte: "0x00, "
+    char *txtData = (char *)RL_CALLOC(dataSize*6 + 2000, sizeof(char));
+
+    int byteCount = 0;
+    byteCount += sprintf(txtData + byteCount, "////////////////////////////////////////////////////////////////////////////////////////\n");
+    byteCount += sprintf(txtData + byteCount, "//                                                                                    //\n");
+    byteCount += sprintf(txtData + byteCount, "// DataAsCode exporter v1.0 - Raw data exported as an array of bytes                  //\n");
+    byteCount += sprintf(txtData + byteCount, "//                                                                                    //\n");
+    byteCount += sprintf(txtData + byteCount, "// more info and bugs-report:  github.com/raysan5/raylib                              //\n");
+    byteCount += sprintf(txtData + byteCount, "// feedback and support:       ray[at]raylib.com                                      //\n");
+    byteCount += sprintf(txtData + byteCount, "//                                                                                    //\n");
+    byteCount += sprintf(txtData + byteCount, "// Copyright (c) 2022-2026 Ramon Santamaria (@raysan5)                                //\n");
+    byteCount += sprintf(txtData + byteCount, "//                                                                                    //\n");
+    byteCount += sprintf(txtData + byteCount, "////////////////////////////////////////////////////////////////////////////////////////\n\n");
+
+    // Get file name from path
+    char varFileName[256] = { 0 };
+    strncpy(varFileName, GetFileNameWithoutExt(fileName), 256 - 1);
+    for (int i = 0; varFileName[i] != '\0'; i++)
+    {
+        // Convert variable name to uppercase
+        if ((varFileName[i] >= 'a') && (varFileName[i] <= 'z')) { varFileName[i] = varFileName[i] - 32; }
+        // Replace non valid character for C identifier with '_'
+        else if (varFileName[i] == '.' || varFileName[i] == '-' || varFileName[i] == '?' || varFileName[i] == '!' || varFileName[i] == '+') { varFileName[i] = '_'; }
+    }
+
+    byteCount += sprintf(txtData + byteCount, "#define %s_DATA_SIZE     %i\n\n", varFileName, dataSize);
+
+    byteCount += sprintf(txtData + byteCount, "static unsigned char %s_DATA[%s_DATA_SIZE] = { ", varFileName, varFileName);
+    for (int i = 0; i < (dataSize - 1); i++) byteCount += sprintf(txtData + byteCount, ((i%TEXT_BYTES_PER_LINE == 0)? "0x%x,\n" : "0x%x, "), data[i]);
+    byteCount += sprintf(txtData + byteCount, "0x%x };\n", data[dataSize - 1]);
+
+    // NOTE: Text data size exported is determined by '\0' (NULL) character
+    success = SaveFileText(fileName, txtData);
+
+    RL_FREE(txtData);
+
+    if (success != 0) TRACELOG(LOG_INFO, "FILEIO: [%s] Data as code exported successfully", fileName);
+    else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to export data as code", fileName);
+
+    return success;
+}
+
+// Load text data from file, returns a '\0' terminated string
+// NOTE: text chars array should be freed manually
+char *LoadFileText(const char *fileName)
+{
+    char *text = NULL;
+
+    if (fileName != NULL)
+    {
+        if (loadFileText)
+        {
+            text = loadFileText(fileName);
+            return text;
+        }
+#if defined(SUPPORT_STANDARD_FILEIO)
+        FILE *file = RL_FS_FOPEN(fileName, "rt");
+
+        if (file != NULL)
+        {
+            // WARNING: When reading a file as 'text' file,
+            // text mode causes carriage return-linefeed translation...
+            // ...but using fseek() should return correct byte-offset
+            RL_FS_FSEEK(file, 0, SEEK_END);
+            unsigned int size = (unsigned int)RL_FS_FTELL(file);
+            RL_FS_FSEEK(file, 0, SEEK_SET);
+
+            if (size > 0)
+            {
+                text = (char *)RL_CALLOC(size + 1, sizeof(char));
+
+                if (text != NULL)
+                {
+                    unsigned int count = (unsigned int)RL_FS_FREAD(text, sizeof(char), size, file);
+
+                    // WARNING: \r\n is converted to \n on reading, so,
+                    // read bytes count gets reduced by the number of lines
+                    if (count < size) text = (char *)RL_REALLOC(text, count + 1);
+
+                    // Zero-terminate the string
+                    text[count] = '\0';
+
+                    TRACELOG(LOG_INFO, "FILEIO: [%s] Text file loaded successfully", fileName);
+                }
+                else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to allocated memory for file reading", fileName);
+            }
+            else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to read text file", fileName);
+
+            RL_FS_FCLOSE(file);
+        }
+        else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to open text file", fileName);
+#else
+    TRACELOG(LOG_WARNING, "FILEIO: Standard file io not supported, use custom file callback");
+#endif
+    }
+    else TRACELOG(LOG_WARNING, "FILEIO: File name provided is not valid");
+
+    return text;
+}
+
+// Unload file text data allocated by LoadFileText()
+void UnloadFileText(char *text)
+{
+    RL_FREE(text);
+}
+
+// Save text data to file (write), string must be '\0' terminated
+bool SaveFileText(const char *fileName, const char *text)
+{
+    bool success = false;
+
+    if (fileName != NULL)
+    {
+        if (saveFileText)
+        {
+            return saveFileText(fileName, text);
+        }
+#if defined(SUPPORT_STANDARD_FILEIO)
+        FILE *file = RL_FS_FOPEN(fileName, "wt");
+
+        if (file != NULL)
+        {
+            int count = RL_FS_FPRINTF(file, "%s", text);
+
+            if (count < 0) TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to write text file", fileName);
+            else TRACELOG(LOG_INFO, "FILEIO: [%s] Text file saved successfully", fileName);
+
+            int result = RL_FS_FCLOSE(file);
+            if (result == 0) success = true;
+        }
+        else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to open text file", fileName);
+#else
+    TRACELOG(LOG_WARNING, "FILEIO: Standard file io not supported, use custom file callback");
+#endif
+    }
+    else TRACELOG(LOG_WARNING, "FILEIO: File name provided is not valid");
+
+    return success;
+}
+
 // Rename file (if exists)
 // NOTE: Only rename file name required, not full path
 int FileRename(const char *fileName, const char *fileRename)
@@ -1868,7 +2251,7 @@ int FileRename(const char *fileName, const char *fileRename)
 
     if (FileExists(fileName))
     {
-        result = rename(fileName, fileRename);
+        result = RL_FS_RENAME(fileName, fileRename);
     }
     else result = -1;
 
@@ -1882,7 +2265,7 @@ int FileRemove(const char *fileName)
 
     if (FileExists(fileName))
     {
-        result = remove(fileName);
+        result = RL_FS_REMOVE(fileName);
     }
     else result = -1;
 
@@ -1974,7 +2357,7 @@ bool FileExists(const char *fileName)
 {
     bool result = false;
 
-    if (ACCESS(fileName) != -1) result = true;
+    if (RL_FS_ACCESS(fileName) != -1) result = true;
 
     // NOTE: Alternatively, stat() can be used instead of access()
     //#include <sys/stat.h>
@@ -2052,12 +2435,12 @@ bool IsFileExtension(const char *fileName, const char *ext)
 bool DirectoryExists(const char *dirPath)
 {
     bool result = false;
-    DIR *dir = opendir(dirPath);
+    DIR *dir = RL_FS_OPENDIR(dirPath);
 
     if (dir != NULL)
     {
         result = true;
-        closedir(dir);
+        RL_FS_CLOSEDIR(dir);
     }
 
     return result;
@@ -2245,7 +2628,7 @@ const char *GetWorkingDirectory(void)
     static char currentDir[MAX_FILEPATH_LENGTH] = { 0 };
     memset(currentDir, 0, MAX_FILEPATH_LENGTH);
 
-    char *path = GETCWD(currentDir, MAX_FILEPATH_LENGTH - 1);
+    char *path = RL_FS_GETCWD(currentDir, MAX_FILEPATH_LENGTH - 1);
 
     return path;
 }
@@ -2364,12 +2747,12 @@ FilePathList LoadDirectoryFiles(const char *dirPath)
     unsigned int fileCounter = 0;
 
     struct dirent *entity;
-    DIR *dir = opendir(dirPath);
+    DIR *dir = RL_FS_OPENDIR(dirPath);
 
     if (dir != NULL) // It's a directory
     {
         // SCAN 1: Count files
-        while ((entity = readdir(dir)) != NULL)
+        while ((entity = RL_FS_READDIR(dir)) != NULL)
         {
             // NOTE: We skip '.' (current dir) and '..' (parent dir) filepaths
             if ((strcmp(entity->d_name, ".") != 0) && (strcmp(entity->d_name, "..") != 0)) fileCounter++;
@@ -2380,7 +2763,7 @@ FilePathList LoadDirectoryFiles(const char *dirPath)
         files.paths = (char **)RL_CALLOC(files.capacity, sizeof(char *));
         for (unsigned int i = 0; i < files.capacity; i++) files.paths[i] = (char *)RL_CALLOC(MAX_FILEPATH_LENGTH, sizeof(char));
 
-        closedir(dir);
+        RL_FS_CLOSEDIR(dir);
 
         // SCAN 2: Read filepaths
         // NOTE: Directory paths are also registered
@@ -2443,14 +2826,14 @@ int MakeDirectory(const char *dirPath)
             if ((pathcpy[i] == '\\') || (pathcpy[i] == '/'))
             {
                 pathcpy[i] = '\0';
-                if (!DirectoryExists(pathcpy)) MKDIR(pathcpy);
+                if (!DirectoryExists(pathcpy)) RL_FS_MKDIR(pathcpy);
                 pathcpy[i] = '/';
             }
         }
     }
 
     // Create final directory
-    if (!DirectoryExists(pathcpy)) MKDIR(pathcpy);
+    if (!DirectoryExists(pathcpy)) RL_FS_MKDIR(pathcpy);
     RL_FREE(pathcpy);
 
     // In case something failed and requested directory
@@ -2463,7 +2846,7 @@ int MakeDirectory(const char *dirPath)
 // Change working directory, returns true on success
 bool ChangeDirectory(const char *dirPath)
 {
-    bool result = CHDIR(dirPath);
+    bool result = RL_FS_CHDIR(dirPath);
 
     if (result != 0) TRACELOG(LOG_WARNING, "SYSTEM: Failed to change to directory: %s", dirPath);
     else TRACELOG(LOG_INFO, "SYSTEM: Working Directory: %s", dirPath);
@@ -3833,11 +4216,11 @@ static void ScanDirectoryFiles(const char *basePath, FilePathList *files, const
     memset(path, 0, MAX_FILEPATH_LENGTH);
 
     struct dirent *dp = NULL;
-    DIR *dir = opendir(basePath);
+    DIR *dir = RL_FS_OPENDIR(basePath);
 
     if (dir != NULL)
     {
-        while ((dp = readdir(dir)) != NULL)
+        while ((dp = RL_FS_READDIR(dir)) != NULL)
         {
             if ((strcmp(dp->d_name, ".") != 0) &&
                 (strcmp(dp->d_name, "..") != 0))
@@ -3880,7 +4263,7 @@ static void ScanDirectoryFiles(const char *basePath, FilePathList *files, const
             }
         }
 
-        closedir(dir);
+        RL_FS_CLOSEDIR(dir);
     }
     else TRACELOG(LOG_WARNING, "FILEIO: Directory cannot be opened (%s)", basePath);
 }
@@ -3893,11 +4276,11 @@ static void ScanDirectoryFilesRecursively(const char *basePath, FilePathList *fi
     memset(path, 0, MAX_FILEPATH_LENGTH);
 
     struct dirent *dp = NULL;
-    DIR *dir = opendir(basePath);
+    DIR *dir = RL_FS_OPENDIR(basePath);
 
     if (dir != NULL)
     {
-        while (((dp = readdir(dir)) != NULL) && (files->count < files->capacity))
+        while (((dp = RL_FS_READDIR(dir)) != NULL) && (files->count < files->capacity))
         {
             if ((strcmp(dp->d_name, ".") != 0) && (strcmp(dp->d_name, "..") != 0))
             {
@@ -3953,7 +4336,7 @@ static void ScanDirectoryFilesRecursively(const char *basePath, FilePathList *fi
             }
         }
 
-        closedir(dir);
+        RL_FS_CLOSEDIR(dir);
     }
     else TRACELOG(LOG_WARNING, "FILEIO: Directory cannot be opened (%s)", basePath);
 }

src/rmodels.c

@@ -49,7 +49,7 @@
 
 #if defined(SUPPORT_MODULE_RMODELS)
 
-#include "utils.h"          // Required for: TRACELOG(), LoadFileData(), LoadFileText(), SaveFileText()
+// TRACELOG macros are defined in raylib.h
 #include "rlgl.h"           // OpenGL abstraction layer to OpenGL 1.1, 2.1, 3.3+ or ES2
 #include "raymath.h"        // Required for: Vector3, Quaternion and Matrix functionality
 

src/rtext.c

@@ -62,7 +62,7 @@
 
 #if defined(SUPPORT_MODULE_RTEXT)
 
-#include "utils.h"          // Required for: LoadFile*()
+// TRACELOG macros are defined in raylib.h
 #include "rlgl.h"           // OpenGL abstraction layer to OpenGL 1.1, 2.1, 3.3+ or ES2 -> Only DrawTextPro()
 
 #include <stdlib.h>         // Required for: malloc(), free()

src/rtextures.c

@@ -70,7 +70,7 @@
 
 #if defined(SUPPORT_MODULE_RTEXTURES)
 
-#include "utils.h"              // Required for: TRACELOG()
+// TRACELOG macros are defined in raylib.h
 #include "rlgl.h"               // OpenGL abstraction layer to multiple versions
 
 #include <stdlib.h>             // Required for: malloc(), calloc(), free()

src/utils.c

@@ -1,509 +0,0 @@
-/**********************************************************************************************
-*
-*   raylib.utils - Some common utility functions
-*
-*   CONFIGURATION:
-*       #define SUPPORT_TRACELOG
-*           Show TraceLog() output messages
-*           NOTE: By default LOG_DEBUG traces not shown
-*
-*
-*   LICENSE: zlib/libpng
-*
-*   Copyright (c) 2014-2026 Ramon Santamaria (@raysan5)
-*
-*   This software is provided "as-is", without any express or implied warranty. In no event
-*   will the authors be held liable for any damages arising from the use of this software.
-*
-*   Permission is granted to anyone to use this software for any purpose, including commercial
-*   applications, and to alter it and redistribute it freely, subject to the following restrictions:
-*
-*     1. The origin of this software must not be misrepresented; you must not claim that you
-*     wrote the original software. If you use this software in a product, an acknowledgment
-*     in the product documentation would be appreciated but is not required.
-*
-*     2. Altered source versions must be plainly marked as such, and must not be misrepresented
-*     as being the original software.
-*
-*     3. This notice may not be removed or altered from any source distribution.
-*
-**********************************************************************************************/
-
-#include "raylib.h"                     // WARNING: Required for: LogType enum
-
-// Check if config flags have been externally provided on compilation line
-#if !defined(EXTERNAL_CONFIG_FLAGS)
-    #include "config.h"                 // Defines module configuration flags
-#endif
-
-#include "utils.h"
-
-#if defined(PLATFORM_ANDROID)
-    #include <errno.h>                  // Required for: Android error types
-    #include <android/log.h>            // Required for: Android log system: __android_log_vprint()
-    #include <android/asset_manager.h>  // Required for: Android assets manager: AAsset, AAssetManager_open()...
-#endif
-
-#include <stdlib.h>                     // Required for: exit()
-#include <stdio.h>                      // Required for: FILE, fopen(), fseek(), ftell(), fread(), fwrite(), fprintf(), vprintf(), fclose()
-#include <stdarg.h>                     // Required for: va_list, va_start(), va_end()
-#include <string.h>                     // Required for: strcpy(), strcat()
-
-//----------------------------------------------------------------------------------
-// Defines and Macros
-//----------------------------------------------------------------------------------
-#ifndef MAX_TRACELOG_MSG_LENGTH
-    #define MAX_TRACELOG_MSG_LENGTH     256         // Max length of one trace-log message
-#endif
-
-//----------------------------------------------------------------------------------
-// Global Variables Definition
-//----------------------------------------------------------------------------------
-static int logTypeLevel = LOG_INFO;                 // Minimum log type level
-
-static TraceLogCallback traceLog = NULL;            // TraceLog callback function pointer
-static LoadFileDataCallback loadFileData = NULL;    // LoadFileData callback function pointer
-static SaveFileDataCallback saveFileData = NULL;    // SaveFileText callback function pointer
-static LoadFileTextCallback loadFileText = NULL;    // LoadFileText callback function pointer
-static SaveFileTextCallback saveFileText = NULL;    // SaveFileText callback function pointer
-
-//----------------------------------------------------------------------------------
-// Functions to set internal callbacks
-//----------------------------------------------------------------------------------
-void SetTraceLogCallback(TraceLogCallback callback) { traceLog = callback; }              // Set custom trace log
-void SetLoadFileDataCallback(LoadFileDataCallback callback) { loadFileData = callback; }  // Set custom file data loader
-void SetSaveFileDataCallback(SaveFileDataCallback callback) { saveFileData = callback; }  // Set custom file data saver
-void SetLoadFileTextCallback(LoadFileTextCallback callback) { loadFileText = callback; }  // Set custom file text loader
-void SetSaveFileTextCallback(SaveFileTextCallback callback) { saveFileText = callback; }  // Set custom file text saver
-
-#if defined(PLATFORM_ANDROID)
-static AAssetManager *assetManager = NULL;          // Android assets manager pointer
-static const char *internalDataPath = NULL;         // Android internal data path
-#endif
-
-//----------------------------------------------------------------------------------
-// Module Internal Functions Declaration
-//----------------------------------------------------------------------------------
-#if defined(PLATFORM_ANDROID)
-FILE *funopen(const void *cookie, int (*readfn)(void *, char *, int), int (*writefn)(void *, const char *, int),
-              fpos_t (*seekfn)(void *, fpos_t, int), int (*closefn)(void *));
-
-static int android_read(void *cookie, char *buf, int size);
-static int android_write(void *cookie, const char *buf, int size);
-static fpos_t android_seek(void *cookie, fpos_t offset, int whence);
-static int android_close(void *cookie);
-#endif
-
-//----------------------------------------------------------------------------------
-// Module Functions Definition
-//----------------------------------------------------------------------------------
-// Set the current threshold (minimum) log level
-void SetTraceLogLevel(int logType) { logTypeLevel = logType; }
-
-// Show trace log messages (LOG_INFO, LOG_WARNING, LOG_ERROR, LOG_DEBUG)
-void TraceLog(int logType, const char *text, ...)
-{
-#if defined(SUPPORT_TRACELOG)
-    // Message has level below current threshold, don't emit
-    if ((logType < logTypeLevel) || (text == NULL)) return;
-
-    va_list args;
-    va_start(args, text);
-
-    if (traceLog)
-    {
-        traceLog(logType, text, args);
-        va_end(args);
-        return;
-    }
-
-#if defined(PLATFORM_ANDROID)
-    switch (logType)
-    {
-        case LOG_TRACE: __android_log_vprint(ANDROID_LOG_VERBOSE, "raylib", text, args); break;
-        case LOG_DEBUG: __android_log_vprint(ANDROID_LOG_DEBUG, "raylib", text, args); break;
-        case LOG_INFO: __android_log_vprint(ANDROID_LOG_INFO, "raylib", text, args); break;
-        case LOG_WARNING: __android_log_vprint(ANDROID_LOG_WARN, "raylib", text, args); break;
-        case LOG_ERROR: __android_log_vprint(ANDROID_LOG_ERROR, "raylib", text, args); break;
-        case LOG_FATAL: __android_log_vprint(ANDROID_LOG_FATAL, "raylib", text, args); break;
-        default: break;
-    }
-#else
-    char buffer[MAX_TRACELOG_MSG_LENGTH] = { 0 };
-
-    switch (logType)
-    {
-        case LOG_TRACE: strcpy(buffer, "TRACE: "); break;
-        case LOG_DEBUG: strcpy(buffer, "DEBUG: "); break;
-        case LOG_INFO: strcpy(buffer, "INFO: "); break;
-        case LOG_WARNING: strcpy(buffer, "WARNING: "); break;
-        case LOG_ERROR: strcpy(buffer, "ERROR: "); break;
-        case LOG_FATAL: strcpy(buffer, "FATAL: "); break;
-        default: break;
-    }
-
-    unsigned int textLength = (unsigned int)strlen(text);
-    memcpy(buffer + strlen(buffer), text, (textLength < (MAX_TRACELOG_MSG_LENGTH - 12))? textLength : (MAX_TRACELOG_MSG_LENGTH - 12));
-    strcat(buffer, "\n");
-    vprintf(buffer, args);
-    fflush(stdout);
-#endif
-
-    va_end(args);
-
-    if (logType == LOG_FATAL) exit(EXIT_FAILURE);  // If fatal logging, exit program
-
-#endif  // SUPPORT_TRACELOG
-}
-
-// Internal memory allocator
-// NOTE: Initializes to zero by default
-void *MemAlloc(unsigned int size)
-{
-    void *ptr = RL_CALLOC(size, 1);
-    return ptr;
-}
-
-// Internal memory reallocator
-void *MemRealloc(void *ptr, unsigned int size)
-{
-    void *ret = RL_REALLOC(ptr, size);
-    return ret;
-}
-
-// Internal memory free
-void MemFree(void *ptr)
-{
-    RL_FREE(ptr);
-}
-
-// Load data from file into a buffer
-unsigned char *LoadFileData(const char *fileName, int *dataSize)
-{
-    unsigned char *data = NULL;
-    *dataSize = 0;
-
-    if (fileName != NULL)
-    {
-        if (loadFileData)
-        {
-            data = loadFileData(fileName, dataSize);
-            return data;
-        }
-#if defined(SUPPORT_STANDARD_FILEIO)
-        FILE *file = fopen(fileName, "rb");
-
-        if (file != NULL)
-        {
-            // WARNING: On binary streams SEEK_END could not be found,
-            // using fseek() and ftell() could not work in some (rare) cases
-            fseek(file, 0, SEEK_END);
-            int size = ftell(file);     // WARNING: ftell() returns 'long int', maximum size returned is INT_MAX (2147483647 bytes)
-            fseek(file, 0, SEEK_SET);
-
-            if (size > 0)
-            {
-                data = (unsigned char *)RL_CALLOC(size, sizeof(unsigned char));
-
-                if (data != NULL)
-                {
-                    // NOTE: fread() returns number of read elements instead of bytes, so we read [1 byte, size elements]
-                    size_t count = fread(data, sizeof(unsigned char), size, file);
-
-                    // WARNING: fread() returns a size_t value, usually 'unsigned int' (32bit compilation) and 'unsigned long long' (64bit compilation)
-                    // dataSize is unified along raylib as a 'int' type, so, for file-sizes > INT_MAX (2147483647 bytes) we have a limitation
-                    if (count > 2147483647)
-                    {
-                        TRACELOG(LOG_WARNING, "FILEIO: [%s] File is bigger than 2147483647 bytes, avoid using LoadFileData()", fileName);
-
-                        RL_FREE(data);
-                        data = NULL;
-                    }
-                    else
-                    {
-                        *dataSize = (int)count;
-
-                        if ((*dataSize) != size) TRACELOG(LOG_WARNING, "FILEIO: [%s] File partially loaded (%i bytes out of %i)", fileName, dataSize, count);
-                        else TRACELOG(LOG_INFO, "FILEIO: [%s] File loaded successfully", fileName);
-                    }
-                }
-                else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to allocated memory for file reading", fileName);
-            }
-            else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to read file", fileName);
-
-            fclose(file);
-        }
-        else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to open file", fileName);
-#else
-    TRACELOG(LOG_WARNING, "FILEIO: Standard file io not supported, use custom file callback");
-#endif
-    }
-    else TRACELOG(LOG_WARNING, "FILEIO: File name provided is not valid");
-
-    return data;
-}
-
-// Unload file data allocated by LoadFileData()
-void UnloadFileData(unsigned char *data)
-{
-    RL_FREE(data);
-}
-
-// Save data to file from buffer
-bool SaveFileData(const char *fileName, void *data, int dataSize)
-{
-    bool success = false;
-
-    if (fileName != NULL)
-    {
-        if (saveFileData)
-        {
-            return saveFileData(fileName, data, dataSize);
-        }
-#if defined(SUPPORT_STANDARD_FILEIO)
-        FILE *file = fopen(fileName, "wb");
-
-        if (file != NULL)
-        {
-            // WARNING: fwrite() returns a size_t value, usually 'unsigned int' (32bit compilation) and 'unsigned long long' (64bit compilation)
-            // and expects a size_t input value but as dataSize is limited to INT_MAX (2147483647 bytes), there shouldn't be a problem
-            int count = (int)fwrite(data, sizeof(unsigned char), dataSize, file);
-
-            if (count == 0) TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to write file", fileName);
-            else if (count != dataSize) TRACELOG(LOG_WARNING, "FILEIO: [%s] File partially written", fileName);
-            else TRACELOG(LOG_INFO, "FILEIO: [%s] File saved successfully", fileName);
-
-            int result = fclose(file);
-            if (result == 0) success = true;
-        }
-        else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to open file", fileName);
-#else
-    TRACELOG(LOG_WARNING, "FILEIO: Standard file io not supported, use custom file callback");
-#endif
-    }
-    else TRACELOG(LOG_WARNING, "FILEIO: File name provided is not valid");
-
-    return success;
-}
-
-// Export data to code (.h), returns true on success
-bool ExportDataAsCode(const unsigned char *data, int dataSize, const char *fileName)
-{
-    bool success = false;
-
-#ifndef TEXT_BYTES_PER_LINE
-    #define TEXT_BYTES_PER_LINE     20
-#endif
-
-    // NOTE: Text data buffer size is estimated considering raw data size in bytes
-    // and requiring 6 char bytes for every byte: "0x00, "
-    char *txtData = (char *)RL_CALLOC(dataSize*6 + 2000, sizeof(char));
-
-    int byteCount = 0;
-    byteCount += sprintf(txtData + byteCount, "////////////////////////////////////////////////////////////////////////////////////////\n");
-    byteCount += sprintf(txtData + byteCount, "//                                                                                    //\n");
-    byteCount += sprintf(txtData + byteCount, "// DataAsCode exporter v1.0 - Raw data exported as an array of bytes                  //\n");
-    byteCount += sprintf(txtData + byteCount, "//                                                                                    //\n");
-    byteCount += sprintf(txtData + byteCount, "// more info and bugs-report:  github.com/raysan5/raylib                              //\n");
-    byteCount += sprintf(txtData + byteCount, "// feedback and support:       ray[at]raylib.com                                      //\n");
-    byteCount += sprintf(txtData + byteCount, "//                                                                                    //\n");
-    byteCount += sprintf(txtData + byteCount, "// Copyright (c) 2022-2026 Ramon Santamaria (@raysan5)                                //\n");
-    byteCount += sprintf(txtData + byteCount, "//                                                                                    //\n");
-    byteCount += sprintf(txtData + byteCount, "////////////////////////////////////////////////////////////////////////////////////////\n\n");
-
-    // Get file name from path
-    char varFileName[256] = { 0 };
-    strncpy(varFileName, GetFileNameWithoutExt(fileName), 256 - 1);
-    for (int i = 0; varFileName[i] != '\0'; i++)
-    {
-        // Convert variable name to uppercase
-        if ((varFileName[i] >= 'a') && (varFileName[i] <= 'z')) { varFileName[i] = varFileName[i] - 32; }
-        // Replace non valid character for C identifier with '_'
-        else if (varFileName[i] == '.' || varFileName[i] == '-' || varFileName[i] == '?' || varFileName[i] == '!' || varFileName[i] == '+') { varFileName[i] = '_'; }
-    }
-
-    byteCount += sprintf(txtData + byteCount, "#define %s_DATA_SIZE     %i\n\n", varFileName, dataSize);
-
-    byteCount += sprintf(txtData + byteCount, "static unsigned char %s_DATA[%s_DATA_SIZE] = { ", varFileName, varFileName);
-    for (int i = 0; i < (dataSize - 1); i++) byteCount += sprintf(txtData + byteCount, ((i%TEXT_BYTES_PER_LINE == 0)? "0x%x,\n" : "0x%x, "), data[i]);
-    byteCount += sprintf(txtData + byteCount, "0x%x };\n", data[dataSize - 1]);
-
-    // NOTE: Text data size exported is determined by '\0' (NULL) character
-    success = SaveFileText(fileName, txtData);
-
-    RL_FREE(txtData);
-
-    if (success != 0) TRACELOG(LOG_INFO, "FILEIO: [%s] Data as code exported successfully", fileName);
-    else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to export data as code", fileName);
-
-    return success;
-}
-
-// Load text data from file, returns a '\0' terminated string
-// NOTE: text chars array should be freed manually
-char *LoadFileText(const char *fileName)
-{
-    char *text = NULL;
-
-    if (fileName != NULL)
-    {
-        if (loadFileText)
-        {
-            text = loadFileText(fileName);
-            return text;
-        }
-#if defined(SUPPORT_STANDARD_FILEIO)
-        FILE *file = fopen(fileName, "rt");
-
-        if (file != NULL)
-        {
-            // WARNING: When reading a file as 'text' file,
-            // text mode causes carriage return-linefeed translation...
-            // ...but using fseek() should return correct byte-offset
-            fseek(file, 0, SEEK_END);
-            unsigned int size = (unsigned int)ftell(file);
-            fseek(file, 0, SEEK_SET);
-
-            if (size > 0)
-            {
-                text = (char *)RL_CALLOC(size + 1, sizeof(char));
-
-                if (text != NULL)
-                {
-                    unsigned int count = (unsigned int)fread(text, sizeof(char), size, file);
-
-                    // WARNING: \r\n is converted to \n on reading, so,
-                    // read bytes count gets reduced by the number of lines
-                    if (count < size) text = (char *)RL_REALLOC(text, count + 1);
-
-                    // Zero-terminate the string
-                    text[count] = '\0';
-
-                    TRACELOG(LOG_INFO, "FILEIO: [%s] Text file loaded successfully", fileName);
-                }
-                else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to allocated memory for file reading", fileName);
-            }
-            else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to read text file", fileName);
-
-            fclose(file);
-        }
-        else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to open text file", fileName);
-#else
-    TRACELOG(LOG_WARNING, "FILEIO: Standard file io not supported, use custom file callback");
-#endif
-    }
-    else TRACELOG(LOG_WARNING, "FILEIO: File name provided is not valid");
-
-    return text;
-}
-
-// Unload file text data allocated by LoadFileText()
-void UnloadFileText(char *text)
-{
-    RL_FREE(text);
-}
-
-// Save text data to file (write), string must be '\0' terminated
-bool SaveFileText(const char *fileName, const char *text)
-{
-    bool success = false;
-
-    if (fileName != NULL)
-    {
-        if (saveFileText)
-        {
-            return saveFileText(fileName, text);
-        }
-#if defined(SUPPORT_STANDARD_FILEIO)
-        FILE *file = fopen(fileName, "wt");
-
-        if (file != NULL)
-        {
-            int count = fprintf(file, "%s", text);
-
-            if (count < 0) TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to write text file", fileName);
-            else TRACELOG(LOG_INFO, "FILEIO: [%s] Text file saved successfully", fileName);
-
-            int result = fclose(file);
-            if (result == 0) success = true;
-        }
-        else TRACELOG(LOG_WARNING, "FILEIO: [%s] Failed to open text file", fileName);
-#else
-    TRACELOG(LOG_WARNING, "FILEIO: Standard file io not supported, use custom file callback");
-#endif
-    }
-    else TRACELOG(LOG_WARNING, "FILEIO: File name provided is not valid");
-
-    return success;
-}
-
-#if defined(PLATFORM_ANDROID)
-// Initialize asset manager from android app
-void InitAssetManager(AAssetManager *manager, const char *dataPath)
-{
-    assetManager = manager;
-    internalDataPath = dataPath;
-}
-
-// Replacement for fopen()
-// REF: https://developer.android.com/ndk/reference/group/asset
-FILE *android_fopen(const char *fileName, const char *mode)
-{
-    if (mode[0] == 'w')
-    {
-        // NOTE: fopen() is mapped to android_fopen() that only grants read access to
-        // assets directory through AAssetManager but we want to also be able to
-        // write data when required using the standard stdio FILE access functions
-        // REF: https://stackoverflow.com/questions/11294487/android-writing-saving-files-from-native-code-only
-        #undef fopen
-        return fopen(TextFormat("%s/%s", internalDataPath, fileName), mode);
-        #define fopen(name, mode) android_fopen(name, mode)
-    }
-    else
-    {
-        // NOTE: AAsset provides access to read-only asset
-        AAsset *asset = AAssetManager_open(assetManager, fileName, AASSET_MODE_UNKNOWN);
-
-        if (asset != NULL)
-        {
-            // Get pointer to file in the assets
-            return funopen(asset, android_read, android_write, android_seek, android_close);
-        }
-        else
-        {
-            #undef fopen
-            // Just do a regular open if file is not found in the assets
-            return fopen(TextFormat("%s/%s", internalDataPath, fileName), mode);
-            #define fopen(name, mode) android_fopen(name, mode)
-        }
-    }
-}
-#endif  // PLATFORM_ANDROID
-
-//----------------------------------------------------------------------------------
-// Module Internal Functions Definition
-//----------------------------------------------------------------------------------
-#if defined(PLATFORM_ANDROID)
-static int android_read(void *cookie, char *data, int dataSize)
-{
-    return AAsset_read((AAsset *)cookie, data, dataSize);
-}
-
-static int android_write(void *cookie, const char *data, int dataSize)
-{
-    TRACELOG(LOG_WARNING, "ANDROID: Failed to provide write access to APK");
-
-    return EACCES;
-}
-
-static fpos_t android_seek(void *cookie, fpos_t offset, int whence)
-{
-    return AAsset_seek((AAsset *)cookie, offset, whence);
-}
-
-static int android_close(void *cookie)
-{
-    AAsset_close((AAsset *)cookie);
-    return 0;
-}
-#endif  // PLATFORM_ANDROID

src/utils.h

@@ -1,81 +0,0 @@
-/**********************************************************************************************
-*
-*   raylib.utils - Some common utility functions
-*
-*
-*   LICENSE: zlib/libpng
-*
-*   Copyright (c) 2014-2026 Ramon Santamaria (@raysan5)
-*
-*   This software is provided "as-is", without any express or implied warranty. In no event
-*   will the authors be held liable for any damages arising from the use of this software.
-*
-*   Permission is granted to anyone to use this software for any purpose, including commercial
-*   applications, and to alter it and redistribute it freely, subject to the following restrictions:
-*
-*     1. The origin of this software must not be misrepresented; you must not claim that you
-*     wrote the original software. If you use this software in a product, an acknowledgment
-*     in the product documentation would be appreciated but is not required.
-*
-*     2. Altered source versions must be plainly marked as such, and must not be misrepresented
-*     as being the original software.
-*
-*     3. This notice may not be removed or altered from any source distribution.
-*
-**********************************************************************************************/
-
-#ifndef UTILS_H
-#define UTILS_H
-
-#if defined(PLATFORM_ANDROID)
-    #include <stdio.h>                      // Required for: FILE
-    #include <android/asset_manager.h>      // Required for: AAssetManager
-#endif
-
-#if defined(SUPPORT_TRACELOG)
-    #define TRACELOG(level, ...) TraceLog(level, __VA_ARGS__)
-
-    #if defined(SUPPORT_TRACELOG_DEBUG)
-        #define TRACELOGD(...) TraceLog(LOG_DEBUG, __VA_ARGS__)
-    #else
-        #define TRACELOGD(...) (void)0
-    #endif
-#else
-    #define TRACELOG(level, ...) (void)0
-    #define TRACELOGD(...) (void)0
-#endif
-
-//----------------------------------------------------------------------------------
-// Some basic Defines
-//----------------------------------------------------------------------------------
-#if defined(PLATFORM_ANDROID)
-    #define fopen(name, mode) android_fopen(name, mode)
-#endif
-
-//----------------------------------------------------------------------------------
-// Types and Structures Definition
-//----------------------------------------------------------------------------------
-//...
-
-//----------------------------------------------------------------------------------
-// Global Variables Definition
-//----------------------------------------------------------------------------------
-// Nop...
-
-//----------------------------------------------------------------------------------
-// Module Functions Declaration
-//----------------------------------------------------------------------------------
-#if defined(__cplusplus)
-extern "C" {            // Prevents name mangling of functions
-#endif
-
-#if defined(PLATFORM_ANDROID)
-void InitAssetManager(AAssetManager *manager, const char *dataPath);   // Initialize asset manager from android app
-FILE *android_fopen(const char *fileName, const char *mode);           // Replacement for fopen() -> Read-only!
-#endif
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif // UTILS_H

tools/rexm/VS2022/raylib/raylib.vcxproj

@@ -312,7 +312,6 @@
     <ClCompile Include="$(RaylibSrcPath)\rshapes.c" />
     <ClCompile Include="$(RaylibSrcPath)\rtext.c" />
     <ClCompile Include="$(RaylibSrcPath)\rtextures.c" />
-    <ClCompile Include="$(RaylibSrcPath)\utils.c" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="$(RaylibSrcPath)\config.h" />

tools/rexm/VS2022/raylib/raylib.vcxproj.filters

@@ -8,7 +8,6 @@
     <ClCompile Include="$(RaylibSrcPath)\rshapes.c" />
     <ClCompile Include="$(RaylibSrcPath)\rtext.c" />
     <ClCompile Include="$(RaylibSrcPath)\rtextures.c" />
-    <ClCompile Include="$(RaylibSrcPath)\utils.c" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="$(RaylibSrcPath)\config.h" />
@@ -16,7 +15,6 @@
     <ClInclude Include="$(RaylibSrcPath)\raylib.h" />
     <ClInclude Include="$(RaylibSrcPath)\raymath.h" />
     <ClInclude Include="$(RaylibSrcPath)\rlgl.h" />
-    <ClInclude Include="$(RaylibSrcPath)\utils.h" />
     <ClInclude Include="$(RaylibSrcPath)\rcamera.h" />
     <ClInclude Include="$(RaylibSrcPath)\external\cgltf.h">
       <Filter>external</Filter>