From 7741e424f155bd05c680a9dc47743ec2047b672f Mon Sep 17 00:00:00 2001 From: Anonymous Maarten Date: Tue, 25 Jan 2022 06:24:24 +0100 Subject: [PATCH 01/14] regsupt: Implement all regsupt functions --- src/BRSRC13/CORE/V1DB/regsupt.c | 124 ++++++++++++++++++++++++++------ 1 file changed, 102 insertions(+), 22 deletions(-) diff --git a/src/BRSRC13/CORE/V1DB/regsupt.c b/src/BRSRC13/CORE/V1DB/regsupt.c index 81f2cfee..c280951f 100644 --- a/src/BRSRC13/CORE/V1DB/regsupt.c +++ b/src/BRSRC13/CORE/V1DB/regsupt.c @@ -10,6 +10,8 @@ // IDA: br_model* __cdecl BrModelAdd(br_model *model) br_model* BrModelAdd(br_model* model) { + LOG_TRACE10("(%p)", model); + BrRegistryAdd(&v1db.reg_models, model); BrModelUpdate(model, BR_MODU_ALL); return model; @@ -26,6 +28,7 @@ br_model* BrModelRemove(br_model* model) { // IDA: br_model* __cdecl BrModelFind(char *pattern) br_model* BrModelFind(char* pattern) { LOG_TRACE("(\"%s\")", pattern); + return BrRegistryFind(&v1db.reg_models, pattern); } @@ -33,7 +36,10 @@ br_model* BrModelFind(char* pattern) { br_model_find_cbfn* BrModelFindHook(br_model_find_cbfn* hook) { br_model_find_cbfn* old; LOG_TRACE("(%p)", hook); - NOT_IMPLEMENTED(); + + old = (br_model_find_cbfn*)v1db.reg_models.find_failed_hook; + v1db.reg_models.find_failed_hook = (br_find_failed_cbfn*)hook; + return old; } // IDA: br_uint_32 __cdecl BrModelAddMany(br_model **items, int n) @@ -41,7 +47,16 @@ br_uint_32 BrModelAddMany(br_model** items, int n) { int i; int r; LOG_TRACE("(%p, %d)", items, n); - NOT_IMPLEMENTED(); + + r = 0; + for (i = 0; i < n; i++) { + BrRegistryAdd(&v1db.reg_models, items[i]); + BrModelUpdate(items[i], BR_MODU_ALL); + if (items[i] != NULL) { + r++; + } + } + return r; } // IDA: br_uint_32 __cdecl BrModelRemoveMany(br_model **items, int n) @@ -49,29 +64,42 @@ br_uint_32 BrModelRemoveMany(br_model** items, int n) { int i; int r; LOG_TRACE("(%p, %d)", items, n); - NOT_IMPLEMENTED(); + + r = 0; + for (i = 0; i < n; i++) { + BrModelClear(items[n]); + if (BrRegistryRemove(&v1db.reg_models, items[n]) != NULL) { + r++; + } + } + return r; } // IDA: br_uint_32 __cdecl BrModelFindMany(char *pattern, br_model **items, int max) br_uint_32 BrModelFindMany(char* pattern, br_model** items, int max) { LOG_TRACE("(\"%s\", %p, %d)", pattern, items, max); - NOT_IMPLEMENTED(); + + return BrRegistryFindMany(&v1db.reg_models, pattern, (void**)items, max); } // IDA: br_uint_32 __cdecl BrModelCount(char *pattern) br_uint_32 BrModelCount(char* pattern) { LOG_TRACE("(\"%s\")", pattern); - NOT_IMPLEMENTED(); + + return BrRegistryCount(&v1db.reg_models, pattern); } // IDA: br_uint_32 __cdecl BrModelEnum(char *pattern, br_model_enum_cbfn *callback, void *arg) br_uint_32 BrModelEnum(char* pattern, br_model_enum_cbfn* callback, void* arg) { LOG_TRACE("(\"%s\", %p, %p)", pattern, callback, arg); - NOT_IMPLEMENTED(); + + return BrRegistryEnum(&v1db.reg_models, pattern, (br_enum_cbfn*)callback, arg); } // IDA: br_material* __cdecl BrMaterialAdd(br_material *material) br_material* BrMaterialAdd(br_material* material) { + LOG_TRACE10("(%p)", material); + BrRegistryAdd(&v1db.reg_materials, material); BrMaterialUpdate(material, BR_MATU_ALL); return material; @@ -95,13 +123,17 @@ br_material* BrMaterialFind(char* pattern) { br_material_find_cbfn* BrMaterialFindHook(br_material_find_cbfn* hook) { br_material_find_cbfn* old; LOG_TRACE("(%p)", hook); - NOT_IMPLEMENTED(); + + old = (br_material_find_cbfn*)v1db.reg_materials.find_failed_hook; + v1db.reg_materials.find_failed_hook = (br_find_failed_cbfn*)hook; + return old; } // IDA: br_uint_32 __cdecl BrMaterialAddMany(br_material **items, int n) br_uint_32 BrMaterialAddMany(br_material** items, int n) { int i; int r; + LOG_TRACE10("(%p, %d)", items, n); r = 0; for (i = 0; i < n; i++) { @@ -119,30 +151,43 @@ br_uint_32 BrMaterialRemoveMany(br_material** items, int n) { int i; int r; LOG_TRACE("(%p, %d)", items, n); - NOT_IMPLEMENTED(); + + r = 0; + for (i = 0; i < n; i++) { + BrMaterialClear(items[i]); + BrRegistryRemove(&v1db.reg_materials, items[i]); + if (items[i]) { + r++; + } + } + return r; } // IDA: br_uint_32 __cdecl BrMaterialFindMany(char *pattern, br_material **items, int max) br_uint_32 BrMaterialFindMany(char* pattern, br_material** items, int max) { LOG_TRACE("(\"%s\", %p, %d)", pattern, items, max); - NOT_IMPLEMENTED(); + + return BrRegistryFindMany(&v1db.reg_materials, pattern, (void**)items, max); } // IDA: br_uint_32 __cdecl BrMaterialCount(char *pattern) br_uint_32 BrMaterialCount(char* pattern) { LOG_TRACE("(\"%s\")", pattern); - NOT_IMPLEMENTED(); + + return BrRegistryCount(&v1db.reg_materials, pattern); } // IDA: br_uint_32 __cdecl BrMaterialEnum(char *pattern, br_material_enum_cbfn *callback, void *arg) br_uint_32 BrMaterialEnum(char* pattern, br_material_enum_cbfn* callback, void* arg) { LOG_TRACE("(\"%s\", %p, %p)", pattern, callback, arg); + return BrRegistryEnum(&v1db.reg_materials, pattern, (br_enum_cbfn*)callback, arg); } // IDA: br_pixelmap* __cdecl BrMapAdd(br_pixelmap *pixelmap) br_pixelmap* BrMapAdd(br_pixelmap* pixelmap) { - LOG_TRACE("(%p)", pixelmap); + LOG_TRACE10("(%p)", pixelmap); + BrRegistryAdd(&v1db.reg_textures, pixelmap); BrMapUpdate(pixelmap, 0xFFFu); return pixelmap; @@ -159,6 +204,7 @@ br_pixelmap* BrMapRemove(br_pixelmap* pixelmap) { // IDA: br_pixelmap* __cdecl BrMapFind(char *pattern) br_pixelmap* BrMapFind(char* pattern) { LOG_TRACE("(\"%s\")", pattern); + return BrRegistryFind(&v1db.reg_textures, pattern); } @@ -166,13 +212,17 @@ br_pixelmap* BrMapFind(char* pattern) { br_map_find_cbfn* BrMapFindHook(br_map_find_cbfn* hook) { br_map_find_cbfn* old; LOG_TRACE("(%p)", hook); - NOT_IMPLEMENTED(); + + old = (br_map_find_cbfn*)v1db.reg_textures.find_failed_hook; + v1db.reg_textures.find_failed_hook = (br_find_failed_cbfn*)hook; + return old; } // IDA: br_uint_32 __cdecl BrMapAddMany(br_pixelmap **items, int n) br_uint_32 BrMapAddMany(br_pixelmap** items, int n) { int i; int r; + LOG_TRACE10("(%p, %d)", items, n); r = 0; for (i = 0; i < n; i++) { @@ -190,25 +240,36 @@ br_uint_32 BrMapRemoveMany(br_pixelmap** items, int n) { int i; int r; LOG_TRACE("(%p, %d)", items, n); - NOT_IMPLEMENTED(); + + r = 0; + for (i = 0; i < n; i++) { + BrBufferClear(items[i]); + if (BrRegistryRemove(&v1db.reg_textures, items[i]) != NULL) { + r++; + } + } + return r; } // IDA: br_uint_32 __cdecl BrMapFindMany(char *pattern, br_pixelmap **items, int max) br_uint_32 BrMapFindMany(char* pattern, br_pixelmap** items, int max) { LOG_TRACE("(\"%s\", %p, %d)", pattern, items, max); - NOT_IMPLEMENTED(); + + return BrRegistryFindMany(&v1db.reg_textures, pattern, (void**)items, max); } // IDA: br_uint_32 __cdecl BrMapCount(char *pattern) br_uint_32 BrMapCount(char* pattern) { LOG_TRACE("(\"%s\")", pattern); - NOT_IMPLEMENTED(); + + return BrRegistryCount(&v1db.reg_textures, pattern); } // IDA: br_uint_32 __cdecl BrMapEnum(char *pattern, br_map_enum_cbfn *callback, void *arg) br_uint_32 BrMapEnum(char* pattern, br_map_enum_cbfn* callback, void* arg) { LOG_TRACE("(\"%s\", %p, %p)", pattern, callback, arg); - NOT_IMPLEMENTED(); + + return BrRegistryEnum(&v1db.reg_textures, pattern, (br_enum_cbfn*)callback, arg); } // IDA: br_pixelmap* __cdecl BrTableAdd(br_pixelmap *pixelmap) @@ -223,12 +284,15 @@ br_pixelmap* BrTableAdd(br_pixelmap* pixelmap) { // IDA: br_pixelmap* __cdecl BrTableRemove(br_pixelmap *pixelmap) br_pixelmap* BrTableRemove(br_pixelmap* pixelmap) { LOG_TRACE("(%p)", pixelmap); - NOT_IMPLEMENTED(); + + BrBufferClear(pixelmap); + return BrRegistryRemove(&v1db.reg_tables, pixelmap); } // IDA: br_pixelmap* __cdecl BrTableFind(char *pattern) br_pixelmap* BrTableFind(char* pattern) { LOG_TRACE("(\"%s\")", pattern); + return BrRegistryFind(&v1db.reg_tables, pattern); } @@ -236,14 +300,19 @@ br_pixelmap* BrTableFind(char* pattern) { br_table_find_cbfn* BrTableFindHook(br_table_find_cbfn* hook) { br_table_find_cbfn* old; LOG_TRACE("(%p)", hook); - NOT_IMPLEMENTED(); + + old = (br_table_find_cbfn*)v1db.reg_tables.find_failed_hook; + v1db.reg_tables.find_failed_hook = (br_find_failed_cbfn*)hook; + return old; } // IDA: br_uint_32 __cdecl BrTableAddMany(br_pixelmap **items, int n) br_uint_32 BrTableAddMany(br_pixelmap** items, int n) { int i; int r = 0; + LOG_TRACE10("(%p, %d)", items, n); + r = 0; for (i = 0; i < n; i++) { BrRegistryAdd(&v1db.reg_tables, items[i]); BrTableUpdate(items[i], BR_TABU_ALL); @@ -259,23 +328,34 @@ br_uint_32 BrTableRemoveMany(br_pixelmap** items, int n) { int i; int r; LOG_TRACE("(%p, %d)", items, n); - NOT_IMPLEMENTED(); + + r = 0; + for (i = 0; i < n; i++) { + BrBufferClear(items[i]); + if (BrRegistryRemove(&v1db.reg_tables, items[i]) != NULL) { + r++; + } + } + return r; } // IDA: br_uint_32 __cdecl BrTableFindMany(char *pattern, br_pixelmap **items, int max) br_uint_32 BrTableFindMany(char* pattern, br_pixelmap** items, int max) { LOG_TRACE("(\"%s\", %p, %d)", pattern, items, max); - NOT_IMPLEMENTED(); + + return BrRegistryFindMany(&v1db.reg_tables, pattern, (void**)items, max); } // IDA: br_uint_32 __cdecl BrTableCount(char *pattern) br_uint_32 BrTableCount(char* pattern) { LOG_TRACE("(\"%s\")", pattern); - NOT_IMPLEMENTED(); + + return BrRegistryCount(&v1db.reg_tables, pattern); } // IDA: br_uint_32 __cdecl BrTableEnum(char *pattern, br_table_enum_cbfn *callback, void *arg) br_uint_32 BrTableEnum(char* pattern, br_table_enum_cbfn* callback, void* arg) { LOG_TRACE("(\"%s\", %p, %p)", pattern, callback, arg); - NOT_IMPLEMENTED(); + + return BrRegistryEnum(&v1db.reg_tables, pattern, (br_enum_cbfn*)callback, arg); } From c0fe8cd43e8f316c62f549b9f8a210d8bcc95e20 Mon Sep 17 00:00:00 2001 From: Anonymous Maarten Date: Tue, 1 Feb 2022 11:32:35 +0100 Subject: [PATCH 02/14] test: fix regsupt tests to cope with 'polluted' brender state --- test/BRSRC13/test_regsupt.c | 34 +++++++++++++++++++++------------- 1 file changed, 21 insertions(+), 13 deletions(-) diff --git a/test/BRSRC13/test_regsupt.c b/test/BRSRC13/test_regsupt.c index 66b33a79..eb2b55ac 100644 --- a/test/BRSRC13/test_regsupt.c +++ b/test/BRSRC13/test_regsupt.c @@ -2,35 +2,43 @@ #include "CORE/V1DB/regsupt.h" #include "tests.h" -int nbr_callbacks; +struct callback_data { + int nb; +}; br_uint_32 callback(br_material* mat, void* arg) { - nbr_callbacks++; + ((struct callback_data*)arg)->nb++; return 0; } void test_regsupt_BrMaterialEnum() { + int nb_initial; int result; + struct callback_data callback_data; br_material *m, *m2; - m = BrMaterialAllocate("mat1"); - m2 = BrMaterialAllocate("mat2"); + callback_data.nb = 0; + BrMaterialEnum(NULL, callback, &callback_data); + nb_initial = callback_data.nb; + + m = BrMaterialAllocate("regsupt_BrMaterialEnum_mat1"); + m2 = BrMaterialAllocate("regsupt_BrMaterialEnum_mat2"); TEST_ASSERT_NOT_NULL(m); TEST_ASSERT_NOT_NULL(m2); BrMaterialAdd(m); BrMaterialAdd(m2); - nbr_callbacks = 0; - result = BrMaterialEnum("*", callback, NULL); - TEST_ASSERT_EQUAL_INT(2, nbr_callbacks); + callback_data.nb = 0; + result = BrMaterialEnum("regsupt_BrMaterialEnum_*", callback, &callback_data); + TEST_ASSERT_EQUAL_INT(2, callback_data.nb); - nbr_callbacks = 0; - result = BrMaterialEnum(NULL, callback, NULL); - TEST_ASSERT_EQUAL_INT(2, nbr_callbacks); + callback_data.nb = 0; + result = BrMaterialEnum(NULL, callback, &callback_data); + TEST_ASSERT_EQUAL_INT(2, callback_data.nb - nb_initial); - nbr_callbacks = 0; - result = BrMaterialEnum("mat1", callback, NULL); - TEST_ASSERT_EQUAL_INT(1, nbr_callbacks); + callback_data.nb = 0; + result = BrMaterialEnum("regsupt_BrMaterialEnum_mat1", callback, &callback_data); + TEST_ASSERT_EQUAL_INT(1, callback_data.nb); } void test_regsupt_suite() { From 9ce4c1dc7f5f82cbbe7acc3680c26e348ab777ac Mon Sep 17 00:00:00 2001 From: Anonymous Maarten Date: Thu, 27 Jan 2022 15:28:31 +0100 Subject: [PATCH 03/14] tests: Re-order tests + fix temp file --- test/main.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/test/main.c b/test/main.c index 6aed8704..b343c2f0 100644 --- a/test/main.c +++ b/test/main.c @@ -1,6 +1,7 @@ #include "tests.h" #include "harness/hooks.h" #include +#include #include #include #include @@ -162,10 +163,11 @@ void create_temp_file(char buffer[PATH_MAX+1], const char *prefix) { struct stat sb; int res; - stat(temp_folder, &sb); - if (!S_ISDIR(sb.st_mode)) { + res = stat(temp_folder, &sb); + if (res == -1 || !S_ISDIR(sb.st_mode)) { res = mkdir(temp_folder, 0770); if (res == -1) { + fprintf(stderr, "mmkdir(\"%s\") failed: %s\n", temp_folder, strerror(errno)); abort(); } } @@ -175,6 +177,7 @@ void create_temp_file(char buffer[PATH_MAX+1], const char *prefix) { strcat(buffer, "XXXXXX"); fdres = mkstemp(buffer); if (fdres == -1) { + fprintf(stderr, "mkstemp(\"%s\") failed: %s\n", buffer, strerror(errno)); abort(); } close(fdres); @@ -198,21 +201,22 @@ int main(int argc, char** argv) { test_matrix34_suite(); test_matrix4_suite(); test_quat_suite(); + test_fixed_suite(); test_brlists_suite(); + test_pattern_suite(); + test_register_suite(); + test_fwsetup_suite(); + test_scratch_suite(); test_resource_suite(); test_actsupt_suite(); test_genclip_suite(); - test_register_suite(); test_datafile_suite(); - test_pattern_suite(); test_pmfile_suite(); - test_fixed_suite(); test_v1dbfile_suite(); test_regsupt_suite(); - test_scratch_suite(); // DETHRACE test_utility_suite(); From f1b64100dcf6f5c1ae8142e377cf71f1cb86092d Mon Sep 17 00:00:00 2001 From: Anonymous Maarten Date: Thu, 27 Jan 2022 16:48:44 +0100 Subject: [PATCH 04/14] tests: Move binary/test file contents test to shared file+header --- test/BRSRC13/test_datafile.c | 43 ------------------------------- test/main.c | 50 +++++++++++++++++++++++++++++++++--- test/tests.h | 3 +++ 3 files changed, 50 insertions(+), 46 deletions(-) diff --git a/test/BRSRC13/test_datafile.c b/test/BRSRC13/test_datafile.c index 76fe208a..10388e73 100644 --- a/test/BRSRC13/test_datafile.c +++ b/test/BRSRC13/test_datafile.c @@ -12,49 +12,6 @@ char *text_magics = TEXT_MAGICS; uint8_t binary_magics[] = {BINARY_MAGICS}; -static void TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(const uint8_t *expected, char *filename, int len) { - FILE *f; - long filesize; - int res; - f = fopen(filename, "rb"); - TEST_ASSERT_NOT_NULL(f); - res = fseek(f, 0, SEEK_END); - TEST_ASSERT_NOT_EQUAL(-1, res); - filesize = ftell(f); - TEST_ASSERT_NOT_EQUAL(-1, filesize); - TEST_ASSERT_EQUAL(len, filesize); - fseek(f, 0, SEEK_SET); - uint8_t* tmpBuffer = (uint8_t*)malloc(filesize); - res = fread(tmpBuffer, filesize, 1, f); - TEST_ASSERT_EQUAL_INT(1, res); - fclose(f); - TEST_ASSERT_EQUAL_MEMORY(expected, tmpBuffer, len); - free(tmpBuffer); -} - -static void TEST_ASSERT_EQUAL_FILE_TEXT(const char *expected, char *filename) { - FILE *f; - long filesize; - int res; - - int len = strlen(expected); - f = fopen(filename, "r"); - TEST_ASSERT_NOT_NULL(f); - res = fseek(f, 0, SEEK_END); - TEST_ASSERT_NOT_EQUAL(-1, res); - filesize = ftell(f); - TEST_ASSERT_NOT_EQUAL(-1, filesize); - fseek(f, 0, SEEK_SET); - char* tmpBuffer = (char*)malloc(filesize+1); - res = fread(tmpBuffer, 1, filesize, f); - TEST_ASSERT_EQUAL_INT(filesize, res); - tmpBuffer[filesize] = '\0'; - fclose(f); - TEST_ASSERT_EQUAL_STRING(expected, tmpBuffer); - TEST_ASSERT_EQUAL(len, filesize); - TEST_ASSERT_EQUAL_INT(filesize, strlen(tmpBuffer)); - free(tmpBuffer); -} static void test_datafile_stack() { int dummy1; diff --git a/test/main.c b/test/main.c index b343c2f0..ec77d2b8 100644 --- a/test/main.c +++ b/test/main.c @@ -85,7 +85,51 @@ static void setup_temp_folder() { temp_folder = temp_folder_buffer; } -void setup_global_vars() { +void TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(const uint8_t *expected, char *filename, int len) { + FILE *f; + long filesize; + int res; + f = fopen(filename, "rb"); + TEST_ASSERT_NOT_NULL(f); + res = fseek(f, 0, SEEK_END); + TEST_ASSERT_NOT_EQUAL(-1, res); + filesize = ftell(f); + TEST_ASSERT_NOT_EQUAL(-1, filesize); + TEST_ASSERT_EQUAL(len, filesize); + fseek(f, 0, SEEK_SET); + uint8_t* tmpBuffer = (uint8_t*)malloc(filesize); + res = fread(tmpBuffer, filesize, 1, f); + TEST_ASSERT_EQUAL_INT(1, res); + fclose(f); + TEST_ASSERT_EQUAL_MEMORY(expected, tmpBuffer, len); + free(tmpBuffer); +} + +void TEST_ASSERT_EQUAL_FILE_TEXT(const char *expected, char *filename) { + FILE *f; + long filesize; + int res; + + int len = strlen(expected); + f = fopen(filename, "r"); + TEST_ASSERT_NOT_NULL(f); + res = fseek(f, 0, SEEK_END); + TEST_ASSERT_NOT_EQUAL(-1, res); + filesize = ftell(f); + TEST_ASSERT_NOT_EQUAL(-1, filesize); + fseek(f, 0, SEEK_SET); + char* tmpBuffer = (char*)malloc(filesize+1); + res = fread(tmpBuffer, 1, filesize, f); + TEST_ASSERT_EQUAL_INT(filesize, res); + tmpBuffer[filesize] = '\0'; + fclose(f); + TEST_ASSERT_EQUAL_STRING(expected, tmpBuffer); + TEST_ASSERT_EQUAL(len, filesize); + TEST_ASSERT_EQUAL_INT(filesize, strlen(tmpBuffer)); + free(tmpBuffer); +} + +void setup_global_vars(int argc, char *argv[]) { strcpy(gDir_separator, "/"); root_dir = getenv("DETHRACE_ROOT_DIR"); @@ -122,7 +166,7 @@ void setup_global_vars() { int fake_argc = 2; char* fake_argv[2]; - fake_argv[0] = "test"; + fake_argv[0] = argv[0]; fake_argv[1] = "-platform=null"; Harness_Init(&fake_argc, fake_argv); } @@ -192,7 +236,7 @@ int main(int argc, char** argv) { exit(1); } - setup_global_vars(); + setup_global_vars(argc, argv); printf("Completed setup\n"); diff --git a/test/tests.h b/test/tests.h index 28a26a2a..b843935a 100644 --- a/test/tests.h +++ b/test/tests.h @@ -9,6 +9,9 @@ #endif #define HOST_NL "\n" +void TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(const uint8_t *expected, char *filename, int len); +void TEST_ASSERT_EQUAL_FILE_TEXT(const char *expected, char *filename); + extern int has_data_directory(); extern void sleep_s(int sec); void create_temp_file(char buffer[PATH_MAX+1], const char *prefix); From 3973442457388b5a2cf04c0829d139c97f8a4857 Mon Sep 17 00:00:00 2001 From: Anonymous Maarten Date: Mon, 31 Jan 2022 16:29:29 +0100 Subject: [PATCH 05/14] Add euler defines to angles header --- src/BRSRC13/CORE/MATH/angles.h | 25 +++++++++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/src/BRSRC13/CORE/MATH/angles.h b/src/BRSRC13/CORE/MATH/angles.h index d19bf4a1..8231faaa 100644 --- a/src/BRSRC13/CORE/MATH/angles.h +++ b/src/BRSRC13/CORE/MATH/angles.h @@ -4,6 +4,31 @@ #include "brender/br_types.h" #include +#define BR_EULER_XYZ_S 0 +#define BR_EULER_XYX_S 8 +#define BR_EULER_XZY_S 4 +#define BR_EULER_XZX_S 12 +#define BR_EULER_YZX_S 1 +#define BR_EULER_YZY_S 9 +#define BR_EULER_YXZ_S 5 +#define BR_EULER_YXY_S 13 +#define BR_EULER_ZXY_S 2 +#define BR_EULER_ZXZ_S 10 +#define BR_EULER_ZYX_S 6 +#define BR_EULER_ZYZ_S 14 +#define BR_EULER_ZYX_R 16 +#define BR_EULER_XYX_R 24 +#define BR_EULER_YZX_R 20 +#define BR_EULER_XZX_R 28 +#define BR_EULER_XZY_R 17 +#define BR_EULER_YZY_R 25 +#define BR_EULER_ZXY_R 21 +#define BR_EULER_YXY_R 29 +#define BR_EULER_YXZ_R 18 +#define BR_EULER_ZXZ_R 26 +#define BR_EULER_XYZ_R 22 +#define BR_EULER_ZYZ_R 30 + br_matrix34* BrEulerToMatrix34(br_matrix34* mat, br_euler* euler); br_euler* BrMatrix34ToEuler(br_euler* euler, br_matrix34* mat); From bf1de8b36ca709a0328b6b52f68645a67a0af513 Mon Sep 17 00:00:00 2001 From: Anonymous Maarten Date: Fri, 28 Jan 2022 10:18:38 +0100 Subject: [PATCH 06/14] Stub BrPixelmapDirectLock and BrPixelmapDirectUnlock (FIXME: add TODO/FIXME) --- src/BRSRC13/CORE/PIXELMAP/pmdsptch.c | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/src/BRSRC13/CORE/PIXELMAP/pmdsptch.c b/src/BRSRC13/CORE/PIXELMAP/pmdsptch.c index f412986c..7acbed56 100644 --- a/src/BRSRC13/CORE/PIXELMAP/pmdsptch.c +++ b/src/BRSRC13/CORE/PIXELMAP/pmdsptch.c @@ -435,11 +435,28 @@ void BrPixelmapPaletteEntrySetMany(br_pixelmap* pm, br_int_32 index, br_int_32 n // IDA: br_pixelmap* __cdecl BrPixelmapDirectLock(br_pixelmap *src, br_boolean block) br_pixelmap* BrPixelmapDirectLock(br_pixelmap* src, br_boolean block) { LOG_TRACE("(%p, %d)", src, block); - NOT_IMPLEMENTED(); + +#if 0 + // FIXME: use pixelmap dispatch table + CheckDispatch(src); + return ((br_device_pixelmap*)(src))->dispatch->_directLock(src) == 0 ? src : NULL; +#else + STUB(); + return src; +#endif } // IDA: br_pixelmap* __cdecl BrPixelmapDirectUnlock(br_pixelmap *src) br_pixelmap* BrPixelmapDirectUnlock(br_pixelmap* src) { LOG_TRACE("(%p)", src); - NOT_IMPLEMENTED(); + + STUB(); +#if 0 + // FIXME: use pixelmap dispatch table + CheckDispatch(src); + return ((br_device_pixelmap*)(src))->dispatch->_directUnlock(src) == 0 ? src : NULL; +#else + STUB(); + return src; +#endif } From c2715ef13f716fc77beedb3d021683c9e6b33148 Mon Sep 17 00:00:00 2001 From: Anonymous Maarten Date: Mon, 31 Jan 2022 16:32:53 +0100 Subject: [PATCH 07/14] math: Implement BrVectorX functions --- src/BRSRC13/CORE/MATH/vector.c | 168 +++++++-- test/BRSRC13/test_vector.c | 637 +++++++++++++++++++++++++++++++++ test/CMakeLists.txt | 1 + test/main.c | 2 + 4 files changed, 772 insertions(+), 36 deletions(-) create mode 100644 test/BRSRC13/test_vector.c diff --git a/src/BRSRC13/CORE/MATH/vector.c b/src/BRSRC13/CORE/MATH/vector.c index ee9c54af..6e918505 100644 --- a/src/BRSRC13/CORE/MATH/vector.c +++ b/src/BRSRC13/CORE/MATH/vector.c @@ -2,121 +2,163 @@ #include "harness/trace.h" #include + +#define BR_MAC2(A, B, C, D) ((A) * (B) + (C) * (D)) +#define BR_MAC4(A, B, C, D, E, F, G, H) ((A) * (B) + (C) * (D) + (E) * (F) + (G) * (H)) + // IDA: void __cdecl BrVector2Copy(br_vector2 *v1, br_vector2 *v2) void BrVector2Copy(br_vector2* v1, br_vector2* v2) { LOG_TRACE("(%p, %p)", v1, v2); - NOT_IMPLEMENTED(); + + v1->v[0] = v2->v[0]; + v1->v[1] = v2->v[1]; } // IDA: void __cdecl BrVector2Set(br_vector2 *v1, br_scalar s1, br_scalar s2) void BrVector2Set(br_vector2* v1, br_scalar s1, br_scalar s2) { LOG_TRACE("(%p, %f, %f)", v1, s1, s2); - NOT_IMPLEMENTED(); + + v1->v[0] = s1; + v1->v[1] = s2; } // IDA: void __cdecl BrVector2SetInt(br_vector2 *v1, int i1, int i2) void BrVector2SetInt(br_vector2* v1, int i1, int i2) { LOG_TRACE("(%p, %d, %d)", v1, i1, i2); - NOT_IMPLEMENTED(); + + v1->v[0] = BR_SCALAR(i1); + v1->v[1] = BR_SCALAR(i2); } // IDA: void __cdecl BrVector2SetFloat(br_vector2 *v1, float f1, float f2) void BrVector2SetFloat(br_vector2* v1, float f1, float f2) { LOG_TRACE("(%p, %f, %f)", v1, f1, f2); - NOT_IMPLEMENTED(); + + v1->v[0] = f1; + v1->v[1] = f2; } // IDA: void __cdecl BrVector2Negate(br_vector2 *v1, br_vector2 *v2) void BrVector2Negate(br_vector2* v1, br_vector2* v2) { LOG_TRACE("(%p, %p)", v1, v2); - NOT_IMPLEMENTED(); + + v1->v[0] = -v2->v[0]; + v1->v[1] = -v2->v[1]; } // IDA: void __cdecl BrVector2Add(br_vector2 *v1, br_vector2 *v2, br_vector2 *v3) void BrVector2Add(br_vector2* v1, br_vector2* v2, br_vector2* v3) { LOG_TRACE("(%p, %p, %p)", v1, v2, v3); - NOT_IMPLEMENTED(); + + v1->v[0] = v2->v[0] + v3->v[0]; + v1->v[1] = v2->v[1] + v3->v[1]; } // IDA: void __cdecl BrVector2Accumulate(br_vector2 *v1, br_vector2 *v2) void BrVector2Accumulate(br_vector2* v1, br_vector2* v2) { LOG_TRACE("(%p, %p)", v1, v2); - NOT_IMPLEMENTED(); + + v1->v[0] += v2->v[0]; + v1->v[1] += v2->v[1]; } // IDA: void __cdecl BrVector2Sub(br_vector2 *v1, br_vector2 *v2, br_vector2 *v3) void BrVector2Sub(br_vector2* v1, br_vector2* v2, br_vector2* v3) { LOG_TRACE("(%p, %p, %p)", v1, v2, v3); - NOT_IMPLEMENTED(); + + v1->v[0] = v2->v[0] - v3->v[0]; + v1->v[1] = v2->v[1] - v3->v[1]; } // IDA: void __cdecl BrVector2Scale(br_vector2 *v1, br_vector2 *v2, br_scalar s) void BrVector2Scale(br_vector2* v1, br_vector2* v2, br_scalar s) { LOG_TRACE("(%p, %p, %f)", v1, v2, s); - NOT_IMPLEMENTED(); + + v1->v[0] = v2->v[0] * s; + v1->v[1] = v2->v[1] * s; } // IDA: void __cdecl BrVector2InvScale(br_vector2 *v1, br_vector2 *v2, br_scalar s) void BrVector2InvScale(br_vector2* v1, br_vector2* v2, br_scalar s) { LOG_TRACE("(%p, %p, %f)", v1, v2, s); - NOT_IMPLEMENTED(); + + v1->v[0] = v2->v[0] / s; + v1->v[1] = v2->v[1] / s; } // IDA: br_scalar __cdecl BrVector2Dot(br_vector2 *v1, br_vector2 *v2) br_scalar BrVector2Dot(br_vector2* v1, br_vector2* v2) { LOG_TRACE("(%p, %p)", v1, v2); - NOT_IMPLEMENTED(); + + return BR_MAC2(v1->v[0], v2->v[0], v1->v[1], v2->v[1]); } // IDA: br_scalar __cdecl BrVector2Length(br_vector2 *v1) br_scalar BrVector2Length(br_vector2* v1) { LOG_TRACE("(%p)", v1); - NOT_IMPLEMENTED(); + + return sqrtf(BR_MAC2(v1->v[0], v1->v[0], v1->v[1], v1->v[1])); } // IDA: br_scalar __cdecl BrVector2LengthSquared(br_vector2 *v1) br_scalar BrVector2LengthSquared(br_vector2* v1) { LOG_TRACE("(%p)", v1); - NOT_IMPLEMENTED(); + + return BR_MAC2(v1->v[0], v1->v[0], v1->v[1], v1->v[1]); } // IDA: void __cdecl BrVector3Copy(br_vector3 *v1, br_vector3 *v2) void BrVector3Copy(br_vector3* v1, br_vector3* v2) { LOG_TRACE("(%p, %p)", v1, v2); - NOT_IMPLEMENTED(); + + v1->v[0] = v2->v[0]; + v1->v[1] = v2->v[1]; + v1->v[2] = v2->v[2]; } // IDA: void __cdecl BrVector3Set(br_vector3 *v1, br_scalar s1, br_scalar s2, br_scalar s3) void BrVector3Set(br_vector3* v1, br_scalar s1, br_scalar s2, br_scalar s3) { LOG_TRACE("(%p, %f, %f, %f)", v1, s1, s2, s3); - NOT_IMPLEMENTED(); + + v1->v[0] = s1; + v1->v[1] = s2; + v1->v[2] = s3; } // IDA: void __cdecl BrVector3SetInt(br_vector3 *v1, int i1, int i2, int i3) void BrVector3SetInt(br_vector3* v1, int i1, int i2, int i3) { LOG_TRACE("(%p, %d, %d, %d)", v1, i1, i2, i3); - NOT_IMPLEMENTED(); + + v1->v[0] = BR_SCALAR(i1); + v1->v[1] = BR_SCALAR(i2); + v1->v[2] = BR_SCALAR(i3); } // IDA: void __cdecl BrVector3SetFloat(br_vector3 *v1, float f1, float f2, float f3) void BrVector3SetFloat(br_vector3* v1, float f1, float f2, float f3) { LOG_TRACE8("(%p, %f, %f, %f)", v1, f1, f2, f3); - v1->v[0] = f1; - v1->v[1] = f2; - v1->v[2] = f3; + v1->v[0] = BR_SCALAR(f1); + v1->v[1] = BR_SCALAR(f2); + v1->v[2] = BR_SCALAR(f3); } // IDA: void __cdecl BrVector3Negate(br_vector3 *v1, br_vector3 *v2) void BrVector3Negate(br_vector3* v1, br_vector3* v2) { LOG_TRACE("(%p, %p)", v1, v2); - NOT_IMPLEMENTED(); + + v1->v[0] = -v2->v[0]; + v1->v[1] = -v2->v[1]; + v1->v[2] = -v2->v[2]; } // IDA: void __cdecl BrVector3Add(br_vector3 *v1, br_vector3 *v2, br_vector3 *v3) void BrVector3Add(br_vector3* v1, br_vector3* v2, br_vector3* v3) { LOG_TRACE("(%p, %p, %p)", v1, v2, v3); - NOT_IMPLEMENTED(); + + v1->v[0] = v2->v[0] + v3->v[0]; + v1->v[1] = v2->v[1] + v3->v[1]; + v1->v[2] = v2->v[2] + v3->v[2]; } // IDA: void __cdecl BrVector3Accumulate(br_vector3 *v1, br_vector3 *v2) @@ -131,6 +173,7 @@ void BrVector3Accumulate(br_vector3* v1, br_vector3* v2) { // IDA: void __cdecl BrVector3Sub(br_vector3 *v1, br_vector3 *v2, br_vector3 *v3) void BrVector3Sub(br_vector3* v1, br_vector3* v2, br_vector3* v3) { LOG_TRACE("(%p, %p, %p)", v1, v2, v3); + v1->v[0] = v2->v[0] - v3->v[0]; v1->v[1] = v2->v[1] - v3->v[1]; v1->v[2] = v2->v[2] - v3->v[2]; @@ -139,19 +182,26 @@ void BrVector3Sub(br_vector3* v1, br_vector3* v2, br_vector3* v3) { // IDA: void __cdecl BrVector3Scale(br_vector3 *v1, br_vector3 *v2, br_scalar s) void BrVector3Scale(br_vector3* v1, br_vector3* v2, br_scalar s) { LOG_TRACE("(%p, %p, %f)", v1, v2, s); - NOT_IMPLEMENTED(); + + v1->v[0] = v2->v[0] * s; + v1->v[1] = v2->v[1] * s; + v1->v[2] = v2->v[2] * s; } // IDA: void __cdecl BrVector3InvScale(br_vector3 *v1, br_vector3 *v2, br_scalar s) void BrVector3InvScale(br_vector3* v1, br_vector3* v2, br_scalar s) { LOG_TRACE("(%p, %p, %f)", v1, v2, s); - NOT_IMPLEMENTED(); + + v1->v[0] = v2->v[0] / s; + v1->v[1] = v2->v[1] / s; + v1->v[2] = v2->v[2] / s; } // IDA: br_scalar __cdecl BrVector3Dot(br_vector3 *v1, br_vector3 *v2) br_scalar BrVector3Dot(br_vector3* v1, br_vector3* v2) { LOG_TRACE("(%p, %p)", v1, v2); - NOT_IMPLEMENTED(); + + return BR_MAC3(v1->v[0], v2->v[0], v1->v[1], v2->v[1], v1->v[2], v2->v[2]); } // IDA: void __cdecl BrVector3Cross(br_vector3 *v1, br_vector3 *v2, br_vector3 *v3) @@ -166,13 +216,15 @@ void BrVector3Cross(br_vector3* v1, br_vector3* v2, br_vector3* v3) { // IDA: br_scalar __cdecl BrVector3Length(br_vector3 *v1) br_scalar BrVector3Length(br_vector3* v1) { LOG_TRACE("(%p)", v1); - NOT_IMPLEMENTED(); + + return sqrtf(BR_MAC3(v1->v[0], v1->v[0], v1->v[1], v1->v[1], v1->v[2], v1->v[2])); } // IDA: br_scalar __cdecl BrVector3LengthSquared(br_vector3 *v1) br_scalar BrVector3LengthSquared(br_vector3* v1) { LOG_TRACE("(%p)", v1); - NOT_IMPLEMENTED(); + + return BR_MAC3(v1->v[0], v1->v[0], v1->v[1], v1->v[1], v1->v[2], v1->v[2]); } // IDA: void __cdecl BrVector3Normalise(br_vector3 *v1, br_vector3 *v2) @@ -198,62 +250,106 @@ void BrVector3Normalise(br_vector3* v1, br_vector3* v2) { void BrVector3NormaliseLP(br_vector3* v1, br_vector3* v2) { br_scalar scale; LOG_TRACE("(%p, %p)", v1, v2); - NOT_IMPLEMENTED(); + + scale = 1.f / sqrtf(BR_MAC3(v2->v[0], v2->v[0], v2->v[1], v2->v[1], v2->v[2], v2->v[2])); + if (scale != 0.f) { + v1->v[0] = v2->v[0] * scale; + v1->v[1] = v2->v[1] * scale; + v1->v[2] = v2->v[2] * scale; + } } // IDA: br_scalar __cdecl BrVector4Dot(br_vector4 *v1, br_vector4 *v2) br_scalar BrVector4Dot(br_vector4* v1, br_vector4* v2) { LOG_TRACE("(%p, %p)", v1, v2); - NOT_IMPLEMENTED(); + + return BR_MAC4(v1->v[0], v2->v[0], v1->v[1], v2->v[1], v1->v[2], v2->v[2], v1->v[3], v2->v[3]); } // IDA: void __cdecl BrVector4Copy(br_vector4 *v1, br_vector4 *v2) void BrVector4Copy(br_vector4* v1, br_vector4* v2) { LOG_TRACE("(%p, %p)", v1, v2); - NOT_IMPLEMENTED(); + + v1->v[0] = v2->v[0]; + v1->v[1] = v2->v[1]; + v1->v[2] = v2->v[2]; + v1->v[3] = v2->v[3]; } // IDA: br_scalar __usercall BrFVector2Dot@(br_fvector2 *v1@, br_vector2 *v2@) br_scalar BrFVector2Dot(br_fvector2* v1, br_vector2* v2) { LOG_TRACE("(%p, %p)", v1, v2); - NOT_IMPLEMENTED(); + + return BR_MAC2(v1->v[0], v2->v[0], v1->v[1], v2->v[1]); } // IDA: void __usercall BrFVector3Copy(br_fvector3 *v1@, br_vector3 *v2@) void BrFVector3Copy(br_fvector3* v1, br_vector3* v2) { LOG_TRACE("(%p, %p)", v1, v2); - NOT_IMPLEMENTED(); + + v1->v[0] = v2->v[0]; + v1->v[1] = v2->v[1]; + v1->v[2] = v2->v[2]; } // IDA: void __usercall BrVector3ScaleF(br_vector3 *v1@, br_fvector3 *v2@, br_scalar s) void BrVector3ScaleF(br_vector3* v1, br_fvector3* v2, br_scalar s) { LOG_TRACE("(%p, %p, %f)", v1, v2, s); - NOT_IMPLEMENTED(); + + v1->v[0] = v2->v[0] * s; + v1->v[1] = v2->v[1] * s; + v1->v[2] = v2->v[2] * s; } // IDA: br_scalar __usercall BrFVector3Dot@(br_fvector3 *v1@, br_vector3 *v2@) br_scalar BrFVector3Dot(br_fvector3* v1, br_vector3* v2) { LOG_TRACE("(%p, %p)", v1, v2); - NOT_IMPLEMENTED(); + + return BR_MAC3(v1->v[0], v2->v[0], v1->v[1], v2->v[1], v1->v[2], v2->v[2]); } // IDA: void __usercall BrFVector3Normalise(br_fvector3 *v1@, br_vector3 *v2@) void BrFVector3Normalise(br_fvector3* v1, br_vector3* v2) { br_scalar scale; LOG_TRACE("(%p, %p)", v1, v2); - NOT_IMPLEMENTED(); + + scale = sqrtf(BR_MAC3(v2->v[0], v2->v[0], v2->v[1], v2->v[1], v2->v[2], v2->v[2])); + if (scale != 0.f) { + scale = 1.f / scale; + v1->v[0] = v2->v[0] * scale; + v1->v[1] = v2->v[1] * scale; + v1->v[2] = v2->v[2] * scale; + } else { + v1->v[0] = 1.f; + v1->v[1] = 0.f; + v1->v[2] = 0.f; + } } // IDA: void __usercall BrFVector3NormaliseLP(br_fvector3 *v1@, br_vector3 *v2@) void BrFVector3NormaliseLP(br_fvector3* v1, br_vector3* v2) { br_scalar scale; LOG_TRACE("(%p, %p)", v1, v2); - NOT_IMPLEMENTED(); + + scale = 1.f / sqrtf(BR_MAC3(v2->v[0], v2->v[0], v2->v[1], v2->v[1], v2->v[2], v2->v[2])); + v1->v[0] = v2->v[0] * scale; + v1->v[1] = v2->v[1] * scale; + v1->v[2] = v2->v[2] * scale; } // IDA: void __cdecl BrVector2Normalise(br_vector2 *v1, br_vector2 *v2) void BrVector2Normalise(br_vector2* v1, br_vector2* v2) { br_scalar scale; LOG_TRACE("(%p, %p)", v1, v2); - NOT_IMPLEMENTED(); + + scale = sqrtf(BR_MAC2(v2->v[0], v2->v[0], v2->v[1], v2->v[1])); + if (scale > 2.3841858e-7f) { + scale = 1.f / scale; + v1->v[0] = v2->v[0] * scale; + v1->v[1] = v2->v[1] * scale; + + } else { + v1->v[0] = 1.f; + v1->v[1] = 0.f; + } } diff --git a/test/BRSRC13/test_vector.c b/test/BRSRC13/test_vector.c new file mode 100644 index 00000000..64102a3a --- /dev/null +++ b/test/BRSRC13/test_vector.c @@ -0,0 +1,637 @@ +#include "CORE/MATH/vector.h" +#include "tests.h" +#include +#include + +static void test_vector_BrVector2Copy() { + br_vector2 vin; + br_vector2 vout; + + vin.v[0] = 2.25f; + vin.v[1] = -4.25f; + memset(&vout, 0, sizeof(br_vector2)); + + TEST_ASSERT(vin.v[0] != vout.v[0]); + TEST_ASSERT(vin.v[1] != vout.v[1]); + + BrVector2Copy(&vout, &vin); + + TEST_ASSERT_EQUAL_FLOAT(vin.v[0], vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(vin.v[1], vout.v[1]); +} + +static void test_vector_BrVector2Set() { + br_vector2 vout; + + memset(&vout, 0, sizeof(br_vector2)); + + BrVector2Set(&vout, BR_SCALAR(4.75f), BR_SCALAR(-2.75)); + + TEST_ASSERT_EQUAL_FLOAT(4.75f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-2.75f, vout.v[1]); +} + +static void test_vector_BrVector2SetInt() { + br_vector2 vout; + + memset(&vout, 0, sizeof(br_vector2)); + + BrVector2SetInt(&vout, 9, -3); + + TEST_ASSERT_EQUAL_FLOAT(9.f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-3.f, vout.v[1]); +} + +static void test_vector_BrVector2SetFloat() { + br_vector2 vout; + + memset(&vout, 0, sizeof(br_vector2)); + + BrVector2SetFloat(&vout, BR_SCALAR(4.75f), BR_SCALAR(-2.75)); + + TEST_ASSERT_EQUAL_FLOAT(4.75f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-2.75f, vout.v[1]); +} + +static void test_vector_BrVector2Negate() { + br_vector2 vin; + br_vector2 vout; + + vin.v[0] = 4.75f; + vin.v[1] = -2.75f; + memset(&vout, 0, sizeof(br_vector2)); + + BrVector2Negate(&vout, &vin); + + TEST_ASSERT_EQUAL_FLOAT(-4.75f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(2.75f, vout.v[1]); +} + +static void test_vector_BrVector2Add() { + br_vector2 vin1; + br_vector2 vin2; + br_vector2 vout; + + vin1.v[0] = 4.75f; + vin1.v[1] = -2.75f; + vin2.v[0] = 1.5f; + vin2.v[1] = 0.5f; + memset(&vout, 0, sizeof(br_vector2)); + + BrVector2Add(&vout, &vin1, &vin2); + + TEST_ASSERT_EQUAL_FLOAT(6.25f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-2.25f, vout.v[1]); +} + +static void test_vector_BrVector2Accumulate() { + br_vector2 vin; + br_vector2 vout; + + vin.v[0] = 4.75f; + vin.v[1] = -2.75f; + vout.v[0] = 1.5f; + vout.v[1] = 0.5f; + + BrVector2Accumulate(&vout, &vin); + + TEST_ASSERT_EQUAL_FLOAT(6.25f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-2.25f, vout.v[1]); +} + +static void test_vector_BrVector2Sub() { + br_vector2 vin1; + br_vector2 vin2; + br_vector2 vout; + + vin1.v[0] = 4.75f; + vin1.v[1] = -2.75f; + vin2.v[0] = 1.5f; + vin2.v[1] = 0.5f; + memset(&vout, 0, sizeof(br_vector2)); + + BrVector2Sub(&vout, &vin1, &vin2); + + TEST_ASSERT_EQUAL_FLOAT(3.25f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-3.25f, vout.v[1]); +} + +static void test_vector_BrVector2Scale() { + br_vector2 vin; + br_vector2 vout; + + vin.v[0] = 4.75f; + vin.v[1] = -2.75f; + memset(&vout, 0, sizeof(br_vector2)); + + BrVector2Scale(&vout, &vin, BR_SCALAR(1.5f)); + + TEST_ASSERT_EQUAL_FLOAT(7.125f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-4.125f, vout.v[1]); +} + +static void test_vector_BrVector2InvScale() { + br_vector2 vin; + br_vector2 vout; + + vin.v[0] = 4.75f; + vin.v[1] = -2.75f; + memset(&vout, 0, sizeof(br_vector2)); + + BrVector2InvScale(&vout, &vin, BR_SCALAR(2.f)); + + TEST_ASSERT_EQUAL_FLOAT(2.375f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-1.375f, vout.v[1]); +} + +static void test_vector_BrVector2Dot() { + br_vector2 vin1; + br_vector2 vin2; + br_scalar out; + + vin1.v[0] = 4.75f; + vin1.v[1] = -2.75f; + vin2.v[0] = 1.5f; + vin2.v[1] = -0.75f; + + out = BrVector2Dot(&vin1, &vin2); + + TEST_ASSERT_EQUAL_FLOAT(9.1875f, out); +} + +static void test_vector_BrVector2Length() { + br_vector2 vin; + br_scalar out; + + vin.v[0] = 1.5f; + vin.v[1] = 2.0f; + + out = BrVector2Length(&vin); + + TEST_ASSERT_EQUAL_FLOAT(2.5f, out); +} + +static void test_vector_BrVector2LengthSquared() { + br_vector2 vin; + br_scalar out; + + vin.v[0] = 1.5f; + vin.v[1] = 2.0f; + + out = BrVector2LengthSquared(&vin); + + TEST_ASSERT_EQUAL_FLOAT(6.25f, out); +} + +static void test_vector_BrVector3Copy() { + br_vector3 vin; + br_vector3 vout; + + vin.v[0] = 2.25f; + vin.v[1] = -4.25f; + vin.v[2] = 9.5f; + memset(&vout, 0, sizeof(br_vector3)); + + TEST_ASSERT(vin.v[0] != vout.v[0]); + TEST_ASSERT(vin.v[1] != vout.v[1]); + TEST_ASSERT(vin.v[2] != vout.v[2]); + + BrVector3Copy(&vout, &vin); + + TEST_ASSERT_EQUAL_FLOAT(vin.v[0], vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(vin.v[1], vout.v[1]); + TEST_ASSERT_EQUAL_FLOAT(vin.v[2], vout.v[2]); +} + +static void test_vector_BrVector3Set() { + br_vector3 vout; + + memset(&vout, 0, sizeof(br_vector3)); + + BrVector3Set(&vout, BR_SCALAR(4.75f), BR_SCALAR(-2.75), BR_SCALAR(1.5f)); + + TEST_ASSERT_EQUAL_FLOAT(4.75f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-2.75f, vout.v[1]); + TEST_ASSERT_EQUAL_FLOAT(1.5f, vout.v[2]); +} + +static void test_vector_BrVector3SetInt() { + br_vector3 vout; + + memset(&vout, 0, sizeof(br_vector3)); + + BrVector3SetInt(&vout, 9, -3, 5); + + TEST_ASSERT_EQUAL_FLOAT(9.f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-3.f, vout.v[1]); + TEST_ASSERT_EQUAL_FLOAT(5.f, vout.v[2]); +} + +static void test_vector_BrVector3SetFloat() { + br_vector3 vout; + + memset(&vout, 0, sizeof(br_vector3)); + + BrVector3SetFloat(&vout, 4.75f, -2.75, 1.5f); + + TEST_ASSERT_EQUAL_FLOAT(4.75f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-2.75f, vout.v[1]); + TEST_ASSERT_EQUAL_FLOAT(1.5f, vout.v[2]); +} + +static void test_vector_BrVector3Negate() { + br_vector3 vin; + br_vector3 vout; + + vin.v[0] = 4.75f; + vin.v[1] = -2.75f; + vin.v[2] = 7.5f; + memset(&vout, 0, sizeof(br_vector3)); + + BrVector3Negate(&vout, &vin); + + TEST_ASSERT_EQUAL_FLOAT(-4.75f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(2.75f, vout.v[1]); + TEST_ASSERT_EQUAL_FLOAT(-7.5f, vout.v[2]); +} + +static void test_vector_BrVector3Add() { + br_vector3 vin1; + br_vector3 vin2; + br_vector3 vout; + + vin1.v[0] = 4.75f; + vin1.v[1] = -2.75f; + vin1.v[2] = 1.675f; + vin2.v[0] = 1.5f; + vin2.v[1] = 0.5f; + vin2.v[2] = -4.5f; + memset(&vout, 0, sizeof(br_vector3)); + + BrVector3Add(&vout, &vin1, &vin2); + + TEST_ASSERT_EQUAL_FLOAT(6.25f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-2.25f, vout.v[1]); + TEST_ASSERT_EQUAL_FLOAT(-2.825f, vout.v[2]); +} + +static void test_vector_BrVector3Accumulate() { + br_vector3 vin; + br_vector3 vout; + + vin.v[0] = 4.75f; + vin.v[1] = -2.75f; + vin.v[2] = 1.5f; + vout.v[0] = 1.5f; + vout.v[1] = 0.5f; + vout.v[2] = -4.5f; + + BrVector3Accumulate(&vout, &vin); + + TEST_ASSERT_EQUAL_FLOAT(6.25f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-2.25f, vout.v[1]); + TEST_ASSERT_EQUAL_FLOAT(-3.f, vout.v[2]); +} + +static void test_vector_BrVector3Sub() { + br_vector3 vin1; + br_vector3 vin2; + br_vector3 vout; + + vin1.v[0] = 4.75f; + vin1.v[1] = -2.75f; + vin1.v[2] = 1.75f; + vin2.v[0] = 1.5f; + vin2.v[1] = 0.5f; + vin2.v[2] = -0.5f; + memset(&vout, 0, sizeof(br_vector3)); + + BrVector3Sub(&vout, &vin1, &vin2); + + TEST_ASSERT_EQUAL_FLOAT(3.25f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-3.25f, vout.v[1]); + TEST_ASSERT_EQUAL_FLOAT(2.25f, vout.v[2]); +} + +static void test_vector_BrVector3Scale() { + br_vector3 vin; + br_vector3 vout; + + vin.v[0] = 4.75f; + vin.v[1] = -2.75f; + vin.v[2] = 1.75f; + memset(&vout, 0, sizeof(br_vector3)); + + BrVector3Scale(&vout, &vin, BR_SCALAR(1.5f)); + + TEST_ASSERT_EQUAL_FLOAT(7.125f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-4.125f, vout.v[1]); + TEST_ASSERT_EQUAL_FLOAT(2.625f, vout.v[2]); +} + +static void test_vector_BrVector3InvScale() { + br_vector3 vin; + br_vector3 vout; + + vin.v[0] = 4.75f; + vin.v[1] = -2.75f; + vin.v[2] = -5.25f; + memset(&vout, 0, sizeof(br_vector3)); + + BrVector3InvScale(&vout, &vin, BR_SCALAR(2.f)); + + TEST_ASSERT_EQUAL_FLOAT(2.375f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-1.375f, vout.v[1]); + TEST_ASSERT_EQUAL_FLOAT(-2.625f, vout.v[2]); +} + +static void test_vector_BrVector3Dot() { + br_vector3 vin1; + br_vector3 vin2; + br_scalar out; + + vin1.v[0] = 4.75f; + vin1.v[1] = -2.75f; + vin1.v[2] = -9.5f; + vin2.v[0] = 1.5f; + vin2.v[1] = -0.75f; + vin2.v[2] = 1.5f; + + out = BrVector3Dot(&vin1, &vin2); + + TEST_ASSERT_EQUAL_FLOAT(-5.0625f, out); +} + +static void test_vector_BrVector3Cross() { + br_vector3 vin1; + br_vector3 vin2; + br_vector3 vout; + + vin1.v[0] = 1.f; + vin1.v[1] = 1.f; + vin1.v[2] = 0.f; + vin2.v[0] = -1.f; + vin2.v[1] = 1.f; + vin2.v[2] = 0.f; + memset(&vout, 0, sizeof(br_vector3)); + + BrVector3Cross(&vout, &vin1, &vin2); + + TEST_ASSERT_EQUAL_FLOAT(0.f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(0.f, vout.v[1]); + TEST_ASSERT_EQUAL_FLOAT(2.f, vout.v[2]); +} + +static void test_vector_BrVector3Length() { + br_vector3 vin; + br_scalar out; + + vin.v[0] = 2.f; + vin.v[1] = 6.5f; + vin.v[2] = 8.0f; + + out = BrVector3Length(&vin); + + TEST_ASSERT_EQUAL_FLOAT(10.5, out); +} + +static void test_vector_BrVector3LengthSquared() { + br_vector3 vin; + br_scalar out; + + vin.v[0] = 1.f; + vin.v[1] = 2.f; + vin.v[2] = 3.f; + + out = BrVector3LengthSquared(&vin); + + TEST_ASSERT_EQUAL_FLOAT(14.f, out); +} + +static void test_vector_BrVector3Normalise() { + br_vector3 vin; + br_vector3 vout; + + vin.v[0] = 3.f; + vin.v[1] = 4.f; + vin.v[2] = 5.f; + memset(&vout, 0, sizeof(br_vector3)); + + BrVector3Normalise(&vout, &vin); + + TEST_ASSERT_FLOAT_WITHIN(1e-5, 0.4242640687119285f, vout.v[0]); + TEST_ASSERT_FLOAT_WITHIN(1e-5, 0.565685424949238f, vout.v[1]); + TEST_ASSERT_FLOAT_WITHIN(1e-5, 0.7071067811865475f, vout.v[2]); +} + +static void test_vector_BrVector3NormaliseLP() { + br_vector3 vin; + br_vector3 vout; + + vin.v[0] = 0.999; + vin.v[1] = 0.001f; + vin.v[2] = 0.001f; + memset(&vout, 0, sizeof(br_vector3)); + + BrVector3NormaliseLP(&vout, &vin); + + TEST_ASSERT_FLOAT_WITHIN(1e-5, 1.f, BrVector3Length(&vout)); +} + +static void test_vector_BrVector4Dot() { + br_vector4 vin1; + br_vector4 vin2; + br_scalar out; + + vin1.v[0] = 4.75f; + vin1.v[1] = -2.75f; + vin1.v[2] = -9.5f; + vin1.v[3] = 1.5f; + vin2.v[0] = 1.5f; + vin2.v[1] = -0.75f; + vin2.v[2] = 1.5f; + vin2.v[3] = 7.75f; + + out = BrVector4Dot(&vin1, &vin2); + + TEST_ASSERT_EQUAL_FLOAT(6.5625f, out); +} + +static void test_vector_BrVector4Copy() { + br_vector4 vin; + br_vector4 vout; + + vin.v[0] = 2.25f; + vin.v[1] = -4.25f; + vin.v[2] = 9.5f; + vin.v[3] = 4.5; + memset(&vout, 0, sizeof(br_vector4)); + + TEST_ASSERT(vin.v[0] != vout.v[0]); + TEST_ASSERT(vin.v[1] != vout.v[1]); + TEST_ASSERT(vin.v[2] != vout.v[2]); + TEST_ASSERT(vin.v[3] != vout.v[3]); + + BrVector4Copy(&vout, &vin); + + TEST_ASSERT_EQUAL_FLOAT(vin.v[0], vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(vin.v[1], vout.v[1]); + TEST_ASSERT_EQUAL_FLOAT(vin.v[2], vout.v[2]); + TEST_ASSERT_EQUAL_FLOAT(vin.v[3], vout.v[3]); +} + +static void test_vector_BrFVector2Dot() { + br_fvector2 vin1; + br_vector2 vin2; + br_scalar out; + + vin1.v[0] = 4.75f; + vin1.v[1] = -2.75f; + vin2.v[0] = 1.5f; + vin2.v[1] = -0.75f; + + out = BrFVector2Dot(&vin1, &vin2); + + TEST_ASSERT_EQUAL_FLOAT(9.1875f, out); +} + +static void test_vector_BrFVector3Copy() { + br_vector3 vin; + br_fvector3 vout; + + vin.v[0] = 2.25f; + vin.v[1] = -4.25f; + vin.v[2] = 9.5f; + memset(&vout, 0, sizeof(br_fvector3)); + + TEST_ASSERT(vin.v[0] != vout.v[0]); + TEST_ASSERT(vin.v[1] != vout.v[1]); + TEST_ASSERT(vin.v[2] != vout.v[2]); + + BrFVector3Copy(&vout, &vin); + + TEST_ASSERT_EQUAL_FLOAT(vin.v[0], vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(vin.v[1], vout.v[1]); + TEST_ASSERT_EQUAL_FLOAT(vin.v[2], vout.v[2]); +} + +static void test_vector_BrVector3ScaleF() { + br_fvector3 vin; + br_vector3 vout; + + vin.v[0] = 4.75f; + vin.v[1] = -2.75f; + vin.v[2] = 1.75f; + memset(&vout, 0, sizeof(br_vector3)); + + BrVector3ScaleF(&vout, &vin, BR_SCALAR(1.5f)); + + TEST_ASSERT_EQUAL_FLOAT(7.125f, vout.v[0]); + TEST_ASSERT_EQUAL_FLOAT(-4.125f, vout.v[1]); + TEST_ASSERT_EQUAL_FLOAT(2.625f, vout.v[2]); +} + +static void test_vector_BrFVector3Dot() { + br_fvector3 vin1; + br_vector3 vin2; + br_scalar out; + + vin1.v[0] = 4.75f; + vin1.v[1] = -2.75f; + vin1.v[2] = -9.5f; + vin2.v[0] = 1.5f; + vin2.v[1] = -0.75f; + vin2.v[2] = 1.5f; + + out = BrFVector3Dot(&vin1, &vin2); + + TEST_ASSERT_EQUAL_FLOAT(-5.0625f, out); +} + +static void test_vector_BrFVector3Normalise() { + br_vector3 vin; + br_fvector3 vout; + + vin.v[0] = 3.f; + vin.v[1] = 4.f; + vin.v[2] = 5.f; + memset(&vout, 0, sizeof(br_fvector3)); + + BrFVector3Normalise(&vout, &vin); + + TEST_ASSERT_FLOAT_WITHIN(1e-5, 0.4242640687119285f, vout.v[0]); + TEST_ASSERT_FLOAT_WITHIN(1e-5, 0.565685424949238f, vout.v[1]); + TEST_ASSERT_FLOAT_WITHIN(1e-5, 0.7071067811865475f, vout.v[2]); +} + +static void test_vector_BrFVector3NormaliseLP() { + br_vector3 vin; + br_fvector3 vout; + br_scalar length; + + vin.v[0] = 0.999; + vin.v[1] = 0.001f; + vin.v[2] = 0.001f; + memset(&vout, 0, sizeof(br_fvector3)); + + BrFVector3NormaliseLP(&vout, &vin); + length = sqrtf(vout.v[0] * vout.v[0] + vout.v[1] * vout.v[1] + vout.v[2] * vout.v[2]); + + TEST_ASSERT_FLOAT_WITHIN(1e-5, 1.f, length); +} + +static void test_vector_BrVector2Normalise() { + br_vector2 vin; + br_vector2 vout; + + vin.v[0] = 3.f; + vin.v[1] = 4.f; + memset(&vout, 0, sizeof(br_vector2)); + + BrVector2Normalise(&vout, &vin); + + TEST_ASSERT_FLOAT_WITHIN(1e-5, 0.6f, vout.v[0]); + TEST_ASSERT_FLOAT_WITHIN(1e-5, 0.8f, vout.v[1]); +} + +void test_vector_suite() { + UnitySetTestFile(__FILE__); + RUN_TEST(test_vector_BrVector2Copy); + RUN_TEST(test_vector_BrVector2Set); + RUN_TEST(test_vector_BrVector2SetInt); + RUN_TEST(test_vector_BrVector2SetFloat); + RUN_TEST(test_vector_BrVector2Negate); + RUN_TEST(test_vector_BrVector2Add); + RUN_TEST(test_vector_BrVector2Accumulate); + RUN_TEST(test_vector_BrVector2Sub); + RUN_TEST(test_vector_BrVector2Scale); + RUN_TEST(test_vector_BrVector2InvScale); + RUN_TEST(test_vector_BrVector2Dot); + RUN_TEST(test_vector_BrVector2Length); + RUN_TEST(test_vector_BrVector2LengthSquared); + RUN_TEST(test_vector_BrVector3Copy); + RUN_TEST(test_vector_BrVector3Set); + RUN_TEST(test_vector_BrVector3SetInt); + RUN_TEST(test_vector_BrVector3SetFloat); + RUN_TEST(test_vector_BrVector3Negate); + RUN_TEST(test_vector_BrVector3Add); + RUN_TEST(test_vector_BrVector3Accumulate); + RUN_TEST(test_vector_BrVector3Sub); + RUN_TEST(test_vector_BrVector3Scale); + RUN_TEST(test_vector_BrVector3InvScale); + RUN_TEST(test_vector_BrVector3Dot); + RUN_TEST(test_vector_BrVector3Cross); + RUN_TEST(test_vector_BrVector3Length); + RUN_TEST(test_vector_BrVector3LengthSquared); + RUN_TEST(test_vector_BrVector3Normalise); + RUN_TEST(test_vector_BrVector3NormaliseLP); + RUN_TEST(test_vector_BrVector4Dot); + RUN_TEST(test_vector_BrVector4Copy); + RUN_TEST(test_vector_BrFVector2Dot); + RUN_TEST(test_vector_BrFVector3Copy); + RUN_TEST(test_vector_BrVector3ScaleF); + RUN_TEST(test_vector_BrFVector3Dot); + RUN_TEST(test_vector_BrFVector3Normalise); + RUN_TEST(test_vector_BrFVector3NormaliseLP); + RUN_TEST(test_vector_BrVector2Normalise); +} diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 704c133e..8ec513ef 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -48,6 +48,7 @@ target_sources(dethrace_test PRIVATE BRSRC13/test_resource.c BRSRC13/test_resreg.c BRSRC13/test_scratch.c + BRSRC13/test_vector.c BRSRC13/test_v1dbfile.c DETHRACE/test_controls.c DETHRACE/test_dossys.c diff --git a/test/main.c b/test/main.c index ec77d2b8..fef1093d 100644 --- a/test/main.c +++ b/test/main.c @@ -55,6 +55,7 @@ extern void test_matrix4_suite(); extern void test_quat_suite(); extern void test_graphics_suite(); extern void test_regsupt_suite(); +extern void test_vector_suite(); extern void test_powerup_suite(); extern void test_flicplay_suite(); @@ -244,6 +245,7 @@ int main(int argc, char** argv) { test_matrix23_suite(); test_matrix34_suite(); test_matrix4_suite(); + test_vector_suite(); test_quat_suite(); test_fixed_suite(); From 15b60cfa1d16bae29e3a1a9943684510be5c3495 Mon Sep 17 00:00:00 2001 From: Anonymous Maarten Date: Thu, 27 Jan 2022 18:53:47 +0100 Subject: [PATCH 08/14] Fix BRender duplicate material struct name + bug in datafile --- src/BRSRC13/CMakeLists.txt | 5 +++++ src/BRSRC13/CORE/FW/datafile.c | 30 ++++++++++++++++++++++-------- test/BRSRC13/test_datafile.c | 2 +- 3 files changed, 28 insertions(+), 9 deletions(-) diff --git a/src/BRSRC13/CMakeLists.txt b/src/BRSRC13/CMakeLists.txt index 9bb81e8c..1766ad76 100644 --- a/src/BRSRC13/CMakeLists.txt +++ b/src/BRSRC13/CMakeLists.txt @@ -1,5 +1,7 @@ add_library(brender STATIC) +option(BRENDER_FIX_BUGS "Fix BRender bugs" ON) + target_include_directories(brender PRIVATE . @@ -31,6 +33,9 @@ else() /wd4996 ) endif() +if(BRENDER_FIX_BUGS) + target_compile_definitions(brender PRIVATE BRENDER_FIX_BUGS) +endif() target_sources(brender PRIVATE include/brender/brender.h diff --git a/src/BRSRC13/CORE/FW/datafile.c b/src/BRSRC13/CORE/FW/datafile.c index ad868ecf..35b12f7e 100644 --- a/src/BRSRC13/CORE/FW/datafile.c +++ b/src/BRSRC13/CORE/FW/datafile.c @@ -145,11 +145,19 @@ struct { int count; } DatafileStack[1024]; +#ifdef BRENDER_FIX_BUGS +char* ChunkNames[62] = { +#else char* ChunkNames[61] = { +#endif "END", "IMAGE_PLANE", "RLE_IMAGE_PLANE", +#ifdef BRENDER_FIX_BUGS + "PIXELMAP_OLD", +#else "PIXELMAP", +#endif "MATERIAL_OLD", "ADD_MATERIAL", "OLD_ACTOR", @@ -206,7 +214,12 @@ char* ChunkNames[61] = { "SATURN_FACES", "SATURN_MODEL", "INDEX_FOG_REF", +#ifdef BRENDER_FIX_BUGS + "MATERIAL", + "PIXELMAP", +#else "MATERIAL_OLD", +#endif }; int DatafileStackTop; @@ -266,7 +279,7 @@ int DfTopType() { // IDA: int __usercall TextReadLine@(br_datafile *df@, char **ident@, char **data@) int TextReadLine(br_datafile* df, char** ident, char** data) { char* cp; - LOG_TRACE("(%p, %p, %p)", df, ident, data); + LOG_TRACE9("(%p, %p, %p)", df, ident, data); while (1) { cp = BrScratchString(); @@ -690,7 +703,7 @@ int DfStructSizeBinary(br_datafile* df, br_file_struct* str, void* base) { // IDA: int __usercall EnumFromString@(br_file_enum *e@, char *str@) int EnumFromString(br_file_enum* e, char* str) { unsigned int m; - LOG_TRACE("(%p, \"%s\")", e, str); + LOG_TRACE9("(%p, \"%s\")", e, str); if (e == NULL) { BrFailure("Unknown enum string: %s", str); @@ -706,7 +719,7 @@ int EnumFromString(br_file_enum* e, char* str) { // IDA: char* __usercall EnumToString@(br_file_enum *e@, int num@) char* EnumToString(br_file_enum* e, int num) { unsigned int m; - LOG_TRACE("(%p, %d)", e, num); + LOG_TRACE9("(%p, %d)", e, num); if (e == NULL) { goto fail; @@ -860,7 +873,7 @@ br_uint_32 StructWriteTextSub(br_datafile* df, br_file_struct* str, void* base, br_uint_32 DfStructReadText(br_datafile* df, br_file_struct* str, void* base) { char* id; char* data; - LOG_TRACE("(%p, %p, %p)", df, str, base); + LOG_TRACE9("(%p, %p, %p)", df, str, base); TextReadLine(df, &id, &data); if (BrStrCmp(id, "struct") != 0) { @@ -886,7 +899,7 @@ br_uint_32 StructReadTextSub(br_datafile* df, br_file_struct* str, void* base) { char* id; char* data; char* ep; - LOG_TRACE("(%p, %p, %p)", df, str, base); + LOG_TRACE9("(%p, %p, %p)", df, str, base); for (m = 0; m < str->nmembers; m++) { sm = &str->members[m]; @@ -1096,7 +1109,7 @@ int DfChunkReadText(br_datafile* df, br_uint_32* plength) { int i; char* id; char* data; - LOG_TRACE("(%p, %p)", df, plength); + LOG_TRACE9("(%p, %p)", df, plength); if (TextReadLine(df, &id, &data) == 0) { return -1; @@ -1252,7 +1265,7 @@ int DfBlockWriteText(br_datafile* df, void* base, int block_size, int block_stri BrFilePutChar('\n', df->h); } } - if ((i & 0x1f) != 0x1f) { + if ((i & 0x1f) != 0x0) { BrFilePutChar('\n', df->h); } if (block != base) { @@ -1269,7 +1282,7 @@ void* DfBlockReadText(br_datafile* df, void* base, int* count, int size, int mty int s; int a; char b[3]; - LOG_TRACE("(%p, %p, %p, %d, %d)", df, base, count, size, mtype); + LOG_TRACE9("(%p, %p, %p, %d, %d)", df, base, count, size, mtype); TextReadLine(df, &id, &data); if (BrStrCmp(id, "block") != 0) { @@ -1463,6 +1476,7 @@ int DfSkipText(br_datafile* df, br_uint_32 length) { while ((BrFileEof(df->h) == 0) && (length != 0)) { TextReadLine(df, &data, &id); + length--; } return 0; } diff --git a/test/BRSRC13/test_datafile.c b/test/BRSRC13/test_datafile.c index 10388e73..a63612cc 100644 --- a/test/BRSRC13/test_datafile.c +++ b/test/BRSRC13/test_datafile.c @@ -2653,7 +2653,7 @@ static const br_uint_32 chunk_length_ref = 0x100; static const uint8_t binary_chunk_data[] = { BINARY_MAGICS, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x01, 0x00, }; static const char *text_chunk_data = TEXT_MAGICS HOST_NL - "*PIXELMAP 256" HOST_NL; + "*PIXELMAP_OLD 256" HOST_NL; static void test_datafile_binary_chunk() { br_datafile* df_w; br_datafile* df_r; From 07e24be1e019ce475248e0e000e511acae387766 Mon Sep 17 00:00:00 2001 From: Anonymous Maarten Date: Sat, 22 Jan 2022 01:59:37 +0100 Subject: [PATCH 09/14] Add missing brstddiag functions --- src/BRSRC13/CORE/STD/brstddiag.c | 35 ++++++++++++++++++++++++++++---- 1 file changed, 31 insertions(+), 4 deletions(-) diff --git a/src/BRSRC13/CORE/STD/brstddiag.c b/src/BRSRC13/CORE/STD/brstddiag.c index f63c6a14..e6a8ecbe 100644 --- a/src/BRSRC13/CORE/STD/brstddiag.c +++ b/src/BRSRC13/CORE/STD/brstddiag.c @@ -1,13 +1,40 @@ #include "brstddiag.h" +#include "CORE/FW/brbegin.h" + #include "harness/trace.h" -br_diaghandler BrStdioDiagHandler; -br_diaghandler* _BrDefaultDiagHandler = NULL; +#include + +br_diaghandler BrStdioDiagHandler = { + "Stdio DiagHandler", + BrStdioWarning, + BrStdioFailure, +}; + +br_diaghandler* _BrDefaultDiagHandler = &BrStdioDiagHandler; void BrStdioWarning(char* message) { - NOT_IMPLEMENTED(); + fflush(stdout); + fputs(message, stderr); + fputc('\n', stderr); + fflush(stderr); } void BrStdioFailure(char* message) { - NOT_IMPLEMENTED(); + LOG_TRACE("(%s)", message); + +#if 0 + // FIXME: 'real' implementation ends BRender + BrEnd(); +#endif + fflush(stdout); + fputs(message, stderr); + fputc('\n', stderr); + fflush(stderr); +#if 0 + // FIXME: 'real' implementation unconditionally exits. + exit(10); +#else + abort(); +#endif } From de1166db7264017d8924b2f7937cc41bf7d7cf5a Mon Sep 17 00:00:00 2001 From: Anonymous Maarten Date: Thu, 27 Jan 2022 22:55:54 +0100 Subject: [PATCH 10/14] BrStdioOpenRead: use brender types --- src/BRSRC13/CORE/STD/brstdfile.c | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/src/BRSRC13/CORE/STD/brstdfile.c b/src/BRSRC13/CORE/STD/brstdfile.c index 5604a07c..5c9d23a9 100644 --- a/src/BRSRC13/CORE/STD/brstdfile.c +++ b/src/BRSRC13/CORE/STD/brstdfile.c @@ -34,32 +34,33 @@ void* BrStdioOpenRead(char* name, br_size_t n_magics, br_mode_test_cbfn* identif char try_name[512]; char* cp; br_uint_8 magics[16]; - int open_mode = 0; + int open_mode; LOG_TRACE("(\"%s\", %d, %p, %p)", name, n_magics, identify, mode_result); + open_mode = BR_FS_MODE_BINARY; fh = fopen(name, "rb"); - if (!fh) { + if (fh == NULL) { // skip logic around getting BRENDER_PATH from ini files etc return NULL; } - if (n_magics) { + if (n_magics != 0) { if (fread(magics, 1u, n_magics, fh) != n_magics) { fclose(fh); return 0; } - if (identify) { + if (identify != NULL) { open_mode = identify(magics, n_magics); } - if (mode_result) { + if (mode_result != NULL) { *mode_result = open_mode; } } fclose(fh); - if (open_mode == 0) { + if (open_mode == BR_FS_MODE_BINARY) { fh = fopen(name, "rb"); - } else if (open_mode == 1) { + } else if (open_mode == BR_FS_MODE_TEXT) { fh = fopen(name, "rt"); } else { BrFailure("BrStdFileOpenRead: invalid open_mode %d", open_mode); @@ -82,6 +83,7 @@ void* BrStdioOpenWrite(char* name, int mode) { void BrStdioClose(void* f) { LOG_TRACE("(%p)", f); + fclose(f); } From e939c62865feb3e88321c5418cd37bba5126c9e8 Mon Sep 17 00:00:00 2001 From: Anonymous Maarten Date: Tue, 25 Jan 2022 17:23:35 +0100 Subject: [PATCH 11/14] Implement all functions in v1dbfile + genfile (=BRender resource loading) --- src/BRSRC13/CMakeLists.txt | 2 + src/BRSRC13/CORE/FW/genfile.c | 36 +- src/BRSRC13/CORE/FW/genfile.h | 11 + src/BRSRC13/CORE/PIXELMAP/pmfile.c | 184 ++- src/BRSRC13/CORE/V1DB/chunkids.h | 52 + src/BRSRC13/CORE/V1DB/stackids.h | 17 + src/BRSRC13/CORE/V1DB/v1dbfile.c | 1041 ++++++++++---- src/BRSRC13/CORE/V1DB/v1dbfile.h | 1 + test/BRSRC13/test_pmfile.c | 542 +++++++- test/BRSRC13/test_v1dbfile.c | 2081 ++++++++++++++++++++++++++++ 10 files changed, 3668 insertions(+), 299 deletions(-) create mode 100644 src/BRSRC13/CORE/V1DB/chunkids.h create mode 100644 src/BRSRC13/CORE/V1DB/stackids.h diff --git a/src/BRSRC13/CMakeLists.txt b/src/BRSRC13/CMakeLists.txt index 1766ad76..9ab1423e 100644 --- a/src/BRSRC13/CMakeLists.txt +++ b/src/BRSRC13/CMakeLists.txt @@ -170,6 +170,7 @@ target_sources(brender PRIVATE CORE/STD/logwrite.h CORE/V1DB/actsupt.c CORE/V1DB/actsupt.h + CORE/V1DB/chunkids.h CORE/V1DB/custsupt.c CORE/V1DB/custsupt.h CORE/V1DB/dbsetup.c @@ -202,6 +203,7 @@ target_sources(brender PRIVATE CORE/V1DB/regsupt.h CORE/V1DB/render.c CORE/V1DB/render.h + CORE/V1DB/stackids.h CORE/V1DB/v1dbfile.c CORE/V1DB/v1dbfile.h ) diff --git a/src/BRSRC13/CORE/FW/genfile.c b/src/BRSRC13/CORE/FW/genfile.c index 97df6a92..de6b7232 100644 --- a/src/BRSRC13/CORE/FW/genfile.c +++ b/src/BRSRC13/CORE/FW/genfile.c @@ -1,11 +1,29 @@ #include "genfile.h" #include "harness/trace.h" + +#include "CORE/V1DB/chunkids.h" +#include #include -br_file_struct_member file_info_FM[2]; -br_file_struct file_info_F; -br_file_enum_member file_type_FM[10]; -br_file_enum file_type_F; +br_file_enum_member file_type_FM[10] = { + { FILE_TYPE_NONE, "FILE_TYPE_NONE" }, + { FILE_TYPE_ACTORS, "FILE_TYPE_ACTORS" }, + { FILE_TYPE_PIXELMAP, "FILE_TYPE_PIXELMAP" }, + { FILE_TYPE_LIGHT, "FILE_TYPE_LIGHT" }, + { FILE_TYPE_CAMERA, "FILE_TYPE_CAMERA" }, + { FILE_TYPE_MATERIAL_OLD, "FILE_TYPE_MATERIAL_OLD" }, + { FILE_TYPE_MODEL, "FILE_TYPE_MODEL" }, + { FILE_TYPE_ANIMATION, "FILE_TYPE_ANIMATION" }, + { FILE_TYPE_TREE, "FILE_TYPE_TREE" }, + { FILE_TYPE_MATERIAL, "FILE_TYPE_MATERIAL" }, +}; +br_file_enum file_type_F = { BR_ASIZE(file_type_FM), file_type_FM }; + +br_file_struct_member file_info_FM[2] = { + { 15, offsetof(file_info, type), "type", &file_type_F }, + { 5, offsetof(file_info, version), "version", NULL }, +}; +br_file_struct file_info_F = { "file_info", BR_ASIZE(file_info_FM), file_info_FM, sizeof(file_info) }; // IDA: int __usercall FopRead_END@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) int FopRead_END(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 count) { @@ -15,12 +33,18 @@ int FopRead_END(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 co // IDA: int __usercall FopWrite_END@(br_datafile *df@) int FopWrite_END(br_datafile* df) { LOG_TRACE("(%p)", df); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_END, 0); } // IDA: int __usercall FopWrite_FILE_INFO@(br_datafile *df@, br_uint_32 type@) int FopWrite_FILE_INFO(br_datafile* df, br_uint_32 type) { file_info fi; LOG_TRACE("(%p, %d)", df, type); - NOT_IMPLEMENTED(); + + fi.type = type; + fi.version = 2; + df->prims->chunk_write(df, CHUNKID_FILE_INFO, df->prims->struct_size(df, &file_info_F, &fi)); + df->prims->struct_write(df, &file_info_F, &fi); + return 0; } diff --git a/src/BRSRC13/CORE/FW/genfile.h b/src/BRSRC13/CORE/FW/genfile.h index 1437ed89..fb457030 100644 --- a/src/BRSRC13/CORE/FW/genfile.h +++ b/src/BRSRC13/CORE/FW/genfile.h @@ -3,6 +3,17 @@ #include "brender/br_types.h" +#define FILE_TYPE_NONE 0x0 +#define FILE_TYPE_ACTORS 0x1 +#define FILE_TYPE_PIXELMAP 0x2 +#define FILE_TYPE_LIGHT 0x3 +#define FILE_TYPE_CAMERA 0x4 +#define FILE_TYPE_MATERIAL_OLD 0x5 +#define FILE_TYPE_MODEL 0xface +#define FILE_TYPE_ANIMATION 0xa11 +#define FILE_TYPE_TREE 0x5eed +#define FILE_TYPE_MATERIAL 0x6 + int FopRead_END(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 count); int FopWrite_END(br_datafile* df); diff --git a/src/BRSRC13/CORE/PIXELMAP/pmfile.c b/src/BRSRC13/CORE/PIXELMAP/pmfile.c index 7013271f..46ec1ca8 100644 --- a/src/BRSRC13/CORE/PIXELMAP/pmfile.c +++ b/src/BRSRC13/CORE/PIXELMAP/pmfile.c @@ -2,54 +2,79 @@ #include "harness/trace.h" #include "CORE/FW/datafile.h" +#include "CORE/FW/diag.h" #include "CORE/FW/genfile.h" #include "CORE/FW/resource.h" #include "CORE/PIXELMAP/pmmem.h" +#include "CORE/PIXELMAP/pmdsptch.h" +#include "CORE/V1DB/chunkids.h" +#include "CORE/V1DB/stackids.h" #include +#include -br_file_enum pixelmap_type_F; +br_file_enum_member pixelmap_type_FM[15] = { + { BR_PMT_INDEX_1, "BR_PMT_INDEX_1", }, + { BR_PMT_INDEX_2, "BR_PMT_INDEX_2", }, + { BR_PMT_INDEX_4, "BR_PMT_INDEX_4", }, + { BR_PMT_INDEX_8, "BR_PMT_INDEX_8", }, + { BR_PMT_RGB_555, "BR_PMT_RGB_555", }, + { BR_PMT_RGB_565, "BR_PMT_RGB_565", }, + { BR_PMT_RGB_888, "BR_PMT_RGB_888", }, + { BR_PMT_RGBX_888, "BR_PMT_RGBX_888", }, + { BR_PMT_RGBA_8888, "BR_PMT_RGBA_8888", }, + { BR_PMT_YUYV_8888, "BR_PMT_YUYV_8888", }, + { BR_PMT_YUV_888, "BR_PMT_YUV_888", }, + { BR_PMT_DEPTH_16, "BR_PMT_DEPTH_16", }, + { BR_PMT_DEPTH_32, "BR_PMT_DEPTH_32", }, + { BR_PMT_ALPHA_8, "BR_PMT_ALPHA_8", }, + { BR_PMT_INDEXA_88, "BR_PMT_INDEXA_88", }, +}; +br_file_enum pixelmap_type_F = { BR_ASIZE(pixelmap_type_FM), pixelmap_type_FM }; br_file_struct_member br_old_pixelmap_FM[7] = { - { 13u, offsetof(br_pixelmap, type), "type", NULL }, - { 3u, offsetof(br_pixelmap, row_bytes), "row_bytes", NULL }, - { 3u, offsetof(br_pixelmap, width), "width", NULL }, - { 3u, offsetof(br_pixelmap, height), "height", NULL }, - { 3u, offsetof(br_pixelmap, origin_x), "origin_x", NULL }, - { 3u, offsetof(br_pixelmap, origin_y), "origin_y", NULL }, - { 17u, offsetof(br_pixelmap, identifier), "identifier", NULL } + { DF_TYPE_ENUM_8, offsetof(br_pixelmap, type), "type", &pixelmap_type_F }, + { DF_TYPE_BR_UINT_16, offsetof(br_pixelmap, row_bytes), "row_bytes", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_pixelmap, width), "width", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_pixelmap, height), "height", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_pixelmap, origin_x), "origin_x", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_pixelmap, origin_y), "origin_y", NULL }, + { DF_TYPE_ASCIZ, offsetof(br_pixelmap, identifier), "identifier", NULL }, }; br_file_struct_member br_pixelmap_FM[8] = { - { 13u, offsetof(br_pixelmap, type), "type", NULL }, - { 3u, offsetof(br_pixelmap, row_bytes), "row_bytes", NULL }, - { 3u, offsetof(br_pixelmap, width), "width", NULL }, - { 3u, offsetof(br_pixelmap, height), "height", NULL }, - { 3u, offsetof(br_pixelmap, origin_x), "origin_x", NULL }, - { 3u, offsetof(br_pixelmap, origin_y), "origin_y", NULL }, - { 3u, offsetof(br_pixelmap, mip_offset), "mip_offset", NULL }, - { 17u, offsetof(br_pixelmap, identifier), "identifier", NULL }, - + { DF_TYPE_ENUM_8, offsetof(br_pixelmap, type), "type", &pixelmap_type_F }, + { DF_TYPE_BR_UINT_16, offsetof(br_pixelmap, row_bytes), "row_bytes", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_pixelmap, width), "width", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_pixelmap, height), "height", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_pixelmap, origin_x), "origin_x", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_pixelmap, origin_y), "origin_y", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_pixelmap, mip_offset), "mip_offset", NULL }, + { DF_TYPE_ASCIZ, offsetof(br_pixelmap, identifier), "identifier", NULL }, }; -br_file_struct br_old_pixelmap_F = { "br_old_pixelmap", 7u, br_old_pixelmap_FM, sizeof(br_pixelmap) }; -br_file_struct br_pixelmap_F = { "br_pixelmap", 8u, br_pixelmap_FM, sizeof(br_pixelmap) }; -br_file_enum_member pixelmap_type_FM[15]; +br_file_struct br_pixelmap_F = { "br_pixelmap", BR_ASIZE(br_pixelmap_FM), br_pixelmap_FM, sizeof(br_pixelmap) }; +br_file_struct br_old_pixelmap_F = { "br_old_pixelmap", BR_ASIZE(br_old_pixelmap_FM), br_old_pixelmap_FM, sizeof(br_pixelmap) }; + br_chunks_table_entry PixelmapLoadEntries[5] = { - { 0u, 0u, &FopRead_END }, - { 3u, 0u, &FopRead_OLD_PIXELMAP }, - { 33u, 0u, &FopRead_PIXELS }, - { 34u, 0u, &FopRead_ADD_MAP } + { CHUNKID_END, 0u, FopRead_END }, + { CHUNKID_PIXELMAP, 0u, FopRead_PIXELMAP }, + { CHUNKID_PIXELMAP_PIXELS, 0u, FopRead_PIXELS }, + { CHUNKID_PIXELMAP_ADD_MAP, 0u, FopRead_ADD_MAP }, + { CHUNKID_OLD_PIXELMAP, 0u, FopRead_OLD_PIXELMAP }, }; -br_chunks_table PixelmapLoadTable = { 4, PixelmapLoadEntries }; - -#define DF_PIXELMAP 2 +br_chunks_table PixelmapLoadTable = { BR_ASIZE(PixelmapLoadEntries), PixelmapLoadEntries }; // IDA: int __usercall FopWrite_PIXELMAP@(br_datafile *df@, br_pixelmap *pixelmap@) int FopWrite_PIXELMAP(br_datafile* df, br_pixelmap* pixelmap) { br_pixelmap pmap; LOG_TRACE("(%p, %p)", df, pixelmap); - NOT_IMPLEMENTED(); + + memcpy(&pmap, pixelmap, sizeof(br_pixelmap)); + pmap.row_bytes = (pmTypeInfo[pmap.type].bits >> 3) * pmap.width; + df->prims->chunk_write(df, CHUNKID_PIXELMAP, df->prims->struct_size(df, &br_pixelmap_F, &pmap)); + df->prims->struct_write(df, &br_pixelmap_F, &pmap); + return 0; } // IDA: int __usercall FopRead_OLD_PIXELMAP@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -57,7 +82,7 @@ int FopRead_OLD_PIXELMAP(br_datafile* df, br_uint_32 id, br_uint_32 length, br_u br_pixelmap* pp; LOG_TRACE("(%p, %d, %d, %d)", df, id, length, count); - pp = (br_pixelmap*)DevicePixelmapMemAllocate(3u, 0, 0, 0, 2); + pp = (br_pixelmap*)DevicePixelmapMemAllocate(BR_PMAF_NO_PIXELS | BR_PMAF_INVERTED, 0, 0, 0, 2); df->res = pp; df->prims->struct_read(df, &br_old_pixelmap_F, pp); df->res = NULL; @@ -69,8 +94,15 @@ int FopRead_OLD_PIXELMAP(br_datafile* df, br_uint_32 id, br_uint_32 length, br_u // IDA: int __usercall FopRead_PIXELMAP@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) int FopRead_PIXELMAP(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 count) { br_pixelmap* pp; - LOG_TRACE9("(%p, %d, %d, %d)", df, id, length, count); - NOT_IMPLEMENTED(); + LOG_TRACE("(%p, %d, %d, %d)", df, id, length, count); + + pp = (br_pixelmap*)DevicePixelmapMemAllocate(BR_PMAF_NO_PIXELS | BR_PMAF_INVERTED, 0, 0, 0, 2); + df->res = pp; + df->prims->struct_read(df, &br_pixelmap_F, pp); + df->res = NULL; + pp->row_bytes = (pmTypeInfo[pp->type].bits >> 3) * pp->width; + DfPush(DF_PIXELMAP, pp, 1); + return 0; } // IDA: int __usercall FopWrite_PIXELS@(br_datafile *df@, br_pixelmap *pixelmap@) @@ -80,7 +112,25 @@ int FopWrite_PIXELS(br_datafile* df, br_pixelmap* pixelmap) { int block_count; char* pixels; LOG_TRACE("(%p, %p)", df, pixelmap); - NOT_IMPLEMENTED(); + + pixels = (char*)pixelmap->pixels + pixelmap->base_x * pixelmap->width + pixelmap->base_y; + if (pixelmap->mip_offset == 0) { + bytes = df->prims->block_size(df, pixels, (pmTypeInfo[pixelmap->type].bits >> 3) * pixelmap->width / pmTypeInfo[pixelmap->type].file_size, pixelmap->row_bytes, pixelmap->height, pmTypeInfo[pixelmap->type].file_size); + df->prims->chunk_write(df, CHUNKID_PIXELMAP_PIXELS, bytes); + bytes = (pmTypeInfo[pixelmap->type].bits >> 3) * pixelmap->width / pmTypeInfo[pixelmap->type].file_size; + size = pixelmap->row_bytes / pmTypeInfo[pixelmap->type].file_size; + block_count = pixelmap->height; + } else { + size = 0; + for (bytes = pixelmap->width; bytes != 0; bytes = bytes >> 1) { + size += bytes * bytes * (pmTypeInfo[pixelmap->type].bits >> 3); + } + df->prims->chunk_write(df, CHUNKID_PIXELMAP_PIXELS, df-> prims->block_size(df, pixels, size / pmTypeInfo[pixelmap->type].file_size, size, 1, pmTypeInfo[pixelmap->type].file_size)); + bytes = size; + block_count = 1; + } + df->prims->block_write(df, pixels, bytes, size, block_count, pmTypeInfo[pixelmap->type].file_size); + return 0; } // IDA: int __usercall FopRead_PIXELS@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -93,7 +143,7 @@ int FopRead_PIXELS(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 pp = DfTop(DF_PIXELMAP, NULL); size = pmTypeInfo[pp->type].file_size; df->res = pp; - pp->pixels = df->prims->block_read(df, NULL, &icount, size, 3); + pp->pixels = df->prims->block_read(df, NULL, &icount, size, BR_MEMORY_PIXELS); pp->flags |= BR_PMF_LINEAR; df->res = NULL; return 0; @@ -102,7 +152,9 @@ int FopRead_PIXELS(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 // IDA: int __usercall FopWrite_ADD_MAP@(br_datafile *df@) int FopWrite_ADD_MAP(br_datafile* df) { LOG_TRACE("(%p)", df); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_PIXELMAP_ADD_MAP, 0); + return 0; } // IDA: int __usercall FopRead_ADD_MAP@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -121,31 +173,45 @@ int FopRead_ADD_MAP(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_3 // IDA: br_uint_32 __cdecl BrPixelmapLoadMany(char *filename, br_pixelmap **pixelmaps, br_uint_16 num) br_uint_32 BrPixelmapLoadMany(char* filename, br_pixelmap** pixelmaps, br_uint_16 num) { br_datafile* df; - int count = 0; + int count; int r; LOG_TRACE("(\"%s\", %p, %d)", filename, pixelmaps, num); df = DfOpen(filename, 0, BRT_FIXED); - if (df) { - do { - if (count >= num) { - break; - } - r = DfChunksInterpret(df, &PixelmapLoadTable); - if (DfTopType() == DF_PIXELMAP) { - pixelmaps[count] = DfPop(DF_PIXELMAP, NULL); - count++; - } - } while (r); - DfClose(df); + if (df == NULL) { + return 0; } + count = 0; + do { + if (count >= num) { + break; + } + r = DfChunksInterpret(df, &PixelmapLoadTable); + if (DfTopType() == DF_PIXELMAP) { + pixelmaps[count] = DfPop(DF_PIXELMAP, 0); + count++; + } + } while (r != 0); + DfClose(df); return count; } // IDA: int __usercall WritePixelmap@(br_pixelmap *pp@, br_datafile *df@) int WritePixelmap(br_pixelmap* pp, br_datafile* df) { LOG_TRACE("(%p, %p)", pp, df); - NOT_IMPLEMENTED(); + + BrPixelmapDirectLock(pp, 1); + if (pp->pixels == NULL) { + _BrAssert("pp->pixels", "pmfile.c", 291); + } + FopWrite_PIXELMAP(df, pp); + if (pp->map != NULL) { + WritePixelmap(pp->map, df); + FopWrite_ADD_MAP(df); + } + FopWrite_PIXELS(df, pp); + BrPixelmapDirectUnlock(pp); + return 0; } // IDA: br_uint_32 __cdecl BrPixelmapSaveMany(char *filename, br_pixelmap **pixelmaps, br_uint_16 num) @@ -153,7 +219,24 @@ br_uint_32 BrPixelmapSaveMany(char* filename, br_pixelmap** pixelmaps, br_uint_1 br_datafile* df; int i; LOG_TRACE("(\"%s\", %p, %d)", filename, pixelmaps, num); - NOT_IMPLEMENTED(); + + if (filename == NULL) { + _BrAssert("filename != NULL", "pmfile.c", 324); + } + if (pixelmaps == NULL) { + _BrAssert("pixelmaps != NULL", "pmfile.c", 325); + } + df = DfOpen(filename, 1, BRT_FIXED); + if (df == NULL) { + return 0; + } + FopWrite_FILE_INFO(df, 2); + for (i = 0; i < num; i++) { + WritePixelmap(pixelmaps[i], df); + FopWrite_END(df); + } + DfClose(df); + return num; } // IDA: br_pixelmap* __cdecl BrPixelmapLoad(char *filename) @@ -169,5 +252,6 @@ br_pixelmap* BrPixelmapLoad(char* filename) { // IDA: br_uint_32 __cdecl BrPixelmapSave(char *filename, br_pixelmap *ptr) br_uint_32 BrPixelmapSave(char* filename, br_pixelmap* ptr) { LOG_TRACE("(\"%s\", %p)", filename, ptr); - NOT_IMPLEMENTED(); + + return BrPixelmapSaveMany(filename, &ptr, 1); } diff --git a/src/BRSRC13/CORE/V1DB/chunkids.h b/src/BRSRC13/CORE/V1DB/chunkids.h new file mode 100644 index 00000000..b22d0e94 --- /dev/null +++ b/src/BRSRC13/CORE/V1DB/chunkids.h @@ -0,0 +1,52 @@ +#ifndef _CHUNKIDS_H_ +#define _CHUNKIDS_H_ + +#define CHUNKID_END 0x0 +#define CHUNKID_OLD_PIXELMAP 0x3 +#define CHUNKID_MATERIAL_OLD 0x4 +#define CHUNKID_OLD_MATERIAL_INDEX 0x9 +#define CHUNKID_OLD_VERTICES 0xa +#define CHUNKID_OLD_VERTICES_UV 0xb +#define CHUNKID_OLD_FACES 0xc +#define CHUNKID_OLD_MODEL 0xd +#define CHUNKID_FILE_INFO 0x12 +#define CHUNKID_MODEL_PIVOT 0x15 +#define CHUNKID_MATERIAL_INDEX 0x16 +#define CHUNKID_MODEL_VERTICES 0x17 +#define CHUNKID_MODEL_VERTEX_UV 0x18 +#define CHUNKID_OLD_FACES_1 0x19 +#define CHUNKID_MODEL_FACE_MATERIAL 0x1a +#define CHUNKID_OLD_MODEL_1 0x1b +#define CHUNKID_MATERIAL_COLOUR_MAP 0x1c +#define CHUNKID_MATERIAL_INDEX_BLEND 0x1e +#define CHUNKID_MATERIAL_INDEX_SHADE 0x1f +#define CHUNKID_MATERIAL_SCREENDOOR 0x20 +#define CHUNKID_PIXELMAP_PIXELS 0x21 +#define CHUNKID_PIXELMAP_ADD_MAP 0x22 +#define CHUNKID_ACTOR 0x23 +#define CHUNKID_ACTOR_MODEL 0x24 +#define CHUNKID_ACTOR_TRANSFORM 0x25 +#define CHUNKID_ACTOR_MATERIAL 0x26 +#define CHUNKID_ACTOR_LIGHT 0x27 +#define CHUNKID_ACTOR_CAMERA 0x28 +#define CHUNKID_ACTOR_BOUNDS 0x29 +#define CHUNKID_ACTOR_ADD_CHILD 0x2a +#define CHUNKID_TRANSFORM_MAT34 0x2b +#define CHUNKID_TRANSFORM_MAT34_LP 0x2c +#define CHUNKID_TRANSFORM_QUAT 0x2d +#define CHUNKID_TRANSFORM_EULER 0x2e +#define CHUNKID_TRANSFORM_LOOK_UP 0x2f +#define CHUNKID_TRANSFORM_TRANSLATION 0x30 +#define CHUNKID_TRANSFORM_IDENTITY 0x31 +#define CHUNKID_BOUNDS 0x32 +#define CHUNKID_LIGHT 0x33 +#define CHUNKID_CAMERA 0x34 +#define CHUNKID_MODEL_FACES 0x35 +#define CHUNKID_MODEL 0x36 +#define CHUNKID_ACTOR_CLIP_PLANE 0x37 +#define CHUNKID_PLANE 0x38 +#define CHUNKID_MATERIAL_INDEX_FOG 0x3b +#define CHUNKID_MATERIAL 0x3c +#define CHUNKID_PIXELMAP 0x3d + +#endif // CHUNKIDS_H_ diff --git a/src/BRSRC13/CORE/V1DB/stackids.h b/src/BRSRC13/CORE/V1DB/stackids.h new file mode 100644 index 00000000..ba341a0f --- /dev/null +++ b/src/BRSRC13/CORE/V1DB/stackids.h @@ -0,0 +1,17 @@ +#ifndef _STACKIDS_H_ +#define _STACKIDS_H_ + +#define DF_PIXELMAP 2 +#define DF_MATERIAL 3 +#define DF_ACTOR 4 +#define DF_MATERIAL_INDEX 5 +#define DF_VERTEX 6 +#define DF_FACE 7 +#define DF_MODEL 8 +#define DF_TRANSFORM 16 +#define DF_LIGHT 17 +#define DF_CAMERA 18 +#define DF_BOUNDS 19 +#define DF_CLIP_PLANE 20 + +#endif // _STACKIDS_H_ diff --git a/src/BRSRC13/CORE/V1DB/v1dbfile.c b/src/BRSRC13/CORE/V1DB/v1dbfile.c index b36863ca..5d0d2636 100644 --- a/src/BRSRC13/CORE/V1DB/v1dbfile.c +++ b/src/BRSRC13/CORE/V1DB/v1dbfile.c @@ -1,76 +1,140 @@ #include "v1dbfile.h" +#include "CORE/FW/brqsort.h" #include "CORE/FW/datafile.h" #include "CORE/FW/diag.h" +#include "CORE/FW/file.h" #include "CORE/FW/genfile.h" #include "CORE/FW/resource.h" #include "CORE/FW/scratch.h" #include "CORE/V1DB/actsupt.h" +#include "CORE/V1DB/chunkids.h" #include "CORE/V1DB/dbsetup.h" #include "CORE/V1DB/matsupt.h" #include "CORE/V1DB/modsupt.h" #include "CORE/V1DB/regsupt.h" +#include "CORE/V1DB/stackids.h" #include "harness/trace.h" #include #include #include -br_chunks_table_entry MaterialLoadEntries[8] = { - { 0u, 0u, &FopRead_END }, - { 4u, 0u, &FopRead_MATERIAL_OLD }, - { 28u, 0u, &FopRead_PIXELMAP_REF }, - { 30u, 0u, &FopRead_PIXELMAP_REF }, - { 31u, 0u, &FopRead_PIXELMAP_REF }, - { 32u, 0u, &FopRead_PIXELMAP_REF }, - { 59u, 0u, &FopRead_PIXELMAP_REF }, - { 60u, 0u, &FopRead_MATERIAL } +br_file_struct_member br_vertex_FM[3] = { + { DF_TYPE_BR_SCALAR, offsetof(br_vertex, p.v[0]), "p.v[x]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_vertex, p.v[1]), "p.v[y]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_vertex, p.v[2]), "p.v[z]", NULL } }; +br_file_struct br_vertex_F = { "br_vertex", BR_ASIZE(br_vertex_FM), br_vertex_FM, sizeof(br_vertex) }; -br_chunks_table MaterialLoadTable = { 8, MaterialLoadEntries }; - -br_file_struct br_camera_F; -br_file_enum camera_type_F; - -br_file_struct_member br_camera_FM[6]; -br_file_enum_member camera_type_FM[2]; -br_file_struct br_light_F; -br_file_enum light_type_F; -br_file_enum_member light_type_FM[6]; -br_file_struct_member br_light_FM[8]; -br_file_struct br_plane_F; -br_file_struct_member br_bounds3_FM[2] = { { 20u, 0u, "min", NULL }, { 20u, 12u, "max", NULL } }; -br_file_struct br_bounds3_F = { "br_bounds3", 2u, br_bounds3_FM, 24 }; -br_file_struct_member br_plane_FM[1]; -br_file_struct br_transform_translation_F; -br_file_struct_member br_transform_translation_FM[1]; -br_file_enum angle_order_F; -br_file_struct_member br_transform_euler_FM[5]; -br_file_struct br_transform_look_up_F; -br_file_struct_member br_transform_look_up_FM[3]; -br_file_struct br_transform_euler_F; -br_file_struct br_transform_quat_F; -br_file_struct_member br_transform_quat_FM[5]; -br_file_enum_member angle_order_FM[24]; - -br_file_struct_member br_transform_matrix34_FM[] = { - { 20u, offsetof(br_transform, t.mat.m[0]), "t.mat.m[0]", NULL }, - { 20u, offsetof(br_transform, t.mat.m[1]), "t.mat.m[1]", NULL }, - { 20u, offsetof(br_transform, t.mat.m[2]), "t.mat.m[2]", NULL }, - { 20u, offsetof(br_transform, t.mat.m[3]), "t.mat.m[3]", NULL } +br_file_struct_member br_vertex_uv_FM[] = { + { DF_TYPE_BR_SCALAR, offsetof(br_vertex, map.v[0]), "map.v[0]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_vertex, map.v[1]), "map.v[1]", NULL } }; -br_file_struct br_transform_matrix34_F = { "br_transform_matrix34", 4u, br_transform_matrix34_FM, sizeof(br_transform) }; - -transform_type TransformTypes[] = { - { 43u, &br_transform_matrix34_F }, - { 44u, &br_transform_matrix34_F }, - { 45u, &br_transform_quat_F }, - { 46u, &br_transform_euler_F }, - { 47u, &br_transform_look_up_F }, - { 48u, &br_transform_translation_F }, - { 49u, NULL } +br_file_struct br_vertex_uv_F = { "br_vertex_uv", BR_ASIZE(br_vertex_uv_FM), br_vertex_uv_FM, sizeof(br_vertex) }; + +br_file_struct_member br_old_vertex_uv_FM[5] = { + { DF_TYPE_BR_SCALAR, offsetof(br_vertex, p) + 0 * sizeof(br_scalar), "p.v[X]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_vertex, p) + 1 * sizeof(br_scalar), "p.v[Y]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_vertex, p) + 2 * sizeof(br_scalar), "p.v[Z]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_vertex, map) + 0 * sizeof(br_scalar), "map.v[0]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_vertex, map) + 1 * sizeof(br_scalar), "map.v[1]", NULL }, }; +br_file_struct br_old_vertex_uv_F = { "br_old_vertex_uv", BR_ASIZE(br_old_vertex_uv_FM), br_old_vertex_uv_FM, sizeof(br_vertex) }; -br_file_enum_member render_style_FM[8]; +br_file_struct_member br_face_FM[5] = { + { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices), "vertices[0]", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices[1]), "vertices[1]", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices[2]), "vertices[2]", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_face, smoothing), "smoothing", NULL }, + { DF_TYPE_BR_UINT_8, offsetof(br_face, flags), "flags", NULL } +}; +br_file_struct br_face_F = { "br_face", BR_ASIZE(br_face_FM), br_face_FM, sizeof(br_face) }; + +br_file_struct_member br_old_face_1_FM[5] = { + { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices) + 0 * sizeof(br_uint_16), "vertices[0]", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices) + 1 * sizeof(br_uint_16), "vertices[1]", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices) + 2 * sizeof(br_uint_16), "vertices[2]", NULL }, + { DF_TYPE_BR_UINT_8, offsetof(br_face, smoothing), "smoothing", NULL }, + { DF_TYPE_BR_UINT_8, offsetof(br_face, flags), "flags", NULL }, +}; +br_file_struct br_old_face_1_F = { "br_old_face_1", BR_ASIZE(br_old_face_1_FM), br_old_face_1_FM, sizeof(br_face) }; + +br_file_struct_member br_old_face_FM[5] = { + { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices) + 0 * sizeof(br_uint_16), "vertices[0]", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices) + 1 * sizeof(br_uint_16), "vertices[1]", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices) + 2 * sizeof(br_uint_16), "vertices[2]", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_face, material), "material", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_face, smoothing), "smoothing", NULL }, // DF_TYPE_BR_UINT_32 in EXE +}; +br_file_struct br_old_face_F = { "br_old_face", BR_ASIZE(br_old_face_FM), br_old_face_FM, sizeof(br_face) }; + +br_file_struct_member br_model_FM[2] = { + { DF_TYPE_BR_UINT_16, offsetof(br_model, flags), "flags", NULL }, + { DF_TYPE_ASCIZ, offsetof(br_model, identifier), "identifier", NULL } +}; +br_file_struct br_model_F = { "br_model", BR_ASIZE(br_model_FM), br_model_FM, sizeof(br_model) }; + +br_file_struct_member br_old_model_1_FM[1] = { + { DF_TYPE_ASCIZ, offsetof(br_model, identifier), "identifier", NULL }, +}; +br_file_struct br_old_model_1_F = { "br_old_model_1", 1, br_old_model_1_FM, sizeof(br_model) }; + +br_file_struct_member br_pivot_FM[3] = { + { DF_TYPE_BR_SCALAR, offsetof(br_model, pivot) + 0 * sizeof(br_scalar), "pivot.v[X]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_model, pivot) + 1 * sizeof(br_scalar), "pivot.v[Y]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_model, pivot) + 2 * sizeof(br_scalar), "pivot.v[Z]", NULL }, +}; +br_file_struct br_pivot_F = { "br_pivot", 3, br_pivot_FM, sizeof(br_model) }; + +br_file_struct_member br_material_old_FM[13] = { + { DF_TYPE_BR_COLOUR, offsetof(br_material, colour), "colour", NULL }, + { DF_TYPE_BR_UINT_8, offsetof(br_material, opacity), "opacity", NULL }, + { DF_TYPE_BR_UFRACTION, offsetof(br_material, ka), "ka", NULL }, + { DF_TYPE_BR_UFRACTION, offsetof(br_material, kd), "kd", NULL }, + { DF_TYPE_BR_UFRACTION, offsetof(br_material, ks), "ks", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_material, power), "power", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_material, flags), "flags", NULL }, + { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform) + 0 *sizeof(br_vector2), "map_transform.m[0]", NULL }, + { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform) + 1 *sizeof(br_vector2), "map_transform.m[1]", NULL }, + { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform) + 2 *sizeof(br_vector2), "map_transform.m[2]", NULL }, + { DF_TYPE_BR_UINT_8, offsetof(br_material, index_base), "index_base", NULL }, + { DF_TYPE_BR_UINT_8, offsetof(br_material, index_range), "index_range", NULL }, + { DF_TYPE_ASCIZ, offsetof(br_material, identifier), "identifier", NULL } +}; +br_file_struct br_material_old_F = { "br_material_old", BR_ASIZE(br_material_old_FM), br_material_old_FM, sizeof(br_material) }; + +br_file_struct_member br_material_FM[17] = { + { DF_TYPE_BR_COLOUR, offsetof(br_material, colour), "colour", NULL }, + { DF_TYPE_BR_UINT_8, offsetof(br_material, opacity), "opacity", NULL }, + { DF_TYPE_BR_UFRACTION, offsetof(br_material, ka), "ka", NULL }, + { DF_TYPE_BR_UFRACTION, offsetof(br_material, kd), "kd", NULL }, + { DF_TYPE_BR_UFRACTION, offsetof(br_material, ks), "ks", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_material, power), "power", NULL }, + { DF_TYPE_BR_UINT_32, offsetof(br_material, flags), "flags", NULL }, + { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform) + 0 * sizeof(br_vector2), "map_transform.m[0]", NULL }, + { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform) + 1 * sizeof(br_vector2), "map_transform.m[1]", NULL }, + { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform) + 2 * sizeof(br_vector2), "map_transform.m[2]", NULL }, + { DF_TYPE_BR_UINT_8, offsetof(br_material, index_base), "index_base", NULL }, + { DF_TYPE_BR_UINT_8, offsetof(br_material, index_range), "index_range", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_material, fog_min), "fog_min", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_material, fog_max), "fog_max", NULL }, + { DF_TYPE_BR_COLOUR, offsetof(br_material, fog_colour), "fog_colour", NULL }, + { DF_TYPE_BR_INT_32, offsetof(br_material, subdivide_tolerance), "subdivide_tolerance", NULL }, + { DF_TYPE_ASCIZ, offsetof(br_material, identifier), "identifier", NULL }, +}; +br_file_struct br_material_F = { "br_material", BR_ASIZE(br_material_FM), br_material_FM, sizeof(br_material) }; + +struct { + br_uint_32 id; + size_t offset; + int table; +} MaterialMaps[5] = { + { CHUNKID_MATERIAL_COLOUR_MAP, offsetof(br_material, colour_map), 0 }, + { CHUNKID_MATERIAL_INDEX_BLEND, offsetof(br_material, index_blend), 1 }, + { CHUNKID_MATERIAL_INDEX_SHADE, offsetof(br_material, index_shade), 1 }, + { CHUNKID_MATERIAL_SCREENDOOR, offsetof(br_material, screendoor), 1 }, + { CHUNKID_MATERIAL_INDEX_FOG, offsetof(br_material, index_fog), 1 }, +}; br_file_enum_member actor_type_FM[8] = { { 0, "BR_ACTOR_NONE" }, @@ -82,146 +146,215 @@ br_file_enum_member actor_type_FM[8] = { { 6, "BR_ACTOR_BOUNDS_CORRECT" }, { 7, "BR_ACTOR_CLIP_PLANE" } }; -br_file_enum actor_type_F = { 8u, actor_type_FM }; +br_file_enum actor_type_F = { BR_ASIZE(actor_type_FM), actor_type_FM }; + +br_file_enum_member render_style_FM[8] = { + { 0, "BR_RSTYLE_DEFAULT"}, + { 1, "BR_RSTYLE_NONE"}, + { 2, "BR_RSTYLE_POINTS"}, + { 3, "BR_RSTYLE_EDGES"}, + { 4, "BR_RSTYLE_FACES"}, + { 5, "BR_RSTYLE_BOUNDING_POINTS"}, + { 6, "BR_RSTYLE_BOUNDING_EDGES"}, + { 7, "BR_RSTYLE_BOUNDING_FACES"}, +}; +br_file_enum render_style_F = { 8, render_style_FM }; br_file_struct_member br_actor_FM[3] = { - { 13u, offsetof(br_actor, type), "type", NULL /*actor_type_FM */ }, - { 13u, offsetof(br_actor, render_style), "render_style", NULL /*render_style_FM*/ }, - { 17u, offsetof(br_actor, identifier), "identifier", NULL } + { DF_TYPE_ENUM_8, offsetof(br_actor, type), "type", &actor_type_F }, + { DF_TYPE_ENUM_8, offsetof(br_actor, render_style), "render_style", &render_style_F }, + { DF_TYPE_ASCIZ, offsetof(br_actor, identifier), "identifier", NULL } }; -br_file_struct br_actor_F = { "br_actor", 3u, br_actor_FM, sizeof(br_actor) }; -br_file_enum render_style_F; - -br_file_struct_member br_material_FM[17]; -br_file_struct br_material_F; +br_file_struct br_actor_F = { "br_actor", BR_ASIZE(br_actor_FM), br_actor_FM, sizeof(br_actor) }; -br_file_struct_member br_material_old_FM[13] = { - { 18u, offsetof(br_material, colour), "colour", NULL }, - { 1u, offsetof(br_material, opacity), "opacity", NULL }, - { 12u, offsetof(br_material, ka), "ka", NULL }, - { 12u, offsetof(br_material, kd), "kd", NULL }, - { 12u, offsetof(br_material, ks), "ks", NULL }, - { 10u, offsetof(br_material, power), "power", NULL }, - { 3u, offsetof(br_material, flags), "flags", NULL }, - { 19u, offsetof(br_material, map_transform), "map_transform.m[0]", NULL }, - { 19u, offsetof(br_material, map_transform) + sizeof(br_scalar) * 2, "map_transform.m[1]", NULL }, - { 19u, offsetof(br_material, map_transform) + sizeof(br_scalar) * 4, "map_transform.m[2]", NULL }, - { 1u, offsetof(br_material, index_base), "index_base", NULL }, - { 1u, offsetof(br_material, index_range), "index_range", NULL }, - { 17u, offsetof(br_material, identifier), "identifier", NULL } +br_file_struct_member br_transform_matrix34_FM[4] = { + { DF_TYPE_BR_VECTOR3, offsetof(br_transform, t.mat.m[0]), "t.mat.m[0]", NULL }, + { DF_TYPE_BR_VECTOR3, offsetof(br_transform, t.mat.m[1]), "t.mat.m[1]", NULL }, + { DF_TYPE_BR_VECTOR3, offsetof(br_transform, t.mat.m[2]), "t.mat.m[2]", NULL }, + { DF_TYPE_BR_VECTOR3, offsetof(br_transform, t.mat.m[3]), "t.mat.m[3]", NULL } }; -br_file_struct br_material_old_F = { "br_material_old", 13, br_material_old_FM, sizeof(br_material) }; - -br_file_struct_member br_pivot_FM[3]; -br_file_struct br_pivot_F; - -br_file_struct_member br_old_model_1_FM[1]; -br_file_struct br_old_model_1_F; - -br_file_struct_member br_model_FM[2] = { - { 3u, offsetof(br_model, flags), "flags", NULL }, - { 17u, offsetof(br_model, identifier), "identifier", NULL } +br_file_struct br_transform_matrix34_F = { "br_transform_matrix34", BR_ASIZE(br_transform_matrix34_FM), br_transform_matrix34_FM, sizeof(br_transform) }; + +br_file_struct_member br_transform_quat_FM[5] = { + { DF_TYPE_BR_SCALAR, offsetof(br_transform, t.quat.q.x), "t.quat.q.x", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_transform, t.quat.q.y), "t.quat.q.y", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_transform, t.quat.q.z), "t.quat.q.z", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_transform, t.quat.q.w), "t.quat.q.w", NULL }, + { DF_TYPE_BR_VECTOR3, offsetof(br_transform, t.quat.t), "t.quat.t", NULL }, }; -br_file_struct br_model_F = { "br_model", 2u, br_model_FM, sizeof(br_model) }; - -br_file_struct_member br_old_face_FM[5]; -br_file_struct br_old_face_F; +br_file_struct br_transform_quat_F = { "br_transform_quat", BR_ASIZE(br_transform_quat_FM), br_transform_quat_FM, sizeof(br_transform) }; + +br_file_enum_member angle_order_FM[24] = { + { 0, "BR_EULER_XYZ_S" }, + { 8, "BR_EULER_XYX_S" }, + { 4, "BR_EULER_XZY_S" }, + { 12, "BR_EULER_XZX_S" }, + { 1, "BR_EULER_YZX_S" }, + { 9, "BR_EULER_YZY_S" }, + { 5, "BR_EULER_YXZ_S" }, + { 13, "BR_EULER_YXY_S" }, + { 2, "BR_EULER_ZXY_S" }, + { 10, "BR_EULER_ZXZ_S" }, + { 6, "BR_EULER_ZYX_S" }, + { 14, "BR_EULER_ZYZ_S" }, + { 16, "BR_EULER_ZYX_R" }, + { 24, "BR_EULER_XYX_R" }, + { 20, "BR_EULER_YZX_R" }, + { 28, "BR_EULER_XZX_R" }, + { 17, "BR_EULER_XZY_R" }, + { 25, "BR_EULER_YZY_R" }, + { 21, "BR_EULER_ZXY_R" }, + { 29, "BR_EULER_YXY_R" }, + { 18, "BR_EULER_YXZ_R" }, + { 26, "BR_EULER_ZXZ_R" }, + { 22, "BR_EULER_XYZ_R" }, + { 30, "BR_EULER_ZYZ_R" }, +}; +br_file_enum angle_order_F = { BR_ASIZE(angle_order_FM), angle_order_FM }; + +br_file_struct_member br_transform_euler_FM[5] = { + { DF_TYPE_ENUM_8, offsetof(br_transform, t.euler.e.order), "t.euler.e.order", &angle_order_F }, + { DF_TYPE_BR_ANGLE, offsetof(br_transform, t.euler.e.a), "t.euler.e.a", NULL }, + { DF_TYPE_BR_ANGLE, offsetof(br_transform, t.euler.e.b), "t.euler.e.b", NULL }, + { DF_TYPE_BR_ANGLE, offsetof(br_transform, t.euler.e.c), "t.euler.e.c", NULL }, + { DF_TYPE_BR_VECTOR3, offsetof(br_transform, t.euler.t), "t.euler.t", NULL }, +}; +br_file_struct br_transform_euler_F = { "br_transform_euler", BR_ASIZE(br_transform_euler_FM), br_transform_euler_FM, sizeof(br_transform) }; -br_file_struct_member br_old_face_1_FM[5]; -br_file_struct br_old_face_1_F; +br_file_struct_member br_transform_look_up_FM[3] = { + { DF_TYPE_BR_VECTOR3, offsetof(br_transform, t.look_up.look), "t.look_up.look", NULL }, + { DF_TYPE_BR_VECTOR3, offsetof(br_transform, t.look_up.up), "t.look_up.up", NULL }, + { DF_TYPE_BR_VECTOR3, offsetof(br_transform, t.look_up.t), "t.look_up.t", NULL }, +}; +br_file_struct br_transform_look_up_F = { "br_transform_look_up", BR_ASIZE(br_transform_look_up_FM), br_transform_look_up_FM, sizeof(br_transform) }; -br_file_struct_member br_face_FM[5] = { - { 3u, offsetof(br_face, vertices), "vertices[0]", NULL }, - { 3u, offsetof(br_face, vertices[1]), "vertices[1]", NULL }, - { 3u, offsetof(br_face, vertices[2]), "vertices[2]", NULL }, - { 3u, offsetof(br_face, smoothing), "smoothing", NULL }, - { 1u, offsetof(br_face, flags), "flags", NULL } +br_file_struct_member br_transform_translation_FM[1] = { + { DF_TYPE_BR_VECTOR3, offsetof(br_transform, t.translate.t), "t.translate.t", NULL }, +}; +br_file_struct br_transform_translation_F = { "br_transform_translation", BR_ASIZE(br_transform_translation_FM), br_transform_translation_FM, sizeof(br_transform) }; + +transform_type TransformTypes[7] = { + { CHUNKID_TRANSFORM_MAT34, &br_transform_matrix34_F }, + { CHUNKID_TRANSFORM_MAT34_LP, &br_transform_matrix34_F }, + { CHUNKID_TRANSFORM_QUAT, &br_transform_quat_F }, + { CHUNKID_TRANSFORM_EULER, &br_transform_euler_F }, + { CHUNKID_TRANSFORM_LOOK_UP, &br_transform_look_up_F }, + { CHUNKID_TRANSFORM_TRANSLATION, &br_transform_translation_F }, + { CHUNKID_TRANSFORM_IDENTITY, NULL } }; -br_file_struct br_face_F = { "br_face", 5u, br_face_FM, sizeof(br_face) }; -br_file_struct_member br_old_vertex_uv_FM[5]; -br_file_struct br_old_vertex_uv_F; +br_file_struct_member br_bounds3_FM[2] = { + { DF_TYPE_BR_VECTOR3, offsetof(br_bounds3, min), "min", NULL }, + { DF_TYPE_BR_VECTOR3, offsetof(br_bounds3, max), "max", NULL }, +}; +br_file_struct br_bounds3_F = { "br_bounds3", BR_ASIZE(br_bounds3_FM), br_bounds3_FM, sizeof(br_bounds3) }; -br_file_struct_member br_vertex_uv_FM[] = { - { 10, offsetof(br_vertex, map.v[0]), "map.v[0]", NULL }, - { 10u, offsetof(br_vertex, map.v[1]), "map.v[1]", NULL } +br_file_struct_member br_plane_FM[1] = { + { DF_TYPE_BR_VECTOR4, offsetof(br_vector4, v), "eqn", NULL }, +}; +br_file_struct br_plane_F = { "br_plane", BR_ASIZE(br_plane_FM), br_plane_FM, sizeof(br_vector4) }; + +br_file_enum_member light_type_FM[6] = { + { 0, "BR_LIGHT_POINT"}, + { 1, "BR_LIGHT_DIRECT"}, + { 2, "BR_LIGHT_SPOT"}, + { 4, "BR_LIGHT_VIEW|BR_LIGHT_POINT"}, + { 5, "BR_LIGHT_VIEW|BR_LIGHT_DIRECT"}, + { 6, "BR_LIGHT_VIEW|BR_LIGHT_SPOT"}, +}; +br_file_enum light_type_F = { BR_ASIZE(light_type_FM), light_type_FM }; + +br_file_struct_member br_light_FM[8] = { + { DF_TYPE_ENUM_8, offsetof(br_light, type), "type", &light_type_F }, + { DF_TYPE_BR_COLOUR, offsetof(br_light, colour), "colour", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_light, attenuation_c), "attenuation_c", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_light, attenuation_l), "attenuation_l", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_light, attenuation_q), "attenuation_q", NULL }, + { DF_TYPE_BR_ANGLE, offsetof(br_light, cone_inner), "cone_inner", NULL }, + { DF_TYPE_BR_ANGLE, offsetof(br_light, cone_outer), "cone_outer", NULL }, + { DF_TYPE_ASCIZ, offsetof(br_light, identifier), "identifier", NULL }, }; -br_file_struct br_vertex_uv_F = { "br_vertex_uv", 2, br_vertex_uv_FM, sizeof(br_vertex) }; +br_file_struct br_light_F = { "br_light", BR_ASIZE(br_light_FM), br_light_FM, sizeof(br_light) }; -br_file_struct_member br_vertex_FM[3] = { - { 10, offsetof(br_vertex, p.v[0]), "p.v[x]", NULL }, - { 10, offsetof(br_vertex, p.v[1]), "p.v[y]", NULL }, - { 10, offsetof(br_vertex, p.v[2]), "p.v[z]", NULL } +br_file_enum_member camera_type_FM[2] = { + { 0, "BR_CAMERA_PARALLEL"}, + { 1, "BR_CAMERA_PERSPECTIVE"}, +}; +br_file_enum camera_type_F = { BR_ASIZE(camera_type_FM), camera_type_FM }; + +br_file_struct_member br_camera_FM[6] = { + { DF_TYPE_ENUM_8, offsetof(br_camera, type), "type", &camera_type_F }, + { DF_TYPE_BR_ANGLE, offsetof(br_camera, field_of_view), "field_of_view", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_camera, hither_z), "hither_z", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_camera, yon_z), "yon_z", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_camera, aspect), "aspect", NULL }, + { DF_TYPE_ASCIZ, offsetof(br_camera, identifier), "identifier", NULL }, }; -br_file_struct br_vertex_F = { "br_vertex", 3, br_vertex_FM, sizeof(br_vertex) }; - -br_chunks_table_entry ModelLoadEntries[] = { - { 0u, 0u, &FopRead_END }, - { 9u, 0u, &FopRead_OLD_MATERIAL_INDEX }, - { 10u, 0u, &FopRead_OLD_VERTICES }, - { 11u, 0u, &FopRead_OLD_VERTICES_UV }, - { 12u, 0u, &FopRead_OLD_FACES }, - { 13u, 0u, &FopRead_OLD_MODEL }, - { 25u, 1u, &FopRead_OLD_FACES_1 }, - { 27u, 0u, &FopRead_OLD_MODEL_1 }, - { 54u, 0u, &FopRead_MODEL }, - { 22u, 1u, &FopRead_MATERIAL_INDEX }, - { 23u, 1u, &FopRead_VERTICES }, - { 24u, 1u, &FopRead_VERTEX_UV }, - { 53u, 1u, &FopRead_FACES }, - { 26u, 0u, &FopRead_FACE_MATERIAL }, - { 21u, 0u, &FopRead_PIVOT } +br_file_struct br_camera_F = { "br_camera", BR_ASIZE(br_camera_FM), br_camera_FM, sizeof(br_camera) }; + +br_chunks_table_entry ModelLoadEntries[15] = { + { CHUNKID_END, 0u, FopRead_END }, + { CHUNKID_OLD_MATERIAL_INDEX, 0u, FopRead_OLD_MATERIAL_INDEX }, + { CHUNKID_OLD_VERTICES, 0u, FopRead_OLD_VERTICES }, + { CHUNKID_OLD_VERTICES_UV, 0u, FopRead_OLD_VERTICES_UV }, + { CHUNKID_OLD_FACES, 0u, FopRead_OLD_FACES }, + { CHUNKID_OLD_MODEL, 0u, FopRead_OLD_MODEL }, + { CHUNKID_OLD_FACES_1, 1u, FopRead_OLD_FACES_1 }, + { CHUNKID_OLD_MODEL_1, 0u, FopRead_OLD_MODEL_1 }, + { CHUNKID_MODEL, 0u, FopRead_MODEL }, + { CHUNKID_MATERIAL_INDEX, 1u, FopRead_MATERIAL_INDEX }, + { CHUNKID_MODEL_VERTICES, 1u, FopRead_VERTICES }, + { CHUNKID_MODEL_VERTEX_UV, 1u, FopRead_VERTEX_UV }, + { CHUNKID_MODEL_FACES, 1u, FopRead_FACES }, + { CHUNKID_MODEL_FACE_MATERIAL, 0u, FopRead_FACE_MATERIAL }, + { CHUNKID_MODEL_PIVOT, 0u, FopRead_PIVOT }, }; -br_chunks_table ModelLoadTable = { 15, ModelLoadEntries }; +br_chunks_table ModelLoadTable = { BR_ASIZE(ModelLoadEntries), ModelLoadEntries }; br_chunks_table_entry ActorLoadEntries[21] = { - { 0u, 0u, &FopRead_END }, - { 35u, 0u, &FopRead_ACTOR }, - { 36u, 0u, &FopRead_ACTOR_MODEL }, - { 37u, 0u, &FopRead_ACTOR_TRANSFORM }, - { 38u, 0u, &FopRead_ACTOR_MATERIAL }, - { 39u, 0u, &FopRead_ACTOR_LIGHT }, - { 40u, 0u, &FopRead_ACTOR_CAMERA }, - { 41u, 0u, &FopRead_ACTOR_BOUNDS }, - { 55u, 0u, &FopRead_ACTOR_CLIP_PLANE }, - { 42u, 0u, &FopRead_ACTOR_ADD_CHILD }, - { 43u, 0u, &FopRead_TRANSFORM }, - { 44u, 0u, &FopRead_TRANSFORM }, - { 45u, 0u, &FopRead_TRANSFORM }, - { 46u, 0u, &FopRead_TRANSFORM }, - { 47u, 0u, &FopRead_TRANSFORM }, - { 48u, 0u, &FopRead_TRANSFORM }, - { 49u, 0u, &FopRead_TRANSFORM }, - { 50u, 0u, &FopRead_BOUNDS }, - { 51u, 0u, &FopRead_LIGHT }, - { 52u, 0u, &FopRead_CAMERA }, - { 56u, 0u, &FopRead_PLANE } + { CHUNKID_END, 0u, FopRead_END }, + { CHUNKID_ACTOR, 0u, FopRead_ACTOR }, + { CHUNKID_ACTOR_MODEL, 0u, FopRead_ACTOR_MODEL }, + { CHUNKID_ACTOR_TRANSFORM, 0u, FopRead_ACTOR_TRANSFORM }, + { CHUNKID_ACTOR_MATERIAL, 0u, FopRead_ACTOR_MATERIAL }, + { CHUNKID_ACTOR_LIGHT, 0u, FopRead_ACTOR_LIGHT }, + { CHUNKID_ACTOR_CAMERA, 0u, FopRead_ACTOR_CAMERA }, + { CHUNKID_ACTOR_BOUNDS, 0u, FopRead_ACTOR_BOUNDS }, + { CHUNKID_ACTOR_CLIP_PLANE, 0u, FopRead_ACTOR_CLIP_PLANE }, + { CHUNKID_ACTOR_ADD_CHILD, 0u, FopRead_ACTOR_ADD_CHILD }, + { CHUNKID_TRANSFORM_MAT34, 0u, FopRead_TRANSFORM }, + { CHUNKID_TRANSFORM_MAT34_LP, 0u, FopRead_TRANSFORM }, + { CHUNKID_TRANSFORM_QUAT, 0u, FopRead_TRANSFORM }, + { CHUNKID_TRANSFORM_EULER, 0u, FopRead_TRANSFORM }, + { CHUNKID_TRANSFORM_LOOK_UP, 0u, FopRead_TRANSFORM }, + { CHUNKID_TRANSFORM_TRANSLATION, 0u, FopRead_TRANSFORM }, + { CHUNKID_TRANSFORM_IDENTITY, 0u, FopRead_TRANSFORM }, + { CHUNKID_BOUNDS, 0u, FopRead_BOUNDS }, + { CHUNKID_LIGHT, 0u, FopRead_LIGHT }, + { CHUNKID_CAMERA, 0u, FopRead_CAMERA }, + { CHUNKID_PLANE, 0u, FopRead_PLANE }, }; -br_chunks_table ActorLoadTable = { 21, ActorLoadEntries }; +br_chunks_table ActorLoadTable = { BR_ASIZE(ActorLoadEntries), ActorLoadEntries }; -struct { - br_uint_32 id; - size_t offset; - int table; -} MaterialMaps[4] = { - { 28u, offsetof(br_material, colour_map), 0 }, - { 30u, offsetof(br_material, index_blend), 1 }, - { 31u, offsetof(br_material, index_shade), 1 }, - { 32u, offsetof(br_material, screendoor), 1 } +br_chunks_table_entry MaterialLoadEntries[8] = { + { CHUNKID_END, 0u, FopRead_END }, + { CHUNKID_MATERIAL_OLD, 0u, FopRead_MATERIAL_OLD }, + { CHUNKID_MATERIAL_COLOUR_MAP, 0u, FopRead_PIXELMAP_REF }, + { CHUNKID_MATERIAL_INDEX_BLEND, 0u, FopRead_PIXELMAP_REF }, + { CHUNKID_MATERIAL_INDEX_SHADE, 0u, FopRead_PIXELMAP_REF }, + { CHUNKID_MATERIAL_SCREENDOOR, 0u, FopRead_PIXELMAP_REF }, + { CHUNKID_MATERIAL_INDEX_FOG, 0u, FopRead_PIXELMAP_REF }, + { CHUNKID_MATERIAL, 0u, FopRead_MATERIAL }, }; - -// Added by Jeff. -#define DF_MATERIAL 3 -#define DF_ACTOR 4 -#define DF_MATERIAL_INDEX 5 -#define DF_MODEL 8 -#define DF_TRANSFORM 16 -#define DF_BOUNDS 19 +br_chunks_table MaterialLoadTable = { BR_ASIZE(MaterialLoadEntries), MaterialLoadEntries }; // IDA: int __usercall FopWrite_VERTICES@(br_datafile *df@, br_vertex *vertices@, int nvertices@) int FopWrite_VERTICES(br_datafile* df, br_vertex* vertices, int nvertices) { LOG_TRACE("(%p, %p, %d)", df, vertices, nvertices); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_MODEL_VERTICES, df->prims->struct_size(df, &br_vertex_F, NULL) * nvertices + df->prims->count_size(df)); + df->prims->count_write(df, nvertices); + DfStructWriteArray(df, &br_vertex_F, vertices, nvertices); } // IDA: int __usercall FopRead_VERTICES@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -247,7 +380,10 @@ int FopRead_OLD_VERTICES(br_datafile* df, br_uint_32 id, br_uint_32 length, br_u // IDA: int __usercall FopWrite_VERTEX_UV@(br_datafile *df@, br_vertex *vertices@, int nvertices@) int FopWrite_VERTEX_UV(br_datafile* df, br_vertex* vertices, int nvertices) { LOG_TRACE("(%p, %p, %d)", df, vertices, nvertices); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_MODEL_VERTEX_UV, df->prims->struct_size(df, &br_vertex_uv_F, NULL) * nvertices + df->prims->count_size(df)); + df->prims->count_write(df, nvertices); + DfStructWriteArray(df, &br_vertex_uv_F, vertices, nvertices); } // IDA: int __usercall FopRead_VERTEX_UV@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -267,7 +403,11 @@ int FopRead_VERTEX_UV(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint int FopRead_OLD_VERTICES_UV(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 count) { void* ptr; LOG_TRACE("(%p, %d, %d, %d)", df, id, length, count); - NOT_IMPLEMENTED(); + + count = length / df->prims->struct_size(df, &br_old_vertex_uv_F, NULL); + ptr = BrResAllocate(v1db.res, count * sizeof(br_vertex), BR_MEMORY_VERTICES); + DfStructReadArray(df, &br_old_vertex_uv_F, ptr, count); + DfPush(DF_VERTEX, ptr, count); } // IDA: int __usercall FopRead_MATERIAL_INDEX@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -292,7 +432,16 @@ int FopWrite_MATERIAL_INDEX(br_datafile* df, br_material** materials, int nmater int i; int s; LOG_TRACE("(%p, %p, %d)", df, materials, nmaterials); - NOT_IMPLEMENTED(); + + s = df->prims->count_size(df); + for (i = 0; i < nmaterials; i++) { + s += df->prims->name_size(df, materials[i]->identifier); + } + df->prims->chunk_write(df, CHUNKID_MATERIAL_INDEX, s); + df->prims->count_write(df, nmaterials); + for (i = 0; i < nmaterials; i++) { + df->prims->name_write(df, materials[i]->identifier); + } } // IDA: int __usercall FopRead_OLD_MATERIAL_INDEX@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -303,7 +452,30 @@ int FopRead_OLD_MATERIAL_INDEX(br_datafile* df, br_uint_32 id, br_uint_32 length int num_materials; br_material** mip; LOG_TRACE("(%p, %d, %d, %d)", df, id, length, count); - NOT_IMPLEMENTED(); + + mblock = BrScratchAllocate(length); + if (BrFileRead(mblock, 1, length, df->h) != length) { + BrFailure("could not read material index"); + } + num_materials = 0; + cp = mblock; + for (i = 0; i < length; i++) { + if (*cp == '\0') { + num_materials++; + } + cp++; + } + mip = BrResAllocate(v1db.res, num_materials * sizeof(br_material*), BR_MEMORY_MATERIAL_INDEX); + cp = mblock; + for (i = 0; i < length; i++) { + *mip = BrMaterialFind(*cp); + while (*cp != '\0') { + cp++; + } + } + BrScratchFree(mblock); + DfPush(DF_MATERIAL_INDEX, mip, count); + return 0; } // IDA: int __usercall FopRead_FACES@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -321,14 +493,17 @@ int FopRead_FACES(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 } mp->faces[i].index = i; } - return 0; } // IDA: int __usercall FopWrite_FACES@(br_datafile *df@, br_face *faces@, int nfaces@) int FopWrite_FACES(br_datafile* df, br_face* faces, int nfaces) { LOG_TRACE("(%p, %p, %d)", df, faces, nfaces); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_MODEL_FACES, df->prims->struct_size(df, &br_face_F, NULL) * nfaces + df->prims->count_size(df)); + df->prims->count_write(df, nfaces); + DfStructWriteArray(df, &br_face_F, faces, nfaces); + return 0; } // IDA: int __usercall FopRead_OLD_FACES_1@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -336,7 +511,19 @@ int FopRead_OLD_FACES_1(br_datafile* df, br_uint_32 id, br_uint_32 length, br_ui br_model* mp; int i; LOG_TRACE("(%p, %d, %d, %d)", df, id, length, count); - NOT_IMPLEMENTED(); + + mp = DfTop(DF_MODEL, NULL); + mp->faces = BrResAllocate(mp, count * sizeof(br_face), BR_MEMORY_FACES); + mp->nfaces = count; + DfStructReadArray(df, &br_old_face_1_F, mp->faces, (br_uint_16)count); + for (i = 0; i < mp->nfaces; i++) { + if (mp->faces[i].smoothing == 0) { + mp->faces[i].smoothing = -1; + } else { + mp->faces[i].smoothing = 1 << ((mp->faces[i].smoothing - 1) % 16); + } + } + return 0; } // IDA: int __usercall FopRead_OLD_FACES@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -347,7 +534,22 @@ int FopRead_OLD_FACES(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint unsigned int i; void* ptr; LOG_TRACE("(%p, %d, %d, %d)", df, id, length, count); - NOT_IMPLEMENTED(); + + ptr = DfPop(DF_VERTEX, (int*)&i); + mip = DfPop(DF_MATERIAL_INDEX, &mi_count); + DfPush(DF_VERTEX, ptr, i); + mi_count = length / df->prims->struct_size(df, &br_old_face_F, NULL); + fp = BrResAllocate(v1db.res, sizeof(br_face) * mi_count, BR_MEMORY_FACES); + DfStructReadArray(df, &br_old_face_F, fp, mi_count); + for (i = 0; i < mi_count; i++) { + fp[i].material = mip[*(br_uint_16*)&fp[i].material]; + if (fp[i].smoothing == 0) { + fp[i].smoothing = -1; + } + } + BrResFree(mip); + DfPush(DF_FACE, fp, mi_count); + return 0; } // IDA: int __usercall FopWrite_FACE_MATERIAL@(br_datafile *df@, br_face *faces@, int nfaces@, br_material **mindex@, int nmaterials) @@ -358,7 +560,24 @@ int FopWrite_FACE_MATERIAL(br_datafile* df, br_face* faces, int nfaces, br_mater int i; int j; LOG_TRACE("(%p, %p, %d, %p, %d)", df, faces, nfaces, mindex, nmaterials); - NOT_IMPLEMENTED(); + + FopWrite_MATERIAL_INDEX(df, mindex, nmaterials); + block = BrResAllocate(v1db.res, nfaces * sizeof(br_uint_16), BR_MEMORY_MATERIAL_INDEX); + for (i = 0; i < nfaces; i++) { + block[i] = 0; + if (faces[i].material != NULL) { + for (j = 0; j < nmaterials; j++) { + if (faces[i].material == mindex[j]) { + block[i] = j + 1; + break; + } + } + } + } + df->prims->chunk_write(df, CHUNKID_MODEL_FACE_MATERIAL, df->prims->block_size(df, block, nfaces, 0, 1, sizeof(br_uint_16))); + df->prims->block_write(df, block, nfaces, 0, 1, sizeof(br_uint_16)); + BrResFree(block); + return 0; } // IDA: int __usercall FopRead_FACE_MATERIAL@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -415,14 +634,23 @@ int FopRead_MODEL(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 int FopWrite_MODEL(br_datafile* df, br_model* mp) { br_model temp_model; LOG_TRACE("(%p, %p)", df, mp); - NOT_IMPLEMENTED(); + + memcpy(&temp_model, mp, sizeof(br_model)); + df->prims->chunk_write(df, CHUNKID_MODEL, df->prims->struct_size(df, &br_model_F, mp)); + df->prims->struct_write(df, &br_model_F, mp); + return 0; } // IDA: int __usercall FopRead_OLD_MODEL_1@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) int FopRead_OLD_MODEL_1(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 count) { br_model* mp; LOG_TRACE("(%p, %d, %d, %d)", df, id, length, count); - NOT_IMPLEMENTED(); + + mp = BrModelAllocate(NULL, 0, 0); + df->res = mp; + df->prims->struct_read(df, &br_old_model_1_F, mp); + DfPush(DF_MODEL, df->res, 1); + return 0; } // IDA: int __usercall FopRead_OLD_MODEL@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -430,14 +658,33 @@ int FopRead_OLD_MODEL(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint br_model* mp; int i; LOG_TRACE("(%p, %d, %d, %d)", df, id, length, count); - NOT_IMPLEMENTED(); + + mp = BrModelAllocate(NULL, 0, 0); + df->res = mp; + df->prims->struct_read(df, &br_model_F, mp); + df->res = NULL; + mp->faces = DfPop(DF_FACE, &i); + mp->nfaces = i; + mp->vertices = DfPop(DF_VERTEX, &i); + mp->nvertices = i; + BrResAdd(mp, mp->faces); + BrResAdd(mp, mp->vertices); + mp->flags = mp->flags & (BR_STATE_SURFACE | BR_STATE_MATRIX | BR_STATE_ENABLE | BR_STATE_CLIP); + DfPush(DF_MODEL, mp, 1); + return 0; } // IDA: int __usercall FopRead_PIVOT@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) int FopRead_PIVOT(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 count) { br_model* mp; LOG_TRACE("(%p, %d, %d, %d)", df, id, length, count); - NOT_IMPLEMENTED(); + + mp = DfPop(DF_MODEL, NULL); + df->res = mp; + df->prims->struct_read(df, &br_pivot_F, mp); + df->res = NULL; + DfPush(DF_MODEL, mp, 1); + return 0; } // IDA: int __usercall FopRead_MATERIAL_OLD@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -455,13 +702,22 @@ int FopRead_MATERIAL_OLD(br_datafile* df, br_uint_32 id, br_uint_32 length, br_u int FopRead_MATERIAL(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 count) { br_material* mp; LOG_TRACE("(%p, %d, %d, %d)", df, id, length, count); - NOT_IMPLEMENTED(); + + mp = BrMaterialAllocate(NULL); + df->res = mp; + df->prims->struct_read(df, &br_material_F, mp); + df->res = NULL; + DfPush(DF_MATERIAL, mp, 1); + return 0; } // IDA: int __usercall FopWrite_MATERIAL@(br_datafile *df@, br_material *mp@) int FopWrite_MATERIAL(br_datafile* df, br_material* mp) { LOG_TRACE("(%p, %p)", df, mp); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_MATERIAL, df->prims->struct_size(df, &br_material_F, mp)); + df->prims->struct_write(df,&br_material_F, mp); + return 0; } // IDA: int __usercall FopRead_PIXELMAP_REF@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -472,8 +728,7 @@ int FopRead_PIXELMAP_REF(br_datafile* df, br_uint_32 id, br_uint_32 length, br_u int i; LOG_TRACE9("(%p, %d, %d, %d)", df, id, length, count); - for (i = 0; i < 5; i++) { - + for (i = 0; i < BR_ASIZE(MaterialMaps); i++) { if (id == MaterialMaps[i].id) { break; } @@ -481,7 +736,7 @@ int FopRead_PIXELMAP_REF(br_datafile* df, br_uint_32 id, br_uint_32 length, br_u mp = DfTop(DF_MATERIAL, NULL); df->prims->name_read(df, name); - if (MaterialMaps[i].table) { + if (MaterialMaps[i].table != 0) { pm = BrTableFind(name); } else { pm = BrMapFind(name); @@ -493,13 +748,19 @@ int FopRead_PIXELMAP_REF(br_datafile* df, br_uint_32 id, br_uint_32 length, br_u // IDA: int __usercall FopWrite_PIXELMAP_REF@(br_datafile *df@, int id@, br_pixelmap *pixelmap@) int FopWrite_PIXELMAP_REF(br_datafile* df, int id, br_pixelmap* pixelmap) { LOG_TRACE("(%p, %d, %p)", df, id, pixelmap); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, id, df->prims->name_size(df, pixelmap->identifier)); + df->prims->name_write(df, pixelmap->identifier); + return 0; } // IDA: int __usercall FopWrite_ACTOR@(br_datafile *df@, br_actor *ap@) int FopWrite_ACTOR(br_datafile* df, br_actor* ap) { LOG_TRACE("(%p, %p)", df, ap); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_ACTOR, df->prims->struct_size(df, &br_actor_F, ap)); + df->prims->struct_write(df, &br_actor_F, ap); + return 0; } // IDA: int __usercall FopRead_ACTOR@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -519,7 +780,10 @@ int FopRead_ACTOR(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 // IDA: int __usercall FopWrite_ACTOR_MODEL@(br_datafile *df@, br_model *model@) int FopWrite_ACTOR_MODEL(br_datafile* df, br_model* model) { LOG_TRACE9("(%p, %p)", df, model); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_ACTOR_MODEL, df->prims->name_size(df, model->identifier)); + df->prims->name_write(df, model->identifier); + return 0; } // IDA: int __usercall FopRead_ACTOR_MODEL@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -537,7 +801,10 @@ int FopRead_ACTOR_MODEL(br_datafile* df, br_uint_32 id, br_uint_32 length, br_ui // IDA: int __usercall FopWrite_ACTOR_MATERIAL@(br_datafile *df@, br_material *material@) int FopWrite_ACTOR_MATERIAL(br_datafile* df, br_material* material) { LOG_TRACE("(%p, %p)", df, material); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_ACTOR_MATERIAL, df->prims->name_size(df, material->identifier)); + df->prims->name_write(df, material->identifier); + return 0; } // IDA: int __usercall FopRead_ACTOR_MATERIAL@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -545,6 +812,7 @@ int FopRead_ACTOR_MATERIAL(br_datafile* df, br_uint_32 id, br_uint_32 length, br char name[256]; br_actor* a; LOG_TRACE9("(%p, %d, %d, %d)", df, id, length, count); + a = DfTop(DF_ACTOR, NULL); df->prims->name_read(df, name); a->material = BrMaterialFind(name); @@ -554,7 +822,9 @@ int FopRead_ACTOR_MATERIAL(br_datafile* df, br_uint_32 id, br_uint_32 length, br // IDA: int __usercall FopWrite_ACTOR_TRANSFORM@(br_datafile *df@) int FopWrite_ACTOR_TRANSFORM(br_datafile* df) { LOG_TRACE("(%p)", df); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_ACTOR_TRANSFORM, 0); + return 0; } // IDA: int __usercall FopRead_ACTOR_TRANSFORM@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -573,7 +843,9 @@ int FopRead_ACTOR_TRANSFORM(br_datafile* df, br_uint_32 id, br_uint_32 length, b // IDA: int __usercall FopWrite_ACTOR_LIGHT@(br_datafile *df@) int FopWrite_ACTOR_LIGHT(br_datafile* df) { LOG_TRACE("(%p)", df); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_ACTOR_LIGHT, 0); + return 0; } // IDA: int __usercall FopRead_ACTOR_LIGHT@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -581,13 +853,19 @@ int FopRead_ACTOR_LIGHT(br_datafile* df, br_uint_32 id, br_uint_32 length, br_ui br_actor* a; br_light* lp; LOG_TRACE("(%p, %d, %d, %d)", df, id, length, count); - NOT_IMPLEMENTED(); + + lp = DfPop(DF_LIGHT, NULL); + a = DfTop(DF_ACTOR, NULL); + a->type_data = lp; + return 0; } // IDA: int __usercall FopWrite_ACTOR_CAMERA@(br_datafile *df@) int FopWrite_ACTOR_CAMERA(br_datafile* df) { LOG_TRACE("(%p)", df); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_ACTOR_CAMERA, 0); + return 0; } // IDA: int __usercall FopRead_ACTOR_CAMERA@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -595,13 +873,19 @@ int FopRead_ACTOR_CAMERA(br_datafile* df, br_uint_32 id, br_uint_32 length, br_u br_actor* a; br_light* cp; LOG_TRACE("(%p, %d, %d, %d)", df, id, length, count); - NOT_IMPLEMENTED(); + + cp = DfPop(DF_CAMERA, NULL); + a = DfTop(DF_ACTOR, NULL); + a->type_data = cp; + return 0; } // IDA: int __usercall FopWrite_ACTOR_BOUNDS@(br_datafile *df@) int FopWrite_ACTOR_BOUNDS(br_datafile* df) { LOG_TRACE("(%p)", df); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_ACTOR_BOUNDS, 0); + return 0; } // IDA: int __usercall FopRead_ACTOR_BOUNDS@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -619,7 +903,9 @@ int FopRead_ACTOR_BOUNDS(br_datafile* df, br_uint_32 id, br_uint_32 length, br_u // IDA: int __usercall FopWrite_ACTOR_CLIP_PLANE@(br_datafile *df@) int FopWrite_ACTOR_CLIP_PLANE(br_datafile* df) { LOG_TRACE("(%p)", df); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_ACTOR_CLIP_PLANE, 0); + return 0; } // IDA: int __usercall FopRead_ACTOR_CLIP_PLANE@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -627,13 +913,19 @@ int FopRead_ACTOR_CLIP_PLANE(br_datafile* df, br_uint_32 id, br_uint_32 length, br_actor* a; br_vector4* vp; LOG_TRACE("(%p, %d, %d, %d)", df, id, length, count); - NOT_IMPLEMENTED(); + + vp = DfPop(DF_CLIP_PLANE, NULL); + a = DfTop(DF_ACTOR, NULL); + a->type_data = vp; + return 0; } // IDA: int __usercall FopWrite_ACTOR_ADD_CHILD@(br_datafile *df@) int FopWrite_ACTOR_ADD_CHILD(br_datafile* df) { LOG_TRACE("(%p)", df); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_ACTOR_ADD_CHILD, 0); + return 0; } // IDA: int __usercall FopRead_ACTOR_ADD_CHILD@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -653,7 +945,16 @@ int FopRead_ACTOR_ADD_CHILD(br_datafile* df, br_uint_32 id, br_uint_32 length, b int FopWrite_TRANSFORM(br_datafile* df, br_transform* t) { transform_type* tt; LOG_TRACE("(%p, %p)", df, t); - NOT_IMPLEMENTED(); + + tt = &TransformTypes[t->type]; + if (tt->fs == NULL) { + df->prims->chunk_write(df, tt->id, 0); + } else { + df->prims->chunk_write(df, tt->id, df->prims->struct_size(df, tt->fs, t)); + df->prims->struct_size(df, tt->fs, &t); + df->prims->struct_write(df, tt->fs, t); + } + return 0; } // IDA: int __usercall FopRead_TRANSFORM@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -684,7 +985,10 @@ int FopRead_TRANSFORM(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint // IDA: int __usercall FopWrite_BOUNDS@(br_datafile *df@, br_bounds *bp@) int FopWrite_BOUNDS(br_datafile* df, br_bounds* bp) { LOG_TRACE("(%p, %p)", df, bp); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_BOUNDS, df->prims->struct_size(df, &br_bounds3_F, bp)); + df->prims->struct_write(df, &br_bounds3_F, bp); + return 0; } // IDA: int __usercall FopRead_BOUNDS@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) @@ -697,47 +1001,73 @@ int FopRead_BOUNDS(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 df->prims->struct_read(df, &br_bounds3_F, bp); df->res = NULL; DfPush(DF_BOUNDS, bp, 1); - return 0; } // IDA: int __usercall FopWrite_PLANE@(br_datafile *df@, br_vector4 *pp@) int FopWrite_PLANE(br_datafile* df, br_vector4* pp) { LOG_TRACE("(%p, %p)", df, pp); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_PLANE, df->prims->struct_size(df, &br_plane_F, pp)); + df->prims->struct_write(df, &br_plane_F, pp); + return 0; } // IDA: int __usercall FopRead_PLANE@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) int FopRead_PLANE(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 count) { br_vector4* pp; LOG_TRACE("(%p, %d, %d, %d)", df, id, length, count); - NOT_IMPLEMENTED(); + + pp = BrResAllocate(v1db.res, sizeof(br_vector4), BR_MEMORY_CLIP_PLANE); + df->res = pp; + df->prims->struct_read(df, &br_plane_F, pp); + df->res = NULL; + DfPush(DF_CLIP_PLANE, pp, 1); + return 0; } // IDA: int __usercall FopWrite_LIGHT@(br_datafile *df@, br_light *lp@) int FopWrite_LIGHT(br_datafile* df, br_light* lp) { LOG_TRACE("(%p, %p)", df, lp); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_LIGHT, df->prims->struct_size(df, &br_light_F, lp)); + df->prims->struct_write(df, &br_light_F, lp); + return 0; } // IDA: int __usercall FopRead_LIGHT@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) int FopRead_LIGHT(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 count) { br_light* lp; LOG_TRACE("(%p, %d, %d, %d)", df, id, length, count); - NOT_IMPLEMENTED(); + + lp = BrResAllocate(v1db.res, sizeof(br_light), BR_MEMORY_LIGHT); + df->res = lp; + df->prims->struct_read(df, &br_light_F, lp); + df->res = NULL; + DfPush(DF_LIGHT, lp, 1); + return 0; } // IDA: int __usercall FopWrite_CAMERA@(br_datafile *df@, br_camera *cp@) int FopWrite_CAMERA(br_datafile* df, br_camera* cp) { LOG_TRACE("(%p, %p)", df, cp); - NOT_IMPLEMENTED(); + + df->prims->chunk_write(df, CHUNKID_CAMERA, df->prims->struct_size(df, &br_camera_F, cp)); + df->prims->struct_write(df, &br_camera_F, cp); + return 0; } // IDA: int __usercall FopRead_CAMERA@(br_datafile *df@, br_uint_32 id@, br_uint_32 length@, br_uint_32 count@) int FopRead_CAMERA(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 count) { br_camera* cp; LOG_TRACE("(%p, %d, %d, %d)", df, id, length, count); - NOT_IMPLEMENTED(); + + cp = BrResAllocate(v1db.res, sizeof(br_camera), BR_MEMORY_CAMERA); + df->res = cp; + df->prims->struct_read(df, &br_camera_F, cp); + df->res = NULL; + DfPush(DF_CAMERA, cp, 1); + return 0; } // IDA: br_uint_32 __cdecl BrModelLoadMany(char *filename, br_model **models, br_uint_16 num) @@ -748,10 +1078,9 @@ br_uint_32 BrModelLoadMany(char* filename, br_model** models, br_uint_16 num) { LOG_TRACE9("(\"%s\", %p, %d)", filename, models, num); df = DfOpen(filename, 0, BRT_FLOAT); - if (!df) { + if (df == NULL) { return 0; } - count = 0; do { if (count >= num) { @@ -762,7 +1091,7 @@ br_uint_32 BrModelLoadMany(char* filename, br_model** models, br_uint_16 num) { models[count] = DfPop(DF_MODEL, 0); count++; } - } while (r); + } while (r != 0); DfClose(df); return count; } @@ -770,7 +1099,11 @@ br_uint_32 BrModelLoadMany(char* filename, br_model** models, br_uint_16 num) { // IDA: int __cdecl PtrCompare(void *a, void *b) int PtrCompare(void* a, void* b) { LOG_TRACE("(%p, %p)", a, b); - NOT_IMPLEMENTED(); + + if (*(uintptr_t*)a > *(uintptr_t*)b) { + return -1; + } + return *(uintptr_t*)a < *(uintptr_t*)b; } // IDA: br_uint_32 __cdecl WriteModel(br_model *mp, br_datafile *df) @@ -781,7 +1114,56 @@ br_uint_32 WriteModel(br_model* mp, br_datafile* df) { int i; int has_uv; LOG_TRACE("(%p, %p)", mp, df); - NOT_IMPLEMENTED(); + + nmaterials = 0; + if (mp->vertices == NULL || mp->faces == NULL) { + if (mp->identifier != NULL) { + BrWarning(mp->identifier); + } + BrWarning("Model must have vertex and face information to save."); + BrWarning("This information may have neem stripped on addition to"); + BrWarning("the registry. To prevent this, set the BR_MODF_UPDATEABLE"); + BrFailure("flag before adding the model to the registry."); + } + mindex = BrResAllocate(v1db.res, mp->nfaces * sizeof(br_material*), BR_MEMORY_MATERIAL_INDEX); + for (i = 0; i < mp->nfaces; i++) { + mindex[i] = mp->faces[i].material; + } + BrQsort(mindex, mp->nfaces, sizeof(br_material*), (br_qsort_cbfn*)PtrCompare); + nmaterials = 1; + for (i = 1; i < mp->nfaces; i++) { + if (mindex[nmaterials-1] == mindex[i]) { + mindex[nmaterials] = mindex[i]; + nmaterials++; + } + } + if (mindex[nmaterials-1] == NULL) { + nmaterials = 0; + } + has_uv = 0; + for (i = 0; i < mp->nvertices; i++) { + if (mp->vertices[i].map.v[0] != 0.f || mp->vertices[i].map.v[1] != 0.f) { + has_uv = 1; + break; + } + } + + FopWrite_MODEL(df, mp); + if (mp->nvertices != 0) { + FopWrite_VERTICES(df, mp->vertices, mp->nvertices); + if (has_uv != 0) { + FopWrite_VERTEX_UV(df, mp->vertices, mp->nvertices); + } + } + if (mp->nfaces != 0) { + FopWrite_FACES(df, mp->faces, mp->nfaces); + if (nmaterials != 0) { + FopWrite_FACE_MATERIAL(df, mp->faces, mp->nfaces, mindex, nmaterials); + } + } + FopWrite_END(df); + BrResFree(mindex); + return 0; } // IDA: br_uint_32 __cdecl BrModelSaveMany(char *filename, br_model **models, br_uint_16 num) @@ -790,7 +1172,23 @@ br_uint_32 BrModelSaveMany(char* filename, br_model** models, br_uint_16 num) { int i; int m; LOG_TRACE("(\"%s\", %p, %d)", filename, models, num); - NOT_IMPLEMENTED(); + + df = DfOpen(filename, 1, BRT_FLOAT); + if (df == NULL) { + return 0; + } + FopWrite_FILE_INFO(df, FILE_TYPE_MODEL); + if (models == NULL) { + BrModelEnum(NULL, (br_model_enum_cbfn*)&WriteModel, df); + m = BrModelCount(NULL); + } else { + for (i = 0; i < num; i++) { + WriteModel(models[i], df); + } + m = num; + } + DfClose(df); + return m; } // IDA: br_uint_32 __cdecl BrActorLoadMany(char *filename, br_actor **actors, br_uint_16 num) @@ -801,7 +1199,7 @@ br_uint_32 BrActorLoadMany(char* filename, br_actor** actors, br_uint_16 num) { LOG_TRACE9("(\"%s\", %p, %d)", filename, actors, num); df = DfOpen(filename, 0, BRT_FLOAT); - if (!df) { + if (df == NULL) { return 0; } @@ -815,7 +1213,7 @@ br_uint_32 BrActorLoadMany(char* filename, br_actor** actors, br_uint_16 num) { actors[count] = DfPop(DF_ACTOR, NULL); count++; } - } while (r); + } while (r != 0); DfClose(df); return count; } @@ -825,7 +1223,54 @@ int WriteActor(br_actor* a, br_datafile* df) { br_actor* ap; br_actor* last_ap; LOG_TRACE("(%p, %p)", a, df); - NOT_IMPLEMENTED(); + + FopWrite_ACTOR(df, a); + if (a->t.type != BR_TRANSFORM_IDENTITY) { + FopWrite_TRANSFORM(df, &a->t); + FopWrite_ACTOR_TRANSFORM(df); + } + if (a->material != NULL) { + FopWrite_ACTOR_MATERIAL(df, a->material); + } + if (a->model != NULL) { + FopWrite_ACTOR_MODEL(df, a->model); + } + if (a->type_data != NULL) { + switch (a->type) { + case BR_ACTOR_LIGHT: + FopWrite_LIGHT(df, a->type_data); + FopWrite_ACTOR_LIGHT(df); + break; + case BR_ACTOR_CAMERA: + FopWrite_CAMERA(df, a->type_data); + FopWrite_ACTOR_CAMERA(df); + break; + case BR_ACTOR_BOUNDS: + FopWrite_BOUNDS(df, a->type_data); + FopWrite_ACTOR_BOUNDS(df); + break; + case BR_ACTOR_CLIP_PLANE: + FopWrite_PLANE(df, a->type_data); + FopWrite_ACTOR_CLIP_PLANE(df); + break; + } + } + if (a->children != NULL){ + last_ap = a->children; + while (last_ap->next != NULL) { + last_ap = last_ap->next; + } + ap = last_ap; + while (1) { + WriteActor(ap, df); + FopWrite_ACTOR_ADD_CHILD(df); + if (a->children == ap) { + break; + } + ap = (br_actor*)ap->prev; + } + } + return 0; } // IDA: br_uint_32 __cdecl BrActorSaveMany(char *filename, br_actor **actors, br_uint_16 num) @@ -833,36 +1278,67 @@ br_uint_32 BrActorSaveMany(char* filename, br_actor** actors, br_uint_16 num) { br_datafile* df; int i; LOG_TRACE("(\"%s\", %p, %d)", filename, actors, num); - NOT_IMPLEMENTED(); + + df = DfOpen(filename, 1, BRT_FLOAT); + if (df == NULL) { + return 0; + } + FopWrite_FILE_INFO(df, FILE_TYPE_ACTORS); + for (i = 0; i < num; i++) { + WriteActor(actors[i], df); + FopWrite_END(df); + } + DfClose(df); + return num; } // IDA: br_uint_32 __cdecl BrMaterialLoadMany(char *filename, br_material **materials, br_uint_16 num) br_uint_32 BrMaterialLoadMany(char* filename, br_material** materials, br_uint_16 num) { br_datafile* df; - int count = 0; - int r = 0; + int count; + int r; df = DfOpen(filename, 0, BRT_FLOAT); - if (df) { - do { - if (count >= num) { - break; - } - r = DfChunksInterpret(df, &MaterialLoadTable); - if (DfTopType() == DF_MATERIAL) { - materials[count] = DfPop(DF_MATERIAL, 0); - ++count; - } - } while (r); - DfClose(df); + if (df == NULL) { + return 0; } + count = 0; + do { + if (count >= num) { + break; + } + r = DfChunksInterpret(df, &MaterialLoadTable); + if (DfTopType() == DF_MATERIAL) { + materials[count] = DfPop(DF_MATERIAL, 0); + ++count; + } + } while (r != 0); + DfClose(df); return count; } // IDA: br_uint_32 __cdecl WriteMaterial(br_material *mp, br_datafile *df) br_uint_32 WriteMaterial(br_material* mp, br_datafile* df) { LOG_TRACE("(%p, %p)", mp, df); - NOT_IMPLEMENTED(); + + FopWrite_MATERIAL(df, mp); + if (mp->colour_map != NULL) { + FopWrite_PIXELMAP_REF(df, CHUNKID_MATERIAL_COLOUR_MAP, mp->colour_map); + } + if (mp->index_shade != NULL) { + FopWrite_PIXELMAP_REF(df, CHUNKID_MATERIAL_INDEX_SHADE, mp->index_shade); + } + if (mp->index_blend != NULL) { + FopWrite_PIXELMAP_REF(df, CHUNKID_MATERIAL_INDEX_BLEND, mp->index_blend); + } + if (mp->screendoor != NULL) { + FopWrite_PIXELMAP_REF(df, CHUNKID_MATERIAL_SCREENDOOR, mp->screendoor); + } + if (mp->index_fog != NULL) { + FopWrite_PIXELMAP_REF(df, CHUNKID_MATERIAL_INDEX_FOG, mp->index_fog); + } + FopWrite_END(df); + return 0; } // IDA: br_uint_32 __cdecl BrMaterialSaveMany(char *filename, br_material **materials, br_uint_16 num) @@ -871,7 +1347,27 @@ br_uint_32 BrMaterialSaveMany(char* filename, br_material** materials, br_uint_1 int i; int count; LOG_TRACE("(\"%s\", %p, %d)", filename, materials, num); - NOT_IMPLEMENTED(); + + df = DfOpen(filename, 1, BRT_FLOAT); + if (df == NULL) { + return 0; + } +#ifdef BRENDER_FIX_BUGS + FopWrite_FILE_INFO(df, FILE_TYPE_MATERIAL); +#else + FopWrite_FILE_INFO(df, FILE_TYPE_MATERIAL_OLD); +#endif + if (materials == NULL) { + BrMaterialEnum(NULL, (br_material_enum_cbfn*)WriteMaterial, df); + count = BrMaterialCount(NULL); + } else { + for (i = 0; i < num; i++) { + WriteMaterial(materials[i], df); + } + count = num; + } + DfClose(df); + return count; } // IDA: br_model* __cdecl BrModelLoad(char *filename) @@ -879,7 +1375,7 @@ br_model* BrModelLoad(char* filename) { br_model* ptr; LOG_TRACE("(\"%s\")", filename); - if (BrModelLoadMany(filename, &ptr, 1u) == 1) { + if (BrModelLoadMany(filename, &ptr, 1) == 1) { return ptr; } return NULL; @@ -888,12 +1384,14 @@ br_model* BrModelLoad(char* filename) { // IDA: br_uint_32 __cdecl BrModelSave(char *filename, br_model *ptr) br_uint_32 BrModelSave(char* filename, br_model* ptr) { LOG_TRACE("(\"%s\", %p)", filename, ptr); - NOT_IMPLEMENTED(); + + return BrModelSaveMany(filename, &ptr, 1); } // IDA: br_material* __cdecl BrMaterialLoad(char *filename) br_material* BrMaterialLoad(char* filename) { br_material* ptr; + if (BrMaterialLoadMany(filename, &ptr, 1) == 1) { return ptr; } @@ -903,15 +1401,16 @@ br_material* BrMaterialLoad(char* filename) { // IDA: br_uint_32 __cdecl BrMaterialSave(char *filename, br_material *ptr) br_uint_32 BrMaterialSave(char* filename, br_material* ptr) { LOG_TRACE("(\"%s\", %p)", filename, ptr); - NOT_IMPLEMENTED(); + + return BrMaterialSaveMany(filename, &ptr, 1); } // IDA: br_actor* __cdecl BrActorLoad(char *filename) br_actor* BrActorLoad(char* filename) { + br_actor* ptr; LOG_TRACE("(\"%s\")", filename); - br_actor* ptr; - if (BrActorLoadMany(filename, &ptr, 1u) == 1) { + if (BrActorLoadMany(filename, &ptr, 1) == 1) { return ptr; } LOG_DEBUG("loadmany fail"); @@ -921,26 +1420,84 @@ br_actor* BrActorLoad(char* filename) { // IDA: br_uint_32 __cdecl BrActorSave(char *filename, br_actor *ptr) br_uint_32 BrActorSave(char* filename, br_actor* ptr) { LOG_TRACE("(\"%s\", %p)", filename, ptr); - NOT_IMPLEMENTED(); + + return BrActorSaveMany(filename, &ptr, 1); } // IDA: br_error __cdecl BrModelFileCount(char *filename, br_uint_16 *num) br_error BrModelFileCount(char* filename, br_uint_16* num) { br_datafile* df; LOG_TRACE("(\"%s\", %p)", filename, num); - NOT_IMPLEMENTED(); + + df = DfOpen(filename, 0, BRT_FLOAT); + if (df == NULL) { + if (num != NULL) { + *num = 0; + } + return 0x1002; + } + if (num == NULL) { + return 0; + } + *num = 0; + while (DfChunksInterpret(df, &ModelLoadTable) != 0) { + if (DfTopType() == DF_MODEL) { + *num = *num + 1; + DfPop(DF_MODEL, NULL); + } + } + DfClose(df); + return 0; } // IDA: br_error __cdecl BrActorFileCount(char *filename, br_uint_16 *num) br_error BrActorFileCount(char* filename, br_uint_16* num) { br_datafile* df; LOG_TRACE("(\"%s\", %p)", filename, num); - NOT_IMPLEMENTED(); + + df = DfOpen(filename, 0, BRT_FLOAT); + if (df == NULL) { + if (num != NULL) { + *num = 0; + } + return 0x1002; + } + if (num == NULL) { + return 0; + } + *num = 0; + while (DfChunksInterpret(df, &ActorLoadTable) != 0) { + if (DfTopType() == DF_ACTOR) { + *num = *num + 1; + DfPop(DF_ACTOR, NULL); + } + } + DfClose(df); + return 0; } // IDA: br_error __cdecl BrMaterialFileCount(char *filename, br_uint_16 *num) br_error BrMaterialFileCount(char* filename, br_uint_16* num) { br_datafile* df; LOG_TRACE("(\"%s\", %p)", filename, num); - NOT_IMPLEMENTED(); + + df = DfOpen(filename, 0, BRT_FLOAT); + if (df == NULL) { + if (num != NULL) { + *num = 0; + } + return 0x1002; + } + if (num == NULL) { + return 0; + } + *num = 0; + while (DfChunksInterpret(df, &MaterialLoadTable) != 0) { + if (DfTopType() == DF_MATERIAL) { + *num = *num + 1; + DfPop(DF_MATERIAL, NULL); + } + } + DfClose(df); + return 0; } diff --git a/src/BRSRC13/CORE/V1DB/v1dbfile.h b/src/BRSRC13/CORE/V1DB/v1dbfile.h index 284e633d..1fd75a83 100644 --- a/src/BRSRC13/CORE/V1DB/v1dbfile.h +++ b/src/BRSRC13/CORE/V1DB/v1dbfile.h @@ -3,6 +3,7 @@ #include "brender/br_types.h" + int FopWrite_VERTICES(br_datafile* df, br_vertex* vertices, int nvertices); int FopRead_VERTICES(br_datafile* df, br_uint_32 id, br_uint_32 length, br_uint_32 count); diff --git a/test/BRSRC13/test_pmfile.c b/test/BRSRC13/test_pmfile.c index 163dcb9b..17d57582 100644 --- a/test/BRSRC13/test_pmfile.c +++ b/test/BRSRC13/test_pmfile.c @@ -1,8 +1,544 @@ #include "tests.h" +#include "CORE/FW/datafile.h" +#include "CORE/FW/resource.h" +#include "CORE/PIXELMAP/pixelmap.h" #include "CORE/PIXELMAP/pmfile.h" -void test_pmfile_BrPixelmapLoad() { +uint8_t binary_pixelmap_lone[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x1a, + 0x08, 0x00, 0x20, 0x00, 0x08, 0x00, 0x04, 0x00, 0x04, 0x00, 0x05, 0x00, + 0x00, 0x74, 0x65, 0x73, 0x74, 0x20, 0x70, 0x69, 0x78, 0x65, 0x6c, 0x6d, + 0x61, 0x70, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x88, 0x00, + 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x01, 0x00, 0x02, 0x00, 0x02, 0x00, 0x03, 0x00, 0x03, 0x00, + 0x04, 0x00, 0x04, 0x00, 0x05, 0x00, 0x05, 0x00, 0x06, 0x00, 0x06, 0x00, + 0x07, 0x00, 0x07, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, + 0x02, 0x01, 0x03, 0x03, 0x03, 0x01, 0x04, 0x04, 0x04, 0x01, 0x05, 0x05, + 0x05, 0x01, 0x06, 0x06, 0x06, 0x01, 0x07, 0x07, 0x07, 0x01, 0x08, 0x00, + 0x00, 0x02, 0x02, 0x02, 0x01, 0x02, 0x03, 0x04, 0x02, 0x02, 0x04, 0x06, + 0x03, 0x02, 0x05, 0x08, 0x04, 0x02, 0x06, 0x0a, 0x05, 0x02, 0x07, 0x0c, + 0x06, 0x02, 0x08, 0x0e, 0x07, 0x02, 0x09, 0x00, 0x00, 0x03, 0x03, 0x03, + 0x01, 0x03, 0x04, 0x06, 0x02, 0x03, 0x05, 0x09, 0x03, 0x03, 0x06, 0x0c, + 0x04, 0x03, 0x07, 0x0f, 0x05, 0x03, 0x08, 0x12, 0x06, 0x03, 0x09, 0x15, + 0x07, 0x03, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; +char *text_pixelmap_lone = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_PIXELMAP # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*PIXELMAP 9" HOST_NL + " struct br_pixelmap" HOST_NL + " enum_8 BR_PMT_RGBA_8888 # type" HOST_NL + " uint_16 32 # row_bytes" HOST_NL + " uint_16 8 # width" HOST_NL + " uint_16 4 # height" HOST_NL + " uint_16 4 # origin_x" HOST_NL + " uint_16 5 # origin_y" HOST_NL + " uint_16 0 # mip_offset" HOST_NL + " asciz \"test pixelmap\" # identifier" HOST_NL + "*PIXELS 6" HOST_NL + " block 32" HOST_NL + " size 4" HOST_NL + " 00000000: 0000000000010001000200020003000300040004000500050006000600070007" HOST_NL + " 00000020: 0000010101010102020201030303010404040105050501060606010707070108" HOST_NL + " 00000040: 00000202020102030402020406030205080402060a0502070c0602080e070209" HOST_NL + " 00000060: 000003030301030406020305090303060c0403070f050308120603091507030a" HOST_NL + "*END 0" HOST_NL; +static void test_pmfile_save_load_pixelmap_lone() { + br_pixelmap *pixelmap_ref; + int res; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + br_colour *rgb_pixels; + br_pixelmap* pixelmaps_read[2]; + int i; + int j; + + pixelmap_ref = BrPixelmapAllocate(BR_PMT_RGBA_8888, 8, 4, NULL, BR_PMAF_NORMAL); + pixelmap_ref->identifier = BrResStrDup(pixelmap_ref, "test pixelmap"); + pixelmap_ref->origin_x = 4; + pixelmap_ref->origin_y = 5; + + // Don't use BrPixelmapPixelSet to avoid dependencies + rgb_pixels = pixelmap_ref->pixels; + for (j = 0; j < pixelmap_ref->height; j++) { + for (i = 0; i < pixelmap_ref->width; i++) { + rgb_pixels[j*pixelmap_ref->width+i] = BR_COLOUR_RGBA(i, j, i+j, i*j); + } + } + + create_temp_file(tmpfilename_binary, "pixelmap_lone_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrPixelmapSave(tmpfilename_binary, pixelmap_ref); + TEST_ASSERT_EQUAL_INT32(1, res); + + create_temp_file(tmpfilename_text, "pixelmap_lone_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrPixelmapSave(tmpfilename_text, pixelmap_ref); + TEST_ASSERT_EQUAL_INT32(1, res); + + LOG_DEBUG("Read binary pixelmap"); + pixelmaps_read[0] = BrPixelmapLoad(tmpfilename_binary); + LOG_DEBUG("Read text pixelmap"); + pixelmaps_read[1] = BrPixelmapLoad(tmpfilename_text); + + for (i = 0; i < BR_ASIZE(pixelmaps_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_ASSERT_NOT_NULL(pixelmaps_read[i]); + TEST_ASSERT_EQUAL_STRING(pixelmap_ref->identifier, pixelmaps_read[i]->identifier); + TEST_ASSERT_EQUAL_UINT16(pixelmap_ref->width, pixelmaps_read[i]->width); + TEST_ASSERT_EQUAL_UINT16(pixelmap_ref->height, pixelmaps_read[i]->height); + TEST_ASSERT_EQUAL_UINT16(pixelmap_ref->origin_x, pixelmaps_read[i]->origin_x); + TEST_ASSERT_EQUAL_UINT16(pixelmap_ref->origin_y, pixelmaps_read[i]->origin_y); + TEST_ASSERT_EQUAL_UINT32(pixelmap_ref->origin_y, pixelmaps_read[i]->origin_y); + TEST_ASSERT_EQUAL_UINT32(pixelmap_ref->mip_offset, pixelmaps_read[i]->mip_offset); + TEST_ASSERT_EQUAL_UINT8(pixelmap_ref->type, pixelmaps_read[i]->type); + TEST_ASSERT_NULL(pixelmaps_read[i]->map); + + TEST_ASSERT_EQUAL_UINT32_ARRAY(pixelmap_ref->pixels, pixelmaps_read[i]->pixels, pixelmap_ref->width * pixelmap_ref->height); + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_pixelmap_lone, tmpfilename_binary, sizeof(binary_pixelmap_lone)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_pixelmap_lone, tmpfilename_text); + + BrResFree(pixelmaps_read[0]); + BrResFree(pixelmaps_read[1]); +} + +uint8_t binary_pixelmap_mapped[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x21, + 0x03, 0x00, 0x08, 0x00, 0x08, 0x00, 0x04, 0x00, 0x04, 0x00, 0x05, 0x00, + 0x00, 0x74, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x61, 0x70, 0x70, 0x65, 0x64, + 0x20, 0x70, 0x69, 0x78, 0x65, 0x6c, 0x6d, 0x61, 0x70, 0x00, 0x00, 0x00, + 0x00, 0x3d, 0x00, 0x00, 0x00, 0x15, 0x07, 0x00, 0x40, 0x00, 0x10, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6e, 0x69, 0x63, 0x65, 0x20, + 0x6d, 0x61, 0x70, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x48, + 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x01, 0x01, 0x00, 0x02, 0x02, 0x02, 0x00, 0x03, 0x03, 0x03, + 0x00, 0x04, 0x04, 0x04, 0x00, 0x05, 0x05, 0x05, 0x00, 0x06, 0x06, 0x06, + 0x00, 0x07, 0x07, 0x07, 0x00, 0x08, 0x08, 0x08, 0x00, 0x09, 0x09, 0x09, + 0x00, 0x0a, 0x0a, 0x0a, 0x00, 0x0b, 0x0b, 0x0b, 0x00, 0x0c, 0x0c, 0x0c, + 0x00, 0x0d, 0x0d, 0x0d, 0x00, 0x0e, 0x0e, 0x0e, 0x00, 0x0f, 0x0f, 0x0f, + 0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, + 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x12, 0x13, + 0x14, 0x15, 0x16, 0x17, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, +}; +char *text_pixelmap_mapped = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_PIXELMAP # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*PIXELMAP 9" HOST_NL + " struct br_pixelmap" HOST_NL + " enum_8 BR_PMT_INDEX_8 # type" HOST_NL + " uint_16 8 # row_bytes" HOST_NL + " uint_16 8 # width" HOST_NL + " uint_16 4 # height" HOST_NL + " uint_16 4 # origin_x" HOST_NL + " uint_16 5 # origin_y" HOST_NL + " uint_16 0 # mip_offset" HOST_NL + " asciz \"test mapped pixelmap\" # identifier" HOST_NL + "*PIXELMAP 9" HOST_NL + " struct br_pixelmap" HOST_NL + " enum_8 BR_PMT_RGBX_888 # type" HOST_NL + " uint_16 64 # row_bytes" HOST_NL + " uint_16 16 # width" HOST_NL + " uint_16 1 # height" HOST_NL + " uint_16 0 # origin_x" HOST_NL + " uint_16 0 # origin_y" HOST_NL + " uint_16 0 # mip_offset" HOST_NL + " asciz \"nice map\" # identifier" HOST_NL + "*PIXELS 4" HOST_NL + " block 16" HOST_NL + " size 4" HOST_NL + " 00000000: 0000000000010101000202020003030300040404000505050006060600070707" HOST_NL + " 00000020: 0008080800090909000a0a0a000b0b0b000c0c0c000d0d0d000e0e0e000f0f0f" HOST_NL + "*ADD_MAP 0" HOST_NL + "*PIXELS 3" HOST_NL + " block 32" HOST_NL + " size 1" HOST_NL + " 00000000: 0001020304050607101112131415161720212223242526273031323334353637" HOST_NL + "*END 0" HOST_NL; +static void test_pmfile_save_load_pixelmap_mapped() { + br_pixelmap *pixelmap_ref; + br_pixelmap *map_ref; + int res; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + br_colour *rgb_pixels; + br_uint_8 *indices; + br_pixelmap* pixelmaps_read[2]; + int i; + int j; + + pixelmap_ref = BrPixelmapAllocate(BR_PMT_INDEX_8, 8, 4, NULL, BR_PMAF_NORMAL); + pixelmap_ref->identifier = BrResStrDup(pixelmap_ref, "test mapped pixelmap"); + pixelmap_ref->origin_x = 4; + pixelmap_ref->origin_y = 5; + map_ref = BrPixelmapAllocate(BR_PMT_RGBX_888, 16, 1, NULL, BR_PMAF_NORMAL); + BrResAdd(pixelmap_ref, map_ref); + pixelmap_ref->map = map_ref; + pixelmap_ref->map->identifier = BrResStrDup(pixelmap_ref->map, "nice map"); + + // Don't use BrPixelmapPixelSet to avoid dependencies + indices = pixelmap_ref->pixels; + for (j = 0; j < pixelmap_ref->height; j++) { + for (i = 0; i < pixelmap_ref->width; i++) { + indices[j*pixelmap_ref->width+i] = j * 16 + i; + } + } + + // Don't use BrPixelmapPixelSet to avoid dependencies + rgb_pixels = map_ref->pixels; + for (i = 0; i < map_ref->width; i++) { + rgb_pixels[i] = BR_COLOUR_RGBA(i, i, i, 0); + } + + create_temp_file(tmpfilename_binary, "pixelmap_map_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrPixelmapSave(tmpfilename_binary, pixelmap_ref); + TEST_ASSERT_EQUAL_INT32(1, res); + + create_temp_file(tmpfilename_text, "pixelmap_map_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrPixelmapSave(tmpfilename_text, pixelmap_ref); + TEST_ASSERT_EQUAL_INT32(1, res); + + LOG_DEBUG("Read binary pixelmap"); + pixelmaps_read[0] = BrPixelmapLoad(tmpfilename_binary); + LOG_DEBUG("Read text pixelmap"); + pixelmaps_read[1] = BrPixelmapLoad(tmpfilename_text); + + for (i = 0; i < BR_ASIZE(pixelmaps_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_ASSERT_NOT_NULL(pixelmaps_read[i]); + TEST_ASSERT_EQUAL_STRING(pixelmap_ref->identifier, pixelmaps_read[i]->identifier); + TEST_ASSERT_EQUAL_UINT16(pixelmap_ref->width, pixelmaps_read[i]->width); + TEST_ASSERT_EQUAL_UINT16(pixelmap_ref->height, pixelmaps_read[i]->height); + TEST_ASSERT_EQUAL_UINT16(pixelmap_ref->origin_x, pixelmaps_read[i]->origin_x); + TEST_ASSERT_EQUAL_UINT16(pixelmap_ref->origin_y, pixelmaps_read[i]->origin_y); + TEST_ASSERT_EQUAL_UINT32(pixelmap_ref->origin_y, pixelmaps_read[i]->origin_y); + TEST_ASSERT_EQUAL_UINT32(pixelmap_ref->mip_offset, pixelmaps_read[i]->mip_offset); + TEST_ASSERT_EQUAL_UINT8(pixelmap_ref->type, pixelmaps_read[i]->type); + + TEST_ASSERT_EQUAL_UINT8_ARRAY(pixelmap_ref->pixels, pixelmaps_read[i]->pixels, pixelmap_ref->width * pixelmap_ref->height); + TEST_ASSERT_EQUAL_UINT32_ARRAY(pixelmap_ref->map->pixels, pixelmaps_read[i]->map->pixels, pixelmap_ref->map->width * pixelmap_ref->map->height); + } + + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_pixelmap_mapped, tmpfilename_binary, sizeof(binary_pixelmap_mapped)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_pixelmap_mapped, tmpfilename_text); + + BrResFree(pixelmaps_read[0]); + BrResFree(pixelmaps_read[1]); + BrResFree(pixelmap_ref); +} + +uint8_t binary_pixelmap_mip[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x21, + 0x03, 0x00, 0x08, 0x00, 0x08, 0x00, 0x08, 0x00, 0x04, 0x00, 0x05, 0x00, + 0x01, 0x74, 0x65, 0x73, 0x74, 0x20, 0x6d, 0x69, 0x70, 0x70, 0x65, 0x64, + 0x20, 0x70, 0x69, 0x78, 0x65, 0x6c, 0x6d, 0x61, 0x70, 0x00, 0x00, 0x00, + 0x00, 0x21, 0x00, 0x00, 0x00, 0x5d, 0x00, 0x00, 0x00, 0x55, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, + 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, + 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, + 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, + 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, + 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, + 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, + 0x52, 0x53, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; +char *text_pixelmap_mip = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_PIXELMAP # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*PIXELMAP 9" HOST_NL + " struct br_pixelmap" HOST_NL + " enum_8 BR_PMT_INDEX_8 # type" HOST_NL + " uint_16 8 # row_bytes" HOST_NL + " uint_16 8 # width" HOST_NL + " uint_16 8 # height" HOST_NL + " uint_16 4 # origin_x" HOST_NL + " uint_16 5 # origin_y" HOST_NL + " uint_16 1 # mip_offset" HOST_NL + " asciz \"test mipped pixelmap\" # identifier" HOST_NL + "*PIXELS 5" HOST_NL + " block 85" HOST_NL + " size 1" HOST_NL + " 00000000: 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f" HOST_NL + " 00000020: 202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f" HOST_NL + " 00000040: 404142434445464748494a4b4c4d4e4f5051525354" HOST_NL + "*END 0" HOST_NL; +static void test_pmfile_save_load_pixelmap_mip() { + br_pixelmap *pixelmap_ref; + int res; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + br_pixelmap *pixelmaps_read[2]; + br_uint_8 *indices; + int i; + int mip_size; + + pixelmap_ref = BrPixelmapAllocate(BR_PMT_INDEX_8, 8, 8, NULL, BR_PMAF_NO_PIXELS); + pixelmap_ref->identifier = BrResStrDup(pixelmap_ref, "test mipped pixelmap"); + pixelmap_ref->origin_x = 4; + pixelmap_ref->origin_y = 5; + pixelmap_ref->mip_offset = 1; + + mip_size = 0; + for (int i = pixelmap_ref->width; i != 0; i >>=1) { + mip_size += i * i; + } + LOG_DEBUG("mip size=%d", mip_size); + + pixelmap_ref->pixels = BrResAllocate(pixelmap_ref, mip_size * sizeof(br_uint_8), BR_MEMORY_PIXELS); + + // Don't use BrPixelmapPixelSet to avoid dependencies + indices = pixelmap_ref->pixels; + for (i = 0; i < mip_size; i++) { + indices[i] = i; + } + + create_temp_file(tmpfilename_binary, "pixelmap_mip_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrPixelmapSave(tmpfilename_binary, pixelmap_ref); + TEST_ASSERT_EQUAL_INT32(1, res); + + create_temp_file(tmpfilename_text, "pixelmap_mip_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrPixelmapSave(tmpfilename_text, pixelmap_ref); + TEST_ASSERT_EQUAL_INT32(1, res); + + LOG_DEBUG("Read binary pixelmap"); + pixelmaps_read[0] = BrPixelmapLoad(tmpfilename_binary); + LOG_DEBUG("Read text pixelmap"); + pixelmaps_read[1] = BrPixelmapLoad(tmpfilename_text); + + for (i = 0; i < BR_ASIZE(pixelmaps_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_ASSERT_NOT_NULL(pixelmaps_read[i]); + TEST_ASSERT_EQUAL_STRING(pixelmap_ref->identifier, pixelmaps_read[i]->identifier); + TEST_ASSERT_EQUAL_UINT16(pixelmap_ref->width, pixelmaps_read[i]->width); + TEST_ASSERT_EQUAL_UINT16(pixelmap_ref->height, pixelmaps_read[i]->height); + TEST_ASSERT_EQUAL_UINT16(pixelmap_ref->origin_x, pixelmaps_read[i]->origin_x); + TEST_ASSERT_EQUAL_UINT16(pixelmap_ref->origin_y, pixelmaps_read[i]->origin_y); + TEST_ASSERT_EQUAL_UINT32(pixelmap_ref->origin_y, pixelmaps_read[i]->origin_y); + TEST_ASSERT_EQUAL_UINT32(pixelmap_ref->mip_offset, pixelmaps_read[i]->mip_offset); + TEST_ASSERT_EQUAL_UINT8(pixelmap_ref->type, pixelmaps_read[i]->type); + TEST_ASSERT_NULL(pixelmaps_read[i]->map); + + TEST_ASSERT_EQUAL_UINT8_ARRAY(pixelmap_ref->pixels, pixelmaps_read[i]->pixels, mip_size); + } + + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_pixelmap_mip, tmpfilename_binary, sizeof(binary_pixelmap_mip)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_pixelmap_mip, tmpfilename_text); + + BrResFree(pixelmaps_read[0]); + BrResFree(pixelmaps_read[1]); + BrResFree(pixelmap_ref); +} + + +uint8_t binary_pixelmap_many[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x02, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x1e, + 0x08, 0x00, 0x10, 0x00, 0x04, 0x00, 0x04, 0x00, 0x01, 0x00, 0x02, 0x00, + 0x00, 0x74, 0x65, 0x73, 0x74, 0x20, 0x70, 0x69, 0x78, 0x65, 0x6c, 0x6d, + 0x61, 0x70, 0x20, 0x75, 0x6e, 0x6f, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, + 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x04, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x02, 0x00, 0x02, 0x00, + 0x03, 0x00, 0x03, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x02, + 0x02, 0x01, 0x03, 0x03, 0x03, 0x01, 0x04, 0x00, 0x00, 0x02, 0x02, 0x02, + 0x01, 0x02, 0x03, 0x04, 0x02, 0x02, 0x04, 0x06, 0x03, 0x02, 0x05, 0x00, + 0x00, 0x03, 0x03, 0x03, 0x01, 0x03, 0x04, 0x06, 0x02, 0x03, 0x05, 0x09, + 0x03, 0x03, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x1e, 0x07, 0x00, 0x0c, 0x00, 0x03, + 0x00, 0x03, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, + 0x20, 0x70, 0x69, 0x78, 0x65, 0x6c, 0x6d, 0x61, 0x70, 0x20, 0x64, 0x6f, + 0x73, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, + 0x00, 0x09, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x01, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x02, 0x02, 0x02, 0x01, 0x03, 0x00, 0x00, 0x02, 0x02, 0x02, 0x01, + 0x02, 0x03, 0x04, 0x02, 0x02, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x3d, 0x00, 0x00, 0x00, 0x1f, 0x08, 0x00, + 0x08, 0x00, 0x02, 0x00, 0x02, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x74, + 0x65, 0x73, 0x74, 0x20, 0x70, 0x69, 0x78, 0x65, 0x6c, 0x6d, 0x61, 0x70, + 0x20, 0x74, 0x72, 0x65, 0x73, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, + 0x00, 0x18, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x3d, 0x00, 0x00, 0x00, 0x21, 0x08, 0x00, 0x0c, 0x00, 0x03, 0x00, + 0x01, 0x00, 0x07, 0x00, 0x08, 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x20, + 0x70, 0x69, 0x78, 0x65, 0x6c, 0x6d, 0x61, 0x70, 0x20, 0x6d, 0x61, 0x72, + 0x69, 0x61, 0x21, 0x00, 0x00, 0x00, 0x00, 0x21, 0x00, 0x00, 0x00, 0x14, + 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x01, 0x00, 0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, +}; +char *text_pixelmap_many = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_PIXELMAP # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*PIXELMAP 9" HOST_NL + " struct br_pixelmap" HOST_NL + " enum_8 BR_PMT_RGBA_8888 # type" HOST_NL + " uint_16 16 # row_bytes" HOST_NL + " uint_16 4 # width" HOST_NL + " uint_16 4 # height" HOST_NL + " uint_16 1 # origin_x" HOST_NL + " uint_16 2 # origin_y" HOST_NL + " uint_16 0 # mip_offset" HOST_NL + " asciz \"test pixelmap uno\" # identifier" HOST_NL + "*PIXELS 4" HOST_NL + " block 16" HOST_NL + " size 4" HOST_NL + " 00000000: 0000000000010001000200020003000300000101010101020202010303030104" HOST_NL + " 00000020: 0000020202010203040202040603020500000303030103040602030509030306" HOST_NL + "*END 0" HOST_NL + "*PIXELMAP 9" HOST_NL + " struct br_pixelmap" HOST_NL + " enum_8 BR_PMT_RGBX_888 # type" HOST_NL + " uint_16 12 # row_bytes" HOST_NL + " uint_16 3 # width" HOST_NL + " uint_16 3 # height" HOST_NL + " uint_16 3 # origin_x" HOST_NL + " uint_16 4 # origin_y" HOST_NL + " uint_16 0 # mip_offset" HOST_NL + " asciz \"test pixelmap dos\" # identifier" HOST_NL + "*PIXELS 4" HOST_NL + " block 9" HOST_NL + " size 4" HOST_NL + " 00000000: 0000000000010001000200020000010101010102020201030000020202010203" HOST_NL + " 00000020: 04020204" HOST_NL + "*END 0" HOST_NL + "*PIXELMAP 9" HOST_NL + " struct br_pixelmap" HOST_NL + " enum_8 BR_PMT_RGBA_8888 # type" HOST_NL + " uint_16 8 # row_bytes" HOST_NL + " uint_16 2 # width" HOST_NL + " uint_16 2 # height" HOST_NL + " uint_16 5 # origin_x" HOST_NL + " uint_16 6 # origin_y" HOST_NL + " uint_16 0 # mip_offset" HOST_NL + " asciz \"test pixelmap tres\" # identifier" HOST_NL + "*PIXELS 3" HOST_NL + " block 4" HOST_NL + " size 4" HOST_NL + " 00000000: 00000000000100010000010101010102" HOST_NL + "*END 0" HOST_NL + "*PIXELMAP 9" HOST_NL + " struct br_pixelmap" HOST_NL + " enum_8 BR_PMT_RGBA_8888 # type" HOST_NL + " uint_16 12 # row_bytes" HOST_NL + " uint_16 3 # width" HOST_NL + " uint_16 1 # height" HOST_NL + " uint_16 7 # origin_x" HOST_NL + " uint_16 8 # origin_y" HOST_NL + " uint_16 0 # mip_offset" HOST_NL + " asciz \"test pixelmap maria!\" # identifier" HOST_NL + "*PIXELS 3" HOST_NL + " block 3" HOST_NL + " size 4" HOST_NL + " 00000000: 000000000001000100020002" HOST_NL + "*END 0" HOST_NL; +static void test_pmfile_save_load_pixelmap_many() { +#define PIXELMAP_MANY_NB (4) +#define PIXELMAP_MANY_READ_CAPACITY (PIXELMAP_MANY_NB*5) + br_pixelmap *pixelmaps_ref[PIXELMAP_MANY_NB]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + br_uint_32 *pixels32; + br_pixelmap* pixelmaps_read[2][PIXELMAP_MANY_NB*5]; + int i; + int j; + int k; + int res; + + pixelmaps_ref[0] = BrPixelmapAllocate(BR_PMT_RGBA_8888, 4, 4, NULL, BR_PMAF_NORMAL); + pixelmaps_ref[0]->identifier = BrResStrDup(pixelmaps_ref[0], "test pixelmap uno"); + pixelmaps_ref[0]->origin_x = 1; + pixelmaps_ref[0]->origin_y = 2; + + pixelmaps_ref[1] = BrPixelmapAllocate(BR_PMT_RGBX_888, 3, 3, NULL, BR_PMAF_NORMAL); + pixelmaps_ref[1]->identifier = BrResStrDup(pixelmaps_ref[0], "test pixelmap dos"); + pixelmaps_ref[1]->origin_x = 3; + pixelmaps_ref[1]->origin_y = 4; + + pixelmaps_ref[2] = BrPixelmapAllocate(BR_PMT_RGBA_8888, 2, 2, NULL, BR_PMAF_NORMAL); + pixelmaps_ref[2]->identifier = BrResStrDup(pixelmaps_ref[0], "test pixelmap tres"); + pixelmaps_ref[2]->origin_x = 5; + pixelmaps_ref[2]->origin_y = 6; + + pixelmaps_ref[3] = BrPixelmapAllocate(BR_PMT_RGBA_8888, 3, 1, NULL, BR_PMAF_NORMAL); + pixelmaps_ref[3]->identifier = BrResStrDup(pixelmaps_ref[0], "test pixelmap maria!"); + pixelmaps_ref[3]->origin_x = 7; + pixelmaps_ref[3]->origin_y = 8; + + // Don't use BrPixelmapPixelSet to avoid dependencies + for (k = 0; k < PIXELMAP_MANY_NB; ++k) { + pixels32 = pixelmaps_ref[k]->pixels; + for (j = 0; j < pixelmaps_ref[k]->height; j++) { + for (i = 0; i < pixelmaps_ref[k]->width; i++) { + pixels32[j*pixelmaps_ref[k]->width+i] = BR_COLOUR_RGBA(i, j, i+j, i*j); + } + } + } + + create_temp_file(tmpfilename_binary, "pixelmaps_many_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrPixelmapSaveMany(tmpfilename_binary, pixelmaps_ref, PIXELMAP_MANY_NB); + TEST_ASSERT_EQUAL_INT32(PIXELMAP_MANY_NB, res); + + create_temp_file(tmpfilename_text, "pixelmaps_many_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrPixelmapSaveMany(tmpfilename_text, pixelmaps_ref, PIXELMAP_MANY_NB); + TEST_ASSERT_EQUAL_INT32(PIXELMAP_MANY_NB, res); + + LOG_DEBUG("Read binary pixelmaps"); + res = BrPixelmapLoadMany(tmpfilename_binary, pixelmaps_read[0], PIXELMAP_MANY_READ_CAPACITY); + TEST_ASSERT_EQUAL_INT32(PIXELMAP_MANY_NB, res); + LOG_DEBUG("Read text pixelmaps"); + res = BrPixelmapLoadMany(tmpfilename_text, pixelmaps_read[1], PIXELMAP_MANY_READ_CAPACITY); + TEST_ASSERT_EQUAL_INT32(PIXELMAP_MANY_NB, res); + + for (i = 0; i < 2; i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + for (k = 0; k < PIXELMAP_MANY_NB; k++) { + TEST_ASSERT_NOT_NULL(pixelmaps_read[i][k]); + TEST_ASSERT_EQUAL_STRING(pixelmaps_ref[k]->identifier, pixelmaps_read[i][k]->identifier); + TEST_ASSERT_EQUAL_UINT16(pixelmaps_ref[k]->width, pixelmaps_read[i][k]->width); + TEST_ASSERT_EQUAL_UINT16(pixelmaps_ref[k]->height, pixelmaps_read[i][k]->height); + TEST_ASSERT_EQUAL_UINT16(pixelmaps_ref[k]->origin_x, pixelmaps_read[i][k]->origin_x); + TEST_ASSERT_EQUAL_UINT16(pixelmaps_ref[k]->origin_y, pixelmaps_read[i][k]->origin_y); + TEST_ASSERT_EQUAL_UINT32(pixelmaps_ref[k]->origin_y, pixelmaps_read[i][k]->origin_y); + TEST_ASSERT_EQUAL_UINT32(pixelmaps_ref[k]->mip_offset, pixelmaps_read[i][k]->mip_offset); + TEST_ASSERT_EQUAL_UINT8(pixelmaps_ref[k]->type, pixelmaps_read[i][k]->type); + TEST_ASSERT_NULL(pixelmaps_read[i][k]->map); + + TEST_ASSERT_EQUAL_UINT32_ARRAY(pixelmaps_ref[k]->pixels, pixelmaps_read[i][k]->pixels, pixelmaps_ref[k]->width * pixelmaps_ref[k]->height); + } + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_pixelmap_many, tmpfilename_binary, sizeof(binary_pixelmap_many)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_pixelmap_many, tmpfilename_text); + + for (k = 0; k < PIXELMAP_MANY_NB; k++) { + LOG_DEBUG("Freeing %d", k); + BrResFree(pixelmaps_ref[k]); + BrResFree(pixelmaps_read[0][k]); + BrResFree(pixelmaps_read[1][k]); + } +} + +static void test_pmfile_BrPixelmapLoad() { REQUIRES_DATA_DIRECTORY(); br_pixelmap* pm; @@ -16,5 +552,9 @@ void test_pmfile_BrPixelmapLoad() { void test_pmfile_suite() { UnitySetTestFile(__FILE__); + RUN_TEST(test_pmfile_save_load_pixelmap_lone); + RUN_TEST(test_pmfile_save_load_pixelmap_mapped); + RUN_TEST(test_pmfile_save_load_pixelmap_mip); + RUN_TEST(test_pmfile_save_load_pixelmap_many); RUN_TEST(test_pmfile_BrPixelmapLoad); } diff --git a/test/BRSRC13/test_v1dbfile.c b/test/BRSRC13/test_v1dbfile.c index 15ad6fe0..cd01ed98 100644 --- a/test/BRSRC13/test_v1dbfile.c +++ b/test/BRSRC13/test_v1dbfile.c @@ -1,11 +1,2076 @@ #include "tests.h" +#include "CORE/FW/resource.h" +#include "CORE/MATH/angles.h" +#include "CORE/MATH/vector.h" #include "CORE/PIXELMAP/pmfile.h" #include "CORE/V1DB/actsupt.h" +#include "CORE/FW/datafile.h" #include "CORE/V1DB/modsupt.h" #include "CORE/V1DB/prepmesh.h" #include "CORE/V1DB/regsupt.h" +#include "CORE/PIXELMAP/pixelmap.h" +#include "CORE/V1DB/matsupt.h" #include "CORE/V1DB/v1dbfile.h" +#include "CORE/MATH/matrix23.h" + +#include +#include + +static void add_test_table(int i) { + br_pixelmap *map; + char name[128]; + + sprintf(name, "test_table_%d", i); + + // First remove all maps by this name + while (1) { + map = BrTableFind(name); + if (map == NULL) { + break; + } + BrTableRemove(map); + BrResFree(map); + } + + // Then create a new one + map = BrPixelmapAllocate(i % 2 == 0 ? BR_PMT_INDEX_8 : BR_PMT_RGBA_8888, 1 << i, 1 << i, NULL, BR_PMAF_NORMAL); + map->identifier = BrResStrDup(map, name); + if (i % 2 == 0) { + map->map = BrPixelmapAllocate(BR_PMT_RGBA_8888, 8, 8, NULL, BR_PMAF_NORMAL); + } + BrTableAdd(map); +} + +static void register_test_tables() { + int i; + int nb; + + nb = 5; + for (i = 0; i < nb; i++) { + add_test_table(i); + } +} + +static void add_test_map(int nb) { + br_pixelmap *map; + char name[128]; + + sprintf(name, "test_map_%d", nb); + + // First remove all maps by this name + while (1) { + map = BrMapFind(name); + if (map == NULL) { + break; + } + BrMapRemove(map); + BrResFree(map); + } + + // Then create a new one + map = BrPixelmapAllocate(nb % 2 == 0 ? BR_PMT_INDEX_8 : BR_PMT_RGB_555, 2 << nb, 2 << nb, NULL, BR_PMAF_NORMAL); + map->identifier = BrResStrDup(map, name); + if (nb % 2 == 0) { + map->map = BrPixelmapAllocate(BR_PMT_YUV_888, 8, 8, NULL, BR_PMAF_NORMAL); + } + BrMapAdd(map); +} + +static void register_test_maps() { + int i; + int nb; + + nb = 5; + for (i = 0; i < nb; i++) { + add_test_map(i); + } +} + +static void add_test_material(int nb) { + br_material *mat; + char name[128]; + + sprintf(name, "test_material_%d", nb); + + // First remove all maps by this name + while (1) { + mat = BrMaterialFind(name); + if (mat == NULL) { + break; + } + BrMaterialRemove(mat); + BrResFree(mat); + } + + // Then create a new one + mat = BrMaterialAllocate(name); + + mat->colour = BR_COLOUR_RGB(145 + nb, 23 + nb, 17 + nb); + mat->opacity = 127 + nb * 1; + mat->ka = 0.25f + nb * 0.125; + mat->kd = 0.75f + nb * 0.125; + mat->ks = 0.15f + nb * 0.125; + mat->power = 19 + 4 * nb; + mat->flags = BR_MATF_DECAL | BR_MATF_SMOOTH; + BrMatrix23Rotate(&mat->map_transform, BrDegreeToAngle(30 + nb * 30)); + BrMatrix23PostTranslate(&mat->map_transform, 0.5f - nb * 0.125, 0.5f + nb * 0.125); + mat->index_base = 13 + nb * 3; + mat->index_range = 42 + nb * 3;; + mat->fog_min = 1.f + nb * .125f; + mat->fog_max = 2.f + nb * .125f; + mat->fog_colour = BR_COLOUR_RGB(10, 20, 30); + mat->subdivide_tolerance = 5 + nb; + + mat->index_blend = BrTableFind("test_table_0"); + TEST_ASSERT_NOT_NULL(mat->index_blend); + if (nb % 2 == 1) { + mat->colour_map = BrMapFind("test_map_1"); + TEST_ASSERT_NOT_NULL(mat->colour_map); + } + if (nb % 3 == 2) { + mat->index_blend = BrTableFind("test_table_2"); + TEST_ASSERT_NOT_NULL(mat->index_blend); + } + mat->index_fog = BrTableFind("test_table_3"); + TEST_ASSERT_NOT_NULL(mat->index_fog); + if (nb % 4 == 3) { + mat->screendoor = BrTableFind("test_table_4"); + TEST_ASSERT_NOT_NULL(mat->screendoor); + } + BrMaterialAdd(mat); +} + +static void register_test_materials() { + int i; + int nb; + + nb = 5; + for (i = 0; i < nb; i++) { + add_test_material(i); + } +} + +static void add_test_model(int nb) { + br_model *mod; + int nvertices; + int nfaces; + int i; + char name[128]; + + sprintf(name, "test_model_%d", nb); + + // First remove all maps by this name + while (1) { + mod = BrModelFind(name); + if (mod == NULL) { + break; + } + BrModelRemove(mod); + BrResFree(mod); + } + + nvertices = 3 + nb; + nfaces = nb + 1; + + // Then create a new one + mod = BrModelAllocate(name, nvertices, nfaces); + + for (i = 0; i < nvertices; i++) { + BrVector3Set(&mod->vertices[i].p, BR_SCALAR(i) + nb, BR_SCALAR(i % 2) + nb, BR_SCALAR(i) + nb); + if (i % 2 != 0) { + BrVector2Set(&mod->vertices[i].map, BR_SCALAR(i / 2) * 2 / nvertices, BR_SCALAR((i + 1) % 2)); + } + } + + for (i = 0; i < nfaces; i++) { + mod->faces[i].flags = i; + mod->faces[i].smoothing = i * 3; + mod->faces[i].vertices[0] = i; + mod->faces[i].vertices[1] = i + 1; + mod->faces[i].vertices[2] = i + 2; + } + + mod->flags = BR_MODF_UPDATEABLE; + if (nb % 2 != 0) { + mod->flags |= BR_MODF_PREPREPARED; + } + BrVector3Set(&mod->pivot, 0.5f * nb, 0.25f * nb, 0.125f * nb); + + BrModelAdd(mod); +} + +static void register_test_models() { + int i; + int nb; + + nb = 5; + for (i = 0; i < nb; i++) { + add_test_model(i); + } +} + +static br_actor* create_test_actor(char *name, int type, int transform, int nb) { + char buffer[128]; + br_actor* act; + br_actor* child; + int depth; + br_light* light; + br_camera* camera; + br_bounds* bounds; + br_vector4* clip_plane; + + act = BrActorAllocate(type, NULL); + act->identifier = BrResStrDup(act, name); + act->t.type = transform; + switch (transform) { + case BR_TRANSFORM_MATRIX34: + case BR_TRANSFORM_MATRIX34_LP: + act->t.t.mat.m[0][0] = BR_SCALAR(1.f); + act->t.t.mat.m[0][1] = BR_SCALAR(2.f); + act->t.t.mat.m[0][2] = BR_SCALAR(3.f); + act->t.t.mat.m[1][0] = BR_SCALAR(4.f); + act->t.t.mat.m[1][1] = BR_SCALAR(5.f); + act->t.t.mat.m[1][2] = BR_SCALAR(6.f); + act->t.t.mat.m[2][0] = BR_SCALAR(7.f); + act->t.t.mat.m[2][1] = BR_SCALAR(8.f); + act->t.t.mat.m[2][2] = BR_SCALAR(9.f); + act->t.t.mat.m[3][0] = BR_SCALAR(10.f); + act->t.t.mat.m[3][1] = BR_SCALAR(11.f); + act->t.t.mat.m[3][2] = BR_SCALAR(12.f); + break; + case BR_TRANSFORM_QUAT: + act->t.t.quat.q.x = BR_SCALAR(.1); + act->t.t.quat.q.y = BR_SCALAR(.2); + act->t.t.quat.q.z = BR_SCALAR(.3); + act->t.t.quat.q.w = BR_SCALAR(.4); + act->t.t.quat.t.v[0] = BR_SCALAR(2.f); + act->t.t.quat.t.v[1] = BR_SCALAR(3.f); + act->t.t.quat.t.v[2] = BR_SCALAR(4.f); + break; + case BR_TRANSFORM_LOOK_UP: + act->t.t.look_up.look.v[0] = BR_SCALAR(1.f); + act->t.t.look_up.look.v[1] = BR_SCALAR(2.f); + act->t.t.look_up.look.v[2] = BR_SCALAR(3.f); + act->t.t.look_up.up.v[0] = BR_SCALAR(4.f); + act->t.t.look_up.up.v[1] = BR_SCALAR(5.f); + act->t.t.look_up.up.v[2] = BR_SCALAR(6.f); + act->t.t.look_up.t.v[0] = BR_SCALAR(7.f); + act->t.t.look_up.t.v[1] = BR_SCALAR(8.f); + act->t.t.look_up.t.v[2] = BR_SCALAR(9.f); + break; + case BR_TRANSFORM_EULER: + act->t.t.euler.e.a = (br_angle)0x1000; + act->t.t.euler.e.b = (br_angle)0x2000; + act->t.t.euler.e.c = (br_angle)0x3000; + act->t.t.euler.e.order = BR_EULER_XZY_R; + act->t.t.euler.t.v[0] = BR_SCALAR(3.f); + act->t.t.euler.t.v[1] = BR_SCALAR(6.f); + act->t.t.euler.t.v[2] = BR_SCALAR(9.f); + break; + } + switch (type) { + case BR_ACTOR_MODEL: + sprintf(buffer, "test_model_%d", nb % 6); + act->model = BrModelFind(buffer); + TEST_ASSERT_NOT_NULL(act->model); + sprintf(buffer, "test_material_%d", nb % 5); + act->material = BrMaterialFind(buffer); + TEST_ASSERT_NOT_NULL(act->material); + act->render_style = BR_RSTYLE_FACES; + break; + case BR_ACTOR_LIGHT: + light = act->type_data; + light->colour = BR_COLOUR_RGBA(0x12 + nb, 0x34 + nb, 0x56 + nb, 0); + light->attenuation_c = BR_SCALAR(0.125f + 0.125f * nb); + light->attenuation_l = BR_SCALAR(0.0625f + 0.125f * nb); + light->attenuation_q = BR_SCALAR(0.25f + 0.125f * nb); + light->cone_outer = BR_ANGLE_DEG(60 + 30 * nb); + light->cone_inner = BR_ANGLE_DEG(30 - 30 * nb); + break; + case BR_ACTOR_CAMERA: + camera = act->type_data; + camera->field_of_view = 0x2000; + camera->hither_z = BR_SCALAR(0.75f + 0.25f * nb); + camera->hither_z = BR_SCALAR(2.f + nb); + camera->aspect = BR_SCALAR(1.33333333333f); + camera->width = BR_SCALAR(2.25f + 0.0625f * nb); + camera->height = BR_SCALAR(1.25f + 0.25f * nb); + camera->distance = BR_SCALAR(1.75f + 0.0625f * nb ); + break; + case BR_ACTOR_BOUNDS: + case BR_ACTOR_BOUNDS_CORRECT: + bounds = act->type_data; + BrVector3Set(&bounds->min, BR_SCALAR(1.25f), BR_SCALAR(1.75f), BR_SCALAR(0.25f)); + BrVector3Set(&bounds->max, BR_SCALAR(7.75f), BR_SCALAR(2.25f), BR_SCALAR(2.0625f)); + break; + case BR_ACTOR_CLIP_PLANE: + clip_plane = act->type_data; + clip_plane->v[0] = BR_SCALAR(1.f); + clip_plane->v[1] = BR_SCALAR(1.25f); + clip_plane->v[2] = BR_SCALAR(1.5f); + clip_plane->v[3] = BR_SCALAR(1.75f); + break; + } + return act; +} + +#define TEST_COMPARE_MATERIAL(MATREF, MAT) do { \ + TEST_ASSERT_NOT_NULL(MATREF); \ + TEST_ASSERT_NOT_NULL(MAT); \ + TEST_ASSERT_EQUAL_STRING((MATREF)->identifier, (MAT)->identifier); \ + TEST_ASSERT_EQUAL_UINT32((MATREF)->colour, (MAT)->colour); \ + TEST_ASSERT_EQUAL_UINT8((MATREF)->opacity, (MAT)->opacity); \ + TEST_ASSERT_FLOAT_WITHIN(1e-5, (MATREF)->ka, (MAT)->ka); \ + TEST_ASSERT_FLOAT_WITHIN(1e-5, (MATREF)->kd, (MAT)->kd); \ + TEST_ASSERT_FLOAT_WITHIN(1e-5, (MATREF)->ks, (MAT)->ks); \ + TEST_ASSERT_EQUAL_UINT32((MATREF)->power, (MAT)->power); \ + TEST_ASSERT_EQUAL_UINT32((MATREF)->flags, (MAT)->flags); \ + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1e-5, (MATREF)->map_transform.m, (MAT)->map_transform.m, 6); \ + \ + TEST_ASSERT_EQUAL_UINT8((MATREF)->index_base, (MAT)->index_base); \ + TEST_ASSERT_EQUAL_UINT8((MATREF)->index_range, (MAT)->index_range); \ + TEST_ASSERT_FLOAT_WITHIN(1e-5, (MATREF)->fog_min, (MAT)->fog_min); \ + TEST_ASSERT_FLOAT_WITHIN(1e-5, (MATREF)->fog_max, (MAT)->fog_max); \ + TEST_ASSERT_EQUAL_UINT32((MATREF)->fog_colour, (MAT)->fog_colour); \ + TEST_ASSERT_EQUAL_INT32((MATREF)->subdivide_tolerance, (MAT)->subdivide_tolerance); \ + \ + TEST_ASSERT_EQUAL_PTR((MATREF)->index_blend, (MAT)->index_blend); \ + TEST_ASSERT_EQUAL_PTR((MATREF)->colour_map, (MAT)->colour_map); \ + TEST_ASSERT_EQUAL_PTR((MATREF)->index_shade, (MAT)->index_shade); \ + TEST_ASSERT_EQUAL_PTR((MATREF)->index_fog, (MAT)->index_fog); \ + TEST_ASSERT_EQUAL_PTR((MATREF)->screendoor, (MAT)->screendoor); \ +} while (0) + +#define TEST_COMPARE_MODEL(MODEL_REF, MODEL) do { \ + int private_index; \ + TEST_ASSERT_NOT_NULL(MODEL_REF); \ + TEST_ASSERT_NOT_NULL(MODEL); \ + TEST_ASSERT_EQUAL_STRING((MODEL_REF)->identifier, (MODEL)->identifier); \ + TEST_ASSERT_EQUAL_UINT16((MODEL_REF)->flags & (BR_MODF_DONT_WELD | BR_MODF_KEEP_ORIGINAL | BR_MODF_GENERATE_TAGS | BR_MODF_QUICK_UPDATE), (MODEL)->flags); \ + TEST_ASSERT_EQUAL_UINT16((MODEL_REF)->nvertices, (MODEL)->nvertices); \ + TEST_ASSERT_EQUAL_UINT16((MODEL_REF)->nfaces, (MODEL)->nfaces); \ + \ + for (private_index = 0; private_index < (MODEL_REF)->nvertices; private_index++) { \ + TEST_ASSERT_FLOAT_WITHIN(1e-5, (MODEL_REF)->vertices[private_index].p.v[0], (MODEL)->vertices[private_index].p.v[0]); \ + TEST_ASSERT_FLOAT_WITHIN(1e-5, (MODEL_REF)->vertices[private_index].p.v[1], (MODEL)->vertices[private_index].p.v[1]); \ + TEST_ASSERT_FLOAT_WITHIN(1e-5, (MODEL_REF)->vertices[private_index].p.v[2], (MODEL)->vertices[private_index].p.v[2]); \ + TEST_ASSERT_FLOAT_WITHIN(1e-5, (MODEL_REF)->vertices[private_index].map.v[0], (MODEL)->vertices[private_index].map.v[0]); \ + TEST_ASSERT_FLOAT_WITHIN(1e-5, (MODEL_REF)->vertices[private_index].map.v[1], (MODEL)->vertices[private_index].map.v[1]); \ + } \ + \ + for (private_index = 0; private_index < (MODEL_REF)->nfaces; private_index++) { \ + TEST_ASSERT_EQUAL_UINT16((MODEL_REF)->faces[private_index].vertices[0], (MODEL)->faces[private_index].vertices[0]); \ + TEST_ASSERT_EQUAL_UINT16((MODEL_REF)->faces[private_index].vertices[1], (MODEL)->faces[private_index].vertices[1]); \ + TEST_ASSERT_EQUAL_UINT16((MODEL_REF)->faces[private_index].vertices[2], (MODEL)->faces[private_index].vertices[2]); \ + TEST_ASSERT_EQUAL_UINT16((MODEL_REF)->faces[private_index].smoothing == 0 ? 0xffff : (MODEL_REF)->faces[private_index].smoothing, (MODEL)->faces[private_index].smoothing); \ + } \ +} while (0) + +static void compare_actor(br_actor *actor_ref, br_actor *actor) { + br_actor *child_ref; + br_actor *child; + + LOG_DEBUG("Comparing actor_ref \"%s\" with actor \"%s\"", actor_ref->identifier, actor->identifier); + TEST_ASSERT_NOT_NULL(actor_ref); + TEST_ASSERT_NOT_NULL(actor); + TEST_ASSERT_EQUAL_STRING(actor_ref->identifier, actor->identifier); + TEST_ASSERT_EQUAL_UINT16(actor_ref->t.type, actor->t.type); + switch (actor_ref->t.type) { + case BR_TRANSFORM_MATRIX34: + case BR_TRANSFORM_MATRIX34_LP: + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1e-3, actor_ref->t.t.mat.m, actor->t.t.mat.m, 12); + break; + case BR_TRANSFORM_EULER: + TEST_ASSERT_EQUAL_UINT16(actor_ref->t.t.euler.e.a, actor->t.t.euler.e.a); + TEST_ASSERT_EQUAL_UINT16(actor_ref->t.t.euler.e.b, actor->t.t.euler.e.b); + TEST_ASSERT_EQUAL_UINT16(actor_ref->t.t.euler.e.c, actor->t.t.euler.e.c); + TEST_ASSERT_EQUAL_UINT8(actor_ref->t.t.euler.e.order, actor->t.t.euler.e.order); + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1e-3, actor_ref->t.t.euler.t.v, actor->t.t.euler.t.v, 3); + break; + case BR_TRANSFORM_QUAT: + TEST_ASSERT_FLOAT_WITHIN(1e-3, actor_ref->t.t.quat.q.x, actor->t.t.quat.q.x); + TEST_ASSERT_FLOAT_WITHIN(1e-3, actor_ref->t.t.quat.q.y, actor->t.t.quat.q.y); + TEST_ASSERT_FLOAT_WITHIN(1e-3, actor_ref->t.t.quat.q.z, actor->t.t.quat.q.z); + TEST_ASSERT_FLOAT_WITHIN(1e-3, actor_ref->t.t.quat.q.w, actor->t.t.quat.q.w); + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1e-3, actor_ref->t.t.quat.t.v, actor->t.t.quat.t.v, 3); + break; + case BR_TRANSFORM_TRANSLATION: + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1e-3, actor_ref->t.t.translate.t.v, actor->t.t.translate.t.v, 3); + break; + case BR_TRANSFORM_LOOK_UP: + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1e-3, actor_ref->t.t.look_up.look.v, actor->t.t.look_up.look.v, 3); + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1e-3, actor_ref->t.t.look_up.up.v, actor->t.t.look_up.up.v, 3); + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1e-3, actor_ref->t.t.look_up.t.v, actor->t.t.look_up.t.v, 3); + break; + } + TEST_ASSERT_EQUAL_PTR(actor_ref->model, actor->model); + TEST_ASSERT_EQUAL_PTR(actor_ref->material, actor->material); + switch (actor_ref->type) { + case BR_ACTOR_CLIP_PLANE: + TEST_ASSERT_FLOAT_ARRAY_WITHIN(1e-5, ((br_vector4*)((actor_ref)->type_data))->v, ((br_vector4*)(actor->type_data))->v, 4); + break; + case BR_ACTOR_LIGHT: + TEST_ASSERT_EQUAL_UINT8_MESSAGE(((br_light*)(actor_ref->type_data))->type, ((br_light*)(actor->type_data))->type, "actor->light_data->type"); + TEST_ASSERT_EQUAL_UINT32_MESSAGE(((br_light*)(actor_ref->type_data))->colour, ((br_light*)(actor->type_data))->colour, "actor->light_data->colour"); + TEST_ASSERT_EQUAL_FLOAT_MESSAGE(((br_light*)(actor_ref->type_data))->attenuation_c, ((br_light*)(actor->type_data))->attenuation_c, "actor->light_data->attenuation_c"); + TEST_ASSERT_EQUAL_FLOAT_MESSAGE(((br_light*)(actor_ref->type_data))->attenuation_l, ((br_light*)(actor->type_data))->attenuation_l, "actor->light_data->attenuation_l"); + TEST_ASSERT_EQUAL_FLOAT_MESSAGE(((br_light*)(actor_ref->type_data))->attenuation_q, ((br_light*)(actor->type_data))->attenuation_q, "actor->light_data->attenuation_q"); + TEST_ASSERT_EQUAL_UINT16_MESSAGE(((br_light*)(actor_ref->type_data))->cone_outer, ((br_light*)(actor->type_data))->cone_outer, "actor->light_data->cone_outer"); + TEST_ASSERT_EQUAL_UINT16_MESSAGE(((br_light*)(actor_ref->type_data))->cone_inner, ((br_light*)(actor->type_data))->cone_inner, "actor->light_data->cone_inner"); + break; + case BR_ACTOR_CAMERA: + TEST_ASSERT_EQUAL_UINT8_MESSAGE(((br_camera*)(actor_ref->type_data))->type, ((br_camera*)(actor->type_data))->type, "actor->camera_data->type"); + TEST_ASSERT_EQUAL_UINT16_MESSAGE(((br_camera*)(actor_ref->type_data))->field_of_view, ((br_camera*)(actor->type_data))->field_of_view, "actor->camera_data->field_of_view"); + TEST_ASSERT_EQUAL_FLOAT_MESSAGE(((br_camera*)(actor_ref->type_data))->hither_z, ((br_camera*)(actor->type_data))->hither_z, "actor->camera_data->hither_z"); + TEST_ASSERT_EQUAL_FLOAT_MESSAGE(((br_camera*)(actor_ref->type_data))->yon_z, ((br_camera*)(actor->type_data))->yon_z, "actor->camera_data->yon_z"); + TEST_ASSERT_EQUAL_FLOAT_MESSAGE(((br_camera*)(actor_ref->type_data))->aspect, ((br_camera*)(actor->type_data))->aspect, "actor->camera_data->aspect"); + break; + case BR_ACTOR_BOUNDS: + case BR_ACTOR_BOUNDS_CORRECT: + TEST_ASSERT_EQUAL_FLOAT_ARRAY(((br_bounds3*)(actor_ref->type_data))->min.v, ((br_bounds3*)(actor->type_data))->min.v, 3); + TEST_ASSERT_EQUAL_FLOAT_ARRAY(((br_bounds3*)(actor_ref->type_data))->max.v, ((br_bounds3*)(actor->type_data))->max.v, 3); + break; + } + if (actor_ref->children != NULL) { + child_ref = actor_ref->children; + child = actor->children; + while (child_ref != NULL) { + compare_actor(child_ref, child); + child_ref = child_ref->next; + child = child->next; + } + } +} + +#define TEST_COMPARE_ACTOR(ACTOR_REF, ACTOR) do { \ + compare_actor(ACTOR_REF, ACTOR); \ +} while (0) + +static void register_test_items() { + register_test_maps(); + register_test_tables(); + register_test_materials(); + register_test_models(); +} + +uint8_t binary_material_lone[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x06, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x52, + 0x92, 0x18, 0x12, 0x80, 0x3e, 0xc0, 0x00, 0x00, 0x3f, 0x60, 0x00, 0x00, + 0x3e, 0x8c, 0xcc, 0xcd, 0x41, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, + 0x3f, 0x00, 0x03, 0xa0, 0x3f, 0x5d, 0xb1, 0xbf, 0xbf, 0x5d, 0xb1, 0xbf, + 0x3f, 0x00, 0x03, 0xa0, 0x3e, 0xc0, 0x00, 0x00, 0x3f, 0x20, 0x00, 0x00, + 0x10, 0x2d, 0x3f, 0x90, 0x00, 0x00, 0x40, 0x08, 0x00, 0x00, 0x0a, 0x14, + 0x1e, 0x00, 0x00, 0x00, 0x06, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x61, + 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x5f, 0x31, 0x00, 0x00, 0x00, 0x00, + 0x1c, 0x00, 0x00, 0x00, 0x0b, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x61, + 0x70, 0x5f, 0x31, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x0d, + 0x74, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x30, + 0x00, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x0d, 0x74, 0x65, 0x73, + 0x74, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x33, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; +char *text_material_lone = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_MATERIAL # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*MATERIAL 18" HOST_NL + " struct br_material" HOST_NL + " colour 146,24,18 # colour" HOST_NL + " uint_8 128 # opacity" HOST_NL + " ufraction 0.375 # ka" HOST_NL + " ufraction 0.875 # kd" HOST_NL + " ufraction 0.275 # ks" HOST_NL + " scalar 23 # power" HOST_NL + " uint_32 68 # flags" HOST_NL + " vector2 0.500055,0.865993 # map_transform.m[0]" HOST_NL + " vector2 -0.865993,0.500055 # map_transform.m[1]" HOST_NL + " vector2 0.375,0.625 # map_transform.m[2]" HOST_NL + " uint_8 16 # index_base" HOST_NL + " uint_8 45 # index_range" HOST_NL + " scalar 1.125 # fog_min" HOST_NL + " scalar 2.125 # fog_max" HOST_NL + " colour 10,20,30 # fog_colour" HOST_NL + " int_32 6 # subdivide_tolerance" HOST_NL + " asciz \"test_material_1\" # identifier" HOST_NL + "*COLOUR_MAP_REF 1" HOST_NL + " name \"test_map_1\"" HOST_NL + "*INDEX_BLEND_REF 1" HOST_NL + " name \"test_table_0\"" HOST_NL + "*INDEX_FOG_REF 1" HOST_NL + " name \"test_table_3\"" HOST_NL + "*END 0" HOST_NL; +static void test_v1dbfile_save_load_material_lone() { + br_material *material_ref; + br_material* materials_read[2]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + int i; + int res; + + register_test_items(); + + material_ref = BrMaterialFind("test_material_1"); + TEST_ASSERT_NOT_NULL(material_ref); + + create_temp_file(tmpfilename_binary, "material_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrMaterialSave(tmpfilename_binary, material_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + create_temp_file(tmpfilename_text, "material_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrMaterialSave(tmpfilename_text, material_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + puts("Read binary material"); + materials_read[0] = BrMaterialLoad(tmpfilename_binary); + puts("Read text material"); + materials_read[1] = BrMaterialLoad(tmpfilename_text); + + for (i = 0; i < BR_ASIZE(materials_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_COMPARE_MATERIAL(material_ref, materials_read[i]); + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_material_lone, tmpfilename_binary, sizeof(binary_material_lone)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_material_lone, tmpfilename_text); + + BrResFree(materials_read[0]); + BrResFree(materials_read[1]); +} + +uint8_t binary_material_many[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x06, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x52, + 0x91, 0x17, 0x11, 0x7f, 0x3e, 0x80, 0x00, 0x00, 0x3f, 0x40, 0x00, 0x00, + 0x3e, 0x19, 0x99, 0x9a, 0x41, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, + 0x3f, 0x5d, 0xb4, 0xe3, 0x3e, 0xff, 0xfc, 0x60, 0xbe, 0xff, 0xfc, 0x60, + 0x3f, 0x5d, 0xb4, 0xe3, 0x3f, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, + 0x0d, 0x2a, 0x3f, 0x80, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x0a, 0x14, + 0x1e, 0x00, 0x00, 0x00, 0x05, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x61, + 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x5f, 0x30, 0x00, 0x00, 0x00, 0x00, + 0x1e, 0x00, 0x00, 0x00, 0x0d, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x61, + 0x62, 0x6c, 0x65, 0x5f, 0x30, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, + 0x00, 0x0d, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x5f, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x52, 0x92, 0x18, 0x12, 0x80, 0x3e, + 0xc0, 0x00, 0x00, 0x3f, 0x60, 0x00, 0x00, 0x3e, 0x8c, 0xcc, 0xcd, 0x41, + 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0x3f, 0x00, 0x03, 0xa0, 0x3f, + 0x5d, 0xb1, 0xbf, 0xbf, 0x5d, 0xb1, 0xbf, 0x3f, 0x00, 0x03, 0xa0, 0x3e, + 0xc0, 0x00, 0x00, 0x3f, 0x20, 0x00, 0x00, 0x10, 0x2d, 0x3f, 0x90, 0x00, + 0x00, 0x40, 0x08, 0x00, 0x00, 0x0a, 0x14, 0x1e, 0x00, 0x00, 0x00, 0x06, + 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, + 0x6c, 0x5f, 0x31, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x0b, + 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x70, 0x5f, 0x31, 0x00, 0x00, + 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x0d, 0x74, 0x65, 0x73, 0x74, 0x5f, + 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x30, 0x00, 0x00, 0x00, 0x00, 0x3b, + 0x00, 0x00, 0x00, 0x0d, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x5f, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x00, 0x52, 0x93, 0x19, 0x13, + 0x81, 0x3f, 0x00, 0x00, 0x00, 0x3f, 0x80, 0x00, 0x00, 0x3e, 0xcc, 0xcc, + 0xcd, 0x41, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x44, 0xb3, 0x3b, 0xbd, + 0x2e, 0x3f, 0x80, 0x00, 0x00, 0xbf, 0x80, 0x00, 0x00, 0xb3, 0x3b, 0xbd, + 0x2e, 0x3e, 0x80, 0x00, 0x00, 0x3f, 0x40, 0x00, 0x00, 0x13, 0x30, 0x3f, + 0xa0, 0x00, 0x00, 0x40, 0x10, 0x00, 0x00, 0x0a, 0x14, 0x1e, 0x00, 0x00, + 0x00, 0x07, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x65, 0x72, + 0x69, 0x61, 0x6c, 0x5f, 0x32, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, + 0x00, 0x0d, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, + 0x5f, 0x32, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x0d, 0x74, + 0x65, 0x73, 0x74, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x33, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, + 0x00, 0x00, 0x00, 0x52, 0x94, 0x1a, 0x14, 0x82, 0x3f, 0x20, 0x00, 0x00, + 0x3f, 0x90, 0x00, 0x00, 0x3f, 0x06, 0x66, 0x66, 0x41, 0xf8, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x44, 0xbe, 0xff, 0xfc, 0x61, 0x3f, 0x5d, 0xb4, 0xe3, + 0xbf, 0x5d, 0xb4, 0xe3, 0xbe, 0xff, 0xfc, 0x61, 0x3e, 0x00, 0x00, 0x00, + 0x3f, 0x60, 0x00, 0x00, 0x16, 0x33, 0x3f, 0xb0, 0x00, 0x00, 0x40, 0x18, + 0x00, 0x00, 0x0a, 0x14, 0x1e, 0x00, 0x00, 0x00, 0x08, 0x74, 0x65, 0x73, + 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x5f, 0x33, + 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x00, 0x0b, 0x74, 0x65, 0x73, + 0x74, 0x5f, 0x6d, 0x61, 0x70, 0x5f, 0x31, 0x00, 0x00, 0x00, 0x00, 0x1e, + 0x00, 0x00, 0x00, 0x0d, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x61, 0x62, + 0x6c, 0x65, 0x5f, 0x30, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, + 0x0d, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, + 0x34, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x00, 0x00, 0x00, 0x0d, 0x74, 0x65, + 0x73, 0x74, 0x5f, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x33, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; +char *text_material_many = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_MATERIAL # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*MATERIAL 18" HOST_NL + " struct br_material" HOST_NL + " colour 145,23,17 # colour" HOST_NL + " uint_8 127 # opacity" HOST_NL + " ufraction 0.25 # ka" HOST_NL + " ufraction 0.75 # kd" HOST_NL + " ufraction 0.15 # ks" HOST_NL + " scalar 19 # power" HOST_NL + " uint_32 68 # flags" HOST_NL + " vector2 0.866041,0.499972 # map_transform.m[0]" HOST_NL + " vector2 -0.499972,0.866041 # map_transform.m[1]" HOST_NL + " vector2 0.5,0.5 # map_transform.m[2]" HOST_NL + " uint_8 13 # index_base" HOST_NL + " uint_8 42 # index_range" HOST_NL + " scalar 1 # fog_min" HOST_NL + " scalar 2 # fog_max" HOST_NL + " colour 10,20,30 # fog_colour" HOST_NL + " int_32 5 # subdivide_tolerance" HOST_NL + " asciz \"test_material_0\" # identifier" HOST_NL + "*INDEX_BLEND_REF 1" HOST_NL + " name \"test_table_0\"" HOST_NL + "*INDEX_FOG_REF 1" HOST_NL + " name \"test_table_3\"" HOST_NL + "*END 0" HOST_NL + "*MATERIAL 18" HOST_NL + " struct br_material" HOST_NL + " colour 146,24,18 # colour" HOST_NL + " uint_8 128 # opacity" HOST_NL + " ufraction 0.375 # ka" HOST_NL + " ufraction 0.875 # kd" HOST_NL + " ufraction 0.275 # ks" HOST_NL + " scalar 23 # power" HOST_NL + " uint_32 68 # flags" HOST_NL + " vector2 0.500055,0.865993 # map_transform.m[0]" HOST_NL + " vector2 -0.865993,0.500055 # map_transform.m[1]" HOST_NL + " vector2 0.375,0.625 # map_transform.m[2]" HOST_NL + " uint_8 16 # index_base" HOST_NL + " uint_8 45 # index_range" HOST_NL + " scalar 1.125 # fog_min" HOST_NL + " scalar 2.125 # fog_max" HOST_NL + " colour 10,20,30 # fog_colour" HOST_NL + " int_32 6 # subdivide_tolerance" HOST_NL + " asciz \"test_material_1\" # identifier" HOST_NL + "*COLOUR_MAP_REF 1" HOST_NL + " name \"test_map_1\"" HOST_NL + "*INDEX_BLEND_REF 1" HOST_NL + " name \"test_table_0\"" HOST_NL + "*INDEX_FOG_REF 1" HOST_NL + " name \"test_table_3\"" HOST_NL + "*END 0" HOST_NL + "*MATERIAL 18" HOST_NL + " struct br_material" HOST_NL + " colour 147,25,19 # colour" HOST_NL + " uint_8 129 # opacity" HOST_NL + " ufraction 0.5 # ka" HOST_NL + " ufraction 1 # kd" HOST_NL + " ufraction 0.4 # ks" HOST_NL + " scalar 27 # power" HOST_NL + " uint_32 68 # flags" HOST_NL + " vector2 -4.37114e-08,1 # map_transform.m[0]" HOST_NL + " vector2 -1,-4.37114e-08 # map_transform.m[1]" HOST_NL + " vector2 0.25,0.75 # map_transform.m[2]" HOST_NL + " uint_8 19 # index_base" HOST_NL + " uint_8 48 # index_range" HOST_NL + " scalar 1.25 # fog_min" HOST_NL + " scalar 2.25 # fog_max" HOST_NL + " colour 10,20,30 # fog_colour" HOST_NL + " int_32 7 # subdivide_tolerance" HOST_NL + " asciz \"test_material_2\" # identifier" HOST_NL + "*INDEX_BLEND_REF 1" HOST_NL + " name \"test_table_2\"" HOST_NL + "*INDEX_FOG_REF 1" HOST_NL + " name \"test_table_3\"" HOST_NL + "*END 0" HOST_NL + "*MATERIAL 18" HOST_NL + " struct br_material" HOST_NL + " colour 148,26,20 # colour" HOST_NL + " uint_8 130 # opacity" HOST_NL + " ufraction 0.625 # ka" HOST_NL + " ufraction 1.125 # kd" HOST_NL + " ufraction 0.525 # ks" HOST_NL + " scalar 31 # power" HOST_NL + " uint_32 68 # flags" HOST_NL + " vector2 -0.499972,0.866041 # map_transform.m[0]" HOST_NL + " vector2 -0.866041,-0.499972 # map_transform.m[1]" HOST_NL + " vector2 0.125,0.875 # map_transform.m[2]" HOST_NL + " uint_8 22 # index_base" HOST_NL + " uint_8 51 # index_range" HOST_NL + " scalar 1.375 # fog_min" HOST_NL + " scalar 2.375 # fog_max" HOST_NL + " colour 10,20,30 # fog_colour" HOST_NL + " int_32 8 # subdivide_tolerance" HOST_NL + " asciz \"test_material_3\" # identifier" HOST_NL + "*COLOUR_MAP_REF 1" HOST_NL + " name \"test_map_1\"" HOST_NL + "*INDEX_BLEND_REF 1" HOST_NL + " name \"test_table_0\"" HOST_NL + "*SCREENDOOR_REF 1" HOST_NL + " name \"test_table_4\"" HOST_NL + "*INDEX_FOG_REF 1" HOST_NL + " name \"test_table_3\"" HOST_NL + "*END 0" HOST_NL; +static void test_v1dbfile_save_load_material_many() { +#define MATERIAL_MANY_NB 4 +#define MATERIAL_MANY_READ_CAPACITY (MATERIAL_MANY_NB*5) + br_material *materials_ref[MATERIAL_MANY_NB]; + br_material* materials_read[2][MATERIAL_MANY_READ_CAPACITY]; + char name[128]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + int i; + int k; + int res; + + register_test_items(); + + for (i = 0; i < MATERIAL_MANY_NB; i++) { + sprintf(name, "test_material_%d", i); + materials_ref[i] = BrMaterialFind(name); + TEST_ASSERT_NOT_NULL(materials_ref[i]); + } + + create_temp_file(tmpfilename_binary, "material_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrMaterialSaveMany(tmpfilename_binary, materials_ref, MATERIAL_MANY_NB); + TEST_ASSERT_EQUAL_INT(MATERIAL_MANY_NB, res); + + create_temp_file(tmpfilename_text, "material_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrMaterialSaveMany(tmpfilename_text, materials_ref, MATERIAL_MANY_NB); + TEST_ASSERT_EQUAL_INT(MATERIAL_MANY_NB, res); + + LOG_DEBUG("Read binary material"); + res = BrMaterialLoadMany(tmpfilename_binary, materials_read[0], MATERIAL_MANY_READ_CAPACITY); + TEST_ASSERT_EQUAL(MATERIAL_MANY_NB, res); + LOG_DEBUG("Read text material"); + res = BrMaterialLoadMany(tmpfilename_text, materials_read[1], MATERIAL_MANY_READ_CAPACITY); + TEST_ASSERT_EQUAL(MATERIAL_MANY_NB, res); + + for (i = 0; i < BR_ASIZE(materials_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + for (k = 0; k < MATERIAL_MANY_NB; k++) { + TEST_COMPARE_MATERIAL(materials_ref[k], materials_read[i][k]); + } + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_material_many, tmpfilename_binary, sizeof(binary_material_many)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_material_many, tmpfilename_text); + + for (k = 0; k < MATERIAL_MANY_NB; k++) { + BrResFree(materials_read[0][k]); + BrResFree(materials_read[1][k]); + } +} + +uint8_t binary_model_lone[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0xfa, 0xce, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x0e, + 0x80, 0x80, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, + 0x5f, 0x32, 0x00, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x40, 0x00, + 0x00, 0x00, 0x05, 0x40, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x40, + 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x40, + 0x40, 0x00, 0x00, 0x40, 0x80, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x40, + 0x80, 0x00, 0x00, 0x40, 0xa0, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x40, + 0xa0, 0x00, 0x00, 0x40, 0xc0, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x40, + 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x2c, 0x00, + 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x3e, 0xcc, 0xcc, 0xcd, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x00, + 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x02, 0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x03, + 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x06, 0x02, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; +char *text_model_lone = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_MODEL # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*MODEL 3" HOST_NL + " struct br_model" HOST_NL + " uint_16 32896 # flags" HOST_NL + " asciz \"test_model_2\" # identifier" HOST_NL + "*VERTICES 21" HOST_NL + " count 5" HOST_NL + " struct br_vertex" HOST_NL + " scalar 2 # p.v[x]" HOST_NL + " scalar 2 # p.v[y]" HOST_NL + " scalar 2 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 3 # p.v[x]" HOST_NL + " scalar 3 # p.v[y]" HOST_NL + " scalar 3 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 4 # p.v[x]" HOST_NL + " scalar 2 # p.v[y]" HOST_NL + " scalar 4 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 5 # p.v[x]" HOST_NL + " scalar 3 # p.v[y]" HOST_NL + " scalar 5 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 6 # p.v[x]" HOST_NL + " scalar 2 # p.v[y]" HOST_NL + " scalar 6 # p.v[z]" HOST_NL + "*VERTEX_UV 16" HOST_NL + " count 5" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0.4 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + "*FACES 19" HOST_NL + " count 3" HOST_NL + " struct br_face" HOST_NL + " uint_16 0 # vertices[0]" HOST_NL + " uint_16 1 # vertices[1]" HOST_NL + " uint_16 2 # vertices[2]" HOST_NL + " uint_16 65535 # smoothing" HOST_NL + " uint_8 0 # flags" HOST_NL + " struct br_face" HOST_NL + " uint_16 1 # vertices[0]" HOST_NL + " uint_16 2 # vertices[1]" HOST_NL + " uint_16 3 # vertices[2]" HOST_NL + " uint_16 3 # smoothing" HOST_NL + " uint_8 1 # flags" HOST_NL + " struct br_face" HOST_NL + " uint_16 2 # vertices[0]" HOST_NL + " uint_16 3 # vertices[1]" HOST_NL + " uint_16 4 # vertices[2]" HOST_NL + " uint_16 6 # smoothing" HOST_NL + " uint_8 2 # flags" HOST_NL + "*END 0" HOST_NL; +static void test_v1dbfile_save_load_model_lone() { + br_model *model_ref; + br_model* models_read[2]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + int i; + int res; + + register_test_items(); + + model_ref = BrModelFind("test_model_2"); + TEST_ASSERT_NOT_NULL(model_ref); + + create_temp_file(tmpfilename_binary, "model_lone_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrModelSave(tmpfilename_binary, model_ref); + TEST_ASSERT_EQUAL(1, res); + + create_temp_file(tmpfilename_text, "model_lone_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrModelSave(tmpfilename_text, model_ref); + TEST_ASSERT_EQUAL(1, res); + + puts("Read binary model"); + models_read[0] = BrModelLoad(tmpfilename_binary); + puts("Read text model"); + models_read[1] = BrModelLoad(tmpfilename_text); + + for (i = 0; i < BR_ASIZE(models_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_COMPARE_MODEL(model_ref, models_read[i]); + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_model_lone, tmpfilename_binary, sizeof(binary_model_lone)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_model_lone, tmpfilename_text); + + BrResFree(models_read[0]); + BrResFree(models_read[1]); +} + +uint8_t binary_model_many[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0xfa, 0xce, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, 0x0e, + 0x80, 0x80, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, + 0x5f, 0x30, 0x00, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x28, 0x00, + 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x3f, 0x80, 0x00, 0x00, 0x3f, 0x80, 0x00, 0x00, 0x3f, + 0x80, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x0d, 0x00, + 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0xff, 0xff, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, + 0x00, 0x00, 0x00, 0x0e, 0x00, 0xc0, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, + 0x6f, 0x64, 0x65, 0x6c, 0x5f, 0x31, 0x00, 0x00, 0x00, 0x00, 0x17, 0x00, + 0x00, 0x00, 0x34, 0x00, 0x00, 0x00, 0x04, 0x3f, 0x80, 0x00, 0x00, 0x3f, + 0x80, 0x00, 0x00, 0x3f, 0x80, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x40, + 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x3f, + 0x80, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x40, 0x80, 0x00, 0x00, 0x40, + 0x00, 0x00, 0x00, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, + 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, 0x00, 0x16, 0x00, + 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00, 0x00, + 0x0e, 0x80, 0x80, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x6f, 0x64, 0x65, + 0x6c, 0x5f, 0x32, 0x00, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, 0x00, 0x40, + 0x00, 0x00, 0x00, 0x05, 0x40, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, + 0x40, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, + 0x40, 0x40, 0x00, 0x00, 0x40, 0x80, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, + 0x40, 0x80, 0x00, 0x00, 0x40, 0xa0, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, + 0x40, 0xa0, 0x00, 0x00, 0x40, 0xc0, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, + 0x40, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x2c, + 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3e, 0xcc, 0xcc, 0xcd, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, + 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x02, 0xff, 0xff, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, + 0x03, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x06, 0x02, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, + 0x00, 0x00, 0x0e, 0x00, 0xc0, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x6f, + 0x64, 0x65, 0x6c, 0x5f, 0x33, 0x00, 0x00, 0x00, 0x00, 0x17, 0x00, 0x00, + 0x00, 0x4c, 0x00, 0x00, 0x00, 0x06, 0x40, 0x40, 0x00, 0x00, 0x40, 0x40, + 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x40, 0x80, 0x00, 0x00, 0x40, 0x80, + 0x00, 0x00, 0x40, 0x80, 0x00, 0x00, 0x40, 0xa0, 0x00, 0x00, 0x40, 0x40, + 0x00, 0x00, 0x40, 0xa0, 0x00, 0x00, 0x40, 0xc0, 0x00, 0x00, 0x40, 0x80, + 0x00, 0x00, 0x40, 0xc0, 0x00, 0x00, 0x40, 0xe0, 0x00, 0x00, 0x40, 0x40, + 0x00, 0x00, 0x40, 0xe0, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x40, 0x80, + 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, + 0x00, 0x34, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0xaa, 0xaa, 0xab, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x2a, + 0xaa, 0xab, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x00, 0x00, + 0x00, 0x28, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x03, 0x01, + 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x06, 0x02, 0x00, 0x03, 0x00, + 0x04, 0x00, 0x05, 0x00, 0x09, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, +}; +char *text_model_many = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_MODEL # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*MODEL 3" HOST_NL + " struct br_model" HOST_NL + " uint_16 32896 # flags" HOST_NL + " asciz \"test_model_0\" # identifier" HOST_NL + "*VERTICES 13" HOST_NL + " count 3" HOST_NL + " struct br_vertex" HOST_NL + " scalar 0 # p.v[x]" HOST_NL + " scalar 0 # p.v[y]" HOST_NL + " scalar 0 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 1 # p.v[x]" HOST_NL + " scalar 1 # p.v[y]" HOST_NL + " scalar 1 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 2 # p.v[x]" HOST_NL + " scalar 0 # p.v[y]" HOST_NL + " scalar 2 # p.v[z]" HOST_NL + "*FACES 7" HOST_NL + " count 1" HOST_NL + " struct br_face" HOST_NL + " uint_16 0 # vertices[0]" HOST_NL + " uint_16 1 # vertices[1]" HOST_NL + " uint_16 2 # vertices[2]" HOST_NL + " uint_16 65535 # smoothing" HOST_NL + " uint_8 0 # flags" HOST_NL + "*END 0" HOST_NL + "*MODEL 3" HOST_NL + " struct br_model" HOST_NL + " uint_16 192 # flags" HOST_NL + " asciz \"test_model_1\" # identifier" HOST_NL + "*VERTICES 17" HOST_NL + " count 4" HOST_NL + " struct br_vertex" HOST_NL + " scalar 1 # p.v[x]" HOST_NL + " scalar 1 # p.v[y]" HOST_NL + " scalar 1 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 2 # p.v[x]" HOST_NL + " scalar 2 # p.v[y]" HOST_NL + " scalar 2 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 3 # p.v[x]" HOST_NL + " scalar 1 # p.v[y]" HOST_NL + " scalar 3 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 4 # p.v[x]" HOST_NL + " scalar 2 # p.v[y]" HOST_NL + " scalar 4 # p.v[z]" HOST_NL + "*VERTEX_UV 13" HOST_NL + " count 4" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0.5 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + "*FACES 13" HOST_NL + " count 2" HOST_NL + " struct br_face" HOST_NL + " uint_16 0 # vertices[0]" HOST_NL + " uint_16 1 # vertices[1]" HOST_NL + " uint_16 2 # vertices[2]" HOST_NL + " uint_16 0 # smoothing" HOST_NL + " uint_8 0 # flags" HOST_NL + " struct br_face" HOST_NL + " uint_16 1 # vertices[0]" HOST_NL + " uint_16 2 # vertices[1]" HOST_NL + " uint_16 3 # vertices[2]" HOST_NL + " uint_16 3 # smoothing" HOST_NL + " uint_8 1 # flags" HOST_NL + "*END 0" HOST_NL + "*MODEL 3" HOST_NL + " struct br_model" HOST_NL + " uint_16 32896 # flags" HOST_NL + " asciz \"test_model_2\" # identifier" HOST_NL + "*VERTICES 21" HOST_NL + " count 5" HOST_NL + " struct br_vertex" HOST_NL + " scalar 2 # p.v[x]" HOST_NL + " scalar 2 # p.v[y]" HOST_NL + " scalar 2 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 3 # p.v[x]" HOST_NL + " scalar 3 # p.v[y]" HOST_NL + " scalar 3 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 4 # p.v[x]" HOST_NL + " scalar 2 # p.v[y]" HOST_NL + " scalar 4 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 5 # p.v[x]" HOST_NL + " scalar 3 # p.v[y]" HOST_NL + " scalar 5 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 6 # p.v[x]" HOST_NL + " scalar 2 # p.v[y]" HOST_NL + " scalar 6 # p.v[z]" HOST_NL + "*VERTEX_UV 16" HOST_NL + " count 5" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0.4 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + "*FACES 19" HOST_NL + " count 3" HOST_NL + " struct br_face" HOST_NL + " uint_16 0 # vertices[0]" HOST_NL + " uint_16 1 # vertices[1]" HOST_NL + " uint_16 2 # vertices[2]" HOST_NL + " uint_16 65535 # smoothing" HOST_NL + " uint_8 0 # flags" HOST_NL + " struct br_face" HOST_NL + " uint_16 1 # vertices[0]" HOST_NL + " uint_16 2 # vertices[1]" HOST_NL + " uint_16 3 # vertices[2]" HOST_NL + " uint_16 3 # smoothing" HOST_NL + " uint_8 1 # flags" HOST_NL + " struct br_face" HOST_NL + " uint_16 2 # vertices[0]" HOST_NL + " uint_16 3 # vertices[1]" HOST_NL + " uint_16 4 # vertices[2]" HOST_NL + " uint_16 6 # smoothing" HOST_NL + " uint_8 2 # flags" HOST_NL + "*END 0" HOST_NL + "*MODEL 3" HOST_NL + " struct br_model" HOST_NL + " uint_16 192 # flags" HOST_NL + " asciz \"test_model_3\" # identifier" HOST_NL + "*VERTICES 25" HOST_NL + " count 6" HOST_NL + " struct br_vertex" HOST_NL + " scalar 3 # p.v[x]" HOST_NL + " scalar 3 # p.v[y]" HOST_NL + " scalar 3 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 4 # p.v[x]" HOST_NL + " scalar 4 # p.v[y]" HOST_NL + " scalar 4 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 5 # p.v[x]" HOST_NL + " scalar 3 # p.v[y]" HOST_NL + " scalar 5 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 6 # p.v[x]" HOST_NL + " scalar 4 # p.v[y]" HOST_NL + " scalar 6 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 7 # p.v[x]" HOST_NL + " scalar 3 # p.v[y]" HOST_NL + " scalar 7 # p.v[z]" HOST_NL + " struct br_vertex" HOST_NL + " scalar 8 # p.v[x]" HOST_NL + " scalar 4 # p.v[y]" HOST_NL + " scalar 8 # p.v[z]" HOST_NL + "*VERTEX_UV 19" HOST_NL + " count 6" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0.333333 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + " struct br_vertex_uv" HOST_NL + " scalar 0.666667 # map.v[0]" HOST_NL + " scalar 0 # map.v[1]" HOST_NL + "*FACES 25" HOST_NL + " count 4" HOST_NL + " struct br_face" HOST_NL + " uint_16 0 # vertices[0]" HOST_NL + " uint_16 1 # vertices[1]" HOST_NL + " uint_16 2 # vertices[2]" HOST_NL + " uint_16 0 # smoothing" HOST_NL + " uint_8 0 # flags" HOST_NL + " struct br_face" HOST_NL + " uint_16 1 # vertices[0]" HOST_NL + " uint_16 2 # vertices[1]" HOST_NL + " uint_16 3 # vertices[2]" HOST_NL + " uint_16 3 # smoothing" HOST_NL + " uint_8 1 # flags" HOST_NL + " struct br_face" HOST_NL + " uint_16 2 # vertices[0]" HOST_NL + " uint_16 3 # vertices[1]" HOST_NL + " uint_16 4 # vertices[2]" HOST_NL + " uint_16 6 # smoothing" HOST_NL + " uint_8 2 # flags" HOST_NL + " struct br_face" HOST_NL + " uint_16 3 # vertices[0]" HOST_NL + " uint_16 4 # vertices[1]" HOST_NL + " uint_16 5 # vertices[2]" HOST_NL + " uint_16 9 # smoothing" HOST_NL + " uint_8 3 # flags" HOST_NL + "*END 0" HOST_NL; +static void test_v1dbfile_save_load_model_many() { +#define MODEL_MANY_NB 4 +#define MODEL_MANY_READ_CAPACITY (MATERIAL_MANY_NB*5) + br_model *models_ref[MODEL_MANY_NB]; + br_model* models_read[2][MODEL_MANY_READ_CAPACITY]; + char name[128]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + int i; + int k; + int res; + + register_test_items(); + + for (i = 0; i < MODEL_MANY_NB; i++) { + sprintf(name, "test_model_%d", i); + models_ref[i] = BrModelFind(name); + TEST_ASSERT_NOT_NULL(models_ref[i]); + } + + create_temp_file(tmpfilename_binary, "model_many_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrModelSaveMany(tmpfilename_binary, models_ref, MODEL_MANY_NB); + TEST_ASSERT_EQUAL_INT(MODEL_MANY_NB, res); + + create_temp_file(tmpfilename_text, "model_many_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrModelSaveMany(tmpfilename_text, models_ref, MODEL_MANY_NB); + TEST_ASSERT_EQUAL_INT(MODEL_MANY_NB, res); + + LOG_DEBUG("Read binary model"); + res = BrModelLoadMany(tmpfilename_binary, models_read[0], MODEL_MANY_READ_CAPACITY); + TEST_ASSERT_EQUAL_INT(MODEL_MANY_NB, res); + LOG_DEBUG("Read text model"); + res = BrModelLoadMany(tmpfilename_text, models_read[1], MODEL_MANY_READ_CAPACITY); + TEST_ASSERT_EQUAL_INT(MODEL_MANY_NB, res); + + for (i = 0; i < BR_ASIZE(models_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + for (k = 0; k < MODEL_MANY_NB; k++) { + TEST_COMPARE_MODEL(models_ref[k], models_read[i][k]); + } + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_model_many, tmpfilename_binary, sizeof(binary_model_many)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_model_many, tmpfilename_text); + + for (k = 0; k < MATERIAL_MANY_NB; k++) { + BrResFree(models_read[0][k]); + BrResFree(models_read[1][k]); + } +} + +static br_uint_8 binary_actor_none_unity_lone[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x21, + 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x6f, 0x72, + 0x5f, 0x6e, 0x6f, 0x6e, 0x65, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, + 0x6f, 0x72, 0x6d, 0x5f, 0x75, 0x6e, 0x69, 0x74, 0x79, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; +static char *text_actor_none_unity_lone = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_ACTORS # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*ACTOR 4" HOST_NL + " struct br_actor" HOST_NL + " enum_8 BR_ACTOR_NONE # type" HOST_NL + " enum_8 BR_RSTYLE_DEFAULT # render_style" HOST_NL + " asciz \"test_actor_none_transform_unity\" # identifier" HOST_NL + "*END 0" HOST_NL; +static void test_v1dbfile_save_load_actor_none_transform_unity_lone() { + br_actor* actor_ref; + br_actor* actors_read[2]; + char name[128]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + int i; + int k; + int res; + + register_test_items(); + actor_ref = create_test_actor("test_actor_none_transform_unity", BR_ACTOR_NONE, BR_TRANSFORM_IDENTITY,0); + + create_temp_file(tmpfilename_binary, "actor_none_transform_unity_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrActorSave(tmpfilename_binary, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + create_temp_file(tmpfilename_text, "actor_none_transform_unity_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrActorSave(tmpfilename_text, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + LOG_DEBUG("Read binary actor"); + actors_read[0] = BrActorLoad(tmpfilename_binary); + TEST_ASSERT_NOT_NULL(actors_read[0]); + LOG_DEBUG("Read text actor"); + actors_read[1] = BrActorLoad(tmpfilename_text); + TEST_ASSERT_NOT_NULL(actors_read[1]); + + for (i = 0; i < BR_ASIZE(actors_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_COMPARE_ACTOR(actor_ref, actors_read[i]); + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_actor_none_unity_lone, tmpfilename_binary, sizeof(binary_actor_none_unity_lone)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_actor_none_unity_lone, tmpfilename_text); + + BrResFree(actor_ref); + BrResFree(actors_read[0]); + BrResFree(actors_read[1]); +} + +static br_uint_8 binary_actor_none_matrix34_lone[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x24, + 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x6f, 0x72, + 0x5f, 0x6e, 0x6f, 0x6e, 0x65, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, + 0x6f, 0x72, 0x6d, 0x5f, 0x6d, 0x61, 0x74, 0x72, 0x69, 0x78, 0x33, 0x34, + 0x00, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0x30, 0x3f, 0x80, 0x00, + 0x00, 0x40, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x40, 0x80, 0x00, + 0x00, 0x40, 0xa0, 0x00, 0x00, 0x40, 0xc0, 0x00, 0x00, 0x40, 0xe0, 0x00, + 0x00, 0x41, 0x00, 0x00, 0x00, 0x41, 0x10, 0x00, 0x00, 0x41, 0x20, 0x00, + 0x00, 0x41, 0x30, 0x00, 0x00, 0x41, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, +}; +static char *text_actor_none_matrix34_lone = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_ACTORS # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*ACTOR 4" HOST_NL + " struct br_actor" HOST_NL + " enum_8 BR_ACTOR_NONE # type" HOST_NL + " enum_8 BR_RSTYLE_DEFAULT # render_style" HOST_NL + " asciz \"test_actor_none_transform_matrix34\" # identifier" HOST_NL + "*TRANSFORM_MATRIX34 5" HOST_NL + " struct br_transform_matrix34" HOST_NL + " vector3 1,2,3 # t.mat.m[0]" HOST_NL + " vector3 4,5,6 # t.mat.m[1]" HOST_NL + " vector3 7,8,9 # t.mat.m[2]" HOST_NL + " vector3 10,11,12 # t.mat.m[3]" HOST_NL + "*ACTOR_TRANSFORM 0" HOST_NL + "*END 0" HOST_NL; +static void test_v1dbfile_save_load_actor_none_transform_matrix34_lone() { + br_actor* actor_ref; + br_actor* actors_read[2]; + char name[128]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + int i; + int k; + int res; + + register_test_items(); + actor_ref = create_test_actor("test_actor_none_transform_matrix34", BR_ACTOR_NONE, BR_TRANSFORM_MATRIX34,0); + + create_temp_file(tmpfilename_binary, "actor_none_transform_matrix34_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrActorSave(tmpfilename_binary, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + create_temp_file(tmpfilename_text, "actor_none_transform_matrix34_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrActorSave(tmpfilename_text, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + LOG_DEBUG("Read binary actor"); + actors_read[0] = BrActorLoad(tmpfilename_binary); + TEST_ASSERT_NOT_NULL(actors_read[0]); + LOG_DEBUG("Read text actor"); + actors_read[1] = BrActorLoad(tmpfilename_text); + TEST_ASSERT_NOT_NULL(actors_read[1]); + + for (i = 0; i < BR_ASIZE(actors_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_COMPARE_ACTOR(actor_ref, actors_read[i]); + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_actor_none_matrix34_lone, tmpfilename_binary, sizeof(binary_actor_none_matrix34_lone)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_actor_none_matrix34_lone, tmpfilename_text); + + BrResFree(actor_ref); + BrResFree(actors_read[0]); + BrResFree(actors_read[1]); +} + +static br_uint_8 binary_actor_none_matrix34lp_lone[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x26, + 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x6f, 0x72, + 0x5f, 0x6e, 0x6f, 0x6e, 0x65, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, + 0x6f, 0x72, 0x6d, 0x5f, 0x6d, 0x61, 0x74, 0x72, 0x69, 0x78, 0x33, 0x34, + 0x6c, 0x70, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x30, 0x3f, + 0x80, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x40, + 0x80, 0x00, 0x00, 0x40, 0xa0, 0x00, 0x00, 0x40, 0xc0, 0x00, 0x00, 0x40, + 0xe0, 0x00, 0x00, 0x41, 0x00, 0x00, 0x00, 0x41, 0x10, 0x00, 0x00, 0x41, + 0x20, 0x00, 0x00, 0x41, 0x30, 0x00, 0x00, 0x41, 0x40, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, +}; +static char *text_actor_none_matrix34lp_lone = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_ACTORS # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*ACTOR 4" HOST_NL + " struct br_actor" HOST_NL + " enum_8 BR_ACTOR_NONE # type" HOST_NL + " enum_8 BR_RSTYLE_DEFAULT # render_style" HOST_NL + " asciz \"test_actor_none_transform_matrix34lp\" # identifier" HOST_NL + "*TRANSFORM_MATRIX34_LP 5" HOST_NL + " struct br_transform_matrix34" HOST_NL + " vector3 1,2,3 # t.mat.m[0]" HOST_NL + " vector3 4,5,6 # t.mat.m[1]" HOST_NL + " vector3 7,8,9 # t.mat.m[2]" HOST_NL + " vector3 10,11,12 # t.mat.m[3]" HOST_NL + "*ACTOR_TRANSFORM 0" HOST_NL + "*END 0" HOST_NL; +static void test_v1dbfile_save_load_actor_none_transform_matrix34lp_lone() { + br_actor* actor_ref; + br_actor* actors_read[2]; + char name[128]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + int i; + int k; + int res; + + register_test_items(); + actor_ref = create_test_actor("test_actor_none_transform_matrix34lp", BR_ACTOR_NONE, BR_TRANSFORM_MATRIX34_LP,0); + + create_temp_file(tmpfilename_binary, "actor_none_transform_matrix34lp_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrActorSave(tmpfilename_binary, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + create_temp_file(tmpfilename_text, "actor_none_transform_matrix34lp_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrActorSave(tmpfilename_text, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + LOG_DEBUG("Read binary actor"); + actors_read[0] = BrActorLoad(tmpfilename_binary); + TEST_ASSERT_NOT_NULL(actors_read[0]); + LOG_DEBUG("Read text actor"); + actors_read[1] = BrActorLoad(tmpfilename_text); + TEST_ASSERT_NOT_NULL(actors_read[1]); + + for (i = 0; i < BR_ASIZE(actors_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_COMPARE_ACTOR(actor_ref, actors_read[i]); + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_actor_none_matrix34lp_lone, tmpfilename_binary, sizeof(binary_actor_none_matrix34lp_lone)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_actor_none_matrix34lp_lone, tmpfilename_text); + + BrResFree(actor_ref); + BrResFree(actors_read[0]); + BrResFree(actors_read[1]); +} + +static br_uint_8 binary_actor_none_quat_lone[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x20, + 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x6f, 0x72, + 0x5f, 0x6e, 0x6f, 0x6e, 0x65, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, + 0x6f, 0x72, 0x6d, 0x5f, 0x71, 0x75, 0x61, 0x74, 0x00, 0x00, 0x00, 0x00, + 0x2d, 0x00, 0x00, 0x00, 0x1c, 0x3d, 0xcc, 0xcc, 0xcd, 0x3e, 0x4c, 0xcc, + 0xcd, 0x3e, 0x99, 0x99, 0x9a, 0x3e, 0xcc, 0xcc, 0xcd, 0x40, 0x00, 0x00, + 0x00, 0x40, 0x40, 0x00, 0x00, 0x40, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, +}; +static char *text_actor_none_quat_lone = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_ACTORS # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*ACTOR 4" HOST_NL + " struct br_actor" HOST_NL + " enum_8 BR_ACTOR_NONE # type" HOST_NL + " enum_8 BR_RSTYLE_DEFAULT # render_style" HOST_NL + " asciz \"test_actor_none_transform_quat\" # identifier" HOST_NL + "*TRANSFORM_QUAT 6" HOST_NL + " struct br_transform_quat" HOST_NL + " scalar 0.1 # t.quat.q.x" HOST_NL + " scalar 0.2 # t.quat.q.y" HOST_NL + " scalar 0.3 # t.quat.q.z" HOST_NL + " scalar 0.4 # t.quat.q.w" HOST_NL + " vector3 2,3,4 # t.quat.t" HOST_NL + "*ACTOR_TRANSFORM 0" HOST_NL + "*END 0" HOST_NL; +static void test_v1dbfile_save_load_actor_none_transform_quat_lone() { + br_actor* actor_ref; + br_actor* actors_read[2]; + char name[128]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + int i; + int k; + int res; + + register_test_items(); + actor_ref = create_test_actor("test_actor_none_transform_quat", BR_ACTOR_NONE, BR_TRANSFORM_QUAT,0); + + create_temp_file(tmpfilename_binary, "actor_none_transform_quat_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrActorSave(tmpfilename_binary, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + create_temp_file(tmpfilename_text, "actor_none_transform_quat_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrActorSave(tmpfilename_text, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + LOG_DEBUG("Read binary actor"); + actors_read[0] = BrActorLoad(tmpfilename_binary); + TEST_ASSERT_NOT_NULL(actors_read[0]); + LOG_DEBUG("Read text actor"); + actors_read[1] = BrActorLoad(tmpfilename_text); + TEST_ASSERT_NOT_NULL(actors_read[1]); + + for (i = 0; i < BR_ASIZE(actors_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_COMPARE_ACTOR(actor_ref, actors_read[i]); + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_actor_none_quat_lone, tmpfilename_binary, sizeof(binary_actor_none_quat_lone)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_actor_none_quat_lone, tmpfilename_text); + + BrResFree(actor_ref); + BrResFree(actors_read[0]); + BrResFree(actors_read[1]); +} + +static br_uint_8 binary_actor_none_lookup_lone[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x22, + 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x6f, 0x72, + 0x5f, 0x6e, 0x6f, 0x6e, 0x65, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, + 0x6f, 0x72, 0x6d, 0x5f, 0x6c, 0x6f, 0x6f, 0x6b, 0x75, 0x70, 0x00, 0x00, + 0x00, 0x00, 0x2f, 0x00, 0x00, 0x00, 0x24, 0x3f, 0x80, 0x00, 0x00, 0x40, + 0x00, 0x00, 0x00, 0x40, 0x40, 0x00, 0x00, 0x40, 0x80, 0x00, 0x00, 0x40, + 0xa0, 0x00, 0x00, 0x40, 0xc0, 0x00, 0x00, 0x40, 0xe0, 0x00, 0x00, 0x41, + 0x00, 0x00, 0x00, 0x41, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; +static char *text_actor_none_lookup_lone = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_ACTORS # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*ACTOR 4" HOST_NL + " struct br_actor" HOST_NL + " enum_8 BR_ACTOR_NONE # type" HOST_NL + " enum_8 BR_RSTYLE_DEFAULT # render_style" HOST_NL + " asciz \"test_actor_none_transform_lookup\" # identifier" HOST_NL + "*TRANSFORM_LOOK_UP 4" HOST_NL + " struct br_transform_look_up" HOST_NL + " vector3 1,2,3 # t.look_up.look" HOST_NL + " vector3 4,5,6 # t.look_up.up" HOST_NL + " vector3 7,8,9 # t.look_up.t" HOST_NL + "*ACTOR_TRANSFORM 0" HOST_NL + "*END 0" HOST_NL; +static void test_v1dbfile_save_load_actor_none_transform_lookup_lone() { + br_actor* actor_ref; + br_actor* actors_read[2]; + char name[128]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + int i; + int k; + int res; + + register_test_items(); + actor_ref = create_test_actor("test_actor_none_transform_lookup", BR_ACTOR_NONE, BR_TRANSFORM_LOOK_UP,0); + + create_temp_file(tmpfilename_binary, "actor_none_transform_lookup_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrActorSave(tmpfilename_binary, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + create_temp_file(tmpfilename_text, "actor_none_transform_lookup_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrActorSave(tmpfilename_text, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + LOG_DEBUG("Read binary actor"); + actors_read[0] = BrActorLoad(tmpfilename_binary); + TEST_ASSERT_NOT_NULL(actors_read[0]); + LOG_DEBUG("Read text actor"); + actors_read[1] = BrActorLoad(tmpfilename_text); + TEST_ASSERT_NOT_NULL(actors_read[1]); + + for (i = 0; i < BR_ASIZE(actors_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_COMPARE_ACTOR(actor_ref, actors_read[i]); + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_actor_none_lookup_lone, tmpfilename_binary, sizeof(binary_actor_none_lookup_lone)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_actor_none_lookup_lone, tmpfilename_text); + + BrResFree(actor_ref); + BrResFree(actors_read[0]); + BrResFree(actors_read[1]); +} + +static br_uint_8 binary_actor_none_euler_lone[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x21, + 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x6f, 0x72, + 0x5f, 0x6e, 0x6f, 0x6e, 0x65, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, + 0x6f, 0x72, 0x6d, 0x5f, 0x65, 0x75, 0x6c, 0x65, 0x72, 0x00, 0x00, 0x00, + 0x00, 0x2e, 0x00, 0x00, 0x00, 0x13, 0x11, 0x10, 0x00, 0x20, 0x00, 0x30, + 0x00, 0x40, 0x40, 0x00, 0x00, 0x40, 0xc0, 0x00, 0x00, 0x41, 0x10, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, +}; +static char *text_actor_none_euler_lone = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_ACTORS # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*ACTOR 4" HOST_NL + " struct br_actor" HOST_NL + " enum_8 BR_ACTOR_NONE # type" HOST_NL + " enum_8 BR_RSTYLE_DEFAULT # render_style" HOST_NL + " asciz \"test_actor_none_transform_euler\" # identifier" HOST_NL + "*TRANSFORM_EULER 6" HOST_NL + " struct br_transform_euler" HOST_NL + " enum_8 BR_EULER_XZY_R # t.euler.e.order" HOST_NL + " angle 22.5 # t.euler.e.a" HOST_NL + " angle 45 # t.euler.e.b" HOST_NL + " angle 67.5 # t.euler.e.c" HOST_NL + " vector3 3,6,9 # t.euler.t" HOST_NL + "*ACTOR_TRANSFORM 0" HOST_NL + "*END 0" HOST_NL; +static void test_v1dbfile_save_load_actor_none_transform_euler_lone() { + br_actor* actor_ref; + br_actor* actors_read[2]; + char name[128]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + int i; + int k; + int res; + + register_test_items(); + actor_ref = create_test_actor("test_actor_none_transform_euler", BR_ACTOR_NONE, BR_TRANSFORM_EULER,0); + + create_temp_file(tmpfilename_binary, "actor_none_transform_euler_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrActorSave(tmpfilename_binary, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + create_temp_file(tmpfilename_text, "actor_none_transform_euler_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrActorSave(tmpfilename_text, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + LOG_DEBUG("Read binary actor"); + actors_read[0] = BrActorLoad(tmpfilename_binary); + TEST_ASSERT_NOT_NULL(actors_read[0]); + LOG_DEBUG("Read text actor"); + actors_read[1] = BrActorLoad(tmpfilename_text); + TEST_ASSERT_NOT_NULL(actors_read[1]); + + for (i = 0; i < BR_ASIZE(actors_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_COMPARE_ACTOR(actor_ref, actors_read[i]); + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_actor_none_euler_lone, tmpfilename_binary, sizeof(binary_actor_none_euler_lone)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_actor_none_euler_lone, tmpfilename_text); + + BrResFree(actor_ref); + BrResFree(actors_read[0]); + BrResFree(actors_read[1]); +} + +static br_uint_8 binary_actor_model_lone[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x12, + 0x01, 0x04, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x6f, 0x72, + 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x26, 0x00, + 0x00, 0x00, 0x10, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x61, 0x74, 0x65, + 0x72, 0x69, 0x61, 0x6c, 0x5f, 0x30, 0x00, 0x00, 0x00, 0x00, 0x24, 0x00, + 0x00, 0x00, 0x0d, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x6d, 0x6f, 0x64, 0x65, + 0x6c, 0x5f, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; +static char *text_actor_model_lone = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_ACTORS # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*ACTOR 4" HOST_NL + " struct br_actor" HOST_NL + " enum_8 BR_ACTOR_MODEL # type" HOST_NL + " enum_8 BR_RSTYLE_FACES # render_style" HOST_NL + " asciz \"test_actor_model\" # identifier" HOST_NL + "*ACTOR_MATERIAL 1" HOST_NL + " name \"test_material_0\"" HOST_NL + "*ACTOR_MODEL 1" HOST_NL + " name \"test_model_0\"" HOST_NL + "*END 0" HOST_NL; +static void test_v1dbfile_save_load_actor_model_lone() { + br_actor* actor_ref; + br_actor* actors_read[2]; + char name[128]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + int i; + int k; + int res; + + register_test_items(); + actor_ref = create_test_actor("test_actor_model", BR_ACTOR_MODEL, BR_TRANSFORM_IDENTITY, 0); + + create_temp_file(tmpfilename_binary, "actor_model_lone_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrActorSave(tmpfilename_binary, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + create_temp_file(tmpfilename_text, "actor_model_lone_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrActorSave(tmpfilename_text, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + LOG_DEBUG("Read binary actor"); + actors_read[0] = BrActorLoad(tmpfilename_binary); + TEST_ASSERT_NOT_NULL(actors_read[0]); + LOG_DEBUG("Read text actor"); + actors_read[1] = BrActorLoad(tmpfilename_text); + TEST_ASSERT_NOT_NULL(actors_read[1]); + + for (i = 0; i < BR_ASIZE(actors_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_COMPARE_ACTOR(actor_ref, actors_read[i]); + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_actor_model_lone, tmpfilename_binary, sizeof(binary_actor_model_lone)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_actor_model_lone, tmpfilename_text); + + BrResFree(actor_ref); + BrResFree(actors_read[0]); + BrResFree(actors_read[1]); +} + +static br_uint_8 binary_actor_light_lone[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x12, + 0x02, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x6f, 0x72, + 0x5f, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x00, 0x00, 0x00, 0x00, 0x33, 0x00, + 0x00, 0x00, 0x15, 0x01, 0x12, 0x34, 0x56, 0x3e, 0x00, 0x00, 0x00, 0x3d, + 0x80, 0x00, 0x00, 0x3e, 0x80, 0x00, 0x00, 0x15, 0x54, 0x2a, 0xa8, 0x00, + 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, +}; +static char *text_actor_light_lone = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_ACTORS # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*ACTOR 4" HOST_NL + " struct br_actor" HOST_NL + " enum_8 BR_ACTOR_LIGHT # type" HOST_NL + " enum_8 BR_RSTYLE_DEFAULT # render_style" HOST_NL + " asciz \"test_actor_light\" # identifier" HOST_NL + "*LIGHT 9" HOST_NL + " struct br_light" HOST_NL + " enum_8 BR_LIGHT_DIRECT # type" HOST_NL + " colour 18,52,86 # colour" HOST_NL + " scalar 0.125 # attenuation_c" HOST_NL + " scalar 0.0625 # attenuation_l" HOST_NL + " scalar 0.25 # attenuation_q" HOST_NL + " angle 29.9927 # cone_inner" HOST_NL + " angle 59.9854 # cone_outer" HOST_NL + " asciz NULL # identifier" HOST_NL + "*ACTOR_LIGHT 0" HOST_NL + "*END 0" HOST_NL; +static void test_v1dbfile_save_load_actor_light_lone() { + br_actor* actor_ref; + br_actor* actors_read[2]; + char name[128]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + int i; + int k; + int res; + + register_test_items(); + actor_ref = create_test_actor("test_actor_light", BR_ACTOR_LIGHT, BR_TRANSFORM_IDENTITY, 0); + + create_temp_file(tmpfilename_binary, "actor_light_lone_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrActorSave(tmpfilename_binary, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + create_temp_file(tmpfilename_text, "actor_light_lone_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrActorSave(tmpfilename_text, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + LOG_DEBUG("Read binary actor"); + actors_read[0] = BrActorLoad(tmpfilename_binary); + TEST_ASSERT_NOT_NULL(actors_read[0]); + LOG_DEBUG("Read text actor"); + actors_read[1] = BrActorLoad(tmpfilename_text); + TEST_ASSERT_NOT_NULL(actors_read[1]); + + for (i = 0; i < BR_ASIZE(actors_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_COMPARE_ACTOR(actor_ref, actors_read[i]); + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_actor_light_lone, tmpfilename_binary, sizeof(binary_actor_light_lone)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_actor_light_lone, tmpfilename_text); + + BrResFree(actor_ref); + BrResFree(actors_read[0]); + BrResFree(actors_read[1]); +} + +static br_uint_8 binary_actor_camera_lone[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x13, + 0x03, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x6f, 0x72, + 0x5f, 0x63, 0x61, 0x6d, 0x65, 0x72, 0x61, 0x00, 0x00, 0x00, 0x00, 0x34, + 0x00, 0x00, 0x00, 0x0f, 0x01, 0x20, 0x00, 0x40, 0x00, 0x00, 0x00, 0x41, + 0x20, 0x00, 0x00, 0x3f, 0xaa, 0xaa, 0xab, 0x00, 0x00, 0x00, 0x00, 0x28, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; +static char *text_actor_camera_lone = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_ACTORS # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*ACTOR 4" HOST_NL + " struct br_actor" HOST_NL + " enum_8 BR_ACTOR_CAMERA # type" HOST_NL + " enum_8 BR_RSTYLE_DEFAULT # render_style" HOST_NL + " asciz \"test_actor_camera\" # identifier" HOST_NL + "*CAMERA 7" HOST_NL + " struct br_camera" HOST_NL + " enum_8 BR_CAMERA_PERSPECTIVE # type" HOST_NL + " angle 45 # field_of_view" HOST_NL + " scalar 2 # hither_z" HOST_NL + " scalar 10 # yon_z" HOST_NL + " scalar 1.33333 # aspect" HOST_NL + " asciz NULL # identifier" HOST_NL + "*ACTOR_CAMERA 0" HOST_NL + "*END 0" HOST_NL; +static void test_v1dbfile_save_load_actor_camera_lone() { + br_actor* actor_ref; + br_actor* actors_read[2]; + char name[128]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + int i; + int k; + int res; + + register_test_items(); + actor_ref = create_test_actor("test_actor_camera", BR_ACTOR_CAMERA, BR_TRANSFORM_IDENTITY, 0); + + create_temp_file(tmpfilename_binary, "actor_camera_lone_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrActorSave(tmpfilename_binary, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + create_temp_file(tmpfilename_text, "actor_camera_lone_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrActorSave(tmpfilename_text, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + LOG_DEBUG("Read binary actor"); + actors_read[0] = BrActorLoad(tmpfilename_binary); + TEST_ASSERT_NOT_NULL(actors_read[0]); + LOG_DEBUG("Read text actor"); + actors_read[1] = BrActorLoad(tmpfilename_text); + TEST_ASSERT_NOT_NULL(actors_read[1]); + + for (i = 0; i < BR_ASIZE(actors_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_COMPARE_ACTOR(actor_ref, actors_read[i]); + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_actor_camera_lone, tmpfilename_binary, sizeof(binary_actor_camera_lone)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_actor_camera_lone, tmpfilename_text); + + BrResFree(actor_ref); + BrResFree(actors_read[0]); + BrResFree(actors_read[1]); +} + +static br_uint_8 binary_actor_bounds_lone[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x13, + 0x05, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x6f, 0x72, + 0x5f, 0x62, 0x6f, 0x75, 0x6e, 0x64, 0x73, 0x00, 0x00, 0x00, 0x00, 0x32, + 0x00, 0x00, 0x00, 0x18, 0x3f, 0xa0, 0x00, 0x00, 0x3f, 0xe0, 0x00, 0x00, + 0x3e, 0x80, 0x00, 0x00, 0x40, 0xf8, 0x00, 0x00, 0x40, 0x10, 0x00, 0x00, + 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; +static char *text_actor_bounds_lone = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_ACTORS # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*ACTOR 4" HOST_NL + " struct br_actor" HOST_NL + " enum_8 BR_ACTOR_BOUNDS # type" HOST_NL + " enum_8 BR_RSTYLE_DEFAULT # render_style" HOST_NL + " asciz \"test_actor_bounds\" # identifier" HOST_NL + "*BOUNDS 3" HOST_NL + " struct br_bounds3" HOST_NL + " vector3 1.25,1.75,0.25 # min" HOST_NL + " vector3 7.75,2.25,2.0625 # max" HOST_NL + "*ACTOR_BOUNDS 0" HOST_NL + "*END 0" HOST_NL; +static void test_v1dbfile_save_load_actor_bounds_lone() { + br_actor* actor_ref; + br_actor* actors_read[2]; + char name[128]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + int i; + int k; + int res; + + register_test_items(); + actor_ref = create_test_actor("test_actor_bounds", BR_ACTOR_BOUNDS, BR_TRANSFORM_IDENTITY, 0); + + create_temp_file(tmpfilename_binary, "actor_bounds_lone_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrActorSave(tmpfilename_binary, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + create_temp_file(tmpfilename_text, "actor_bounds_lone_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrActorSave(tmpfilename_text, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + LOG_DEBUG("Read binary actor"); + actors_read[0] = BrActorLoad(tmpfilename_binary); + TEST_ASSERT_NOT_NULL(actors_read[0]); + LOG_DEBUG("Read text actor"); + actors_read[1] = BrActorLoad(tmpfilename_text); + TEST_ASSERT_NOT_NULL(actors_read[1]); + + for (i = 0; i < BR_ASIZE(actors_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_COMPARE_ACTOR(actor_ref, actors_read[i]); + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_actor_bounds_lone, tmpfilename_binary, sizeof(binary_actor_bounds_lone)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_actor_bounds_lone, tmpfilename_text); + + BrResFree(actor_ref); + BrResFree(actors_read[0]); + BrResFree(actors_read[1]); +} + +static br_uint_8 binary_actor_clipplane_lone[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x16, + 0x07, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x6f, 0x72, + 0x5f, 0x63, 0x6c, 0x69, 0x70, 0x70, 0x6c, 0x61, 0x6e, 0x65, 0x00, 0x00, + 0x00, 0x00, 0x38, 0x00, 0x00, 0x00, 0x10, 0x3f, 0x80, 0x00, 0x00, 0x3f, + 0xa0, 0x00, 0x00, 0x3f, 0xc0, 0x00, 0x00, 0x3f, 0xe0, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x37, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, +}; +static char *text_actor_clipplane_lone = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_ACTORS # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*ACTOR 4" HOST_NL + " struct br_actor" HOST_NL + " enum_8 BR_ACTOR_CLIP_PLANE # type" HOST_NL + " enum_8 BR_RSTYLE_DEFAULT # render_style" HOST_NL + " asciz \"test_actor_clipplane\" # identifier" HOST_NL + "*PLANE 2" HOST_NL + " struct br_plane" HOST_NL + " vector4 1,1.25,1.5,1.75 # eqn" HOST_NL + "*ACTOR_CLIP_PLANE 0" HOST_NL + "*END 0" HOST_NL; +static void test_v1dbfile_save_load_actor_clipplane_lone() { + br_actor* actor_ref; + br_actor* actors_read[2]; + char name[128]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + int i; + int k; + int res; + + register_test_items(); + actor_ref = create_test_actor("test_actor_clipplane", BR_ACTOR_CLIP_PLANE, BR_TRANSFORM_IDENTITY, 0); + + create_temp_file(tmpfilename_binary, "actor_clipplane_lone_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrActorSave(tmpfilename_binary, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + create_temp_file(tmpfilename_text, "actor_clipplane_lone_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrActorSave(tmpfilename_text, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + LOG_DEBUG("Read binary actor"); + actors_read[0] = BrActorLoad(tmpfilename_binary); + TEST_ASSERT_NOT_NULL(actors_read[0]); + LOG_DEBUG("Read text actor"); + actors_read[1] = BrActorLoad(tmpfilename_text); + TEST_ASSERT_NOT_NULL(actors_read[1]); + + for (i = 0; i < BR_ASIZE(actors_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_COMPARE_ACTOR(actor_ref, actors_read[i]); + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_actor_clipplane_lone, tmpfilename_binary, sizeof(binary_actor_clipplane_lone)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_actor_clipplane_lone, tmpfilename_text); + + BrResFree(actor_ref); + BrResFree(actors_read[0]); + BrResFree(actors_read[1]); +} + +static br_uint_8 binary_actor_tree_lone[] = { + 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x11, + 0x00, 0x00, 0x74, 0x65, 0x73, 0x74, 0x5f, 0x61, 0x63, 0x74, 0x6f, 0x72, + 0x5f, 0x74, 0x72, 0x65, 0x65, 0x00, 0x00, 0x00, 0x00, 0x23, 0x00, 0x00, + 0x00, 0x08, 0x00, 0x00, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x31, 0x00, 0x00, + 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x00, + 0x00, 0x00, 0x08, 0x00, 0x00, 0x63, 0x68, 0x69, 0x6c, 0x64, 0x32, 0x00, + 0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, +}; +static char *text_actor_tree_lone = + "*FILE_INFO 3" HOST_NL + " struct file_info" HOST_NL + " enum_32 FILE_TYPE_ACTORS # type" HOST_NL + " uint_32 2 # version" HOST_NL + "*ACTOR 4" HOST_NL + " struct br_actor" HOST_NL + " enum_8 BR_ACTOR_NONE # type" HOST_NL + " enum_8 BR_RSTYLE_DEFAULT # render_style" HOST_NL + " asciz \"test_actor_tree\" # identifier" HOST_NL + "*ACTOR 4" HOST_NL + " struct br_actor" HOST_NL + " enum_8 BR_ACTOR_NONE # type" HOST_NL + " enum_8 BR_RSTYLE_DEFAULT # render_style" HOST_NL + " asciz \"child1\" # identifier" HOST_NL + "*ACTOR_ADD_CHILD 0" HOST_NL + "*ACTOR 4" HOST_NL + " struct br_actor" HOST_NL + " enum_8 BR_ACTOR_NONE # type" HOST_NL + " enum_8 BR_RSTYLE_DEFAULT # render_style" HOST_NL + " asciz \"child2\" # identifier" HOST_NL + "*ACTOR_ADD_CHILD 0" HOST_NL + "*END 0" HOST_NL; +static void test_v1dbfile_save_load_actor_tree_lone() { + br_actor* actor_ref; + br_actor* actors_read[2]; + br_actor* child; + char name[128]; + char tmpfilename_binary[PATH_MAX+1]; + char tmpfilename_text[PATH_MAX+1]; + int i; + int k; + int res; + + register_test_items(); + actor_ref = create_test_actor("test_actor_tree", BR_ACTOR_NONE, BR_TRANSFORM_IDENTITY, 0); + + BrActorAdd(actor_ref, create_test_actor("child1", BR_ACTOR_NONE, BR_TRANSFORM_IDENTITY, 1)); + BrActorAdd(actor_ref, create_test_actor("child2", BR_ACTOR_NONE, BR_TRANSFORM_IDENTITY, 1)); + + create_temp_file(tmpfilename_binary, "actor_tree_lone_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); + res = BrActorSave(tmpfilename_binary, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + create_temp_file(tmpfilename_text, "actor_tree_lone_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); + res = BrActorSave(tmpfilename_text, actor_ref); + TEST_ASSERT_EQUAL_INT(1, res); + + LOG_DEBUG("Read binary actor"); + actors_read[0] = BrActorLoad(tmpfilename_binary); + TEST_ASSERT_NOT_NULL(actors_read[0]); + LOG_DEBUG("Read text actor"); + actors_read[1] = BrActorLoad(tmpfilename_text); + TEST_ASSERT_NOT_NULL(actors_read[1]); + + for (i = 0; i < BR_ASIZE(actors_read); i++) { + LOG_DEBUG("Iteration %d (binary=0 text=1)", i); + TEST_COMPARE_ACTOR(actor_ref, actors_read[i]); + } + TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(binary_actor_tree_lone, tmpfilename_binary, sizeof(binary_actor_tree_lone)); + TEST_ASSERT_EQUAL_FILE_TEXT(text_actor_tree_lone, tmpfilename_text); + + BrResFree(actor_ref); + BrResFree(actors_read[0]); + BrResFree(actors_read[1]); +} void test_v1dbfile_BrModelLoad() { REQUIRES_DATA_DIRECTORY(); @@ -63,6 +2128,22 @@ void test_v1dbfile_BrMaterialLoad() { void test_v1dbfile_suite() { UnitySetTestFile(__FILE__); + RUN_TEST(test_v1dbfile_save_load_material_lone); + RUN_TEST(test_v1dbfile_save_load_material_many); + RUN_TEST(test_v1dbfile_save_load_model_lone); + RUN_TEST(test_v1dbfile_save_load_model_many); + RUN_TEST(test_v1dbfile_save_load_actor_none_transform_unity_lone); + RUN_TEST(test_v1dbfile_save_load_actor_none_transform_matrix34_lone); + RUN_TEST(test_v1dbfile_save_load_actor_none_transform_matrix34lp_lone); + RUN_TEST(test_v1dbfile_save_load_actor_none_transform_quat_lone); + RUN_TEST(test_v1dbfile_save_load_actor_none_transform_lookup_lone); + RUN_TEST(test_v1dbfile_save_load_actor_none_transform_euler_lone); + RUN_TEST(test_v1dbfile_save_load_actor_model_lone); + RUN_TEST(test_v1dbfile_save_load_actor_light_lone); + RUN_TEST(test_v1dbfile_save_load_actor_camera_lone); + RUN_TEST(test_v1dbfile_save_load_actor_bounds_lone); + RUN_TEST(test_v1dbfile_save_load_actor_clipplane_lone); + RUN_TEST(test_v1dbfile_save_load_actor_tree_lone); RUN_TEST(test_v1dbfile_BrModelLoad); RUN_TEST(test_v1dbfile_BrActorLoad); RUN_TEST(test_v1dbfile_BrMaterialLoad); From 651b144f5222349cf0eb21871ad0d45dd9a0c5f3 Mon Sep 17 00:00:00 2001 From: Anonymous Maarten Date: Tue, 1 Feb 2022 12:25:49 +0100 Subject: [PATCH 12/14] tests: Fix test_loading_ConvertPixToStripMap --- test/DETHRACE/test_loading.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/test/DETHRACE/test_loading.c b/test/DETHRACE/test_loading.c index 39aef09d..b0d37a17 100644 --- a/test/DETHRACE/test_loading.c +++ b/test/DETHRACE/test_loading.c @@ -124,7 +124,8 @@ void test_loading_ConvertPixToStripMap() { int y; br_uint_8* src_pix; br_uint_8* dst_pix; - pm = DRPixelmapLoad("DATA/32x20x8/PIXELMAP/FRANKF.PIX"); + + pm = DRPixelmapLoad("DATA/32X20X8/PIXELMAP/FRANKF.PIX"); TEST_ASSERT_NOT_NULL(pm); strip_data = ConvertPixToStripMap(pm); TEST_ASSERT_NOT_NULL(strip_data); From 54d758ecf1eeb364d9e53d86e77c3c97521f87ed Mon Sep 17 00:00:00 2001 From: Anonymous Maarten Date: Tue, 1 Feb 2022 12:45:20 +0100 Subject: [PATCH 13/14] Fix tests on Windows --- test/BRSRC13/test_datafile.c | 64 ++++++++++++++++++++++++++++++++++++ test/main.c | 13 +++++--- test/tests.h | 5 +++ 3 files changed, 77 insertions(+), 5 deletions(-) diff --git a/test/BRSRC13/test_datafile.c b/test/BRSRC13/test_datafile.c index a63612cc..75fd9e49 100644 --- a/test/BRSRC13/test_datafile.c +++ b/test/BRSRC13/test_datafile.c @@ -106,6 +106,7 @@ static void test_datafile_binary_br_int_8() { create_temp_file(tmpfilename, "br_int_8_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -136,6 +137,7 @@ static void test_datafile_text_br_int_8() { char tmpfilename[PATH_MAX+1]; struct_br_int_8 read_struct; + BrWriteModeSet(BR_FS_MODE_TEXT); create_temp_file(tmpfilename, "br_int_8_text"); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); @@ -200,6 +202,7 @@ static void test_datafile_binary_br_uint_8() { create_temp_file(tmpfilename, "br_uint_8_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -232,6 +235,7 @@ static void test_datafile_text_br_uint_8() { create_temp_file(tmpfilename, "br_uint_8_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -294,6 +298,7 @@ static void test_datafile_binary_br_int_16() { create_temp_file(tmpfilename, "br_int_16_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -326,6 +331,7 @@ static void test_datafile_text_br_int_16() { create_temp_file(tmpfilename, "br_int_16_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -388,6 +394,7 @@ static void test_datafile_binary_br_uint_16() { create_temp_file(tmpfilename, "br_uint_16_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -420,6 +427,7 @@ static void test_datafile_text_br_uint_16() { create_temp_file(tmpfilename, "br_uint_16_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -482,6 +490,7 @@ static void test_datafile_binary_br_int_32() { create_temp_file(tmpfilename, "br_int_32_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -514,6 +523,7 @@ static void test_datafile_text_br_int_32() { create_temp_file(tmpfilename, "br_int_32_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -576,6 +586,7 @@ static void test_datafile_binary_br_uint_32() { create_temp_file(tmpfilename, "br_uint_32_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -608,6 +619,7 @@ static void test_datafile_text_br_uint_32() { create_temp_file(tmpfilename, "br_uint_32_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -670,6 +682,7 @@ static void test_datafile_binary_br_fixed() { create_temp_file(tmpfilename, "br_fixed_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -705,6 +718,7 @@ static void test_datafile_text_br_fixed() { create_temp_file(tmpfilename, "br_fixed_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -767,6 +781,7 @@ static void test_datafile_binary_br_angle() { create_temp_file(tmpfilename, "br_angle_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -799,6 +814,7 @@ static void test_datafile_text_br_angle() { create_temp_file(tmpfilename, "br_angle_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -861,6 +877,7 @@ static void test_datafile_binary_float() { create_temp_file(tmpfilename, "float_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -893,6 +910,7 @@ static void test_datafile_text_float() { create_temp_file(tmpfilename, "float_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -955,6 +973,7 @@ static void test_datafile_binary_double() { create_temp_file(tmpfilename, "double_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -987,6 +1006,7 @@ static void test_datafile_text_double() { create_temp_file(tmpfilename, "double_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1067,6 +1087,7 @@ static void test_datafile_binary_enum_8() { create_temp_file(tmpfilename, "enum_8_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1099,6 +1120,7 @@ static void test_datafile_text_enum_8() { create_temp_file(tmpfilename, "enum_8_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1179,6 +1201,7 @@ static void test_datafile_binary_enum_16() { create_temp_file(tmpfilename, "enum_16_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1211,6 +1234,7 @@ static void test_datafile_text_enum_16() { create_temp_file(tmpfilename, "enum_16_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1291,6 +1315,7 @@ static void test_datafile_binary_enum_32() { create_temp_file(tmpfilename, "enum_32_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1323,6 +1348,7 @@ static void test_datafile_text_enum_32() { create_temp_file(tmpfilename, "enum_32_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1393,6 +1419,7 @@ static void test_datafile_binary_asciz() { create_temp_file(tmpfilename, "asciz_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1429,6 +1456,7 @@ static void test_datafile_text_asciz() { create_temp_file(tmpfilename, "asciz_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1494,6 +1522,7 @@ static void test_datafile_binary_br_colour() { create_temp_file(tmpfilename, "br_colour_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1526,6 +1555,7 @@ static void test_datafile_text_br_colour() { create_temp_file(tmpfilename, "br_colour_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1588,6 +1618,7 @@ static void test_datafile_binary_br_fraction_x() { create_temp_file(tmpfilename, "br_fraction_x_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1623,6 +1654,7 @@ static void test_datafile_text_br_fraction_x() { create_temp_file(tmpfilename, "br_fraction_x_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1685,6 +1717,7 @@ static void test_datafile_binary_br_ufraction_x() { create_temp_file(tmpfilename, "br_ufraction_x_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1720,6 +1753,7 @@ static void test_datafile_text_br_ufraction_x() { create_temp_file(tmpfilename, "br_ufraction_x_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1782,6 +1816,7 @@ static void test_datafile_binary_br_fraction_f() { create_temp_file(tmpfilename, "br_fraction_f_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1814,6 +1849,7 @@ static void test_datafile_text_br_fraction_f() { create_temp_file(tmpfilename, "br_fraction_f_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1876,6 +1912,7 @@ static void test_datafile_binary_br_ufraction_f() { create_temp_file(tmpfilename, "br_ufraction_f_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1908,6 +1945,7 @@ static void test_datafile_text_br_ufraction_f() { create_temp_file(tmpfilename, "br_ufraction_f_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -1970,6 +2008,7 @@ static void test_datafile_binary_br_vector2_x() { create_temp_file(tmpfilename, "br_vector2_x_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2002,6 +2041,7 @@ static void test_datafile_text_br_vector2_x() { create_temp_file(tmpfilename, "br_vector2_x_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2068,6 +2108,7 @@ static void test_datafile_binary_br_vector3_x() { create_temp_file(tmpfilename, "br_vector3_x_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2100,6 +2141,7 @@ static void test_datafile_text_br_vector3_x() { create_temp_file(tmpfilename, "br_vector3_x_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2166,6 +2208,7 @@ static void test_datafile_binary_br_vector4_x() { create_temp_file(tmpfilename, "br_vector4_x_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2198,6 +2241,7 @@ static void test_datafile_text_br_vector4_x() { create_temp_file(tmpfilename, "br_vector4_x_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2264,6 +2308,7 @@ static void test_datafile_binary_br_vector2_f() { create_temp_file(tmpfilename, "br_vector2_f_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2296,6 +2341,7 @@ static void test_datafile_text_br_vector2_f() { create_temp_file(tmpfilename, "br_vector2_f_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2362,6 +2408,7 @@ static void test_datafile_binary_br_vector3_f() { create_temp_file(tmpfilename, "br_vector3_f_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2396,6 +2443,7 @@ static void test_datafile_text_br_vector3_f() { create_temp_file(tmpfilename, "br_vector3_f_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2462,6 +2510,7 @@ static void test_datafile_binary_br_vector4_f() { create_temp_file(tmpfilename, "br_vector4_f_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2494,6 +2543,7 @@ static void test_datafile_text_br_vector4_f() { create_temp_file(tmpfilename, "br_vector4_f_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2587,6 +2637,7 @@ static void test_datafile_binary_substruct() { create_temp_file(tmpfilename, "struct_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2621,6 +2672,7 @@ static void test_datafile_text_substruct() { create_temp_file(tmpfilename, "struct_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2663,6 +2715,7 @@ static void test_datafile_binary_chunk() { create_temp_file(tmpfilename, "chunk_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2697,6 +2750,7 @@ static void test_datafile_text_chunk() { create_temp_file(tmpfilename, "chunk_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2738,6 +2792,7 @@ static void test_datafile_binary_chunk_unknown() { create_temp_file(tmpfilename, "chunk_unknown_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2772,6 +2827,7 @@ static void test_datafile_text_chunk_unknown() { create_temp_file(tmpfilename, "chunk_unknown_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_NOT_NULL(df_w); @@ -2811,6 +2867,7 @@ static void test_datafile_binary_count() { create_temp_file(tmpfilename, "count_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_EQUAL_INT(4, DfCountSizeBinary(df_w)); @@ -2844,6 +2901,7 @@ static void test_datafile_text_count() { create_temp_file(tmpfilename, "count_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_EQUAL_INT(1, DfCountSizeText(df_w)); @@ -2883,6 +2941,7 @@ static void test_datafile_binary_name() { create_temp_file(tmpfilename, "name_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_EQUAL_INT(strlen(name_ref) + 1, DfNameSizeBinary(df_w, name_ref)); @@ -2917,6 +2976,7 @@ static void test_datafile_text_name() { create_temp_file(tmpfilename, "name_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_EQUAL_INT(1, DfNameSizeText(df_w, name_ref)); @@ -2985,6 +3045,7 @@ static void test_datafile_binary_block_continguous() { create_temp_file(tmpfilename, "block_continguous_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_EQUAL_INT(120, DfBlockSizeBinary(df_w, block_continguous_ref, block_continguous_block_size_ref, block_continguous_block_stride_ref, block_continguous_block_count_ref, block_continguous_size_ref)); @@ -3023,6 +3084,7 @@ static void test_datafile_text_block_continguous() { create_temp_file(tmpfilename, "block_continguous_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_EQUAL_INT(6, DfBlockSizeText(df_w, block_continguous_ref, block_continguous_block_size_ref, block_continguous_block_stride_ref, block_continguous_block_count_ref, block_continguous_size_ref)); @@ -3091,6 +3153,7 @@ static void test_datafile_binary_block_striped() { create_temp_file(tmpfilename, "block_striped_binary"); + BrWriteModeSet(BR_FS_MODE_BINARY); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_EQUAL_INT(56, DfBlockSizeBinary(df_w, block_striped_input_ref, block_striped_block_size_ref, block_striped_block_stride_ref, block_striped_block_count_ref, block_striped_size_ref)); @@ -3129,6 +3192,7 @@ static void test_datafile_text_block_striped() { create_temp_file(tmpfilename, "block_striped_text"); + BrWriteModeSet(BR_FS_MODE_TEXT); df_w = DfOpen(tmpfilename, 1, BRT_FLOAT); TEST_ASSERT_EQUAL_INT(4, DfBlockSizeText(df_w, block_striped_input_ref, block_striped_block_size_ref, block_striped_block_stride_ref, block_striped_block_count_ref, block_striped_size_ref)); diff --git a/test/main.c b/test/main.c index fef1093d..d2d897b5 100644 --- a/test/main.c +++ b/test/main.c @@ -108,24 +108,27 @@ void TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(const uint8_t *expected, char *filen void TEST_ASSERT_EQUAL_FILE_TEXT(const char *expected, char *filename) { FILE *f; + char *tmpBuffer; long filesize; int res; + int len; - int len = strlen(expected); - f = fopen(filename, "r"); + len = strlen(expected); + f = fopen(filename, "rb"); TEST_ASSERT_NOT_NULL(f); res = fseek(f, 0, SEEK_END); TEST_ASSERT_NOT_EQUAL(-1, res); filesize = ftell(f); TEST_ASSERT_NOT_EQUAL(-1, filesize); fseek(f, 0, SEEK_SET); - char* tmpBuffer = (char*)malloc(filesize+1); + tmpBuffer = (char*)malloc(filesize+1); + TEST_ASSERT_NOT_NULL(tmpBuffer); res = fread(tmpBuffer, 1, filesize, f); - TEST_ASSERT_EQUAL_INT(filesize, res); tmpBuffer[filesize] = '\0'; fclose(f); TEST_ASSERT_EQUAL_STRING(expected, tmpBuffer); - TEST_ASSERT_EQUAL(len, filesize); + TEST_ASSERT_EQUAL_INT(filesize, res); + TEST_ASSERT_EQUAL_INT(len, filesize); TEST_ASSERT_EQUAL_INT(filesize, strlen(tmpBuffer)); free(tmpBuffer); } diff --git a/test/tests.h b/test/tests.h index b843935a..75aeb9f5 100644 --- a/test/tests.h +++ b/test/tests.h @@ -7,7 +7,12 @@ #ifndef PATH_MAX #define PATH_MAX 300 #endif + +#ifdef _WIN32 +#define HOST_NL "\r\n" +#else #define HOST_NL "\n" +#endif void TEST_ASSERT_EQUAL_FILE_CONTENTS_BINARY(const uint8_t *expected, char *filename, int len); void TEST_ASSERT_EQUAL_FILE_TEXT(const char *expected, char *filename); From 7c891fcf02f86ddca757426611b6c2e9df438301 Mon Sep 17 00:00:00 2001 From: Anonymous Maarten Date: Sat, 5 Feb 2022 23:12:32 +0100 Subject: [PATCH 14/14] Use array indices as argument to offset --- src/BRSRC13/CORE/V1DB/v1dbfile.c | 40 ++++++++++++++++---------------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/src/BRSRC13/CORE/V1DB/v1dbfile.c b/src/BRSRC13/CORE/V1DB/v1dbfile.c index 5d0d2636..37db94e4 100644 --- a/src/BRSRC13/CORE/V1DB/v1dbfile.c +++ b/src/BRSRC13/CORE/V1DB/v1dbfile.c @@ -33,11 +33,11 @@ br_file_struct_member br_vertex_uv_FM[] = { br_file_struct br_vertex_uv_F = { "br_vertex_uv", BR_ASIZE(br_vertex_uv_FM), br_vertex_uv_FM, sizeof(br_vertex) }; br_file_struct_member br_old_vertex_uv_FM[5] = { - { DF_TYPE_BR_SCALAR, offsetof(br_vertex, p) + 0 * sizeof(br_scalar), "p.v[X]", NULL }, - { DF_TYPE_BR_SCALAR, offsetof(br_vertex, p) + 1 * sizeof(br_scalar), "p.v[Y]", NULL }, - { DF_TYPE_BR_SCALAR, offsetof(br_vertex, p) + 2 * sizeof(br_scalar), "p.v[Z]", NULL }, - { DF_TYPE_BR_SCALAR, offsetof(br_vertex, map) + 0 * sizeof(br_scalar), "map.v[0]", NULL }, - { DF_TYPE_BR_SCALAR, offsetof(br_vertex, map) + 1 * sizeof(br_scalar), "map.v[1]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_vertex, p.v[0]), "p.v[X]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_vertex, p.v[1]), "p.v[Y]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_vertex, p.v[2]), "p.v[Z]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_vertex, map.v[0]), "map.v[0]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_vertex, map.v[1]), "map.v[1]", NULL }, }; br_file_struct br_old_vertex_uv_F = { "br_old_vertex_uv", BR_ASIZE(br_old_vertex_uv_FM), br_old_vertex_uv_FM, sizeof(br_vertex) }; @@ -51,18 +51,18 @@ br_file_struct_member br_face_FM[5] = { br_file_struct br_face_F = { "br_face", BR_ASIZE(br_face_FM), br_face_FM, sizeof(br_face) }; br_file_struct_member br_old_face_1_FM[5] = { - { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices) + 0 * sizeof(br_uint_16), "vertices[0]", NULL }, - { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices) + 1 * sizeof(br_uint_16), "vertices[1]", NULL }, - { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices) + 2 * sizeof(br_uint_16), "vertices[2]", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices[0]), "vertices[0]", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices[1]), "vertices[1]", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices[2]), "vertices[2]", NULL }, { DF_TYPE_BR_UINT_8, offsetof(br_face, smoothing), "smoothing", NULL }, { DF_TYPE_BR_UINT_8, offsetof(br_face, flags), "flags", NULL }, }; br_file_struct br_old_face_1_F = { "br_old_face_1", BR_ASIZE(br_old_face_1_FM), br_old_face_1_FM, sizeof(br_face) }; br_file_struct_member br_old_face_FM[5] = { - { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices) + 0 * sizeof(br_uint_16), "vertices[0]", NULL }, - { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices) + 1 * sizeof(br_uint_16), "vertices[1]", NULL }, - { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices) + 2 * sizeof(br_uint_16), "vertices[2]", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices[0]), "vertices[0]", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices[1]), "vertices[1]", NULL }, + { DF_TYPE_BR_UINT_16, offsetof(br_face, vertices[2]), "vertices[2]", NULL }, { DF_TYPE_BR_UINT_16, offsetof(br_face, material), "material", NULL }, { DF_TYPE_BR_UINT_16, offsetof(br_face, smoothing), "smoothing", NULL }, // DF_TYPE_BR_UINT_32 in EXE }; @@ -80,9 +80,9 @@ br_file_struct_member br_old_model_1_FM[1] = { br_file_struct br_old_model_1_F = { "br_old_model_1", 1, br_old_model_1_FM, sizeof(br_model) }; br_file_struct_member br_pivot_FM[3] = { - { DF_TYPE_BR_SCALAR, offsetof(br_model, pivot) + 0 * sizeof(br_scalar), "pivot.v[X]", NULL }, - { DF_TYPE_BR_SCALAR, offsetof(br_model, pivot) + 1 * sizeof(br_scalar), "pivot.v[Y]", NULL }, - { DF_TYPE_BR_SCALAR, offsetof(br_model, pivot) + 2 * sizeof(br_scalar), "pivot.v[Z]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_model, pivot.v[0]), "pivot.v[X]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_model, pivot.v[1]), "pivot.v[Y]", NULL }, + { DF_TYPE_BR_SCALAR, offsetof(br_model, pivot.v[2]), "pivot.v[Z]", NULL }, }; br_file_struct br_pivot_F = { "br_pivot", 3, br_pivot_FM, sizeof(br_model) }; @@ -94,9 +94,9 @@ br_file_struct_member br_material_old_FM[13] = { { DF_TYPE_BR_UFRACTION, offsetof(br_material, ks), "ks", NULL }, { DF_TYPE_BR_SCALAR, offsetof(br_material, power), "power", NULL }, { DF_TYPE_BR_UINT_16, offsetof(br_material, flags), "flags", NULL }, - { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform) + 0 *sizeof(br_vector2), "map_transform.m[0]", NULL }, - { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform) + 1 *sizeof(br_vector2), "map_transform.m[1]", NULL }, - { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform) + 2 *sizeof(br_vector2), "map_transform.m[2]", NULL }, + { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform.m[0]), "map_transform.m[0]", NULL }, + { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform.m[1]), "map_transform.m[1]", NULL }, + { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform.m[2]), "map_transform.m[2]", NULL }, { DF_TYPE_BR_UINT_8, offsetof(br_material, index_base), "index_base", NULL }, { DF_TYPE_BR_UINT_8, offsetof(br_material, index_range), "index_range", NULL }, { DF_TYPE_ASCIZ, offsetof(br_material, identifier), "identifier", NULL } @@ -111,9 +111,9 @@ br_file_struct_member br_material_FM[17] = { { DF_TYPE_BR_UFRACTION, offsetof(br_material, ks), "ks", NULL }, { DF_TYPE_BR_SCALAR, offsetof(br_material, power), "power", NULL }, { DF_TYPE_BR_UINT_32, offsetof(br_material, flags), "flags", NULL }, - { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform) + 0 * sizeof(br_vector2), "map_transform.m[0]", NULL }, - { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform) + 1 * sizeof(br_vector2), "map_transform.m[1]", NULL }, - { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform) + 2 * sizeof(br_vector2), "map_transform.m[2]", NULL }, + { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform.m[0]), "map_transform.m[0]", NULL }, + { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform.m[1]), "map_transform.m[1]", NULL }, + { DF_TYPE_BR_VECTOR2, offsetof(br_material, map_transform.m[2]), "map_transform.m[2]", NULL }, { DF_TYPE_BR_UINT_8, offsetof(br_material, index_base), "index_base", NULL }, { DF_TYPE_BR_UINT_8, offsetof(br_material, index_range), "index_range", NULL }, { DF_TYPE_BR_SCALAR, offsetof(br_material, fog_min), "fog_min", NULL },