YourWishes/dusk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Consistent

Browse Source
This commit is contained in:
Dominic Masters
2026-05-30 20:30:13 -05:00
parent 1cd6f4cb72
commit 6acfca6d48
9 changed files with 178 additions and 420 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/dusk/asset/loader/assetloader.c
+8 -9
View File
@@ -11,8 +11,8 @@ assetloadercallbacks_t ASSET_LOADER_CALLBACKS[ASSET_LOADER_TYPE_COUNT] = {
[ASSET_LOADER_TYPE_NULL] = { 0 }, [ASSET_LOADER_TYPE_NULL] = { 0 },
[ASSET_LOADER_TYPE_MESH] = { [ASSET_LOADER_TYPE_MESH] = {
.loadSync = assetMeshLoaderNEW, .loadSync = assetMeshLoaderSync,
.dispose = assetMeshDisposeNEW .dispose = assetMeshDispose
}, },
[ASSET_LOADER_TYPE_TEXTURE] = { [ASSET_LOADER_TYPE_TEXTURE] = {
@@ -20,19 +20,18 @@ assetloadercallbacks_t ASSET_LOADER_CALLBACKS[ASSET_LOADER_TYPE_COUNT] = {
.dispose = assetTextureDispose .dispose = assetTextureDispose
}, },
[ASSET_LOADER_TYPE_TILESET] = { [ASSET_LOADER_TYPE_TILESET] = {
.loadSync = assetTilesetLoaderNEW, .loadSync = assetTilesetLoaderSync,
.dispose = assetTilesetDisposeNEW .dispose = assetTilesetDispose
}, },
[ASSET_LOADER_TYPE_LOCALE] = { [ASSET_LOADER_TYPE_LOCALE] = {
.loadSync = assetLocaleLoaderNEW, .loadSync = assetLocaleLoaderSync,
.dispose = assetLocaleDisposeNEW .dispose = assetLocaleDispose
}, },
[ASSET_LOADER_TYPE_JSON] = { [ASSET_LOADER_TYPE_JSON] = {
.loadSync = assetJsonLoaderNEW, .loadSync = assetJsonLoaderSync,
.dispose = assetJsonDisposeNEW .dispose = assetJsonDispose
}, },
}; };
src/dusk/asset/loader/display/assetmeshloader.c
+97 -182
View File
@@ -5,208 +5,123 @@
* https://opensource.org/licenses/MIT * https://opensource.org/licenses/MIT
*/ */
#include "asset/loader/display/assetmeshloader.h" #include "assetmeshloader.h"
#include "asset/asset.h"
#include "assert/assert.h" #include "assert/assert.h"
#include "util/endian.h" #include "util/endian.h"
#include "util/memory.h" #include "util/memory.h"
#include "asset/loader/assetloading.h" #include "asset/loader/assetloading.h"
#include "asset/loader/assetentry.h" #include "asset/loader/assetentry.h"
errorret_t assetMeshLoaderNEW(assetloading_t *loading) { errorret_t assetMeshLoaderSync(assetloading_t *loading) {
assertNotNull(loading, "Loading cannot be NULL"); assertNotNull(loading, "Loading cannot be NULL");
assertTrue(loading->type == ASSET_LOADER_TYPE_MESH, "Invalid type."); assertTrue(loading->type == ASSET_LOADER_TYPE_MESH, "Invalid type.");
assetmeshoutput_t *out = &loading->entry->data.mesh; assetmeshoutput_t *out = &loading->entry->data.mesh;
assetfile_t *file = &loading->loading.mesh.file; assetfile_t *file = &loading->loading.mesh.file;
assetmeshinputaxis_t axis = loading->entry->input->mesh;
assetmeshloaderparams_t params = { errorChain(assetFileInit(file, loading->entry->name, NULL, NULL));
.outMesh = &out->mesh, errorChain(assetFileOpen(file));
.outVertices = &out->vertices,
.inputAxis = loading->entry->input->mesh
};
errorChain(assetFileInit(file, loading->entry->name, NULL, &params)); // Skip the 80-byte STL header
errorChain(assetMeshLoader(file)); errorChain(assetFileRead(file, NULL, 80));
if(file->lastRead != 80) errorThrow("Failed to skip STL header");
uint32_t triangleCount;
errorChain(assetFileRead(file, &triangleCount, sizeof(uint32_t)));
if(file->lastRead != sizeof(uint32_t)) errorThrow("Failed to read tri count");
triangleCount = endianLittleToHost32(triangleCount);
out->vertices = memoryAllocate(sizeof(meshvertex_t) * triangleCount * 3);
meshvertex_t *verts = out->vertices;
errorret_t ret;
for(uint32_t i = 0; i < triangleCount; i++) {
assetmeshstltriangle_t triData;
ret = assetFileRead(file, &triData, sizeof(triData));
if(ret.code != ERROR_OK) {
memoryFree(verts);
out->vertices = NULL;
errorChain(ret);
}
if(file->lastRead != sizeof(triData)) {
memoryFree(verts);
out->vertices = NULL;
errorThrow("Failed to read triangle data");
}
for(uint8_t j = 0; j < 3; j++) {
#if MESH_ENABLE_COLOR
verts[i * 3 + j].color.r = (uint8_t)(endianLittleToHostFloat(triData.normal[0]) * 255.0f);
verts[i * 3 + j].color.g = (uint8_t)(endianLittleToHostFloat(triData.normal[1]) * 255.0f);
verts[i * 3 + j].color.b = (uint8_t)(endianLittleToHostFloat(triData.normal[2]) * 255.0f);
verts[i * 3 + j].color.a = 0xFF;
#endif
verts[i * 3 + j].uv[0] = 0.0f;
verts[i * 3 + j].uv[1] = 0.0f;
for(uint8_t k = 0; k < 3; k++) {
verts[i * 3 + j].pos[k] = endianLittleToHostFloat(triData.positions[j][k]);
}
switch(axis) {
case MESH_INPUT_AXIS_Z_UP: {
float_t temp = verts[i * 3 + j].pos[1];
verts[i * 3 + j].pos[1] = verts[i * 3 + j].pos[2];
verts[i * 3 + j].pos[2] = temp;
break;
}
case MESH_INPUT_AXIS_X_UP: {
float_t temp = verts[i * 3 + j].pos[0];
verts[i * 3 + j].pos[0] = verts[i * 3 + j].pos[1];
verts[i * 3 + j].pos[1] = temp;
break;
}
case MESH_INPUT_AXIS_Y_DOWN:
verts[i * 3 + j].pos[1] = -verts[i * 3 + j].pos[1];
break;
case MESH_INPUT_AXIS_Z_DOWN: {
float_t temp = verts[i * 3 + j].pos[1];
verts[i * 3 + j].pos[1] = -verts[i * 3 + j].pos[2];
verts[i * 3 + j].pos[2] = temp;
break;
}
case MESH_INPUT_AXIS_X_DOWN: {
float_t temp = verts[i * 3 + j].pos[0];
verts[i * 3 + j].pos[0] = verts[i * 3 + j].pos[1];
verts[i * 3 + j].pos[1] = -temp;
break;
}
case MESH_INPUT_AXIS_Y_UP:
default:
break;
}
}
}
ret = assetFileClose(file);
if(ret.code != ERROR_OK) {
memoryFree(verts);
out->vertices = NULL;
errorChain(ret);
}
assetFileDispose(file); assetFileDispose(file);
ret = meshInit(&out->mesh, MESH_PRIMITIVE_TYPE_TRIANGLES, triangleCount * 3, verts);
if(ret.code != ERROR_OK) {
memoryFree(verts);
out->vertices = NULL;
errorChain(ret);
}
errorOk(); errorOk();
} }
errorret_t assetMeshDisposeNEW(assetentry_t *entry) { errorret_t assetMeshDispose(assetentry_t *entry) {
assertNotNull(entry, "Asset entry cannot be NULL"); assertNotNull(entry, "Asset entry cannot be NULL");
assertTrue(entry->type == ASSET_LOADER_TYPE_MESH, "Invalid type."); assertTrue(entry->type == ASSET_LOADER_TYPE_MESH, "Invalid type.");
errorChain(meshDispose(&entry->data.mesh.mesh)); errorChain(meshDispose(&entry->data.mesh.mesh));
memoryFree(entry->data.mesh.vertices); memoryFree(entry->data.mesh.vertices);
errorOk(); errorOk();
} }
errorret_t assetMeshLoader(assetfile_t *file) {
assertNotNull(file, "Asset file cannot be null");
assetmeshloaderparams_t *output = (assetmeshloaderparams_t *)file->output;
assertNotNull(output, "Output cannot be null");
assertNotNull(output->outMesh, "Output mesh cannot be null");
assertNotNull(output->outVertices, "Output vertices cannot be null");
// STL file loading
errorChain(assetFileOpen(file));
// Skip the 80 byte header
errorChain(assetFileRead(file, NULL, 80));
if(file->lastRead != 80) errorThrow("Failed to skip STL header");
uint32_t triangleCount;
errorChain(assetFileRead(file, &triangleCount, sizeof(uint32_t)));
if(file->lastRead != sizeof(uint32_t)) errorThrow("Failed read tri count");
// normalize
triangleCount = endianLittleToHost32(triangleCount);
// Allocate mesh and vertex data
errorret_t ret;
meshvertex_t *verts = memoryAllocate(
sizeof(meshvertex_t) * triangleCount * 3
);
*output->outVertices = verts;
// Read triangle data
for(uint32_t i = 0; i < triangleCount; i++) {
assetmeshstltriangle_t triData;
ret = assetFileRead(file, &triData, sizeof(triData));
if(ret.code != ERROR_OK) {
memoryFree(verts);
errorChain(ret);
}
if(file->lastRead != sizeof(triData)) {
memoryFree(verts);
errorThrow("Failed to read triangle data");
}
// Skip normals, we don't use them
// Fix endianess of of data
for(uint8_t j = 0; j < 3; j++) {
#if MESH_ENABLE_COLOR
verts[i * 3 + j].color.r = (uint8_t)(endianLittleToHostFloat(
triData.normal[0]
) * 255.0f);
verts[i * 3 + j].color.g = (uint8_t)(endianLittleToHostFloat(
triData.normal[1]
) * 255.0f);
verts[i * 3 + j].color.b = (uint8_t)(endianLittleToHostFloat(
triData.normal[2]
) * 255.0f);
verts[i * 3 + j].color.a = 0xFF;
#endif
verts[i * 3 + j].uv[0] = 0.0f; // No UV data in STL, just set to 0
verts[i * 3 + j].uv[1] = 0.0f;
for(uint8_t k = 0; k < 3; k++) {
verts[i * 3 + j].pos[k] = endianLittleToHostFloat(
triData.positions[j][k]
);
}
switch(output->inputAxis) {
case MESH_INPUT_AXIS_Z_UP:
// Convert Z-Up to Y-Up
{
float_t temp = verts[i * 3 + j].pos[1];
verts[i * 3 + j].pos[1] = verts[i * 3 + j].pos[2];
verts[i * 3 + j].pos[2] = temp;
}
break;
case MESH_INPUT_AXIS_X_UP:
// Convert X-Up to Y-Up
{
float_t temp = verts[i * 3 + j].pos[0];
verts[i * 3 + j].pos[0] = verts[i * 3 + j].pos[1];
verts[i * 3 + j].pos[1] = temp;
}
break;
case MESH_INPUT_AXIS_Y_DOWN:
// Invert Y axis
verts[i * 3 + j].pos[1] = -verts[i * 3 + j].pos[1];
break;
case MESH_INPUT_AXIS_Z_DOWN:
// Convert Z-Up to Y-Up and invert Y axis
{
float_t temp = verts[i * 3 + j].pos[1];
verts[i * 3 + j].pos[1] = -verts[i * 3 + j].pos[2];
verts[i * 3 + j].pos[2] = temp;
}
break;
case MESH_INPUT_AXIS_X_DOWN:
// Convert X-Up to Y-Up and invert Y axis
{
float_t temp = verts[i * 3 + j].pos[0];
verts[i * 3 + j].pos[0] = verts[i * 3 + j].pos[1];
verts[i * 3 + j].pos[1] = -temp;
}
break;
case MESH_INPUT_AXIS_Y_UP:
default:
// No covnersion possible / Needed
break;
}
}
}
// Finally, init mesh
ret = meshInit(
output->outMesh,
MESH_PRIMITIVE_TYPE_TRIANGLES,
triangleCount * 3,
verts
);
if(ret.code != ERROR_OK) {
memoryFree(verts);
errorChain(ret);
}
ret = assetFileClose(file);
if(ret.code != ERROR_OK) {
errorCatch(errorPrint(meshDispose(output->outMesh)));
memoryFree(verts);
errorChain(ret);
}
errorOk();
}
// errorret_t assetMeshLoadToOutput(
// const char_t *path,
// assetmeshoutput_t *output
// ) {
// assertNotNull(path, "Path cannot be null");
// assertNotNull(output, "Output cannot be null");
// assertNotNull(output->outMesh, "Output mesh cannot be null");
// assertNotNull(output->outVertices, "Output vertices cannot be null");
// return assetLoad(path, &assetMeshLoader, NULL, output);
// }
// errorret_t assetMeshLoad(
// const char_t *path,
// mesh_t *outMesh,
// meshvertex_t **outVertices,
// const assetmeshinputaxis_t inputAxis
// ) {
// assertNotNull(path, "Path cannot be null");
// assertNotNull(outMesh, "Output mesh cannot be null");
// assertNotNull(outVertices, "Output vertices cannot be null");
// assetmeshoutput_t output = {
// outMesh,
// outVertices,
// inputAxis
// };
// return assetMeshLoadToOutput(path, &output);
// }
src/dusk/asset/loader/display/assetmeshloader.h
+8 -23
View File
@@ -10,8 +10,11 @@
#include "display/mesh/mesh.h" #include "display/mesh/mesh.h"
#include "assert/assert.h" #include "assert/assert.h"
typedef struct assetloading_s assetloading_t;
typedef struct assetentry_s assetentry_t;
typedef enum { typedef enum {
MESH_INPUT_AXIS_Y_UP,// Default MESH_INPUT_AXIS_Y_UP,
MESH_INPUT_AXIS_Z_UP, MESH_INPUT_AXIS_Z_UP,
MESH_INPUT_AXIS_X_UP, MESH_INPUT_AXIS_X_UP,
@@ -20,30 +23,17 @@ typedef enum {
MESH_INPUT_AXIS_X_DOWN, MESH_INPUT_AXIS_X_DOWN,
} assetmeshinputaxis_t; } assetmeshinputaxis_t;
typedef struct {
mesh_t *outMesh;
meshvertex_t **outVertices;
assetmeshinputaxis_t inputAxis;
} assetmeshloaderparams_t;
// NEW STUFF
typedef struct assetloading_s assetloading_t;
typedef struct assetentry_s assetentry_t;
typedef assetmeshinputaxis_t assetmeshloaderinput_t; typedef assetmeshinputaxis_t assetmeshloaderinput_t;
typedef struct { typedef struct {
assetfile_t file; assetfile_t file;
} assetmeshloaderloading_t; } assetmeshloaderloading_t;
typedef struct { typedef struct {
mesh_t mesh; mesh_t mesh;
meshvertex_t *vertices; meshvertex_t *vertices;
} assetmeshoutput_t; } assetmeshoutput_t;
errorret_t assetMeshLoaderNEW(assetloading_t *loading);
errorret_t assetMeshDisposeNEW(assetentry_t *entry);
// END NEW STUFF
#pragma pack(push, 1) #pragma pack(push, 1)
typedef struct { typedef struct {
vec3 normal; vec3 normal;
@@ -54,10 +44,5 @@ typedef struct {
assertStructSize(assetmeshstltriangle_t, 50); assertStructSize(assetmeshstltriangle_t, 50);
/** errorret_t assetMeshLoaderSync(assetloading_t *loading);
* Loader for mesh assets. errorret_t assetMeshDispose(assetentry_t *entry);
*
* @param file Asset file to load the mesh from.
* @return Any error that occurs during loading.
*/
errorret_t assetMeshLoader(assetfile_t *file);
src/dusk/asset/loader/display/assettilesetloader.c
+16 -53
View File
@@ -9,97 +9,60 @@
#include "assert/assert.h" #include "assert/assert.h"
#include "util/memory.h" #include "util/memory.h"
#include "util/endian.h" #include "util/endian.h"
#include "asset/loader/assetloading.h" #include "asset/loader/assetloading.h"
#include "asset/loader/assetentry.h" #include "asset/loader/assetentry.h"
errorret_t assetTilesetLoaderNEW(assetloading_t *loading) { errorret_t assetTilesetLoaderSync(assetloading_t *loading) {
assertNotNull(loading, "Loading cannot be NULL"); assertNotNull(loading, "Loading cannot be NULL");
assertTrue(loading->type == ASSET_LOADER_TYPE_TILESET, "Invalid type."); assertTrue(loading->type == ASSET_LOADER_TYPE_TILESET, "Invalid type.");
assetfile_t *file = &loading->loading.tileset.file; assetfile_t *file = &loading->loading.tileset.file;
tileset_t *out = &loading->entry->data.tileset; tileset_t *out = &loading->entry->data.tileset;
assertNotNull(file, "File cannot be NULL");
assertNotNull(out, "Output cannot be NULL");
errorChain(assetFileInit(file, loading->entry->name, NULL, out)); errorChain(assetFileInit(file, loading->entry->name, NULL, NULL));
errorChain(assetTilesetLoader(file));
errorChain(assetFileDispose(file));
errorOk();
}
errorret_t assetTilesetDisposeNEW(assetentry_t *entry) {
assertNotNull(entry, "Entry cannot be NULL");
assertTrue(entry->type == ASSET_LOADER_TYPE_TILESET, "Invalid type.");
errorOk();
}
errorret_t assetTilesetLoader(assetfile_t *file) {
assertNotNull(file, "Asset file pointer for tileset loader is null.");
tileset_t *out = (tileset_t *)file->output;
assertNotNull(out, "Output pointer for tileset loader is null.");
uint8_t *entire = memoryAllocate(file->size); uint8_t *entire = memoryAllocate(file->size);
errorChain(assetFileOpen(file)); errorChain(assetFileOpen(file));
errorChain(assetFileRead(file, entire, file->size)); errorChain(assetFileRead(file, entire, file->size));
errorChain(assetFileClose(file)); errorChain(assetFileClose(file));
errorChain(assetFileDispose(file));
assertTrue(file->lastRead == file->size, "Failed to read entire file."); assertTrue(file->lastRead == file->size, "Failed to read entire file.");
if(entire[0] != 'D' || entire[1] != 'T' || entire[2] != 'F') {
if( memoryFree(entire);
entire[0] != 'D' ||
entire[1] != 'T' ||
entire[2] != 'F'
) {
errorThrow("Invalid tileset header"); errorThrow("Invalid tileset header");
} }
if(entire[3] != 0x00) { if(entire[3] != 0x00) {
memoryFree(entire);
errorThrow("Unsupported tileset version"); errorThrow("Unsupported tileset version");
} }
// Fix endianness
out->tileWidth = endianLittleToHost16(*(uint16_t *)(entire + 4)); out->tileWidth = endianLittleToHost16(*(uint16_t *)(entire + 4));
out->tileHeight = endianLittleToHost16(*(uint16_t *)(entire + 6)); out->tileHeight = endianLittleToHost16(*(uint16_t *)(entire + 6));
out->columns = endianLittleToHost16(*(uint16_t *)(entire + 8)); out->columns = endianLittleToHost16(*(uint16_t *)(entire + 8));
out->rows = endianLittleToHost16(*(uint16_t *)(entire + 10)); out->rows = endianLittleToHost16(*(uint16_t *)(entire + 10));
// out->right = endianLittleToHost16(*(uint16_t *)(entire + 12));
// out->bottom = endianLittleToHost16(*(uint16_t *)(entire + 14));
if(out->tileWidth == 0) { if(out->tileWidth == 0) { memoryFree(entire); errorThrow("Tile width cannot be 0"); }
errorThrow("Tile width cannot be 0"); if(out->tileHeight == 0) { memoryFree(entire); errorThrow("Tile height cannot be 0"); }
} if(out->columns == 0) { memoryFree(entire); errorThrow("Column count cannot be 0"); }
if(out->tileHeight == 0) { if(out->rows == 0) { memoryFree(entire); errorThrow("Row count cannot be 0"); }
errorThrow("Tile height cannot be 0");
}
if(out->columns == 0) {
errorThrow("Column count cannot be 0");
}
if(out->rows == 0) {
errorThrow("Row count cannot be 0");
}
out->uv[0] = endianLittleToHostFloat(*(float *)(entire + 16)); out->uv[0] = endianLittleToHostFloat(*(float *)(entire + 16));
out->uv[1] = endianLittleToHostFloat(*(float *)(entire + 20)); out->uv[1] = endianLittleToHostFloat(*(float *)(entire + 20));
if(out->uv[1] < 0.0f || out->uv[1] > 1.0f) { if(out->uv[1] < 0.0f || out->uv[1] > 1.0f) {
memoryFree(entire);
errorThrow("Invalid v0 value in tileset"); errorThrow("Invalid v0 value in tileset");
} }
// Setup tileset
out->tileCount = out->columns * out->rows; out->tileCount = out->columns * out->rows;
memoryFree(entire); memoryFree(entire);
errorOk(); errorOk();
} }
// errorret_t assetTilesetLoad( errorret_t assetTilesetDispose(assetentry_t *entry) {
// const char_t *path, assertNotNull(entry, "Entry cannot be NULL");
// tileset_t *out assertTrue(entry->type == ASSET_LOADER_TYPE_TILESET, "Invalid type.");
// ) { errorOk();
// return assetLoad(path, assetTilesetLoader, NULL, out); }
// }
src/dusk/asset/loader/display/assettilesetloader.h
+5 -14
View File
@@ -9,27 +9,18 @@
#include "asset/assetfile.h" #include "asset/assetfile.h"
#include "display/texture/tileset.h" #include "display/texture/tileset.h"
typedef struct assetloading_s assetloading_t;
typedef struct assetentry_s assetentry_t;
typedef struct { typedef struct {
void *nothing; void *nothing;
} assettilesetloaderinput_t; } assettilesetloaderinput_t;
// NEW STUFF
typedef struct assetloading_s assetloading_t;
typedef struct assetentry_s assetentry_t;
typedef struct { typedef struct {
assetfile_t file; assetfile_t file;
} assettilesetloaderloading_t; } assettilesetloaderloading_t;
typedef tileset_t assettilesetoutput_t; typedef tileset_t assettilesetoutput_t;
errorret_t assetTilesetLoaderNEW(assetloading_t *loading); errorret_t assetTilesetLoaderSync(assetloading_t *loading);
errorret_t assetTilesetDisposeNEW(assetentry_t *entry); errorret_t assetTilesetDispose(assetentry_t *entry);
/**
* Handler for tileset assets.
*
* @param file Asset file to load the tileset from.
* @return Any error that occurs during loading.
*/
errorret_t assetTilesetLoader(assetfile_t *file);
src/dusk/asset/loader/json/assetjsonloader.c
+24 -48
View File
@@ -8,66 +8,42 @@
#include "assetjsonloader.h" #include "assetjsonloader.h"
#include "util/memory.h" #include "util/memory.h"
#include "assert/assert.h" #include "assert/assert.h"
#include "asset/loader/assetloading.h" #include "asset/loader/assetloading.h"
#include "asset/loader/assetentry.h" #include "asset/loader/assetentry.h"
errorret_t assetJsonLoaderNEW(assetloading_t *loading) { errorret_t assetJsonLoaderSync(assetloading_t *loading) {
assertNotNull(loading, "Loading cannot be NULL"); assertNotNull(loading, "Loading cannot be NULL");
assertTrue(loading->type == ASSET_LOADER_TYPE_JSON, "Invalid type."); assertTrue(loading->type == ASSET_LOADER_TYPE_JSON, "Invalid type.");
assetfile_t *file = &loading->loading.json.file; assetfile_t *file = &loading->loading.json.file;
errorChain(assetFileInit(file, loading->entry->name, NULL, &loading->entry->data.json)); errorChain(assetFileInit(file, loading->entry->name, NULL, NULL));
return assetJsonLoader(file);
if(file->size > ASSET_JSON_FILE_SIZE_MAX) {
errorThrow("JSON exceeds maximum allowed size");
}
uint8_t *buffer = memoryAllocate(file->size);
errorChain(assetFileOpen(file));
errorChain(assetFileRead(file, buffer, file->size));
assertTrue(file->lastRead == file->size, "Failed to read entire JSON file.");
errorChain(assetFileClose(file));
errorChain(assetFileDispose(file));
loading->entry->data.json = yyjson_read(
(char *)buffer,
file->size,
YYJSON_READ_ALLOW_COMMENTS | YYJSON_READ_ALLOW_TRAILING_COMMAS
);
memoryFree(buffer);
if(!loading->entry->data.json) errorThrow("Failed to parse JSON");
errorOk();
} }
errorret_t assetJsonDisposeNEW(assetentry_t *entry) { errorret_t assetJsonDispose(assetentry_t *entry) {
assertNotNull(entry, "Asset entry cannot be NULL"); assertNotNull(entry, "Asset entry cannot be NULL");
assertTrue(entry->type == ASSET_LOADER_TYPE_JSON, "Invalid type."); assertTrue(entry->type == ASSET_LOADER_TYPE_JSON, "Invalid type.");
yyjson_doc_free(entry->data.json); yyjson_doc_free(entry->data.json);
entry->data.json = NULL; entry->data.json = NULL;
errorOk(); errorOk();
} }
errorret_t assetJsonLoadFileToDoc(assetfile_t *file, yyjson_doc **outDoc) {
assertNotNull(file, "Asset file pointer for JSON loader is null.");
assertNotNull(outDoc, "Output pointer for JSON loader is null.");
if(file->size > ASSET_JSON_FILE_SIZE_MAX) {
errorThrow("JSON exceeds maximum allowed size");
}
// Create buffer
uint8_t *buffer = memoryAllocate(file->size);
errorChain(assetFileOpen(file));
// Read entire file
errorChain(assetFileRead(file, buffer, file->size));
assertTrue(file->lastRead == file->size, "Failed to read entire JSON file.");
errorChain(assetFileClose(file));
*outDoc = yyjson_read(
buffer,
file->size,
YYJSON_READ_ALLOW_COMMENTS | YYJSON_READ_ALLOW_TRAILING_COMMAS
);
memoryFree(buffer);
if(!*outDoc) errorThrow("Failed to parse JSON");
errorOk();
}
errorret_t assetJsonLoader(assetfile_t *file) {
yyjson_doc **outDoc = (yyjson_doc **)file->output;
assertNotNull(outDoc, "Output pointer for JSON loader is null.");
return assetJsonLoadFileToDoc(file, outDoc);
}
// errorret_t assetJsonLoad(
// const char_t *path,
// yyjson_doc **outDoc
// ) {
// return assetLoad(path, assetJsonLoader, NULL, outDoc);
// }
src/dusk/asset/loader/json/assetjsonloader.h
+2 -26
View File
@@ -11,11 +11,6 @@
#define ASSET_JSON_FILE_SIZE_MAX 1024*256 #define ASSET_JSON_FILE_SIZE_MAX 1024*256
typedef struct {
void *nothing;
} assetjsonloaderparams_t;
// NEW STUFF
typedef struct assetloading_s assetloading_t; typedef struct assetloading_s assetloading_t;
typedef struct assetentry_s assetentry_t; typedef struct assetentry_s assetentry_t;
@@ -25,24 +20,5 @@ typedef struct {
} assetjsonloaderloading_t; } assetjsonloaderloading_t;
typedef yyjson_doc * assetjsonoutput_t; typedef yyjson_doc * assetjsonoutput_t;
errorret_t assetJsonLoaderNEW(assetloading_t *loading); errorret_t assetJsonLoaderSync(assetloading_t *loading);
errorret_t assetJsonDisposeNEW(assetentry_t *entry); errorret_t assetJsonDispose(assetentry_t *entry);
// END NEW STUFF
/**
* Loads a JSON document from the specified asset file.
*
* @param file Asset file to load the JSON document from.
* @param outDoc Pointer to store the loaded JSON document.
* @return Any error that occurs during loading.
*/
errorret_t assetJsonLoadFileToDoc(assetfile_t *file, yyjson_doc **outDoc);
/**
* Handler for locale assets.
*
* @param file Asset file to load the locale from.
* @return Any error that occurs during loading.
*/
errorret_t assetJsonLoader(assetfile_t *file);
src/dusk/asset/loader/locale/assetlocaleloader.c
+8 -32
View File
@@ -14,51 +14,27 @@
#include "asset/loader/assetloading.h" #include "asset/loader/assetloading.h"
#include "asset/loader/assetentry.h" #include "asset/loader/assetentry.h"
errorret_t assetLocaleLoaderNEW(assetloading_t *loading) { errorret_t assetLocaleLoaderSync(assetloading_t *loading) {
assertNotNull(loading, "Loading cannot be NULL"); assertNotNull(loading, "Loading cannot be NULL");
assertTrue(loading->type == ASSET_LOADER_TYPE_LOCALE, "Invalid type."); assertTrue(loading->type == ASSET_LOADER_TYPE_LOCALE, "Invalid type.");
return assetLocaleFileInit(
&loading->entry->data.locale,
loading->entry->name
);
}
errorret_t assetLocaleDisposeNEW(assetentry_t *entry) {
assertNotNull(entry, "Asset entry cannot be NULL");
assertTrue(entry->type == ASSET_LOADER_TYPE_LOCALE, "Invalid type.");
return assetLocaleFileDispose(&entry->data.locale);
}
errorret_t assetLocaleFileInit(
assetlocalefile_t *localeFile,
const char_t *path
) {
assertNotNull(localeFile, "Locale file cannot be NULL.");
assertNotNull(path, "Locale file path cannot be NULL.");
assetlocalefile_t *localeFile = &loading->entry->data.locale;
memoryZero(localeFile, sizeof(assetlocalefile_t)); memoryZero(localeFile, sizeof(assetlocalefile_t));
errorChain(assetFileInit(&localeFile->file, loading->entry->name, NULL, NULL));
// Init the asset file.
errorChain(assetFileInit(&localeFile->file, path, NULL, NULL));
// Open the file handle
errorChain(assetFileOpen(&localeFile->file)); errorChain(assetFileOpen(&localeFile->file));
// Get the blank key, this is basically the header info for po files
char_t buffer[1024]; char_t buffer[1024];
errorChain(assetLocaleGetString(localeFile, "", 0, buffer, sizeof(buffer))); errorChain(assetLocaleGetString(localeFile, "", 0, buffer, sizeof(buffer)));
errorChain(assetLocaleParseHeader(localeFile, buffer, sizeof(buffer))); errorChain(assetLocaleParseHeader(localeFile, buffer, sizeof(buffer)));
errorOk(); errorOk();
} }
errorret_t assetLocaleFileDispose(assetlocalefile_t *localeFile) { errorret_t assetLocaleDispose(assetentry_t *entry) {
assertNotNull(localeFile, "Locale file cannot be NULL."); assertNotNull(entry, "Asset entry cannot be NULL");
assertTrue(entry->type == ASSET_LOADER_TYPE_LOCALE, "Invalid type.");
assetlocalefile_t *localeFile = &entry->data.locale;
errorChain(assetFileClose(&localeFile->file)); errorChain(assetFileClose(&localeFile->file));
errorChain(assetFileDispose(&localeFile->file)); return assetFileDispose(&localeFile->file);
errorOk();
} }
errorret_t assetLocaleParseHeader( errorret_t assetLocaleParseHeader(
src/dusk/asset/loader/locale/assetlocaleloader.h
+2 -25
View File
@@ -8,7 +8,6 @@
#pragma once #pragma once
#include "asset/assetfile.h" #include "asset/assetfile.h"
// NEW STUFF
typedef struct assetloading_s assetloading_t; typedef struct assetloading_s assetloading_t;
typedef struct assetentry_s assetentry_t; typedef struct assetentry_s assetentry_t;
@@ -52,30 +51,8 @@ typedef struct {
typedef assetlocalefile_t assetlocaleoutput_t; typedef assetlocalefile_t assetlocaleoutput_t;
errorret_t assetLocaleLoaderNEW(assetloading_t *loading); errorret_t assetLocaleLoaderSync(assetloading_t *loading);
errorret_t assetLocaleDisposeNEW(assetentry_t *entry); errorret_t assetLocaleDispose(assetentry_t *entry);
// END NEW STUFF
/**
* Initialize a locale asset file.
*
* @param localeFile The locale file to initialize.
* @param path The path to the locale file.
* @return An error code if a failure occurs.
*/
errorret_t assetLocaleFileInit(
assetlocalefile_t *localeFile,
const char_t *path
);
/**
* Dispose of a locale asset file.
*
* @param localeFile The locale file to dispose of.
* @return An error code if a failure occurs.
*/
errorret_t assetLocaleFileDispose(assetlocalefile_t *localeFile);
errorret_t assetLocaleParseHeader( errorret_t assetLocaleParseHeader(
assetlocalefile_t *localeFile, assetlocalefile_t *localeFile,