decomp: clarify fields, parameters and state names (batch 38)

include/rnc/overlay/shared/camera/follow_camera_offset_effect_data.h

@@ -0,0 +1,6 @@
+#ifndef LOMBYTE_RNC_OVERLAY_SHARED_CAMERA_FOLLOW_CAMERA_OFFSET_EFFECT_DATA_H
+#define LOMBYTE_RNC_OVERLAY_SHARED_CAMERA_FOLLOW_CAMERA_OFFSET_EFFECT_DATA_H
+
+extern char camera_offset_effect_selection_gate[] __asm__("D_0013CA44");
+
+#endif

include/rnc/overlay/shared/ui/hud/draw_trick_combo_hud_data/hud_release_held_element.h

@@ -7,4 +7,6 @@
  * Keep its include at this declaration block: SN small-data ordering matters. */
 extern int animation_parameter_target_id __asm__("D_L05_0015F980");
 
+extern short l05_hud_release_counter __asm__("D_L05_0015F978") __attribute__((sda));
+
 #endif /* LOMBYTE_RNC_OVERLAY_SHARED_UI_HUD_DRAW_TRICK_COMBO_HUD_DATA_HUD_RELEASE_HELD_ELEMENT_H */

src/audio/decoder/audio_dec_begin_put.c

@@ -6,10 +6,10 @@ void audio_dec_begin_put(
 
 void audio_dec_begin_put(struct AudioDec *dec,
                          void           **first_destination,
-                         s32             *size1,
+                         s32             *first_destination_byte_count,
                          void           **second_destination,
 
-                         s32 *size2) {
+                         s32 *second_destination_byte_count) {
     enum {
         AUDIO_DEC_STATE_HEADER_PENDING = 0
     };
@@ -18,27 +18,27 @@ void audio_dec_begin_put(struct AudioDec *dec,
     if (dec->state == AUDIO_DEC_STATE_HEADER_PENDING) {
         if (dec->strType != 4) {
             *first_destination = ((u8 *)&dec->hdr + dec->hdrCount);
-            *size1 = 0x28 - dec->hdrCount;
+            *first_destination_byte_count = 0x28 - dec->hdrCount;
             *second_destination = dec->data;
-            *size2 = dec->size;
+            *second_destination_byte_count = dec->size;
         } else {
             *first_destination = dec->data;
-            *size1 = dec->size;
+            *first_destination_byte_count = dec->size;
             *second_destination = NULL;
-            *size2 = 0;
+            *second_destination_byte_count = 0;
         }
     } else {
         writable_byte_count = dec->size - dec->count;
         if ((dec->size - dec->put) >= writable_byte_count) {
             *first_destination = dec->data + dec->put;
-            *size1 = writable_byte_count;
+            *first_destination_byte_count = writable_byte_count;
             *second_destination = NULL;
-            *size2 = 0;
+            *second_destination_byte_count = 0;
         } else {
             *first_destination = dec->data + dec->put;
-            *size1 = dec->size - dec->put;
+            *first_destination_byte_count = dec->size - dec->put;
             *second_destination = dec->data;
-            *size2 = writable_byte_count - (dec->size - dec->put);
+            *second_destination_byte_count = writable_byte_count - (dec->size - dec->put);
         }
     }
 }

src/audio/decoder/send_to_spu.c

@@ -13,7 +13,7 @@ void send_to_spu(struct AudioDec *dec,
 
 void send_to_spu(struct AudioDec *dec,
                  s32              adpcm_source_address,
-                 s32              size,
+                 s32              transfer_byte_count,
 
                  s32 staging_byte_offset) {
     u32 descriptor[4];
@@ -22,14 +22,14 @@ void send_to_spu(struct AudioDec *dec,
     FlushCache(0);
     descriptor[0] = adpcm_source_address;
     descriptor[1] = dec->iopBuff;
-    descriptor[2] = size;
+    descriptor[2] = transfer_byte_count;
     descriptor[3] = 0;
     do {
         dma_id = sceSifSetDma(descriptor, 1);
     } while (dma_id == 0);
     while (sceSifDmaStat(dma_id) >= 0) {
     }
-    snd_update_movie_adpcm(size, staging_byte_offset);
+    snd_update_movie_adpcm(transfer_byte_count, staging_byte_offset);
 }
 
 extern __typeof__(send_to_spu) func_0023AF18 __attribute__((alias("FUN_0023af18")));

src/audio/music/process_bgm_display_text_event.c

@@ -34,7 +34,7 @@ void process_bgm_display_text_event(u64           color,
                                     f32 scale) {
     u8           *text_cursor;
     s32           i;
-    f32           size;
+    f32           glyph_quad_size;
     f32           top;
     f32           dx;
     f32           dy;
@@ -45,7 +45,7 @@ void process_bgm_display_text_event(u64           color,
     if (font_window_active == 0) {
         font_palette_colors[0] = color;
     }
-    size = scale * 16.0f;
+    glyph_quad_size = scale * 16.0f;
     i = 0;
     if (byte_limit == 0 || *str == 0) {
         return;
@@ -66,8 +66,8 @@ void process_bgm_display_text_event(u64           color,
                 dy = convert_integer_to_float(additional_glyph->top) * scale;
                 emit_textured_rectangle(x + dx,
                                         y + dy,
-                                        size,
-                                        size,
+                                        glyph_quad_size,
+                                        glyph_quad_size,
                                         additional_glyph->u,
                                         additional_glyph->v,
                                         16,
@@ -94,8 +94,8 @@ void process_bgm_display_text_event(u64           color,
             } else if (*text_cursor > 0x20) {
                 emit_textured_rectangle(x,
                                         y + top,
-                                        size,
-                                        size,
+                                        glyph_quad_size,
+                                        glyph_quad_size,
                                         glyph_table[*text_cursor].u,
                                         glyph_table[*text_cursor].v,
                                         16,

src/audio/rpc/snd_send_iop_command_and_wait.c

@@ -17,11 +17,11 @@ s32         snd_send_iop_command_and_wait(s32 cmd, s32 size, u8 *data) __asm__("
 
 extern s32 snd_batches_held __asm__("D_0015ECC4") __attribute__((sda));
 
-s32 snd_send_iop_command_and_wait(s32 cmd, s32 size, u8 *command_payload) {
+s32 snd_send_iop_command_and_wait(s32 cmd, s32 payload_byte_count, u8 *command_payload) {
     s32 i;
     s32 iop_command_result;
 
-    for (i = 0; i < size; i++) {
+    for (i = 0; i < payload_byte_count; i++) {
         snd_sync_send_buffer[i] = command_payload[i];
     }
     goto check;
@@ -36,9 +36,16 @@ s32 snd_send_iop_command_and_wait(s32 cmd, s32 size, u8 *command_payload) {
         snd_flush_sound_commands();
         FlushCache(0);
     }
-    if (size != 0) {
-        sceSifCallRpc(
-            sound_command_client, cmd, 1, snd_sync_send_buffer, size, snd_sync_buffer, 0xC, 0, 0);
+    if (payload_byte_count != 0) {
+        sceSifCallRpc(sound_command_client,
+                      cmd,
+                      1,
+                      snd_sync_send_buffer,
+                      payload_byte_count,
+                      snd_sync_buffer,
+                      0xC,
+                      0,
+                      0);
     } else {
         sceSifCallRpc(sound_command_client, cmd, 1, 0, 0, snd_sync_buffer, 0xC, 0, 0);
     }

src/audio/rpc/snd_send_iop_command_no_wait.c

@@ -25,15 +25,15 @@ void snd_send_iop_command_no_wait(s32 cmd, s32 size, u8 *data, s32 cb, s64 cb_da
 
 extern s32 snd_batches_held __asm__("D_0015ECC4") __attribute__((sda));
 
-void snd_send_iop_command_no_wait(s32 cmd, s32 size, u8 *data, s32 cb, s64 cb_data) {
+void snd_send_iop_command_no_wait(s32 cmd, s32 payload_byte_count, u8 *data, s32 cb, s64 cb_data) {
     s32 need;
     s32 tries;
     s32 held;
     s32 i;
     u8 *command_write_cursor;
 
     held = 0;
-    if (snd_batches_held == 0 && snd_current_buffer == 0 && size == 0 && cb == 0) {
+    if (snd_batches_held == 0 && snd_current_buffer == 0 && payload_byte_count == 0 && cb == 0) {
         snd_prepare_return_buffer(snd_sync_buffer, 1);
         while (SceSifCheckStatRpc(sound_command_client) != 0) {
             Printf(snd_non_idle_error_string);
@@ -43,7 +43,7 @@ void snd_send_iop_command_no_wait(s32 cmd, s32 size, u8 *data, s32 cb, s64 cb_da
         sceSifCallRpc(sound_command_client, cmd, 1, 0, 0, snd_sync_buffer, 0xC, 0, 0);
         return;
     }
-    need = size + 4;
+    need = payload_byte_count + 4;
     tries = 0;
     if (need % 4 != 0) {
         need += 4 - need % 4;
@@ -73,9 +73,9 @@ void snd_send_iop_command_no_wait(s32 cmd, s32 size, u8 *data, s32 cb, s64 cb_da
                            (snd_batch_free_bytes[snd_batch_index] - 0x1000);
     *(s16 *)command_write_cursor = cmd;
     command_write_cursor += 2;
-    *(s16 *)command_write_cursor = size;
+    *(s16 *)command_write_cursor = payload_byte_count;
     command_write_cursor += 2;
-    for (i = 0; i < size; i++) {
+    for (i = 0; i < payload_byte_count; i++) {
         command_write_cursor[i] = data[i];
     }
     snd_batch_free_bytes[snd_batch_index] -= need;

src/audio/streaming/vag/snd_play_vag_stream_by_loc_ex_cb.c

@@ -20,28 +20,28 @@ void       snd_play_vag_stream_by_loc_ex_cb(s32 loc,
                                             u64 cb_data) __asm__("FUN_0012ec08");
 
 void snd_play_vag_stream_by_loc_ex_cb(s32 loc,
-                                      s32 size,
+                                      s32 request_word_1,
                                       s32 vol_l,
                                       s32 vol_r,
                                       s32 pitch,
                                       s32 flags,
                                       s32 voice,
                                       s32 channel,
                                       s32 request_word_6,
-                                      s32 id,
+                                      s32 callback_address,
 
                                       u64 cb_data) {
     int new_var;
     s32 playback_request_payload[7];
     new_var = (pitch << 16) | (vol_l & 0xFFFF);
     playback_request_payload[0] = loc;
-    playback_request_payload[1] = size;
+    playback_request_payload[1] = request_word_1;
     playback_request_payload[2] = new_var;
     playback_request_payload[3] = (flags << 16) | (vol_r & 0xFFFF);
     playback_request_payload[4] = voice;
     playback_request_payload[5] = channel;
     playback_request_payload[6] = request_word_6;
-    snd_send_iop_command_no_wait(0x2C, 0x1C, playback_request_payload, id, cb_data);
+    snd_send_iop_command_no_wait(0x2C, 0x1C, playback_request_payload, callback_address, cb_data);
 }
 
 extern __typeof__(snd_play_vag_stream_by_loc_ex_cb) func_0012EC08

src/audio/voices/allocate_voice_for_bank_entry.c

@@ -14,14 +14,15 @@ struct VoiceBankEntryWindow {
 extern s32 allocate_voice_slot(u8 *, s32, s32, s32, s32) __asm__("func_0022D7F0");
 s32 allocate_voice_for_bank_entry(s32 entry_index, s32 flags, s32 owner) __asm__("FUN_0022db10");
 
-s32 allocate_voice_for_bank_entry(s32 entry_index, s32 flags, s32 owner) {
+s32 allocate_voice_for_bank_entry(s32 entry_index, s32 voice_control_flags, s32 owner) {
     s32                          slot_index;
     struct VoiceBankEntryWindow *slot;
 
     if (entry_index >= D_0015F5B4) {
         return -1;
     }
-    slot_index = allocate_voice_slot(level_sound_defs + (entry_index << 5), flags, owner, 0, 0x400);
+    slot_index = allocate_voice_slot(
+        level_sound_defs + (entry_index << 5), voice_control_flags, owner, 0, 0x400);
     if (slot_index >= 0) {
         slot = (struct VoiceBankEntryWindow *)(((u8 *)&voice_pool) + slot_index * 0x70);
         slot->owner = owner;

src/audio/voices/allocate_voice_for_group_entry.c

@@ -17,7 +17,7 @@ s32 allocate_voice_for_group_entry(s32 group_entry_index,
                                    s32 flags,
                                    s32 owner) __asm__("FUN_0022dba0");
 
-s32 allocate_voice_for_group_entry(s32 group_entry_index, s32 flags, s32 owner) {
+s32 allocate_voice_for_group_entry(s32 group_entry_index, s32 playback_flags, s32 owner) {
     s32                           entry_index;
     s32                           slot_index;
     struct VoiceGroupEntryWindow *slot;
@@ -26,7 +26,8 @@ s32 allocate_voice_for_group_entry(s32 group_entry_index, s32 flags, s32 owner)
     if (entry_index >= level_sound_def_count) {
         return -1;
     }
-    slot_index = allocate_voice_slot(level_sound_defs + (entry_index << 5), flags, owner, 0, 0x400);
+    slot_index =
+        allocate_voice_slot(level_sound_defs + (entry_index << 5), playback_flags, owner, 0, 0x400);
     if (slot_index >= 0) {
         slot = (struct VoiceGroupEntryWindow *)(slot_index * 0x70 + ((u8 *)&voice_pool));
         slot->owner = owner;

src/audio/voices/allocate_voice_for_target_entry.c

@@ -33,7 +33,10 @@ s32        allocate_voice_for_target_entry(s32                   entry_index,
 /* Queue a class sound entry for a moby; return its pool index or -1.
  * The caller supplies a nonnegative entry index: retail only checks the
  * upper bound. This does not allocate a hardware voice or play immediately. */
-s32 allocate_voice_for_target_entry(s32 entry_index, s32 flags, struct MobyAudioView *moby) {
+s32 allocate_voice_for_target_entry(s32 entry_index,
+                                    s32 voice_slot_flags,
+
+                                    struct MobyAudioView *moby) {
     struct MobyClassAudioView   *pclass;
     s32                          slot_index;
     s32                          sound_defs;
@@ -53,7 +56,8 @@ s32 allocate_voice_for_target_entry(s32 entry_index, s32 flags, struct MobyAudio
     if (entry_index >= (s32)pclass->sound_def_count) {
         return -1;
     }
-    slot_index = allocate_voice_slot(sound_defs + (entry_index << 5), flags, moby, 0, 0x400);
+    slot_index =
+        allocate_voice_slot(sound_defs + (entry_index << 5), voice_slot_flags, moby, 0, 0x400);
     if (slot_index >= 0) {
         slot = (struct VoiceMobyEntryWindow *)((slot_index * 0x70) + (s32)((u8 *)&voice_pool));
         slot->owner = moby;

src/audio/voices/pause_all_sounds.c

@@ -36,11 +36,11 @@ extern s32
 
 extern void update_skill_point_and_gold_weapon_menu_entries() __asm__("func_00226E58");
 
-void pause_all_sounds(s32 mode) __asm__("FUN_00218d78");
+void pause_all_sounds(s32 menu_state) __asm__("FUN_00218d78");
 
 extern s32 game_mode_macro __asm__("D_0015F604") MACRO_ADDR;
 
-void pause_all_sounds(s32 mode) {
+void pause_all_sounds(s32 menu_state) {
     struct MenuSystem *g;
     snd_pause_all_sounds_in_group(0x1D);
     music_pause(0);
@@ -68,7 +68,7 @@ void pause_all_sounds(s32 mode) {
     {
         struct MenuSystem         *g = &menu_system;
         struct MenuTextListScreen *head = &pause_menu_chain_head;
-        g->sequence_autoclose = mode == 0x23;
+        g->sequence_autoclose = menu_state == 0x23;
         head->list.up = g->goodies_tab_shown ? (struct MenuScreen *)&pause_goodies_tab
                                              : (struct MenuScreen *)&pause_menu_chain_tail;
     }
@@ -81,7 +81,7 @@ void pause_all_sounds(s32 mode) {
     {
         struct MenuSystem *g = &menu_system;
         game_mode_macro = 3;
-        g->state = mode;
+        g->state = menu_state;
         g->close_request = 0;
         g->graphics_workspace = 0;
         g->update_count = 0;

src/audio/voices/sound_update.c

@@ -277,8 +277,9 @@ s32 sound_update(void) {
                     {
                         /* Fakematch: the byte index in a local keeps the copy's start address as
                            (index + base) + 1, unflattened as retail's loop pass emits it. */
-                        s32 offset = slot_index * (s32)sizeof(VoiceSlot) + 0xB4;
-                        s32 index = history_offset + offset;
+                        s32 occlusion_history_pool_offset =
+                            slot_index * (s32)sizeof(VoiceSlot) + 0xB4;
+                        s32 index = history_offset + occlusion_history_pool_offset;
                         for (repeat_index = 1; repeat_index < 6; repeat_index++) {
                             ((u8 *)&voice_pool)[index + repeat_index] =
                                 voice_pool.voices[slot_index].occlusion_history[history_offset];

src/camera/sample_camera_path.c

@@ -25,7 +25,13 @@ void sample_camera_path(struct CameraPath *path,
 
 void sample_camera_path(
 
-    struct CameraPath *path, s32 loop, void *position, f32 *rotation, s32 flags, f32 progress) {
+    struct CameraPath *path,
+    s32                loop,
+    void              *position,
+    f32               *rotation,
+    s32                rotation_output_flags,
+
+    f32 progress) {
     Vec4 current_point;
     Vec4 next_point;
     Vec4 following_point;
@@ -68,7 +74,7 @@ void sample_camera_path(
     qcopy(&current_point.q, &path->points[point_index]);
     qcopy(&next_point.q, &path->points[next_index]);
     lerp_vector(position, &current_point, &next_point, fraction);
-    if (!(flags & 1)) {
+    if (!(rotation_output_flags & 1)) {
         fast_vec_sub(&segment, &next_point, &current_point);
         heading = fast_arc_tan(segment.f[0], segment.f[1]);
         pitch = fast_arc_tan(vector_length_xy(&segment), segment.f[2]);

src/game/dispatch_game_state_update.c

@@ -14,16 +14,16 @@ void dispatch_game_state_update(void) {
     enum {
         LEVEL_FRAME_RENDER = 4
     };
-    s32 state;
+    s32 render_dispatch_state;
 
     if (space_load_in_progress != 0) {
         return;
     }
-    state = ship_substate[0];
-    if ((u32)state >= 9U) {
+    render_dispatch_state = ship_substate[0];
+    if ((u32)render_dispatch_state >= 9U) {
         return;
     }
-    switch (state) {
+    switch (render_dispatch_state) {
     case 0:
     case 8:
         prepare_debug_profiler_render();