/********************************************************************************************** * * rres v1.0 - A simple and easy-to-use file-format to package resources * * CONFIGURATION: * * #define RRES_IMPLEMENTATION * Generates the implementation of the library into the included file. * If not defined, the library is in header only mode and can be included in other headers * or source files without problems. But only ONE file should hold the implementation. * * FEATURES: * * - Multi-resource files: Some files could end-up generating multiple connected resources in * the rres output file (i.e TTF files could generate RRES_DATA_FONT_GLYPHS and RRES_DATA_IMAGE). * - File packaging as raw resource data: Avoid data processing and just package the file bytes. * - Per-file data compression/encryption: Configure compression/encription for every input file. * - Externally linked files: Package only the file path, to be loaded from external file when the * specific id is requested. WARNING: Be careful with path, it should be relative to application dir. * - Central Directory resource (optional): Create a central directory with the input filename relation * to the resource(s) id. This is the default option but it can be avoided; in that case, a header * file (.h) is generated with the file ids definitions. * * FILE STRUCTURE: * * rres files consist of a file header followed by a number of resource chunks. * * Optionally it can contain a Central Directory resource chunk (usually at the end) with the info * of all the files processed into the rres file. * * NOTE: Chunks count could not match files count, some processed files (i.e Font, Mesh) * could generate multiple chunks with the same id related by the rresResourceChunkInfo.nextOffset * Those chunks are loaded together when resource is loaded * * rresFileHeader (16 bytes) * Signature Id (4 bytes) // File signature id: 'rres' * Version (2 bytes) // Format version * Resource Count (2 bytes) // Number of resource chunks contained * CD Offset (4 bytes) // Central Directory offset (if available) * Reserved (4 bytes) // * * rresResourceChunk[] * { * rresResourceChunkInfo (32 bytes) * Type (4 bytes) // Resource type (FourCC) * Id (4 bytes) // Resource identifier (CRC32 filename hash or custom) * Compressor (1 byte) // Data compression algorithm * Cipher (1 byte) // Data encryption algorithm * Flags (2 bytes) // Data flags (if required) * Data Packed Size (4 bytes) // Data packed size (compressed/encrypted + custom data appended) * Data Base Size (4 bytes) // Data base size (uncompressed/unencrypted) * Next Offset (4 bytes) // Next resource chunk offset (if required) * Reserved (4 bytes) // * CRC32 (4 bytes) // Resource Data Chunk CRC32 * * rresResourceChunkData (n bytes) // Packed data * Property Count (4 bytes) // Number of properties contained * Properties[] (4*i bytes) // Resource data required properties, depend on Type * Data (m bytes) // Resource data * } * * rresResourceChunk: RRES_DATA_DIRECTORY // Central directory (special resource chunk) * { * rresResourceChunkInfo (32 bytes) * * rresCentralDir (n bytes) // rresResourceChunkData * Entries Count (4 bytes) // Central directory entries count (files) * rresDirEntry[] * { * Id (4 bytes) // Resource id * Offset (4 bytes) // Resource global offset in file * reserved (4 bytes) // * FileName Size (4 bytes) // Resource fileName size (NULL terminator and 4-bytes align padding considered) * FileName (m bytes) // Resource original fileName (NULL terminated and padded to 4-byte alignment) * } * } * * DESIGN DECISIONS / LIMITATIONS: * * - rres file maximum chunks: 65535 (16bit chunk count in rresFileHeader) * - rres file maximum size: 4GB (chunk offset and Central Directory Offset is 32bit, so it can not address more than 4GB * - Chunk search by ID is done one by one, starting at first chunk and accessed with fread() function * - Endianness: rres does not care about endianness, data is stored as desired by the host platform (most probably Little Endian) * Endianness won't affect chunk data but it will affect rresFileHeader and rresResourceChunkInfo * - CRC32 hash is used to to generate the rres file identifier from filename * There is a "small" probability of random collision (1 in 2^32 approx.) but considering * the chance of collision is related to the number of data inputs, not the size of the inputs, we assume that risk * Also note that CRC32 is not used as a security/cryptographic hash, just an identifier for the input file * - CRC32 hash is also used to detect chunk data corruption. CRC32 is smaller and computationally much less complex than MD5 or SHA1. * Using a hash function like MD5 is probably overkill for random error detection * - Central Directory rresDirEntry.fileName is NULL terminated and padded to 4-byte, rresDirEntry.fileNameSize considers the padding * - Compression and Encryption. rres supports chunks data compression and encryption, it provides two fields in the rresResourceChunkInfo to * note it, but in those cases is up to the user to implement the desired compressor/uncompressor and encryption/decryption mechanisms * In case of data encryption, it's recommended that any additional resource data (i.e. MAC) to be appended to data chunk and properly * noted in the packed data size field of rresResourceChunkInfo. Data compression should be applied before encryption. * * DEPENDENCIES: * * rres library dependencies has been keep to the minimum. It depends only some libc functionality: * * - stdlib.h: Required for memory allocation: malloc(), calloc(), free() * NOTE: Allocators can be redefined with macros RRES_MALLOC, RRES_CALLOC, RRES_FREE * - stdio.h: Required for file access functionality: FILE, fopen(), fseek(), fread(), fclose() * - string.h: Required for memory data management: memcpy(), memcmp() * * VERSION HISTORY: * * - 1.0 (12-May-2022): Implementation review for better alignment with rres specs * - 0.9 (28-Apr-2022): Initial implementation of rres specs * * * LICENSE: MIT * * Copyright (c) 2016-2022 Ramon Santamaria (@raysan5) * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. * **********************************************************************************************/ #ifndef RRES_H #define RRES_H // Function specifiers in case library is build/used as a shared library (Windows) // NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll #if defined(_WIN32) #if defined(BUILD_LIBTYPE_SHARED) #define RRESAPI __declspec(dllexport) // We are building the library as a Win32 shared library (.dll) #elif defined(USE_LIBTYPE_SHARED) #define RRESAPI __declspec(dllimport) // We are using the library as a Win32 shared library (.dll) #endif #endif // Function specifiers definition #ifndef RRESAPI #define RRESAPI // Functions defined as 'extern' by default (implicit specifiers) #endif //---------------------------------------------------------------------------------- // Defines and Macros //---------------------------------------------------------------------------------- // Allow custom memory allocators #ifndef RRES_MALLOC #define RRES_MALLOC(sz) malloc(sz) #endif #ifndef RRES_CALLOC #define RRES_CALLOC(ptr,sz) calloc(ptr,sz) #endif #ifndef RRES_REALLOC #define RRES_REALLOC(ptr,sz) realloc(ptr,sz) #endif #ifndef RRES_FREE #define RRES_FREE(ptr) free(ptr) #endif // Simple log system to avoid printf() calls if required // NOTE: Avoiding those calls, also avoids const strings memory usage #define RRES_SUPPORT_LOG_INFO #if defined(RRES_SUPPORT_LOG_INFO) #define RRES_LOG(...) printf(__VA_ARGS__) #else #define RRES_LOG(...) #endif #define RRES_MAX_FILENAME_SIZE 1024 //---------------------------------------------------------------------------------- // Types and Structures Definition //---------------------------------------------------------------------------------- // rres file header (16 bytes) typedef struct rresFileHeader { unsigned char id[4]; // File identifier: rres unsigned short version; // File version: 100 for version 1.0 unsigned short chunkCount; // Number of resource chunks in the file (MAX: 65535) unsigned int cdOffset; // Central Directory offset in file (0 if not available) unsigned int reserved; // } rresFileHeader; // rres resource chunk info header (32 bytes) typedef struct rresResourceChunkInfo { unsigned char type[4]; // Resource chunk type (FourCC) unsigned int id; // Resource chunk identifier (generated from filename CRC32 hash) unsigned char compType; // Data compression algorithm unsigned char cipherType; // Data encription algorithm unsigned short flags; // Data flags (if required) unsigned int packedSize; // Data chunk size (compressed/encrypted + custom data appended) unsigned int baseSize; // Data base size (uncompressed/unencrypted) unsigned int nextOffset; // Next resource chunk global offset (if resource has multiple chunks) unsigned int reserved; // unsigned int crc32; // Data chunk CRC32 (propCount + props[] + data) } rresResourceChunkInfo; // rres resource chunk data typedef struct rresResourceChunkData { unsigned int propCount; // Resource chunk properties count unsigned int *props; // Resource chunk properties void *raw; // Resource chunk raw data } rresResourceChunkData; // rres resource chunk typedef struct rresResourceChunk { rresResourceChunkInfo info; // Resource chunk info rresResourceChunkData data; // Resource chunk packed data, contains propCount, props[] and raw data } rresResourceChunk; // rres resource multi // NOTE: It supports multiple resource chunks typedef struct rresResourceMulti { unsigned int count; // Resource chunks count rresResourceChunk *chunks; // Resource chunks } rresResourceMulti; // Useful data types for specific chunk types //---------------------------------------------------------------------- // CDIR: rres central directory entry typedef struct rresDirEntry { unsigned int id; // Resource id unsigned int offset; // Resource global offset in file unsigned int reserved; // reserved unsigned int fileNameSize; // Resource fileName size (NULL terminator and 4-byte alignment padding considered) char fileName[RRES_MAX_FILENAME_SIZE]; // Resource original fileName (NULL terminated and padded to 4-byte alignment) } rresDirEntry; // CDIR: rres central directory // NOTE: This data conforms the rresResourceChunkData typedef struct rresCentralDir { unsigned int count; // Central directory entries count rresDirEntry *entries; // Central directory entries } rresCentralDir; // FNTG: rres font glyphs info (32 bytes) // NOTE: And array of this type conforms the rresResourceChunkData typedef struct rresFontGlyphInfo { int x, y, width, height; // Glyph rectangle in the atlas image int value; // Glyph codepoint value int offsetX, offsetY; // Glyph drawing offset (from base line) int advanceX; // Glyph advance X for next character } rresFontGlyphInfo; //---------------------------------------------------------------------------------- // Enums Definition // The following enums are useful to fill some fields of the rresResourceChunkInfo // and also some fields of the different data types properties //---------------------------------------------------------------------------------- // rres resource chunk data type // NOTE 1: Data type determines the properties and the data included in every chunk // NOTE 2: This enum defines the basic resource data types, // some input files could generate multiple resource chunks: // Fonts processed could generate (2) resource chunks: // - [FNTG] rres[0]: RRES_DATA_FONT_GLYPHS // - [IMGE] rres[1]: RRES_DATA_IMAGE // // Mesh processed could generate (n) resource chunks: // - [VRTX] rres[0]: RRES_DATA_VERTEX // ... // - [VRTX] rres[n]: RRES_DATA_VERTEX typedef enum rresResourceDataType { RRES_DATA_NULL = 0, // FourCC: NULL - Reserved for empty chunks, no props/data RRES_DATA_RAW = 1, // FourCC: RAWD - Raw file data, 4 properties // props[0]:size (bytes) // props[1]:extension01 (big-endian: ".png" = 0x2e706e67) // props[2]:extension02 (additional part, extensions with +3 letters) // props[3]:reserved // data: raw bytes RRES_DATA_TEXT = 2, // FourCC: TEXT - Text file data, 4 properties // props[0]:size (bytes) // props[1]:rresTextEncoding // props[2]:rresCodeLang // props[3]:cultureCode // data: text RRES_DATA_IMAGE = 3, // FourCC: IMGE - Image file data, 4 properties // props[0]:width // props[1]:height // props[2]:rresPixelFormat // props[3]:mipmaps // data: pixels RRES_DATA_WAVE = 4, // FourCC: WAVE - Audio file data, 4 properties // props[0]:frameCount // props[1]:sampleRate // props[2]:sampleSize // props[3]:channels // data: samples RRES_DATA_VERTEX = 5, // FourCC: VRTX - Vertex file data, 4 properties // props[0]:vertexCount // props[1]:rresVertexAttribute // props[2]:componentCount // props[3]:rresVertexFormat // data: vertex RRES_DATA_FONT_GLYPHS = 6, // FourCC: FNTG - Font glyphs info data, 4 properties // props[0]:baseSize // props[1]:glyphCount // props[2]:glyphPadding // props[3]:rresFontStyle // data: rresFontGlyphInfo[0..glyphCount] RRES_DATA_LINK = 99, // FourCC: LINK - External linked file, 1 property // props[0]:size (bytes) // data: filepath (as provided on input) RRES_DATA_DIRECTORY = 100, // FourCC: CDIR - Central directory for input files // props[0]:entryCount, 1 property // data: rresDirEntry[0..entryCount] // TODO: 2.0: Support resource package types (muti-resource) // NOTE: They contains multiple rresResourceChunk in rresResourceData.raw //RRES_DATA_PACK_FONT = 110, // FourCC: PFNT - Resources Pack: Font data, 1 property (2 resource chunks: RRES_DATA_GLYPHS, RRES_DATA_IMAGE) // props[0]:chunkCount //RRES_DATA_PACK_MESH = 120, // FourCC: PMSH - Resources Pack: Mesh data, 1 property (n resource chunks: RRES_DATA_VERTEX) // props[0]:chunkCount // TODO: Add additional resource data types if required (define props + data) } rresResourceDataType; // Compression algorithms // Value required by rresResourceChunkInfo.compType // NOTE 1: This enum just list some common data compression algorithms for convenience, // The rres packer tool and the engine-specific library are responsible to implement the desired ones, // NOTE 2: rresResourceChunkInfo.compType is a byte-size value, limited to [0..255] typedef enum rresCompressionType { RRES_COMP_NONE = 0, // No data compression RRES_COMP_RLE = 1, // RLE compression RRES_COMP_DEFLATE = 10, // DEFLATE compression RRES_COMP_LZ4 = 20, // LZ4 compression RRES_COMP_LZMA2 = 30, // LZMA2 compression RRES_COMP_QOI = 40, // QOI compression, useful for RGB(A) image data // TODO: Add additional compression algorithms if required } rresCompressionType; // Encryption algoritms // Value required by rresResourceChunkInfo.cipherType // NOTE 1: This enum just lists some common data encryption algorithms for convenience, // The rres packer tool and the engine-specific library are responsible to implement the desired ones, // NOTE 2: Some encryption algorithm could require/generate additional data (seed, salt, nonce, MAC...) // in those cases, that extra data must be appended to the original encrypted message and added to the resource data chunk // NOTE 3: rresResourceChunkInfo.cipherType is a byte-size value, limited to [0..255] typedef enum rresEncryptionType { RRES_CIPHER_NONE = 0, // No data encryption RRES_CIPHER_XOR = 1, // XOR encryption, generic using 128bit key in blocks RRES_CIPHER_DES = 10, // DES encryption RRES_CIPHER_TDES = 11, // Triple DES encryption RRES_CIPHER_IDEA = 20, // IDEA encryption RRES_CIPHER_AES = 30, // AES (128bit or 256bit) encryption RRES_CIPHER_AES_GCM = 31, // AES Galois/Counter Mode (Galois Message Authentification Code - GMAC) RRES_CIPHER_XTEA = 40, // XTEA encryption RRES_CIPHER_BLOWFISH = 50, // BLOWFISH encryption RRES_CIPHER_RSA = 60, // RSA asymmetric encryption RRES_CIPHER_SALSA20 = 70, // SALSA20 encryption RRES_CIPHER_CHACHA20 = 71, // CHACHA20 encryption RRES_CIPHER_XCHACHA20 = 72, // XCHACHA20 encryption RRES_CIPHER_XCHACHA20_POLY1305 = 73, // XCHACHA20 with POLY1305 for message authentification (MAC) // TODO: Add additional encryption algorithm if required } rresEncryptionType; // TODO: rres error codes (not used at this moment) // NOTE: Error codes when processing rres files typedef enum rresErrorType { RRES_SUCCESS = 0, // rres file loaded/saved successfully RRES_ERROR_FILE_NOT_FOUND, // rres file can not be opened (spelling issues, file actually does not exist...) RRES_ERROR_FILE_FORMAT, // rres file format not a supported (wrong header, wrong identifier) RRES_ERROR_MEMORY_ALLOC, // Memory could not be allocated for operation. } rresErrorType; // Enums required by specific resource types for its properties //---------------------------------------------------------------------------------- // TEXT: Text encoding property values typedef enum rresTextEncoding { RRES_TEXT_ENCODING_UNDEFINED = 0, // Not defined, usually UTF-8 RRES_TEXT_ENCODING_UTF8 = 1, // UTF-8 text encoding RRES_TEXT_ENCODING_UTF8_BOM = 2, // UTF-8 text encoding with Byte-Order-Mark RRES_TEXT_ENCODING_UTF16_LE = 10, // UTF-16 Little Endian text encoding RRES_TEXT_ENCODING_UTF16_BE = 11, // UTF-16 Big Endian text encoding // TODO: Add additional encodings if required } rresTextEncoding; // TEXT: Text code language // NOTE: It could be useful for code script resources typedef enum rresCodeLang { RRES_CODE_LANG_UNDEFINED = 0, // Undefined code language, text is plain text RRES_CODE_LANG_C, // Text contains C code RRES_CODE_LANG_CPP, // Text contains C++ code RRES_CODE_LANG_CS, // Text contains C# code RRES_CODE_LANG_LUA, // Text contains Lua code RRES_CODE_LANG_JS, // Text contains JavaScript code RRES_CODE_LANG_PYTHON, // Text contains Python code RRES_CODE_LANG_RUST, // Text contains Rust code RRES_CODE_LANG_ZIG, // Text contains Zig code RRES_CODE_LANG_ODIN, // Text contains Odin code RRES_CODE_LANG_JAI, // Text contains Jai code RRES_CODE_LANG_GDSCRIPT, // Text contains GDScript (Godot) code RRES_CODE_LANG_GLSL, // Text contains GLSL shader code // TODO: Add additional code languages if required } rresCodeLang; // IMGE: Image/Texture pixel formats typedef enum rresPixelFormat { RRES_PIXELFORMAT_UNDEFINED = 0, RRES_PIXELFORMAT_UNCOMP_GRAYSCALE = 1, // 8 bit per pixel (no alpha) RRES_PIXELFORMAT_UNCOMP_GRAY_ALPHA, // 16 bpp (2 channels) RRES_PIXELFORMAT_UNCOMP_R5G6B5, // 16 bpp RRES_PIXELFORMAT_UNCOMP_R8G8B8, // 24 bpp RRES_PIXELFORMAT_UNCOMP_R5G5B5A1, // 16 bpp (1 bit alpha) RRES_PIXELFORMAT_UNCOMP_R4G4B4A4, // 16 bpp (4 bit alpha) RRES_PIXELFORMAT_UNCOMP_R8G8B8A8, // 32 bpp RRES_PIXELFORMAT_UNCOMP_R32, // 32 bpp (1 channel - float) RRES_PIXELFORMAT_UNCOMP_R32G32B32, // 32*3 bpp (3 channels - float) RRES_PIXELFORMAT_UNCOMP_R32G32B32A32, // 32*4 bpp (4 channels - float) RRES_PIXELFORMAT_COMP_DXT1_RGB, // 4 bpp (no alpha) RRES_PIXELFORMAT_COMP_DXT1_RGBA, // 4 bpp (1 bit alpha) RRES_PIXELFORMAT_COMP_DXT3_RGBA, // 8 bpp RRES_PIXELFORMAT_COMP_DXT5_RGBA, // 8 bpp RRES_PIXELFORMAT_COMP_ETC1_RGB, // 4 bpp RRES_PIXELFORMAT_COMP_ETC2_RGB, // 4 bpp RRES_PIXELFORMAT_COMP_ETC2_EAC_RGBA, // 8 bpp RRES_PIXELFORMAT_COMP_PVRT_RGB, // 4 bpp RRES_PIXELFORMAT_COMP_PVRT_RGBA, // 4 bpp RRES_PIXELFORMAT_COMP_ASTC_4x4_RGBA, // 8 bpp RRES_PIXELFORMAT_COMP_ASTC_8x8_RGBA // 2 bpp // TOO: Add additional pixel formats if required } rresPixelFormat; // VRTX: Vertex data attribute // NOTE: The expected number of components for every vertex attributes is provided as a property to data, // the listed components count are the expected/default ones typedef enum rresVertexAttribute { RRES_VERTEX_ATTRIBUTE_POSITION = 0, // Vertex position attribute: [x, y, z] RRES_VERTEX_ATTRIBUTE_TEXCOORD1 = 10, // Vertex texture coordinates attribute: [u, v] RRES_VERTEX_ATTRIBUTE_TEXCOORD2 = 11, // Vertex texture coordinates attribute: [u, v] RRES_VERTEX_ATTRIBUTE_TEXCOORD3 = 12, // Vertex texture coordinates attribute: [u, v] RRES_VERTEX_ATTRIBUTE_TEXCOORD4 = 13, // Vertex texture coordinates attribute: [u, v] RRES_VERTEX_ATTRIBUTE_NORMAL = 20, // Vertex normal attribute: [x, y, z] RRES_VERTEX_ATTRIBUTE_TANGENT = 30, // Vertex tangent attribute: [x, y, z, w] RRES_VERTEX_ATTRIBUTE_COLOR = 40, // Vertex color attribute: [r, g, b, a] RRES_VERTEX_ATTRIBUTE_INDEX = 100, // Vertex index attribute: [i] // TODO: Add additional attributes if required } rresVertexAttribute; // VRTX: Vertex data format type typedef enum rresVertexFormat { RRES_VERTEX_FORMAT_UBYTE = 0, // 8 bit unsigned integer data RRES_VERTEX_FORMAT_BYTE, // 8 bit signed integer data RRES_VERTEX_FORMAT_USHORT, // 16 bit unsigned integer data RRES_VERTEX_FORMAT_SHORT, // 16 bit signed integer data RRES_VERTEX_FORMAT_UINT, // 32 bit unsigned integer data RRES_VERTEX_FORMAT_INT, // 32 bit integer data RRES_VERTEX_FORMAT_HFLOAT, // 16 bit float data RRES_VERTEX_FORMAT_FLOAT, // 32 bit float data // TODO: Add additional required vertex formats (i.e. normalized data) } rresVertexFormat; // FNTG: Font style typedef enum rresFontStyle { RRES_FONT_STYLE_UNDEFINED = 0, // Undefined font style RRES_FONT_STYLE_REGULAR, // Regular font style RRES_FONT_STYLE_BOLD, // Bold font style RRES_FONT_STYLE_ITALIC, // Italic font style // TODO: Add additional font styles if required } rresFontStyle; //---------------------------------------------------------------------------------- // Global variables //---------------------------------------------------------------------------------- //... //---------------------------------------------------------------------------------- // Module Functions Declaration //---------------------------------------------------------------------------------- #ifdef __cplusplus extern "C" { // Prevents name mangling of functions #endif // Load only one resource chunk (first resource id found) RRESAPI rresResourceChunk rresLoadResourceChunk(const char *fileName, int rresId); // Load one resource chunk for provided id RRESAPI void rresUnloadResourceChunk(rresResourceChunk chunk); // Unload resource chunk from memory // Load multi resource chunks for a specified rresId RRESAPI rresResourceMulti rresLoadResourceMulti(const char *fileName, int rresId); // Load resource for provided id (multiple resource chunks) RRESAPI void rresUnloadResourceMulti(rresResourceMulti multi); // Unload resource from memory (multiple resource chunks) // Load resource(s) chunk info from file RRESAPI rresResourceChunkInfo rresLoadResourceChunkInfo(const char *fileName, int rresId); // Load resource chunk info for provided id RRESAPI rresResourceChunkInfo *rresLoadResourceChunkInfoAll(const char *fileName, unsigned int *chunkCount); // Load all resource chunks info RRESAPI rresCentralDir rresLoadCentralDirectory(const char *fileName); // Load central directory resource chunk from file RRESAPI void rresUnloadCentralDirectory(rresCentralDir dir); // Unload central directory resource chunk RRESAPI unsigned int rresGetDataType(const unsigned char *fourCC); // Get rresResourceDataType from FourCC code RRESAPI int rresGetResourceId(rresCentralDir dir, const char *fileName); // Get resource id for a provided filename // NOTE: It requires CDIR available in the file (it's optinal by design) RRESAPI unsigned int rresComputeCRC32(unsigned char *data, int len); // Compute CRC32 for provided data // Manage password for data encryption/decryption // NOTE: The cipher password is kept as an internal pointer to provided string, it's up to the user to manage that sensible data properly // Password should be to allocate and set before loading an encrypted resource and it should be cleaned/wiped after the encrypted resource has been loaded // TODO: Move this functionality to engine-library, after all rres.h does not manage data decryption RRESAPI void rresSetCipherPassword(const char *pass); // Set password to be used on data decryption RRESAPI const char *rresGetCipherPassword(void); // Get password to be used on data decryption #ifdef __cplusplus } #endif #endif // RRES_H