falso
/
dethrace
mirror of https://github.com/dethrace-labs/dethrace.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add all datafile functions (+needed dependent functions) (#73) 

* brender: add fixed functions + tests

* brender: re-order assignment of variables

Little nitpick patch, sorry :^)

* brender: implement all scratch functions + tests

* tests: Actually build and run math test functions

* brender: implement BrFilePrintf

* brender: BrVsprintfN returns number of characers written

* tests: add ability to create temporary file in temporary folder

* brender: add binary/text store+load of datafile + tests
This commit is contained in:
Anonymous Maarten 2022-01-25 23:54:30 +01:00 committed by GitHub
parent 44d8b2f66d
commit ba4b7630fb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
20 changed files with 5843 additions and 300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/BRSRC13/CMakeLists.txt
View File

@ -113,6 +113,8 @@ target_sources(brender PRIVATE
CORE/HOST/memmgmt.h
CORE/MATH/angles.c
CORE/MATH/angles.h
CORE/MATH/fixed.c
CORE/MATH/fixed.h
CORE/MATH/matrix23.c
CORE/MATH/matrix23.h
CORE/MATH/matrix34.c

1261
src/BRSRC13/CORE/FW/datafile.c
View File

File diff suppressed because it is too large Load Diff

101
src/BRSRC13/CORE/FW/datafile.h
View File

@ -3,6 +3,107 @@
#include "brender/br_types.h"
// The names of these enum values are a wild guess
enum {
DF_TYPE_BR_INT_8 = 0,
DF_TYPE_BR_UINT_8 = 1,
DF_TYPE_BR_INT_16 = 2,
DF_TYPE_BR_UINT_16 = 3,
DF_TYPE_BR_INT_32 = 4,
DF_TYPE_BR_UINT_32 = 5,
DF_TYPE_BR_FIXED = 6,
DF_TYPE_BR_ANGLE = 7,
DF_TYPE_FLOAT = 8,
DF_TYPE_DOUBLE = 9,
DF_TYPE_BR_SCALAR = 10,
DF_TYPE_BR_FRACTION = 11,
DF_TYPE_BR_UFRACTION = 12,
DF_TYPE_ENUM_8 = 13,
DF_TYPE_ENUM_16 = 14,
DF_TYPE_ENUM_32 = 15,
DF_TYPE_STRUCT = 16,
DF_TYPE_ASCIZ = 17,
DF_TYPE_BR_COLOUR = 18,
DF_TYPE_BR_VECTOR2 = 19,
DF_TYPE_BR_VECTOR3 = 20,
DF_TYPE_BR_VECTOR4 = 21,
DF_TYPE_BR_FRACTION_X = 22,
DF_TYPE_BR_UFRACTION_X = 23,
DF_TYPE_BR_FRACTION_F = 24,
DF_TYPE_BR_UFRACTION_F = 25,
DF_TYPE_BR_VECTOR2_X = 26,
DF_TYPE_BR_VECTOR3_X = 27,
DF_TYPE_BR_VECTOR4_X = 28,
DF_TYPE_BR_VECTOR2_F = 29,
DF_TYPE_BR_VECTOR3_F = 30,
DF_TYPE_BR_VECTOR4_F = 31,
DF_TYPE_COUNT,
};
enum {
DF_CHUNKID_END = 0,
DF_CHUNKID_IMAGE_PLANE = 1,
DF_CHUNKID_RLE_IMAGE_PLANE = 2,
DF_CHUNKID_PIXELMAP = 3,
DF_CHUNKID_MATERIAL_OLD = 4,
DF_CHUNKID_ADD_MATERIAL = 5,
DF_CHUNKID_OLD_ACTOR = 6,
DF_CHUNKID_OLD_ADD_SIBLING = 7,
DF_CHUNKID_OLD_ADD_CHILD = 8,
DF_CHUNKID_OLD_MATERIAL_INDEX = 9,
DF_CHUNKID_OLD_VERTICES = 10,
DF_CHUNKID_OLD_VERTICES_UV = 11,
DF_CHUNKID_OLD_FACES = 12,
DF_CHUNKID_OLD_MODEL = 13,
DF_CHUNKID_ADD_MODEL = 14,
DF_CHUNKID_ANIM = 15,
DF_CHUNKID_ANIM_TRANSFORM = 16,
DF_CHUNKID_ANIM_RATE = 17,
DF_CHUNKID_FILE_INFO = 18,
DF_CHUNKID_OLD_LIGHT = 19,
DF_CHUNKID_OLD_CAMERA = 20,
DF_CHUNKID_PIVOT = 21,
DF_CHUNKID_MATERIAL_INDEX = 22,
DF_CHUNKID_VERTICES = 23,
DF_CHUNKID_VERTEX_UV = 24,
DF_CHUNKID_OLD_FACES_1 = 25,
DF_CHUNKID_FACE_MATERIAL = 26,
DF_CHUNKID_OLD_MODEL_1 = 27,
DF_CHUNKID_COLOUR_MAP_REF = 28,
DF_CHUNKID_OPACITY_MAP_REF = 29,
DF_CHUNKID_INDEX_BLEND_REF = 30,
DF_CHUNKID_INDEX_SHADE_REF = 31,
DF_CHUNKID_SCREENDOOR_REF = 32,
DF_CHUNKID_PIXELS = 33,
DF_CHUNKID_ADD_MAP = 34,
DF_CHUNKID_ACTOR = 35,
DF_CHUNKID_ACTOR_MODEL = 36,
DF_CHUNKID_ACTOR_TRANSFORM = 37,
DF_CHUNKID_ACTOR_MATERIAL = 38,
DF_CHUNKID_ACTOR_LIGHT = 39,
DF_CHUNKID_ACTOR_CAMERA = 40,
DF_CHUNKID_ACTOR_BOUNDS = 41,
DF_CHUNKID_ACTOR_ADD_CHILD = 42,
DF_CHUNKID_TRANSFORM_MATRIX34 = 43,
DF_CHUNKID_TRANSFORM_MATRIX34_LP = 44,
DF_CHUNKID_TRANSFORM_QUAT = 45,
DF_CHUNKID_TRANSFORM_EULER = 46,
DF_CHUNKID_TRANSFORM_LOOK_UP = 47,
DF_CHUNKID_TRANSFORM_TRANSLATION = 48,
DF_CHUNKID_TRANSFORM_IDENTITY = 49,
DF_CHUNKID_BOUNDS = 50,
DF_CHUNKID_LIGHT = 51,
DF_CHUNKID_CAMERA = 52,
DF_CHUNKID_FACES = 53,
DF_CHUNKID_MODEL = 54,
DF_CHUNKID_ACTOR_CLIP_PLANE = 55,
DF_CHUNKID_PLANE = 56,
DF_CHUNKID_SATURN_FACES = 57,
DF_CHUNKID_SATURN_MODEL = 58,
DF_CHUNKID_INDEX_FOG_REF = 59,
DF_CHUNKID_MATERIAL_OLD_2 = 60,
};
void DfPush(int type, void* value, int count);
void* DfPop(int type, int* countp);

9
src/BRSRC13/CORE/FW/file.c
View File

@ -1,4 +1,5 @@
#include "file.h"
#include "scratch.h"
#include "CORE/FW/fwsetup.h"
#include "CORE/FW/resource.h"
#include "CORE/STD/brstdlib.h"
@ -114,6 +115,10 @@ void BrFileAdvance(long count, void* f) {
int BrFilePrintf(void* f, char* fmt, ...) {
int n;
va_list args;
LOG_TRACE("(%p, \"%s\")", f, fmt);
NOT_IMPLEMENTED();
LOG_TRACE9("(%p, \"%s\")", f, fmt);
va_start(args, fmt);
n = BrVSprintf(BrScratchString(), fmt, args);
va_end(args);
return BrFileWrite(BrScratchString(), 1, n, f);
}

34
src/BRSRC13/CORE/FW/scratch.c
View File

@ -4,22 +4,22 @@
#include "harness/trace.h"
#include "resource.h"
char scratchString[512];
char scratchString[512] = "SCRATCH";
// IDA: void* __cdecl BrScratchAllocate(br_size_t size)
void* BrScratchAllocate(br_size_t size) {
LOG_TRACE("(%d)", size);
if (fw.scratch_inuse)
if (fw.scratch_inuse != 0) {
BrFailure("Scratchpad not available");
}
fw.scratch_last = size;
if (size > fw.scratch_size) {
if (fw.scratch_ptr)
if (fw.scratch_ptr != NULL) {
BrResFree(fw.scratch_ptr);
}
fw.scratch_ptr = BrResAllocate(fw.res, size, BR_MEMORY_SCRATCH);
fw.scratch_size = size;
}
@ -30,29 +30,41 @@ void* BrScratchAllocate(br_size_t size) {
// IDA: void __cdecl BrScratchFree(void *scratch)
void BrScratchFree(void* scratch) {
LOG_TRACE("(%p)", scratch);
fw.scratch_inuse = 0;
}
// IDA: void __cdecl BrScratchFlush()
void BrScratchFlush() {
LOG_TRACE("()");
NOT_IMPLEMENTED();
if (fw.scratch_inuse != 0) {
BrFailure("Scratchpad cannot be flushed while in use");
}
if (fw.scratch_ptr != NULL) {
BrResFree(fw.scratch_ptr);
}
fw.scratch_ptr = NULL;
fw.scratch_size = 0;
}
// IDA: br_size_t __cdecl BrScratchInquire()
br_size_t BrScratchInquire() {
LOG_TRACE("()");
NOT_IMPLEMENTED();
return fw.scratch_size;
}
// IDA: char* __cdecl BrScratchString()
char* BrScratchString() {
LOG_TRACE("()");
NOT_IMPLEMENTED();
LOG_TRACE9("()");
return scratchString;
}
// IDA: br_size_t __cdecl BrScratchStringSize()
br_size_t BrScratchStringSize() {
LOG_TRACE("()");
NOT_IMPLEMENTED();
LOG_TRACE9("()");
return sizeof(scratchString);
}

661
src/BRSRC13/CORE/MATH/fixed.c Normal file
View File

@ -0,0 +1,661 @@
#include "fixed.h"
#include "harness/trace.h"
#include <assert.h>
#define fixed_cos_table ((unsigned short*)&fixed_sin_table[64])
static unsigned short fixed_sin_table[] = {
// start sin table
0x0000, 0x0324, 0x0647, 0x096a, 0x0c8b, 0x0fab, 0x12c7, 0x15e1,
0x18f8, 0x1c0b, 0x1f19, 0x2223, 0x2527, 0x2826, 0x2b1e, 0x2e10,
0x30fb, 0x33de, 0x36b9, 0x398c, 0x3c56, 0x3f16, 0x41cd, 0x447a,
0x471c, 0x49b3, 0x4c3f, 0x4ebf, 0x5133, 0x539a, 0x55f4, 0x5842,
0x5a81, 0x5cb3, 0x5ed6, 0x60eb, 0x62f1, 0x64e7, 0x66ce, 0x68a5,
0x6a6c, 0x6c23, 0x6dc9, 0x6f5e, 0x70e1, 0x7254, 0x73b5, 0x7503,
0x7640, 0x776b, 0x7883, 0x7989, 0x7a7c, 0x7b5c, 0x7c29, 0x7ce2,
0x7d89, 0x7e1c, 0x7e9c, 0x7f08, 0x7f61, 0x7fa6, 0x7fd7, 0x7ff5,
// start cos table
0x7fff, 0x7ff5, 0x7fd7, 0x7fa6, 0x7f61, 0x7f08, 0x7e9c, 0x7e1c,
0x7d89, 0x7ce2, 0x7c29, 0x7b5c, 0x7a7c, 0x7989, 0x7883, 0x776b,
0x7640, 0x7503, 0x73b5, 0x7254, 0x70e1, 0x6f5e, 0x6dc9, 0x6c23,
0x6a6c, 0x68a5, 0x66ce, 0x64e7, 0x62f1, 0x60eb, 0x5ed6, 0x5cb3,
0x5a81, 0x5842, 0x55f4, 0x539a, 0x5133, 0x4ebf, 0x4c3f, 0x49b3,
0x471c, 0x447a, 0x41cd, 0x3f16, 0x3c56, 0x398c, 0x36b9, 0x33de,
0x30fb, 0x2e10, 0x2b1e, 0x2826, 0x2527, 0x2223, 0x1f19, 0x1c0b,
0x18f8, 0x15e1, 0x12c7, 0x0fab, 0x0c8b, 0x096a, 0x0647, 0x0324,
0x0000, 0xfcdc, 0xf9b9, 0xf696, 0xf375, 0xf055, 0xed39, 0xea1f,
0xe708, 0xe3f5, 0xe0e7, 0xdddd, 0xdad9, 0xd7da, 0xd4e2, 0xd1f0,
0xcf05, 0xcc22, 0xc947, 0xc674, 0xc3aa, 0xc0ea, 0xbe33, 0xbb86,
0xb8e4, 0xb64d, 0xb3c1, 0xb141, 0xaecd, 0xac66, 0xaa0c, 0xa7be,
0xa57f, 0xa34d, 0xa12a, 0x9f15, 0x9d0f, 0x9b19, 0x9932, 0x975b,
0x9594, 0x93dd, 0x9237, 0x90a2, 0x8f1f, 0x8dac, 0x8c4b, 0x8afd,
0x89c0, 0x8895, 0x877d, 0x8677, 0x8584, 0x84a4, 0x83d7, 0x831e,
0x8277, 0x81e4, 0x8164, 0x80f8, 0x809f, 0x805a, 0x8029, 0x800b,
0x8001, 0x800b, 0x8029, 0x805a, 0x809f, 0x80f8, 0x8164, 0x81e4,
0x8277, 0x831e, 0x83d7, 0x84a4, 0x8584, 0x8677, 0x877d, 0x8895,
0x89c0, 0x8afd, 0x8c4b, 0x8dac, 0x8f1f, 0x90a2, 0x9237, 0x93dd,
0x9594, 0x975b, 0x9932, 0x9b19, 0x9d0f, 0x9f15, 0xa12a, 0xa34d,
0xa57f, 0xa7be, 0xaa0c, 0xac66, 0xaecd, 0xb141, 0xb3c1, 0xb64d,
0xb8e4, 0xbb86, 0xbe33, 0xc0ea, 0xc3aa, 0xc674, 0xc947, 0xcc22,
0xcf05, 0xd1f0, 0xd4e2, 0xd7da, 0xdad9, 0xdddd, 0xe0e7, 0xe3f5,
0xe708, 0xea1f, 0xed39, 0xf055, 0xf375, 0xf696, 0xf9b9, 0xfcdc,
0x0000, 0x0324, 0x0647, 0x096a, 0x0c8b, 0x0fab, 0x12c7, 0x15e1,
0x18f8, 0x1c0b, 0x1f19, 0x2223, 0x2527, 0x2826, 0x2b1e, 0x2e10,
0x30fb, 0x33de, 0x36b9, 0x398c, 0x3c56, 0x3f16, 0x41cd, 0x447a,
0x471c, 0x49b3, 0x4c3f, 0x4ebf, 0x5133, 0x539a, 0x55f4, 0x5842,
0x5a81, 0x5cb3, 0x5ed6, 0x60eb, 0x62f1, 0x64e7, 0x66ce, 0x68a5,
0x6a6c, 0x6c23, 0x6dc9, 0x6f5e, 0x70e1, 0x7254, 0x73b5, 0x7503,
0x7640, 0x776b, 0x7883, 0x7989, 0x7a7c, 0x7b5c, 0x7c29, 0x7ce2,
0x7d89, 0x7e1c, 0x7e9c, 0x7f08, 0x7f61, 0x7fa6, 0x7fd7, 0x7ff5,
0x7fff, 0x7fff,
};
static unsigned short fixed_asin_table[] = {
0xc001, 0xc519, 0xc737, 0xc8d7, 0xca37, 0xcb6d, 0xcc87, 0xcd8a,
0xce7c, 0xcf5f, 0xd037, 0xd104, 0xd1c9, 0xd286, 0xd33c, 0xd3ed,
0xd498, 0xd53e, 0xd5df, 0xd67c, 0xd716, 0xd7ac, 0xd83f, 0xd8cf,
0xd95c, 0xd9e7, 0xda6f, 0xdaf4, 0xdb78, 0xdbf9, 0xdc79, 0xdcf7,
0xdd73, 0xdded, 0xde66, 0xdedd, 0xdf53, 0xdfc8, 0xe03b, 0xe0ad,
0xe11e, 0xe18d, 0xe1fc, 0xe26a, 0xe2d6, 0xe342, 0xe3ac, 0xe416,
0xe47f, 0xe4e7, 0xe54e, 0xe5b4, 0xe61a, 0xe67f, 0xe6e3, 0xe746,
0xe7a9, 0xe80c, 0xe86d, 0xe8ce, 0xe92f, 0xe98f, 0xe9ee, 0xea4d,
0xeaab, 0xeb09, 0xeb66, 0xebc3, 0xec20, 0xec7c, 0xecd7, 0xed33,
0xed8d, 0xede8, 0xee42, 0xee9c, 0xeef5, 0xef4e, 0xefa7, 0xefff,
0xf057, 0xf0af, 0xf106, 0xf15d, 0xf1b4, 0xf20b, 0xf261, 0xf2b8,
0xf30d, 0xf363, 0xf3b9, 0xf40e, 0xf463, 0xf4b8, 0xf50c, 0xf561,
0xf5b5, 0xf609, 0xf65d, 0xf6b1, 0xf704, 0xf758, 0xf7ab, 0xf7fe,
0xf851, 0xf8a4, 0xf8f7, 0xf949, 0xf99c, 0xf9ee, 0xfa41, 0xfa93,
0xfae5, 0xfb37, 0xfb89, 0xfbdb, 0xfc2d, 0xfc7f, 0xfcd1, 0xfd23,
0xfd74, 0xfdc6, 0xfe17, 0xfe69, 0xfeba, 0xff0c, 0xff5e, 0xffaf,
0x0000, 0x0051, 0x00a2, 0x00f4, 0x0146, 0x0197, 0x01e9, 0x023a,
0x028c, 0x02dd, 0x032f, 0x0381, 0x03d3, 0x0425, 0x0477, 0x04c9,
0x051b, 0x056d, 0x05bf, 0x0612, 0x0664, 0x06b7, 0x0709, 0x075c,
0x07af, 0x0802, 0x0855, 0x08a8, 0x08fc, 0x094f, 0x09a3, 0x09f7,
0x0a4b, 0x0a9f, 0x0af4, 0x0b48, 0x0b9d, 0x0bf2, 0x0c47, 0x0c9d,
0x0cf3, 0x0d48, 0x0d9f, 0x0df5, 0x0e4c, 0x0ea3, 0x0efa, 0x0f51,
0x0fa9, 0x1001, 0x1059, 0x10b2, 0x110b, 0x1164, 0x11be, 0x1218,
0x1273, 0x12cd, 0x1329, 0x1384, 0x13e0, 0x143d, 0x149a, 0x14f7,
0x1555, 0x15b3, 0x1612, 0x1671, 0x16d1, 0x1732, 0x1793, 0x17f4,
0x1857, 0x18ba, 0x191d, 0x1981, 0x19e6, 0x1a4c, 0x1ab2, 0x1b19,
0x1b81, 0x1bea, 0x1c54, 0x1cbe, 0x1d2a, 0x1d96, 0x1e04, 0x1e73,
0x1ee2, 0x1f53, 0x1fc5, 0x2038, 0x20ad, 0x2123, 0x219a, 0x2213,
0x228d, 0x2309, 0x2387, 0x2407, 0x2488, 0x250c, 0x2591, 0x2619,
0x26a4, 0x2731, 0x27c1, 0x2854, 0x28ea, 0x2984, 0x2a21, 0x2ac2,
0x2b68, 0x2c13, 0x2cc4, 0x2d7a, 0x2e37, 0x2efc, 0x2fc9, 0x30a1,
0x3184, 0x3276, 0x3379, 0x3493, 0x35c9, 0x3729, 0x38c9, 0x3ae7,
0x4000,
};
static unsigned short fixed_acos_table[] = {
0x7fff, 0x7ae7, 0x78c9, 0x7729, 0x75c9, 0x7493, 0x7379, 0x7276,
0x7184, 0x70a1, 0x6fc9, 0x6efc, 0x6e37, 0x6d7a, 0x6cc4, 0x6c13,
0x6b68, 0x6ac2, 0x6a21, 0x6984, 0x68ea, 0x6854, 0x67c1, 0x6731,
0x66a4, 0x6619, 0x6591, 0x650c, 0x6488, 0x6407, 0x6387, 0x6309,
0x628d, 0x6213, 0x619a, 0x6123, 0x60ad, 0x6038, 0x5fc5, 0x5f53,
0x5ee2, 0x5e73, 0x5e04, 0x5d96, 0x5d2a, 0x5cbe, 0x5c54, 0x5bea,
0x5b81, 0x5b19, 0x5ab2, 0x5a4c, 0x59e6, 0x5981, 0x591d, 0x58ba,
0x5857, 0x57f4, 0x5793, 0x5732, 0x56d1, 0x5671, 0x5612, 0x55b3,
0x5555, 0x54f7, 0x549a, 0x543d, 0x53e0, 0x5384, 0x5329, 0x52cd,
0x5273, 0x5218, 0x51be, 0x5164, 0x510b, 0x50b2, 0x5059, 0x5001,
0x4fa9, 0x4f51, 0x4efa, 0x4ea3, 0x4e4c, 0x4df5, 0x4d9f, 0x4d48,
0x4cf3, 0x4c9d, 0x4c47, 0x4bf2, 0x4b9d, 0x4b48, 0x4af4, 0x4a9f,
0x4a4b, 0x49f7, 0x49a3, 0x494f, 0x48fc, 0x48a8, 0x4855, 0x4802,
0x47af, 0x475c, 0x4709, 0x46b7, 0x4664, 0x4612, 0x45bf, 0x456d,
0x451b, 0x44c9, 0x4477, 0x4425, 0x43d3, 0x4381, 0x432f, 0x42dd,
0x428c, 0x423a, 0x41e9, 0x4197, 0x4146, 0x40f4, 0x40a2, 0x4051,
0x3fff, 0x3fae, 0x3f5d, 0x3f0b, 0x3eb9, 0x3e68, 0x3e16, 0x3dc5,
0x3d73, 0x3d22, 0x3cd0, 0x3c7e, 0x3c2c, 0x3bda, 0x3b88, 0x3b36,
0x3ae4, 0x3a92, 0x3a40, 0x39ed, 0x399b, 0x3948, 0x38f6, 0x38a3,
0x3850, 0x37fd, 0x37aa, 0x3757, 0x3703, 0x36b0, 0x365c, 0x3608,
0x35b4, 0x3560, 0x350b, 0x34b7, 0x3462, 0x340d, 0x33b8, 0x3362,
0x330c, 0x32b7, 0x3260, 0x320a, 0x31b3, 0x315c, 0x3105, 0x30ae,
0x3056, 0x2ffe, 0x2fa6, 0x2f4d, 0x2ef4, 0x2e9b, 0x2e41, 0x2de7,
0x2d8c, 0x2d32, 0x2cd6, 0x2c7b, 0x2c1f, 0x2bc2, 0x2b65, 0x2b08,
0x2aaa, 0x2a4c, 0x29ed, 0x298e, 0x292e, 0x28cd, 0x286c, 0x280b,
0x27a8, 0x2745, 0x26e2, 0x267e, 0x2619, 0x25b3, 0x254d, 0x24e6,
0x247e, 0x2415, 0x23ab, 0x2341, 0x22d5, 0x2269, 0x21fb, 0x218c,
0x211d, 0x20ac, 0x203a, 0x1fc7, 0x1f52, 0x1edc, 0x1e65, 0x1dec,
0x1d72, 0x1cf6, 0x1c78, 0x1bf8, 0x1b77, 0x1af3, 0x1a6e, 0x19e6,
0x195b, 0x18ce, 0x183e, 0x17ab, 0x1715, 0x167b, 0x15de, 0x153d,
0x1497, 0x13ec, 0x133b, 0x1285, 0x11c8, 0x1103, 0x1036, 0x0f5e,
0x0e7b, 0x0d89, 0x0c86, 0x0b6c, 0x0a36, 0x08d6, 0x0736, 0x0518,
0x0000,
};
static unsigned short fixed_atan_table[] = {
0x0000, 0x0028, 0x0051, 0x007a, 0x00a2, 0x00cb, 0x00f4, 0x011d,
0x0145, 0x016e, 0x0197, 0x01bf, 0x01e8, 0x0211, 0x0239, 0x0262,
0x028b, 0x02b3, 0x02dc, 0x0304, 0x032d, 0x0355, 0x037e, 0x03a6,
0x03ce, 0x03f7, 0x041f, 0x0448, 0x0470, 0x0498, 0x04c0, 0x04e8,
0x0511, 0x0539, 0x0561, 0x0589, 0x05b1, 0x05d9, 0x0601, 0x0628,
0x0650, 0x0678, 0x06a0, 0x06c7, 0x06ef, 0x0716, 0x073e, 0x0765,
0x078d, 0x07b4, 0x07db, 0x0803, 0x082a, 0x0851, 0x0878, 0x089f,
0x08c6, 0x08ed, 0x0913, 0x093a, 0x0961, 0x0987, 0x09ae, 0x09d4,
0x09fb, 0x0a21, 0x0a47, 0x0a6d, 0x0a94, 0x0aba, 0x0ae0, 0x0b05,
0x0b2b, 0x0b51, 0x0b77, 0x0b9c, 0x0bc2, 0x0be7, 0x0c0c, 0x0c32,
0x0c57, 0x0c7c, 0x0ca1, 0x0cc6, 0x0ceb, 0x0d0f, 0x0d34, 0x0d58,
0x0d7d, 0x0da1, 0x0dc6, 0x0dea, 0x0e0e, 0x0e32, 0x0e56, 0x0e7a,
0x0e9e, 0x0ec1, 0x0ee5, 0x0f08, 0x0f2c, 0x0f4f, 0x0f72, 0x0f95,
0x0fb8, 0x0fdb, 0x0ffe, 0x1021, 0x1044, 0x1066, 0x1089, 0x10ab,
0x10cd, 0x10ef, 0x1111, 0x1133, 0x1155, 0x1177, 0x1199, 0x11ba,
0x11dc, 0x11fd, 0x121e, 0x123f, 0x1260, 0x1281, 0x12a2, 0x12c3,
0x12e4, 0x1304, 0x1325, 0x1345, 0x1365, 0x1385, 0x13a5, 0x13c5,
0x13e5, 0x1405, 0x1424, 0x1444, 0x1463, 0x1483, 0x14a2, 0x14c1,
0x14e0, 0x14ff, 0x151e, 0x153c, 0x155b, 0x1579, 0x1598, 0x15b6,
0x15d4, 0x15f2, 0x1610, 0x162e, 0x164c, 0x166a, 0x1687, 0x16a5,
0x16c2, 0x16df, 0x16fc, 0x1719, 0x1736, 0x1753, 0x1770, 0x178c,
0x17a9, 0x17c5, 0x17e2, 0x17fe, 0x181a, 0x1836, 0x1852, 0x186e,
0x188a, 0x18a5, 0x18c1, 0x18dc, 0x18f7, 0x1913, 0x192e, 0x1949,
0x1964, 0x197f, 0x1999, 0x19b4, 0x19ce, 0x19e9, 0x1a03, 0x1a1d,
0x1a37, 0x1a51, 0x1a6b, 0x1a85, 0x1a9f, 0x1ab9, 0x1ad2, 0x1aec,
0x1b05, 0x1b1e, 0x1b37, 0x1b50, 0x1b69, 0x1b82, 0x1b9b, 0x1bb4,
0x1bcc, 0x1be5, 0x1bfd, 0x1c16, 0x1c2e, 0x1c46, 0x1c5e, 0x1c76,
0x1c8e, 0x1ca5, 0x1cbd, 0x1cd5, 0x1cec, 0x1d04, 0x1d1b, 0x1d32,
0x1d49, 0x1d60, 0x1d77, 0x1d8e, 0x1da5, 0x1dbb, 0x1dd2, 0x1de9,
0x1dff, 0x1e15, 0x1e2c, 0x1e42, 0x1e58, 0x1e6e, 0x1e84, 0x1e99,
0x1eaf, 0x1ec5, 0x1eda, 0x1ef0, 0x1f05, 0x1f1b, 0x1f30, 0x1f45,
0x1f5a, 0x1f6f, 0x1f84, 0x1f99, 0x1fad, 0x1fc2, 0x1fd7, 0x1feb,
0x2000,
};
static uint16_t fast_sqrt_table[] = {
0x8000, 0x80ff, 0x81fc, 0x82f7, 0x83f0, 0x84e7, 0x85dd, 0x86d1,
0x87c3, 0x88b4, 0x89a3, 0x8a90, 0x8b7c, 0x8c66, 0x8d4e, 0x8e36,
0x8f1b, 0x9000, 0x90e2, 0x91c4, 0x92a4, 0x9383, 0x9460, 0x953c,
0x9617, 0x96f1, 0x97ca, 0x98a1, 0x9977, 0x9a4c, 0x9b20, 0x9bf2,
0x9cc4, 0x9d94, 0x9e64, 0x9f32, 0xa000, 0xa0cc, 0xa197, 0xa261,
0xa32b, 0xa3f3, 0xa4ba, 0xa581, 0xa646, 0xa70b, 0xa7cf, 0xa892,
0xa953, 0xaa15, 0xaad5, 0xab94, 0xac53, 0xad11, 0xadcd, 0xae8a,
0xaf45, 0xb000, 0xb0b9, 0xb172, 0xb22b, 0xb2e2, 0xb399, 0xb44f,
0xb504, 0xb5b9, 0xb66d, 0xb720, 0xb7d3, 0xb885, 0xb936, 0xb9e7,
0xba97, 0xbb46, 0xbbf5, 0xbca3, 0xbd50, 0xbdfd, 0xbea9, 0xbf55,
0xc000, 0xc0aa, 0xc154, 0xc1fd, 0xc2a5, 0xc34e, 0xc3f5, 0xc49c,
0xc542, 0xc5e8, 0xc68e, 0xc732, 0xc7d7, 0xc87a, 0xc91d, 0xc9c0,
0xca62, 0xcb04, 0xcba5, 0xcc46, 0xcce6, 0xcd86, 0xce25, 0xcec3,
0xcf62, 0xd000, 0xd09d, 0xd13a, 0xd1d6, 0xd272, 0xd30d, 0xd3a8,
0xd443, 0xd4dd, 0xd577, 0xd610, 0xd6a9, 0xd742, 0xd7da, 0xd871,
0xd908, 0xd99f, 0xda35, 0xdacb, 0xdb61, 0xdbf6, 0xdc8b, 0xdd1f,
0xddb3, 0xde47, 0xdeda, 0xdf6d, 0xe000, 0xe092, 0xe123, 0xe1b5,
0xe246, 0xe2d6, 0xe367, 0xe3f7, 0xe486, 0xe515, 0xe5a4, 0xe633,
0xe6c1, 0xe74f, 0xe7dc, 0xe869, 0xe8f6, 0xe983, 0xea0f, 0xea9b,
0xeb26, 0xebb1, 0xec3c, 0xecc7, 0xed51, 0xeddb, 0xee65, 0xeeee,
0xef77, 0xf000, 0xf088, 0xf110, 0xf198, 0xf21f, 0xf2a6, 0xf32d,
0xf3b4, 0xf43a, 0xf4c0, 0xf546, 0xf5cb, 0xf651, 0xf6d6, 0xf75a,
0xf7de, 0xf863, 0xf8e6, 0xf96a, 0xf9ed, 0xfa70, 0xfaf3, 0xfb75,
0xfbf7, 0xfc79, 0xfcfb, 0xfd7c, 0xfdfd, 0xfe7e, 0xfeff, 0xff7f,
};
static uint16_t fast_rsqrt_table[] = {
0xffff, 0xfe05, 0xfc17, 0xfa33, 0xf85b, 0xf68c, 0xf4c8, 0xf30d,
0xf15b, 0xefb3, 0xee13, 0xec7b, 0xeaeb, 0xe964, 0xe7e3, 0xe66b,
0xe4f9, 0xe38e, 0xe229, 0xe0cc, 0xdf74, 0xde23, 0xdcd7, 0xdb91,
0xda51, 0xd916, 0xd7e0, 0xd6b0, 0xd584, 0xd45e, 0xd33c, 0xd21e,
0xd105, 0xcff1, 0xcee1, 0xcdd4, 0xcccc, 0xcbc8, 0xcac8, 0xc9cb,
0xc8d2, 0xc7dd, 0xc6eb, 0xc5fc, 0xc511, 0xc429, 0xc344, 0xc263,
0xc184, 0xc0a8, 0xbfd0, 0xbefa, 0xbe26, 0xbd56, 0xbc88, 0xbbbd,
0xbaf4, 0xba2e, 0xb96a, 0xb8a9, 0xb7ea, 0xb72d, 0xb673, 0xb5bb,
0xb504, 0xb450, 0xb39f, 0xb2ef, 0xb241, 0xb195, 0xb0eb, 0xb043,
0xaf9d, 0xaef8, 0xae56, 0xadb5, 0xad16, 0xac79, 0xabdd, 0xab43,
0xaaaa, 0xaa13, 0xa97e, 0xa8ea, 0xa858, 0xa7c7, 0xa737, 0xa6a9,
0xa61d, 0xa592, 0xa508, 0xa47f, 0xa3f8, 0xa372, 0xa2ee, 0xa26a,
0xa1e8, 0xa167, 0xa0e7, 0xa069, 0x9fec, 0x9f6f, 0x9ef4, 0x9e7a,
0x9e01, 0x9d89, 0x9d13, 0x9c9d, 0x9c28, 0x9bb4, 0x9b42, 0x9ad0,
0x9a5f, 0x99ef, 0x9981, 0x9913, 0x98a6, 0x983a, 0x97ce, 0x9764,
0x96fb, 0x9692, 0x962a, 0x95c3, 0x955d, 0x94f8, 0x9493, 0x9430,
0x93cd, 0x936b, 0x9309, 0x92a9, 0x9249, 0x91e9, 0x918b, 0x912d,
0x90d0, 0x9074, 0x9018, 0x8fbd, 0x8f63, 0x8f09, 0x8eb0, 0x8e58,
0x8e00, 0x8da9, 0x8d53, 0x8cfd, 0x8ca8, 0x8c53, 0x8bff, 0x8bac,
0x8b59, 0x8b06, 0x8ab5, 0x8a64, 0x8a13, 0x89c3, 0x8973, 0x8924,
0x88d6, 0x8888, 0x883b, 0x87ee, 0x87a1, 0x8755, 0x870a, 0x86bf,
0x8675, 0x862b, 0x85e1, 0x8598, 0x8550, 0x8508, 0x84c0, 0x8479,
0x8432, 0x83ec, 0x83a6, 0x8361, 0x831c, 0x82d7, 0x8293, 0x824f,
0x820c, 0x81c9, 0x8186, 0x8144, 0x8103, 0x80c1, 0x8080, 0x8040,
};
br_fixed_ls BrFixedAbs(br_fixed_ls a) {
LOG_TRACE("(%08x)", a);
if (a < 0) {
a = -a;
}
return a;
}
br_fixed_ls BrFixedMul(br_fixed_ls a, br_fixed_ls b) {
LOG_TRACE("(%08x, %08x)", a, b);
return ((long long)a * (long long)b) >> 16;
}
br_fixed_ls BrFixedMac2(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d) {
LOG_TRACE("(%08x, %08x, %08x, %08x)", a, b, c, d);
return ((long long)a * (long long)b + (long long)c * (long long)d) >> 16;
}
br_fixed_ls BrFixedMac3(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d, br_fixed_ls e, br_fixed_ls f) {
LOG_TRACE("(%08x, %08x, %08x, %08x, %08x, %08x)", a, b, c, d, e, f);
return ((long long)a * (long long)b + (long long)c * (long long)d + (long long)e * (long long)f) >> 16;
}
br_fixed_ls BrFixedMac4(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d, br_fixed_ls e, br_fixed_ls f, br_fixed_ls g, br_fixed_ls h) {
LOG_TRACE("(%08x, %08x, %08x, %08x, %08x, %08x, %08x, %08x)", a, b, c, d, e, f, g, h);
return ((long long)a * (long long)b + (long long)c * (long long)d + (long long)e * (long long)f + (long long)g * (long long)h) >> 16;
}
br_fixed_ls BrFixedLength2(br_fixed_ls a, br_fixed_ls b) {
LOG_TRACE("(%08x, %08x)", a, b);
return _BrISqrt64((long long)a * (long long)a + (long long)b * (long long)b);
}
br_fixed_ls BrFixedLength3(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c) {
LOG_TRACE("(%08x, %08x, %08x)", a, b, c);
return _BrISqrt64((long long)a * (long long)a + (long long)b * (long long)b + (long long)c * (long long)c);
}
br_fixed_ls BrFixedLength4(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d) {
LOG_TRACE("(%08x, %08x, %08x, %08x)", a, b, c, d);
return _BrISqrt64((long long)a * (long long)a + (long long)b * (long long)b + (long long)c * (long long)c + (long long)d * (long long)d);
}
br_fixed_ls BrFixedRLength2(br_fixed_ls a, br_fixed_ls b) {
LOG_TRACE("(%08x, %08x)", a, b);
return _BrFastRSqrt64((long long)a * (long long)a + (long long)b * (long long)b);
}
br_fixed_ls BrFixedRLength3(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c) {
LOG_TRACE("(%08x, %08x, %08x)", a, b, c);
return _BrFastRSqrt64((long long)a * (long long)a + (long long)b * (long long)b + (long long)c * (long long)c);
}
br_fixed_ls BrFixedRLength4(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d) {
LOG_TRACE("(%08x, %08x, %08x, %08x)", a, b, c, d);
return _BrFastRSqrt64((long long)a * (long long)a + (long long)b * (long long)b + (long long)c * (long long)c + (long long)d * (long long)d);
}
br_fixed_ls BrFixedDiv(br_fixed_ls a, br_fixed_ls b) {
LOG_TRACE("(%08x, %08x)", a, b);
return (((long long)a) << 16) / (long long)b;
}
br_fixed_ls BrFixedDivR(br_fixed_ls a, br_fixed_ls b) {
LOG_TRACE("(%08x, %08x)", a, b);
return (((long long)a) << 16 | ((((uint32_t)(a)) & 0x80000000) ? 0xffff : 0x0)) / b;
}
br_fixed_ls BrFixedDivF(br_fixed_ls a, br_fixed_ls b) {
LOG_TRACE("(%08x, %08x)", a, b);
return (((long long)a) << 31) / b;
}
br_fixed_ls BrFixedMulDiv(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c) {
LOG_TRACE("(%08x, %08x, %08x)", a, b, c);
return ((long long)a * (long long)b) / (long long)c;
}
br_fixed_ls BrFixedMac2Div(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d, br_fixed_ls e) {
LOG_TRACE("(%08x, %08x, %08x, %08x, %08x)", a, b, c, d, e);
return ((long long)a * (long long)b + (long long)c * (long long)d) / (long long)e;
}
br_fixed_ls BrFixedMac3Div(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d, br_fixed_ls e, br_fixed_ls f, br_fixed_ls g) {
LOG_TRACE("(%08x, %08x, %08x, %08x, %08x, %08x, %08x)", a, b, c, d, e, f, g);
return ((long long)a * (long long)b + (long long)c * (long long)d + (long long)e * (long long)f) / (long long)g;
}
br_fixed_ls BrFixedMac4Div(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d, br_fixed_ls e, br_fixed_ls f, br_fixed_ls g, br_fixed_ls h, br_fixed_ls i) {
LOG_TRACE("(%08x, %08x, %08x, %08x, %08x, %08x, %08x, %08x, %08x)", a, b, c, d, e, f, g, h, i);
return ((long long)a * (long long)b + (long long)c * (long long)d + (long long)e * (long long)f + (long long)g * (long long)h) / (long long)i;
}
br_fixed_ls BrFixedFMac2(br_fixed_lsf a, br_fixed_ls b, br_fixed_lsf c, br_fixed_ls d) {
LOG_TRACE("(%08x, %08x, %08x, %08x)", a, b, c, d);
return ((long long)a * (long long)b + (long long)c * (long long)d) >> 15;
}
br_fixed_ls BrFixedFMac3(br_fixed_lsf a, br_fixed_ls b, br_fixed_lsf c, br_fixed_ls d, br_fixed_lsf e, br_fixed_ls f) {
LOG_TRACE("(%08x, %08x, %08x, %08x, %08x, %08x)", a, b, c, d, e, f);
return ((long long)a * (long long)b + (long long)c * (long long)d + (long long)e * (long long)f) >> 15;
}
br_fixed_ls BrFixedFMac4(br_fixed_lsf a, br_fixed_ls b, br_fixed_lsf c, br_fixed_ls d, br_fixed_lsf e, br_fixed_ls f, br_fixed_lsf g, br_fixed_ls h) {
LOG_TRACE("(%08x, %08x, %08x, %08x, %08x, %08x, %08x, %08x, %08x)", a, b, c, d, e, f, g, h);
return ((long long)a * (long long)b + (long long)c * (long long)d + (long long)e * (long long)f + (long long)g * (long long)h) >> 15;
}
br_fixed_ls BrFixedRcp(br_fixed_ls a) {
LOG_TRACE("(%08x)", a);
return (br_fixed_ls)(((long long)0x100000000) / a);
}
br_fixed_ls BrFixedSqr(br_fixed_ls a) {
LOG_TRACE("(%08x)", a);
return ((long long)a * (long long)a) >> 16;
}
br_fixed_ls BrFixedSqr2(br_fixed_ls a, br_fixed_ls b) {
LOG_TRACE("(%08x, %08x)", a, b);
return ((long long)a * (long long)a + (long long)b * (long long)b) >> 16;
}
br_fixed_ls BrFixedSqr3(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c) {
LOG_TRACE("(%08x, %08x, %08x)", a, b, c);
return ((long long)a * (long long)a + (long long)b * (long long)b + (long long)c * (long long)c) >> 16;
}
br_fixed_ls BrFixedSqr4(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d) {
LOG_TRACE("(%08x, %08x, %08x, %08x)", a, b, c, d);
return ((long long)a * (long long)a + (long long)b * (long long)b + (long long)c * (long long)c + (long long)d * (long long)d) >> 16;
}
static int16_t fixed_lut_interpolate(uint16_t *table, uint32_t value) {
uint16_t idx = value >> 8;
int16_t basew = table[idx];
int16_t deltaw = table[idx+1] - basew;
int16_t errw = (deltaw * (value & 0xff)) >> 8;
return basew + errw;
}
br_fixed_ls BrFixedSin(br_angle a) {
LOG_TRACE("(%04x)", a);
return 2 * fixed_lut_interpolate(fixed_sin_table, a);
}
br_fixed_ls BrFixedCos(br_angle a) {
LOG_TRACE("(%04x)", a);
return 2 * fixed_lut_interpolate(fixed_cos_table, a);
}
br_angle BrFixedASin(br_fixed_ls a) {
LOG_TRACE("(%08x)", a);
assert(a <= BrFloatToFixed(1.f) && "a must be <= BrFloatToFixed(1.f)");
assert(a >= BrFloatToFixed(-1.f) && "a must be >= BrFloatToFixed(-1.f)");
return fixed_lut_interpolate(fixed_asin_table, (a+0x10000) >> 1);
}
br_angle BrFixedACos(br_fixed_ls a) {
LOG_TRACE("(%08x)", a);
assert(a <= BrFloatToFixed(1.f) && "a must be <= BrFloatToFixed(1.f)");
assert(a >= BrFloatToFixed(-1.f) && "a must be >= BrFloatToFixed(-1.f)");
return fixed_lut_interpolate(fixed_acos_table, (a+0x10000) >> 1);
}
br_angle BrFixedATan2(br_fixed_ls x, br_fixed_ls y) {
LOG_TRACE("(%08x %08x)", x, y);
if (y > 0) {
if (x >= 0) {
if (x > y) {
return fixed_lut_interpolate(fixed_atan_table, ((((unsigned long long)y)<<32) / x) >> 16); // atan(y / x)
} else if (x == y) {
return 0x2000; // PI / 4
} else {
return 0x4000 - fixed_lut_interpolate(fixed_atan_table, ((((unsigned long long)x)<<32) / y) >> 16); // PI/2 - atan(x / y)
}
} else {
x = -x;
if (x < y) {
return 0x4000 + fixed_lut_interpolate(fixed_atan_table, ((((unsigned long long)x)<<32) / y) >> 16); // PI/2 + atan(x / y)
} else if (x == y) {
return 0x6000; // 3 * PI / 4
} else {
return 0x8000 - fixed_lut_interpolate(fixed_atan_table, ((((unsigned long long)y)<<32) / x) >> 16); // PI - atan(y / x)
}
}
} else if (y < 0) {
y = -y;
if (x < 0) {
x = -x;
if (x > y) {
return 0x8000 + fixed_lut_interpolate(fixed_atan_table, ((((unsigned long long)y)<<32) / x) >> 16); // PI + atan(y / x)
} else if (x == y) {
return 0xa000; // 5 * PI / 4
} else {
return 0xc000 - fixed_lut_interpolate(fixed_atan_table, ((((unsigned long long)x)<<32) / y) >> 16); // 3 * PI / 2 - atan(x / y)
}
} else {
if (x < y) {
return 0xc000 + fixed_lut_interpolate(fixed_atan_table, ((((unsigned long long)x)<<32) / y) >> 16); // 3 * PI / 2 + atan(x / y)
} else if (x == y) {
return 0xe000; // 7 * PI / 4
} else {
return -fixed_lut_interpolate(fixed_atan_table, ((((unsigned long long)y)<<32) / x) >> 16); // 2 * pi - atan(y / x)
}
}
} else {
if (x >= 0) {
return 0; // 0
} else {
return 0x8000; // PI
}
}
}
br_angle BrFixedATan2Fast(br_fixed_ls x, br_fixed_ls y) {
LOG_TRACE("(%08x %08x)", x, y);
if (y > 0) {
if (x >= 0) {
if (x > y) {
return ((((unsigned long long)y)<<32) / x) >> 19; // atan(y / x)
} else if (x == y) {
return 0x2000; // PI / 4
} else {
return 0x4000 - (((((unsigned long long)x)<<32) / y) >> 19); // PI/2 - atan(x / y)
}
} else {
x = -x;
if (x < y) {
return 0x4000 + (((((unsigned long long)x)<<32) / y) >> 19); // PI/2 + atan(x / y)
} else if (x == y) {
return 0x6000; // 3 * PI / 4
} else {
return 0x8000 - (((((unsigned long long)y)<<32) / x) >> 19); // PI - atan(y / x)
}
}
} else if (y < 0) {
y = -y;
if (x < 0) {
x = -x;
if (x > y) {
return 0x8000 + (((((unsigned long long)y)<<32) / x) >> 19); // PI + atan(y / x)
} else if (x == y) {
return 0xa000; // 5 * PI / 4
} else {
return 0xc000 - (((((unsigned long long)x)<<32) / y) >> 19); // 3 * PI / 2 - atan(x / y)
}
} else {
if (x < y) {
return 0xc000 + (((((unsigned long long)x)<<32) / y) >> 19); // 3 * PI / 2 + atan(x / y)
} else if (x == y) {
return 0xe000; // 7 * PI / 4
} else {
return (br_angle)(0x10000 - (((((unsigned long long)y)<<32) / x) >> 19)); // 2 * pi - atan(y / x)
}
}
} else {
if (x >= 0) {
return 0; // 0
} else {
return 0x8000; // PI
}
}
return 0;
}
uint16_t _BrISqrt32(uint32_t a) {
// Shifting nth root algorithm
uint32_t err;
uint32_t est;
uint32_t est_2;
int i;
LOG_TRACE("(%u)", a);
err = 0;
est = 0;
est_2 = 0;
// 2 MSB bits
err = a >> 30;
a <<= 2;
if (err != 0) {
err -= 1;
est = 1;
est_2 = 2;
}
// 14 iterations: 14*2-bit pairs=28 bits
for (i = 0; i < 14; i++) {
err = (err << 2) | (a >> 30);
a <<= 2;
est <<= 1;
est_2 <<= 1;
if (err > est_2) {
err -= est_2 + 1;
est += 1;
est_2 += 2;
}
}
// 2 LSB bits
err = (err << 2) | (a >> 30);
est <<= 1;
est_2 <<= 1;
if (err > est_2) {
est += 1;
}
return est;
}
#include <stdio.h>
br_uint_32 _BrISqrt64(uint64_t a) {
// Shifting nth root algorithm
uint64_t err;
uint64_t est;
uint64_t est_2;
int i;
LOG_TRACE("(%lu)", a);
err = 0;
est = 0;
est_2 = 0;
// 32 iterations (32 * 2bits)
for (i = 0; i < 32; i++) {
err = (err << 2) | (a >> 62);
a <<= 2;
est <<= 1;
est_2 <<= 1;
if (err > est_2) {
err -= est_2 + 1;
est += 1;
est_2 += 2;
}
}
return (br_uint_32)est;
}
#if 0
// working inprecise
uint16_t _BrFastSqrt32(uint32_t v) {
uint32_t exp;
LOG_TRACE("(%u)", v);
if (v == 0) {
return v;
}
for (exp = 31; (v >> exp) == 0; exp--) {
}
// Exponent must be multiple of 2 (because square root divides exponent by 2)
exp = (exp | 1) + 1;
// Normalise number: exponent in [0..31], mantissa in [0x40-0xff]
v = (v << (31 - exp)) >> 24;
v = fast_sqrt_table[2*v-0x40];
return (v << 16) >> (32 - (exp >> 1));
}
#endif
uint16_t _BrFastSqrt32(uint32_t v) {
uint32_t exp;
LOG_TRACE("(%u)", v);
if (v == 0) {
return v;
}
for (exp = 31; (v >> exp) == 0; exp--) {
}
// Exponent must be multiple of 2 (because square root divides exponent by 2)
exp = (exp | 1) + 1;
// Normalise number: exponent in [0..31], mantissa in [0x40-0xff]
v = (v << (32 - exp)) >> 24;
v = fast_sqrt_table[v-0x40];
return (v << 16) >> (32 - (exp >> 1));
}
uint32_t _BrFastRSqrt32(uint32_t v) {
uint32_t exp;
LOG_TRACE("(0x%08x)", v);
if (v == 0) {
return v;
}
for (exp = 31; (v >> exp) == 0; exp--) {
}
exp = exp | 1;
v = (v << (31 - exp)) >> 24;
v = fast_rsqrt_table[v-0x40];
return v >> (exp >> 1);
}
br_uint_32 _BrFastRSqrt64(uint64_t v) {
uint32_t exp;
uint32_t tmp;
LOG_TRACE("(0x%016llx)", v);
if (v == 0) {
return 0;
}
tmp = v >> 32;
if (tmp != 0) {
for (exp = 31; (tmp >> exp) == 0; exp--) {
}
exp = (31-exp) & 0xfe;
v = (v << exp) >> 56;
fflush(stdout);
v = fast_rsqrt_table[v-0x40];
return (br_uint_32)(v >> ((30 - exp) >> 1));
}
tmp = (br_uint_32)v;
for (exp = 31; (tmp >> exp) == 0; exp--) {
}
exp = exp | 1;
v = (v << (31 - exp)) >> 24;
v = fast_rsqrt_table[v-0x40];
return (br_uint_32)((v << 16) >> (exp >> 1));
}

109
src/BRSRC13/CORE/MATH/fixed.h Normal file
View File

@ -0,0 +1,109 @@
#ifndef _FIXED_H_
#define _FIXED_H_
#include "brender/br_types.h"
#define BR_ONE_LS ((br_fixed_ls)0x00010000)
#define BR_ONE_LU ((br_fixed_lu)0x00010000)
#define BR_ONE_LSF ((br_fixed_ls)0x00008000)
#define BR_ONE_LUF ((br_fixed_lu)0x00010000)
#define BR_ONE_SS ((br_fixed_ss)0x0100)
#define BR_ONE_SU ((br_fixed_ss)0x0100)
#define BR_ONE_SSF ((br_fixed_ss)0x0080)
#define BR_ONE_SUF ((br_fixed_ss)0x0100)
#define BrIntToFixed(i) ((i)<<16)
#define BrFloatToFixed(f) ((br_fixed_ls)((f)*65536.f))
#define BrFixedToInt(i) ((i)>>16)
#define BrFixedToFloat(i) ((float)((i)*(1.f/65536.f)))
#define BrFloatToFixedFraction(f) ((br_fixed_lsf)((f)*32768.f))
#define BrFixedFractionToFloat(f) ((float)(((br_fixed_lsf)(f))*(1.f/32768.f)))
#define BrFloatToFixedUFraction(f) ((br_fixed_luf)((f)*65536.f))
#define BrFixedUFractionToFloat(f) ((float)(((br_fixed_luf)(f))*(1.f/65536.f)))
#if 1
#define BrFloatToScalar(f) f
#define BrScalarToFlat(f) f
#define BrFixedToScalar BrFixedToFloat
#define BrScalarToFixed BrFloatToFixed
#define BrScalarToFraction(f) f
#define BrFractionToScalar(f) f
#endif
br_fixed_ls BrFixedAbs(br_fixed_ls a);
br_fixed_ls BrFixedMul(br_fixed_ls a, br_fixed_ls b);
br_fixed_ls BrFixedMac2(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d);
br_fixed_ls BrFixedMac3(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d, br_fixed_ls e, br_fixed_ls f);
br_fixed_ls BrFixedMac4(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d, br_fixed_ls e, br_fixed_ls f, br_fixed_ls g, br_fixed_ls h);
br_fixed_ls BrFixedLength2(br_fixed_ls a, br_fixed_ls b);
br_fixed_ls BrFixedLength3(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c);
br_fixed_ls BrFixedLength4(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d);
br_fixed_ls BrFixedRLength2(br_fixed_ls a, br_fixed_ls b);
br_fixed_ls BrFixedRLength3(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c);
br_fixed_ls BrFixedRLength4(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d);
br_fixed_ls BrFixedDiv(br_fixed_ls a, br_fixed_ls b);
br_fixed_ls BrFixedDivR(br_fixed_ls a, br_fixed_ls b);
br_fixed_ls BrFixedDivF(br_fixed_ls a, br_fixed_ls b);
br_fixed_ls BrFixedMulDiv(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c);
br_fixed_ls BrFixedMac2Div(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d, br_fixed_ls e);
br_fixed_ls BrFixedMac3Div(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d, br_fixed_ls e, br_fixed_ls f, br_fixed_ls g);
br_fixed_ls BrFixedMac4Div(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d, br_fixed_ls e, br_fixed_ls f, br_fixed_ls g, br_fixed_ls h, br_fixed_ls i);
br_fixed_ls BrFixedFMac2(br_fixed_lsf a, br_fixed_ls b, br_fixed_lsf c, br_fixed_ls d);
br_fixed_ls BrFixedFMac3(br_fixed_lsf a, br_fixed_ls b, br_fixed_lsf c, br_fixed_ls d, br_fixed_lsf e, br_fixed_ls f);
br_fixed_ls BrFixedFMac4(br_fixed_lsf a, br_fixed_ls b, br_fixed_lsf c, br_fixed_ls d, br_fixed_lsf e, br_fixed_ls f, br_fixed_lsf g, br_fixed_ls h);
br_fixed_ls BrFixedRcp(br_fixed_ls a);
br_fixed_ls BrFixedSqr(br_fixed_ls a);
br_fixed_ls BrFixedSqr2(br_fixed_ls a, br_fixed_ls b);
br_fixed_ls BrFixedSqr3(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c);
br_fixed_ls BrFixedSqr4(br_fixed_ls a, br_fixed_ls b, br_fixed_ls c, br_fixed_ls d);
br_fixed_ls BrFixedSin(br_angle a);
br_fixed_ls BrFixedCos(br_angle a);
br_angle BrFixedASin(br_fixed_ls a);
br_angle BrFixedACos(br_fixed_ls a);
br_angle BrFixedATan2(br_fixed_ls x, br_fixed_ls y);
br_angle BrFixedATan2Fast(br_fixed_ls x, br_fixed_ls y);
br_uint_16 _BrISqrt32(br_uint_32 a);
br_uint_32 _BrISqrt64(uint64_t a);
br_uint_16 _BrFastSqrt32(br_uint_32 v);
br_uint_32 _BrFastRSqrt32(br_uint_32 v);
br_uint_32 _BrFastRSqrt64(uint64_t v);
#endif

16
src/BRSRC13/CORE/MATH/plane.c
View File

@ -19,25 +19,25 @@ br_int_32 BrPlaneEquation(br_vector4* eqn, br_vector3* v0, br_vector3* v1, br_ve
float d;
float l;
ax = v1->v[0] - v0->v[0];
ay = v1->v[1] - v0->v[1];
bz = v2->v[2] - v0->v[2];
az = v1->v[2] - v0->v[2];
bx = v2->v[0] - v0->v[0];
ax = v1->v[0] - v0->v[0];
by = v2->v[1] - v0->v[1];
bz = v2->v[2] - v0->v[2];
nx = ay * bz - az * by;
ny = az * bx - ax * bz;
nz = ax * by - ay * bx;
l = nx * nx + ny * ny + nz * nz;
l = BrFloatSqrt(l);
if (isnan(l)) {
nx = 0.0;
ny = 0.0;
nz = 1.0;
nx = 0.f;
ny = 0.f;
nz = 1.f;
} else {
nx = nx * (1.0f / l);
ny = ny * (1.0f / l);
nz = nz * (1.0f / l);
nx = nx * (1.f / l);
ny = ny * (1.f / l);
nz = nz * (1.f / l);
}
d = nx * v0->v[0] + ny * v0->v[1] + nz * v0->v[2];
eqn->v[0] = nx;

2
src/BRSRC13/CORE/STD/brstdfile.c
View File

@ -102,6 +102,7 @@ void BrStdioPutChar(int c, void* f) {
br_size_t BrStdioRead(void* buf, br_size_t size, unsigned int n, void* f) {
int i;
LOG_TRACE9("(%p, %d, %d, %p)", buf, size, n, f);
i = fread(buf, size, n, f);
return i;
@ -114,6 +115,7 @@ br_size_t BrStdioWrite(void* buf, br_size_t size, unsigned int n, void* f) {
br_size_t BrStdioGetLine(char* buf, br_size_t buf_len, void* f) {
br_size_t l;
LOG_TRACE9("(%p, %d, %p)", buf, buf_len, f);
if (fgets(buf, buf_len, f) == NULL) {
return 0;
}

1
src/BRSRC13/CORE/STD/brstdlib.c
View File

@ -124,6 +124,7 @@ br_int_32 BrVSprintfN(char* buf, br_size_t buf_size, const char* fmt, va_list ar
strncpy(buf, tmp, n);
buf[n] = '\0';
return n;
}
br_int_32 BrVSScanf(char* buf, const char* fmt, va_list args) {

3279
test/BRSRC13/test_datafile.c
View File

File diff suppressed because it is too large Load Diff

471
test/BRSRC13/test_fixed.c Normal file
View File

@ -0,0 +1,471 @@
#include "CORE/MATH/fixed.h"
#include "tests.h"
#include <math.h>
#include <string.h>
static void test_fixed_conversions() {
TEST_ASSERT_EQUAL_INT(1<<16, BR_ONE_LS);
TEST_ASSERT_EQUAL_INT(1<<16, BR_ONE_LU);
TEST_ASSERT_EQUAL_INT(1<<8, BR_ONE_SS);
TEST_ASSERT_EQUAL_INT(1<<8, BR_ONE_SU);
TEST_ASSERT_EQUAL_INT(1<<15, BR_ONE_LSF);
TEST_ASSERT_EQUAL_INT(1<<16, BR_ONE_LUF);
TEST_ASSERT_EQUAL_INT(1<<7, BR_ONE_SSF);
TEST_ASSERT_EQUAL_INT(1<<8, BR_ONE_SUF);
TEST_ASSERT_EQUAL_INT(0, BrIntToFixed(0));
TEST_ASSERT_EQUAL_INT((br_fixed_ls)0xffff0000, BrIntToFixed(-1));
TEST_ASSERT_EQUAL_INT((br_fixed_ls)(42<<16), BrIntToFixed(42));
TEST_ASSERT_EQUAL_INT(42<<16, BrFloatToFixed(42.f));
TEST_ASSERT_EQUAL_INT((br_fixed_ls)0x00008000, BrFloatToFixed(.5f));
TEST_ASSERT_EQUAL_INT((br_fixed_ls)0xffff8000, BrFloatToFixed(-.5f));
TEST_ASSERT_EQUAL_INT((br_fixed_ls)0x00005555, BrFloatToFixed(.333333333333f));
TEST_ASSERT_EQUAL_INT(0x00005555, BrScalarToFixed(BR_SCALAR(.333333333333f)));
TEST_ASSERT_EQUAL_INT(0x42, BrFixedToInt(0x0042ffff));
TEST_ASSERT_EQUAL_FLOAT(.5f, BrFixedToFloat(0x00008000));
TEST_ASSERT_FLOAT_WITHIN(1e-5f, .333333333333f, BrFixedToFloat(0x00005555));
TEST_ASSERT_FLOAT_WITHIN(1e-5f, .333333333333f, BrFixedToScalar(0x00005555));
TEST_ASSERT_EQUAL_UINT16(0x0000, BrFloatToFixedFraction(0.f));
TEST_ASSERT_EQUAL_UINT16(0x7fff, BrFloatToFixedFraction(0.99999f));
TEST_ASSERT_EQUAL_UINT16(0x8000, BrFloatToFixedFraction(-1.f));
TEST_ASSERT_EQUAL_UINT16(0x6000, BrFloatToFixedFraction(0.75f));
TEST_ASSERT_EQUAL_UINT16(0xa000, BrFloatToFixedFraction(-0.75f));
TEST_ASSERT_EQUAL_FLOAT(0.f, BrFixedFractionToFloat(0x0000));
TEST_ASSERT_EQUAL_FLOAT(0.9999695f, BrFixedFractionToFloat(0x7fff));
TEST_ASSERT_EQUAL_FLOAT(-1.f, BrFixedFractionToFloat(0x8000));
TEST_ASSERT_EQUAL_FLOAT(0.75f, BrFixedFractionToFloat(0x6000));
TEST_ASSERT_EQUAL_FLOAT(-0.75f, BrFixedFractionToFloat(0xa000));
}
static void test_fixed_BrFixedAbs() {
TEST_ASSERT_EQUAL(BrFloatToFixed(42.f), BrFixedAbs(BrFloatToFixed(42.f)));
TEST_ASSERT_EQUAL(BrFloatToFixed(42.f), BrFixedAbs(BrFloatToFixed(-42.f)));
TEST_ASSERT_EQUAL(BrFloatToFixed(1.234f), BrFixedAbs(BrFloatToFixed(-1.234f)));
}
static void test_fixed_BrFixedMul() {
TEST_ASSERT_EQUAL(BrFloatToFixed(63.f), BrFixedMul(BrFloatToFixed(1.5f), BrFloatToFixed(42.f)));
TEST_ASSERT_EQUAL(BrFloatToFixed(-63.f), BrFixedMul(BrFloatToFixed(1.5f), BrFloatToFixed(-42.f)));
TEST_ASSERT_EQUAL(BrFloatToFixed(63.f), BrFixedMul(BrFloatToFixed(-1.5f), BrFloatToFixed(-42.f)));
}
static void test_fixed_BrFixedMac2() {
TEST_ASSERT_EQUAL(BrFloatToFixed(108.f), BrFixedMac2(BrFloatToFixed(1.5f), BrFloatToFixed(42.f),
BrFloatToFixed(.5f), BrFloatToFixed(90.f)));
}
static void test_fixed_BrFixedMac3() {
TEST_ASSERT_EQUAL(BrFloatToFixed(133.f), BrFixedMac3(BrFloatToFixed(1.5f), BrFloatToFixed(42.f),
BrFloatToFixed(.5f), BrFloatToFixed(90.f),
BrFloatToFixed(.25f), BrFloatToFixed(100.f)));
}
static void test_fixed_BrFixedMac4() {
TEST_ASSERT_EQUAL(BrFloatToFixed(138.f), BrFixedMac4(BrFloatToFixed(1.5f), BrFloatToFixed(42.f),
BrFloatToFixed(.5f), BrFloatToFixed(90.f),
BrFloatToFixed(.25f), BrFloatToFixed(100.f),
BrFloatToFixed(.125f), BrFloatToFixed(40.f)));
}
static void test_fixed_BrISqrt32() {
TEST_ASSERT_EQUAL_UINT16(0, _BrISqrt32(0));
TEST_ASSERT_EQUAL_UINT16(1, _BrISqrt32(1));
TEST_ASSERT_EQUAL_UINT16(1, _BrISqrt32(2));
TEST_ASSERT_EQUAL_UINT16(2, _BrISqrt32(4));
TEST_ASSERT_EQUAL_UINT16(2, _BrISqrt32(8));
TEST_ASSERT_EQUAL_UINT16(3, _BrISqrt32(9));
TEST_ASSERT_EQUAL_UINT16(3, _BrISqrt32(15));
TEST_ASSERT_EQUAL_UINT16(4, _BrISqrt32(16));
TEST_ASSERT_EQUAL_UINT16(4, _BrISqrt32(24));
TEST_ASSERT_EQUAL_UINT16(5, _BrISqrt32(25));
TEST_ASSERT_EQUAL_UINT16(15, _BrISqrt32(255));
TEST_ASSERT_EQUAL_UINT16(16, _BrISqrt32(256));
TEST_ASSERT_EQUAL_UINT16(99, _BrISqrt32(9999));
TEST_ASSERT_EQUAL_UINT16(100, _BrISqrt32(10000));
TEST_ASSERT_EQUAL_UINT16(17320, _BrISqrt32(300000000));
TEST_ASSERT_EQUAL_UINT16(0xffff, _BrISqrt32(0xffffffff));
}
static void test_fixed_BrISqrt64() {
TEST_ASSERT_EQUAL_UINT32(0, _BrISqrt64(0));
TEST_ASSERT_EQUAL_UINT32(1, _BrISqrt64(1));
TEST_ASSERT_EQUAL_UINT32(1, _BrISqrt64(2));
TEST_ASSERT_EQUAL_UINT32(2, _BrISqrt64(4));
TEST_ASSERT_EQUAL_UINT32(2, _BrISqrt64(8));
TEST_ASSERT_EQUAL_UINT32(3, _BrISqrt64(9));
TEST_ASSERT_EQUAL_UINT32(3, _BrISqrt64(15));
TEST_ASSERT_EQUAL_UINT32(4, _BrISqrt64(16));
TEST_ASSERT_EQUAL_UINT32(4, _BrISqrt64(24));
TEST_ASSERT_EQUAL_UINT32(5, _BrISqrt64(25));
TEST_ASSERT_EQUAL_UINT32(15, _BrISqrt64(255));
TEST_ASSERT_EQUAL_UINT32(16, _BrISqrt64(256));
TEST_ASSERT_EQUAL_UINT32(99, _BrISqrt64(9999));
TEST_ASSERT_EQUAL_UINT32(100, _BrISqrt64(10000));
TEST_ASSERT_EQUAL_UINT32(17320, _BrISqrt64(300000000));
TEST_ASSERT_EQUAL_UINT32(0xffff, _BrISqrt64(0xffffffff));
TEST_ASSERT_EQUAL_UINT32(0xffffffff, _BrISqrt64(0xffffffffffffffff));
}
static void test_fixed_BrFixedLength2() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(5.f), BrFixedLength2(BrFloatToFixed(3.f), BrFloatToFixed(4.f)));
TEST_ASSERT_INT32_WITHIN(BrFloatToFixed(1e-4f), BrFloatToFixed(.5f), BrFixedLength2(BrFloatToFixed(.3f), BrFloatToFixed(.4f)));
}
static void test_fixed_BrFixedLength3() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(7.f), BrFixedLength3(BrFloatToFixed(2.f), BrFloatToFixed(3.f), BrFloatToFixed(6.f)));
TEST_ASSERT_INT32_WITHIN(BrFloatToFixed(1.e-4f), BrFloatToFixed(.7f), BrFixedLength3(BrFloatToFixed(.2f), BrFloatToFixed(.3f), BrFloatToFixed(.6f)));
}
static void test_fixed_BrFixedLength4() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(9.f), BrFixedLength4(BrFloatToFixed(2.f), BrFloatToFixed(4.f), BrFloatToFixed(5.f), BrFloatToFixed(6.f)));
TEST_ASSERT_INT32_WITHIN(BrFloatToFixed(1e-4f), BrFloatToFixed(.9f), BrFixedLength4(BrFloatToFixed(.2f), BrFloatToFixed(.4f), BrFloatToFixed(.5f), BrFloatToFixed(.6f)));
}
static void test_fixed_BrFixedDiv() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(1.f), BrFixedDiv(BrFloatToFixed(1.f), BrFloatToFixed(1.f)));
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(2.f), BrFixedDiv(BrFloatToFixed(1.f), BrFloatToFixed(.5f)));
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(5.f), BrFixedDiv(BrFloatToFixed(5.f), BrFloatToFixed(1.f)));
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(10.f), BrFixedDiv(BrFloatToFixed(5.f), BrFloatToFixed(.5f)));
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(20.f), BrFixedDiv(BrFloatToFixed(5.f), BrFloatToFixed(.25f)));
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(2.f), BrFixedDiv(BrFloatToFixed(.5f), BrFloatToFixed(.25f)));
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(-5000.f), BrFixedDiv(BrFloatToFixed(20000.f), BrFloatToFixed(-4.f)));
TEST_ASSERT_EQUAL_UINT32(0xfff1b6dc, BrFixedDiv(-100, 7));
}
static void test_fixed_BrFixedDivR() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(5.f), BrFixedDivR(BrFloatToFixed(5.f), BrFloatToFixed(1.f)));
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(10.f), BrFixedDivR(BrFloatToFixed(5.f), BrFloatToFixed(.5f)));
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(20.f), BrFixedDivR(BrFloatToFixed(5.f), BrFloatToFixed(.25f)));
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(2.f), BrFixedDivR(BrFloatToFixed(.5f), BrFloatToFixed(.25f)));
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(-5000.f), BrFixedDivR(BrFloatToFixed(20000.f), BrFloatToFixed(-4.f)));
TEST_ASSERT_EQUAL_UINT32(0xfff1db6e, BrFixedDivR(-100, 7));
}
static void test_fixed_BrFixedDivF() {
TEST_ASSERT_EQUAL_UINT32(1 << 31, BrFixedDivF(BrFloatToFixed(1.f), BrFloatToFixed(1.f)));
TEST_ASSERT_EQUAL_UINT32(1 << 30, BrFixedDivF(BrFloatToFixed(1.f), BrFloatToFixed(2.f)));
}
static void test_fixed_BrFixedMulDiv() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(7.5f), BrFixedMulDiv(BrFloatToFixed(3.f), BrFloatToFixed(5.f),
BrFloatToFixed(2.f)));
}
static void test_fixed_BrFixedMac2Div() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(13.5f), BrFixedMac2Div(BrFloatToFixed(3.f), BrFloatToFixed(5.f),
BrFloatToFixed(2.f), BrFloatToFixed(6.f),
BrFloatToFixed(2.f)));
}
static void test_fixed_BrFixedMac3Div() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(-18.f), BrFixedMac3Div(BrFloatToFixed(3.f), BrFloatToFixed(5.f),
BrFloatToFixed(2.f), BrFloatToFixed(6.f),
BrFloatToFixed(-7.f), BrFloatToFixed(9.f),
BrFloatToFixed(2.f)));
}
static void test_fixed_BrFixedMac4Div() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(4.5f), BrFixedMac4Div(BrFloatToFixed(3.f), BrFloatToFixed(5.f),
BrFloatToFixed(2.f), BrFloatToFixed(6.f),
BrFloatToFixed(-7.f), BrFloatToFixed(9.f),
BrFloatToFixed(9.f), BrFloatToFixed(5.f),
BrFloatToFixed(2.f)));
}
static void test_fixed_BrFixedFMac2() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(2.75f), BrFixedFMac2(BrFloatToFixedFraction(.25f), BrFloatToFixed(5.f),
BrFloatToFixedFraction(.5f), BrFloatToFixed(3.f)));
}
static void test_fixed_BrFixedFMac3() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(5.75f), BrFixedFMac3(BrFloatToFixedFraction(.25f), BrFloatToFixed(5.f),
BrFloatToFixedFraction(.5f), BrFloatToFixed(3.f),
BrFloatToFixedFraction(.75f), BrFloatToFixed(4.f)));
}
static void test_fixed_BrFixedFMac4() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(6.625f), BrFixedFMac4(BrFloatToFixedFraction(.25f), BrFloatToFixed(5.f),
BrFloatToFixedFraction(.5f), BrFloatToFixed(3.f),
BrFloatToFixedFraction(.75f), BrFloatToFixed(4.f),
BrFloatToFixedFraction(.125f), BrFloatToFixed(7.f)));
}
static void test_fixed_BrFixedRcp() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(4.f), BrFixedRcp(BrFloatToFixed(.25f)));
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(.25f), BrFixedRcp(BrFloatToFixed(4.f)));
}
static void test_fixed_BrFixedSqr() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(.0625f), BrFixedSqr(BrFloatToFixed(.25f)));
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(16.f), BrFixedSqr(BrFloatToFixed(4.f)));
}
static void test_fixed_BrFixedSqr2() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(1.0625f), BrFixedSqr2(BrFloatToFixed(.25f), BrFloatToFixed(1.f)));
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(20.f), BrFixedSqr2(BrFloatToFixed(4.f), BrFloatToFixed(2.f)));
}
static void test_fixed_BrFixedSqr3() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(5.0625f), BrFixedSqr3(BrFloatToFixed(.25f), BrFloatToFixed(1.f), BrFloatToFixed(2.f)));
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(29.f), BrFixedSqr3(BrFloatToFixed(4.f), BrFloatToFixed(2.f), BrFloatToFixed(3.f)));
}
static void test_fixed_BrFixedSqr4() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(14.0625f), BrFixedSqr4(BrFloatToFixed(.25f), BrFloatToFixed(1.f), BrFloatToFixed(2.f), BrFloatToFixed(-3.f)));
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(45.f), BrFixedSqr4(BrFloatToFixed(4.f), BrFloatToFixed(2.f), BrFloatToFixed(3.f), BrFloatToFixed(-4.f)));
}
static void test_fixed_BrFixedSin() {
TEST_ASSERT_EQUAL_UINT32(BrFloatToFixed(.0f), BrFixedSin(BrRadianToAngle(0.0f * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(.5f), BrFixedSin(BrRadianToAngle((1.f/6.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(.7071067811865476f), BrFixedSin(BrRadianToAngle((1.f/4.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(.8660254037844386f), BrFixedSin(BrRadianToAngle((1.f/3.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(1.f), BrFixedSin(BrRadianToAngle((1.f/2.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(.8660254037844386f), BrFixedSin(BrRadianToAngle((2.f/3.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(.7071067811865476f), BrFixedSin(BrRadianToAngle((3.f/4.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(.5f), BrFixedSin(BrRadianToAngle((5.f/6.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(.0f), BrFixedSin(BrRadianToAngle(1.0f * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(-.5f), BrFixedSin(BrRadianToAngle((7.f/6.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(-.7071067811865476f), BrFixedSin(BrRadianToAngle((5.f/4.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(-.8660254037844386f), BrFixedSin(BrRadianToAngle((4.f/3.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(-1.f), BrFixedSin(BrRadianToAngle((-1.f/2.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(-.8660254037844386f), BrFixedSin(BrRadianToAngle((5.f/3.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(-.7071067811865476f), BrFixedSin(BrRadianToAngle((7.f/4.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(-.5f), BrFixedSin(BrRadianToAngle((11.f/6.f) * PI)));
}
static void test_fixed_BrFixedCos() {
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(1.f), BrFixedCos(BrRadianToAngle(0.0f * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(.8660254037844386f), BrFixedCos(BrRadianToAngle((1.f/6.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(.7071067811865476f), BrFixedCos(BrRadianToAngle((1.f/4.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(.5f), BrFixedCos(BrRadianToAngle((1.f/3.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(0.f), BrFixedCos(BrRadianToAngle((1.f/2.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(-.5f), BrFixedCos(BrRadianToAngle((2.f/3.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(-.7071067811865476f), BrFixedCos(BrRadianToAngle((3.f/4.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(-.8660254037844386f), BrFixedCos(BrRadianToAngle((5.f/6.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(-1.f), BrFixedCos(BrRadianToAngle(1.0f * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(-.8660254037844386f), BrFixedCos(BrRadianToAngle((7.f/6.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(-.7071067811865476f), BrFixedCos(BrRadianToAngle((5.f/4.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(-.5f), BrFixedCos(BrRadianToAngle((4.f/3.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(0.f), BrFixedCos(BrRadianToAngle((-1.f/2.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(.5f), BrFixedCos(BrRadianToAngle((5.f/3.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(.7071067811865476f), BrFixedCos(BrRadianToAngle((7.f/4.f) * PI)));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(.8660254037844386f), BrFixedCos(BrRadianToAngle((11.f/6.f) * PI)));
}
static void test_fixed_BrFixedASin() {
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle(( 3.f / 2.f) * PI), BrFixedASin(BrFloatToFixed(-1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle(( 5.f / 3.f) * PI), BrFixedASin(BrFloatToFixed(-.8660254037844386f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle(( 7.f / 4.f) * PI), BrFixedASin(BrFloatToFixed(-.7071067811865476f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle((11.f / 6.f) * PI), BrFixedASin(BrFloatToFixed(-.5f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 0.0f * PI), BrFixedASin(BrFloatToFixed(.0f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle(( 1.f / 6.f) * PI), BrFixedASin(BrFloatToFixed(.5f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle(( 1.f / 4.f) * PI), BrFixedASin(BrFloatToFixed(.7071067811865476f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle(( 1.f / 3.f) * PI), BrFixedASin(BrFloatToFixed(.8660254037844386f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle(( 1.f / 2.f) * PI), BrFixedASin(BrFloatToFixed(1.f)));
}
static void test_fixed_BrFixedACos() {
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 1.f * PI), BrFixedACos(BrFloatToFixed(-1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle((5.f / 6.f) * PI), BrFixedACos(BrFloatToFixed(-.8660254037844386f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle((3.f / 4.f) * PI), BrFixedACos(BrFloatToFixed(-.7071067811865476f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle((2.f / 3.f) * PI), BrFixedACos(BrFloatToFixed(-.5f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle((1.f / 2.f) * PI), BrFixedACos(BrFloatToFixed(.0f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle((1.f / 3.f) * PI), BrFixedACos(BrFloatToFixed(.5f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle((1.f / 4.f) * PI), BrFixedACos(BrFloatToFixed(.7071067811865476f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle((1.f / 6.f) * PI), BrFixedACos(BrFloatToFixed(.8660254037844386f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 0.f * PI), BrFixedACos(BrFloatToFixed(1.f)));
}
static void test_fixed_BrFixedATan2() {
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 0.f * PI), BrFixedATan2(BrFloatToFixed( 1.f), BrFloatToFixed(0.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 1.f / 6.f * PI), BrFixedATan2(BrFloatToFixed( 1.f), BrFloatToFixed(0.5773502691896258f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 1.f / 4.f * PI), BrFixedATan2(BrFloatToFixed( 1.f), BrFloatToFixed(1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 1.f / 3.f * PI), BrFixedATan2(BrFloatToFixed( 1.f), BrFloatToFixed(1.7320508075688772f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 1.f / 2.f * PI), BrFixedATan2(BrFloatToFixed( 0.f), BrFloatToFixed(1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 2.f / 3.f * PI), BrFixedATan2(BrFloatToFixed(-1.f), BrFloatToFixed(1.7320508075688772f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 3.f / 4.f * PI), BrFixedATan2(BrFloatToFixed(-1.f), BrFloatToFixed(1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 5.f / 6.f * PI), BrFixedATan2(BrFloatToFixed(-1.f), BrFloatToFixed(0.5773502691896258f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 1.f * PI), BrFixedATan2(BrFloatToFixed(-1.f), BrFloatToFixed(0.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 7.f / 6.f * PI), BrFixedATan2(BrFloatToFixed(-1.f), BrFloatToFixed(-0.5773502691896258f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 5.f / 4.f * PI), BrFixedATan2(BrFloatToFixed(-1.f), BrFloatToFixed(-1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 4.f / 3.f * PI), BrFixedATan2(BrFloatToFixed(-1.f), BrFloatToFixed(-1.7320508075688772f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 3.f / 2.f * PI), BrFixedATan2(BrFloatToFixed( 0.f), BrFloatToFixed(-1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 5.f / 3.f * PI), BrFixedATan2(BrFloatToFixed( 1.f), BrFloatToFixed(-1.7320508075688772f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle( 7.f / 4.f * PI), BrFixedATan2(BrFloatToFixed( 1.f), BrFloatToFixed(-1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle(11.f / 6.f * PI), BrFixedATan2(BrFloatToFixed( 1.f), BrFloatToFixed(-0.5773502691896258f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle(1.f / 2.f * PI), BrFixedATan2(BrFloatToFixed(1.f), BrFloatToFixed(16000.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle(1.f / 6.f * PI), BrFixedATan2(BrFloatToFixed(1.7320508075688772f), BrFloatToFixed(1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle(1.f / 3.f * PI), BrFixedATan2(BrFloatToFixed(0.5773502691896258f), BrFloatToFixed(1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle(1.f / 6.f * PI), BrFixedATan2(BrFloatToFixed(1.7320508075688772f), BrFloatToFixed(1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-3f), BrRadianToAngle(1.f / 3.f * PI), BrFixedATan2(BrFloatToFixed(0.5773502691896258f), BrFloatToFixed(1.f)));
}
static void test_fixed_BrFixedATan2Fast() {
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle( 0.f * PI), BrFixedATan2Fast(BrFloatToFixed( 1.f), BrFloatToFixed(0.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle( 1.f / 6.f * PI), BrFixedATan2Fast(BrFloatToFixed( 1.f), BrFloatToFixed(0.5773502691896258f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle( 1.f / 4.f * PI), BrFixedATan2Fast(BrFloatToFixed( 1.f), BrFloatToFixed(1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle( 1.f / 3.f * PI), BrFixedATan2Fast(BrFloatToFixed( 1.f), BrFloatToFixed(1.7320508075688772f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle( 1.f / 2.f * PI), BrFixedATan2Fast(BrFloatToFixed( 0.f), BrFloatToFixed(1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle( 2.f / 3.f * PI), BrFixedATan2Fast(BrFloatToFixed(-1.f), BrFloatToFixed(1.7320508075688772f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle( 3.f / 4.f * PI), BrFixedATan2Fast(BrFloatToFixed(-1.f), BrFloatToFixed(1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle( 5.f / 6.f * PI), BrFixedATan2Fast(BrFloatToFixed(-1.f), BrFloatToFixed(0.5773502691896258f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle( 1.f * PI), BrFixedATan2Fast(BrFloatToFixed(-1.f), BrFloatToFixed(0.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle( 7.f / 6.f * PI), BrFixedATan2Fast(BrFloatToFixed(-1.f), BrFloatToFixed(-0.5773502691896258f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle( 5.f / 4.f * PI), BrFixedATan2Fast(BrFloatToFixed(-1.f), BrFloatToFixed(-1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle( 4.f / 3.f * PI), BrFixedATan2Fast(BrFloatToFixed(-1.f), BrFloatToFixed(-1.7320508075688772f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle( 3.f / 2.f * PI), BrFixedATan2Fast(BrFloatToFixed( 0.f), BrFloatToFixed(-1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle( 5.f / 3.f * PI), BrFixedATan2Fast(BrFloatToFixed( 1.f), BrFloatToFixed(-1.7320508075688772f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle( 7.f / 4.f * PI), BrFixedATan2Fast(BrFloatToFixed( 1.f), BrFloatToFixed(-1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle(11.f / 6.f * PI), BrFixedATan2Fast(BrFloatToFixed( 1.f), BrFloatToFixed(-0.5773502691896258f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle(1.f / 2.f * PI), BrFixedATan2Fast(BrFloatToFixed(1.f), BrFloatToFixed(30000.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle(1.f / 6.f * PI), BrFixedATan2Fast(BrFloatToFixed(1.7320508075688772f), BrFloatToFixed(1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle(1.f / 3.f * PI), BrFixedATan2Fast(BrFloatToFixed(0.5773502691896258f), BrFloatToFixed(1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle(1.f / 6.f * PI), BrFixedATan2Fast(BrFloatToFixed(1.7320508075688772f), BrFloatToFixed(1.f)));
TEST_ASSERT_UINT16_WITHIN(BrRadianToAngle(1e-1f), BrRadianToAngle(1.f / 3.f * PI), BrFixedATan2Fast(BrFloatToFixed(0.5773502691896258f), BrFloatToFixed(1.f)));
}
static void test_fixed_BrFastSqrt32() {
TEST_ASSERT_UINT16_WITHIN(5, 0, _BrFastSqrt32(0));
TEST_ASSERT_UINT16_WITHIN(5, 1, _BrFastSqrt32(1));
TEST_ASSERT_UINT16_WITHIN(5, 1, _BrFastSqrt32(2));
TEST_ASSERT_UINT16_WITHIN(5, 2, _BrFastSqrt32(4));
TEST_ASSERT_UINT16_WITHIN(5, 2, _BrFastSqrt32(8));
TEST_ASSERT_UINT16_WITHIN(5, 3, _BrFastSqrt32(9));
TEST_ASSERT_UINT16_WITHIN(5, 3, _BrFastSqrt32(15));
TEST_ASSERT_UINT16_WITHIN(5, 4, _BrFastSqrt32(16));
TEST_ASSERT_UINT16_WITHIN(5, 4, _BrFastSqrt32(24));
TEST_ASSERT_UINT16_WITHIN(5, 5, _BrFastSqrt32(25));
TEST_ASSERT_UINT16_WITHIN(5, 15, _BrFastSqrt32(255));
TEST_ASSERT_UINT16_WITHIN(5, 16, _BrFastSqrt32(256));
TEST_ASSERT_UINT16_WITHIN(5, 99, _BrFastSqrt32(9999));
TEST_ASSERT_UINT16_WITHIN(5, 100, _BrFastSqrt32(10000));
TEST_ASSERT_UINT16_WITHIN(0x100, 17320, _BrFastSqrt32(300000000));
TEST_ASSERT_UINT16_WITHIN(0x100, 0xffff, _BrFastSqrt32(0xffffffff));
}
static void test_fixed_BrFastRSqrt32() {
TEST_ASSERT_UINT32_WITHIN(0, 0x00000, _BrFastRSqrt32(0));
TEST_ASSERT_UINT32_WITHIN(1, 0x10000, _BrFastRSqrt32(1));
TEST_ASSERT_UINT32_WITHIN(1, (uint32_t)(0x10000 / sqrtf(2.f)), _BrFastRSqrt32(2));
TEST_ASSERT_UINT32_WITHIN(1, 0x08000, _BrFastRSqrt32(4));
TEST_ASSERT_UINT32_WITHIN(1, (uint32_t)(0x10000 / sqrtf(8.f)), _BrFastRSqrt32(8));
TEST_ASSERT_UINT32_WITHIN(1, (uint32_t)(0x10000 / sqrtf(9.f)), _BrFastRSqrt32(9));
TEST_ASSERT_UINT32_WITHIN(1, (uint32_t)(0x10000 / sqrtf(15.f)), _BrFastRSqrt32(15));
TEST_ASSERT_UINT32_WITHIN(1, 0x04000, _BrFastRSqrt32(16));
TEST_ASSERT_UINT32_WITHIN(1, (uint32_t)(0x10000 / sqrtf(24.f)), _BrFastRSqrt32(24));
TEST_ASSERT_UINT32_WITHIN(1, (uint32_t)(0x10000 / sqrtf(25.f)), _BrFastRSqrt32(25));
TEST_ASSERT_UINT32_WITHIN(10, (uint32_t)(0x10000 / sqrtf(255.f)), _BrFastRSqrt32(255));
TEST_ASSERT_UINT32_WITHIN(10, 0x01000, _BrFastRSqrt32(256));
TEST_ASSERT_UINT32_WITHIN(10, 0x00800, _BrFastRSqrt32(1024));
TEST_ASSERT_UINT32_WITHIN(10, (uint32_t)(0x10000 / sqrtf(9999.f)), _BrFastRSqrt32(9999));
TEST_ASSERT_UINT32_WITHIN(10, (uint32_t)(0x10000 / sqrtf(10000.f)), _BrFastRSqrt32(10000));
TEST_ASSERT_UINT32_WITHIN(10, (uint32_t)(0x10000 / sqrtf(300000000.f)), _BrFastRSqrt32(300000000));
TEST_ASSERT_UINT32_WITHIN(10, (uint32_t)(0x10000 / sqrtf((float)0xffffffff)), _BrFastRSqrt32(0xffffffff));
}
static void test_fixed_BrFastRSqrt64() {
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), 0x00000000, _BrFastRSqrt64(0));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-0f), 0xffffffff, _BrFastRSqrt64(1));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-0f), 0x80000000, _BrFastRSqrt64(4));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-0f), 0x40000000, _BrFastRSqrt64(16));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-0f), 0x20000000, _BrFastRSqrt64(64));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-0f), 0x10000000, _BrFastRSqrt64(256));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-1f), 0x08000000, _BrFastRSqrt64(1024));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-2f), 0x1000000, _BrFastRSqrt64(0x00010000ULL));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), 0x000100000, _BrFastRSqrt64(0x01000000ULL));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-1f), BrFloatToFixed(1.f / sqrtf(2.f)), _BrFastRSqrt64(2ULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), 0x00008000, _BrFastRSqrt64(4ULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), BrFloatToFixed(1.f / sqrtf(8.f)), _BrFastRSqrt64(8ULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), BrFloatToFixed(1.f / sqrtf(9.f)), _BrFastRSqrt64(9ULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), BrFloatToFixed(1.f / sqrtf(15.f)), _BrFastRSqrt64(15ULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), 0x4000, _BrFastRSqrt64(16ULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), BrFloatToFixed(1.f / sqrtf(24.f)), _BrFastRSqrt64(24ULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), BrFloatToFixed(1.f / sqrtf(25.f)), _BrFastRSqrt64(25ULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), BrFloatToFixed(1.f / sqrtf(81.f)), _BrFastRSqrt64(81ULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), BrFloatToFixed(1.f / sqrtf(255.f)), _BrFastRSqrt64(255ULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), 0x1000, _BrFastRSqrt64(256ULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), 0x00800, _BrFastRSqrt64(1024ULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), BrFloatToFixed(1.f / sqrtf(9999.f)), _BrFastRSqrt64(9999ULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), BrFloatToFixed(1.f / sqrtf(10000.f)), _BrFastRSqrt64(10000ULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), BrFloatToFixed(1.f / sqrtf(300000000.f)), _BrFastRSqrt64(300000000ULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), BrFloatToFixed(1.f / sqrtf(1600000000000.f)), _BrFastRSqrt64(1600000000000ULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), BrFloatToFixed(1.f / sqrtf((float)0xffffffff)), _BrFastRSqrt64(0xffffffffULL<<32));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), 0x10000, _BrFastRSqrt64(0x100000000));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e-3f), 0x8000, _BrFastRSqrt64(0x400000000));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e1f), BrFloatToFixed(1.f / sqrtf((float)0x1000000000)), _BrFastRSqrt64(0x1000000000ULL));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e1f), BrFloatToFixed(1.f / sqrtf((float)0x100000000000)), _BrFastRSqrt64(0x100000000000ULL));
TEST_ASSERT_UINT32_WITHIN(BrFloatToFixed(1.e1f), BrFloatToFixed(1.f / sqrtf((float)0xffffffffffffffffULL)), _BrFastRSqrt64(0xffffffffffffffffULL));
}
static void test_fixed_BrFixedRLength2() {
TEST_ASSERT_EQUAL_INT32(BrFloatToFixed(.2f), BrFixedRLength2(BrFloatToFixed(3.f), BrFloatToFixed(4.f)));
TEST_ASSERT_INT32_WITHIN(BrFloatToFixed(1e-2f), BrFloatToFixed(2.f), BrFixedRLength2(BrFloatToFixed(.3f), BrFloatToFixed(.4f)));
}
static void test_fixed_BrFixedRLength3() {
TEST_ASSERT_EQUAL_INT32(BrFloatToFixed(1/7.f), BrFixedRLength3(BrFloatToFixed(2.f), BrFloatToFixed(3.f), BrFloatToFixed(6.f)));
TEST_ASSERT_INT32_WITHIN(BrFloatToFixed(1.e-2f), BrFloatToFixed(1/.7f), BrFixedRLength3(BrFloatToFixed(.2f), BrFloatToFixed(.3f), BrFloatToFixed(.6f)));
}
static void test_fixed_BrFixedRLength4() {
TEST_ASSERT_EQUAL_INT32(BrFloatToFixed(1/9.f), BrFixedRLength4(BrFloatToFixed(2.f), BrFloatToFixed(4.f), BrFloatToFixed(5.f), BrFloatToFixed(6.f)));
TEST_ASSERT_INT32_WITHIN(BrFloatToFixed(1e-3f), BrFloatToFixed(1/.9f), BrFixedRLength4(BrFloatToFixed(.2f), BrFloatToFixed(.4f), BrFloatToFixed(.5f), BrFloatToFixed(.6f)));
}
void test_fixed_suite() {
UnitySetTestFile(__FILE__);
RUN_TEST(test_fixed_conversions);
RUN_TEST(test_fixed_BrFixedAbs);
RUN_TEST(test_fixed_BrFixedMul);
RUN_TEST(test_fixed_BrFixedMac2);
RUN_TEST(test_fixed_BrFixedMac3);
RUN_TEST(test_fixed_BrFixedMac4);
RUN_TEST(test_fixed_BrISqrt32);
RUN_TEST(test_fixed_BrISqrt64);
RUN_TEST(test_fixed_BrFixedLength2);
RUN_TEST(test_fixed_BrFixedLength3);
RUN_TEST(test_fixed_BrFixedLength4);
RUN_TEST(test_fixed_BrFixedDiv);
RUN_TEST(test_fixed_BrFixedDivR);
RUN_TEST(test_fixed_BrFixedDivF);
RUN_TEST(test_fixed_BrFixedMulDiv);
RUN_TEST(test_fixed_BrFixedMac2Div);
RUN_TEST(test_fixed_BrFixedMac3Div);
RUN_TEST(test_fixed_BrFixedMac4Div);
RUN_TEST(test_fixed_BrFixedFMac2);
RUN_TEST(test_fixed_BrFixedFMac3);
RUN_TEST(test_fixed_BrFixedFMac4);
RUN_TEST(test_fixed_BrFixedRcp);
RUN_TEST(test_fixed_BrFixedSqr);
RUN_TEST(test_fixed_BrFixedSqr2);
RUN_TEST(test_fixed_BrFixedSqr3);
RUN_TEST(test_fixed_BrFixedSqr4);
RUN_TEST(test_fixed_BrFixedSin);
RUN_TEST(test_fixed_BrFixedCos);
RUN_TEST(test_fixed_BrFixedASin);
RUN_TEST(test_fixed_BrFixedACos);
RUN_TEST(test_fixed_BrFixedATan2);
RUN_TEST(test_fixed_BrFixedATan2Fast);
RUN_TEST(test_fixed_BrFastSqrt32);
RUN_TEST(test_fixed_BrFastRSqrt32);
RUN_TEST(test_fixed_BrFastRSqrt64);
RUN_TEST(test_fixed_BrFixedRLength2);
RUN_TEST(test_fixed_BrFixedRLength3);
RUN_TEST(test_fixed_BrFixedRLength4);
}

1
test/BRSRC13/test_matrix23.c
View File

@ -401,6 +401,7 @@ void test_matrix23_BrMatrix23PostShearY() {
}
void test_matrix23_suite() {
UnitySetTestFile(__FILE__);
RUN_TEST(test_matrix23_BrMatrix23Copy);
RUN_TEST(test_matrix23_BrMatrix23Identity);
RUN_TEST(test_matrix23_BrMatrix23Rotate);

1
test/BRSRC13/test_matrix34.c
View File

@ -547,6 +547,7 @@ static void test_matrix34_BrMatrix34PostRotateZ() {
}
void test_matrix34_suite() {
UnitySetTestFile(__FILE__);
RUN_TEST(test_matrix34_BrMatrix34Copy);
RUN_TEST(test_matrix34_BrMatrix34Mul);
RUN_TEST(test_matrix34_BrMatrix34Identity);

1
test/BRSRC13/test_matrix4.c
View File

@ -321,6 +321,7 @@ void test_matrix4_BrMatrix4ShearZ() {
}
void test_matrix4_suite() {
UnitySetTestFile(__FILE__);
RUN_TEST(test_matrix4_BrMatrix4Copy);
RUN_TEST(test_matrix4_BrMatrix4Mul);
RUN_TEST(test_matrix4_BrMatrix4Identity);

1
test/BRSRC13/test_quat.c
View File

@ -357,6 +357,7 @@ static void test_quat_BrMatrix4ToQuat() {
}
void test_quat_suite() {
UnitySetTestFile(__FILE__);
RUN_TEST(test_quat_BrQuatMul);
RUN_TEST(test_quat_BrQuatNormalise);
RUN_TEST(test_quat_BrQuatInvert);

100
test/BRSRC13/test_scratch.c Normal file
View File

@ -0,0 +1,100 @@
#include "CORE/FW/scratch.h"
#include "CORE/FW/fwsetup.h"
#include "tests.h"
#include <stddef.h>
static void test_scratch_BrScratchAllocate_BrScratchFree_BrScratchInquire() {
void *block = NULL;
TEST_ASSERT_FALSE(fw.scratch_inuse);
block = BrScratchAllocate(0x100);
TEST_ASSERT_NOT_NULL(block);
TEST_ASSERT_TRUE(fw.scratch_inuse);
TEST_ASSERT_EQUAL(0x100, fw.scratch_last);
TEST_ASSERT_EQUAL(block, fw.scratch_ptr);
TEST_ASSERT_LESS_OR_EQUAL_size_t(0x100, BrScratchInquire());
BrScratchFree(block);
TEST_ASSERT_EQUAL(block, fw.scratch_ptr);
TEST_ASSERT_FALSE(fw.scratch_inuse);
}
static void test_scratch_BrScratchFree_NULL() {;
br_size_t scratch_size;
void *block = NULL;
TEST_ASSERT_FALSE(fw.scratch_inuse);
block = BrScratchAllocate(0x100);
TEST_ASSERT_TRUE(fw.scratch_inuse);
BrScratchFree(block);
block = NULL;
TEST_ASSERT_FALSE(fw.scratch_inuse);
}
static void test_scratch_BrScratchFlush() {;
br_size_t scratch_size;
void *block = NULL;
TEST_ASSERT_FALSE(fw.scratch_inuse);
block = BrScratchAllocate(0x100);
TEST_ASSERT_TRUE(fw.scratch_inuse);
TEST_ASSERT_EQUAL(block, fw.scratch_ptr);
BrScratchFree(block);
TEST_ASSERT_FALSE(fw.scratch_inuse);
TEST_ASSERT_EQUAL(block, fw.scratch_ptr);
BrScratchFlush();
TEST_ASSERT_FALSE(fw.scratch_inuse);
TEST_ASSERT_EQUAL(NULL, fw.scratch_ptr);
}
static void test_scratch_BrScratchSize() {
TEST_ASSERT_EQUAL(0x200, BrScratchStringSize());
}
static void test_scratch_BrScratchString() {
int i;
char *text1;
char *text2;
text1 = NULL;
text2 = NULL;
text1 = BrScratchString();
TEST_ASSERT_NOT_NULL(text1);
for (int i = 0; i < 0x200; i++) {
text1[i] = (char)i;
}
text2 = BrScratchString();
TEST_ASSERT_NOT_NULL(text2);
TEST_ASSERT_EQUAL(text1, text2);
for (int i = 0; i < 0x200; i++) {
TEST_ASSERT_EQUAL_UINT8(i, text2[i]);
}
}
void test_scratch_suite() {
UnitySetTestFile(__FILE__);
RUN_TEST(test_scratch_BrScratchAllocate_BrScratchFree_BrScratchInquire);
RUN_TEST(test_scratch_BrScratchFree_NULL);
RUN_TEST(test_scratch_BrScratchFlush);
RUN_TEST(test_scratch_BrScratchSize);
RUN_TEST(test_scratch_BrScratchString);
}

5
test/CMakeLists.txt
View File

@ -34,15 +34,20 @@ target_sources(dethrace_test PRIVATE
BRSRC13/test_actsupt.c
BRSRC13/test_brlists.c
BRSRC13/test_datafile.c
BRSRC13/test_fixed.c
BRSRC13/test_fwsetup.c
BRSRC13/test_genclip.c
BRSRC13/test_pattern.c
BRSRC13/test_pmfile.c
BRSRC13/test_quat.c
BRSRC13/test_matrix23.c
BRSRC13/test_matrix34.c
BRSRC13/test_matrix4.c
BRSRC13/test_register.c
BRSRC13/test_regsupt.c
BRSRC13/test_resource.c
BRSRC13/test_resreg.c
BRSRC13/test_scratch.c
BRSRC13/test_v1dbfile.c
DETHRACE/test_controls.c
DETHRACE/test_dossys.c

78
test/main.c
View File

@ -1,3 +1,4 @@
#include "tests.h"
#include "harness/hooks.h"
#include <assert.h>
#include <stdio.h>
@ -43,8 +44,13 @@ extern void test_genclip_suite();
extern void test_datafile_suite();
extern void test_v1dbfile_suite();
extern void test_register_suite();
extern void test_scratch_suite();
extern void test_pattern_suite();
extern void test_pmfile_suite();
extern void test_fixed_suite();
extern void test_matrix23_suite();
extern void test_matrix34_suite();
extern void test_matrix4_suite();
extern void test_quat_suite();
extern void test_graphics_suite();
extern void test_regsupt_suite();
@ -60,6 +66,24 @@ void setUp(void) {
void tearDown(void) {
}
static const char *temp_folder;
static char temp_folder_buffer[PATH_MAX+1];
static void setup_temp_folder() {
#ifdef _WIN32
DWORD res;
char tmpBuffer[PATH_MAX+1];
res = GetTempPathA(sizeof(tmpBuffer), tmpBuffer);
if (res == 0) {
abort();
}
sprintf(temp_folder_buffer, "%s\\dethrace_test_%d", tmpBuffer, GetCurrentProcessId());
#else
sprintf(temp_folder_buffer, "/tmp/dethrace_test_%d", getpid());
#endif
temp_folder = temp_folder_buffer;
}
void setup_global_vars() {
strcpy(gDir_separator, "/");
@ -88,6 +112,9 @@ void setup_global_vars() {
strcpy(gBasic_car_names[0], "BLKEAGLE.TXT");
setup_temp_folder();
printf("INFO: temp folder is \"%s\"\n", temp_folder);
_unittest_do_not_exit = 1;
harness_debug_level = 7;
harness_game_info.mode = eGame_carmageddon;
@ -111,6 +138,49 @@ void sleep_s(int sec) {
#endif
}
void create_temp_file(char buffer[PATH_MAX+1], const char *prefix) {
#ifdef _WIN32
DWORD attributes;
UINT res;
BOOL success;
attributes = GetFileAttributesA(temp_folder);
if ((attributes == INVALID_FILE_ATTRIBUTES) || ((attributes & FILE_ATTRIBUTE_DIRECTORY) == 0)) {
LOG_TRACE("Temporary folder does not exist => creating");
success = CreateDirectoryA(temp_folder, NULL);
if (success == 0) {
abort();
}
}
res = GetTempFileNameA(temp_folder, prefix, 0, buffer);
if (res == 0) {
abort();
}
strcat(buffer, prefix);
#else
int fdres;
struct stat sb;
int res;
stat(temp_folder, &sb);
if (!S_ISDIR(sb.st_mode)) {
res = mkdir(temp_folder, 0770);
if (res == -1) {
abort();
}
}
strcpy(buffer, temp_folder);
strcat(buffer, "/");
strcat(buffer, prefix);
strcat(buffer, "XXXXXX");
fdres = mkstemp(buffer);
if (fdres == -1) {
abort();
}
close(fdres);
#endif
}
int main(int argc, char** argv) {
UNITY_BEGIN();
@ -124,6 +194,11 @@ int main(int argc, char** argv) {
printf("Completed setup\n");
// BRSRC13
test_matrix23_suite();
test_matrix34_suite();
test_matrix4_suite();
test_quat_suite();
test_brlists_suite();
test_fwsetup_suite();
test_resource_suite();
@ -134,9 +209,10 @@ int main(int argc, char** argv) {
test_pattern_suite();
test_pmfile_suite();
test_quat_suite();
test_fixed_suite();
test_v1dbfile_suite();
test_regsupt_suite();
test_scratch_suite();
// DETHRACE
test_utility_suite();

10
test/tests.h
View File

@ -4,19 +4,25 @@
#include "framework/unity.h"
#include "harness/trace.h"
#ifndef PATH_MAX
#define PATH_MAX 300
#endif
#define HOST_NL "\n"
extern int has_data_directory();
extern void sleep_s(int sec);
void create_temp_file(char buffer[PATH_MAX+1], const char *prefix);
#define REQUIRES_DATA_DIRECTORY() \
if (!has_data_directory()) \
TEST_IGNORE();
#define TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements) { \
#define TEST_ASSERT_FLOAT_ARRAY_WITHIN(delta, expected, actual, num_elements) do { \
float *priv_expected = (float*)(expected); \
float *priv_actual = (float*)(actual); \
for(int it = (num_elements); it != 0; --it, ++priv_expected, ++priv_actual) { \
TEST_ASSERT_FLOAT_WITHIN((delta), *priv_expected, *priv_actual); \
} \
}
} while (0)
#endif