diff --git a/config/GMPE01_00/rels/m427Dll/symbols.txt b/config/GMPE01_00/rels/m427Dll/symbols.txt index bc2a2d73..d075d6af 100644 --- a/config/GMPE01_00/rels/m427Dll/symbols.txt +++ b/config/GMPE01_00/rels/m427Dll/symbols.txt @@ -370,13 +370,14 @@ lbl_1_data_203 = .data:0x00000203; // type:object size:0x10 data:string lbl_1_data_213 = .data:0x00000213; // type:object size:0x26 data:string lbl_1_data_239 = .data:0x00000239; // type:object size:0x25 lbl_1_data_260 = .data:0x00000260; // type:object size:0x15C -lbl_1_data_3BC = .data:0x000003BC; // type:object size:0x178 +lbl_1_data_3BC = .data:0x000003BC; // type:object size:0x15C +lbl_1_data_518 = .data:0x00000518; // type:object size:0x1C lbl_1_data_534 = .data:0x00000534; // type:object size:0x18 lbl_1_data_54C = .data:0x0000054C; // type:object size:0x18 data:float lbl_1_data_564 = .data:0x00000564; // type:object size:0xC data:float lbl_1_data_570 = .data:0x00000570; // type:object size:0xC data:float lbl_1_data_57C = .data:0x0000057C; // type:object size:0x4 -lbl_1_data_580 = .data:0x00000580; // type:object size:0xE data:string +lbl_1_data_580 = .data:0x00000580; // type:object size:0xE scope:local data:string lbl_1_data_590 = .data:0x00000590; // type:object size:0x1C lbl_1_data_5AC = .data:0x000005AC; // type:object size:0x1C lbl_1_data_5C8 = .data:0x000005C8; // type:object size:0x8 diff --git a/config/GMPE01_00/symbols.txt b/config/GMPE01_00/symbols.txt index e2763245..d4d7595a 100644 --- a/config/GMPE01_00/symbols.txt +++ b/config/GMPE01_00/symbols.txt @@ -3653,7 +3653,7 @@ lbl_8011E580 = .rodata:0x8011E580; // type:object size:0x20 lbl_8011E5A0 = .rodata:0x8011E5A0; // type:object size:0x38 lbl_8011E5D8 = .rodata:0x8011E5D8; // type:object size:0x40 fix_pool_sizes = .rodata:0x8011E618; // type:object size:0x18 scope:local data:4byte -lbl_8011E630 = .rodata:0x8011E630; // type:object size:0xE0 +lbl_8011E630 = .rodata:0x8011E630; // type:object size:0xE0 data:string @stringBase0 = .rodata:0x8011E710; // type:object size:0x25 scope:local data:string_table Zero = .rodata:0x8011E738; // type:object size:0x10 scope:local bp = .rodata:0x8011E748; // type:object size:0x10 scope:local data:double diff --git a/configure.py b/configure.py index 613dd441..ccea1eaa 100644 --- a/configure.py +++ b/configure.py @@ -227,6 +227,7 @@ cflags_thp = [ # Metrowerks library flags cflags_msl = [ *cflags_base, + "-char signed", "-use_lmw_stmw on", "-str reuse,pool,readonly", "-common off", @@ -676,47 +677,47 @@ config.libs = [ }, { "lib": "MSL_C.PPCEABI.bare.H", - "mw_version": config.linker_version, + "mw_version": "GC/1.3", "cflags": cflags_msl, "host": False, "objects": [ Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/abort_exit.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/alloc.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/alloc.c"), Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/errno.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/ansi_files.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/ansi_fp.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/arith.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/buffer_io.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/ansi_files.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/ansi_fp.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/arith.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/buffer_io.c"), Object(NonMatching, "MSL_C.PPCEABI.bare.H/ctype.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/direct_io.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/file_io.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/FILE_POS.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/mbstring.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/direct_io.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/file_io.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/FILE_POS.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/mbstring.c"), Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/mem.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/mem_funcs.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/misc_io.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/mem_funcs.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/misc_io.c"), Object(NonMatching, "MSL_C.PPCEABI.bare.H/printf.c"), Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/float.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/signal.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/string.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/uart_console_io.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/wchar_io.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/signal.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/string.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/uart_console_io.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/wchar_io.c"), Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/e_acos.c"), Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/e_asin.c"), Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/e_atan2.c"), Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/e_fmod.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/e_pow.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/e_rem_pio2.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/k_cos.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/k_rem_pio2.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/k_sin.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/k_tan.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/s_atan.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/e_pow.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/e_rem_pio2.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/k_cos.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/k_rem_pio2.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/k_sin.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/k_tan.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/s_atan.c"), Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/s_copysign.c"), Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/s_cos.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/s_floor.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/s_floor.c"), Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/s_frexp.c"), - Object(NonMatching, "MSL_C.PPCEABI.bare.H/s_ldexp.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/s_ldexp.c"), Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/s_modf.c"), Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/s_sin.c"), Object(MatchingFor("GMPE01_00", "GMPE01_01"), "MSL_C.PPCEABI.bare.H/s_tan.c"), @@ -1080,7 +1081,7 @@ config.libs = [ objects={ Object(MatchingFor("GMPE01_00", "GMPE01_01"), "REL/m427Dll/main.c"), Object(NonMatching, "REL/m427Dll/map.c"), - Object(NonMatching, "REL/m427Dll/player.c"), + Object(MatchingFor("GMPE01_00", "GMPE01_01"), "REL/m427Dll/player.c"), }, ), Rel( diff --git a/include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_files.h b/include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_files.h index f06c55df..a1fb6fdc 100644 --- a/include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_files.h +++ b/include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_files.h @@ -85,6 +85,7 @@ typedef struct _FILE { file_modes file_mode; file_states file_state; + unsigned char is_dynamically_allocated; char char_buffer; char char_buffer_overflow; char ungetc_buffer[2]; @@ -104,19 +105,14 @@ typedef struct _FILE { __io_proc write_fn; __close_proc close_fn; __idle_proc idle_fn; + struct _FILE* next_file_struct; } FILE; -typedef struct _files { - FILE _stdin; - FILE _stdout; - FILE _stderr; -} files; - #define _IONBF 0 #define _IOLBF 1 #define _IOFBF 2 -extern files __files; +extern FILE __files[]; extern int __close_console(__file_handle file); extern int __write_console(__file_handle file, unsigned char* buf, size_t* count, __idle_proc idle_fn); diff --git a/include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_fp.h b/include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_fp.h index 90ba7acf..a7a5cc67 100644 --- a/include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_fp.h +++ b/include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_fp.h @@ -22,15 +22,6 @@ typedef struct decform { short digits; } decform; -/* void __ull2dec(decimal*, u64); -void __timesdec(decimal*, const decimal*, const decimal*); -void __str2dec(decimal*, const char*, short); -void __two_exp(decimal*, s16); -BOOL __equals_dec(const decimal*, const decimal*); -BOOL __less_dec(const decimal*, const decimal*); -void __minus_dec(decimal*, const decimal*, const decimal*); -void __num2dec_internal(decimal*, f64); -void __num2dec(const decform*, f64, decimal*); -f64 __dec2num(const decimal*); */ +void __num2dec(const decform* form, double x, decimal* d); #endif diff --git a/include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/stdio.h b/include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/stdio.h index 89806588..01097a0c 100644 --- a/include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/stdio.h +++ b/include/PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/stdio.h @@ -6,8 +6,8 @@ #include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/printf.h" // IWYU pragma: export #include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/extras.h" // IWYU pragma: export -#define stdin (&__files._stdin) -#define stdout (&__files._stdout) -#define stderr (&__files._stderr) +#define stdin (&__files[0]) +#define stdout (&__files[1]) +#define stderr (&__files[2]) #endif diff --git a/include/REL/m427Dll.h b/include/REL/m427Dll.h index cef5b491..1678efc2 100644 --- a/include/REL/m427Dll.h +++ b/include/REL/m427Dll.h @@ -1,8 +1,16 @@ #include "dolphin.h" #include "game/object.h" -void fn_1_32F4(Process*); +s32 fn_1_1788(void); +void fn_1_1798(s32 arg0, float arg8); +s32 fn_1_1884(void); +s32 fn_1_32EC(void); + +void fn_1_32F4(Process* arg0); +void fn_1_3B20(s8 arg0, s16 arg1); void fn_1_3A88(void); +void fn_1_91E0(s16 arg0, float arg8, float arg9, float argA, float argB); +float fn_1_AE78(s16 arg0, float arg8, float arg9); void fn_1_E98C(Process*); void fn_1_EC54(void); s32 fn_1_10FE8(s16, s32*); diff --git a/include/game/hsfanim.h b/include/game/hsfanim.h index 198a4fc6..32c9c4cc 100644 --- a/include/game/hsfanim.h +++ b/include/game/hsfanim.h @@ -11,10 +11,7 @@ typedef struct particle_data ParticleData; typedef void (*ParticleHook)(ModelData *model, ParticleData *particle, Mtx matrix); typedef struct { - /* 0x00 */ union { - u16 unk00; - s16 unk00_s16; - }; + /* 0x00 */ s16 unk00; /* 0x02 */ s16 unk02; /* 0x04 */ s16 unk04; /* 0x06 */ s16 unk06; diff --git a/include/game/hsfdraw.h b/include/game/hsfdraw.h index 94b16a6b..d3b46df6 100755 --- a/include/game/hsfdraw.h +++ b/include/game/hsfdraw.h @@ -6,7 +6,7 @@ typedef struct model_data ModelData; -typedef struct { +typedef struct hsfdraw_struct_01 { /* 0x00 */ u16 unk00; /* 0x02 */ s16 unk02; /* 0x04 */ s16 unk04; diff --git a/include/game/hsfformat.h b/include/game/hsfformat.h index 04f3d458..36c083a9 100644 --- a/include/game/hsfformat.h +++ b/include/game/hsfformat.h @@ -99,7 +99,7 @@ typedef struct hsf_palette { typedef struct hsf_attribute { char *name; - void *unk04; + struct hsfdraw_struct_01 *unk04; u8 unk8[4]; float unk0C; u8 unk10[4]; diff --git a/include/string.h b/include/string.h index 6ba311ed..863a4f97 100644 --- a/include/string.h +++ b/include/string.h @@ -10,7 +10,7 @@ char* strrchr(const char* str, int c); char* strchr(const char* str, int c); int strncmp(const char* str1, const char* str2, size_t n); int strcmp(const char* str1, const char* str2); -char* strcat(char* dst, const char* src); +char* strcat(char* dst, const char* src, size_t n); char* strncpy(char* dst, const char* src, size_t n); char* strcpy(char* dst, const char* src); size_t strlen(const char* str); diff --git a/src/MSL_C.PPCEABI.bare.H/FILE_POS.c b/src/MSL_C.PPCEABI.bare.H/FILE_POS.c new file mode 100755 index 00000000..f0b5e933 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/FILE_POS.c @@ -0,0 +1,97 @@ +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_files.h" +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/errno.h" + +inline fpos_t _ftell(FILE* file) { + int charsInUndoBuffer = 0; + fpos_t position; + unsigned char tmp_kind = file->file_mode.file_kind; + + if (!(tmp_kind == __disk_file || tmp_kind == __console_file) || file->file_state.error) { + errno = EFPOS; + return -1; + } + + if (file->file_state.io_state == __neutral) + return (file->position); + + position = file->buffer_position + (file->buffer_ptr - file->buffer); + + if (file->file_state.io_state >= __rereading) { + charsInUndoBuffer = file->file_state.io_state - __rereading + 1; + position -= charsInUndoBuffer; + } + + return (position); +} + +long ftell(FILE* file) { + long retval; + + retval = (long)_ftell(file); + + return retval; +} + +int _fseek(FILE* file, fpos_t offset, int file_mode) { + fpos_t position; + __pos_proc pos_proc; + unsigned char tmp_kind = file->file_mode.file_kind; + + if (!(tmp_kind == __disk_file) || file->file_state.error) { + errno = EFPOS; + return (-1); + } + + if (file->file_state.io_state == __writing) { + if (__flush_buffer(file, NULL) != __no_io_error) { + set_error(file); + errno = EFPOS; + return (-1); + } + } + + if (file_mode == SEEK_CUR) { + file_mode = SEEK_SET; + if ((position = _ftell(file)) < 0) + position = 0; + offset += position; + } + + if ((file_mode != SEEK_END) && (file->file_mode.io_mode != __read_write) && + ((file->file_state.io_state == __reading) || (file->file_state.io_state == __rereading))) + { + if (offset >= file->position || offset < file->buffer_position) { + file->file_state.io_state = __neutral; + } else { + file->buffer_ptr = file->buffer + (offset - file->buffer_position); + file->buffer_length = file->position - offset; + file->file_state.io_state = __reading; + } + } else { + file->file_state.io_state = __neutral; + } + + if (file->file_state.io_state == __neutral) { + if ((pos_proc = file->position_fn) != NULL && pos_proc(file->handle, &offset, file_mode, file->idle_fn)) { + set_error(file); + errno = EFPOS; + return -1; + } + + file->file_state.eof = 0; + file->position = offset; + file->buffer_length = 0; + } + + return 0; +} + +int fseek(FILE * file, long offset, int file_mode) +{ + fpos_t real_offset = (fpos_t)offset; + int retval; + + retval = _fseek(file, real_offset, file_mode); + + return(retval); +} diff --git a/src/MSL_C.PPCEABI.bare.H/alloc.c b/src/MSL_C.PPCEABI.bare.H/alloc.c new file mode 100755 index 00000000..ba041356 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/alloc.c @@ -0,0 +1,410 @@ +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/alloc.h" + +typedef struct Block { + struct Block* prev; + struct Block* next; + unsigned long max_size; + unsigned long size; +} Block; + +typedef struct SubBlock { + unsigned long size; + Block* block; + struct SubBlock* prev; + struct SubBlock* next; +} SubBlock; + +struct FixSubBlock; + +typedef struct FixBlock { + struct FixBlock* prev_; + struct FixBlock* next_; + unsigned long client_size_; + struct FixSubBlock* start_; + unsigned long n_allocated_; +} FixBlock; + +typedef struct FixSubBlock { + FixBlock* block_; + struct FixSubBlock* next_; +} FixSubBlock; + +typedef struct FixStart { + FixBlock* tail_; + FixBlock* head_; +} FixStart; + +typedef struct __mem_pool_obj { + Block* start_; + FixStart fix_start[6]; +} __mem_pool_obj; + +typedef struct __mem_pool { + void* reserved[14]; +} __mem_pool; + +typedef signed long tag_word; + +typedef struct block_header { + tag_word tag; + struct block_header * prev; + struct block_header * next; +} block_header; + +typedef struct list_header { + block_header * rover; + block_header header; +} list_header; + +typedef struct heap_header { + struct heap_header* prev; + struct heap_header* next; +} heap_header; + +struct mem_pool_obj; +typedef void * (*sys_alloc_ptr)(unsigned long, struct mem_pool_obj*); +typedef void (*sys_free_ptr)(void *, struct mem_pool_obj*); + +typedef struct pool_options{ + sys_alloc_ptr sys_alloc_func; + sys_free_ptr sys_free_func; + unsigned long min_heap_size; + int always_search_first; +} pool_options; + +typedef struct mem_pool_obj { + list_header free_list; + pool_options options; + heap_header* heap_list; + void* userData; + +} mem_pool_obj; + +mem_pool_obj __malloc_pool; +static int initialized = 0; + +static SubBlock* SubBlock_merge_prev(SubBlock*, SubBlock**); +static void SubBlock_merge_next(SubBlock* , SubBlock** ); + +static const unsigned long fix_pool_sizes[] = {4, 12, 20, 36, 52, 68}; + +#define SubBlock_size(ths) ((ths)->size & 0xFFFFFFF8) +#define SubBlock_block(ths) ((Block*)((unsigned long)((ths)->block) & ~0x1)) +#define Block_size(ths) ((ths)->size & 0xFFFFFFF8) +#define Block_start(ths) (*(SubBlock**)((char*)(ths) + Block_size((ths)) - sizeof(unsigned long))) + +#define SubBlock_set_free(ths) \ + unsigned long this_size = SubBlock_size((ths)); \ + (ths)->size &= ~0x2; \ + *(unsigned long*)((char*)(ths) + this_size) &= ~0x4; \ + *(unsigned long*)((char*)(ths) + this_size - sizeof(unsigned long)) = this_size + + +#define SubBlock_is_free(ths) !((ths)->size & 2) +#define SubBlock_set_size(ths, sz) \ + (ths)->size &= ~0xFFFFFFF8; \ + (ths)->size |= (sz) & 0xFFFFFFF8; \ + if (SubBlock_is_free((ths))) \ + *(unsigned long*)((char*)(ths) + (sz) - sizeof(unsigned long)) = (sz) + +#define SubBlock_from_pointer(ptr) ((SubBlock*)((char*)(ptr) - 8)) +#define FixSubBlock_from_pointer(ptr) ((FixSubBlock*)((char*)(ptr) - 4)) + +#define FixBlock_client_size(ths) ((ths)->client_size_) +#define FixSubBlock_size(ths) (FixBlock_client_size((ths)->block_)) + +#define classify(ptr) (*(unsigned long*)((char*)(ptr) - sizeof(unsigned long)) & 1) +#define __msize_inline(ptr) (!classify(ptr) ? FixSubBlock_size(FixSubBlock_from_pointer(ptr)) : SubBlock_size(SubBlock_from_pointer(ptr)) - 8) + +#define Block_empty(ths) \ + (_sb = (SubBlock*)((char*)(ths) + 16)), \ + SubBlock_is_free(_sb) && SubBlock_size(_sb) == Block_size((ths)) - 24 + +//unused +void Block_subBlock(){ +} + +void Block_link(Block* ths, SubBlock* sb) { + SubBlock** st; + SubBlock_set_free(sb); + st = &Block_start(ths); + + if (*st != 0) + { + sb->prev = (*st)->prev; + sb->prev->next = sb; + sb->next = *st; + (*st)->prev = sb; + *st = sb; + *st = SubBlock_merge_prev(*st, st); + SubBlock_merge_next(*st, st); + } + else + { + *st = sb; + sb->prev = sb; + sb->next = sb; + } + if (ths->max_size < SubBlock_size(*st)) + ths->max_size = SubBlock_size(*st); +} + +static SubBlock* SubBlock_merge_prev(SubBlock *ths, SubBlock **start) { + unsigned long prevsz; + SubBlock* p; + + if (!(ths->size & 0x04)) + { + prevsz = *(unsigned long*)((char*)ths - sizeof(unsigned long)); + if (prevsz & 0x2) + return ths; + p = (SubBlock*)((char*)ths - prevsz); + SubBlock_set_size(p, prevsz + SubBlock_size(ths)); + + if (*start == ths) + *start = (*start)->next; + ths->next->prev = ths->prev; + ths->next->prev->next = ths->next; + return p; + } + return ths; +} + + +static void SubBlock_merge_next(SubBlock *pBlock, SubBlock **pStart) { + SubBlock* next_sub_block; + unsigned long this_cur_size; + + next_sub_block = (SubBlock*)((char*)pBlock + (pBlock->size & 0xFFFFFFF8)); + + if (!(next_sub_block->size & 2)) { + this_cur_size = (pBlock->size & 0xFFFFFFF8) + (next_sub_block->size & 0xFFFFFFF8); + + pBlock->size &= ~0xFFFFFFF8; + pBlock->size |= this_cur_size & 0xFFFFFFF8; + + if (!(pBlock->size & 2)) { + *(unsigned long*)((char*)(pBlock) + (this_cur_size) - 4) = (this_cur_size); + } + + if (!(pBlock->size & 2)) { + *(unsigned long *)((char*)pBlock + this_cur_size) &= ~4; + } + else { + *(unsigned long *)((char*)pBlock + this_cur_size) |= 4; + } + + if (*pStart == next_sub_block) { + *pStart = (*pStart)->next; + } + + if (*pStart == next_sub_block) { + *pStart = 0; + } + + next_sub_block->next->prev = next_sub_block->prev; + next_sub_block->prev->next = next_sub_block->next; + } +} + +static Block* __unlink(__mem_pool_obj* pool_obj, Block* bp) { + Block* result = bp->next; + if (result == bp) { + result = 0; + } + + if (pool_obj->start_ == bp) { + pool_obj->start_ = result; + } + + if (result != 0) { + result->prev = bp->prev; + result->prev->next = result; + } + + bp->next = 0; + bp->prev = 0; + return result; +} + +//unused +void allocate_from_var_pools(){ +} + +//unused +void soft_allocate_from_var_pools(){ +} + +static void deallocate_from_var_pools(__mem_pool_obj* pool_obj, void *ptr) { + SubBlock* sb = SubBlock_from_pointer(ptr); + SubBlock* _sb; + + Block* bp = SubBlock_block(sb); + Block_link(bp, sb); + + if (Block_empty(bp)) { + __unlink(pool_obj, bp); + __sys_free(bp); + } +} + +//unused +void FixBlock_construct(){ +} + +void __init_pool_obj(__mem_pool* pool_obj) { + memset(pool_obj, 0, sizeof(__mem_pool_obj)); +} + + +static __mem_pool* get_malloc_pool(void) { + static __mem_pool protopool; + static unsigned char init = 0; + if (!init) { + __init_pool_obj(&protopool); + init = 1; + } + + return &protopool; +} + +//unused +void allocate_from_fixed_pools(){ +} + +void deallocate_from_fixed_pools(__mem_pool_obj* pool_obj, void* ptr, unsigned long size) { + unsigned long i = 0; + FixSubBlock* p; + FixBlock* b; + FixStart* fs; + + while (size > fix_pool_sizes[i]) { + ++i; + } + + fs = &pool_obj->fix_start[i]; + p = FixSubBlock_from_pointer(ptr); + b = p->block_; + + if (b->start_ == 0 && fs->head_ != b) { + if (fs->tail_ == b) { + fs->head_ = fs->head_->prev_; + fs->tail_ = fs->tail_->prev_; + } + else { + b->prev_->next_ = b->next_; + b->next_->prev_ = b->prev_; + b->next_ = fs->head_; + b->prev_ = b->next_->prev_; + b->prev_->next_ = b; + b->next_->prev_ = b; + fs->head_ = b; + } + } + + p->next_ = b->start_; + b->start_ = p; + + if (--b->n_allocated_ == 0) { + if (fs->head_ == b) { + fs->head_ = b->next_; + } + + if (fs->tail_ == b) { + fs->tail_ = b->prev_; + } + + b->prev_->next_ = b->next_; + b->next_->prev_ = b->prev_; + + if (fs->head_ == b) { + fs->head_ = 0; + } + + if (fs->tail_ == b) { + fs->tail_ = 0; + } + + deallocate_from_var_pools(pool_obj, b); + } +} + +//unused +void __pool_allocate_resize(){ +} + +//unused +void __msize(){ +} + +//unused +void __pool_alloc(){ +} + +//unused +void __allocate_size(){ +} + +//unused +void __allocate(){ +} + +//unused +void __allocate_resize(){ +} + +//unused +void __allocate_expand(){ +} + +void __pool_free(__mem_pool *pool, void *ptr) { + __mem_pool_obj* pool_obj; + unsigned long size; + + if (ptr == 0) { + return; + } + + pool_obj = (__mem_pool_obj*)pool; + size = __msize_inline(ptr); + + if (size <= 68) { + deallocate_from_fixed_pools(pool_obj, ptr, size); + } + else { + deallocate_from_var_pools(pool_obj, ptr); + } +} + +//unused +void __pool_realloc(){ +} + +//unused +void __pool_alloc_clear(){ +} + +//unused +void malloc(){ +} + +void free(void *ptr) { + __pool_free(get_malloc_pool(), ptr); +} + + +//unused +void realloc(){ +} + +//unused +void calloc(){ +} + +//unused +void __pool_free_all(){ +} + +//unused +void __malloc_free_all(){ +} diff --git a/src/MSL_C.PPCEABI.bare.H/ansi_files.c b/src/MSL_C.PPCEABI.bare.H/ansi_files.c index f0113bf4..76ffbe61 100644 --- a/src/MSL_C.PPCEABI.bare.H/ansi_files.c +++ b/src/MSL_C.PPCEABI.bare.H/ansi_files.c @@ -1,95 +1,111 @@ #include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_files.h" #include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/file_io.h" -extern files __files = { - { - 0, - 0, - 1, - 0, - 2, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - { 0, 0 }, - { 0, 0 }, - 0, - (unsigned char*)&__files._stdin.char_buffer, - 1, - (unsigned char*)&__files._stdin.char_buffer, - 0, - 0, - 0, - 0, - NULL, - __read_console, - __write_console, - __close_console, - NULL, - }, - { - 0, - 0, - 2, - 0, - 2, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - { 0, 0 }, - { 0, 0 }, - 0, - (unsigned char*)&__files._stdout.char_buffer, - 1, - (unsigned char*)&__files._stdout.char_buffer, - 0, - 0, - 0, - 0, - NULL, - __read_console, - __write_console, - __close_console, - NULL, - }, - { - 0, - 0, - 2, - 0, - 2, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - { 0, 0 }, - { 0, 0 }, - 0, - (unsigned char*)&__files._stderr.char_buffer, - 1, - (unsigned char*)&__files._stderr.char_buffer, - 0, - 0, - 0, - 0, - NULL, - __read_console, - __write_console, - __close_console, - NULL, - }, +static unsigned char stdin_buff[0x100]; +static unsigned char stdout_buff[0x100]; +static unsigned char stderr_buff[0x100]; + +FILE __files[4] = { + {0, + {0, 1, 1, 2, 0}, + {0, 0, 0, 0}, + 0, + 0, + 0, + {0, 0}, + {0, 0}, + 0, + stdin_buff, + sizeof(stdin_buff), + stdin_buff, + 0, + 0, + 0, + 0, + NULL, + &__read_console, + &__write_console, + &__close_console, + 0, + &__files[1]}, + {1, + {0, 2, 1, 2, 0}, + {0, 0, 0, 0}, + 0, + 0, + 0, + {0, 0}, + {0, 0}, + 0, + stdout_buff, + sizeof(stdout_buff), + stdout_buff, + 0, + 0, + 0, + 0, + NULL, + &__read_console, + &__write_console, + &__close_console, + 0, + &__files[2]}, + {2, + {0, 2, 0, 2, 0}, + {0, 0, 0, 0}, + 0, + 0, + 0, + {0, 0}, + {0, 0}, + 0, + stderr_buff, + sizeof(stderr_buff), + stderr_buff, + 0, + 0, + 0, + 0, + NULL, + &__read_console, + &__write_console, + &__close_console, + 0, + &__files[3]}, }; + +void __close_all() { + FILE* p = &__files[0]; + FILE* plast; + + while (p != NULL) { + if (p->file_mode.file_kind != __closed_file) { + fclose(p); + } + + plast = p; + p = p->next_file_struct; + if (plast->is_dynamically_allocated) + free(plast); + else { + plast->file_mode.file_kind = __string_file; + if ((p != NULL) && p->is_dynamically_allocated) + plast->next_file_struct = NULL; + } + } +} + +unsigned int __flush_all() { + unsigned int retval = 0; + FILE* __stream; + + __stream = &__files[0]; + while (__stream) { + if ((__stream->file_mode.file_kind) && (fflush(__stream))) { + retval = -1; + } + __stream = __stream->next_file_struct; + }; + + return retval; +} diff --git a/src/MSL_C.PPCEABI.bare.H/ansi_fp.c b/src/MSL_C.PPCEABI.bare.H/ansi_fp.c new file mode 100755 index 00000000..e8d7f0c7 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/ansi_fp.c @@ -0,0 +1,393 @@ +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_fp.h" + +static int __count_trailing_zerol(unsigned int arg0) { + int var_r4; + int var_r5; + int var_r6; + int var_r7; + unsigned int var_r8; + + var_r5 = 0x20; + var_r8 = 0xFFFF; + var_r6 = 0x10; + var_r4 = 0; + var_r7 = 0x10; + while (var_r5 != 0) { + if (!(arg0 & var_r8)) { + var_r4 += var_r7; + arg0 >>= var_r7; + var_r5 -= var_r7; + } else if (var_r8 == 1) { + break; + } + if (var_r6 > 1) { + var_r6 /= 2; + } + if (var_r8 > 1) { + var_r8 >>= var_r6; + var_r7 -= var_r6; + } + } + return var_r4; +} + +static inline int __count_trailing_zero(double n){ + if (__LO(n) != 0U) { + return __count_trailing_zerol(__LO(n)); + } else { + return 32 + __count_trailing_zerol(__HI(n) | 0x100000); + } +} + +static void __ull2dec(decimal* result, unsigned long long val) { + result->sign = 0; + + if (val == 0) { + result->exp = 0; + result->sig.length = 1; + result->sig.text[0] = 0; + return; + } + + result->sig.length = 0; + + for(; val != 0; val /= 10) { + result->sig.text[result->sig.length++] = val % 10; + } + + { + unsigned char* i = result->sig.text; + unsigned char* j = result->sig.text + result->sig.length; + + for (; i < --j; ++i) { + unsigned char t = *i; + *i = *j; + *j = t; + } + } + + result->exp = result->sig.length - 1; +} + +static inline void __dorounddecup(decimal* d, int digits){ + unsigned char* b = d->sig.text; + unsigned char* i = b + digits - 1; + + while(1){ + if (*i < 9) { + *i += 1; + break; + } + if (i == b) { + *i = 1; + d->exp++; + break; + } + *i-- = 0; + } +} + +static void __timesdec(decimal* result, const decimal* x, const decimal* y) { + unsigned int accumulator = 0; + unsigned char mantissa[SIGDIGLEN * 2]; + int i = x->sig.length + y->sig.length - 1; + unsigned char* pDigit; + unsigned char* ip = mantissa + i + 1; + unsigned char* ep = ip; + + result->sign = 0; + + for(; i > 0; i--) { + int k = y->sig.length - 1; + int j = i - k - 1; + int l; + int t; + const unsigned char* jp; + const unsigned char* kp; + + if (j < 0) { + j = 0; + k = i - 1; + } + + jp = x->sig.text + j; + kp = y->sig.text + k; + l = k + 1; + t = x->sig.length - j; + + if (l > t) l = t; + + for (; l > 0; l--, jp++, kp--) { + accumulator += *jp * *kp; + } + + *--ip = accumulator % 10; + accumulator /= 10; + } + + result->exp = (short)(x->exp + y->exp); + + if (accumulator) { + *--ip = accumulator; + result->exp++; + } + + for (i = 0; i < SIGDIGLEN && ip < ep; i++, ip++) { + result->sig.text[i] = *ip; + } + result->sig.length = i; + + if (ip < ep && *ip >= 5){ + if (*ip == 5){ + unsigned char* jp = ip + 1; + for (; jp < ep; jp++) { + if (*jp != 0) goto round; + } + if ((ip[-1] & 1) == 0) return; + } + round: + __dorounddecup(result, result->sig.length); + } +} + +static void __str2dec(decimal* d, const signed char* s, short exp) { + int i; + + d->exp = exp; + d->sign = 0; + + for (i = 0; i < SIGDIGLEN && *s; ) { + d->sig.text[i++] = *s++ - '0'; + } + d->sig.length = i; + + if (*s != 0 && *s >= 5) { + const signed char* p = s + 1; + + for (; *p != 0; p++) { + if (*p != '0') goto round; + } + + if ((d->sig.text[i - 1] & 1) == 0) return; + round: + __dorounddecup(d, d->sig.length); + } +} + +// TODO: ideally, these strings should be used as literals in the function below. +// However, the first one (179769313486231580793729011405303420, corresponding to +// 2^1024) is not used in the function and messes up alignment. + +const signed char lbl_8011E630[] = + "179769313486231580793729011405303420\000" \ + "542101086242752217003726400434970855712890625\000" \ + "11102230246251565404236316680908203125\000" \ + "23283064365386962890625\000" \ + "152587890625\000" \ + "390625\000" \ + "78125\000" \ + "15625\000" \ + "3125\000" \ + "625\000" \ + "125\000" \ + "25\000" \ + "5\000" \ + "1\000" \ + "2\000" \ + "4\000" \ + "8\000" \ + "16\000" \ + "32\000" \ + "64\000" \ + "128\000" \ + "256"; + +static void __two_exp(decimal* result, short exp) { + decimal sp8C; + decimal sp60; + decimal sp34; + decimal sp8; + + switch (exp) { + case -64: + __str2dec(result, lbl_8011E630 + 0x25, -20); + break; + case -53: + __str2dec(result, lbl_8011E630 + 0x53, -16); + break; + case -32: + __str2dec(result, lbl_8011E630 + 0x7A, -10); + break; + case -16: + __str2dec(result, lbl_8011E630 + 0x92, -5); + break; + case -8: + __str2dec(result, lbl_8011E630 + 0x9F, -3); + break; + case -7: + __str2dec(result, lbl_8011E630 + 0xA6, -3); + break; + case -6: + __str2dec(result, lbl_8011E630 + 0xAC, -2); + break; + case -5: + __str2dec(result, lbl_8011E630 + 0xB2, -2); + break; + case -4: + __str2dec(result, lbl_8011E630 + 0xB7, -2); + break; + case -3: + __str2dec(result, lbl_8011E630 + 0xBB, -1); + break; + case -2: + __str2dec(result, lbl_8011E630 + 0xBF, -1); + break; + case -1: + __str2dec(result, lbl_8011E630 + 0xC2, -1); + break; + case 0: + __str2dec(result, lbl_8011E630 + 0xC4, 0); + break; + case 1: + __str2dec(result, lbl_8011E630 + 0xC6, 0); + break; + case 2: + __str2dec(result, lbl_8011E630 + 0xC8, 0); + break; + case 3: + __str2dec(result, lbl_8011E630 + 0xCA, 0); + break; + case 4: + __str2dec(result, lbl_8011E630 + 0xCC, 1); + break; + case 5: + __str2dec(result, lbl_8011E630 + 0xCF, 1); + break; + case 6: + __str2dec(result, lbl_8011E630 + 0xD2, 1); + break; + case 7: + __str2dec(result, lbl_8011E630 + 0xD5, 2); + break; + case 8: + __str2dec(result, lbl_8011E630 + 0xD9, 2); + break; + default: + __two_exp(&sp8C, exp / 2); + __timesdec(result, &sp8C, &sp8C); + if (exp & 1) { + sp60 = *result; + if (exp > 0) { + __str2dec(&sp34, lbl_8011E630 + 0xC6, 0); + __timesdec(result, &sp60, &sp34); + } else { + __str2dec(&sp8, lbl_8011E630 + 0xC2, -1); + __timesdec(result, &sp60, &sp8); + } + } + break; + } +} + +static void __num2dec_internal(decimal* d, double x) { + signed char sign = (signbit(x) != 0); + + if (x == 0) { + d->sign = sign; + d->exp = 0; + d->sig.length = 1; + d->sig.text[0] = 0; + return; + } + + if (!isfinite(x)) { + d->sign = sign; + d->exp = 0; + d->sig.length = 1; + d->sig.text[0] = (fpclassify(x) == 1) ? 'N' : 'I'; + return; + } + + if (sign != 0) { + x = -x; + } + + { + int exp; + double frac = frexp(x, &exp); + short num_bits_extract = DBL_MANT_DIG - __count_trailing_zero(frac); + decimal int_d, pow2_d; + double sp30; + + __two_exp(&pow2_d, exp - num_bits_extract); + modf(ldexp(frac, num_bits_extract), &sp30); + __ull2dec(&int_d, sp30); + __timesdec(d, &int_d, &pow2_d); + d->sign = sign; + } +} + +static inline int __must_round(const decimal* d, int digits){ + unsigned char const* i = d->sig.text + digits; + + if (*i > 5) { + return 1; + } + + if (*i < 5) { + return -1; + } + + { + unsigned char const* e = d->sig.text + d->sig.length; + + for(i++; i < e; i++){ + if (*i != 0) { + return 1; + } + } + } + + if (d->sig.text[digits - 1] & 1) { + return 1; + } + + return -1; +} + +static inline void __rounddec(decimal* d, int digits){ + if (digits > 0 && digits < d->sig.length) { + int unkBool = __must_round(d,digits); + d->sig.length = digits; + + if (unkBool >= 0) { + __dorounddecup(d, digits); + } + } +} + +void __num2dec(const decform* form, double x, decimal* d) { + short digits = form->digits; + int i; + __num2dec_internal(d, x); + + if (d->sig.text[0] > 9) { + return; + } + + if (digits > SIGDIGLEN) { + digits = SIGDIGLEN; + } + + __rounddec(d, digits); + + while(d->sig.length < digits){ + d->sig.text[d->sig.length++] = 0; + } + + d->exp -= d->sig.length - 1; + + for(i = 0; i < d->sig.length; i++) { + d->sig.text[i] += '0'; + } +} diff --git a/src/MSL_C.PPCEABI.bare.H/arith.c b/src/MSL_C.PPCEABI.bare.H/arith.c new file mode 100755 index 00000000..974c95c2 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/arith.c @@ -0,0 +1,13 @@ +int abs(int n) { + if (n < 0) + return (-n); + else + return (n); +} + +long labs(long n) { + if (n < 0) + return (-n); + else + return (n); +} diff --git a/src/MSL_C.PPCEABI.bare.H/direct_io.c b/src/MSL_C.PPCEABI.bare.H/direct_io.c index 51184220..4cfa5184 100644 --- a/src/MSL_C.PPCEABI.bare.H/direct_io.c +++ b/src/MSL_C.PPCEABI.bare.H/direct_io.c @@ -1,114 +1,114 @@ #include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/direct_io.h" -#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/buffer_io.h" -#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/misc_io.h" -#include "string.h" -#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/wchar_io.h" +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_files.h" -size_t fwrite(const void* buffer, size_t size, size_t count, FILE* stream) -{ - unsigned char* write_ptr; - size_t num_bytes, bytes_to_go, bytes_written; - int ioresult, always_buffer; - - if (fwide(stream, 0) == 0) - fwide(stream, -1); - - bytes_to_go = size * count; - - if (!bytes_to_go || stream->file_state.error - || stream->file_mode.file_kind == __closed_file) - return 0; - - if ((int)stream->file_mode.file_kind == __console_file) - __stdio_atexit(); - - always_buffer = !stream->file_mode.binary_io - || (int)stream->file_mode.file_kind == __string_file - || stream->file_mode.buffer_mode == _IOFBF - || stream->file_mode.buffer_mode == _IOLBF; - - if (stream->file_state.io_state == __neutral) { - if (stream->file_mode.io_mode & __write) { - stream->file_state.io_state = __writing; - - __prep_buffer(stream); - } - } - - if (stream->file_state.io_state != __writing) { - set_error(stream); - return 0; - } - - write_ptr = (unsigned char*)buffer; - bytes_written = 0; - - if (bytes_to_go - && (stream->buffer_ptr != stream->buffer || always_buffer)) { - stream->buffer_length - = stream->buffer_size - (stream->buffer_ptr - stream->buffer); - - do { - unsigned char* newline = NULL; - - num_bytes = stream->buffer_length; - - if (num_bytes > bytes_to_go) - num_bytes = bytes_to_go; - - if (num_bytes) { - memcpy(stream->buffer_ptr, write_ptr, num_bytes); - - write_ptr += num_bytes; - bytes_written += num_bytes; - bytes_to_go -= num_bytes; - - stream->buffer_ptr += num_bytes; - stream->buffer_length -= num_bytes; - } - - if (!stream->buffer_length - && (int)stream->file_mode.file_kind == __string_file) { - bytes_written += bytes_to_go; - break; - } - - if (!stream->buffer_length || newline != NULL - || (stream->file_mode.buffer_mode == _IONBF)) { - ioresult = __flush_buffer(stream, NULL); - - if (ioresult) { - set_error(stream); - bytes_to_go = 0; - break; - } - } - } while (bytes_to_go && always_buffer); - } - - if (bytes_to_go && !always_buffer) { - unsigned char* save_buffer = stream->buffer; - size_t save_size = stream->buffer_size; - - stream->buffer = write_ptr; - stream->buffer_size = bytes_to_go; - stream->buffer_ptr = write_ptr + bytes_to_go; - - if (__flush_buffer(stream, &num_bytes) != __no_io_error) - set_error(stream); - - bytes_written += num_bytes; - - stream->buffer = save_buffer; - stream->buffer_size = save_size; - - __prep_buffer(stream); - - stream->buffer_length = 0; - } - - if (stream->file_mode.buffer_mode != _IOFBF) - stream->buffer_length = 0; - - return ((bytes_written + size - 1) / size); +size_t fwrite(const void* ptr, size_t memb_size, size_t num_memb, FILE* file) { + size_t retval; + retval = __fwrite(ptr, memb_size, num_memb, file); + return (retval); +} + +size_t __fwrite(const void* ptr, size_t memb_size, size_t num_memb, FILE* file) { + unsigned char* write_ptr; + size_t num_bytes, bytes_to_go, bytes_written; + int ioresult, always_buffer; + +#ifndef __NO_WIDE_CHAR + if (fwide(file, 0) == 0) + fwide(file, -1); +#endif + + bytes_to_go = memb_size * num_memb; + + if (!bytes_to_go || file->file_state.error || file->file_mode.file_kind == __closed_file) + return 0; + + if (file->file_mode.file_kind == __console_file) + __stdio_atexit(); + + always_buffer = + !file->file_mode.binary_io || file->file_mode.buffer_mode == _IOFBF || file->file_mode.buffer_mode == _IOLBF; + + if (file->file_state.io_state == __neutral) { + if (file->file_mode.io_mode & __write) { + if (file->file_mode.io_mode & __append) { + if (fseek(file, 0, SEEK_END)) + return 0; + } + file->file_state.io_state = __writing; + + __prep_buffer(file); + } + } + + if (file->file_state.io_state != __writing) { + set_error(file); + return 0; + } + + write_ptr = (unsigned char*)ptr; + bytes_written = 0; + + if (bytes_to_go && (file->buffer_ptr != file->buffer || always_buffer)) { + file->buffer_length = file->buffer_size - (file->buffer_ptr - file->buffer); + + do { + unsigned char* newline = NULL; + + num_bytes = file->buffer_length; + + if (num_bytes > bytes_to_go) + num_bytes = bytes_to_go; + if (file->file_mode.buffer_mode == _IOLBF && num_bytes) + if ((newline = (unsigned char*)__memrchr(write_ptr, '\n', num_bytes)) != NULL) + num_bytes = newline + 1 - write_ptr; + + if (num_bytes) { + memcpy(file->buffer_ptr, write_ptr, num_bytes); + + write_ptr += num_bytes; + bytes_written += num_bytes; + bytes_to_go -= num_bytes; + + file->buffer_ptr += num_bytes; + file->buffer_length -= num_bytes; + } + if (!file->buffer_length || newline != NULL || + (file->file_mode.buffer_mode == _IONBF)) + { + ioresult = __flush_buffer(file, NULL); + + if (ioresult) { + set_error(file); + bytes_to_go = 0; + break; + } + } + } while (bytes_to_go && always_buffer); + } + + if (bytes_to_go && !always_buffer) { + unsigned char* save_buffer = file->buffer; + size_t save_size = file->buffer_size; + + file->buffer = write_ptr; + file->buffer_size = bytes_to_go; + file->buffer_ptr = write_ptr + bytes_to_go; + + if (__flush_buffer(file, &num_bytes) != __no_io_error) + set_error(file); + + bytes_written += num_bytes; + + file->buffer = save_buffer; + file->buffer_size = save_size; + + __prep_buffer(file); + + file->buffer_length = 0; + } + + if (file->file_mode.buffer_mode != _IOFBF) + file->buffer_length = 0; + + return ((bytes_written + memb_size - 1) / memb_size); } diff --git a/src/MSL_C.PPCEABI.bare.H/e_acos.c b/src/MSL_C.PPCEABI.bare.H/e_acos.c index 4842c54b..01bba5e0 100644 --- a/src/MSL_C.PPCEABI.bare.H/e_acos.c +++ b/src/MSL_C.PPCEABI.bare.H/e_acos.c @@ -1,5 +1,5 @@ #include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common_Embedded/Math/fdlibm.h" -#include "math.h" +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/math.h" #ifdef __STDC__ static const double diff --git a/src/MSL_C.PPCEABI.bare.H/e_asin.c b/src/MSL_C.PPCEABI.bare.H/e_asin.c index 4abcf49d..743d78d5 100644 --- a/src/MSL_C.PPCEABI.bare.H/e_asin.c +++ b/src/MSL_C.PPCEABI.bare.H/e_asin.c @@ -1,5 +1,5 @@ #include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common_Embedded/Math/fdlibm.h" -#include "math.h" +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/math.h" #ifdef __STDC__ static const double diff --git a/src/MSL_C.PPCEABI.bare.H/e_pow.c b/src/MSL_C.PPCEABI.bare.H/e_pow.c index 47b8f4e8..55b9b1c1 100644 --- a/src/MSL_C.PPCEABI.bare.H/e_pow.c +++ b/src/MSL_C.PPCEABI.bare.H/e_pow.c @@ -57,7 +57,7 @@ #include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common_Embedded/Math/fdlibm.h" #include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/errno.h" -#include "math.h" +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/math.h" #ifdef __STDC__ static const double @@ -302,7 +302,7 @@ ivln2_l = 1.92596299112661746887e-08; /* 0x3E54AE0B, 0xF85DDF44 =1/ln2 tail*/ z = one-(r-z); j = __HI(z); j += (n<<20); - if((j>>20)<=0) z = scalbn(z,n); /* subnormal output */ + if((j>>20)<=0) z = ldexp(z,n); /* subnormal output */ else __HI(z) += (n<<20); return s*z; } diff --git a/src/MSL_C.PPCEABI.bare.H/e_rem_pio2.c b/src/MSL_C.PPCEABI.bare.H/e_rem_pio2.c new file mode 100755 index 00000000..ee1a50fa --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/e_rem_pio2.c @@ -0,0 +1,175 @@ +/* @(#)e_rem_pio2.c 1.4 95/01/18 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + * + */ + +/* __ieee754_rem_pio2(x,y) + * + * return the remainder of x rem pi/2 in y[0]+y[1] + * use __kernel_rem_pio2() + */ + +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common_Embedded/Math/fdlibm.h" +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/math.h" + +/* + * Table of constants for 2/pi, 396 Hex digits (476 decimal) of 2/pi + */ +#ifdef __STDC__ +static const int two_over_pi[] = { +#else +static int two_over_pi[] = { +#endif +0xA2F983, 0x6E4E44, 0x1529FC, 0x2757D1, 0xF534DD, 0xC0DB62, +0x95993C, 0x439041, 0xFE5163, 0xABDEBB, 0xC561B7, 0x246E3A, +0x424DD2, 0xE00649, 0x2EEA09, 0xD1921C, 0xFE1DEB, 0x1CB129, +0xA73EE8, 0x8235F5, 0x2EBB44, 0x84E99C, 0x7026B4, 0x5F7E41, +0x3991D6, 0x398353, 0x39F49C, 0x845F8B, 0xBDF928, 0x3B1FF8, +0x97FFDE, 0x05980F, 0xEF2F11, 0x8B5A0A, 0x6D1F6D, 0x367ECF, +0x27CB09, 0xB74F46, 0x3F669E, 0x5FEA2D, 0x7527BA, 0xC7EBE5, +0xF17B3D, 0x0739F7, 0x8A5292, 0xEA6BFB, 0x5FB11F, 0x8D5D08, +0x560330, 0x46FC7B, 0x6BABF0, 0xCFBC20, 0x9AF436, 0x1DA9E3, +0x91615E, 0xE61B08, 0x659985, 0x5F14A0, 0x68408D, 0xFFD880, +0x4D7327, 0x310606, 0x1556CA, 0x73A8C9, 0x60E27B, 0xC08C6B, +}; + +#ifdef __STDC__ +static const int npio2_hw[] = { +#else +static int npio2_hw[] = { +#endif +0x3FF921FB, 0x400921FB, 0x4012D97C, 0x401921FB, 0x401F6A7A, 0x4022D97C, +0x4025FDBB, 0x402921FB, 0x402C463A, 0x402F6A7A, 0x4031475C, 0x4032D97C, +0x40346B9C, 0x4035FDBB, 0x40378FDB, 0x403921FB, 0x403AB41B, 0x403C463A, +0x403DD85A, 0x403F6A7A, 0x40407E4C, 0x4041475C, 0x4042106C, 0x4042D97C, +0x4043A28C, 0x40446B9C, 0x404534AC, 0x4045FDBB, 0x4046C6CB, 0x40478FDB, +0x404858EB, 0x404921FB, +}; + +/* + * invpio2: 53 bits of 2/pi + * pio2_1: first 33 bit of pi/2 + * pio2_1t: pi/2 - pio2_1 + * pio2_2: second 33 bit of pi/2 + * pio2_2t: pi/2 - (pio2_1+pio2_2) + * pio2_3: third 33 bit of pi/2 + * pio2_3t: pi/2 - (pio2_1+pio2_2+pio2_3) + */ + +#ifdef __STDC__ +static const double +#else +static double +#endif +zero = 0.00000000000000000000e+00, /* 0x00000000, 0x00000000 */ +half = 5.00000000000000000000e-01, /* 0x3FE00000, 0x00000000 */ +two24 = 1.67772160000000000000e+07, /* 0x41700000, 0x00000000 */ +invpio2 = 6.36619772367581382433e-01, /* 0x3FE45F30, 0x6DC9C883 */ +pio2_1 = 1.57079632673412561417e+00, /* 0x3FF921FB, 0x54400000 */ +pio2_1t = 6.07710050650619224932e-11, /* 0x3DD0B461, 0x1A626331 */ +pio2_2 = 6.07710050630396597660e-11, /* 0x3DD0B461, 0x1A600000 */ +pio2_2t = 2.02226624879595063154e-21, /* 0x3BA3198A, 0x2E037073 */ +pio2_3 = 2.02226624871116645580e-21, /* 0x3BA3198A, 0x2E000000 */ +pio2_3t = 8.47842766036889956997e-32; /* 0x397B839A, 0x252049C1 */ + +#ifdef __STDC__ + int __ieee754_rem_pio2(double x, double *y) +#else + int __ieee754_rem_pio2(x,y) + double x,y[]; +#endif +{ + double z,w,t,r,fn; + double tx[3]; + int e0,i,j,nx,n,ix,hx; + + hx = __HI(x); /* high word of x */ + ix = hx&0x7fffffff; + if(ix<=0x3fe921fb) /* |x| ~<= pi/4 , no need for reduction */ + {y[0] = x; y[1] = 0; return 0;} + if(ix<0x4002d97c) { /* |x| < 3pi/4, special case with n=+-1 */ + if(hx>0) { + z = x - pio2_1; + if(ix!=0x3ff921fb) { /* 33+53 bit pi is good enough */ + y[0] = z - pio2_1t; + y[1] = (z-y[0])-pio2_1t; + } else { /* near pi/2, use 33+33+53 bit pi */ + z -= pio2_2; + y[0] = z - pio2_2t; + y[1] = (z-y[0])-pio2_2t; + } + return 1; + } else { /* negative x */ + z = x + pio2_1; + if(ix!=0x3ff921fb) { /* 33+53 bit pi is good enough */ + y[0] = z + pio2_1t; + y[1] = (z-y[0])+pio2_1t; + } else { /* near pi/2, use 33+33+53 bit pi */ + z += pio2_2; + y[0] = z + pio2_2t; + y[1] = (z-y[0])+pio2_2t; + } + return -1; + } + } + if(ix<=0x413921fb) { /* |x| ~<= 2^19*(pi/2), medium size */ + t = fabs(x); + n = (int) (t*invpio2+half); + fn = (double)n; + r = t-fn*pio2_1; + w = fn*pio2_1t; /* 1st round good to 85 bit */ + if(n<32&&ix!=npio2_hw[n-1]) { + y[0] = r-w; /* quick check no cancellation */ + } else { + j = ix>>20; + y[0] = r-w; + i = j-(((__HI(y[0]))>>20)&0x7ff); + if(i>16) { /* 2nd iteration needed, good to 118 */ + t = r; + w = fn*pio2_2; + r = t-w; + w = fn*pio2_2t-((t-r)-w); + y[0] = r-w; + i = j-(((__HI(y[0]))>>20)&0x7ff); + if(i>49) { /* 3rd iteration need, 151 bits acc */ + t = r; /* will cover all possible cases */ + w = fn*pio2_3; + r = t-w; + w = fn*pio2_3t-((t-r)-w); + y[0] = r-w; + } + } + } + y[1] = (r-y[0])-w; + if(hx<0) {y[0] = -y[0]; y[1] = -y[1]; return -n;} + else return n; + } + /* + * all other (large) arguments + */ + if(ix>=0x7ff00000) { /* x is inf or NaN */ + y[0]=y[1]=x-x; return 0; + } + /* set z = scalbn(|x|,ilogb(x)-23) */ + __LO(z) = __LO(x); + e0 = (ix>>20)-1046; /* e0 = ilogb(z)-23; */ + __HI(z) = ix - (e0<<20); + for(i=0;i<2;i++) { + tx[i] = (double)((int)(z)); + z = (z-tx[i])*two24; + } + tx[2] = z; + nx = 3; + while(tx[nx-1]==zero) nx--; /* skip zero term */ + n = __kernel_rem_pio2(tx,y,e0,nx,2,two_over_pi); + if(hx<0) {y[0] = -y[0]; y[1] = -y[1]; return -n;} + return n; +} diff --git a/src/MSL_C.PPCEABI.bare.H/file_io.c b/src/MSL_C.PPCEABI.bare.H/file_io.c new file mode 100755 index 00000000..6ca5b36a --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/file_io.c @@ -0,0 +1,58 @@ +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/file_io.h" + +int fclose(FILE* file) { + int flush_result, close_result; + + if (file == NULL) { + return -1; + } + if (file->file_mode.file_kind == __closed_file) { + return 0; + } + flush_result = fflush(file); + close_result = file->close_fn(file->handle); + file->file_mode.file_kind = __closed_file; + file->handle = NULL; + if (file->file_state.free_buffer) { + free(file->buffer); + } + return (flush_result || close_result) ? -1 : 0; +} + +int fflush(FILE* file) { + unsigned long pos; + + if (file == NULL) { + return __flush_all(); + } + if (file->file_state.error != 0 || file->file_mode.file_kind == __closed_file) { + return -1; + } + if (file->file_mode.io_mode == __read) { + return 0; + } + if (file->file_state.io_state >= __rereading) { + file->file_state.io_state = __reading; + } + if (file->file_state.io_state == __reading) { + file->buffer_length = 0; + } + if (file->file_state.io_state != __writing) { + file->file_state.io_state = __neutral; + return 0; + } + if (file->file_mode.file_kind != __disk_file) { + pos = 0; + } else { + pos = ftell(file); + } + if (__flush_buffer(file, 0) != __no_io_error) { + file->file_state.error = 1; + file->buffer_length = 0; + return -1; + } + file->file_state.io_state = __neutral; + file->position = pos; + file->buffer_length = 0; + return 0; +} diff --git a/src/MSL_C.PPCEABI.bare.H/k_cos.c b/src/MSL_C.PPCEABI.bare.H/k_cos.c new file mode 100755 index 00000000..2f69d256 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/k_cos.c @@ -0,0 +1,91 @@ +/* @(#)k_cos.c 1.3 95/01/18 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * __kernel_cos( x, y ) + * kernel cos function on [-pi/4, pi/4], pi/4 ~ 0.785398164 + * Input x is assumed to be bounded by ~pi/4 in magnitude. + * Input y is the tail of x. + * + * Algorithm + * 1. Since cos(-x) = cos(x), we need only to consider positive x. + * 2. if x < 2^-27 (hx<0x3e400000 0), return 1 with inexact if x!=0. + * 3. cos(x) is approximated by a polynomial of degree 14 on + * [0,pi/4] + * 4 14 + * cos(x) ~ 1 - x*x/2 + C1*x + ... + C6*x + * where the remez error is + * + * | 2 4 6 8 10 12 14 | -58 + * |cos(x)-(1-.5*x +C1*x +C2*x +C3*x +C4*x +C5*x +C6*x )| <= 2 + * | | + * + * 4 6 8 10 12 14 + * 4. let r = C1*x +C2*x +C3*x +C4*x +C5*x +C6*x , then + * cos(x) = 1 - x*x/2 + r + * since cos(x+y) ~ cos(x) - sin(x)*y + * ~ cos(x) - x*y, + * a correction term is necessary in cos(x) and hence + * cos(x+y) = 1 - (x*x/2 - (r - x*y)) + * For better accuracy when x > 0.3, let qx = |x|/4 with + * the last 32 bits mask off, and if x > 0.78125, let qx = 0.28125. + * Then + * cos(x+y) = (1-qx) - ((x*x/2-qx) - (r-x*y)). + * Note that 1-qx and (x*x/2-qx) is EXACT here, and the + * magnitude of the latter is at least a quarter of x*x/2, + * thus, reducing the rounding error in the subtraction. + */ + +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common_Embedded/Math/fdlibm.h" + +#ifdef __STDC__ +static const double +#else +static double +#endif +one = 1.00000000000000000000e+00, /* 0x3FF00000, 0x00000000 */ +C1 = 4.16666666666666019037e-02, /* 0x3FA55555, 0x5555554C */ +C2 = -1.38888888888741095749e-03, /* 0xBF56C16C, 0x16C15177 */ +C3 = 2.48015872894767294178e-05, /* 0x3EFA01A0, 0x19CB1590 */ +C4 = -2.75573143513906633035e-07, /* 0xBE927E4F, 0x809C52AD */ +C5 = 2.08757232129817482790e-09, /* 0x3E21EE9E, 0xBDB4B1C4 */ +C6 = -1.13596475577881948265e-11; /* 0xBDA8FAE9, 0xBE8838D4 */ + +#ifdef __STDC__ + double __kernel_cos(double x, double y) +#else + double __kernel_cos(x, y) + double x,y; +#endif +{ + double a,hz,z,r,qx; + int ix; + ix = __HI(x)&0x7fffffff; /* ix = |x|'s high word*/ + if(ix<0x3e400000) { /* if x < 2**27 */ + if(((int)x)==0) return one; /* generate inexact */ + } + z = x*x; + r = z*(C1+z*(C2+z*(C3+z*(C4+z*(C5+z*C6))))); + if(ix < 0x3FD33333) /* if |x| < 0.3 */ + return one - (0.5*z - (z*r - x*y)); + else { + if(ix > 0x3fe90000) { /* x > 0.78125 */ + qx = 0.28125; + } else { + __HI(qx) = ix-0x00200000; /* x/4 */ + __LO(qx) = 0; + } + hz = 0.5*z-qx; + a = one-qx; + return a - (hz - (z*r-x*y)); + } +} diff --git a/src/MSL_C.PPCEABI.bare.H/k_rem_pio2.c b/src/MSL_C.PPCEABI.bare.H/k_rem_pio2.c new file mode 100755 index 00000000..b14d7d2a --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/k_rem_pio2.c @@ -0,0 +1,316 @@ + +/* @(#)k_rem_pio2.c 1.3 95/01/18 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * __kernel_rem_pio2(x,y,e0,nx,prec,ipio2) + * double x[],y[]; int e0,nx,prec; int ipio2[]; + * + * __kernel_rem_pio2 return the last three digits of N with + * y = x - N*pi/2 + * so that |y| < pi/2. + * + * The method is to compute the integer (mod 8) and fraction parts of + * (2/pi)*x without doing the full multiplication. In general we + * skip the part of the product that are known to be a huge integer ( + * more accurately, = 0 mod 8 ). Thus the number of operations are + * independent of the exponent of the input. + * + * (2/pi) is represented by an array of 24-bit integers in ipio2[]. + * + * Input parameters: + * x[] The input value (must be positive) is broken into nx + * pieces of 24-bit integers in double precision format. + * x[i] will be the i-th 24 bit of x. The scaled exponent + * of x[0] is given in input parameter e0 (i.e., x[0]*2^e0 + * match x's up to 24 bits. + * + * Example of breaking a double positive z into x[0]+x[1]+x[2]: + * e0 = ilogb(z)-23 + * z = ldexp(z,-e0) + * for i = 0,1,2 + * x[i] = floor(z) + * z = (z-x[i])*2**24 + * + * + * y[] ouput result in an array of double precision numbers. + * The dimension of y[] is: + * 24-bit precision 1 + * 53-bit precision 2 + * 64-bit precision 2 + * 113-bit precision 3 + * The actual value is the sum of them. Thus for 113-bit + * precison, one may have to do something like: + * + * long double t,w,r_head, r_tail; + * t = (long double)y[2] + (long double)y[1]; + * w = (long double)y[0]; + * r_head = t+w; + * r_tail = w - (r_head - t); + * + * e0 The exponent of x[0] + * + * nx dimension of x[] + * + * prec an integer indicating the precision: + * 0 24 bits (single) + * 1 53 bits (double) + * 2 64 bits (extended) + * 3 113 bits (quad) + * + * ipio2[] + * integer array, contains the (24*i)-th to (24*i+23)-th + * bit of 2/pi after binary point. The corresponding + * floating value is + * + * ipio2[i] * 2^(-24(i+1)). + * + * External function: + * double ldexp(), floor(); + * + * + * Here is the description of some local variables: + * + * jk jk+1 is the initial number of terms of ipio2[] needed + * in the computation. The recommended value is 2,3,4, + * 6 for single, double, extended,and quad. + * + * jz local integer variable indicating the number of + * terms of ipio2[] used. + * + * jx nx - 1 + * + * jv index for pointing to the suitable ipio2[] for the + * computation. In general, we want + * ( 2^e0*x[0] * ipio2[jv-1]*2^(-24jv) )/8 + * is an integer. Thus + * e0-3-24*jv >= 0 or (e0-3)/24 >= jv + * Hence jv = max(0,(e0-3)/24). + * + * jp jp+1 is the number of terms in PIo2[] needed, jp = jk. + * + * q[] double array with integral value, representing the + * 24-bits chunk of the product of x and 2/pi. + * + * q0 the corresponding exponent of q[0]. Note that the + * exponent for q[i] would be q0-24*i. + * + * PIo2[] double precision array, obtained by cutting pi/2 + * into 24 bits chunks. + * + * f[] ipio2[] in floating point + * + * iq[] integer array by breaking up q[] in 24-bits chunk. + * + * fq[] final product of x*(2/pi) in fq[0],..,fq[jk] + * + * ih integer. If >0 it indicates q[] is >= 0.5, hence + * it also indicates the *sign* of the result. + * + */ + + +/* + * Constants: + * The hexadecimal values are the intended ones for the following + * constants. The decimal values may be used, provided that the + * compiler will convert from decimal to binary accurately enough + * to produce the hexadecimal values shown. + */ + +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common_Embedded/Math/fdlibm.h" + +#ifdef __STDC__ +static const int init_jk[] = {2,3,4,6}; /* initial value for jk */ +#else +static int init_jk[] = {2,3,4,6}; +#endif + +#ifdef __STDC__ +static const double PIo2[] = { +#else +static double PIo2[] = { +#endif + 1.57079625129699707031e+00, /* 0x3FF921FB, 0x40000000 */ + 7.54978941586159635335e-08, /* 0x3E74442D, 0x00000000 */ + 5.39030252995776476554e-15, /* 0x3CF84698, 0x80000000 */ + 3.28200341580791294123e-22, /* 0x3B78CC51, 0x60000000 */ + 1.27065575308067607349e-29, /* 0x39F01B83, 0x80000000 */ + 1.22933308981111328932e-36, /* 0x387A2520, 0x40000000 */ + 2.73370053816464559624e-44, /* 0x36E38222, 0x80000000 */ + 2.16741683877804819444e-51, /* 0x3569F31D, 0x00000000 */ +}; + +#ifdef __STDC__ +static const double +#else +static double +#endif +zero = 0.0, +one = 1.0, +two24 = 1.67772160000000000000e+07, /* 0x41700000, 0x00000000 */ +twon24 = 5.96046447753906250000e-08; /* 0x3E700000, 0x00000000 */ + +#ifdef __STDC__ + int __kernel_rem_pio2(double *x, double *y, int e0, int nx, int prec, const int *ipio2) +#else + int __kernel_rem_pio2(x,y,e0,nx,prec,ipio2) + double x[], y[]; int e0,nx,prec; int ipio2[]; +#endif +{ + int jz,jx,jv,jp,jk,carry,n,iq[20],i,j,k,m,q0,ih; + double z,fw,f[20],fq[20],q[20]; + + /* initialize jk*/ + jk = init_jk[prec]; + jp = jk; + + /* determine jx,jv,q0, note that 3>q0 */ + jx = nx-1; + jv = (e0-3)/24; if(jv<0) jv=0; + q0 = e0-24*(jv+1); + + /* set up f[0] to f[jx+jk] where f[jx+jk] = ipio2[jv+jk] */ + j = jv-jx; m = jx+jk; + for(i=0;i<=m;i++,j++) f[i] = (j<0)? zero : (double) ipio2[j]; + + /* compute q[0],q[1],...q[jk] */ + for (i=0;i<=jk;i++) { + for(j=0,fw=0.0;j<=jx;j++) fw += x[j]*f[jx+i-j]; q[i] = fw; + } + + jz = jk; +recompute: + /* distill q[] into iq[] reversingly */ + for(i=0,j=jz,z=q[jz];j>0;i++,j--) { + fw = (double)((int)(twon24* z)); + iq[i] = (int)(z-two24*fw); + z = q[j-1]+fw; + } + + /* compute n */ + z = ldexp(z,q0); /* actual value of z */ + z -= 8.0*floor(z*0.125); /* trim off integer >= 8 */ + n = (int) z; + z -= (double)n; + ih = 0; + if(q0>0) { /* need iq[jz-1] to determine n */ + i = (iq[jz-1]>>(24-q0)); n += i; + iq[jz-1] -= i<<(24-q0); + ih = iq[jz-1]>>(23-q0); + } + else if(q0==0) ih = iq[jz-1]>>23; + else if(z>=0.5) ih=2; + + if(ih>0) { /* q > 0.5 */ + n += 1; carry = 0; + for(i=0;i0) { /* rare case: chance is 1 in 12 */ + switch(q0) { + case 1: + iq[jz-1] &= 0x7fffff; break; + case 2: + iq[jz-1] &= 0x3fffff; break; + } + } + if(ih==2) { + z = one - z; + if(carry!=0) z -= ldexp(one,q0); + } + } + + /* check if recomputation is needed */ + if(z==zero) { + j = 0; + for (i=jz-1;i>=jk;i--) j |= iq[i]; + if(j==0) { /* need recomputation */ + for(k=1;iq[jk-k]==0;k++); /* k = no. of terms needed */ + + for(i=jz+1;i<=jz+k;i++) { /* add q[jz+1] to q[jz+k] */ + f[jx+i] = (double) ipio2[jv+i]; + for(j=0,fw=0.0;j<=jx;j++) fw += x[j]*f[jx+i-j]; + q[i] = fw; + } + jz += k; + goto recompute; + } + } + + /* chop off zero terms */ + if(z==0.0) { + jz -= 1; q0 -= 24; + while(iq[jz]==0) { jz--; q0-=24;} + } else { /* break z into 24-bit if necessary */ + z = ldexp(z,-q0); + if(z>=two24) { + fw = (double)((int)(twon24*z)); + iq[jz] = (int)(z-two24*fw); + jz += 1; q0 += 24; + iq[jz] = (int) fw; + } else iq[jz] = (int) z ; + } + + /* convert integer "bit" chunk to floating-point value */ + fw = ldexp(one,q0); + for(i=jz;i>=0;i--) { + q[i] = fw*(double)iq[i]; fw*=twon24; + } + + /* compute PIo2[0,...,jp]*q[jz,...,0] */ + for(i=jz;i>=0;i--) { + for(fw=0.0,k=0;k<=jp&&k<=jz-i;k++) fw += PIo2[k]*q[i+k]; + fq[jz-i] = fw; + } + + /* compress fq[] into y[] */ + switch(prec) { + case 0: + fw = 0.0; + for (i=jz;i>=0;i--) fw += fq[i]; + y[0] = (ih==0)? fw: -fw; + break; + case 1: + case 2: + fw = 0.0; + for (i=jz;i>=0;i--) fw += fq[i]; + y[0] = (ih==0)? fw: -fw; + fw = fq[0]-fw; + for (i=1;i<=jz;i++) fw += fq[i]; + y[1] = (ih==0)? fw: -fw; + break; + case 3: /* painful */ + for (i=jz;i>0;i--) { + fw = fq[i-1]+fq[i]; + fq[i] += fq[i-1]-fw; + fq[i-1] = fw; + } + for (i=jz;i>1;i--) { + fw = fq[i-1]+fq[i]; + fq[i] += fq[i-1]-fw; + fq[i-1] = fw; + } + for (fw=0.0,i=jz;i>=2;i--) fw += fq[i]; + if(ih==0) { + y[0] = fq[0]; y[1] = fq[1]; y[2] = fw; + } else { + y[0] = -fq[0]; y[1] = -fq[1]; y[2] = -fw; + } + } + return n&7; +} diff --git a/src/MSL_C.PPCEABI.bare.H/k_sin.c b/src/MSL_C.PPCEABI.bare.H/k_sin.c new file mode 100755 index 00000000..b136909a --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/k_sin.c @@ -0,0 +1,73 @@ +/* @(#)k_sin.c 1.3 95/01/18 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* __kernel_sin( x, y, iy) + * kernel sin function on [-pi/4, pi/4], pi/4 ~ 0.7854 + * Input x is assumed to be bounded by ~pi/4 in magnitude. + * Input y is the tail of x. + * Input iy indicates whether y is 0. (if iy=0, y assume to be 0). + * + * Algorithm + * 1. Since sin(-x) = -sin(x), we need only to consider positive x. + * 2. if x < 2^-27 (hx<0x3e400000 0), return x with inexact if x!=0. + * 3. sin(x) is approximated by a polynomial of degree 13 on + * [0,pi/4] + * 3 13 + * sin(x) ~ x + S1*x + ... + S6*x + * where + * + * |sin(x) 2 4 6 8 10 12 | -58 + * |----- - (1+S1*x +S2*x +S3*x +S4*x +S5*x +S6*x )| <= 2 + * | x | + * + * 4. sin(x+y) = sin(x) + sin'(x')*y + * ~ sin(x) + (1-x*x/2)*y + * For better accuracy, let + * 3 2 2 2 2 + * r = x *(S2+x *(S3+x *(S4+x *(S5+x *S6)))) + * then 3 2 + * sin(x) = x + (S1*x + (x *(r-y/2)+y)) + */ + +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common_Embedded/Math/fdlibm.h" + +#ifdef __STDC__ +static const double +#else +static double +#endif +half = 5.00000000000000000000e-01, /* 0x3FE00000, 0x00000000 */ +S1 = -1.66666666666666324348e-01, /* 0xBFC55555, 0x55555549 */ +S2 = 8.33333333332248946124e-03, /* 0x3F811111, 0x1110F8A6 */ +S3 = -1.98412698298579493134e-04, /* 0xBF2A01A0, 0x19C161D5 */ +S4 = 2.75573137070700676789e-06, /* 0x3EC71DE3, 0x57B1FE7D */ +S5 = -2.50507602534068634195e-08, /* 0xBE5AE5E6, 0x8A2B9CEB */ +S6 = 1.58969099521155010221e-10; /* 0x3DE5D93A, 0x5ACFD57C */ + +#ifdef __STDC__ + double __kernel_sin(double x, double y, int iy) +#else + double __kernel_sin(x, y, iy) + double x,y; int iy; /* iy=0 if y is zero */ +#endif +{ + double z,r,v; + int ix; + ix = __HI(x)&0x7fffffff; /* high word of x */ + if(ix<0x3e400000) /* |x| < 2**-27 */ + {if((int)x==0) return x;} /* generate inexact */ + z = x*x; + v = z*x; + r = S2+z*(S3+z*(S4+z*(S5+z*S6))); + if(iy==0) return x+v*(S1+z*r); + else return x-((z*(half*y-v*r)-y)-v*S1); +} diff --git a/src/MSL_C.PPCEABI.bare.H/k_tan.c b/src/MSL_C.PPCEABI.bare.H/k_tan.c new file mode 100755 index 00000000..d7dec7f5 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/k_tan.c @@ -0,0 +1,134 @@ +/* + * ==================================================== + * Copyright 2004 Sun Microsystems, Inc. All Rights Reserved. + * + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* INDENT OFF */ +/* __kernel_tan( x, y, k ) + * kernel tan function on [-pi/4, pi/4], pi/4 ~ 0.7854 + * Input x is assumed to be bounded by ~pi/4 in magnitude. + * Input y is the tail of x. + * Input k indicates whether tan (if k = 1) or -1/tan (if k = -1) is returned. + * + * Algorithm + * 1. Since tan(-x) = -tan(x), we need only to consider positive x. + * 2. if x < 2^-28 (hx<0x3e300000 0), return x with inexact if x!=0. + * 3. tan(x) is approximated by a odd polynomial of degree 27 on + * [0,0.67434] + * 3 27 + * tan(x) ~ x + T1*x + ... + T13*x + * where + * + * |tan(x) 2 4 26 | -59.2 + * |----- - (1+T1*x +T2*x +.... +T13*x )| <= 2 + * | x | + * + * Note: tan(x+y) = tan(x) + tan'(x)*y + * ~ tan(x) + (1+x*x)*y + * Therefore, for better accuracy in computing tan(x+y), let + * 3 2 2 2 2 + * r = x *(T2+x *(T3+x *(...+x *(T12+x *T13)))) + * then + * 3 2 + * tan(x+y) = x + (T1*x + (x *(r+y)+y)) + * + * 4. For x in [0.67434,pi/4], let y = pi/4 - x, then + * tan(x) = tan(pi/4-y) = (1-tan(y))/(1+tan(y)) + * = 1 - 2*(tan(y) - (tan(y)^2)/(1+tan(y))) + */ + +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common_Embedded/Math/fdlibm.h" +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/math.h" + +static const double xxx[] = { + 3.33333333333334091986e-01, /* 3FD55555, 55555563 */ + 1.33333333333201242699e-01, /* 3FC11111, 1110FE7A */ + 5.39682539762260521377e-02, /* 3FABA1BA, 1BB341FE */ + 2.18694882948595424599e-02, /* 3F9664F4, 8406D637 */ + 8.86323982359930005737e-03, /* 3F8226E3, E96E8493 */ + 3.59207910759131235356e-03, /* 3F6D6D22, C9560328 */ + 1.45620945432529025516e-03, /* 3F57DBC8, FEE08315 */ + 5.88041240820264096874e-04, /* 3F4344D8, F2F26501 */ + 2.46463134818469906812e-04, /* 3F3026F7, 1A8D1068 */ + 7.81794442939557092300e-05, /* 3F147E88, A03792A6 */ + 7.14072491382608190305e-05, /* 3F12B80F, 32F0A7E9 */ + -1.85586374855275456654e-05, /* BEF375CB, DB605373 */ + 2.59073051863633712884e-05, /* 3EFB2A70, 74BF7AD4 */ +}; +#define pio4 7.85398163397448278999e-01 +#define pio4lo 3.06161699786838301793e-17 +#define T xxx +/* INDENT ON */ + +double +__kernel_tan(double x, double y, int iy) { + double z, r, v, w, s; + int ix, hx; + + hx = __HI(x); /* high word of x */ + ix = hx & 0x7fffffff; /* high word of |x| */ + if (ix < 0x3e300000) { /* x < 2**-28 */ + if ((int) x == 0) { /* generate inexact */ + if (((ix | __LO(x)) | (iy + 1)) == 0) + return 1 / fabs(x); + else { + if (iy == 1) + return x; + else + return -1 / x; + } + } + } + if (ix >= 0x3FE59428) { /* |x| >= 0.6744 */ + if (hx < 0) { + x = -x; + y = -y; + } + z = pio4 - x; + w = pio4lo - y; + x = z + w; + y = 0.0; + } + z = x * x; + w = z * z; + /* + * Break x^5*(T[1]+x^2*T[2]+...) into + * x^5(T[1]+x^4*T[3]+...+x^20*T[11]) + + * x^5(x^2*(T[2]+x^4*T[4]+...+x^22*[T12])) + */ + r = T[1] + w * (T[3] + w * (T[5] + w * (T[7] + w * (T[9] + + w * T[11])))); + v = z * (T[2] + w * (T[4] + w * (T[6] + w * (T[8] + w * (T[10] + + w * T[12]))))); + s = z * x; + r = y + z * (s * (r + v) + y); + r += T[0] * s; + w = x + r; + if (ix >= 0x3FE59428) { + v = (double) iy; + return (double) (1 - ((hx >> 30) & 2)) * + (v - 2.0 * (x - (w * w / (w + v) - r))); + } + if (iy == 1) + return w; + else { + /* + * if allow error up to 2 ulp, simply return + * -1.0 / (x+r) here + */ + /* compute -1.0 / (x+r) accurately */ + double a, t; + z = w; + __LO(z) = 0; + v = r - (z - x); /* z+v = r+x */ + t = a = -1.0 / w; /* a = -1.0/w */ + __LO(t) = 0; + s = 1.0 + t * z; + return t + a * (s + t * v); + } +} diff --git a/src/MSL_C.PPCEABI.bare.H/mbstring.c b/src/MSL_C.PPCEABI.bare.H/mbstring.c index fa77c660..0364afa3 100644 --- a/src/MSL_C.PPCEABI.bare.H/mbstring.c +++ b/src/MSL_C.PPCEABI.bare.H/mbstring.c @@ -1,18 +1,64 @@ -#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/mbstring.h" +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_files.h" -size_t wcstombs(char* s, const wchar_t* pwcs, size_t n) -{ - wchar_t next; - size_t chars_written; - int i; +static int unicode_to_UTF8(char* s, wchar_t wchar) { + int number_of_bytes; + char* target_ptr; + char first_byte_mark[4] = {0x00, 0x00, 0xc0, 0xe0}; - chars_written = 0; - for (i = 0; i < n; ++i) { - next = *pwcs++; - *s++ = (char)next; - if ((char)next == '\0') - break; - ++chars_written; - } - return chars_written; + if (!s) { + return 0; + } + + if (wchar < 0x0080) + number_of_bytes = 1; + else if (wchar < 0x0800) + number_of_bytes = 2; + else + number_of_bytes = 3; + + target_ptr = s + number_of_bytes; + + switch (number_of_bytes) { + case 3: + *--target_ptr = (wchar & 0x003f) | 0x80; + wchar >>= 6; + case 2: + *--target_ptr = (wchar & 0x003f) | 0x80; + wchar >>= 6; + case 1: + *--target_ptr = wchar | first_byte_mark[number_of_bytes]; + } + + return (number_of_bytes); +} + +static inline int wctomb(char* s, wchar_t wchar) { + return (unicode_to_UTF8(s, wchar)); +} + +size_t wcstombs(char* s, const wchar_t* pwcs, size_t n) { + int chars_written = 0; + int result; + char temp[3]; + wchar_t* source; + + if (!s || !pwcs) + return (0); + + source = (wchar_t*)pwcs; + while (chars_written <= n) { + if (!*source) { + *(s + chars_written) = '\0'; + break; + } else { + result = wctomb(temp, *source++); + if ((chars_written + result) <= n) { + strcat(s + chars_written, temp, result); + chars_written += result; + } else + break; + } + } + + return (chars_written); } diff --git a/src/MSL_C.PPCEABI.bare.H/misc_io.c b/src/MSL_C.PPCEABI.bare.H/misc_io.c index 2b6c9913..06827814 100644 --- a/src/MSL_C.PPCEABI.bare.H/misc_io.c +++ b/src/MSL_C.PPCEABI.bare.H/misc_io.c @@ -1 +1,6 @@ -void __stdio_atexit(void) { } +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_files.h" +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/abort_exit.h" + +void __stdio_atexit(void) { + __stdio_exit = __close_all; +} diff --git a/src/MSL_C.PPCEABI.bare.H/printf.c b/src/MSL_C.PPCEABI.bare.H/printf.c index 21d248da..9fa17473 100644 --- a/src/MSL_C.PPCEABI.bare.H/printf.c +++ b/src/MSL_C.PPCEABI.bare.H/printf.c @@ -17,1060 +17,1123 @@ extern void __num2dec(const decform*, double, decimal*); #define TARGET_FLOAT_MANT_DIG LDBL_MANT_DIG #define TARGET_FLOAT_IMPLICIT_J_BIT 1 #define TARGET_FLOAT_MANT_BITS \ - (TARGET_FLOAT_MANT_DIG - TARGET_FLOAT_IMPLICIT_J_BIT) + (TARGET_FLOAT_MANT_DIG - TARGET_FLOAT_IMPLICIT_J_BIT) #define TARGET_FLOAT_EXP_BITS (TARGET_FLOAT_BITS - TARGET_FLOAT_MANT_BITS - 1) enum justification_options { - left_justification, - right_justification, - zero_fill + left_justification, + right_justification, + zero_fill }; enum sign_options { only_minus, sign_always, space_holder }; enum argument_options { - normal_argument, - char_argument, - short_argument, - long_argument, - long_long_argument, - long_double_argument, - wchar_argument + normal_argument, + char_argument, + short_argument, + long_argument, + long_long_argument, + long_double_argument, + wchar_argument }; typedef struct { - unsigned char justification_options; - unsigned char sign_options; - unsigned char precision_specified; - unsigned char alternate_form; - unsigned char argument_options; - unsigned char conversion_char; - int field_width; - int precision; + unsigned char justification_options; + unsigned char sign_options; + unsigned char precision_specified; + unsigned char alternate_form; + unsigned char argument_options; + unsigned char conversion_char; + int field_width; + int precision; } print_format; -static const char* parse_format(const char* format_string, va_list* arg, - print_format* format) -{ - print_format f; - const char* s = format_string; - int c; - int flag_found; - f.justification_options = right_justification; - f.sign_options = only_minus; - f.precision_specified = 0; - f.alternate_form = 0; - f.argument_options = normal_argument; - f.field_width = 0; - f.precision = 0; +static const char* parse_format(const char *format_string, va_list *arg, print_format *format) { + print_format f; + const char* s = format_string; + int c; + int flag_found; + f.justification_options = right_justification; + f.sign_options = only_minus; + f.precision_specified = 0; + f.alternate_form = 0; + f.argument_options = normal_argument; + f.field_width = 0; + f.precision = 0; - if ((c = *++s) == '%') { - f.conversion_char = c; - *format = f; - return ((const char*)s + 1); - } + if ((c = *++s) == '%') { + f.conversion_char = c; + *format = f; + return ((const char*)s + 1); + } - for (;;) { - flag_found = 1; + for (;;) { + flag_found = 1; - switch (c) { - case '-': - f.justification_options = left_justification; - break; - case '+': - f.sign_options = sign_always; - break; - case ' ': - if (f.sign_options != sign_always) { - f.sign_options = space_holder; - } - break; - case '#': - f.alternate_form = 1; - break; - case '0': - if (f.justification_options != left_justification) { - f.justification_options = zero_fill; - } - break; - default: - flag_found = 0; - break; - } + switch (c) { + case '-': + f.justification_options = left_justification; + break; + case '+': + f.sign_options = sign_always; + break; + case ' ': + if (f.sign_options != sign_always) { + f.sign_options = space_holder; + } + break; + case '#': + f.alternate_form = 1; + break; + case '0': + if (f.justification_options != left_justification) { + f.justification_options = zero_fill; + } + break; + default: + flag_found = 0; + break; + } - if (flag_found) { - c = *++s; - } else { - break; - } - } + if (flag_found) { + c = *++s; + } + else { + break; + } + } - if (c == '*') { - if ((f.field_width = va_arg(*arg, int)) < 0) { - f.justification_options = left_justification; - f.field_width = -f.field_width; - } + if (c == '*') { + if ((f.field_width = va_arg(*arg, int)) < 0) { + f.justification_options = left_justification; + f.field_width = -f.field_width; + } - c = *++s; - } else { - while (isdigit(c)) { - f.field_width = (f.field_width * 10) + (c - '0'); - c = *++s; - } - } + c = *++s; + } + else { + while (isdigit(c)) { + f.field_width = (f.field_width * 10) + (c - '0'); + c = *++s; + } + } - if (f.field_width > 509) { - f.conversion_char = 0xFF; - *format = f; - return ((const char*)s + 1); - } + if (f.field_width > 509) { + f.conversion_char = 0xFF; + *format = f; + return ((const char*)s + 1); + } - if (c == '.') { - f.precision_specified = 1; + if (c == '.') { + f.precision_specified = 1; - if ((c = *++s) == '*') { - if ((f.precision = va_arg(*arg, int)) < 0) { - f.precision_specified = 0; - } + if ((c = *++s) == '*') { + if ((f.precision = va_arg(*arg, int)) < 0) { + f.precision_specified = 0; + } - c = *++s; - } else { - while (isdigit(c)) { - f.precision = (f.precision * 10) + (c - '0'); - c = *++s; - } - } - } + c = *++s; + } + else { + while (isdigit(c)) { + f.precision = (f.precision * 10) + (c - '0'); + c = *++s; + } + } + } - flag_found = 1; + flag_found = 1; - switch (c) { - case 'h': - f.argument_options = short_argument; + switch (c) { + case 'h': + f.argument_options = short_argument; - if (s[1] == 'h') { - f.argument_options = char_argument; - c = *++s; - } + if (s[1] == 'h') { + f.argument_options = char_argument; + c = *++s; + } - break; + break; - case 'l': - f.argument_options = long_argument; + case 'l': + f.argument_options = long_argument; - if (s[1] == 'l') { - f.argument_options = long_long_argument; - c = *++s; - } + if (s[1] == 'l') { + f.argument_options = long_long_argument; + c = *++s; + } - break; + break; - case 'L': - f.argument_options = long_double_argument; - break; - default: - flag_found = 0; - break; - } + case 'L': + f.argument_options = long_double_argument; + break; + default: + flag_found = 0; + break; + } - if (flag_found) { - c = *++s; - } + if (flag_found) { + c = *++s; + } - f.conversion_char = c; + f.conversion_char = c; - switch (c) { - case 'd': - case 'i': - case 'u': - case 'o': - case 'x': - case 'X': - if (f.argument_options == long_double_argument) { - f.conversion_char = 0xFF; - break; - } + switch (c) { + case 'd': + case 'i': + case 'u': + case 'o': + case 'x': + case 'X': + if (f.argument_options == long_double_argument) { + f.conversion_char = 0xFF; + break; + } - if (!f.precision_specified) { - f.precision = 1; - } else if (f.justification_options == zero_fill) { - f.justification_options = right_justification; - } - break; + if (!f.precision_specified) { + f.precision = 1; + } + else if (f.justification_options == zero_fill) { + f.justification_options = right_justification; + } + break; - case 'f': - if (f.argument_options == short_argument - || f.argument_options == long_long_argument) { - f.conversion_char = 0xFF; - break; - } + case 'f': + case 'F': + if (f.argument_options == short_argument || f.argument_options == long_long_argument) { + f.conversion_char = 0xFF; + break; + } - if (!f.precision_specified) { - f.precision = 6; - } - break; + if (!f.precision_specified) { + f.precision = 6; + } + break; - case 'g': - case 'G': - if (!f.precision) { - f.precision = 1; - } + case 'a': + case 'A': + if (!f.precision_specified) { + f.precision = 0xD; + } - case 'e': - case 'E': - if (f.argument_options == short_argument - || f.argument_options == long_long_argument - || f.argument_options == char_argument) { - f.conversion_char = 0xFF; - break; - } + if (f.argument_options == short_argument || f.argument_options == long_long_argument || f.argument_options == char_argument) { + f.conversion_char = 0xFF; + } - if (!f.precision_specified) { - f.precision = 6; - } - break; + break; - case 'p': - f.conversion_char = 'x'; - f.alternate_form = 1; - f.argument_options = long_argument; - f.precision = 8; - break; + case 'g': + case 'G': + if (!f.precision) { + f.precision = 1; + } - case 'c': - if (f.argument_options == long_argument) { - f.argument_options = wchar_argument; - } else { - if (f.precision_specified - || f.argument_options != normal_argument) { - f.conversion_char = 0xFF; - } - } + case 'e': + case 'E': + if (f.argument_options == short_argument || f.argument_options == long_long_argument || f.argument_options == char_argument) { + f.conversion_char = 0xFF; + break; + } - break; + if (!f.precision_specified) { + f.precision = 6; + } + break; - case 's': - if (f.argument_options == long_argument) { - f.argument_options = wchar_argument; - } else { - if (f.argument_options != normal_argument) { - f.conversion_char = 0xFF; - } - } + case 'p': + f.conversion_char = 'x'; + f.alternate_form = 1; + f.argument_options = long_argument; + f.precision = 8; + break; - break; + case 'c': + if (f.argument_options == long_argument) { + f.argument_options = wchar_argument; + } + else { + if (f.precision_specified || f.argument_options != normal_argument) { + f.conversion_char = 0xFF; + } + } - case 'n': - if (f.argument_options == long_double_argument) { - f.conversion_char = 0xFF; - } + break; - break; + case 's': + if (f.argument_options == long_argument) { + f.argument_options = wchar_argument; + } + else { + if (f.argument_options != normal_argument) { + f.conversion_char = 0xFF; + } + } - default: - f.conversion_char = 0xFF; - break; - } + break; - *format = f; - return ((const char*)s + 1); + case 'n': + if (f.argument_options == long_double_argument) { + f.conversion_char = 0xFF; + } + + break; + + default: + f.conversion_char = 0xFF; + break; + } + + *format = f; + return ((const char*)s + 1); } -static char* long2str(signed long num, char* buff, print_format* format) +static char* long2str(long num, char* buff, print_format format) { - unsigned long unsigned_num, base; - char* p; - int n, digits; - int minus = 0; - unsigned_num = num; - minus = 0; + unsigned long unsigned_num, base; + char* p; + int n, digits; + int minus = 0; + unsigned_num = num; + minus = 0; - p = buff; - *--p = 0; - digits = 0; + p = buff; + *--p = 0; + digits = 0; - if (!num && !format->precision - && !(format->alternate_form && format->conversion_char == 'o')) { - return p; - } + if (!num && !format.precision + && !(format.alternate_form && format.conversion_char == 'o')) { + return p; + } - switch (format->conversion_char) { - case 'd': - case 'i': - base = 10; + switch (format.conversion_char) { + case 'd': + case 'i': + base = 10; - if (num < 0) { - unsigned_num = -unsigned_num; - minus = 1; - } - break; + if (num < 0) { + unsigned_num = -unsigned_num; + minus = 1; + } + break; - case 'o': - base = 8; - format->sign_options = only_minus; - break; + case 'o': + base = 8; + format.sign_options = only_minus; + break; - case 'u': - base = 10; - format->sign_options = only_minus; - break; + case 'u': + base = 10; + format.sign_options = only_minus; + break; - case 'x': - case 'X': - base = 16; - format->sign_options = only_minus; - break; - } + case 'x': + case 'X': + base = 16; + format.sign_options = only_minus; + break; + } - do { - n = unsigned_num % base; - unsigned_num /= base; + do { + n = unsigned_num % base; + unsigned_num /= base; - if (n < 10) { - n += '0'; - } else { - n -= 10; + if (n < 10) { + n += '0'; + } else { + n -= 10; - if (format->conversion_char == 'x') { - n += 'a'; - } else { - n += 'A'; - } - } + if (format.conversion_char == 'x') { + n += 'a'; + } else { + n += 'A'; + } + } - *--p = n; - ++digits; - } while (unsigned_num != 0); + *--p = n; + ++digits; + } while (unsigned_num != 0); - if (base == 8 && format->alternate_form && *p != '0') { - *--p = '0'; - ++digits; - } + if (base == 8 && format.alternate_form && *p != '0') { + *--p = '0'; + ++digits; + } - if (format->justification_options == zero_fill) { - format->precision = format->field_width; + if (format.justification_options == zero_fill) { + format.precision = format.field_width; - if (minus || format->sign_options != only_minus) - --format->precision; + if (minus || format.sign_options != only_minus) + --format.precision; - if (base == 16 && format->alternate_form) - format->precision -= 2; - } + if (base == 16 && format.alternate_form) + format.precision -= 2; + } - if (buff - p + format->precision > 509) - return (0); + if (buff - p + format.precision > 509) + return (0); - while (digits < format->precision) { - *--p = '0'; - ++digits; - } + while (digits < format.precision) { + *--p = '0'; + ++digits; + } - if (base == 16 && format->alternate_form) { - *--p = format->conversion_char; - *--p = '0'; - } + if (base == 16 && format.alternate_form) { + *--p = format.conversion_char; + *--p = '0'; + } - if (minus) { - *--p = '-'; - } else if (format->sign_options == sign_always) { - *--p = '+'; - } else if (format->sign_options == space_holder) { - *--p = ' '; - } + if (minus) { + *--p = '-'; + } else if (format.sign_options == sign_always) { + *--p = '+'; + } else if (format.sign_options == space_holder) { + *--p = ' '; + } - return p; + return p; } -static char* longlong2str(signed long long num, char* pBuf, print_format* fmt) +static char* longlong2str(long long num, char* pBuf, print_format fmt) { - unsigned long long unsigned_num, base; - char* p; - int n, digits; - int minus = 0; - unsigned_num = num; - minus = 0; - p = pBuf; - *--p = 0; - digits = 0; + unsigned long long unsigned_num, base; + char* p; + int n, digits; + int minus = 0; + unsigned_num = num; + minus = 0; + p = pBuf; + *--p = 0; + digits = 0; - if (!num && !fmt->precision - && !(fmt->alternate_form && fmt->conversion_char == 'o')) { - return p; - } + if (!num && !fmt.precision + && !(fmt.alternate_form && fmt.conversion_char == 'o')) { + return p; + } - switch (fmt->conversion_char) { - case 'd': - case 'i': - base = 10; + switch (fmt.conversion_char) { + case 'd': + case 'i': + base = 10; - if (num < 0) { - unsigned_num = -unsigned_num; - minus = 1; - } - break; - case 'o': - base = 8; - fmt->sign_options = only_minus; - break; - case 'u': - base = 10; - fmt->sign_options = only_minus; - break; - case 'x': - case 'X': - base = 16; - fmt->sign_options = only_minus; - break; - } + if (num < 0) { + unsigned_num = -unsigned_num; + minus = 1; + } + break; + case 'o': + base = 8; + fmt.sign_options = only_minus; + break; + case 'u': + base = 10; + fmt.sign_options = only_minus; + break; + case 'x': + case 'X': + base = 16; + fmt.sign_options = only_minus; + break; + } - do { - n = unsigned_num % base; - unsigned_num /= base; + do { + n = unsigned_num % base; + unsigned_num /= base; - if (n < 10) { - n += '0'; - } else { - n -= 10; - if (fmt->conversion_char == 'x') { - n += 'a'; - } else { - n += 'A'; - } - } + if (n < 10) { + n += '0'; + } else { + n -= 10; + if (fmt.conversion_char == 'x') { + n += 'a'; + } else { + n += 'A'; + } + } - *--p = n; - ++digits; - } while (unsigned_num != 0); + *--p = n; + ++digits; + } while (unsigned_num != 0); - if (base == 8 && fmt->alternate_form && *p != '0') { - *--p = '0'; - ++digits; - } + if (base == 8 && fmt.alternate_form && *p != '0') { + *--p = '0'; + ++digits; + } - if (fmt->justification_options == zero_fill) { - fmt->precision = fmt->field_width; + if (fmt.justification_options == zero_fill) { + fmt.precision = fmt.field_width; - if (minus || fmt->sign_options != only_minus) { - --fmt->precision; - } + if (minus || fmt.sign_options != only_minus) { + --fmt.precision; + } - if (base == 16 && fmt->alternate_form) { - fmt->precision -= 2; - } - } + if (base == 16 && fmt.alternate_form) { + fmt.precision -= 2; + } + } - if (pBuf - p + fmt->precision > 509) { - return 0; - } + if (pBuf - p + fmt.precision > 509) { + return 0; + } - while (digits < fmt->precision) { - *--p = '0'; - ++digits; - } + while (digits < fmt.precision) { + *--p = '0'; + ++digits; + } - if (base == 16 && fmt->alternate_form) { - *--p = fmt->conversion_char; - *--p = '0'; - } + if (base == 16 && fmt.alternate_form) { + *--p = fmt.conversion_char; + *--p = '0'; + } - if (minus) { - *--p = '-'; - } else if (fmt->sign_options == sign_always) { - *--p = '+'; - } else if (fmt->sign_options == space_holder) { - *--p = ' '; - } + if (minus) { + *--p = '-'; + } else if (fmt.sign_options == sign_always) { + *--p = '+'; + } else if (fmt.sign_options == space_holder) { + *--p = ' '; + } - return p; + return p; } +static char * double2hex(long double num, char * buff, print_format format); + static void round_decimal(decimal* dec, int new_length) { - char c; - char* p; - int carry; + char c; + char* p; + int carry; - if (new_length < 0) { - return_zero: - dec->sign = 0; - dec->exp = 0; - dec->sig.length = 1; - *dec->sig.text = '0'; - return; - } + if (new_length < 0) { + return_zero: + dec->exp = 0; + dec->sig.length = 1; + *dec->sig.text = '0'; + return; + } - if (new_length >= dec->sig.length) { - return; - } + if (new_length >= dec->sig.length) { + return; + } - p = (char*)dec->sig.text + new_length + 1; - c = *--p - '0'; + p = (char*)dec->sig.text + new_length + 1; + c = *--p - '0'; - if (c == 5) { - char* q = &((char*)dec->sig.text)[dec->sig.length]; + if (c == 5) { + char* q = &((char*)dec->sig.text)[dec->sig.length]; - while (--q > p && *q == '0') - ; - carry = (q == p) ? p[-1] & 1 : 1; - } else { - carry = (c > 5); - } + while (--q > p && *q == '0') + ; + carry = (q == p) ? p[-1] & 1 : 1; + } else { + carry = (c > 5); + } - while (new_length != 0) { - c = *--p - '0' + carry; + while (new_length != 0) { + c = *--p - '0' + carry; - if ((carry = (c > 9)) != 0 || c == 0) { - --new_length; - } else { - *p = c + '0'; - break; - } - } + if ((carry = (c > 9)) != 0 || c == 0) { + --new_length; + } else { + *p = c + '0'; + break; + } + } - if (carry != 0) { - dec->exp += 1; - dec->sig.length = 1; - *dec->sig.text = '1'; - return; - } else if (new_length == 0) { - goto return_zero; - } + if (carry != 0) { + dec->exp += 1; + dec->sig.length = 1; + *dec->sig.text = '1'; + return; + } else if (new_length == 0) { + goto return_zero; + } - dec->sig.length = new_length; + dec->sig.length = new_length; } -static char* float2str(va_list arg, char* buff, print_format* format, - int vecIndex) -{ - decimal dec; - decform form; - char* p; - char* q; - int n, digits, sign; - int int_digits, frac_digits; - long double num; +static char* float2str(long double num, char *buff, print_format format) { + decimal dec; + decform form; + char* p; + char* q; + int n, digits, sign; + int int_digits, frac_digits; - if (format->argument_options == long_double_argument) { - num = va_arg(arg, long double); - } else { - num = va_arg(arg, double); - } + if (format.precision > 509) { + return 0; + } - if (format->precision > 509) { - return 0; - } + form.style = 0; + form.digits = 0x20; + __num2dec(&form, num, &dec); + p = (char*)dec.sig.text + dec.sig.length; - form.style = 0; - form.digits = 0x20; - __num2dec(&form, num, &dec); - p = (char*)dec.sig.text + dec.sig.length; + while (dec.sig.length > 1 && *--p == '0') { + --dec.sig.length; + ++dec.exp; + } - while (dec.sig.length > 1 && *--p == '0') { - --dec.sig.length; - ++dec.exp; - } + switch (*dec.sig.text) { + case '0': + dec.exp = 0; + break; + case 'I': + if (num < 0) { + p = buff - 5; - switch (*dec.sig.text) { - case '0': - dec.exp = 0; - break; - case 'I': - if (num < 0) { - p = buff - 5; - strcpy(p, "-Inf"); - } else { - p = buff - 4; - strcpy(p, "Inf"); - } + if (isupper(format.conversion_char)) { + strcpy(p, "-INF"); + } + else { + strcpy(p, "-inf"); + } + } + else { + p = buff - 4; + if (isupper(format.conversion_char)) { + strcpy(p, "INF"); + } + else { + strcpy(p, "inf"); + } + } - return p; + return p; - case 'N': - p = buff - 4; - strcpy(p, "NaN"); - return p; - } + case 'N': + if (dec.sign) { + p = buff - 5; - dec.exp += dec.sig.length - 1; - p = buff; - *--p = 0; + if (isupper(format.conversion_char)) { + strcpy(p, "-NAN"); + } + else { + strcpy(p, "-nan"); + } + } + else { + p = buff - 4; + if (isupper(format.conversion_char)) { + strcpy(p, "NAN"); + } + else { + strcpy(p, "nan"); + } + } - switch (format->conversion_char) { - case 'g': - case 'G': + return p; + } - if (dec.sig.length > format->precision) { - round_decimal(&dec, format->precision); - } + dec.exp += dec.sig.length - 1; + p = buff; + *--p = 0; - if (dec.exp < -4 || dec.exp >= format->precision) { - if (format->alternate_form) { - --format->precision; - } else { - format->precision = dec.sig.length - 1; - } + switch (format.conversion_char) + { + case 'g': + case 'G': - if (format->conversion_char == 'g') { - format->conversion_char = 'e'; - } else { - format->conversion_char = 'E'; - } + if (dec.sig.length > format.precision) { + round_decimal(&dec, format.precision); + } - goto e_format; - } + if (dec.exp < -4 || dec.exp >= format.precision) + { + if (format.alternate_form) { + --format.precision; + } + else { + format.precision = dec.sig.length - 1; + } - if (format->alternate_form) { - format->precision -= dec.exp + 1; - } else { - if ((format->precision = dec.sig.length - (dec.exp + 1)) < 0) { - format->precision = 0; - } - } + if (format.conversion_char == 'g') { + format.conversion_char = 'e'; + } + else { + format.conversion_char = 'E'; + } - goto f_format; + goto e_format; + } - case 'e': - case 'E': - e_format: + if (format.alternate_form) { + format.precision -= dec.exp + 1; + } + else { + if ((format.precision = dec.sig.length - (dec.exp + 1)) < 0) { + format.precision = 0; + } + } - if (dec.sig.length > format->precision + 1) { - round_decimal(&dec, format->precision + 1); - } + goto f_format; - n = dec.exp; - sign = '+'; + case 'e': + case 'E': + e_format: - if (n < 0) { - n = -n; - sign = '-'; - } + if (dec.sig.length > format.precision + 1) { + round_decimal(&dec, format.precision + 1); + } - for (digits = 0; n || digits < 2; ++digits) { - *--p = n % 10 + '0'; - n /= 10; - } + n = dec.exp; + sign = '+'; - *--p = sign; - *--p = format->conversion_char; + if (n < 0) { + n = -n; + sign = '-'; + } - if (buff - p + format->precision > 509) { - return 0; - } + for (digits = 0; n || digits < 2; ++digits) { + *--p = n % 10 + '0'; + n /= 10; + } - if (dec.sig.length < format->precision + 1) { - for (n = format->precision + 1 - dec.sig.length + 1; --n;) { - *--p = '0'; - } - } + *--p = sign; + *--p = format.conversion_char; - for (n = dec.sig.length, q = (char*)dec.sig.text + dec.sig.length; - --n;) { - *--p = *--q; - } + if (buff - p + format.precision > 509) { + return 0; + } - if (format->precision || format->alternate_form) { - *--p = '.'; - } + if (dec.sig.length < format.precision + 1) { + for (n = format.precision + 1 - dec.sig.length + 1; --n;) { + *--p = '0'; + } + } - *--p = *dec.sig.text; + for (n = dec.sig.length, q = (char*)dec.sig.text + dec.sig.length; --n;) { + *--p = *--q; + } - if (dec.sign) - *--p = '-'; - else if (format->sign_options == sign_always) - *--p = '+'; - else if (format->sign_options == space_holder) - *--p = ' '; + if (format.precision || format.alternate_form) { + *--p = '.'; + } - break; + *--p = *dec.sig.text; - case 'f': - f_format: + if (dec.sign) + *--p = '-'; + else if (format.sign_options == sign_always) + *--p = '+'; + else if (format.sign_options == space_holder) + *--p = ' '; - if ((frac_digits = -dec.exp + dec.sig.length - 1) < 0) - frac_digits = 0; + break; - if (frac_digits > format->precision) { - round_decimal(&dec, - dec.sig.length - (frac_digits - format->precision)); + case 'f': + case 'F': + f_format: - if ((frac_digits = -dec.exp + dec.sig.length - 1) < 0) - frac_digits = 0; - } + if ((frac_digits = -dec.exp + dec.sig.length - 1) < 0) + frac_digits = 0; - if ((int_digits = dec.exp + 1) < 0) - int_digits = 0; + if (frac_digits > format.precision) { + round_decimal(&dec, dec.sig.length - (frac_digits - format.precision)); - if (int_digits + frac_digits > 509) - return 0; + if ((frac_digits = -dec.exp + dec.sig.length - 1) < 0) + frac_digits = 0; + } - q = (char*)dec.sig.text + dec.sig.length; + if ((int_digits = dec.exp + 1) < 0) + int_digits = 0; - for (digits = 0; digits < (format->precision - frac_digits); ++digits) - *--p = '0'; + if (int_digits + frac_digits > 509) + return 0; - for (digits = 0; digits < frac_digits && digits < dec.sig.length; - ++digits) - *--p = *--q; + q = (char *) dec.sig.text + dec.sig.length; - for (; digits < frac_digits; ++digits) - *--p = '0'; + for (digits = 0; digits < (format.precision - frac_digits); ++digits) + *--p = '0'; - if (format->precision || format->alternate_form) - *--p = '.'; + for (digits = 0; digits < frac_digits && digits < dec.sig.length; ++digits) + *--p = *--q; - if (int_digits) { - for (digits = 0; digits < int_digits - dec.sig.length; ++digits) { - *--p = '0'; - } + for (; digits < frac_digits; ++digits) + *--p = '0'; - for (; digits < int_digits; ++digits) { - *--p = *--q; - } - } else { - *--p = '0'; - } + if (format.precision || format.alternate_form) + *--p = '.'; - if (dec.sign) { - *--p = '-'; - } else if (format->sign_options == sign_always) { - *--p = '+'; - } else if (format->sign_options == space_holder) { - *--p = ' '; - } + if (int_digits) { + for (digits = 0; digits < int_digits - dec.sig.length; ++digits) { + *--p = '0'; + } - break; - } + for (; digits < int_digits; ++digits) { + *--p = *--q; + } + } + else { + *--p = '0'; + } - return p; + if (dec.sign) { + *--p = '-'; + } + else if (format.sign_options == sign_always) { + *--p = '+'; + } + else if (format.sign_options == space_holder) { + *--p = ' '; + } + + break; + } + + return p; } -static int __pformatter(void* (*WriteProc)(void*, const char*, size_t), - void* WriteProcArg, const char* format_str, va_list arg) -{ - int num_chars, chars_written, field_width; - const char* format_ptr; - const char* curr_format; - print_format format; - signed long long_num; - signed long long long_long_num; - char buff[512]; - char* buff_ptr; - char* string_end; - char fill_char = ' '; +static int __pformatter(void *(*WriteProc)(void *, const char *, size_t), void *WriteProcArg, const char * format_str, va_list arg) { + int num_chars, chars_written, field_width; + const char* format_ptr; + const char* curr_format; + print_format format; + long long_num; + long long long_long_num; + long double long_double_num; + char buff[512]; + char* buff_ptr; + char* string_end; + char fill_char = ' '; - format_ptr = format_str; - chars_written = 0; + format_ptr = format_str; + chars_written = 0; - while (*format_ptr) { - if (!(curr_format = strchr(format_ptr, '%'))) { - num_chars = strlen(format_ptr); - chars_written += num_chars; + while (*format_ptr) { + if (!(curr_format = strchr(format_ptr, '%'))) { + num_chars = strlen(format_ptr); + chars_written += num_chars; - if (num_chars - && !(*WriteProc)(WriteProcArg, format_ptr, num_chars)) { - return -1; - } + if (num_chars && !(*WriteProc)(WriteProcArg, format_ptr, num_chars)) { + return -1; + } - break; - } + break; + } - num_chars = curr_format - format_ptr; - chars_written += num_chars; + num_chars = curr_format - format_ptr; + chars_written += num_chars; - if (num_chars && !(*WriteProc)(WriteProcArg, format_ptr, num_chars)) { - return -1; - } + if (num_chars && !(*WriteProc)(WriteProcArg, format_ptr, num_chars)) { + return -1; + } - format_ptr = curr_format; - format_ptr = parse_format(format_ptr, (va_list*)arg, &format); + format_ptr = curr_format; + format_ptr = parse_format(format_ptr, (va_list*)arg, &format); - switch (format.conversion_char) { - case 'd': - case 'i': - if (format.argument_options == long_argument) { - long_num = va_arg(arg, signed long); - } else if (format.argument_options == long_long_argument) { - long_long_num = va_arg(arg, signed long long); - } else { - long_num = va_arg(arg, int); - } + switch (format.conversion_char) { + case 'd': + case 'i': + if (format.argument_options == long_argument) { + long_num = va_arg(arg, long); + } + else if (format.argument_options == long_long_argument) { + long_long_num = va_arg(arg, long long); + } + else { + long_num = va_arg(arg, int); + } - if (format.argument_options == short_argument) { - long_num = (signed short)long_num; - } + if (format.argument_options == short_argument) { + long_num = (short)long_num; + } - if (format.argument_options == char_argument) { - long_num = (signed char)long_num; - } + if (format.argument_options == char_argument) { + long_num = (signed char)long_num; + } - if (format.argument_options == long_long_argument) { - if (!(buff_ptr - = longlong2str(long_long_num, buff + 512, &format))) { - goto conversion_error; - } - } else { - if (!(buff_ptr = long2str(long_num, buff + 512, &format))) { - goto conversion_error; - } - } + if (format.argument_options == long_long_argument) { + if (!(buff_ptr = longlong2str(long_long_num, buff + 512, format))) { + goto conversion_error; + } + } + else { + if (!(buff_ptr = long2str(long_num, buff + 512, format))) { + goto conversion_error; + } + } - num_chars = buff + 512 - 1 - buff_ptr; - break; + num_chars = buff + 512 - 1 - buff_ptr; + break; - case 'o': - case 'u': - case 'x': - case 'X': - if (format.argument_options == long_argument) { - long_num = va_arg(arg, unsigned long); - } else if (format.argument_options == long_long_argument) { - long_long_num = va_arg(arg, signed long long); - } else { - long_num = va_arg(arg, unsigned int); - } + case 'o': + case 'u': + case 'x': + case 'X': + if (format.argument_options == long_argument) { + long_num = va_arg(arg, unsigned long); + } + else if (format.argument_options == long_long_argument) { + long_long_num = va_arg(arg, long long); + } + else { + long_num = va_arg(arg, unsigned int); + } - if (format.argument_options == short_argument) { - long_num = (unsigned short)long_num; - } + if (format.argument_options == short_argument) { + long_num = (unsigned short)long_num; + } - if (format.argument_options == char_argument) { - long_num = (unsigned char)long_num; - } + if (format.argument_options == char_argument) { + long_num = (unsigned char)long_num; + } - if (format.argument_options == long_long_argument) { - if (!(buff_ptr - = longlong2str(long_long_num, buff + 512, &format))) { - goto conversion_error; - } - } else { - if (!(buff_ptr = long2str(long_num, buff + 512, &format))) { - goto conversion_error; - } - } + if (format.argument_options == long_long_argument) { + if (!(buff_ptr = longlong2str(long_long_num, buff + 512, format))) { + goto conversion_error; + } + } + else { + if (!(buff_ptr = long2str(long_num, buff + 512, format))) { + goto conversion_error; + } + } - num_chars = buff + 512 - 1 - buff_ptr; - break; + num_chars = buff + 512 - 1 - buff_ptr; + break; - case 'f': - case 'e': - case 'E': - case 'g': - case 'G': - if (!(buff_ptr = float2str(arg, buff + 512, &format, 0))) { - goto conversion_error; - } + case 'f': + case 'F': + case 'e': + case 'E': + case 'g': + case 'G': + if (format.argument_options == long_double_argument) { + long_double_num = va_arg(arg, long double); + } + else { + long_double_num = va_arg(arg, double); + } - num_chars = buff + 512 - 1 - buff_ptr; - break; + if (!(buff_ptr = float2str(long_double_num, buff + 512, format))) { + goto conversion_error; + } - case 's': - if (format.argument_options == wchar_argument) { - wchar_t* wcs_ptr = va_arg(arg, wchar_t*); + num_chars = buff + 512 - 1 - buff_ptr; + break; - if (wcs_ptr == NULL) { - wcs_ptr = L""; - } + case 'a': + case 'A': + if (format.argument_options == long_double_argument) { + long_double_num = va_arg(arg, long double); + } + else { + long_double_num = va_arg(arg, double); + } - if ((num_chars = wcstombs(buff, wcs_ptr, sizeof(buff))) < 0) { - goto conversion_error; - } + if (!(buff_ptr = double2hex(long_double_num, buff + 512, format))) { + goto conversion_error; + } - buff_ptr = &buff[0]; - } else { - buff_ptr = va_arg(arg, char*); - } + num_chars = buff + 512 - 1 - buff_ptr; + break; - if (buff_ptr == NULL) { - buff_ptr = ""; - } + case 's': + if (format.argument_options == wchar_argument) { + wchar_t* wcs_ptr = va_arg(arg, wchar_t*); - if (format.alternate_form) { - num_chars = (unsigned char)*buff_ptr++; + if(wcs_ptr == NULL){ + wcs_ptr = L""; + } - if (format.precision_specified - && num_chars > format.precision) { - num_chars = format.precision; - } - } else if (format.precision_specified) { - num_chars = format.precision; + if ((num_chars = wcstombs(buff, wcs_ptr, sizeof(buff))) < 0) { + goto conversion_error; + } - if ((string_end - = (char*)memchr((unsigned char*)buff_ptr, 0, num_chars)) - != 0) { - num_chars = string_end - buff_ptr; - } - } else { - num_chars = strlen(buff_ptr); - } + buff_ptr = &buff[0]; + } + else { + buff_ptr = va_arg(arg, char *); + } - break; + if (buff_ptr == NULL) { + buff_ptr = ""; + } - case 'n': - buff_ptr = va_arg(arg, char*); + if (format.alternate_form) { + num_chars = (unsigned char)*buff_ptr++; - switch (format.argument_options) { - case normal_argument: - *(int*)buff_ptr = chars_written; - break; - case short_argument: - *(signed short*)buff_ptr = chars_written; - break; - case long_argument: - *(signed long*)buff_ptr = chars_written; - break; - case long_long_argument: - *(signed long long*)buff_ptr = chars_written; - break; - } + if (format.precision_specified && num_chars > format.precision) { + num_chars = format.precision; + } + } + else if (format.precision_specified) { + num_chars = format.precision; - continue; + if ((string_end = (char*)memchr((unsigned char*)buff_ptr, 0, num_chars)) != 0) { + num_chars = string_end - buff_ptr; + } + } + else { + num_chars = strlen(buff_ptr); + } - case 'c': - buff_ptr = buff; - *buff_ptr = va_arg(arg, int); - num_chars = 1; - break; + break; - case '%': - buff_ptr = buff; - *buff_ptr = '%'; - num_chars = 1; - break; + case 'n': + buff_ptr = va_arg(arg, char *); - case 0xFF: - default: - conversion_error: - num_chars = strlen(curr_format); - chars_written += num_chars; + switch (format.argument_options) { + case normal_argument: + *(int*)buff_ptr = chars_written; + break; + case short_argument: + *(short*)buff_ptr = chars_written; + break; + case long_argument: + *(long*)buff_ptr = chars_written; + break; + case long_long_argument: + *(long long*)buff_ptr = chars_written; + break; + } - if (num_chars - && !(*WriteProc)(WriteProcArg, curr_format, num_chars)) { - return -1; - } + continue; - return chars_written; - break; - } + case 'c': + buff_ptr = buff; + *buff_ptr = va_arg(arg, int); + num_chars = 1; + break; - field_width = num_chars; + case '%': + buff_ptr = buff; + *buff_ptr = '%'; + num_chars = 1; + break; - if (format.justification_options != left_justification) { - fill_char = (format.justification_options == zero_fill) ? '0' : ' '; + case 0xFF: + default: + conversion_error: + num_chars = strlen(curr_format); + chars_written += num_chars; - if (((*buff_ptr == '+') || (*buff_ptr == '-')) - && (fill_char == '0')) { - if ((*WriteProc)(WriteProcArg, buff_ptr, 1) == 0) { - return -1; - } + if (num_chars && !(*WriteProc)(WriteProcArg, curr_format, num_chars)) { + return -1; + } - ++buff_ptr; - num_chars--; - } + return chars_written; + break; + } - while (field_width < format.field_width) { - if ((*WriteProc)(WriteProcArg, &fill_char, 1) == 0) { - return -1; - } + field_width = num_chars; - ++field_width; - } - } + if (format.justification_options != left_justification) { + fill_char = (format.justification_options == zero_fill) ? '0' : ' '; - if (num_chars && !(*WriteProc)(WriteProcArg, buff_ptr, num_chars)) { - return -1; - } + if (((*buff_ptr == '+') || (*buff_ptr == '-') || (*buff_ptr == ' ')) && (fill_char == '0')) { + if ((*WriteProc)(WriteProcArg, buff_ptr, 1) == 0) { + return -1; + } - if (format.justification_options == left_justification) { - while (field_width < format.field_width) { - char blank = ' '; + ++buff_ptr; + num_chars--; + } - if ((*WriteProc)(WriteProcArg, &blank, 1) == 0) { - return -1; - } + while (field_width < format.field_width) { + if ((*WriteProc)(WriteProcArg, &fill_char, 1) == 0) { + return -1; + } - ++field_width; - } - } + ++field_width; + } + } - chars_written += field_width; - } + if (num_chars && !(*WriteProc)(WriteProcArg, buff_ptr, num_chars)) { + return -1; + } - return chars_written; + if (format.justification_options == left_justification) { + while (field_width < format.field_width) { + char blank = ' '; + + if ((*WriteProc)(WriteProcArg, &blank, 1) == 0) { + return -1; + } + + ++field_width; + } + } + + chars_written += field_width; + } + + return chars_written; } -static void* __FileWrite(void* pFile, const char* pBuffer, size_t char_num) +void* __FileWrite(void* pFile, const char* pBuffer, size_t char_num) { - return (fwrite(pBuffer, 1, char_num, (FILE*)pFile) == char_num ? pFile : 0); + return (fwrite(pBuffer, 1, char_num, (FILE*)pFile) == char_num ? pFile : 0); } -static void* __StringWrite(void* pCtrl, const char* pBuffer, size_t char_num) +void* __StringWrite(void* pCtrl, const char* pBuffer, size_t char_num) { - size_t chars; - __OutStrCtrl* ctrl = (__OutStrCtrl*)pCtrl; - void* res; + size_t chars; + __OutStrCtrl* ctrl = (__OutStrCtrl*)pCtrl; - chars = ((ctrl->CharsWritten + char_num) <= ctrl->MaxCharCount) - ? char_num - : ctrl->MaxCharCount - ctrl->CharsWritten; - res = memcpy(ctrl->CharStr + ctrl->CharsWritten, pBuffer, chars); - ctrl->CharsWritten += chars; - return res; + chars = ((ctrl->CharsWritten + char_num) <= ctrl->MaxCharCount) + ? char_num + : ctrl->MaxCharCount - ctrl->CharsWritten; + memcpy(ctrl->CharStr + ctrl->CharsWritten, pBuffer, chars); + ctrl->CharsWritten += chars; + return (void*) 1; } int printf(const char* format, ...) { - int res; + int res; - if (fwide(stdout, -1) >= 0) { - return -1; - } + if (fwide(stdout, -1) >= 0) { + return -1; + } - { - va_list args; - va_start(args, format); - res = __pformatter(&__FileWrite, (void*)stdout, format, args); - } + { + va_list args; + va_start(args, format); + res = __pformatter(&__FileWrite, (void*)stdout, format, args); + } - return res; + return res; } int vprintf(const char* format, va_list arg) { - int ret; + int ret; - if (fwide(stdout, -1) >= 0) { - return -1; - } + if (fwide(stdout, -1) >= 0) { + return -1; + } - ret = __pformatter(&__FileWrite, (void*)stdout, format, arg); - return ret; + ret = __pformatter(&__FileWrite, (void*)stdout, format, arg); + return ret; } int vsnprintf(char* s, size_t n, const char* format, va_list arg) { - int end; - __OutStrCtrl osc; - osc.CharStr = s; - osc.MaxCharCount = n; - osc.CharsWritten = 0; + int end; + __OutStrCtrl osc; + osc.CharStr = s; + osc.MaxCharCount = n; + osc.CharsWritten = 0; - end = __pformatter(&__StringWrite, &osc, format, arg); + end = __pformatter(&__StringWrite, &osc, format, arg); - s[(end < n) ? end : n - 1] = '\0'; + if (s) { + s[(end < n) ? end : n - 1] = '\0'; + } - return end; + return end; } -int snprintf(char* s, size_t n, const char* format, ...) -{ - va_list args; - va_start(args, format); - return vsnprintf(s, n, format, args); +int vsprintf(char *s, const char *format, va_list arg) { + return vsnprintf(s, 0xFFFFFFFF, format, arg); } int sprintf(char* s, const char* format, ...) { - va_list args; - va_start(args, format); - return vsnprintf(s, 0xFFFFFFFF, format, args); + va_list args; + va_start(args, format); + return vsnprintf(s, 0xFFFFFFFF, format, args); } diff --git a/src/MSL_C.PPCEABI.bare.H/s_floor.c b/src/MSL_C.PPCEABI.bare.H/s_floor.c new file mode 100755 index 00000000..70001539 --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/s_floor.c @@ -0,0 +1,78 @@ +/* @(#)s_floor.c 1.3 95/01/18 */ +/* + * ==================================================== + * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + * + * Developed at SunSoft, a Sun Microsystems, Inc. business. + * Permission to use, copy, modify, and distribute this + * software is freely granted, provided that this notice + * is preserved. + * ==================================================== + */ + +/* + * floor(x) + * Return x rounded toward -inf to integral value + * Method: + * Bit twiddling. + * Exception: + * Inexact flag raised if x not equal to floor(x). + */ + +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common_Embedded/Math/fdlibm.h" + +#ifdef __STDC__ +static const double huge = 1.0e300; +#else +static double huge = 1.0e300; +#endif + +#ifdef __STDC__ + double floor(double x) +#else + double floor(x) + double x; +#endif +{ + int i0,i1,j0; + unsigned i,j; + i0 = __HI(x); + i1 = __LO(x); + j0 = ((i0>>20)&0x7ff)-0x3ff; + if(j0<20) { + if(j0<0) { /* raise inexact if x != 0 */ + if(huge+x>0.0) {/* return 0*sign(x) if |x|<1 */ + if(i0>=0) {i0=i1=0;} + else if(((i0&0x7fffffff)|i1)!=0) + { i0=0xbff00000;i1=0;} + } + } else { + i = (0x000fffff)>>j0; + if(((i0&i)|i1)==0) return x; /* x is integral */ + if(huge+x>0.0) { /* raise inexact flag */ + if(i0<0) i0 += (0x00100000)>>j0; + i0 &= (~i); i1=0; + } + } + } else if (j0>51) { + if(j0==0x400) return x+x; /* inf or NaN */ + else return x; /* x is integral */ + } else { + i = ((unsigned)(0xffffffff))>>(j0-20); + if((i1&i)==0) return x; /* x is integral */ + if(huge+x>0.0) { /* raise inexact flag */ + if(i0<0) { + if(j0==20) i0+=1; + else { + j = i1+(1<<(52-j0)); + if(j>20; /* extract exponent */ + if (k==0) { /* 0 or subnormal x */ + if ((lx|(hx&0x7fffffff))==0) return x; /* +-0 */ + x *= two54; + hx = __HI(x); + k = ((hx&0x7ff00000)>>20) - 54; + if (n< -50000) return tiny*x; /*underflow*/ + } + if (k==0x7ff) return x+x; /* NaN or Inf */ + k = k+n; + if (k > 0x7fe) return huge*copysign(huge,x); /* overflow */ + if (k > 0) /* normal result */ + {__HI(x) = (hx&0x800fffff)|(k<<20); return x;} + if (k <= -54) + if (n > 50000) /* in case integer overflow in n+k */ + return huge*copysign(huge,x); /*overflow*/ + else return tiny*copysign(tiny,x); /*underflow*/ + k += 54; /* subnormal result */ + __HI(x) = (hx&0x800fffff)|(k<<20); + return x*twom54; } diff --git a/src/MSL_C.PPCEABI.bare.H/signal.c b/src/MSL_C.PPCEABI.bare.H/signal.c new file mode 100755 index 00000000..3967650d --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/signal.c @@ -0,0 +1,24 @@ +#include +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/signal.h" + +__signal_func_ptr signal_funcs[6]; + +int raise(int sig) { + __signal_func_ptr temp_r31; + + if (sig < 1 || sig > 6) { + return -1; + } + temp_r31 = signal_funcs[sig - 1]; + if ((unsigned long) temp_r31 != 1) { + signal_funcs[sig - 1] = NULL; + } + if ((unsigned long) temp_r31 == 1 || (temp_r31 == NULL && sig == 1)) { + return 0; + } + if (temp_r31 == NULL) { + exit(0); + } + temp_r31(sig); + return 0; +} diff --git a/src/MSL_C.PPCEABI.bare.H/string.c b/src/MSL_C.PPCEABI.bare.H/string.c index 4fbb776f..895f6662 100644 --- a/src/MSL_C.PPCEABI.bare.H/string.c +++ b/src/MSL_C.PPCEABI.bare.H/string.c @@ -1,8 +1,8 @@ #include "string.h" #include "stddef.h" -static int K1 = 0x80808080; -static int K2 = 0xFEFEFEFF; +#define K1 0x80808080 +#define K2 0xFEFEFEFF size_t strlen(const char* str) { @@ -20,8 +20,6 @@ char* strcpy(char* dst, const char* src) { register unsigned char *destb, *fromb; register unsigned long w, t, align; - register unsigned int k1; - register unsigned int k2; fromb = (unsigned char*)src; destb = (unsigned char*)dst; @@ -44,14 +42,11 @@ char* strcpy(char* dst, const char* src) ++fromb; } - k1 = K1; - k2 = K2; - w = *((int*)(fromb)); - t = w + k2; + t = w + K2; - t &= k1; + t &= K1; if (t) { goto bytecopy; } @@ -61,8 +56,8 @@ char* strcpy(char* dst, const char* src) *(++((int*)(destb))) = w; w = *(++((int*)(fromb))); - t = w + k2; - t &= k1; + t = w + K2; + t &= K1; if (t) { goto adjust; } @@ -103,16 +98,21 @@ char* strncpy(char* dst, const char* src, size_t n) return dst; } -char* strcat(char* dst, const char* src) +// TODO: same implementation as strncpy? +char* strcat(char* dst, const char* src, size_t n) { - const unsigned char* p = (unsigned char*)src - 1; + const unsigned char* p = (const unsigned char*)src - 1; unsigned char* q = (unsigned char*)dst - 1; - while (*++q) { } - - q--; - - while (*++q = *++p) { } + n++; + while (--n) { + if (!(*++q = *++p)) { + while (--n) { + *++q = 0; + } + break; + } + } return dst; } @@ -196,6 +196,22 @@ bytecopy: } while (1); } +int strncmp(const char* str1, const char* str2, size_t n) +{ + const unsigned char* p1 = (unsigned char*)str1 - 1; + const unsigned char* p2 = (unsigned char*)str2 - 1; + unsigned long c1, c2; + + n++; + + while (--n) + if ((c1 = *++p1) != (c2 = *++p2)) + return (c1 - c2); + else if (!c1) + break; + return 0; +} + char* strchr(const char* str, int c) { const unsigned char* p = (unsigned char*)str - 1; diff --git a/src/MSL_C.PPCEABI.bare.H/uart_console_io.c b/src/MSL_C.PPCEABI.bare.H/uart_console_io.c new file mode 100755 index 00000000..e26388da --- /dev/null +++ b/src/MSL_C.PPCEABI.bare.H/uart_console_io.c @@ -0,0 +1,32 @@ +#include "PowerPC_EABI_Support/Msl/MSL_C/MSL_Common/ansi_files.h" + +static inline int __init_uart_console(void) { + int err = 0; + static int initialized = 0; + + if (initialized == 0) { + err = InitializeUART(57600); + if (err == 0) + initialized = 1; + } + + return (err); +} + +int __write_console(__file_handle handle, unsigned char* buffer, size_t* count, __idle_proc idle_proc) { + if (__init_uart_console() != 0) { + return 1; + } + + if (WriteUARTN(buffer, *count) != 0) { + *count = 0; + return 1; + } + + __TRK_write_console(handle, buffer, count, idle_proc); + return 0; +} + +int __close_console() { + return 0; +} diff --git a/src/MSL_C.PPCEABI.bare.H/wchar_io.c b/src/MSL_C.PPCEABI.bare.H/wchar_io.c index 4d5d32b5..77f4b5fa 100644 --- a/src/MSL_C.PPCEABI.bare.H/wchar_io.c +++ b/src/MSL_C.PPCEABI.bare.H/wchar_io.c @@ -2,7 +2,7 @@ int fwide(FILE* file, int mode) { - if (file->file_mode.file_kind == __closed_file) { + if (!file || file->file_mode.file_kind == __closed_file) { return 0; } diff --git a/src/REL/m408Dll/camera.c b/src/REL/m408Dll/camera.c index d0f693ea..370848c4 100644 --- a/src/REL/m408Dll/camera.c +++ b/src/REL/m408Dll/camera.c @@ -449,15 +449,15 @@ void fn_1_A37C(ModelData *model, ParticleData *particle, Mtx matrix) else { temp_r31 = particle->unk_48; for (temp_r29 = 0; temp_r29 < particle->unk_30; temp_r29++, temp_r31++) { - if (temp_r31->unk00_s16) { + if (temp_r31->unk00) { temp_r31->unk34.x += temp_r31->unk08.x; temp_r31->unk34.y += temp_r31->unk08.y; temp_r31->unk34.z += temp_r31->unk08.z; temp_r31->unk2C += temp_r31->unk14.x; temp_r31->unk14.y -= temp_r31->unk14.z; temp_r31->unk40.a = temp_r31->unk14.y; - if (--temp_r31->unk00_s16 == 0) { - temp_r31->unk00_s16 = 0; + if (--temp_r31->unk00 == 0) { + temp_r31->unk00 = 0; temp_r31->unk2C = 0; temp_r31->unk40.a = 0; } @@ -477,10 +477,10 @@ void fn_1_A4E8(s32 arg0, Vec *arg1, u32 arg2) if (temp_r30->unk_00) { temp_r31 = temp_r30->unk_48; for (temp_r29 = 0; temp_r29 < temp_r30->unk_30; temp_r29++, temp_r31++) { - if (temp_r31->unk00_s16 != 0) { + if (temp_r31->unk00 != 0) { continue; } - temp_r31->unk00_s16 = 60.0f * (((1.5f / 1000.0f) * frandmod(1000)) + 1.0f); + temp_r31->unk00 = 60.0f * (((1.5f / 1000.0f) * frandmod(1000)) + 1.0f); temp_r31->unk34.x = arg1->x; temp_r31->unk34.y = 12000; temp_r31->unk34.z = arg1->z; @@ -491,7 +491,7 @@ void fn_1_A4E8(s32 arg0, Vec *arg1, u32 arg2) temp_r31->unk2C = 10; temp_r31->unk40.a = frandmod(127) + 64; temp_r31->unk14.y = temp_r31->unk40.a; - temp_r31->unk14.z = temp_r31->unk14.y * (1.0f / temp_r31->unk00_s16); + temp_r31->unk14.z = temp_r31->unk14.y * (1.0f / temp_r31->unk00); temp_f31 = frandmod(1000) * (1.0f / 1000.0f); temp_r31->unk40.r = (temp_f31 * 55) + 200; temp_r31->unk40.g = (temp_f31 * 50) + 205; @@ -549,7 +549,7 @@ void fn_1_A894(ModelData *model, ParticleData *particle, Mtx matrix) else { temp_r31 = particle->unk_48; for (temp_r29 = 0; temp_r29 < particle->unk_30; temp_r29++, temp_r31++) { - if (temp_r31->unk00_s16 == 0) { + if (temp_r31->unk00 == 0) { continue; } sp8.x = sind(CRot.y) * cosd(CRot.x); @@ -649,7 +649,7 @@ void fn_1_AFF4(ModelData *model, ParticleData *particle, Mtx matrix) temp_r30 = particle->unk_48; temp_f30 = 0; for (temp_r29 = 0; temp_r29 < particle->unk_30; temp_r29++, temp_r30++) { - if (temp_r30->unk00_s16 == 0) { + if (temp_r30->unk00 == 0) { continue; } temp_f30 += 1.0f / particle->unk_30; @@ -751,15 +751,15 @@ void fn_1_BDE0(void) Vec sp14; Vec sp8; temp_r31 = lbl_1_bss_A4[0]; - temp_r31->unk00_s16++; - if (temp_r31->unk00_s16 < 339.0f) { + temp_r31->unk00++; + if (temp_r31->unk00 < 339.0f) { return; } - if (temp_r31->unk00_s16 >= 600.0f) { - temp_r31->unk00_s16 = 601; + if (temp_r31->unk00 >= 600.0f) { + temp_r31->unk00 = 601; for (temp_r30 = 0; temp_r30 < lbl_1_bss_A0; temp_r30++) { temp_r31 = lbl_1_bss_A4[temp_r30]; - temp_r31->unk00_s16 = 0; + temp_r31->unk00 = 0; temp_r31->unk2C = 0; temp_r31->unk40.a = 0; } diff --git a/src/REL/m408Dll/main.c b/src/REL/m408Dll/main.c index 38ab51b1..7494d1eb 100644 --- a/src/REL/m408Dll/main.c +++ b/src/REL/m408Dll/main.c @@ -1127,7 +1127,7 @@ void fn_1_5AB4(ModelData *model, ParticleData *particle, Mtx matrix) } temp_r31 = particle->unk_48; for (temp_r29 = 0; temp_r29 < particle->unk_30; temp_r29++, temp_r31++) { - if (temp_r31->unk00_s16 == 0 || temp_r31->unk00_s16 != 1) { + if (temp_r31->unk00 == 0 || temp_r31->unk00 != 1) { continue; } temp_r31->unk02++; @@ -1163,7 +1163,7 @@ void fn_1_5DCC(s32 arg0, Vec *arg1, u32 arg2) if (temp_r29->unk_00 != 0) { temp_r31 = temp_r29->unk_48; for (temp_r28 = 0; temp_r28 < temp_r29->unk_30; temp_r28++, temp_r31++) { - if (temp_r31->unk00_s16) { + if (temp_r31->unk00) { continue; } temp_r31->unk00 = 1; diff --git a/src/REL/m408Dll/object.c b/src/REL/m408Dll/object.c index 817ec9e3..a7db6c04 100644 --- a/src/REL/m408Dll/object.c +++ b/src/REL/m408Dll/object.c @@ -1332,8 +1332,8 @@ void fn_1_15658(ModelData *model, ParticleData *particle, Mtx matrix) } temp_r31->unk40.a = temp_r29; } - temp_r31->unk00_s16--; - if (temp_r31->unk00_s16 <= 0) { + temp_r31->unk00--; + if (temp_r31->unk00 <= 0) { temp_r31->unk2C = 0; } } @@ -1501,8 +1501,8 @@ void fn_1_15D64(ModelData *model, ParticleData *particle, Mtx matrix) } temp_r31->unk40.a = temp_r28; } - temp_r31->unk00_s16--; - if (temp_r31->unk00_s16 <= 0) { + temp_r31->unk00--; + if (temp_r31->unk00 <= 0) { temp_r31->unk2C = 0; } } diff --git a/src/REL/m408Dll/stage.c b/src/REL/m408Dll/stage.c index 06fc40fb..71b8bafd 100644 --- a/src/REL/m408Dll/stage.c +++ b/src/REL/m408Dll/stage.c @@ -413,7 +413,7 @@ s16 fn_1_D978(AnimData *arg0, s16 arg1, ParticleHook arg2) } temp_r30 = HuMemDirectMallocNum(HEAP_SYSTEM, sizeof(HsfanimStruct01), MEMORY_DEFAULT_NUM); temp_r29->unk_1C = temp_r30; - temp_r30->unk00_s16 = temp_r28; + temp_r30->unk00 = temp_r28; temp_r30->unk02 = 0; for (temp_r31 = 0; temp_r31 < 32; temp_r31++) { // Ugly expression to match store without new type @@ -449,7 +449,7 @@ void fn_1_DA6C(ModelData *model, ParticleData *particle, Mtx matrix) for (temp_r28 = 0; temp_r28 < 100; temp_r28++) { temp_r31 = particle->unk_48; for (temp_r27 = 0; temp_r27 < particle->unk_30; temp_r27++, temp_r31++) { - if (!temp_r31->unk00_s16) { + if (!temp_r31->unk00) { break; } } @@ -472,13 +472,13 @@ void fn_1_DA6C(ModelData *model, ParticleData *particle, Mtx matrix) temp_r31->unk2C = (0.01 * (frand() % 2000)) + 30.0; temp_r31->unk2C *= 0.1f; temp_r31->unk40.a = 255; - temp_r31->unk00_s16 = 30; + temp_r31->unk00 = 30; } break; } temp_r31 = particle->unk_48; for (temp_r28 = 0; temp_r28 < particle->unk_30; temp_r28++, temp_r31++) { - if (temp_r31->unk00_s16 == 0) { + if (temp_r31->unk00 == 0) { continue; } temp_f30 = temp_r31->unk14.x; @@ -493,7 +493,7 @@ void fn_1_DA6C(ModelData *model, ParticleData *particle, Mtx matrix) temp_r31->unk08.y += 0.1f; if (temp_r31->unk40.a < 2) { temp_r31->unk40.a = 0; - temp_r31->unk00_s16 = 0; + temp_r31->unk00 = 0; particle->unk_00++; } } @@ -566,7 +566,7 @@ void fn_1_E310(ModelData *model, ParticleData *particle, Mtx matrix) temp_f30 = 360.0f / particle->unk_30; for (temp_r28 = 0; temp_r28 < particle->unk_30; temp_r28++, temp_r31++) { - temp_r31->unk00_s16 = (s32)(360.0 * ((1.0 / 65536.0) * (float)fn_1_11670())); + temp_r31->unk00 = (s32)(360.0 * ((1.0 / 65536.0) * (float)fn_1_11670())); temp_r31->unk34.x = temp_r31->unk34.y = temp_r31->unk34.z = 0; temp_r26 = (temp_f30 * temp_r28) + (int)((temp_f30 * 0.5f) * ((1.0 / 32768.0) * (float)(fn_1_11670() - 32768))); temp_r31->unk20 = temp_r26; @@ -598,15 +598,15 @@ void fn_1_E310(ModelData *model, ParticleData *particle, Mtx matrix) case 1: temp_r31 = particle->unk_48; for (temp_r28 = 0; temp_r28 < particle->unk_30; temp_r28++, temp_r31++) { - temp_r31->unk00_s16 += 4; - if (temp_r31->unk00_s16 >= 360) { - temp_r31->unk00_s16 -= 360; + temp_r31->unk00 += 4; + if (temp_r31->unk00 >= 360) { + temp_r31->unk00 -= 360; } temp_r31->unk34.x = temp_r31->unk14.x; temp_r31->unk34.y = temp_r31->unk14.y; temp_r31->unk34.z = temp_r31->unk14.z; temp_r31->unk30 = M_PI * (90 + (temp_r31->unk20 + temp_r29->unk_04.z)) / 180; - temp_r31->unk2C = temp_r31->unk24 * ((0.1f * sind(temp_r31->unk00_s16)) + 1.0); + temp_r31->unk2C = temp_r31->unk24 * ((0.1f * sind(temp_r31->unk00)) + 1.0); } break; } @@ -627,7 +627,7 @@ void fn_1_E9B4(ModelData *model, ParticleData *particle, Mtx matrix) case 0: temp_r31 = particle->unk_48; for (temp_r28 = 0; temp_r28 < particle->unk_30; temp_r28++, temp_r31++) { - temp_r31->unk00_s16 = fn_1_11670() % 360; + temp_r31->unk00 = fn_1_11670() % 360; temp_r31->unk34.x = temp_r31->unk34.y = temp_r31->unk34.z = 0; temp_r27 = fn_1_11670() % 360; temp_r31->unk20 = temp_r27; @@ -653,14 +653,14 @@ void fn_1_E9B4(ModelData *model, ParticleData *particle, Mtx matrix) case 1: temp_r31 = particle->unk_48; for (temp_r28 = 0; temp_r28 < particle->unk_30; temp_r28++, temp_r31++) { - temp_r31->unk00_s16 += 2; - if (temp_r31->unk00_s16 >= 360) { - temp_r31->unk00_s16 -= 360; + temp_r31->unk00 += 2; + if (temp_r31->unk00 >= 360) { + temp_r31->unk00 -= 360; } temp_r31->unk34.x = temp_r31->unk14.x; temp_r31->unk34.y = temp_r31->unk14.y; temp_r31->unk34.z = temp_r31->unk14.z; - temp_r31->unk2C = temp_r31->unk24 * ((0.1f * sind(temp_r31->unk00_s16)) + 1.0); + temp_r31->unk2C = temp_r31->unk24 * ((0.1f * sind(temp_r31->unk00)) + 1.0); } break; } @@ -718,7 +718,7 @@ void fn_1_F06C(ModelData *model, ParticleData *particle, Mtx matrix) case 0: temp_r31 = particle->unk_48; for (temp_r28 = 0; temp_r28 < particle->unk_30; temp_r28++, temp_r31++) { - temp_r31->unk00_s16 = temp_r31->unk02 = 0; + temp_r31->unk00 = temp_r31->unk02 = 0; } temp_r29->unk_02++; break; @@ -726,8 +726,8 @@ void fn_1_F06C(ModelData *model, ParticleData *particle, Mtx matrix) case 1: temp_r31 = particle->unk_48; for (temp_r28 = 0; temp_r28 < particle->unk_30; temp_r28++, temp_r31++) { - if (temp_r31->unk00_s16) { - temp_r31->unk00_s16--; + if (temp_r31->unk00) { + temp_r31->unk00--; continue; } if (temp_r31->unk02 == 0) { @@ -739,7 +739,7 @@ void fn_1_F06C(ModelData *model, ParticleData *particle, Mtx matrix) temp_r31->unk40.r = temp_r31->unk40.g = temp_r31->unk40.b = temp_r31->unk40.a = 192; temp_r31->unk40.b = 160; temp_r31->unk2C = 0; - temp_r31->unk00_s16 = (s32)(90.0 * ((1.0 / 65536.0) * (float)fn_1_11670())); + temp_r31->unk00 = (s32)(90.0 * ((1.0 / 65536.0) * (float)fn_1_11670())); temp_r31->unk02 = 60; } temp_r31->unk40.a = 248 * sind(temp_r31->unk02 * 3); diff --git a/src/REL/m412Dll/main.c b/src/REL/m412Dll/main.c index d71592b2..35f10b6a 100644 --- a/src/REL/m412Dll/main.c +++ b/src/REL/m412Dll/main.c @@ -1425,7 +1425,6 @@ static inline void PadInline(void) (void)var_f27; } -// fn_1_6814: https://decomp.me/scratch/WQPjD void fn_1_6814(unkStruct3 *arg0) { Vec sp104; diff --git a/src/REL/m416Dll/main.c b/src/REL/m416Dll/main.c index 33fe0518..0364445e 100644 --- a/src/REL/m416Dll/main.c +++ b/src/REL/m416Dll/main.c @@ -1609,7 +1609,7 @@ void fn_1_613C(ModelData *model, ParticleData *particle, Mtx matrix) temp_r31->unk34.y = (64.0f * ((1.0f / 256.0f) * frand8())); temp_r31->unk34.z = (4.0f * (((1.0f / 256.0f) * ((s32)frand() & 0x1FF)) - 1)); temp_r31->unk30 = 360.0f * ((1.0f / 256.0f) * frand8()); - temp_r31->unk00_s16 = frand8(); + temp_r31->unk00 = frand8(); temp_r31->unk02 = (frand() & 0x3) + 4; } temp_f29 = temp_f28 = 0; @@ -1620,7 +1620,7 @@ void fn_1_613C(ModelData *model, ParticleData *particle, Mtx matrix) } temp_r31 = particle->unk_48; for (temp_r29 = 0; temp_r29 < particle->unk_30; temp_r31++, temp_r29++) { - temp_f30 = temp_r31->unk00_s16 / 255.0f; + temp_f30 = temp_r31->unk00 / 255.0f; temp_f31 = temp_f30 * temp_f30; temp_r31->unk34.x += temp_f29 * temp_f31; temp_r31->unk34.y = 60.0f * temp_f30; @@ -1628,12 +1628,12 @@ void fn_1_613C(ModelData *model, ParticleData *particle, Mtx matrix) temp_r31->unk40.a = 255.0f * (1.0f - temp_f30); temp_f31 = 0.5 * (1 + sind(270.0f * temp_f30)); temp_r31->unk2C = temp_f31 * (temp_r31->unk08.x * temp_f31); - temp_r31->unk00_s16 += temp_r31->unk02; - if (temp_r31->unk00_s16 > 255) { + temp_r31->unk00 += temp_r31->unk02; + if (temp_r31->unk00 > 255) { temp_r31->unk34.x = (4.0f * (((1.0f / 256.0f) * ((s32)frand() & 0x1FF)) - 1)); temp_r31->unk34.y = 0; temp_r31->unk34.z = (4.0f * (((1.0f / 256.0f) * ((s32)frand() & 0x1FF)) - 1)); - temp_r31->unk00_s16 = 0; + temp_r31->unk00 = 0; } } DCStoreRangeNoSync(particle->unk_48, particle->unk_30 * sizeof(HsfanimStruct01)); @@ -1664,7 +1664,7 @@ void fn_1_6640(ModelData *model, ParticleData *particle, Mtx matrix) temp_r31->unk08.z = temp_f30 * cosd(temp_f31); temp_r31->unk40.r = temp_r31->unk40.g = temp_r31->unk40.b = 255; temp_r31->unk40.a = 0; - temp_r31->unk00_s16 = ((float)particle->unk_3C) * ((float)temp_r28 / (float)particle->unk_30); + temp_r31->unk00 = ((float)particle->unk_3C) * ((float)temp_r28 / (float)particle->unk_30); } } else { @@ -1674,25 +1674,25 @@ void fn_1_6640(ModelData *model, ParticleData *particle, Mtx matrix) temp_r27 = 0; temp_r31 = particle->unk_48; for (temp_r28 = 0; temp_r28 < particle->unk_30; temp_r31++, temp_r28++) { - if (temp_r31->unk00_s16 >= 0) { - if (temp_r31->unk00_s16 == 0) { + if (temp_r31->unk00 >= 0) { + if (temp_r31->unk00 == 0) { temp_r31->unk34.x += temp_r31->unk08.x + temp_f29; temp_r31->unk34.y += temp_r31->unk08.y; temp_r31->unk34.z += temp_r31->unk08.z + temp_f28; temp_r31->unk08.y += -1.0000001f; if (temp_r31->unk40.a) { if (--temp_r31->unk40.a == 0) { - temp_r31->unk00_s16 = -1; + temp_r31->unk00 = -1; } } if (temp_r31->unk34.y < 0.0f) { temp_r31->unk34.y = 0; - temp_r31->unk00_s16 = -1; + temp_r31->unk00 = -1; temp_r31->unk40.a = 0; } } else { - if (--temp_r31->unk00_s16 == 0) { + if (--temp_r31->unk00 == 0) { temp_r31->unk40.a = 255; } } @@ -1728,12 +1728,12 @@ void fn_1_6AE8(ModelData *model, ParticleData *particle, Mtx matrix) temp_r31->unk08.y = 100.0f * (0.05f * (((1.0f / 256.0f) * ((s32)frand() & 0x1FF)) - 1.0f)); temp_r31->unk08.z = 100.0f * (0.05f * (((1.0f / 256.0f) * ((s32)frand() & 0x1FF)) - 1.0f)); temp_r31->unk40.a = 128; - temp_r31->unk00_s16 = 0; + temp_r31->unk00 = 0; } } temp_r31 = particle->unk_48; for (temp_r29 = 0; temp_r29 < particle->unk_30; temp_r29++, temp_r31++) { - if (temp_r31->unk00_s16 < 0) { + if (temp_r31->unk00 < 0) { temp_r27++; continue; } @@ -1746,7 +1746,7 @@ void fn_1_6AE8(ModelData *model, ParticleData *particle, Mtx matrix) temp_r28 = temp_r31->unk40.a; temp_r28 -= 4; if (temp_r28 < 0) { - temp_r31->unk00_s16 = -1; + temp_r31->unk00 = -1; temp_r28 = 0; } temp_r31->unk40.a = temp_r28; diff --git a/src/REL/m417Dll/water.c b/src/REL/m417Dll/water.c index 6217da9f..85cdcaea 100644 --- a/src/REL/m417Dll/water.c +++ b/src/REL/m417Dll/water.c @@ -892,7 +892,7 @@ void fn_1_6B94(ModelData *model, ParticleData *particle, float (*matrix)[4]) particle->unk_00++; var_r31 = particle->unk_48; for (var_r29 = 0; var_r29 < particle->unk_30; var_r29++, var_r31++) { - var_r31->unk00_s16 = 0; + var_r31->unk00 = 0; var_r31->unk2C = 0.0f; var_r31->unk40.a = 0; } @@ -900,16 +900,16 @@ void fn_1_6B94(ModelData *model, ParticleData *particle, float (*matrix)[4]) } var_r31 = particle->unk_48; for (var_r29 = 0; var_r29 < particle->unk_30; var_r29++, var_r31++) { - if (var_r31->unk00_s16) { + if (var_r31->unk00) { var_r31->unk34.x += var_r31->unk08.x; var_r31->unk34.y += var_r31->unk08.y; var_r31->unk34.z += var_r31->unk08.z; var_r31->unk08.y += -0.27222225f; - if (var_r31->unk00_s16 < 12.0f) { + if (var_r31->unk00 < 12.0f) { var_r31->unk40.a = 0.88f * var_r31->unk40.a; } - if (!(--var_r31->unk00_s16)) { - var_r31->unk00_s16 = 0; + if (!(--var_r31->unk00)) { + var_r31->unk00 = 0; var_r31->unk2C = 0.0f; var_r31->unk40.a = 0; } @@ -951,7 +951,7 @@ void fn_1_6D64(s32 arg0, u32 arg1, float arg8, float arg9, float argA) var_f27 = 0.0f; } for (var_r29 = 0; var_r29 < var_r30->unk_30; var_r29++, var_r31++) { - if (var_r31->unk00_s16) { + if (var_r31->unk00) { continue; } var_r31->unk00 = 60.0f * (1.0f + (0.0005f * frandmod(1000))); diff --git a/src/REL/m421Dll/player.c b/src/REL/m421Dll/player.c index 4735d112..ce14a94c 100644 --- a/src/REL/m421Dll/player.c +++ b/src/REL/m421Dll/player.c @@ -1606,14 +1606,14 @@ void fn_1_9C38(ModelData *model, ParticleData *particle, Mtx matrix) s32 var_r29; for (var_r31 = particle->unk_48, var_r29 = 0; var_r29 < particle->unk_30; var_r29++, var_r31++) { - if (var_r31->unk00_s16 != 0) { + if (var_r31->unk00 != 0) { VECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34); var_r31->unk2C += 2.0f; var_r31->unk40.a *= 0.98f; - if (var_r31->unk00_s16 < 24.0f) { + if (var_r31->unk00 < 24.0f) { var_r31->unk40.a = 0.9f * var_r31->unk40.a; } - if (--var_r31->unk00_s16 == 0) { + if (--var_r31->unk00 == 0) { var_r31->unk00 = 0; var_r31->unk2C = 0.0f; var_r31->unk40.a = 0; @@ -1649,10 +1649,10 @@ void fn_1_9DD0(omObjData *object, Vec *arg1) spC[2] = (220.0f + (0.13725491f * sp14.b)) - sp10[2]; var_r26 = 0x64; for (var_r31 = var_r30->unk_48, var_r29 = 0; var_r29 < var_r30->unk_30; var_r29++, var_r31++) { - if (var_r31->unk00_s16 != 0) { + if (var_r31->unk00 != 0) { continue; } - var_r31->unk00_s16 = 60.0f * (0.6f + (0.0005f * frandmod(0x3E8))); + var_r31->unk00 = 60.0f * (0.6f + (0.0005f * frandmod(0x3E8))); var_f31 = frandmod(0x168); var_f30 = frandmod(0x168); sp18.y = sind(var_f31); diff --git a/src/REL/m422Dll/main.c b/src/REL/m422Dll/main.c index b51c3e68..79b64b3c 100755 --- a/src/REL/m422Dll/main.c +++ b/src/REL/m422Dll/main.c @@ -1402,7 +1402,7 @@ void fn_1_9410(ModelData *model, ParticleData *particle, Mtx matrix) if (particle->unk_34 < 50) { var_r31 = particle->unk_48; for (i = 0; i < particle->unk_30; i++, var_r31++) { - var_r31->unk00_s16 = particle->unk_34 + 41; + var_r31->unk00 = particle->unk_34 + 41; var_r31->unk40.a = 0; var_r31->unk2C = 0.0f; } @@ -1410,7 +1410,7 @@ void fn_1_9410(ModelData *model, ParticleData *particle, Mtx matrix) if (particle->unk_34 >= 255) { var_r31 = particle->unk_48; for (i = 0; i < particle->unk_30; i++, var_r31++) { - var_r31->unk00_s16 = 255; + var_r31->unk00 = 255; var_r31->unk40.a = 0; var_r31->unk2C = 0.0f; } @@ -1423,7 +1423,7 @@ void fn_1_9410(ModelData *model, ParticleData *particle, Mtx matrix) } var_r31 = particle->unk_48; for (i = 0; i < particle->unk_30; i++, var_r31++) { - if (var_r31->unk00_s16 == 104) { + if (var_r31->unk00 == 104) { var_r31->unk34.x = var_r31->unk34.z = 0.0f; var_r31->unk34.y = 72.0f; temp_f31 = frandu8() * 360 / 256; @@ -1440,7 +1440,7 @@ void fn_1_9410(ModelData *model, ParticleData *particle, Mtx matrix) var_r31->unk2C = 50.0f; VECAdd(&var_r31->unk08, &var_r31->unk34, &var_r31->unk34); } - if (var_r31->unk00_s16 < 240) { + if (var_r31->unk00 < 240) { VECAdd(&var_r31->unk08, &var_r31->unk34, &var_r31->unk34); var_r31->unk08.x *= 0.9f; var_r31->unk08.z *= 0.9f; @@ -1456,7 +1456,7 @@ void fn_1_9410(ModelData *model, ParticleData *particle, Mtx matrix) var_r31->unk2C = 0.0f; } } - var_r31->unk00_s16 += (var_r31->unk00_s16 < 0x8000); + var_r31->unk00 += (var_r31->unk00 < 0x8000); } } diff --git a/src/REL/m425Dll/main.c b/src/REL/m425Dll/main.c index 2853e783..01182261 100644 --- a/src/REL/m425Dll/main.c +++ b/src/REL/m425Dll/main.c @@ -1300,14 +1300,14 @@ void fn_1_4A88(ModelData *model, ParticleData *particle, Mtx matrix) switch (var_r29->unk_04) { case 0: for (var_r31 = particle->unk_48, var_r28 = 0; var_r28 < particle->unk_30; var_r28++, var_r31++) { - var_r31->unk00_s16 = var_r31->unk02 = 0; + var_r31->unk00 = var_r31->unk02 = 0; } var_r29->unk_04++; break; case 1: for (var_r31 = particle->unk_48, var_r28 = 0; var_r28 < particle->unk_30; var_r28++, var_r31++) { - if (var_r31->unk00_s16 != 0) { - var_r31->unk00_s16--; + if (var_r31->unk00 != 0) { + var_r31->unk00--; } else { if (var_r31->unk02 == 0) { @@ -1325,7 +1325,7 @@ void fn_1_4A88(ModelData *model, ParticleData *particle, Mtx matrix) var_r31->unk40.r = var_r31->unk40.g = var_r31->unk40.b = var_r31->unk40.a = 0xC0; var_r31->unk40.b = 0xA0; var_r31->unk2C = 0.0f; - var_r31->unk00_s16 = (s32)(90.0 * (1.52587890625e-05 * (float)fn_1_64D4())); + var_r31->unk00 = (s32)(90.0 * (1.52587890625e-05 * (float)fn_1_64D4())); var_r31->unk02 = 0x3C; var_r31->unk40.r = 0xC0; var_r31->unk40.g = 0xE0; diff --git a/src/REL/m427Dll/player.c b/src/REL/m427Dll/player.c new file mode 100644 index 00000000..b27e5584 --- /dev/null +++ b/src/REL/m427Dll/player.c @@ -0,0 +1,2361 @@ +#include "REL/m427Dll.h" + +#include "dolphin/gx/GXEnum.h" +#include "dolphin/gx/GXStruct.h" +#include "dolphin/gx/GXVert.h" +#include "ext_math.h" +#include "game/audio.h" +#include "game/chrman.h" +#include "game/gamework.h" +#include "game/gamework_data.h" +#include "game/hsfdraw.h" +#include "game/hsfformat.h" +#include "game/hsfman.h" +#include "game/hsfmotion.h" +#include "game/memory.h" +#include "game/minigame_seq.h" +#include "game/object.h" +#include "game/objsub.h" +#include "game/pad.h" +#include "game/wipe.h" +#include "string.h" + +#ifndef __MWERKS__ +#include "game/frand.h" +#endif + +typedef struct M427DllPlayerWork2 { + /* 0x00 */ s32 unk_00; + /* 0x04 */ s32 unk_04; + /* 0x08 */ s32 unk_08; + /* 0x0C */ s32 unk_0C; + /* 0x10 */ s32 unk_10; + /* 0x14 */ s32 unk_14; + /* 0x18 */ s32 unk_18; + /* 0x1C */ s32 unk_1C; + /* 0x20 */ s32 unk_20; + /* 0x24 */ s32 unk_24; + /* 0x28 */ s32 unk_28; + /* 0x2C */ s32 unk_2C; + /* 0x30 */ s32 unk_30; + /* 0x34 */ s32 unk_34; + /* 0x38 */ s32 unk_38; + /* 0x3C */ s32 unk_3C; + /* 0x40 */ s32 unk_40; + /* 0x44 */ s32 unk_44; + /* 0x48 */ s32 unk_48; + /* 0x4C */ s32 unk_4C; + /* 0x50 */ s32 unk_50; + /* 0x54 */ s32 unk_54; + /* 0x58 */ s32 unk_58; + /* 0x5C */ s32 unk_5C; + /* 0x60 */ s32 unk_60; + /* 0x64 */ s32 unk_64; + /* 0x68 */ float unk_68; + /* 0x6C */ float unk_6C; + /* 0x70 */ float unk_70; +} M427DllPlayerWork2; /* size = 0x74 */ + +typedef struct M427DllPlayerWork { + /* 0x00 */ omObjData *unk_00[2]; + /* 0x08 */ M427DllPlayerWork2 *unk_08[2]; + /* 0x10 */ s32 unk_10; + /* 0x14 */ s32 unk_14; + /* 0x18 */ s32 unk_18; + /* 0x1C */ s32 unk_1C; + /* 0x20 */ s32 unk_20; + /* 0x24 */ s32 unk_24; + /* 0x28 */ float unk_28; + /* 0x2C */ float unk_2C; + /* 0x30 */ s32 unk_30[5]; + /* 0x34 */ char unk44[8]; + /* 0x4C */ float unk_4C; + /* 0x50 */ float unk_50; + /* 0x54 */ float unk_54; + /* 0x58 */ float unk_58; + /* 0x5C */ float unk_5C; + /* 0x60 */ s32 unk_60; + /* 0x64 */ float unk_64; + /* 0x68 */ s32 unk_68; + /* 0x6C */ char unk6C[4]; +} M427DllPlayerWork; /* size = 0x70 */ + +typedef struct M427DllBss57CStruct { + /* 0x00 */ s32 unk_00; + /* 0x04 */ s32 unk_04; + /* 0x08 */ s32 unk_08; + /* 0x0C */ s32 unk_0C; + /* 0x10 */ s32 unk_10; + /* 0x14 */ s32 unk_14; + /* 0x18 */ s32 unk_18; + /* 0x1C */ Vec unk_1C; + /* 0x28 */ Vec unk_28; + /* 0x34 */ float unk_34; + /* 0x38 */ char unk38[4]; +} M427DllBss57CStruct; /* size = 0x3C */ + +typedef struct M427DllBss590Struct { + /* 0x00 */ s32 unk_00; + /* 0x04 */ s32 unk_04; + /* 0x08 */ s32 unk_08; + /* 0x0C */ float unk_0C; + /* 0x10 */ float unk_10; + /* 0x14 */ Vec unk_14[2]; + /* 0x2C */ Vec unk_2C[2]; + /* 0x44 */ Vec unk_44; + /* 0x50 */ float unk_50; + /* 0x54 */ float unk_54; + /* 0x58 */ float unk_58; + /* 0x5C */ float unk_5C; + /* 0x60 */ float unk_60; + /* 0x64 */ float unk_64; + /* 0x68 */ float unk_68; + /* 0x6C */ float unk_6C; + /* 0x70 */ float unk_70; + /* 0x74 */ float unk_74; + /* 0x78 */ Vec *unk_78; + /* 0x7C */ Vec *unk_7C; + /* 0x80 */ Vec *unk_80; +} M427DllBss590Struct; /* size = 0x84 */ + +void fn_1_10830(omObjData *object); +void fn_1_1143C(omObjData *object); +void fn_1_115B4(omObjData *object); +void fn_1_119C0(omObjData *object); +void fn_1_11A74(omObjData *object); +void fn_1_11ED8(omObjData *object); +void fn_1_12514(omObjData *object); +void fn_1_12518(omObjData *object); +void fn_1_12580(omObjData *object); +void fn_1_12B08(void); +void fn_1_13F24(void); +void fn_1_13FB8(void); +s32 fn_1_155E0(float arg8, float arg9, float argA, float *arg0); +float fn_1_15714(float arg8, float arg9); +void fn_1_158D8(float arg8, float arg9, Vec *arg0); +s32 fn_1_15AF0(s32 arg0, Vec *arg1, Vec *arg2, Vec *arg3, Vec *arg4); +void fn_1_1607C(s32 arg0); +s32 fn_1_160D4(s32 arg0, Vec *arg1, float arg8); +s32 fn_1_16260(s32 arg0, Vec *arg2, Vec *arg3, Vec *arg4, float arg8); +float fn_1_16594(float arg8, float arg9); +void fn_1_16E3C(Vec *arg0, Vec *arg1, Vec *arg2, s32 arg3); +void fn_1_17048(Vec *arg0, float *arg1, Vec *arg2, Vec *arg3); +void fn_1_1723C(Mtx arg0, Vec *arg1); +void fn_1_172F0(s32 arg0, float arg8); +s32 fn_1_17430(s32 arg0, s32 arg1, s32 arg2); +void fn_1_EC74(omObjData *object); +void fn_1_EC94(omObjData *object); +void fn_1_F0E0(omObjData *object); + +Vec lbl_1_data_260[0x1D] = { + { -900.0f, 0.0f, 2000.0f }, + { -900.0f, 0.0f, 0.0f }, + { -900.0f, 0.0f, -2000.0f }, + { -900.0f, 0.0f, -4000.0f }, + { -1300.0f, 0.0f, -4500.0f }, + { -1600.0f, 0.0f, -5000.0f }, + { -1800.0f, 0.0f, -5500.0f }, + { -1900.0f, 0.0f, -6000.0f }, + { -1800.0f, 0.0f, -6500.0f }, + { -1600.0f, -100.0f, -7000.0f }, + { -1300.0f, -200.0f, -7500.0f }, + { -900.0f, -300.0f, -8000.0f }, + { -900.0f, -300.0f, -8500.0f }, + { -500.0f, -300.0f, -9000.0f }, + { -500.0f, -300.0f, -10000.0f }, + { -500.0f, -300.0f, -11000.0f }, + { -900.0f, -300.0f, -11500.0f }, + { -900.0f, -300.0f, -12000.0f }, + { -500.0f, -300.0f, -12500.0f }, + { -200.0f, -300.0f, -13000.0f }, + { -0.0f, -300.0f, -13500.0f }, + { 100.0f, -300.0f, -14000.0f }, + { 0.0f, -300.0f, -14500.0f }, + { -200.0f, -400.0f, -15000.0f }, + { -500.0f, -500.0f, -15500.0f }, + { -900.0f, -600.0f, -16000.0f }, + { -900.0f, -600.0f, -18000.0f }, + { -900.0f, -600.0f, -20000.0f }, + { -900.0f, -600.0f, -22000.0f }, +}; +Vec lbl_1_data_3BC[29] = { + { 900.0f, 0.0f, 2000.0f }, + { 900.0f, 0.0f, -0.0f }, + { 900.0f, 0.0f, -2000.0f }, + { 900.0f, 0.0f, -4000.0f }, + { 500.0f, 0.0f, -4500.0f }, + { 200.0f, 0.0f, -5000.0f }, + { 0.0f, 0.0f, -5500.0f }, + { -100.0f, 0.0f, -6000.0f }, + { 0.0f, 0.0f, -6500.0f }, + { 200.0f, -100.0f, -7000.0f }, + { 500.0f, -200.0f, -7500.0f }, + { 900.0f, -300.0f, -8000.0f }, + { 900.0f, -300.0f, -8500.0f }, + { 500.0f, -300.0f, -9000.0f }, + { 500.0f, -300.0f, -10000.0f }, + { 500.0f, -300.0f, -11000.0f }, + { 900.0f, -300.0f, -11500.0f }, + { 900.0f, -300.0f, -12000.0f }, + { 1300.0f, -300.0f, -12500.0f }, + { 1600.0f, -300.0f, -13000.0f }, + { 1800.0f, -300.0f, -13500.0f }, + { 1900.0f, -300.0f, -14000.0f }, + { 1800.0f, -300.0f, -14500.0f }, + { 1600.0f, -400.0f, -15000.0f }, + { 1300.0f, -500.0f, -15500.0f }, + { 900.0f, -600.0f, -16000.0f }, + { 900.0f, -600.0f, -18000.0f }, + { 900.0f, -600.0f, -20000.0f }, + { 900.0f, -600.0f, -22000.0f }, +}; +s32 lbl_1_data_518[7] = { 0, 1, 2, 3, 4, 5, 6 }; +Vec lbl_1_data_534[2] = { { 0.0f, -25.0f, 50.0f }, { 0.0f, -25.0f, -50.0f } }; +Vec lbl_1_data_54C[2] = { { 0.0f, 0.0f, 1900.0f }, { 0.0f, 20.0f, 20.0f } }; +Vec lbl_1_data_564 = { 0.0f, 240.00002f, 360.0f }; +Vec lbl_1_data_570 = { 0.0f, 1.0f, 1.5f }; +GXColor lbl_1_data_57C = { 0xFF, 0xFF, 0xFF, 0xFF }; + +Process *lbl_1_bss_594; +M427DllBss590Struct *lbl_1_bss_590; +Vec *lbl_1_bss_58C; +Vec *lbl_1_bss_588; +Vec *lbl_1_bss_584; +s32 lbl_1_bss_580; +M427DllBss57CStruct *lbl_1_bss_57C; +M427DllPlayerWork *lbl_1_bss_578; +M427DllPlayerWork2 *lbl_1_bss_574; +omObjData *lbl_1_bss_56C[2]; +char lbl_1_bss_55C[0x10]; +Vec *lbl_1_bss_558; +Vec *lbl_1_bss_554; +Vec *lbl_1_bss_550; + +void fn_1_E98C(Process *sp8) +{ + s32 sp10; + omObjData *object; + s32 var_r30; + s32 var_r29; + s32 var_r28; + s32 var_r27; + s32 var_r26; + + s8 spE[2] = { 0xFF, 0xFF }; + s8 spC[2] = { 0xFF, 0xFF }; + sp10 = 0; + OSReport("Init Player \n"); + lbl_1_bss_594 = sp8; + object = omAddObjEx(lbl_1_bss_594, 0x42, 0, 0, -1, fn_1_EC74); + omMakeGroupEx(lbl_1_bss_594, 0, 4); + omGetGroupMemberListEx(lbl_1_bss_594, 0); + for (var_r30 = 0, var_r28 = 0, var_r27 = 0, var_r29 = 0; var_r30 < 4; var_r30++) { + var_r26 = GWPlayerCfg[var_r30].group; + switch (var_r26) { + case 0: + if (var_r28 >= 2) { + var_r29 = 1; + } + else { + spE[var_r28] = var_r30; + var_r28++; + } + break; + case 1: + if (var_r27 >= 2) { + var_r29 = 1; + } + else { + spC[var_r27] = var_r30; + var_r27++; + } + break; + default: + var_r29 = 1; + break; + } + if (var_r29 != 0) { + break; + } + } + lbl_1_bss_578 = HuMemDirectMallocNum(HEAP_SYSTEM, 2 * sizeof(M427DllPlayerWork), MEMORY_DEFAULT_NUM); + memset(lbl_1_bss_578, 0, 0xE0); + lbl_1_bss_574 = HuMemDirectMallocNum(HEAP_SYSTEM, 4 * sizeof(M427DllPlayerWork2), MEMORY_DEFAULT_NUM); + memset(lbl_1_bss_574, 0, 0x1D0); + memset(lbl_1_bss_56C, 0, 8); + memset(lbl_1_bss_55C, 0, 0x10); + for (var_r30 = 0; var_r30 < 2; var_r30++) { + object = lbl_1_bss_56C[var_r30] = omAddObjEx(lbl_1_bss_594, 0x41, 0xE, 0, -1, fn_1_EC94); + object->work[0] = var_r30; + if (var_r29 != 0) { + object->work[1] = var_r30 * 2; + object->work[2] = (var_r30 * 2) + 1; + } + else if (var_r30 == 0) { + object->work[1] = spE[0]; + object->work[2] = spE[1]; + } + else { + object->work[1] = spC[0]; + object->work[2] = spC[1]; + } + } + fn_1_12B08(); +} + +s32 lbl_1_data_590[7] = { 0x3A001C, 0x3A001D, 0x3A001E, 0x3A001F, 0x3A0020, 0x3A0026, 0x3A0027 }; +s32 lbl_1_data_5AC[7] = { 0x3A0021, 0x3A0022, 0x3A0023, 0x3A0024, 0x3A0025, 0x3A0026, 0x3A0027 }; +s32 lbl_1_data_5C8[2] = { 1, 3 }; +s32 lbl_1_data_5D0[2] = { 2, 4 }; + +void fn_1_EC54(void) +{ + fn_1_13FB8(); +} + +void fn_1_EC74(omObjData *object) +{ + fn_1_13F24(); +} + +void fn_1_EC94(omObjData *object) +{ + M427DllPlayerWork *work; + s32 var_r29; + s32 var_r28; + s32 var_r27; + + work = &lbl_1_bss_578[object->work[0]]; + object->data = work; + work->unk_10 = object->work[0]; + work->unk_14 = 0; + work->unk_18 = 0; + work->unk_1C = 0; + work->unk_20 = 0; + work->unk_24 = 0; + work->unk_28 = 0.0f; + work->unk_2C = 0.0f; + work->unk_4C = 0.0f; + work->unk_50 = 0.0f; + work->unk_54 = 0.0f; + work->unk_58 = 0.0f; + work->unk_5C = 0.0f; + work->unk_60 = 0; + work->unk_64 = 180.0f; + work->unk_68 = 0; + object->trans.x = lbl_1_data_54C->x; + object->trans.y = lbl_1_data_54C->y; + object->trans.z = lbl_1_data_54C->z; + for (var_r29 = 0; var_r29 < 7; var_r29++) { + if (work->unk_10 == 0) { + object->model[var_r29] = Hu3DModelCreateFile(lbl_1_data_590[var_r29]); + } + else { + object->model[var_r29] = Hu3DModelCreateFile(lbl_1_data_5AC[var_r29]); + } + Hu3DModelLayerSet(object->model[var_r29], 2); + if (work->unk_10 == 0) { + Hu3DModelCameraSet(object->model[var_r29], 1); + } + else { + Hu3DModelCameraSet(object->model[var_r29], 2); + } + if (var_r29 < 5) { + Hu3DMotionSpeedSet(object->model[var_r29], 2.0f); + } + } + Hu3DModelAttrSet(object->model[0], HU3D_MOTATTR_LOOP); + Hu3DMotionSpeedSet(object->model[0], 2.0f); + Hu3DModelLayerSet(object->model[5], 5); + Hu3DModelAttrSet(object->model[5], HU3D_MOTATTR_LOOP); + for (var_r29 = 0; var_r29 < 5; var_r29++) { + if (var_r29 == 0) { + var_r28 = object->model[var_r29]; + var_r27 = Hu3DLLightCreateV(var_r28, &lbl_1_data_564, &lbl_1_data_570, &lbl_1_data_57C); + work->unk_30[var_r29] = var_r27; + Hu3DLLightStaticSet(var_r28, var_r27, 1); + Hu3DLLightPointSet(var_r28, var_r27, 80.0f, 0.95f, 3); + Hu3DLLightColorSet(var_r28, var_r27, 0xFF, 0xF0, 0xDC, 0xFF); + Hu3DLLightPosSet( + var_r28, var_r27, lbl_1_data_564.x, lbl_1_data_564.y, lbl_1_data_564.z, lbl_1_data_570.x, lbl_1_data_570.y, lbl_1_data_570.z); + } + else { + var_r28 = object->model[var_r29]; + work->unk_30[var_r29] = fn_1_17430(object->model[0], work->unk_30[0], var_r28); + } + fn_1_172F0(var_r28, 0.1f); + } + for (var_r29 = 0; var_r29 < 2; var_r29++) { + work->unk_00[var_r29] = omAddObjEx(lbl_1_bss_594, 0x40, 2, 4, -1, fn_1_11A74); + work->unk_00[var_r29]->work[0] = object->work[var_r29 + 1]; + work->unk_00[var_r29]->work[1] = work->unk_10; + work->unk_00[var_r29]->work[2] = var_r29; + } + object->func = fn_1_F0E0; +} + +void fn_1_F0E0(omObjData *object) +{ + Mtx sp38; + Vec sp2C; + Vec sp20; + Vec sp14; + Vec sp8; + float var_f31; + float var_f30; + float var_f29; + M427DllPlayerWork *work; + s32 var_r29; + s32 var_r28; + + work = object->data; + if ((work->unk_00[0] == NULL) || (work->unk_08[0] == NULL)) { + return; + } + sp2C.x = object->trans.x; + sp2C.y = object->trans.y; + sp2C.z = object->trans.z; + switch (work->unk_1C) { + case 0: + object->rot.y = work->unk_64 = 180.0f; + for (var_r29 = 0; var_r29 < 2; var_r29++) { + if ((work->unk_08[var_r29]->unk_30 != 0) && (Hu3DMotionEndCheck(object->model[lbl_1_data_5C8[var_r29]]) != 0)) { + fn_1_3B20(var_r29 * 2, work->unk_10); + Hu3DMotionTimeSet(object->model[lbl_1_data_5C8[var_r29]], 0.0f); + if (work->unk_10 == 0) { + HuAudFXPlay(0x655); + } + else { + HuAudFXPlay(0x656); + } + } + if ((work->unk_08[var_r29]->unk_34 != 0) && (Hu3DMotionEndCheck(object->model[lbl_1_data_5D0[var_r29]]) != 0)) { + fn_1_3B20((var_r29 * 2) + 1, work->unk_10); + Hu3DMotionTimeSet(object->model[lbl_1_data_5D0[var_r29]], 0.0f); + if (work->unk_10 == 0) { + HuAudFXPlay(0x655); + } + else { + HuAudFXPlay(0x656); + } + } + } + if (sp2C.z != object->trans.z) { + work->unk_60 = 2; + } + else { + work->unk_60 = 0; + } + if (fn_1_1788() == 3) { + work->unk_1C = 1; + } + break; + case 1: + if (sp2C.z != object->trans.z) { + work->unk_60 = 2; + } + else { + work->unk_60 = 0; + } + if (fn_1_1788() == 4) { + work->unk_1C = 2; + } + break; + case 2: + for (var_r29 = 0; var_r29 < 2; var_r29++) { + if (work->unk_08[var_r29]->unk_30 != 0) { + work->unk_58 += 0.1f; + if (Hu3DMotionEndCheck(object->model[lbl_1_data_5C8[var_r29]]) != 0) { + fn_1_3B20(var_r29 * 2, work->unk_10); + Hu3DMotionTimeSet(object->model[lbl_1_data_5C8[var_r29]], 0.0f); + if (work->unk_10 == 0) { + HuAudFXPlay(0x655); + } + else { + HuAudFXPlay(0x656); + } + } + } + if (work->unk_08[var_r29]->unk_34 != 0) { + work->unk_5C += 0.1f; + if (Hu3DMotionEndCheck(object->model[lbl_1_data_5D0[var_r29]]) != 0) { + fn_1_3B20((var_r29 * 2) + 1, work->unk_10); + Hu3DMotionTimeSet(object->model[lbl_1_data_5D0[var_r29]], 0.0f); + if (work->unk_10 == 0) { + HuAudFXPlay(0x655); + } + else { + HuAudFXPlay(0x656); + } + } + } + } + fn_1_158D8(object->trans.x, object->trans.z, &sp8); + work->unk_4C += 0.15f * sp8.x; + work->unk_54 += 0.15f * sp8.z; + work->unk_58 *= 0.995f; + work->unk_5C *= 0.995f; + work->unk_4C *= 0.99f; + work->unk_54 *= 0.99f; + work->unk_60 = work->unk_58 + work->unk_5C; + if (work->unk_60 < -5.0f) { + work->unk_60 = -5; + } + else if (work->unk_60 > 5.0f) { + work->unk_60 = 5; + } + var_f30 = 0.25f * (work->unk_58 - work->unk_5C); + if (var_f30 > 20.0f) { + var_f30 = 20.0f; + } + else if (var_f30 < -20.0f) { + var_f30 = -20.0f; + } + work->unk_64 += var_f30; + if (work->unk_64 > 360.0f) { + work->unk_64 -= 360.0f; + } + else if (work->unk_64 < 0.0f) { + work->unk_64 += 360.0f; + } + if (work->unk_64 > 270.0f) { + work->unk_64 = 270.0f; + } + else if (work->unk_64 < 90.0f) { + work->unk_64 = 90.0f; + } + object->rot.y = work->unk_64; + var_f31 = work->unk_60; + object->trans.x = object->trans.x + (2.0 * (var_f31 * sind(work->unk_64))); + object->trans.z = object->trans.z + (2.0 * (var_f31 * cosd(work->unk_64))); + object->trans.x += work->unk_4C; + object->trans.z += work->unk_54; + if (work->unk_68 > 0) { + work->unk_68--; + } + for (var_r29 = 0, var_r28 = 1; (var_r28 == 1) && (var_r29 < 6); var_r29++) { + var_r28 = 0; + sp20.x = object->trans.x; + sp20.y = object->trans.y; + sp20.z = object->trans.z; + if (fn_1_15AF0(-1, &sp2C, &sp20, &sp14, &sp8) != 0) { + var_r28 = 1; + sp2C = sp20; + object->trans.x = sp14.x; + object->trans.y = sp14.y; + object->trans.z = sp14.z; + if ((work->unk_68 == 0) && (fn_1_1788() <= 4)) { + if (work->unk_10 == 0) { + HuAudFXPlay(0x65C); + } + else { + HuAudFXPlay(0x65D); + } + } + work->unk_68 = 5; + } + sp20.x = object->trans.x; + sp20.y = object->trans.y; + sp20.z = object->trans.z; + if (fn_1_16260(work->unk_10, &sp2C, &sp20, &sp14, 200.0f) != 0) { + var_r28 = 1; + sp2C = sp20; + object->trans.x = sp14.x; + object->trans.y = sp14.y; + object->trans.z = sp14.z; + } + } + if (work->unk_20 <= 0) { + sp20.x = object->trans.x; + sp20.y = object->trans.y; + sp20.z = object->trans.z; + if (fn_1_160D4(work->unk_10, &sp20, 200.0f) != 0) { + omVibrate(work->unk_08[0]->unk_00, 0xC, 6, 6); + omVibrate(work->unk_08[1]->unk_00, 0xC, 6, 6); + HuAudCharVoicePlay(work->unk_08[0]->unk_0C, 0x123); + HuAudCharVoicePlay(work->unk_08[1]->unk_0C, 0x123); + work->unk_24 = 0x78; + work->unk_1C = 3; + work->unk_28 = 5.0f; + work->unk_2C = 360.0f * ((frand() & 0x7F) / 127.0f); + work->unk_18 = 0; + } + } + else { + work->unk_20--; + } + fn_1_119C0(object); + if (fn_1_1788() >= 5) { + work->unk_1C = 4; + } + break; + case 3: + work->unk_58 = 0.0f; + work->unk_5C = 0.0f; + work->unk_4C = 0.0f; + work->unk_54 = 0.0f; + work->unk_60 = work->unk_58 + work->unk_5C; + if (work->unk_60 < -5.0f) { + work->unk_60 = -5; + } + else if (work->unk_60 > 5.0f) { + work->unk_60 = 5; + } + var_f31 = work->unk_60 / 5.0f; + var_f31 = 5.0f * (var_f31 * var_f31); + object->trans.x = object->trans.x + (2.0 * (var_f31 * sind(work->unk_64))); + object->trans.z = object->trans.z + (2.0 * (var_f31 * cosd(work->unk_64))); + object->trans.x += work->unk_4C; + object->trans.z += work->unk_54; + for (var_r29 = 0, var_r28 = 1; (var_r28 == 1) && (var_r29 < 6); var_r29++) { + var_r28 = 0; + sp20.x = object->trans.x; + sp20.y = object->trans.y; + sp20.z = object->trans.z; + if (fn_1_15AF0(-1, &sp2C, &sp20, &sp14, &sp8) != 0) { + var_r28 = 1; + sp2C = sp20; + object->trans.x = sp14.x; + object->trans.y = sp14.y; + object->trans.z = sp14.z; + } + sp20.x = object->trans.x; + sp20.y = object->trans.y; + sp20.z = object->trans.z; + if (fn_1_16260(work->unk_10, &sp2C, &sp20, &sp14, 200.0f) != 0) { + var_r28 = 1; + sp2C = sp20; + object->trans.x = sp14.x; + object->trans.y = sp14.y; + object->trans.z = sp14.z; + } + } + if ((--work->unk_24 > 0) && ((work->unk_18 & 3) == 0)) { + omVibrate(work->unk_08[0]->unk_00, 0xC, 6, 6); + omVibrate(work->unk_08[1]->unk_00, 0xC, 6, 6); + } + if (work->unk_18 >= 120.0f) { + work->unk_1C = 2; + work->unk_20 = 0xB4; + work->unk_18 = 0; + } + fn_1_119C0(object); + if (fn_1_1788() >= 7) { + work->unk_20 = 0; + work->unk_18 = 0; + work->unk_1C = 4; + object->func = fn_1_10830; + } + break; + case 4: + work->unk_58 *= 0.993f; + work->unk_5C *= 0.993f; + work->unk_4C *= 0.993f; + work->unk_54 *= 0.993f; + work->unk_60 = work->unk_58 + work->unk_5C; + if (work->unk_60 < -5.0f) { + work->unk_60 = -5; + } + else if (work->unk_60 > 5.0f) { + work->unk_60 = 5; + } + var_f31 = work->unk_60 / 5.0f; + var_f31 = 5.0f * (var_f31 * var_f31); + object->trans.x = object->trans.x + (2.0 * (var_f31 * sind(work->unk_64))); + object->trans.z = object->trans.z + (2.0 * (var_f31 * cosd(work->unk_64))); + object->trans.x += work->unk_4C; + object->trans.z += work->unk_54; + for (var_r29 = 0, var_r28 = 1; (var_r28 == 1) && (var_r29 < 6); var_r29++) { + var_r28 = 0; + sp20.x = object->trans.x; + sp20.y = object->trans.y; + sp20.z = object->trans.z; + if (fn_1_15AF0(-1, &sp2C, &sp20, &sp14, &sp8) != 0) { + var_r28 = 1; + sp2C = sp20; + object->trans.x = sp14.x; + object->trans.y = sp14.y; + object->trans.z = sp14.z; + } + sp20.x = object->trans.x; + sp20.y = object->trans.y; + sp20.z = object->trans.z; + if (fn_1_16260(work->unk_10, &sp2C, &sp20, &sp14, 200.0f) != 0) { + var_r28 = 1; + sp2C = sp20; + object->trans.x = sp14.x; + object->trans.y = sp14.y; + object->trans.z = sp14.z; + } + } + work->unk_20 = 0; + if (fn_1_1788() >= 7) { + work->unk_18 = 0; + work->unk_1C = 4; + object->func = fn_1_10830; + } + break; + case 5: + if (sp2C.z != object->trans.z) { + work->unk_60 = 2; + } + else { + work->unk_60 = 0; + } + break; + case 6: + break; + case 7: + break; + } + var_f31 = work->unk_60 / 5.0f; + Hu3DMotionSpeedSet(object->model[0], 2.0f * var_f31); + if (work->unk_1C == 3) { + work->unk_2C += (frand() & 3) + 2; + object->rot.x = 0.0f; + object->rot.z = 0.0f; + work->unk_28 = 5.0f - (5.0f * (0.008333334f * work->unk_18)); + var_f29 = 7.0 * (work->unk_28 * sind((10.0f * work->unk_18))); + object->rot.x = object->rot.x + (var_f29 * sind(work->unk_2C)); + object->rot.z = object->rot.z + (var_f29 * cosd(work->unk_2C)); + } + if (((work->unk_1C == 3) || (work->unk_20 != 0)) && ((work->unk_18 & 1) != 0)) { + for (var_r29 = 0; var_r29 < 7; var_r29++) { + Hu3DModelAttrSet(object->model[var_r29], HU3D_ATTR_DISPOFF); + } + for (var_r29 = 0; var_r29 < 2; var_r29++) { + if (work->unk_00[var_r29]->model[0] != -1) { + Hu3DModelAttrSet(*work->unk_00[var_r29]->model, HU3D_ATTR_DISPOFF); + } + } + } + else { + for (var_r29 = 0; var_r29 < 7; var_r29++) { + Hu3DModelAttrReset(object->model[var_r29], HU3D_ATTR_DISPOFF); + } + for (var_r29 = 0; var_r29 < 2; var_r29++) { + if (work->unk_00[var_r29]->model[0] != -1) { + Hu3DModelAttrReset(*work->unk_00[var_r29]->model, HU3D_ATTR_DISPOFF); + } + } + } + for (var_r29 = 0; var_r29 < 2; var_r29++) { + work->unk_08[var_r29]->unk_24 = work->unk_1C; + } + object->trans.y = fn_1_AE78(work->unk_10, object->trans.x, object->trans.z); + mtxRot(sp38, object->rot.x, object->rot.y, object->rot.z); + sp38[1][0] *= object->scale.y; + sp38[1][1] *= object->scale.y; + sp38[1][2] *= object->scale.z; + sp20.x = 0.0f; + sp20.y = 0.0f; + sp20.z = 100.0f; + fn_1_1723C(sp38, &sp20); + sp20.x += object->trans.x; + sp20.y += object->trans.y; + sp20.z += object->trans.z; + fn_1_91E0(work->unk_10, sp20.x, sp20.y, sp20.z, 180.0f + object->rot.y); + for (var_r29 = 0; var_r29 < 2; var_r29++) { + sp20 = lbl_1_data_534[var_r29]; + fn_1_1723C(sp38, &sp20); + work->unk_00[var_r29]->trans.x = object->trans.x + sp20.x; + work->unk_00[var_r29]->trans.y = object->trans.y + sp20.y; + work->unk_00[var_r29]->trans.z = object->trans.z + sp20.z; + work->unk_00[var_r29]->rot.x = object->rot.x; + work->unk_00[var_r29]->rot.y = object->rot.y; + work->unk_00[var_r29]->rot.z = object->rot.z; + } + for (var_r29 = 0; var_r29 < 7; var_r29++) { + Hu3DModelPosSet(object->model[var_r29], object->trans.x, object->trans.y, object->trans.z); + Hu3DModelRotSet(object->model[var_r29], object->rot.x, object->rot.y, object->rot.z); + } + fn_1_1143C(object); + if ((fn_1_32EC() == 0) && (object->func != fn_1_10830) && ((work->unk_1C == 2) || (work->unk_1C == 3))) { + fn_1_115B4(object); + } + work->unk_18++; +} + +s32 lbl_1_data_5F8[2] = { 1, 3 }; +s32 lbl_1_data_600[2] = { 2, 4 }; +s32 lbl_1_data_608[4] = { 0x3A002F, 0x3A0037, 0x3A003F, 0x3A0047 }; +s32 lbl_1_data_618[4] = { 15, 10, 6, 5 }; + +void fn_1_10830(omObjData *object) +{ + Mtx sp14; + Vec sp8; + s32 var_r30; + M427DllPlayerWork *work; + s32 var_r28; + s32 var_r27; + + work = object->data; + switch (work->unk_1C) { + case 4: + var_r27 = fn_1_1884(); + if (var_r27 == 3) { + break; + } + if (var_r27 == work->unk_10) { + for (var_r30 = 0; var_r30 < 2; var_r30++) { + Hu3DModelCameraSet(*work->unk_00[var_r30]->model, 1); + Hu3DModelLayerSet(*work->unk_00[var_r30]->model, 3); + fn_1_172F0(work->unk_00[var_r30]->model[0], 5.0f); + } + for (var_r30 = 0; var_r30 < 7; var_r30++) { + Hu3DModelCameraSet(object->model[var_r30], 1); + Hu3DModelLayerSet(object->model[var_r30], 3); + if (var_r30 < 5) { + fn_1_172F0(object->model[var_r30], 5.0f); + } + } + Hu3DModelAttrSet(object->model[5], HU3D_ATTR_DISPOFF); + for (var_r30 = 0; var_r30 < 2; var_r30++) { + work->unk_00[var_r30]->model[1] = Hu3DModelLink(*work->unk_00[var_r30]->model); + Hu3DModelCameraSet(work->unk_00[var_r30]->model[1], 1); + Hu3DModelLayerSet(work->unk_00[var_r30]->model[1], 1); + } + for (var_r30 = 0; var_r30 < 7; var_r30++) { + object->model[var_r30 + 7] = Hu3DModelLink(object->model[var_r30]); + Hu3DModelCameraSet(object->model[var_r30 + 7], 1); + Hu3DModelLayerSet(object->model[var_r30 + 7], 1); + } + object->trans.x = object->trans.y = object->trans.z = 0.0f; + object->rot.x = object->rot.z = 0.0f; + object->rot.y = 180.0f; + work->unk_1C = 5; + break; + } + for (var_r30 = 0; var_r30 < 2; var_r30++) { + Hu3DModelAttrSet(work->unk_00[var_r30]->model[0], HU3D_ATTR_DISPOFF); + work->unk_00[var_r30]->func = NULL; + } + for (var_r30 = 0; var_r30 < 7; var_r30++) { + Hu3DModelAttrSet(object->model[var_r30], HU3D_ATTR_DISPOFF); + } + object->func = NULL; + return; + case 5: + for (var_r30 = 0; var_r30 < 2; var_r30++) { + var_r28 = lbl_1_data_5F8[var_r30]; + if ((work->unk_08[var_r30]->unk_30 != 0) && (Hu3DMotionEndCheck(object->model[var_r28]) != 0)) { + fn_1_3B20(var_r30 * 2, work->unk_10); + Hu3DMotionTimeSet(object->model[var_r28], 0.0f); + if (work->unk_10 == 0) { + HuAudFXPlay(0x655); + } + else { + HuAudFXPlay(0x656); + } + } + var_r28 = lbl_1_data_600[var_r30]; + if ((work->unk_08[var_r30]->unk_34 != 0) && (Hu3DMotionEndCheck(object->model[var_r28]) != 0)) { + fn_1_3B20((var_r30 * 2) + 1, work->unk_10); + Hu3DMotionTimeSet(object->model[var_r28], 0.0f); + if (work->unk_10 == 0) { + HuAudFXPlay(0x655); + } + else { + HuAudFXPlay(0x656); + } + } + } + if (fn_1_1788() >= 0xC) { + work->unk_1C = 6; + } + break; + case 6: + case 7: + break; + } + for (var_r30 = 0; var_r30 < 2; var_r30++) { + work->unk_08[var_r30]->unk_24 = work->unk_1C; + } + mtxRot(sp14, object->rot.x, object->rot.y, object->rot.z); + sp14[1][0] *= object->scale.y; + sp14[1][1] *= object->scale.y; + sp14[1][2] *= object->scale.z; + sp8.x = 0.0f; + sp8.y = 0.0f; + sp8.z = 100.0f; + fn_1_1723C(sp14, &sp8); + sp8.x += object->trans.x; + sp8.y += object->trans.y; + sp8.z += object->trans.z; + fn_1_91E0(work->unk_10, sp8.x, sp8.y, sp8.z, 180.0f + object->rot.y); + object->trans.y = fn_1_AE78(work->unk_10, object->trans.x, object->trans.z); + for (var_r30 = 0; var_r30 < 2; var_r30++) { + sp8 = lbl_1_data_534[var_r30]; + fn_1_1723C(sp14, &sp8); + work->unk_00[var_r30]->trans.x = object->trans.x + sp8.x; + work->unk_00[var_r30]->trans.y = object->trans.y + sp8.y; + work->unk_00[var_r30]->trans.z = object->trans.z + sp8.z; + work->unk_00[var_r30]->rot.x = object->rot.x; + work->unk_00[var_r30]->rot.y = object->rot.y; + work->unk_00[var_r30]->rot.z = object->rot.z; + if (work->unk_00[var_r30]->model[1] != -1) { + Hu3DModelPosSet( + work->unk_00[var_r30]->model[1], -work->unk_00[var_r30]->trans.x, work->unk_00[var_r30]->trans.y, work->unk_00[var_r30]->trans.z); + Hu3DModelRotSet( + work->unk_00[var_r30]->model[1], work->unk_00[var_r30]->rot.x, -work->unk_00[var_r30]->rot.y, work->unk_00[var_r30]->rot.z); + } + } + for (var_r30 = 0; var_r30 < 0xE; var_r30++) { + if (object->model[var_r30] != -1) { + if (var_r30 < 7) { + Hu3DModelPosSet(object->model[var_r30], object->trans.x, object->trans.y, object->trans.z); + Hu3DModelRotSet(object->model[var_r30], object->rot.x, object->rot.y, object->rot.z); + } + else { + Hu3DModelPosSet(object->model[var_r30], -object->trans.x, object->trans.y, object->trans.z); + Hu3DModelRotSet(object->model[var_r30], object->rot.x, -object->rot.y, object->rot.z); + } + } + } + work->unk_64 = 200.0f; + fn_1_1143C(object); + work->unk_18++; +} + +void fn_1_10F8C(omObjData *object) +{ + s32 var_r31; + M427DllPlayerWork *work = object->data; + for (var_r31 = 0; var_r31 < 2; var_r31++) { + fn_1_12514(work->unk_00[var_r31]); + } +} + +s32 fn_1_10FE8(s32 arg0, s32 *arg1) +{ + s32 var_r31; + M427DllPlayerWork *var_r30; + omObjData *var_r29; + + var_r29 = lbl_1_bss_56C[arg0]; + var_r30 = &lbl_1_bss_578[arg0]; + if ((var_r29 == NULL) || (var_r30 == NULL)) { + return -1; + } + if ((var_r30->unk_00[0] == NULL) || (var_r30->unk_08[0] == NULL)) { + return -1; + } + for (var_r31 = 0; var_r31 < 7; var_r31++) { + if (var_r31 < 5) { + arg1[var_r31] = var_r29->model[var_r31]; + } + else if (var_r31 < 6) { + arg1[var_r31] = var_r30->unk_00[0]->model[0]; + } + else { + arg1[var_r31] = var_r30->unk_00[1]->model[0]; + } + } + return var_r31; +} + +void fn_1_110E8(s32 arg0, s32 *arg1) +{ + s32 var_r31; + M427DllPlayerWork *var_r30; + omObjData *var_r29; + + var_r29 = lbl_1_bss_56C[arg0]; + var_r30 = &lbl_1_bss_578[arg0]; + for (var_r31 = 0; var_r31 < 2; var_r31++) { + arg1[var_r31] = 0; + } + if ((var_r29 == NULL) || (var_r30 == NULL)) { + return; + } + if ((var_r30->unk_00[0] == NULL) || (var_r30->unk_08[0] == NULL)) { + return; + } + for (var_r31 = 0; var_r31 < 2; var_r31++) { + arg1[var_r31] = var_r30->unk_08[var_r31]->unk_0C; + } +} + +void fn_1_111C0(s32 arg0, s32 *arg1) +{ + s32 var_r31; + M427DllPlayerWork *var_r30; + omObjData *var_r29; + + var_r29 = lbl_1_bss_56C[arg0]; + var_r30 = &lbl_1_bss_578[arg0]; + for (var_r31 = 0; var_r31 < 2; var_r31++) { + arg1[var_r31] = 0; + } + if ((var_r29 == NULL) || (var_r30 == NULL)) { + return; + } + if ((var_r30->unk_00[0] == NULL) || (var_r30->unk_08[0] == NULL)) { + return; + } + for (var_r31 = 0; var_r31 < 2; var_r31++) { + arg1[var_r31] = var_r30->unk_08[var_r31]->unk_00; + } +} + +void fn_1_11298(float var_f30) +{ + float var_f31; + omObjData *object; + s32 var_r30; + + if (fn_1_1788() < 4) { + for (var_r30 = 0; var_r30 < 2; var_r30++) { + object = lbl_1_bss_56C[var_r30]; + if (object) { + object->trans.z = 1900.0f + (-1800.0f * var_f30); + } + } + return; + } + for (var_r30 = 0; var_r30 < 2; var_r30++) { + object = lbl_1_bss_56C[var_r30]; + if (object) { + object->trans.z = -1800.0f * var_f30; + if (object->trans.z < -1500.0f) { + var_f31 = (object->trans.z - -1500.0f) / 300.0f; + object->rot.y = 180.0f - (30.0f * var_f31); + } + } + } +} + +s32 fn_1_113F0(s32 arg0) +{ + M427DllPlayerWork *work; + omObjData *object; + + object = lbl_1_bss_56C[arg0]; + work = object->data; + if (work->unk_14 == 3) { + return 1; + } + return 0; +} + +void fn_1_1143C(omObjData *object) +{ + Mtx sp20; + Vec sp14; + Vec sp8; + M427DllPlayerWork *work; + s32 var_r29; + + work = object->data; + mtxRot(sp20, 0.0f, work->unk_64, 0.0f); + sp14 = lbl_1_data_564; + fn_1_1723C(sp20, &sp14); + sp14.x += object->trans.x; + sp14.y += object->trans.y; + sp14.z += object->trans.z; + sp8.x = sp8.z = 0.0f; + sp8.y = 1.0f; + Hu3DLLightPosSet(object->model[0], work->unk_30[0], sp14.x, sp14.y, sp14.z, sp8.x, sp8.y, sp8.z); + for (var_r29 = 0; var_r29 < 2; var_r29++) { + if (*work->unk_00[var_r29]->model != -1) { + Hu3DLLightPosSet(work->unk_00[var_r29]->model[0], work->unk_08[var_r29]->unk_14, sp14.x, sp14.y, sp14.z, sp8.x, sp8.y, sp8.z); + } + } +} + +void fn_1_115B4(omObjData *object) +{ + Vec spC; + float sp8; + float var_f31; + float var_f30; + float var_f29; + M427DllBss590Struct *var_r31; + M427DllPlayerWork *work; + s32 var_r28; + + work = object->data; + var_r28 = fn_1_155E0(object->trans.x, object->trans.y, object->trans.z, &sp8); + if ((var_r28 < 0) || (var_r28 >= (lbl_1_bss_580 - 1))) { + return; + } + var_r31 = &lbl_1_bss_590[var_r28]; + spC.x = var_r31->unk_44.x + (sp8 * var_r31->unk_50); + spC.y = 275.0f + (var_r31->unk_44.y + (sp8 * var_r31->unk_54)); + spC.z = var_r31->unk_44.z + (sp8 * var_r31->unk_58); + var_f29 = object->trans.x - spC.x; + spC.x += 0.4f * var_f29; + if (var_f29 < 0.0f) { + var_f30 = fabs(var_r31->unk_5C + (sp8 * (var_r31->unk_64 - var_r31->unk_5C))); + } + else { + var_f30 = fabs(var_r31->unk_60 + (sp8 * (var_r31->unk_68 - var_r31->unk_60))); + } + CenterM[work->unk_10].x = CenterM[work->unk_10].x + (0.06666667f * (spC.x - CenterM[work->unk_10].x)); + CenterM[work->unk_10].y = CenterM[work->unk_10].y + (0.06666667f * (spC.y - CenterM[work->unk_10].y)); + CenterM[work->unk_10].z = CenterM[work->unk_10].z + (0.06666667f * (spC.z - CenterM[work->unk_10].z)); + var_f31 = var_r31->unk_0C; + if (var_f31 < 0.0f) { + var_f31 += 360.0f; + } + var_f31 = 180.0f + (0.25f * (var_f31 - 180.0f)); + if (var_f30 != 0.0f) { + var_f30 = var_f29 / var_f30; + } + var_f31 -= 30.0f * var_f30; + CRotM[work->unk_10].y = fn_1_168FC(0.020000001f, CRotM[work->unk_10].y, 180.0f + var_f31); +} + +void fn_1_119C0(omObjData *object) +{ + float var_f31; + float var_f30; + M427DllBss590Struct *var_r31; + M427DllPlayerWork *work; + M427DllBss590Struct *var_r28; + + work = object->data; + var_r31 = &lbl_1_bss_590[1]; + var_r28 = &lbl_1_bss_590[27]; + var_f31 = var_r28->unk_80->z - var_r31->unk_80->z; + var_f30 = object->trans.z - var_r31->unk_80->z; + fn_1_1798(work->unk_10, var_f30 / var_f31); +} + +void fn_1_11A74(omObjData *object) +{ + M427DllPlayerWork2 *var_r31; + s32 var_r29; + s32 var_r28; + s32 var_r27; + M427DllPlayerWork *var_r26; + + var_r31 = &lbl_1_bss_574[object->work[0]]; + object->data = var_r31; + var_r26 = &lbl_1_bss_578[object->work[1]]; + lbl_1_bss_578[object->work[1]].unk_08[object->work[2]] = var_r31; + var_r31->unk_00 = object->work[0]; + var_r31->unk_04 = object->work[1]; + var_r31->unk_08 = GWPlayerCfg[var_r31->unk_00].pad_idx; + var_r31->unk_0C = GWPlayerCfg[var_r31->unk_00].character; + var_r31->unk_10 = object->work[2]; + var_r31->unk_18 = GWPlayerCfg[var_r31->unk_00].iscom; + var_r31->unk_1C = GWPlayerCfg[var_r31->unk_00].diff; + var_r31->unk_20 = 0; + var_r31->unk_24 = 0; + var_r31->unk_28 = 0; + var_r31->unk_30 = 0; + var_r31->unk_34 = 0; + var_r31->unk_38 = 0; + var_r31->unk_3C = 0; + var_r31->unk_40 = var_r31->unk_44 = 0; + var_r31->unk_48 = var_r31->unk_4C = 0; + var_r31->unk_50 = 0; + var_r31->unk_54 = 0; + var_r31->unk_60 = lbl_1_data_618[var_r31->unk_1C]; + var_r31->unk_58 = frand() % var_r31->unk_60; + var_r31->unk_5C = frand() % 7; + var_r31->unk_64 = -1; + var_r31->unk_68 = var_r31->unk_6C = var_r31->unk_70 = 0.0f; + if (var_r31->unk_18 != 0) { + var_r26->unk_14 |= 1 << var_r31->unk_10; + } + var_r27 = var_r31->unk_0C; + object->model[0] = CharModelCreate(var_r27, 4); + Hu3DModelLayerSet(object->model[0], 2); + if (var_r31->unk_04 == 0) { + Hu3DModelCameraSet(object->model[0], 1); + } + else { + Hu3DModelCameraSet(object->model[0], 2); + } + if (var_r31->unk_10 != 0) { + fn_1_172F0(object->model[0], 0.3f); + } + else { + fn_1_172F0(object->model[0], 0.3f); + } + CharModelStepTypeSet(var_r27, 3); + for (var_r29 = 0; var_r29 < 4; var_r29++) { + object->motion[var_r29] = Hu3DJointMotionFile(object->model[0], var_r31->unk_0C + lbl_1_data_608[var_r29]); + } + var_r31->unk_2C = 0; + CharModelMotionSet(var_r31->unk_0C, object->motion[0]); + CharModelMotionDataClose(var_r27); + var_r28 = Hu3DLLightCreateV(object->model[0], &lbl_1_data_564, &lbl_1_data_570, &lbl_1_data_57C); + var_r31->unk_14 = var_r28; + Hu3DLLightStaticSet(object->model[0], var_r28, 1); + if (var_r31->unk_10 == 0) { + Hu3DLLightPointSet(object->model[0], var_r28, 80.0f, 0.95f, 3); + } + else { + Hu3DLLightPointSet(object->model[0], var_r28, 80.0f, 0.95f, 3); + } + Hu3DLLightColorSet(object->model[0], var_r28, 0xFF, 0xFF, 0xFF, 0xFF); + Hu3DLLightPosSet( + object->model[0], var_r28, lbl_1_data_564.x, lbl_1_data_564.y, lbl_1_data_564.z, lbl_1_data_570.x, lbl_1_data_570.y, lbl_1_data_570.z); + object->func = fn_1_11ED8; + (void)var_r29; +} + +void fn_1_11ED8(omObjData *object) +{ + M427DllPlayerWork2 *var_r31; + s32 var_r29; + M427DllPlayerWork *var_r28; + omObjData *var_r27; + + var_r31 = object->data; + var_r28 = &lbl_1_bss_578[var_r31->unk_04]; + var_r27 = lbl_1_bss_56C[var_r31->unk_04]; + var_r31->unk_40 = HuPadBtn[var_r31->unk_08]; + var_r31->unk_44 = HuPadBtnDown[var_r31->unk_08]; + if ((var_r31->unk_18 != 0) && (var_r31->unk_24 == 2)) { + if (var_r28->unk_14 == 3) { + fn_1_12580(object); + } + else { + fn_1_12518(object); + } + } + var_r31->unk_38 = var_r31->unk_3C = 0; + if (var_r31->unk_30 != 0) { + var_r31->unk_38 = 1; + } + if (var_r31->unk_34 != 0) { + var_r31->unk_3C = 1; + } + var_r31->unk_30 = var_r31->unk_34 = 0; + switch (var_r31->unk_24) { + case 0: + if (((var_r31->unk_20 & 0xF) == 0) && (var_r27->trans.z > 100.0f)) { + var_r31->unk_30 = 1; + var_r31->unk_34 = 1; + } + var_r29 = 1; + if (var_r29 != var_r31->unk_2C) { + var_r31->unk_2C = var_r29; + CharModelMotionShiftSet(var_r31->unk_0C, object->motion[var_r31->unk_2C], 0.0f, 8.0f, 0x40000001); + } + break; + case 1: + var_r29 = 0; + if ((var_r29 != var_r31->unk_2C) && (CharModelMotionShiftIDGet(var_r31->unk_0C) == -1)) { + var_r31->unk_2C = var_r29; + CharModelMotionShiftSet(var_r31->unk_0C, object->motion[var_r31->unk_2C], 0.0f, 8.0f, 0x40000001); + var_r31->unk_28 = 0; + } + break; + case 2: + if (fn_1_32EC() == 0) { + if ((var_r31->unk_44 & 0x100) != 0) { + var_r31->unk_30 = 1; + } + if ((var_r31->unk_44 & 0x200) != 0) { + var_r31->unk_34 = 1; + } + } + var_r31->unk_48 = var_r31->unk_40; + var_r31->unk_4C = var_r31->unk_44; + if ((var_r31->unk_30 != 0) || (var_r31->unk_34 != 0)) { + var_r29 = 1; + } + else { + var_r29 = 0; + } + if ((CharModelMotionShiftIDGet(var_r31->unk_0C) == -1) + && ((var_r29 != var_r31->unk_2C) || (CharModelMotionEndCheck(var_r31->unk_0C) == 1))) { + if (var_r31->unk_2C == var_r29) { + CharModelMotionTimeSet(var_r31->unk_0C, 0.0f); + } + else { + var_r31->unk_2C = var_r29; + CharModelMotionShiftSet(var_r31->unk_0C, object->motion[var_r31->unk_2C], 0.0f, 8.0f, 0); + } + } + break; + case 3: + var_r29 = 2; + if ((var_r29 != var_r31->unk_2C) && (CharModelMotionShiftIDGet(var_r31->unk_0C) == -1)) { + var_r31->unk_2C = var_r29; + CharModelMotionShiftSet(var_r31->unk_0C, object->motion[var_r31->unk_2C], 0.0f, 8.0f, 0x40000001); + var_r31->unk_28 = 0; + } + if (var_r31->unk_2C == 2) { + if (++var_r31->unk_28 >= 240.0f) { + Hu3DModelAttrReset(object->model[0], HU3D_MOTATTR_LOOP); + } + } + break; + case 4: + var_r29 = 0; + if ((var_r29 != var_r31->unk_2C) && (CharModelMotionShiftIDGet(var_r31->unk_0C) == -1)) { + var_r31->unk_2C = var_r29; + if (object->model[1] != -1) { + Hu3DMotionShiftSet(object->model[1], object->motion[var_r31->unk_2C], 0.0f, 8.0f, HU3D_MOTATTR_LOOP); + } + else { + CharModelMotionShiftSet(var_r31->unk_0C, object->motion[var_r31->unk_2C], 0.0f, 8.0f, 0x40000001); + } + var_r31->unk_28 = 0; + } + break; + case 5: + if (object->trans.z > -1300.0f) { + if ((var_r31->unk_20 & 0xF) == 0) { + var_r31->unk_30 = 1; + var_r31->unk_34 = 1; + } + var_r29 = 1; + } + else { + var_r29 = 0; + } + if (var_r31->unk_2C == 1) { + Hu3DModelAttrSet(object->model[0], HU3D_MOTATTR_LOOP); + } + if ((CharModelMotionShiftIDGet(var_r31->unk_0C) == -1) && (var_r29 != var_r31->unk_2C)) { + var_r31->unk_2C = var_r29; + CharModelMotionShiftSet(var_r31->unk_0C, object->motion[var_r31->unk_2C], 0.0f, 8.0f, 0x40000001); + } + break; + case 6: + var_r29 = 3; + if ((var_r29 != var_r31->unk_2C) && (CharModelMotionShiftIDGet(var_r31->unk_0C) == -1)) { + var_r31->unk_2C = var_r29; + CharModelMotionShiftSet(var_r31->unk_0C, object->motion[var_r31->unk_2C], 0.0f, 8.0f, 0); + HuAudCharVoicePlay(var_r31->unk_0C, 0x124); + var_r31->unk_28 = 0; + } + break; + case 7: + break; + } + var_r31->unk_20++; +} + +void fn_1_12514(omObjData *object) { } + +void fn_1_12518(omObjData *object) +{ + M427DllPlayerWork *var_r31; + M427DllPlayerWork2 *var_r30; + M427DllPlayerWork2 *var_r29; + + var_r30 = object->data; + var_r31 = &lbl_1_bss_578[var_r30->unk_04]; + if (var_r31->unk_14 == 1) { + var_r29 = var_r31->unk_08[1]; + } + else { + var_r29 = var_r31->unk_08[0]; + } + var_r30->unk_40 = var_r29->unk_48; + var_r30->unk_44 = var_r29->unk_4C; +} + +void fn_1_12580(omObjData *var_r24) +{ + float var_f31; + float var_f30; + float var_f29; + float var_f28; + float var_f27; + M427DllPlayerWork2 *var_r31; + M427DllBss590Struct *var_r30; + omObjData *var_r29; + M427DllPlayerWork *var_r28; + s32 var_r27; + s32 var_r26; + s32 var_r25; + + var_r31 = var_r24->data; + var_r28 = &lbl_1_bss_578[var_r31->unk_04]; + var_r29 = lbl_1_bss_56C[var_r31->unk_04]; + var_r31->unk_40 = 0; + var_r31->unk_44 = 0; + var_r26 = fn_1_155E0(var_r29->trans.x, var_r29->trans.y, var_r29->trans.z, NULL); + if ((var_r31->unk_64 != var_r26) || (var_r31->unk_54 > 180.0f)) { + var_r31->unk_64 = var_r26; + switch (var_r31->unk_1C) { + case 0: + var_r27 = 2; + break; + case 1: + var_r27 = 2; + break; + case 2: + var_r27 = 3; + break; + case 3: + var_r27 = 4; + break; + } + if ((var_r31->unk_64 >= 0) && (var_r31->unk_64 < (lbl_1_bss_580 - var_r27)) && (var_r31->unk_64 <= (lbl_1_bss_580 - 2))) { + var_r26 = var_r31->unk_64 + var_r27; + var_r30 = &lbl_1_bss_590[var_r26]; + var_f31 = 0.5f * (var_r30->unk_64 + var_r30->unk_68); + var_f30 = (0.6f - (0.1f * var_r31->unk_1C)) - (0.1f * var_r31->unk_1C * ((frand() & 0x7F) / 127.0f)); + if (var_f30 > 1.0f) { + var_f30 = 1.0f; + } + else if (var_f30 < 0.0f) { + var_f30 = 0.0f; + } + var_f31 *= var_f30; + if ((frand() & 1) != 0) { + var_f31 *= -1.0f; + } + var_r31->unk_68 = var_r30->unk_80->x + var_f31; + var_r31->unk_6C = var_r30->unk_80->y; + var_r31->unk_70 = var_r30->unk_80->z; + } + else { + var_r30 = &lbl_1_bss_590[lbl_1_bss_580 - 1]; + var_r31->unk_68 = var_r30->unk_80->x; + var_r31->unk_6C = var_r30->unk_80->y; + var_r31->unk_70 = var_r30->unk_80->z; + } + var_r31->unk_54 = 0; + } + var_r25 = var_r31->unk_60 + var_r31->unk_5C; + if (var_r28->unk_20 != 0) { + var_r25 = 5; + } + if (++var_r31->unk_58 > var_r25) { + var_r31->unk_58 = 0; + var_r31->unk_5C = frand() % 7; + var_f28 = var_r31->unk_68 - var_r29->trans.x; + var_f27 = var_r31->unk_70 - var_r29->trans.z; + var_f31 = fn_1_16594(atan2d(var_f28, var_f27), var_r28->unk_64); + if (fabs(var_f31) < (30.0f - (5.0f * var_r31->unk_1C))) { + if (var_r31->unk_1C > 2) { + var_f29 = 0.25f * (var_r28->unk_58 - var_r28->unk_5C); + if (var_f29 > 10.0f) { + var_r31->unk_44 |= 0x100; + } + else if (var_f29 < -10.0f) { + var_r31->unk_44 |= 0x200; + } + else { + var_r31->unk_44 |= 0x300; + } + } + else { + var_r31->unk_44 |= 0x300; + } + } + else if (var_f31 < 0.0f) { + var_r31->unk_44 |= 0x200; + } + else { + var_r31->unk_44 |= 0x100; + } + } + var_r31->unk_50++; + var_r31->unk_54++; +} + +void fn_1_12B08(void) +{ + Vec sp20; + float sp1C; + float sp18; + float sp14; + float sp10; + float spC; + float sp8; + float var_f31; + float var_f30; + float var_f29; + float var_f28; + float var_f27; + float var_f26; + float var_f25; + float var_f24; + float var_f23; + float var_f22; + float var_f21; + float var_f20; + float var_f19; + float var_f18; + M427DllBss590Struct *var_r31; + s32 var_r30; + M427DllBss57CStruct *var_r29; + + lbl_1_bss_580 = 0x1D; + lbl_1_bss_584 = HuMemDirectMallocNum(HEAP_SYSTEM, lbl_1_bss_580 * sizeof(Vec), MEMORY_DEFAULT_NUM); + memset(lbl_1_bss_584, 0, lbl_1_bss_580 * sizeof(Vec)); + for (var_r30 = 0; var_r30 < lbl_1_bss_580; var_r30++) { + lbl_1_bss_584[var_r30].x = 0.5f * (lbl_1_data_260[var_r30].x + lbl_1_data_3BC[var_r30].x); + lbl_1_bss_584[var_r30].y = 0.5f * (lbl_1_data_260[var_r30].y + lbl_1_data_3BC[var_r30].y); + lbl_1_bss_584[var_r30].z = 0.5f * (lbl_1_data_260[var_r30].z + lbl_1_data_3BC[var_r30].z); + } + lbl_1_bss_58C = HuMemDirectMallocNum(HEAP_SYSTEM, lbl_1_bss_580 * sizeof(Vec), MEMORY_DEFAULT_NUM); + memset(lbl_1_bss_58C, 0, lbl_1_bss_580 * sizeof(Vec)); + for (var_r30 = 0; var_r30 < lbl_1_bss_580; var_r30++) { + VECSubtract(&lbl_1_bss_584[var_r30], &lbl_1_data_260[var_r30], &lbl_1_bss_58C[var_r30]); + VECNormalize(&lbl_1_bss_58C[var_r30], &lbl_1_bss_58C[var_r30]); + VECScale(&lbl_1_bss_58C[var_r30], &lbl_1_bss_58C[var_r30], 200.0f); + VECAdd(&lbl_1_bss_58C[var_r30], &lbl_1_data_260[var_r30], &lbl_1_bss_58C[var_r30]); + } + lbl_1_bss_588 = HuMemDirectMallocNum(HEAP_SYSTEM, lbl_1_bss_580 * sizeof(Vec), MEMORY_DEFAULT_NUM); + memset(lbl_1_bss_588, 0, lbl_1_bss_580 * sizeof(Vec)); + for (var_r30 = 0; var_r30 < lbl_1_bss_580; var_r30++) { + VECSubtract(&lbl_1_bss_584[var_r30], &lbl_1_data_3BC[var_r30], &lbl_1_bss_588[var_r30]); + VECNormalize(&lbl_1_bss_588[var_r30], &lbl_1_bss_588[var_r30]); + VECScale(&lbl_1_bss_588[var_r30], &lbl_1_bss_588[var_r30], 200.0f); + VECAdd(&lbl_1_bss_588[var_r30], &lbl_1_data_3BC[var_r30], &lbl_1_bss_588[var_r30]); + } + var_r31 = lbl_1_bss_590 = HuMemDirectMallocNum(HEAP_SYSTEM, lbl_1_bss_580 * sizeof(M427DllBss590Struct), MEMORY_DEFAULT_NUM); + memset(lbl_1_bss_590, 0, lbl_1_bss_580 * sizeof(M427DllBss590Struct)); + for (var_r30 = 0; var_r30 < lbl_1_bss_580; var_r30++, var_r31++) { + var_r31->unk_00 = var_r30; + var_r31->unk_04 = var_r30 + 1; + var_r31->unk_08 = var_r30 - 1; + if (var_r31->unk_04 >= lbl_1_bss_580) { + var_r31->unk_04 = -1; + } + if (var_r31->unk_08 >= lbl_1_bss_580) { + var_r31->unk_08 = -1; + } + var_r31->unk_78 = &lbl_1_bss_58C[var_r30]; + var_r31->unk_7C = &lbl_1_bss_588[var_r30]; + var_r31->unk_80 = &lbl_1_bss_584[var_r30]; + if (var_r31->unk_04 < 0) { + var_r31->unk_0C = 180.0f; + var_r31->unk_70 = 180.0f; + var_r31->unk_74 = 180.0f; + } + else { + var_r31->unk_0C + = atan2d(lbl_1_bss_584[var_r31->unk_04].x - lbl_1_bss_584[var_r30].x, lbl_1_bss_584[var_r31->unk_04].z - lbl_1_bss_584[var_r30].z); + var_r31->unk_70 + = atan2d(lbl_1_bss_58C[var_r31->unk_04].x - lbl_1_bss_58C[var_r30].x, lbl_1_bss_58C[var_r31->unk_04].z - lbl_1_bss_58C[var_r30].z); + var_r31->unk_74 + = atan2d(lbl_1_bss_588[var_r31->unk_04].x - lbl_1_bss_588[var_r30].x, lbl_1_bss_588[var_r31->unk_04].z - lbl_1_bss_588[var_r30].z); + } + if (var_r31->unk_08 < 0) { + var_r31->unk_10 = 0.0f; + } + else { + var_r31->unk_10 + = atan2d(lbl_1_bss_584[var_r31->unk_08].x - lbl_1_bss_584[var_r30].x, lbl_1_bss_584[var_r31->unk_08].z - lbl_1_bss_584[var_r30].z); + } + if (var_r31->unk_04 < 0) { + var_r31->unk_6C = 0.0f; + sp20.x = lbl_1_bss_58C[var_r30].x + lbl_1_bss_590[var_r30 - 1].unk_14[1].x; + sp20.y = lbl_1_bss_58C[var_r30].y + lbl_1_bss_590[var_r30 - 1].unk_14[1].y; + sp20.z = lbl_1_bss_58C[var_r30].z + lbl_1_bss_590[var_r30 - 1].unk_14[1].z; + fn_1_16E3C(&lbl_1_data_260[var_r30], &sp20, &var_r31->unk_14[0], 0); + sp20.x = lbl_1_bss_588[var_r30].x + lbl_1_bss_590[var_r30 - 1].unk_2C[1].x; + sp20.y = lbl_1_bss_588[var_r30].y + lbl_1_bss_590[var_r30 - 1].unk_2C[1].y; + sp20.z = lbl_1_bss_588[var_r30].z + lbl_1_bss_590[var_r30 - 1].unk_2C[1].z; + fn_1_16E3C(&lbl_1_data_3BC[var_r30], &sp20, &var_r31->unk_2C[0], 0); + sp20.x = lbl_1_bss_584[var_r30].x + lbl_1_bss_590[var_r30 - 1].unk_50; + sp20.y = lbl_1_bss_584[var_r30].y + lbl_1_bss_590[var_r30 - 1].unk_54; + sp20.z = lbl_1_bss_584[var_r30].z + lbl_1_bss_590[var_r30 - 1].unk_58; + fn_1_16E3C(&lbl_1_bss_584[var_r30], &sp20, &var_r31->unk_44, 0); + } + else { + sp20.x = lbl_1_bss_584[var_r30 + 1].x - lbl_1_bss_584[var_r30].x; + sp20.y = lbl_1_bss_584[var_r30 + 1].y - lbl_1_bss_584[var_r30].y; + sp20.z = lbl_1_bss_584[var_r30 + 1].z - lbl_1_bss_584[var_r30].z; + var_r31->unk_6C = sqrtf((sp20.z * sp20.z) + ((sp20.x * sp20.x) + (sp20.y * sp20.y))); + fn_1_16E3C(&lbl_1_bss_58C[var_r30], &lbl_1_bss_58C[var_r31->unk_04], &var_r31->unk_14[0], 0); + fn_1_16E3C(&lbl_1_bss_588[var_r30], &lbl_1_bss_588[var_r31->unk_04], &var_r31->unk_2C[0], 0); + fn_1_16E3C(&lbl_1_bss_584[var_r30], &lbl_1_bss_584[var_r31->unk_04], &var_r31->unk_44, 0); + } + sp20.x = lbl_1_bss_58C[var_r30].x - lbl_1_bss_584[var_r30].x; + sp20.z = lbl_1_bss_58C[var_r30].z - lbl_1_bss_584[var_r30].z; + sp20.y = 0.0f; + var_r31->unk_5C = sqrtf((sp20.z * sp20.z) + ((sp20.x * sp20.x) + (sp20.y * sp20.y))); + sp20.x = lbl_1_bss_588[var_r30].x - lbl_1_bss_584[var_r30].x; + sp20.z = lbl_1_bss_588[var_r30].z - lbl_1_bss_584[var_r30].z; + sp20.y = 0.0f; + var_r31->unk_60 = sqrtf((sp20.z * sp20.z) + ((sp20.x * sp20.x) + (sp20.y * sp20.y))); + if (var_r31->unk_04 < 0) { + var_r31->unk_64 = var_r31->unk_5C; + var_r31->unk_68 = var_r31->unk_60; + } + else { + sp20.x = lbl_1_bss_58C[var_r31->unk_04].x - lbl_1_bss_584[var_r31->unk_04].x; + sp20.z = lbl_1_bss_58C[var_r31->unk_04].z - lbl_1_bss_584[var_r31->unk_04].z; + sp20.y = 0.0f; + var_r31->unk_64 = sqrtf((sp20.z * sp20.z) + ((sp20.x * sp20.x) + (sp20.y * sp20.y))); + sp20.x = lbl_1_bss_588[var_r31->unk_04].x - lbl_1_bss_584[var_r31->unk_04].x; + sp20.z = lbl_1_bss_588[var_r31->unk_04].z - lbl_1_bss_584[var_r31->unk_04].z; + sp20.y = 0.0f; + var_r31->unk_68 = sqrtf((sp20.z * sp20.z) + ((sp20.x * sp20.x) + (sp20.y * sp20.y))); + } + } + lbl_1_bss_558 = lbl_1_data_260; + lbl_1_bss_554 = lbl_1_data_3BC; + lbl_1_bss_550 = lbl_1_bss_584; + var_r29 = HuMemDirectMallocNum(HEAP_SYSTEM, 0x40 * sizeof(M427DllBss57CStruct), MEMORY_DEFAULT_NUM); + lbl_1_bss_57C = var_r29; + memset(lbl_1_bss_57C, 0, 0x40 * sizeof(M427DllBss57CStruct)); + for (var_r30 = 0; var_r30 < 0x40; var_r30++, var_r29++) { + var_r29->unk_00 = var_r30; + var_r29->unk_04 = -1; + var_r29->unk_08 = -1; + var_r29->unk_0C = 0; + var_r29->unk_10 = 0; + var_r29->unk_14 = var_r29->unk_18 = 0; + } +} + +void fn_1_13F24(void) +{ + M427DllBss57CStruct *var_r31; + s32 var_r30; + + for (var_r31 = lbl_1_bss_57C, var_r30 = 0; var_r30 < 0x40; var_r30 += 1, var_r31++) { + if ((var_r31->unk_04 >= 0) && (var_r31->unk_08 >= 0) && (var_r31->unk_18 >= 0)) { + if (++var_r31->unk_14 > var_r31->unk_18) { + fn_1_1607C(var_r30); + } + } + } +} + +void fn_1_13FB8(void) { } + +GXColor lbl_1_data_648 = { 0xFF, 0xFF, 0xFF, 0xFF }; +GXColor lbl_1_data_64C = { 0xFF, 0, 0, 0xFF }; +GXColor lbl_1_data_650 = { 0xFF, 0xFF, 0, 0xFF }; + +void fn_1_13FBC(ModelData *model, Mtx matrix) +{ + Mtx sp70; + float var_f31; + float var_f30; + float var_f29; + M427DllBss57CStruct *var_r31; + M427DllBss590Struct *var_r30; + s16 var_r29; + s16 var_r28; + M427DllPlayerWork *var_r27; + M427DllPlayerWork2 *var_r26; + s32 *var_r25; + omObjData *var_r24; + + var_r25 = model->unk_120; + var_r27 = &lbl_1_bss_578[*var_r25]; + var_r24 = lbl_1_bss_56C[*var_r25]; + GXLoadPosMtxImm(matrix, 0); + PSMTXInvXpose(matrix, sp70); + GXLoadNrmMtxImm(sp70, 0); + GXSetNumTevStages(1); + GXSetNumTexGens(1); + GXSetNumChans(1); + GXSetTexCoordGen2(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, 0x3C, GX_FALSE, 0x7D); + GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0); + GXSetTevOp(GX_TEVSTAGE0, GX_REPLACE); + GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_RASC); + GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVREG0); + GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_KONST); + GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVREG0); + GXSetChanCtrl(GX_COLOR0A0, 1, GX_SRC_VTX, GX_SRC_VTX, 0, GX_DF_CLAMP, GX_AF_SPEC); + GXSetAlphaCompare(GX_GEQUAL, 1, GX_AOP_AND, GX_GEQUAL, 1); + GXSetZMode(GX_TRUE, GX_LEQUAL, GX_FALSE); + GXSetZCompLoc(GX_FALSE); + GXSetBlendMode(GX_BM_BLEND, GX_BL_ONE, GX_BL_ZERO, GX_LO_NOOP); + GXSetLineWidth(0x10, GX_TO_ZERO); + GXClearVtxDesc(); + GXSetVtxDesc(GX_VA_POS, GX_INDEX16); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_TEX_ST, GX_RGBA6, 0); + GXSetArray(GX_VA_POS, lbl_1_data_260, sizeof(Vec)); + GXSetVtxDesc(GX_VA_CLR0, GX_INDEX16); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_TEX_ST, GX_RGBA8, 0); + GXSetArray(GX_VA_CLR0, &lbl_1_data_648, sizeof(GXColor)); + GXBegin(GX_LINESTRIP, GX_VTXFMT0, 0x1D); + for (var_r29 = 0; var_r29 < 0x1DU; var_r29++) { + GXPosition1x16(var_r29); + GXColor1x16(0); + } + GXClearVtxDesc(); + GXSetVtxDesc(GX_VA_POS, GX_INDEX16); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0); + GXSetArray(GX_VA_POS, &lbl_1_data_3BC, sizeof(Vec)); + GXSetVtxDesc(GX_VA_CLR0, GX_INDEX16); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0); + GXSetArray(GX_VA_CLR0, &lbl_1_data_648, sizeof(GXColor)); + GXBegin(GX_LINESTRIP, GX_VTXFMT0, 0x1D); + for (var_r29 = 0; var_r29 < 0x1DU; var_r29++) { + GXPosition1x16(var_r29); + GXColor1x16(0); + } + GXClearVtxDesc(); + GXSetVtxDesc(GX_VA_POS, GX_INDEX16); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0); + GXSetArray(GX_VA_POS, lbl_1_bss_584, sizeof(Vec)); + GXSetVtxDesc(GX_VA_CLR0, GX_INDEX16); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0); + GXSetArray(GX_VA_CLR0, &lbl_1_data_650, sizeof(GXColor)); + GXBegin(GX_LINESTRIP, GX_VTXFMT0, 0x1D); + for (var_r29 = 0; var_r29 < lbl_1_bss_580; var_r29++) { + GXPosition1x16(var_r29); + GXColor1x16(0); + } + GXClearVtxDesc(); + GXSetVtxDesc(GX_VA_POS, GX_DIRECT); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0); + GXSetVtxDesc(GX_VA_CLR0, GX_DIRECT); + GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0); + GXBegin(GX_LINES, GX_VTXFMT0, lbl_1_bss_580 * 4); + for (var_r30 = lbl_1_bss_590, var_r29 = 0; var_r29 < lbl_1_bss_580; var_r29++, var_r30++) { + GXPosition3f32(var_r30->unk_78->x, var_r30->unk_78->y, var_r30->unk_78->z); + GXColor4u8(lbl_1_data_64C.r, lbl_1_data_64C.g, lbl_1_data_64C.b, lbl_1_data_64C.a); + GXPosition3f32(var_r30->unk_80->x, var_r30->unk_80->y, var_r30->unk_80->z); + GXColor4u8(lbl_1_data_64C.r, lbl_1_data_64C.g, lbl_1_data_64C.b, lbl_1_data_64C.a); + GXPosition3f32(var_r30->unk_7C->x, var_r30->unk_7C->y, var_r30->unk_7C->z); + GXColor4u8(lbl_1_data_64C.r, lbl_1_data_64C.g, lbl_1_data_64C.b, lbl_1_data_64C.a); + GXPosition3f32(var_r30->unk_80->x, var_r30->unk_80->y, var_r30->unk_80->z); + GXColor4u8(lbl_1_data_64C.r, lbl_1_data_64C.g, lbl_1_data_64C.b, lbl_1_data_64C.a); + } + for (var_r29 = 0, var_r31 = lbl_1_bss_57C; var_r29 < 0x40; var_r29++, var_r31++) { + if ((var_r31->unk_04 >= 0) && (var_r31->unk_08 >= 0) && (var_r31->unk_10 == *var_r25) && (var_r31->unk_04 == 1)) { + switch (var_r31->unk_08) { + case 0: + GXBegin(GX_LINESTRIP, GX_VTXFMT0, 5); + var_f31 = 200.0f + fn_1_15714(var_r31->unk_1C.x, var_r31->unk_1C.z); + GXPosition3f32(var_r31->unk_1C.x, var_f31, var_r31->unk_1C.z); + GXColor4u8(0, 0xFF, 0, 0xFF); + GXPosition3f32(var_r31->unk_28.x, var_f31, var_r31->unk_1C.z); + GXColor4u8(0, 0xFF, 0, 0xFF); + GXPosition3f32(var_r31->unk_28.x, var_f31, var_r31->unk_28.z); + GXColor4u8(0, 0xFF, 0, 0xFF); + GXPosition3f32(var_r31->unk_1C.x, var_f31, var_r31->unk_28.z); + GXColor4u8(0, 0xFF, 0, 0xFF); + GXPosition3f32(var_r31->unk_1C.x, var_f31, var_r31->unk_1C.z); + GXColor4u8(0, 0xFF, 0, 0xFF); + break; + case 1: + GXBegin(GX_LINESTRIP, GX_VTXFMT0, 0xA); + var_f31 = 200.0f + fn_1_15714(var_r31->unk_1C.x, var_r31->unk_1C.z); + for (var_r28 = 0; var_r28 < 0xA; var_r28++) { + var_f30 = var_r31->unk_1C.x + (var_r31->unk_34 * sind((40.0f * var_r28))); + var_f29 = var_r31->unk_1C.z + (var_r31->unk_34 * cosd((40.0f * var_r28))); + GXPosition3f32(var_f30, var_f31, var_f29); + GXColor4u8(0, 0xFF, 0, 0xFF); + } + break; + } + } + } + for (var_r29 = 0, var_r31 = lbl_1_bss_57C; var_r29 < 0x40; var_r29++, var_r31++) { + if ((var_r31->unk_04 >= 0) && (var_r31->unk_08 >= 0) && (var_r31->unk_10 == *var_r25) && (var_r31->unk_04 == 0)) { + switch (var_r31->unk_08) { + case 0: + GXBegin(GX_LINESTRIP, GX_VTXFMT0, 5); + var_f31 = 200.0f + fn_1_15714(var_r31->unk_1C.x, var_r31->unk_1C.z); + GXPosition3f32(var_r31->unk_1C.x, var_f31, var_r31->unk_1C.z); + GXColor4u8(0, 0, 0xFF, 0xFF); + GXPosition3f32(var_r31->unk_28.x, var_f31, var_r31->unk_1C.z); + GXColor4u8(0, 0, 0xFF, 0xFF); + GXPosition3f32(var_r31->unk_28.x, var_f31, var_r31->unk_28.z); + GXColor4u8(0, 0, 0xFF, 0xFF); + GXPosition3f32(var_r31->unk_1C.x, var_f31, var_r31->unk_28.z); + GXColor4u8(0, 0, 0xFF, 0xFF); + GXPosition3f32(var_r31->unk_1C.x, var_f31, var_r31->unk_1C.z); + GXColor4u8(0, 0, 0xFF, 0xFF); + break; + case 1: + GXBegin(GX_LINESTRIP, GX_VTXFMT0, 0xA); + var_f31 = 200.0f + fn_1_15714(var_r31->unk_1C.x, var_r31->unk_1C.z); + for (var_r28 = 0; var_r28 < 0xA; var_r28++) { + var_f30 = var_r31->unk_1C.x + (var_r31->unk_34 * sind((40.0f * var_r28))); + var_f29 = var_r31->unk_1C.z + (var_r31->unk_34 * cosd((40.0f * var_r28))); + GXPosition3f32(var_f30, var_f31, var_f29); + GXColor4u8(0, 0, 0xFF, 0xFF); + } + break; + } + } + } + if ((var_r24 == NULL) || (var_r27 == NULL)) { + return; + } + if ((var_r27->unk_00[0] == NULL) || (var_r27->unk_08[0] == NULL)) { + return; + } + GXBegin(GX_LINESTRIP, GX_VTXFMT0, 0xA); + var_f31 = 100.0f + var_r24->trans.y; + for (var_r28 = 0; var_r28 < 0xA; var_r28++) { + var_f30 = var_r24->trans.x + (200.0 * sind((40.0f * var_r28))); + var_f30 = var_f30; + var_f29 = var_r24->trans.z + (200.0 * cosd((40.0f * var_r28))); + var_f29 = var_f29; + GXPosition3f32(var_f30, var_f31, var_f29); + GXColor4u8(0xFF, 0, 0xFF, 0xFF); + } + GXBegin(GX_LINESTRIP, GX_VTXFMT0, 4); + var_r26 = var_r27->unk_08[0]; + var_f30 = var_r26->unk_68; + var_f29 = var_r26->unk_70; + var_f31 = 100.0f + fn_1_15714(var_f30, var_f29); + GXPosition3f32(var_f30, var_f31, var_f29); + GXColor4u8(0xFF, 0x80, 0, 0xFF); + GXPosition3f32(100.0f + var_f30, 200.0f + var_f31, var_f29); + GXColor4u8(0xFF, 0x80, 0, 0xFF); + GXPosition3f32(var_f30 - 100.0f, 200.0f + var_f31, var_f29); + GXColor4u8(0xFF, 0x80, 0, 0xFF); + GXPosition3f32(var_f30, var_f31, var_f29); + GXColor4u8(0xFF, 0x80, 0, 0xFF); + GXBegin(GX_LINESTRIP, GX_VTXFMT0, 4); + var_r26 = var_r27->unk_08[1]; + var_f30 = var_r26->unk_68; + var_f29 = var_r26->unk_70; + var_f31 = 100.0f + fn_1_15714(var_f30, var_f29); + GXPosition3f32(var_f30, var_f31, var_f29); + GXColor4u8(0, 0x80, 0xFF, 0xFF); + GXPosition3f32(100.0f + var_f30, 200.0f + var_f31, var_f29); + GXColor4u8(0, 0x80, 0xFF, 0xFF); + GXPosition3f32(var_f30 - 100.0f, 200.0f + var_f31, var_f29); + GXColor4u8(0, 0x80, 0xFF, 0xFF); + GXPosition3f32(var_f30, var_f31, var_f29); + GXColor4u8(0, 0x80, 0xFF, 0xFF); +} + +void fn_1_154B8(void) { } + +s32 fn_1_154BC(float arg8, float arg9, float argA) +{ + float var_f31; + float var_f30; + float var_f29; + float var_f28; + float var_f27; + s32 var_r31; + s32 var_r30; + + var_r30 = -1; + var_f27 = 1e7f; + for (var_r31 = 0; var_r31 < lbl_1_bss_580; var_r31++) { + var_f31 = lbl_1_bss_590[var_r31].unk_80->x - arg8; + var_f30 = lbl_1_bss_590[var_r31].unk_80->y - arg9; + var_f29 = lbl_1_bss_590[var_r31].unk_80->z - argA; + var_f28 = (var_f29 * var_f29) + ((var_f31 * var_f31) + (var_f30 * var_f30)); + if (var_f28 < var_f27) { + var_r30 = var_r31; + var_f27 = var_f28; + } + } + return var_r30; +} + +s32 fn_1_155E0(float arg8, float arg9, float argA, float *arg0) +{ + float var_f31; + float var_f30; + double var_f29; + double var_f28; + M427DllBss590Struct *var_r31; + s32 var_r30; + M427DllBss590Struct *var_r29; + + for (var_r30 = 0; var_r30 < (lbl_1_bss_580 - 1); var_r30++) { + var_r31 = &lbl_1_bss_590[var_r30]; + var_r29 = &lbl_1_bss_590[var_r30 + 1]; + if ((argA < var_r31->unk_80->z) && (argA >= var_r29->unk_80->z)) { + var_f31 = var_r29->unk_80->z - var_r31->unk_80->z; + if ((arg0 != NULL) && (var_f31 != 0.0f)) { + *arg0 = fabs((argA - var_r31->unk_80->z) / var_f31); + } + break; + } + } + return var_r30; +} + +float fn_1_15714(float arg8, float arg9) +{ + float sp8; + M427DllBss590Struct *var_r31; + s32 var_r28; + M427DllBss590Struct *var_r26; + + var_r28 = fn_1_155E0(0.0f, 0.0f, arg9, &sp8); + var_r31 = &lbl_1_bss_590[var_r28]; + if ((var_r28 < 0) || (var_r28 >= (lbl_1_bss_580 - 1))) { + return var_r31->unk_80->y; + } + var_r26 = &lbl_1_bss_590[var_r28 + 1]; + return var_r31->unk_80->y + (sp8 * (var_r26->unk_80->y - var_r31->unk_80->y)); +} + +void fn_1_158D8(float arg8, float var_f30, Vec *var_r31) +{ + float sp8; + M427DllBss590Struct *var_r30; + M427DllBss590Struct *var_r29; + s32 var_r26; + + var_r31->x = var_r31->y = var_r31->z = 0.0f; + var_r26 = fn_1_155E0(0.0f, 0.0f, var_f30, &sp8); + var_r30 = &lbl_1_bss_590[var_r26]; + if ((var_r26 < 0) || (var_r26 >= (lbl_1_bss_580 - 1))) { + return; + } + var_r29 = &lbl_1_bss_590[var_r26 + 1]; + if (var_r30->unk_80->y > var_r29->unk_80->y) { + var_r31->x = var_r29->unk_80->x - var_r30->unk_80->x; + var_r31->z = var_r29->unk_80->z - var_r30->unk_80->z; + VECNormalize(var_r31, var_r31); + } +} + +s32 fn_1_15AF0(s32 arg0, Vec *arg1, Vec *arg2, Vec *arg3, Vec *arg4) +{ + Vec sp3C; + Vec sp30; + Vec sp24; + Vec sp18; + Vec spC; + float sp8; + float var_f31; + float var_f29; + M427DllBss590Struct *var_r30; + + *arg3 = *arg2; + arg4->x = arg4->y = arg4->z = 0.0f; + if (arg0 < 0) { + arg0 = fn_1_155E0(0.0f, 0.0f, arg2->z, &sp8); + } + if ((arg0 < 0) || (arg0 >= (lbl_1_bss_580 - 1))) { + return 0; + } + var_r30 = &lbl_1_bss_590[arg0]; + sp3C.x = arg2->x - arg1->x; + sp3C.y = arg2->y - arg1->y; + sp3C.z = arg2->z - arg1->z; + VECNormalize(&sp3C, &sp3C); + spC.x = var_r30->unk_44.x + (sp8 * var_r30->unk_50); + spC.y = var_r30->unk_44.y + (sp8 * var_r30->unk_54); + spC.z = var_r30->unk_44.z + (sp8 * var_r30->unk_58); + var_f29 = fabs(arg2->x - spC.x); + if (arg2->x < spC.x) { + var_f31 = var_r30->unk_5C + (sp8 * (var_r30->unk_64 - var_r30->unk_5C)); + if (var_f29 > var_f31) { + sp30 = *arg2; + fn_1_17048(var_r30->unk_14, NULL, &sp30, &sp24); + arg3->x = sp24.x; + arg3->y = sp24.y; + arg3->z = sp24.z; + arg4->x = arg3->x - arg2->x; + arg4->y = arg3->y - arg2->y; + arg4->z = arg3->z - arg2->z; + return 1; + } + goto block_18; + } + var_f31 = var_r30->unk_60 + (sp8 * (var_r30->unk_68 - var_r30->unk_60)); + if (var_f29 > var_f31) { + sp30 = *arg2; + fn_1_17048(var_r30->unk_2C, NULL, &sp30, &sp18); + arg3->x = sp18.x; + arg3->y = sp18.y; + arg3->z = sp18.z; + arg4->x = arg3->x - arg2->x; + arg4->y = arg3->y - arg2->y; + arg4->z = arg3->z - arg2->z; + return 1; + } +block_18: + return 0; +} + +s32 fn_1_15F10(Vec *arg0, Vec *arg1, s32 arg2, s32 arg3, s32 arg4) +{ + M427DllBss57CStruct *var_r31; + s32 var_r30; + + for (var_r31 = lbl_1_bss_57C, var_r30 = 0; var_r30 < 0x40; var_r30++, var_r31++) { + if ((var_r31->unk_04 < 0) || (var_r31->unk_08 < 0)) { + break; + } + } + if (var_r30 >= 0x40) { + return -1; + } + var_r31->unk_04 = arg2; + var_r31->unk_08 = 0; + var_r31->unk_0C = 0; + var_r31->unk_10 = arg4; + var_r31->unk_18 = arg3; + var_r31->unk_14 = 0; + var_r31->unk_1C = *arg0; + var_r31->unk_28 = *arg1; + return var_r30; +} + +s32 fn_1_15FD0(Vec *arg0, s32 arg1, s32 arg2, s32 arg3, float arg8) +{ + M427DllBss57CStruct *var_r31; + s32 var_r30; + + for (var_r31 = lbl_1_bss_57C, var_r30 = 0; var_r30 < 0x40; var_r30++, var_r31++) { + if ((var_r31->unk_04 < 0) || (var_r31->unk_08 < 0)) { + break; + } + } + if (var_r30 >= 0x40) { + return -1; + } + var_r31->unk_04 = arg1; + var_r31->unk_08 = 1; + var_r31->unk_0C = 0; + var_r31->unk_10 = arg3; + var_r31->unk_18 = arg2; + var_r31->unk_14 = 0; + var_r31->unk_1C = *arg0; + var_r31->unk_34 = arg8; + return var_r30; +} + +void fn_1_1607C(s32 arg0) +{ + M427DllBss57CStruct *var_r31; + + if ((arg0 < 0) || (arg0 >= 0x40)) { + return; + } + var_r31 = &lbl_1_bss_57C[arg0]; + var_r31->unk_04 = -1; + var_r31->unk_08 = -1; + var_r31->unk_14 = var_r31->unk_18 = 0; +} + +s32 fn_1_160D4(s32 arg0, Vec *arg1, float arg8) +{ + float var_f31; + float var_f30; + float var_f29; + M427DllBss57CStruct *var_r31; + s32 var_r30; + + for (var_r31 = lbl_1_bss_57C, var_r30 = 0; var_r30 < 0x40; var_r30++, var_r31++) { + if ((var_r31->unk_04 >= 0) && (var_r31->unk_08 >= 0) && (var_r31->unk_10 == arg0) && ((var_r31->unk_04 == 1) || (var_r31->unk_04 == 2))) { + switch (var_r31->unk_08) { + case 0: + var_f31 = arg1->x - var_r31->unk_1C.x; + var_f30 = arg1->z - var_r31->unk_1C.z; + if ((arg1->x >= (var_r31->unk_1C.x - arg8)) && (arg1->x <= (var_r31->unk_28.x + arg8)) && (arg1->z >= (var_r31->unk_1C.z - arg8)) + && (arg1->z <= (var_r31->unk_28.z + arg8))) { + return 1; + } + break; + case 1: + var_f31 = arg1->x - var_r31->unk_1C.x; + var_f30 = arg1->z - var_r31->unk_1C.z; + var_f29 = var_r31->unk_34 + arg8; + if (((var_f31 * var_f31) + (var_f30 * var_f30)) < (var_f29 * var_f29)) { + return 1; + } + break; + } + } + } + return 0; +} + +s32 fn_1_16260(s32 arg0, Vec *arg2, Vec *arg3, Vec *arg4, float arg8) +{ + float var_f31; + float var_f30; + float var_f28; + M427DllBss57CStruct *var_r31; + s32 var_r30; + + *arg4 = *arg3; + for (var_r31 = lbl_1_bss_57C, var_r30 = 0; var_r30 < 0x40; var_r30++, var_r31++) { + if ((var_r31->unk_04 >= 0) && (var_r31->unk_08 >= 0) && (var_r31->unk_10 == arg0) && ((var_r31->unk_04 == 0) || (var_r31->unk_04 == 2))) { + switch (var_r31->unk_08) { + case 0: + var_f31 = arg3->x - var_r31->unk_1C.x; + var_f30 = arg3->z - var_r31->unk_1C.z; + if ((arg3->x >= (var_r31->unk_1C.x - arg8)) && (arg3->x <= (var_r31->unk_28.x + arg8)) && (arg3->z >= (var_r31->unk_1C.z - arg8)) + && (arg3->z <= (var_r31->unk_28.z + arg8))) { + return 1; + } + break; + case 1: + var_f31 = arg3->x - var_r31->unk_1C.x; + var_f30 = arg3->z - var_r31->unk_1C.z; + var_f28 = var_r31->unk_34 + arg8; + if (((var_f31 * var_f31) + (var_f30 * var_f30)) < (var_f28 * var_f28)) { + var_f28 = sqrtf((var_f31 * var_f31) + (var_f30 * var_f30)); + if (var_f28 == 0.0f) { + var_f31 = 0.0f; + var_f30 = 1.0f; + } + else { + var_f31 /= var_f28; + var_f30 /= var_f28; + } + var_f28 = var_r31->unk_34 + arg8; + arg4->x = var_r31->unk_1C.x + (var_f31 * var_f28); + arg4->z = var_r31->unk_1C.z + (var_f30 * var_f28); + arg4->y = arg3->y; + return 1; + } + break; + } + } + } + return 0; +} + +float fn_1_16594(float arg8, float arg9) +{ + float var_f31; + + if (arg8 >= 360.0f) { + arg8 -= 360.0f; + } + else if (arg8 < 0.0f) { + arg8 += 360.0f; + } + if (arg9 >= 360.0f) { + arg9 -= 360.0f; + } + else if (arg9 < 0.0f) { + arg9 += 360.0f; + } + var_f31 = arg8 - arg9; + if (var_f31 <= -180.0f) { + var_f31 += 360.0f; + } + else if (var_f31 >= 180.0f) { + var_f31 -= 360.0f; + } + return var_f31; +} + +float fn_1_166AC(float arg8, float arg9, float argA) +{ + float var_f31; + float var_f30; + float var_f26; + + if (arg8 >= 360.0) { + arg8 -= 360.0; + } + else if (arg8 < 0.0) { + arg8 += 360.0; + } + if (arg9 >= 360.0) { + arg9 -= 360.0; + } + else if (arg9 < 0.0) { + arg9 += 360.0; + } + var_f30 = 360.0 + (arg8 - arg9); + if (fabs(var_f30) >= 360.0) { + var_f30 = fmod(var_f30, 360.0); + } + if (var_f30 < 180.0) { + if (var_f30 <= argA) { + var_f31 = var_f30; + } + else { + var_f31 = argA; + } + } + else if ((360.0 - var_f30) <= argA) { + var_f31 = -(360.0 - var_f30); + } + else { + var_f31 = -argA; + } + var_f31 += arg9; + if (var_f31 >= 360.0) { + var_f31 -= 360.0; + } + else if (var_f31 < 0.0) { + var_f31 += 360.0; + } + return var_f31; +} + +float fn_1_168FC(float arg8, float arg9, float argA) +{ + float var_f24; + float var_f23; + + var_f23 = fn_1_16594(argA, arg9); + var_f24 = fabs(var_f23 * arg8); + return fn_1_166AC(argA, arg9, var_f24); +} + +void fn_1_16CF4(Vec *arg0, Vec *arg1, Vec *arg2, Vec *arg3) +{ + Vec sp14; + Vec sp8; + + sp14.x = arg1->x - arg0->x; + sp14.y = arg1->y - arg0->y; + sp14.z = arg1->z - arg0->z; + sp8.x = arg2->x - arg0->x; + sp8.y = arg2->y - arg0->y; + sp8.z = arg2->z - arg0->z; + arg3->x = (sp14.y * sp8.z) - (sp14.z * sp8.y); + arg3->y = (sp14.z * sp8.x) - (sp14.x * sp8.z); + arg3->z = (sp14.x * sp8.y) - (sp14.y * sp8.x); + VECNormalize(arg3, arg3); + arg3[1].x = (arg3->z * arg0->z) + ((arg3->x * arg0->x) + (arg3->y * arg0->y)); +} + +void fn_1_16E3C(Vec *arg0, Vec *arg1, Vec *arg2, s32 arg3) +{ + Vec spC; + + spC.x = arg1->x - arg0->x; + spC.y = arg1->y - arg0->y; + spC.z = arg1->z - arg0->z; + if (arg3 != 0) { + VECNormalize(&spC, &spC); + } + arg2->x = arg0->x; + arg2->y = arg0->y; + arg2->z = arg0->z; + arg2[1].x = spC.x; + arg2[1].y = spC.y; + arg2[1].z = spC.z; +} + +void fn_1_16EF8(Vec *arg0, float *arg1, Vec *arg2, Vec *arg3) +{ + float var_f31; + float var_f30; + float var_f29; + + var_f30 = (arg0[1].z * arg0[1].z) + ((arg0[1].x * arg0[1].x) + (arg0[1].y * arg0[1].y)); + var_f29 = (-arg0[0].z * arg0[1].z) + (arg2->z * arg0[1].z) + + ((-arg0[0].x * arg0[1].x) + (arg2->x * arg0[1].x) + ((-arg0[0].y * arg0[1].y) + (arg2->y * arg0[1].y))); + if (var_f30 != 0.0f) { + var_f31 = var_f29 / var_f30; + } + else { + var_f31 = 0.0f; + } + if (arg3 != NULL) { + arg3->x = arg0[0].x + (var_f31 * arg0[1].x); + arg3->y = arg0[0].y + (var_f31 * arg0[1].y); + arg3->z = arg0[0].z + (var_f31 * arg0[1].z); + } + if (arg1 != NULL) { + *arg1 = var_f31; + } +} + +typedef struct Vec3d { + double x; + double y; + double z; +} Vec3d; + +void fn_1_17048(Vec *arg0, float *arg1, Vec *arg2, Vec *arg3) +{ + Vec3d sp38; + Vec3d sp20; + Vec3d sp8; + double var_f31; + double var_f30; + double var_f29; + + sp20.x = 0.0; + sp20.y = 0.0; + sp20.z = 0.0; + sp38.x = arg0[1].x; + sp38.y = arg0[1].y; + sp38.z = arg0[1].z; + sp8.x = arg2->x - arg0->x; + sp8.y = arg2->y - arg0->y; + sp8.z = arg2->z - arg0->z; + + var_f30 = (sp38.z * arg0[1].z) + ((sp38.x * arg0[1].x) + (sp38.y * arg0[1].y)); + var_f29 = (-sp20.z * sp38.z) + (sp8.z * sp38.z) + ((-sp20.x * sp38.x) + (sp8.x * sp38.x) + ((-sp20.y * sp38.y) + (sp8.y * sp38.y))); + if (0.0 != var_f30) { + var_f31 = var_f29 / var_f30; + } + else { + var_f31 = 0.0; + } + if (arg3 != NULL) { + arg3->x = arg0->x + (float)(sp20.x + (var_f31 * sp38.x)); + arg3->y = arg0->y + (float)(sp20.y + (var_f31 * sp38.y)); + arg3->z = arg0->z + (float)(sp20.z + (var_f31 * sp38.z)); + } + if (arg1 != NULL) { + *arg1 = var_f31; + } +} + +void fn_1_17238(void) { } + +void fn_1_1723C(Mtx arg0, Vec *arg1) +{ + Vec sp8; + + sp8.x = (arg0[0][2] * arg1->z) + ((arg0[0][0] * arg1->x) + (arg0[0][1] * arg1->y)); + sp8.y = (arg0[1][2] * arg1->z) + ((arg0[1][0] * arg1->x) + (arg0[1][1] * arg1->y)); + sp8.z = (arg0[2][2] * arg1->z) + ((arg0[2][0] * arg1->x) + (arg0[2][1] * arg1->y)); + *arg1 = sp8; +} + +void fn_1_172F0(s32 arg0, float arg8) +{ + HsfMaterial *var_r31; + s32 var_r30; + HsfData *var_r29; + s32 var_r28; + ModelData *var_r27; + s32 var_r26; + + var_r27 = &Hu3DData[arg0]; + var_r29 = var_r27->hsfData; + var_r31 = var_r29->material; + var_r26 = var_r29->materialCnt; + for (var_r28 = 0; var_r28 < var_r26; var_r28++, var_r31++) { + var_r31->vtxMode = 1; + var_r30 = var_r31->litColor[0] * arg8; + if (var_r30 > 0xFF) { + var_r30 = 0xFF; + } + var_r31->litColor[0] = var_r30; + var_r30 = var_r31->litColor[1] * arg8; + if (var_r30 > 0xFF) { + var_r30 = 0xFF; + } + var_r31->litColor[1] = var_r30; + var_r30 = var_r31->litColor[2] * arg8; + if (var_r30 > 0xFF) { + var_r30 = 0xFF; + } + var_r31->litColor[2] = var_r30; + } +} + +s32 fn_1_17430(s32 arg0, s32 arg1, s32 arg2) +{ + s32 var_r31; + ModelData *var_r30; + ModelData *var_r29; + + var_r29 = &Hu3DData[arg0]; + var_r30 = &Hu3DData[arg2]; + for (var_r31 = 0; var_r31 < 8; var_r31++) { + if (var_r30->unk_38[var_r31] == -1) { + break; + } + } + if (var_r31 == 8) { + return -1; + } + var_r30->unk_38[var_r31] = var_r29->unk_38[arg1]; + var_r30->attr |= 0x1000; + return var_r31; +} diff --git a/src/REL/m428Dll/map.c b/src/REL/m428Dll/map.c index ce4c7764..925c04bc 100644 --- a/src/REL/m428Dll/map.c +++ b/src/REL/m428Dll/map.c @@ -631,7 +631,7 @@ void fn_1_6280(ModelData *arg1, ParticleData *particle, Mtx matrix) break; } for (var_r31 = particle->unk_48, var_r27 = 0, var_r28 = 0; var_r28 < particle->unk_30; var_r28++, var_r31++) { - switch (var_r31->unk00_s16) { + switch (var_r31->unk00) { case 0: if (((var_r28 > (0.4f * particle->unk_30)) && (particle->unk_04.x == 0.0f)) || (var_r27 >= (10.0f + (0.75f * particle->unk_04.x)))) { var_r31->unk2C = 0.01f; @@ -662,7 +662,7 @@ void fn_1_6280(ModelData *arg1, ParticleData *particle, Mtx matrix) var_r31->unk40.r = var_r31->unk40.g = var_r31->unk40.b = 0xFF; var_r31->unk02 = 0; var_r27++; - var_r31->unk00_s16++; + var_r31->unk00++; } break; case 1: diff --git a/src/REL/m430Dll/player.c b/src/REL/m430Dll/player.c index ca486592..baa21d63 100644 --- a/src/REL/m430Dll/player.c +++ b/src/REL/m430Dll/player.c @@ -2044,7 +2044,7 @@ void fn_1_11D70(void) var_r25 = &Hu3DData[var_r31->unk_04]; var_r29 = var_r25->unk_120; for (var_r30 = var_r29->unk_48, var_r27 = 0; var_r27 < var_r29->unk_30; var_r27++, var_r30++) { - if (++var_r30->unk00_s16 > var_r30->unk02) { + if (++var_r30->unk00 > var_r30->unk02) { var_r24 = var_r30->unk40.a - 9; if (var_r24 < 0) { var_r30->unk2C = 0.0f; diff --git a/src/REL/m430Dll/water.c b/src/REL/m430Dll/water.c index 4cdcef5c..cfb782c7 100644 --- a/src/REL/m430Dll/water.c +++ b/src/REL/m430Dll/water.c @@ -1637,15 +1637,15 @@ void fn_1_AD04(ModelData *model, ParticleData *particle, Mtx matrix) return; } for (var_r31 = particle->unk_48, var_r29 = 0; var_r29 < particle->unk_30; var_r29++, var_r31++) { - if (var_r31->unk00_s16 != 0) { + if (var_r31->unk00 != 0) { VECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34); VECScale(&var_r31->unk08, &var_r31->unk08, 0.97f); - if (var_r31->unk00_s16 < 24.0f) { + if (var_r31->unk00 < 24.0f) { var_r31->unk40.a = 0.9f * var_r31->unk40.a; } var_r31->unk2C += 1.5f; - if (--var_r31->unk00_s16 == 0) { - var_r31->unk00_s16 = 0; + if (--var_r31->unk00 == 0) { + var_r31->unk00 = 0; var_r31->unk2C = 0.0f; var_r31->unk40.a = 0; } @@ -1676,7 +1676,7 @@ void fn_1_AEE0(s32 arg0, Vec *arg1, float arg8, float arg9) var_r27 = 1; var_f28 = 30.0f; for (var_r29 = 0; var_r29 < var_r30->unk_30; var_r29++, var_r31++) { - if (var_r31->unk00_s16 == 0) { + if (var_r31->unk00 == 0) { var_r31->unk00 = 60.0f * (0.5f + (0.0005f * frandmod(0x3E8))); var_f30 = (0.002f * frandmod(0x3E8)) - 1.0f; var_f30 = arg8 + (var_f30 * var_f28); @@ -1714,22 +1714,22 @@ void fn_1_B394(ModelData *model, ParticleData *var_r30, Mtx matrix) if ((var_r30->unk_00 == 0) || (lbl_1_bss_5C != 0)) { var_r30->unk_00++; for (var_r31 = var_r30->unk_48, var_r29 = 0; var_r29 < var_r30->unk_30; var_r29++, var_r31++) { - var_r31->unk00_s16 = 0; + var_r31->unk00 = 0; var_r31->unk2C = 0.0f; var_r31->unk40.a = 0; } return; } for (var_r31 = var_r30->unk_48, var_r29 = 0; var_r29 < var_r30->unk_30; var_r29++, var_r31++) { - if (var_r31->unk00_s16 != 0) { - var_r31->unk00_s16--; + if (var_r31->unk00 != 0) { + var_r31->unk00--; VECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34); var_r31->unk2C += 0.5f; - if (var_r31->unk00_s16 < 30.0) { + if (var_r31->unk00 < 30.0) { var_r31->unk40.a = 0.98f * var_r31->unk40.a; } - if ((var_r31->unk34.y < -40.0f) || (var_r31->unk00_s16 == 0)) { - var_r31->unk00_s16 = 0; + if ((var_r31->unk34.y < -40.0f) || (var_r31->unk00 == 0)) { + var_r31->unk00 = 0; var_r31->unk2C = 0.0f; var_r31->unk40.a = 0; } @@ -1766,8 +1766,8 @@ void fn_1_B570(s32 arg0, Vec *arg1, float arg8, float arg9, Vec *arg2) VECScale(arg2, &sp1C, 0.2f); sp1C.x = 0.0f; for (var_r29 = 0; var_r29 < var_r30->unk_30; var_r29++, var_r31++) { - if (var_r31->unk00_s16 == 0) { - var_r31->unk00_s16 = 60.0f * (0.5f + (0.0005f * frandmod(0x3E8))); + if (var_r31->unk00 == 0) { + var_r31->unk00 = 60.0f * (0.5f + (0.0005f * frandmod(0x3E8))); var_f30 = (0.002f * frandmod(0x3E8)) - 1.0f; var_f30 = arg8 + sp14[var_r29 & 1] + (var_f30 * var_f28); sp28.x = sind(var_f30); diff --git a/src/REL/m433Dll/player.c b/src/REL/m433Dll/player.c index 7b69466d..b6ef317c 100644 --- a/src/REL/m433Dll/player.c +++ b/src/REL/m433Dll/player.c @@ -2174,7 +2174,7 @@ void fn_1_BD48(omObjData *object) for (var_r27 = ((ParticleData *)Hu3DData[var_r28].unk_120)->unk_48, var_r29 = 0; var_r29 < 0xC8; var_r29++, var_r27++) { var_r27->unk2C = 0.0f; var_r27->unk40.a = 0; - var_r27->unk00_s16 = 0; + var_r27->unk00 = 0; } object->model[9] = Hu3DModelCreateFile(DATA_MAKE_NUM(DATADIR_M433, 2)); Hu3DModelScaleSet(object->model[9], 1.05f, 1.05f, 1.05f); @@ -2581,18 +2581,18 @@ void fn_1_D6A8(ModelData *model, ParticleData *particle, Mtx matrix) s32 var_r29; for (var_r31 = particle->unk_48, var_r29 = 0; var_r29 < particle->unk_30; var_r29++, var_r31++) { - if (var_r31->unk00_s16 != 0) { + if (var_r31->unk00 != 0) { VECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34); var_r31->unk08.x *= 0.92f; var_r31->unk08.z *= 0.92f; var_r31->unk08.y += -0.27222225f; var_r31->unk2C += 2.0f; var_r31->unk40.a *= 0.99f; - if (var_r31->unk00_s16 < 24.0f) { + if (var_r31->unk00 < 24.0f) { var_r31->unk40.a = 0.9f * var_r31->unk40.a; } - if (--var_r31->unk00_s16 == 0) { - var_r31->unk00_s16 = 0; + if (--var_r31->unk00 == 0) { + var_r31->unk00 = 0; var_r31->unk2C = 0.0f; var_r31->unk40.a = 0; } @@ -2613,8 +2613,8 @@ void fn_1_D888(Vec *arg0, float arg8) var_r31 = ((ParticleData *)Hu3DData[lbl_1_bss_7CC->model[5]].unk_120)->unk_48; var_r28 = 3.0f + (12.0f * arg8); for (var_r29 = 0; var_r29 < 0xC8; var_r29++, var_r31++) { - if (var_r31->unk00_s16 == 0) { - var_r31->unk00_s16 = 60.0f * (0.6f + (0.0006f * frandmod(0x3E8))); + if (var_r31->unk00 == 0) { + var_r31->unk00 = 60.0f * (0.6f + (0.0006f * frandmod(0x3E8))); var_f30 = frandmod(0x168); sp8.x = sind(var_f30); sp8.y = 0.0f; diff --git a/src/REL/m438Dll/map.c b/src/REL/m438Dll/map.c index b0da050e..ea4ba2d0 100644 --- a/src/REL/m438Dll/map.c +++ b/src/REL/m438Dll/map.c @@ -377,15 +377,15 @@ void fn_1_C764(ModelData *model, ParticleData *particle, Mtx matrix) var_r31 = particle->unk_48; for (var_r29 = 0; var_r29 < particle->unk_30; var_r29++, var_r31++) { - if (var_r31->unk00_s16 != 0) { + if (var_r31->unk00 != 0) { VECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34); var_r31->unk08.x *= 0.95f; var_r31->unk08.z *= 0.95f; var_r31->unk08.y += -0.27222225f; - if (var_r31->unk00_s16 < 24.0f) { + if (var_r31->unk00 < 24.0f) { var_r31->unk40.a = 0.9f * var_r31->unk40.a; } - if (--var_r31->unk00_s16 == 0) { + if (--var_r31->unk00 == 0) { var_r31->unk00 = 0; var_r31->unk2C = 0.0f; var_r31->unk40.a = 0; @@ -404,16 +404,16 @@ void fn_1_C8E8(ModelData *model, ParticleData *particle, Mtx matrix) var_r31 = particle->unk_48; for (var_r29 = 0; var_r29 < particle->unk_30; var_r29++, var_r31++) { - if (var_r31->unk00_s16 != 0) { + if (var_r31->unk00 != 0) { VECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34); var_r31->unk08.x *= 0.92f; var_r31->unk08.z *= 0.92f; var_r31->unk2C += 5.0f; var_r31->unk40.a *= 0.99f; - if (var_r31->unk00_s16 < 24.0f) { + if (var_r31->unk00 < 24.0f) { var_r31->unk40.a = 0.9f * var_r31->unk40.a; } - if (--var_r31->unk00_s16 == 0) { + if (--var_r31->unk00 == 0) { var_r31->unk00 = 0; var_r31->unk2C = 0.0f; var_r31->unk40.a = 0; @@ -440,8 +440,8 @@ void fn_1_CAB0(f32 arg8) for (var_r30 = 0; var_r30 < 0x96; var_r30++) { var_r31 = lbl_1_bss_E34[var_r30]; - if (var_r31->unk00_s16 == 0) { - var_r31->unk00_s16 = 60.0f * (0.6f + (0.0006f * frandmod(0x3E8))); + if (var_r31->unk00 == 0) { + var_r31->unk00 = 60.0f * (0.6f + (0.0006f * frandmod(0x3E8))); temp_f31 = ((0.002f * frandmod(0x3E8)) - 1.0f); temp_f31 = arg8 + (temp_f31 * temp_f28); sp8.x = sind(temp_f31); @@ -471,8 +471,8 @@ void fn_1_CAB0(f32 arg8) var_r31 = ((ParticleData *)(Hu3DData[lbl_1_bss_108C[0]->model[6]].unk_120))->unk_48; var_r29 = 0xF; for (var_r30 = 0; var_r30 < 0x32; var_r30++, var_r31++) { - if (var_r31->unk00_s16 == 0) { - var_r31->unk00_s16 = 60.0f * (0.6f + (0.0006f * frandmod(0x3E8))); + if (var_r31->unk00 == 0) { + var_r31->unk00 = 60.0f * (0.6f + (0.0006f * frandmod(0x3E8))); temp_f31 = ((0.002f * frandmod(0x3E8)) - 1.0f); temp_f31 = arg8 + (temp_f31 * temp_f28); sp8.x = sind(temp_f31); @@ -513,14 +513,14 @@ void fn_1_D3FC(ModelData *model, ParticleData *particle, Mtx matrix) lbl_1_bss_E2C = 0; var_r31 = particle->unk_48; for (var_r29 = 0; var_r29 < particle->unk_30; var_r29++, var_r31++) { - if (var_r31->unk00_s16 != 0) { + if (var_r31->unk00 != 0) { VECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34); var_r31->unk08.y += -0.27222225f; - if (var_r31->unk00_s16 < 12.0f) { + if (var_r31->unk00 < 12.0f) { var_r31->unk40.a = (0.8f * var_r31->unk40.a); } - if (--var_r31->unk00_s16 == 0) { - var_r31->unk00_s16 = 0; + if (--var_r31->unk00 == 0) { + var_r31->unk00 = 0; var_r31->unk2C = 0.0f; var_r31->unk40.a = 0; } @@ -543,8 +543,8 @@ void fn_1_D57C(Vec *arg0, f32 arg1) var_r29 = (u32)(3.0f + (15.0f * arg1)); for (var_r30 = 0; var_r30 < 0x1F4; var_r30++, var_r31++) { - if (var_r31->unk00_s16 == 0) { - var_r31->unk00_s16 = 60.0f * (0.3f + (0.0003f * frandmod(0x3E8))); + if (var_r31->unk00 == 0) { + var_r31->unk00 = 60.0f * (0.3f + (0.0003f * frandmod(0x3E8))); var_r31->unk34 = *arg0; var_r31->unk34.x += arg1 * (0.07f * (frandmod(0x3E8) - 0x1F4)); var_r31->unk34.z += arg1 * (0.07f * (frandmod(0x3E8) - 0x1F4)); diff --git a/src/REL/m443Dll/player.c b/src/REL/m443Dll/player.c index fb293d09..b0f2554d 100644 --- a/src/REL/m443Dll/player.c +++ b/src/REL/m443Dll/player.c @@ -1138,15 +1138,15 @@ void fn_1_8E34(s32 arg0) var_r31 = temp_r30->unk_48; for (var_r29 = 0; var_r29 < temp_r30->unk_30; var_r29++, var_r31++) { - if (var_r31->unk00_s16 != 0) { + if (var_r31->unk00 != 0) { VECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34); var_r31->unk08.z -= 0.3f; var_r31->unk2C += 2.0f; var_r31->unk40.a *= 0.98f; - if (var_r31->unk00_s16 < 24.0f) { + if (var_r31->unk00 < 24.0f) { var_r31->unk40.a = var_r31->unk40.a * 0.9f; } - if (--var_r31->unk00_s16 == 0) { + if (--var_r31->unk00 == 0) { var_r31->unk00 = 0; var_r31->unk2C = 0.0f; var_r31->unk40.a = 0; @@ -1183,10 +1183,10 @@ void fn_1_8FFC(u32 arg0, Point3d *arg1, f32 arg2, f32 arg3) var_r31 = temp_r29->unk_48; for (var_r28 = 0; var_r28 < temp_r29->unk_30; var_r28++, var_r31++) { - if (var_r31->unk00_s16 != 0) + if (var_r31->unk00 != 0) continue; - var_r31->unk00_s16 = (60.0f * (0.6f + (0.0005f * frandmod(0x3E8)))); + var_r31->unk00 = (60.0f * (0.6f + (0.0005f * frandmod(0x3E8)))); var_f29 = isEven(var_r27); temp_f31 = 0.030000001f * frandmod(0x3E8); var_r31->unk34.x = arg1->x + var_f29 * (70.0f + (0.07f * frandmod(0x3E8))); diff --git a/src/REL/m447dll/block.c b/src/REL/m447dll/block.c index 939c795b..335a8091 100755 --- a/src/REL/m447dll/block.c +++ b/src/REL/m447dll/block.c @@ -391,7 +391,7 @@ void fn_1_9F40(ModelData *model, ParticleData *particle, Mtx matrix) if (particle->unk_00 == 0) { particle->unk_00 = 1; for (i = 0, var_r31 = particle->unk_48; i < particle->unk_30; i++, var_r31++) { - var_r31->unk00_s16 = i * 5; + var_r31->unk00 = i * 5; var_r31->unk02 = 0; var_r31->unk2C = 0.0f; var_r31->unk40.r = sp8.r; @@ -401,7 +401,7 @@ void fn_1_9F40(ModelData *model, ParticleData *particle, Mtx matrix) } } for (i = 0, var_r27 = 0, var_r31 = particle->unk_48; i < particle->unk_30; i++, var_r31++) { - if (var_r31->unk00_s16 > 0 && --var_r31->unk00_s16 > 0) { + if (var_r31->unk00 > 0 && --var_r31->unk00 > 0) { continue; } if (var_r31->unk02 == 0 && temp_r29->unk04 == 5 && temp_r29->unk10.z > -700.0f) { diff --git a/src/REL/m447dll/stage.c b/src/REL/m447dll/stage.c index b0ac0d86..f1a456fa 100755 --- a/src/REL/m447dll/stage.c +++ b/src/REL/m447dll/stage.c @@ -444,7 +444,7 @@ void fn_1_2DAC(ModelData *model, ParticleData *particle, Mtx matrix) } } for (i = 0, var_r31 = particle->unk_48; i < particle->unk_30; i++, var_r31++) { - if (var_r31->unk00_s16 < 0) { + if (var_r31->unk00 < 0) { continue; } var_r31->unk34.x += var_r31->unk08.x; diff --git a/src/REL/m448Dll/main.c b/src/REL/m448Dll/main.c index 0fccc340..961f27be 100755 --- a/src/REL/m448Dll/main.c +++ b/src/REL/m448Dll/main.c @@ -1498,7 +1498,7 @@ void fn_1_7DC4(ModelData *model, ParticleData *particle, Mtx matrix) if (particle->unk_34 == 0) { var_r31 = particle->unk_48; for (i = 0; i < particle->unk_30; i++, var_r31++) { - var_r31->unk00_s16 = i * 2 + 100; + var_r31->unk00 = i * 2 + 100; var_r31->unk40.a = 0; var_r31->unk2C = 0.0f; } @@ -1511,8 +1511,8 @@ void fn_1_7DC4(ModelData *model, ParticleData *particle, Mtx matrix) } var_r31 = particle->unk_48; for (i = 0; i < particle->unk_30; i++, var_r31++) { - if (var_r31->unk00_s16 == 100) { - var_r31->unk00_s16 = (lbl_1_data_1DC[0] == 0.0f && lbl_1_data_1DC[1] == 0.0f && lbl_1_data_1DC[2] == 0.0f) ? 0 : var_r31->unk00_s16; + if (var_r31->unk00 == 100) { + var_r31->unk00 = (lbl_1_data_1DC[0] == 0.0f && lbl_1_data_1DC[1] == 0.0f && lbl_1_data_1DC[2] == 0.0f) ? 0 : var_r31->unk00; var_r31->unk34.x = lbl_1_data_1DC[0] + 75.0 * (rand8() / 255.0); var_r31->unk34.y = lbl_1_data_1DC[1] + 75.0 * (rand8() / 255.0); var_r31->unk34.z = lbl_1_data_1DC[2] + 75.0 * (rand8() / 255.0); @@ -1523,14 +1523,14 @@ void fn_1_7DC4(ModelData *model, ParticleData *particle, Mtx matrix) var_r31->unk30 = 0.785f; var_r31->unk2C = 40.0f; } - if (var_r31->unk00_s16 <= 100) { + if (var_r31->unk00 <= 100) { var_r31->unk34.y -= 3.0f; - var_r31->unk2C = ((var_r31->unk00_s16 > 50) ? (var_r31->unk00_s16 - 50) / 50.0 : 0.0) * (rand8() * 80 / 255.0); + var_r31->unk2C = ((var_r31->unk00 > 50) ? (var_r31->unk00 - 50) / 50.0 : 0.0) * (rand8() * 80 / 255.0); } - if (var_r31->unk00_s16 == 0) { + if (var_r31->unk00 == 0) { var_r31->unk2C = 0.0f; } - var_r31->unk00_s16 -= (var_r31->unk00_s16 > 0); + var_r31->unk00 -= (var_r31->unk00 > 0); } } diff --git a/src/REL/m449Dll/main.c b/src/REL/m449Dll/main.c index be902879..02d13d79 100644 --- a/src/REL/m449Dll/main.c +++ b/src/REL/m449Dll/main.c @@ -1697,7 +1697,7 @@ void fn_1_7F94(ModelData *model, ParticleData *particle, Mtx matrix) } } for (var_r31 = particle->unk_48, var_r29 = 0; var_r29 < particle->unk_30; var_r29++, var_r31++) { - if (var_r31->unk00_s16 == 1) { + if (var_r31->unk00 == 1) { var_f31 = ((frand() & 0xFF) * 0x168) >> 8; var_f30 = 0.5 + (1.5 * (rand8() / 256.0)); var_r31->unk08.x = 2.5 * (var_f30 * sind(var_f31)); @@ -1715,7 +1715,7 @@ void fn_1_7F94(ModelData *model, ParticleData *particle, Mtx matrix) var_r31->unk40.a = 0xFF; var_r31->unk2C = 50.0f; } - if (var_r31->unk00_s16 < 0xF0) { + if (var_r31->unk00 < 0xF0) { VECAdd(&var_r31->unk08, &var_r31->unk34, &var_r31->unk34); var_r31->unk08.x *= 0.9f; var_r31->unk08.z *= 0.9f; @@ -1730,8 +1730,8 @@ void fn_1_7F94(ModelData *model, ParticleData *particle, Mtx matrix) var_r31->unk2C = 0.0f; } } - var_r31->unk00_s16 += var_r31->unk00_s16 < 0x8000; - if (var_r31->unk00_s16 >= 0xF0) { + var_r31->unk00 += var_r31->unk00 < 0x8000; + if (var_r31->unk00 >= 0xF0) { var_r31->unk40.a = 0; var_r31->unk2C = 0.0f; } diff --git a/src/REL/m455Dll/stage.c b/src/REL/m455Dll/stage.c index c7873251..ff708c84 100644 --- a/src/REL/m455Dll/stage.c +++ b/src/REL/m455Dll/stage.c @@ -1096,7 +1096,7 @@ void fn_1_6A6C(omObjData *object) HsfanimStruct01 *data = particleP->unk_48; s32 j; for(j=0; junk_30; j++, data++) { - if(++data->unk00_s16 > data->unk02) { + if(++data->unk00 > data->unk02) { s32 alpha = data->unk40.a-1; if(alpha < 0) { data->unk2C = 0; @@ -1163,7 +1163,7 @@ s32 fn_1_6CB0(Vec *arg0, float arg1) temp_r30->unk08.x = temp_f31*(0.65f*(50.0*(temp_f28*sind(temp_f29)))); temp_r30->unk08.z = temp_f31*(0.65f*(50.0*(temp_f28*cosd(temp_f29)))); temp_r30->unk08.y = temp_f31*(50*temp_f26*temp_f25); - temp_r30->unk00_s16 = 0; + temp_r30->unk00 = 0; temp_r30->unk02 = ((s32)frand()%16)+45; temp_r30->unk30 = (s32)frand()%360; temp_r30->unk2C = 145; @@ -1280,10 +1280,10 @@ void fn_1_76B0(omObjData *object) if(temp_r30->unk2C <= 0.0f) { continue; } - if(++temp_r30->unk00_s16 > 360) { - temp_r30->unk00_s16 -= 360; + if(++temp_r30->unk00 > 360) { + temp_r30->unk00 -= 360; } - temp_r30->unk34.x += temp_r30->unk08.x*sind(2.0f*temp_r30->unk00_s16); + temp_r30->unk34.x += temp_r30->unk08.x*sind(2.0f*temp_r30->unk00); temp_r30->unk34.y += temp_r30->unk08.y; if(temp_r30->unk34.y >= 0.0f) { fn_1_6698(&temp_r30->unk34, 0.00625f*temp_r30->unk2C, 1, 15); @@ -1322,7 +1322,7 @@ s32 fn_1_79C8(Vec *pos, float scale) temp_r31->unk08.x = (1.5f+(0.2f*(0.007874016f*((s32)frand() & 0x7F))))*0.5f; temp_r31->unk08.z = (1.5f+(0.2f*(0.007874016f*((s32)frand() & 0x7F)))); temp_r31->unk08.y = (1.5f+(0.2f*(0.007874016f*((s32)frand() & 0x7F))))*2.0f; - temp_r31->unk00_s16 = (s32)frand()%360; + temp_r31->unk00 = (s32)frand()%360; temp_r31->unk2C = 20*scale; return i; } @@ -1804,4 +1804,4 @@ float fn_1_9F18(float start, float end, float max) } return angle; -} \ No newline at end of file +} diff --git a/src/REL/m456Dll/stage.c b/src/REL/m456Dll/stage.c index 072377d8..8e13a6cf 100644 --- a/src/REL/m456Dll/stage.c +++ b/src/REL/m456Dll/stage.c @@ -991,7 +991,7 @@ void fn_1_659C(omObjData *object) HsfanimStruct01 *data = particleP->unk_48; s32 j; for (j = 0; j < particleP->unk_30; j++, data++) { - if (++data->unk00_s16 > data->unk02) { + if (++data->unk00 > data->unk02) { s32 alpha = data->unk40.a - 1; if (alpha < 0) { data->unk2C = 0; @@ -1060,7 +1060,7 @@ s32 fn_1_67E0(Vec *arg0, float arg1) temp_r30->unk08.x = temp_f31 * (0.65f * (50.0 * (temp_f28 * sind(temp_f29)))); temp_r30->unk08.z = temp_f31 * (0.65f * (50.0 * (temp_f28 * cosd(temp_f29)))); temp_r30->unk08.y = temp_f31 * (50 * temp_f26 * temp_f25); - temp_r30->unk00_s16 = 0; + temp_r30->unk00 = 0; temp_r30->unk02 = ((s32)frand() % 16) + 45; temp_r30->unk30 = (s32)frand() % 360; temp_r30->unk2C = 145.0f; @@ -1174,10 +1174,10 @@ void fn_1_71E0(omObjData *object) if (temp_r30->unk2C <= 0.0f) { continue; } - if (++temp_r30->unk00_s16 > 360) { - temp_r30->unk00_s16 -= 360; + if (++temp_r30->unk00 > 360) { + temp_r30->unk00 -= 360; } - temp_r30->unk34.x += temp_r30->unk08.x * sind(2.0f * temp_r30->unk00_s16); + temp_r30->unk34.x += temp_r30->unk08.x * sind(2.0f * temp_r30->unk00); temp_r30->unk34.y += temp_r30->unk08.y; if (temp_r30->unk34.y >= 0.0f) { fn_1_61C8(&temp_r30->unk34, 0.00625f * temp_r30->unk2C, 1, REFRESH_RATE / 4); @@ -1221,7 +1221,7 @@ s32 fn_1_74F8(Vec *pos, float scale) temp_r31->unk08.z = (1.5f + (0.2f * (0.007874016f * ((s32)frand() & 0x7F)))); temp_r31->unk08.y = (1.5f + (0.2f * (0.007874016f * ((s32)frand() & 0x7F)))) * 2.0f; #endif - temp_r31->unk00_s16 = (s32)frand() % 360; + temp_r31->unk00 = (s32)frand() % 360; temp_r31->unk2C = 20 * scale; return i; } diff --git a/src/REL/m460Dll/map.c b/src/REL/m460Dll/map.c index 609dad13..15fa7f53 100644 --- a/src/REL/m460Dll/map.c +++ b/src/REL/m460Dll/map.c @@ -408,7 +408,7 @@ void fn_1_7B94(s32 arg0) var_r30 = Hu3DData[arg0].unk_120; for (var_r31 = var_r30->unk_48, var_r29 = 0; var_r29 < var_r30->unk_30; var_r29++, var_r31++) { - if (var_r31->unk00_s16 != 0) { + if (var_r31->unk00 != 0) { VECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34); switch (var_r31->unk02) { case 0: @@ -425,11 +425,11 @@ void fn_1_7B94(s32 arg0) var_r31->unk20 *= 0.995f; break; } - if (var_r31->unk00_s16 < 12.0f) { + if (var_r31->unk00 < 12.0f) { var_r31->unk20 = 0.9f * var_r31->unk20; } var_r31->unk40.a = var_r31->unk20; - if (--var_r31->unk00_s16 == 0) { + if (--var_r31->unk00 == 0) { var_r31->unk00 = 0; var_r31->unk2C = 0.0f; var_r31->unk40.a = 0; @@ -459,7 +459,7 @@ void fn_1_7DA8(omObjData *object, Vec *arg1, u32 arg2) } var_r27 = sp10[arg2]; for (var_r31 = var_r30->unk_48, var_r28 = 0; var_r28 < var_r30->unk_30; var_r28++, var_r31++) { - if (var_r31->unk00_s16 == 0) { + if (var_r31->unk00 == 0) { var_r31->unk02 = arg2; sp1C.x = 100.0f * ((0.0026f * frandmod(0x3E8)) - 1.3f); sp1C.y = 0.0f; @@ -468,7 +468,7 @@ void fn_1_7DA8(omObjData *object, Vec *arg1, u32 arg2) var_r31->unk30 = 0.0031415902f * frandmod(0x3E8); switch (arg2) { case 0: - var_r31->unk00_s16 = 60.0f * (0.8f + (0.0007f * frandmod(0x3E8))); + var_r31->unk00 = 60.0f * (0.8f + (0.0007f * frandmod(0x3E8))); var_r31->unk08.x = 1.6666667f * (0.000100000005f * frandmod(0x3E8) - 0.05f); var_r31->unk08.y = 1.6666667f * (0.05f + (0.00020000001f * frandmod(0x3E8))); var_r31->unk08.z = 1.6666667f * (0.1f + (0.0006f * frandmod(0x3E8))); diff --git a/src/REL/mstory3Dll/win_effect.c b/src/REL/mstory3Dll/win_effect.c index 48590c1b..2a86dd6c 100755 --- a/src/REL/mstory3Dll/win_effect.c +++ b/src/REL/mstory3Dll/win_effect.c @@ -253,7 +253,7 @@ void fn_1_1E820(ModelData* model, ParticleData* particle, Mtx matrix) { if (!var_r31->unk2C) { continue; } - if (var_r31->unk00_s16 == 0) { + if (var_r31->unk00 == 0) { PSVECAdd(&var_r31->unk08, &var_r31->unk34, &var_r31->unk34); var_r31->unk08.x *= 0.999f; var_r31->unk08.y -= 0.5f; @@ -262,19 +262,19 @@ void fn_1_1E820(ModelData* model, ParticleData* particle, Mtx matrix) { PSVECScale(&var_r31->unk08, &var_r31->unk08, 1.0 - ((var_r31->unk02 - (temp_r26 - temp_r26 / 5.0)) / (temp_r26 / 5.0))); } if (var_r31->unk02 == temp_r26) { - var_r31->unk00_s16++; + var_r31->unk00++; } if (var_r31->unk34.y <= 0.0f) { var_r31->unk08.y = 0.5f * -var_r31->unk08.y; var_r31->unk34.y = 0.0f; } - } else if (var_r31->unk00_s16 == 1) { + } else if (var_r31->unk00 == 1) { sp8 = temp_r28->unk00[var_r29]; PSVECSubtract(&sp8, &var_r31->unk34, &sp8); if (PSVECMag(&sp8) <= 1.0 + temp_f31) { var_r23++; var_r31->unk34 = temp_r28->unk00[var_r29]; - var_r31->unk00_s16++; + var_r31->unk00++; continue; } PSVECNormalize(&sp8, &sp8); @@ -286,7 +286,7 @@ void fn_1_1E820(ModelData* model, ParticleData* particle, Mtx matrix) { } else { var_r23++; } - if (var_r31->unk00_s16 >= 1) { + if (var_r31->unk00 >= 1) { var_r27 = var_r31->unk40.r; var_r27 += (var_r27 - 0xFF) / 20; if (var_r27 > 0xFF) { diff --git a/src/game/board/item.c b/src/game/board/item.c index 4386a4a7..d2341c9c 100755 --- a/src/game/board/item.c +++ b/src/game/board/item.c @@ -1942,7 +1942,7 @@ static void LampParticleUpdate(ModelData *model, ParticleData *particle, Mtx mat var_r31->unk2C = 25.0f; temp_f30 = 175.0f + frand8() * 0x50 * 0.003921569f; var_r31->unk40.r = var_r31->unk40.g = var_r31->unk40.b = temp_f30; - var_r31->unk00_s16 = 0; + var_r31->unk00 = 0; } } } @@ -1952,7 +1952,7 @@ static void LampParticleUpdate(ModelData *model, ParticleData *particle, Mtx mat var_r31 = particle->unk_48; for (i = 0; i < particle->unk_30; i++, var_r31++) { if (var_r31->unk2C != 0.0f) { - if (var_r31->unk00_s16 == 0) { + if (var_r31->unk00 == 0) { VECAdd(&var_r31->unk34, &var_r31->unk08, &var_r31->unk34); VECScale(&var_r31->unk08, &var_r31->unk08, 0.95f); var_r31->unk2C += 8.0f; @@ -1963,7 +1963,7 @@ static void LampParticleUpdate(ModelData *model, ParticleData *particle, Mtx mat var_r31->unk08.x = 6.0 * cosd(temp_f31); var_r31->unk08.y = -4.0f; var_r31->unk08.z = 6.0 * sind(temp_f31); - var_r31->unk00_s16 = 1; + var_r31->unk00 = 1; } var_r31->unk40.a = var_r31->unk14.y; } diff --git a/src/game/chrman.c b/src/game/chrman.c index aa090cf3..e98f50e1 100755 --- a/src/game/chrman.c +++ b/src/game/chrman.c @@ -911,7 +911,7 @@ static void UpdateEffect(ModelData *model, ParticleData *particle, Mtx matrix) var_r31->unk40.a = var_r28; if (var_r31->unk2C) { if (temp_r30[i].unk00 & 1) { - var_r31->unk2C = var_r31->unk28 * (((var_r31->unk00_s16 + i) & 1) ? 1.0 : 0.5); + var_r31->unk2C = var_r31->unk28 * (((var_r31->unk00 + i) & 1) ? 1.0 : 0.5); } else { var_r31->unk2C = var_r31->unk28; @@ -921,7 +921,7 @@ static void UpdateEffect(ModelData *model, ParticleData *particle, Mtx matrix) var_r31->unk2C = 0.0f; } } - var_r31->unk00_s16++; + var_r31->unk00++; } else { switch (var_r31->unk02) { @@ -947,11 +947,11 @@ static void RotateEffect(HsfanimStruct01 *arg0) float var_f31; temp_r30 = &Hu3DData[(s32)arg0->unk08.x]; - if (arg0->unk00_s16 < 8) { - var_f31 = 0.3 + sind(40.0f + 10.0f * (arg0->unk00_s16 + 1)); + if (arg0->unk00 < 8) { + var_f31 = 0.3 + sind(40.0f + 10.0f * (arg0->unk00 + 1)); arg0->unk2C = 50.0f * var_f31 * temp_r30->scale.x; arg0->unk40.a = 0xFF; - var_f31 = 0.3 + sind(15.0f * (arg0->unk00_s16 + 1)); + var_f31 = 0.3 + sind(15.0f * (arg0->unk00 + 1)); } else { var_f31 = 0.3 + sind(135); @@ -960,14 +960,14 @@ static void RotateEffect(HsfanimStruct01 *arg0) arg0->unk34.x = temp_r30->pos.x + arg0->unk14.x * var_f31; arg0->unk34.y = temp_r30->pos.y + arg0->unk08.y * temp_r30->scale.x + arg0->unk14.y * var_f31; arg0->unk34.z = temp_r30->pos.z + arg0->unk14.z * var_f31; - if (arg0->unk00_s16 > 0x14) { + if (arg0->unk00 > 0x14) { arg0->unk40.a -= 0x20; arg0->unk2C -= 8.0f * temp_r30->scale.x; if (arg0->unk2C < 0.0f) { arg0->unk2C = 0.0f; } } - arg0->unk00_s16++; + arg0->unk00++; } static float voiceParam[16] @@ -984,7 +984,7 @@ static void PlayEffectSound(HsfanimStruct01 *arg0) temp_r28 = arg0->unk08.x; temp_r29 = &charInstance[temp_r28]; temp_r30 = &Hu3DData[temp_r29->unk00]; - if (arg0->unk00_s16 < 0x14 && arg0->unk2C < 40.0f * temp_r30->scale.x) { + if (arg0->unk00 < 0x14 && arg0->unk2C < 40.0f * temp_r30->scale.x) { arg0->unk2C += 4.0f * temp_r30->scale.x; } arg0->unk40.a = 0xFF; @@ -994,15 +994,15 @@ static void PlayEffectSound(HsfanimStruct01 *arg0) else { var_r25 = voiceParam[temp_r28 * 2 + 1]; } - temp_r26 = (arg0->unk00_s16 * 5) % 360; + temp_r26 = (arg0->unk00 * 5) % 360; arg0->unk34.x = temp_r30->pos.x + 40.0 * sind(arg0->unk08.y + temp_r26) * temp_r30->scale.x; arg0->unk34.y = temp_r30->pos.y + var_r25 * temp_r30->scale.x; arg0->unk34.z = temp_r30->pos.z + 40.0 * cosd(arg0->unk08.y + temp_r26) * temp_r30->scale.x; - arg0->unk00_s16++; - if (arg0->unk00_s16 >= 0x8F) { - arg0->unk00_s16 = 0x48; + arg0->unk00++; + if (arg0->unk00 >= 0x8F) { + arg0->unk00 = 0x48; } - if (temp_r29->unk04 != 0x15 && temp_r29->unk04 != 0x16 && temp_r29->unk04 != 0x79 && arg0->unk00_s16 > 0x1E) { + if (temp_r29->unk04 != 0x15 && temp_r29->unk04 != 0x16 && temp_r29->unk04 != 0x79 && arg0->unk00 > 0x1E) { arg0->unk2C -= 4.0f * temp_r30->scale.x; if (arg0->unk2C < 0.0f) { arg0->unk2C = 0.0f; @@ -1501,7 +1501,7 @@ static void OrbitEffect(HsfanimStruct01 *arg0) float var_f30; s16 temp_r30; - var_f30 = 20.0f + 3.75f * arg0->unk00_s16; + var_f30 = 20.0f + 3.75f * arg0->unk00; if (var_f30 > 90.0f) { var_f30 = 90.0f; } @@ -1514,7 +1514,7 @@ static void OrbitEffect(HsfanimStruct01 *arg0) if (arg0->unk20 < 1.0f) { arg0->unk20 = 1.0f; } - if (arg0->unk00_s16 > 8) { + if (arg0->unk00 > 8) { temp_r30 = arg0->unk40.a; temp_r30 -= 8; if (temp_r30 < 0) { @@ -1525,7 +1525,7 @@ static void OrbitEffect(HsfanimStruct01 *arg0) arg0->unk40.a = temp_r30; } } - arg0->unk00_s16++; + arg0->unk00++; } static EffectParamData coinParticleParam diff --git a/src/game/hsfanim.c b/src/game/hsfanim.c index 7de7763f..b5a73d37 100755 --- a/src/game/hsfanim.c +++ b/src/game/hsfanim.c @@ -55,7 +55,7 @@ s16 Hu3DAnimCreate(void *arg0, s16 arg1, char *arg2) { Hu3DTexAnimDataStruct *var_r31; HsfAttribute *var_r29; HsfData *temp_r27; - HsfanimStruct01 *var_r30; + HsfdrawStruct01 *var_r30; s16 i; s16 var_r25; s16 var_r28; @@ -75,7 +75,7 @@ s16 Hu3DAnimCreate(void *arg0, s16 arg1, char *arg2) { for (i = var_r25 = 0; i < temp_r27->attributeCnt; i++, var_r29++) { if (strcmp(arg2, var_r29->bitmap->name) == 0) { if (!var_r29->unk04) { - var_r30 = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfanimStruct01), (u32) Hu3DData[arg1].unk_48); + var_r30 = HuMemDirectMallocNum(HEAP_DATA, sizeof(*var_r30), (u32) Hu3DData[arg1].unk_48); var_r29->unk04 = var_r30; var_r30->unk00 = 0; } else { @@ -84,7 +84,7 @@ s16 Hu3DAnimCreate(void *arg0, s16 arg1, char *arg2) { var_r30->unk00 |= 1; var_r30->unk02 = var_r28; var_r30->unk2C = var_r30->unk30 = 1.0f; - var_r30->unk34.x = var_r30->unk34.y = 0.0f; + var_r30->unk34 = var_r30->unk38 = 0.0f; var_r25++; } } @@ -112,7 +112,7 @@ s16 Hu3DAnimLink(s16 arg0, s16 arg1, char *arg2) { AnimData *temp_r4; HsfAttribute *var_r29; HsfData *temp_r27; - HsfanimStruct01 *var_r30; + HsfdrawStruct01 *var_r30; s16 var_r28; s16 i; s16 var_r25; @@ -132,14 +132,14 @@ s16 Hu3DAnimLink(s16 arg0, s16 arg1, char *arg2) { for (i = var_r25 = 0; i < temp_r27->attributeCnt; i++, var_r29++) { if (strcmp(arg2, var_r29->bitmap->name) == 0) { if (!var_r29->unk04) { - var_r30 = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfanimStruct01), (u32) Hu3DData[arg1].unk_48); + var_r30 = HuMemDirectMallocNum(HEAP_DATA, sizeof(*var_r30), (u32) Hu3DData[arg1].unk_48); var_r29->unk04 = var_r30; } else { var_r30 = var_r29->unk04; } var_r30->unk02 = var_r28; var_r30->unk2C = var_r30->unk30 = 1.0f; - var_r30->unk34.x = var_r30->unk34.y = 0.0f; + var_r30->unk34 = var_r30->unk38 = 0.0f; var_r25++; } } @@ -162,7 +162,7 @@ void Hu3DAnimKill(s16 arg0) { Hu3DTexAnimDataStruct *temp_r31 = &Hu3DTexAnimData[arg0]; HsfData *temp_r28 = Hu3DData[temp_r31->unk06].hsfData; HsfAttribute *var_r30; - HsfanimStruct01 *temp_r29; + HsfdrawStruct01 *temp_r29; s16 i; if (temp_r28) { @@ -242,7 +242,7 @@ void Hu3DAnmNoSet(s16 arg0, u16 arg1) { } s32 Hu3DAnimSet(ModelData *arg0, HsfAttribute *arg1, s16 arg2) { - HsfanimStruct01 *temp_r30; + HsfdrawStruct01 *temp_r30; Hu3DTexAnimDataStruct *temp_r29; AnimData *temp_r27; AnimBmpData *temp_r28; @@ -268,8 +268,8 @@ s32 Hu3DAnimSet(ModelData *arg0, HsfAttribute *arg1, s16 arg2) { (arg0->attr & HU3D_ATTR_TEX_NEAR) ? GX_NEAR : GX_LINEAR); temp_r30->unk2C = (float) temp_r31->sizeX / temp_r28->sizeX; temp_r30->unk30 = (float) temp_r31->sizeY / temp_r28->sizeY; - temp_r30->unk34.x = (float) temp_r31->startX / temp_r28->sizeX; - temp_r30->unk34.y = (float) temp_r31->startY / temp_r28->sizeY; + temp_r30->unk34 = (float) temp_r31->startX / temp_r28->sizeX; + temp_r30->unk38 = (float) temp_r31->startY / temp_r28->sizeY; return 1; } @@ -359,7 +359,7 @@ s16 Hu3DTexScrollCreate(s16 arg0, char *arg1) { Hu3DTexScrDataStruct *var_r31; HsfData *temp_r27; HsfAttribute *var_r29; - HsfanimStruct01 *var_r30; + HsfdrawStruct01 *var_r30; s16 i; s16 var_r25; s16 var_r28; @@ -379,7 +379,7 @@ s16 Hu3DTexScrollCreate(s16 arg0, char *arg1) { for (i = var_r25 = 0; i < temp_r27->attributeCnt; i++, var_r29++) { if (strcmp(arg1, var_r29->bitmap->name) == 0) { if (!var_r29->unk04) { - var_r30 = HuMemDirectMallocNum(HEAP_DATA, sizeof(HsfanimStruct01), (u32) Hu3DData[arg0].unk_48); + var_r30 = HuMemDirectMallocNum(HEAP_DATA, sizeof(*var_r30), (u32) Hu3DData[arg0].unk_48); var_r29->unk04 = var_r30; var_r30->unk00 = 0; } else { @@ -388,7 +388,7 @@ s16 Hu3DTexScrollCreate(s16 arg0, char *arg1) { var_r30->unk00 |= 2; var_r30->unk04 = var_r28; var_r30->unk2C = var_r30->unk30 = 1.0f; - var_r30->unk34.x = var_r30->unk34.y = 0.0f; + var_r30->unk34 = var_r30->unk38 = 0.0f; var_r25++; } } @@ -408,7 +408,7 @@ void Hu3DTexScrollKill(s16 arg0) { Hu3DTexScrDataStruct *temp_r28 = &Hu3DTexScrData[arg0]; HsfData *temp_r29 = Hu3DData[temp_r28->unk02].hsfData; HsfAttribute *var_r31; - HsfanimStruct01 *temp_r30; + HsfdrawStruct01 *temp_r30; s16 i; if (temp_r29) { @@ -1241,7 +1241,7 @@ static void ParManHook(ModelData *model, ParticleData *particle, Mtx matrix) { var_r29->unk2C = var_r29->unk28; } if (!(temp_r28->unk02 & 0x80)) { - sp8 = var_r29->unk00_s16; + sp8 = var_r29->unk00; var_r29->unk34.x += var_r29->unk08.x + var_r29->unk14.x; var_r29->unk34.y += var_r29->unk08.y + var_r29->unk14.y; var_r29->unk34.z += var_r29->unk08.z + var_r29->unk14.z; @@ -1261,7 +1261,7 @@ static void ParManHook(ModelData *model, ParticleData *particle, Mtx matrix) { } } var_r29->unk28 *= temp_r26->unk28; - var_f30 = (float) var_r29->unk00_s16 / temp_r26->unk00; + var_f30 = (float) var_r29->unk00 / temp_r26->unk00; if (var_f30 > 1.0f) { var_f30 = 1.0f; } @@ -1272,10 +1272,10 @@ static void ParManHook(ModelData *model, ParticleData *particle, Mtx matrix) { var_r29->unk40.g = temp_r27->g + var_f30 * (temp_r24->g - temp_r27->g); var_r29->unk40.b = temp_r27->b + var_f30 * (temp_r24->b - temp_r27->b); var_r29->unk40.a = temp_r27->a + var_f30 * (temp_r24->a - temp_r27->a); - if (var_r29->unk2C < 0.01 || var_r29->unk00_s16 >= temp_r26->unk00) { + if (var_r29->unk2C < 0.01 || var_r29->unk00 >= temp_r26->unk00) { var_r29->unk2C = 0.0f; } - var_r29->unk00_s16++; + var_r29->unk00++; } } }