mirror of
https://github.com/ACreTeam/ac-decomp
synced 2026-09-09 02:50:08 -04:00
Cuyler36
559 lines
16 KiB
C
559 lines
16 KiB
C
#include "ac_field_draw.h"
|
|
|
|
#include "audio.h"
|
|
#include "m_debug.h"
|
|
#include "m_field_info.h"
|
|
#include "m_player_lib.h"
|
|
#include "m_random_field.h"
|
|
#include "m_common_data.h"
|
|
#include "m_rcp.h"
|
|
#include "sys_matrix.h"
|
|
|
|
static void Bg_Draw_Actor_ct(ACTOR* actorx, GAME* game);
|
|
static void Bg_Draw_Actor_dt(ACTOR* actorx, GAME* game);
|
|
static void Bg_Draw_Actor_move(ACTOR* actorx, GAME* game);
|
|
static void Bg_Draw_Actor_draw(ACTOR* actorx, GAME* game);
|
|
|
|
ACTOR_PROFILE Field_Draw_Profile = {
|
|
mAc_PROFILE_FIELD_DRAW,
|
|
ACTOR_PART_FG,
|
|
ACTOR_STATE_NO_MOVE_WHILE_CULLED | ACTOR_STATE_NO_DRAW_WHILE_CULLED,
|
|
EMPTY_NO,
|
|
ACTOR_OBJ_BANK_KEEP,
|
|
sizeof(FIELD_DRAW_ACTOR),
|
|
&Bg_Draw_Actor_ct,
|
|
&Bg_Draw_Actor_dt,
|
|
&Bg_Draw_Actor_move,
|
|
&Bg_Draw_Actor_draw,
|
|
NULL
|
|
};
|
|
|
|
static void aFD_MakeMarinScrollInfo(ACTOR* actorx, GAME* game);
|
|
|
|
enum {
|
|
aFD_SEARCH_FULL,
|
|
aFD_SEARCH_CURRENT,
|
|
aFD_SEARCH_ROW,
|
|
|
|
aFD_SEARCH_NUM
|
|
};
|
|
|
|
typedef struct {
|
|
int sound_source_no;
|
|
int bx;
|
|
int bz;
|
|
f32 dist;
|
|
} aFD_ongen_info_c;
|
|
|
|
typedef struct {
|
|
int sound_source_no;
|
|
int bx;
|
|
int bz;
|
|
} aFD_ongen_info2_c;
|
|
|
|
typedef struct {
|
|
s16 offset_x;
|
|
s16 offset_z;
|
|
} aFD_offset_c;
|
|
|
|
/*
|
|
4 3 5
|
|
1 0 2
|
|
7 6 8
|
|
*/
|
|
static aFD_offset_c aFD_block_offset_table[] = {
|
|
{ 0, 0 }, // current
|
|
{ -1, 0 }, // left
|
|
{ 1, 0 }, // right
|
|
{ 0, -1 }, // top
|
|
{ -1, -1 }, // top-left
|
|
{ 1, -1 }, // top-right
|
|
{ 0, 1 }, // bot
|
|
{ -1, 1 }, // bot-left
|
|
{ 1, 1 } // bot-right
|
|
};
|
|
|
|
static Gfx* aFD_MakeEnvSetDisplayList(u8 r, u8 g, u8 b, u8 a, GAME* game) {
|
|
Gfx* gfx = GRAPH_ALLOC_TYPE(game->graph, Gfx, 2);
|
|
|
|
if (gfx != NULL) {
|
|
gDPSetEnvColor(gfx + 0, r, g, b, a);
|
|
gSPEndDisplayList(gfx + 1);
|
|
return gfx;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static int aFD_OperateWaterSound(xyz_t* center_pos, ACTOR* actorx, s16 ongen_type, u8 se_no, f32 ofs_x, f32 ofs_z, int search_type) {
|
|
static aFD_ongen_info_c dist_info[9 * mFM_SOUND_SOURCE_NUM];
|
|
static int ongen_block_count_table[aFD_SEARCH_NUM] = { 9, 1, 3 };
|
|
int res = FALSE;
|
|
int search_clamped = search_type >= 0 && search_type < aFD_SEARCH_NUM ? search_type : aFD_SEARCH_FULL;
|
|
int ongen_block_count = ongen_block_count_table[search_clamped];
|
|
int i;
|
|
int j;
|
|
int source_num = 0;
|
|
aFD_ongen_info2_c ongen_info[2] = { { -1, 0, 0 }, { -1, 0, 0 } };
|
|
int bx;
|
|
int bz;
|
|
|
|
if (mFI_Wpos2BlockNum(&bx, &bz, *center_pos)) {
|
|
for (i = 0; i < ongen_block_count; i++) {
|
|
int search_bx = bx + aFD_block_offset_table[i].offset_x;
|
|
int search_bz = bz + aFD_block_offset_table[i].offset_z;
|
|
mFM_bg_sound_source_c* source = mFI_GetSoundSourcePBlockNum(search_bx, search_bz);
|
|
|
|
if (source != NULL) {
|
|
|
|
for (j = 0; j < mFM_SOUND_SOURCE_NUM; j++) {
|
|
if (source->kind == ongen_type) {
|
|
aFD_ongen_info_c* info = &dist_info[source_num++];
|
|
f32 dx = center_pos->x - source->pos.x;
|
|
f32 dz = center_pos->z - source->pos.z;
|
|
|
|
info->sound_source_no = j;
|
|
info->bx = search_bx;
|
|
info->bz = search_bz;
|
|
info->dist = (dx * dx) + (dz * dz);
|
|
}
|
|
|
|
source++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (source_num != 0) {
|
|
int closest_idx = -1;
|
|
f32 closest_dist = 10000000.0f;
|
|
|
|
/* Find the closest sound */
|
|
for (i = 0; i < source_num; i++) {
|
|
if (dist_info[i].dist < closest_dist) {
|
|
ongen_info[0].sound_source_no = dist_info[i].sound_source_no;
|
|
ongen_info[0].bx = dist_info[i].bx;
|
|
ongen_info[0].bz = dist_info[i].bz;
|
|
|
|
closest_idx = i;
|
|
closest_dist = dist_info[i].dist;
|
|
}
|
|
}
|
|
|
|
/* Find the second closest sound (if any) */
|
|
closest_dist = 10000000.0f;
|
|
for (i = 0; i < source_num; i++) {
|
|
if (i != closest_idx) {
|
|
if (dist_info[i].dist < closest_dist) {
|
|
ongen_info[1].sound_source_no = dist_info[i].sound_source_no;
|
|
ongen_info[1].bx = dist_info[i].bx;
|
|
ongen_info[1].bz = dist_info[i].bz;
|
|
|
|
closest_dist = dist_info[i].dist;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Start playing the sounds */
|
|
for (i = 0; i < ARRAY_COUNT(ongen_info); i++) {
|
|
aFD_ongen_info2_c* info = &ongen_info[i];
|
|
|
|
if (info->sound_source_no != -1) {
|
|
u32 ongen_id = (u32)actorx + (mFI_GetBlockXMax() * info->bz + info->bx) * mFM_SOUND_SOURCE_NUM + info->sound_source_no;
|
|
mFM_bg_sound_source_c* source = mFI_GetSoundSourcePBlockNum(info->bx, info->bz);
|
|
|
|
if (source != NULL) {
|
|
xyz_t ongen_pos = source[info->sound_source_no].pos;
|
|
|
|
ongen_pos.x += ofs_x;
|
|
ongen_pos.z += ofs_z;
|
|
ongen_pos.y = mCoBG_GetBgY_OnlyCenter_FromWpos(source[info->sound_source_no].pos, 0.0f) + 40.0f;
|
|
sAdo_OngenPos(ongen_id, se_no, &ongen_pos);
|
|
res = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
static f32 aFD_position_offset = 0.0f;
|
|
|
|
static void aFD_SetActorPosition(ACTOR* actorx, GAME_PLAY* play) {
|
|
PLAYER_ACTOR* player = GET_PLAYER_ACTOR(play);
|
|
|
|
actorx->world.position = player->actor_class.world.position;
|
|
actorx->world.position.y += aFD_position_offset;
|
|
}
|
|
|
|
static void aFD_PrepareFieldDraw(ACTOR* actorx, GAME* game) {
|
|
/*
|
|
6 7 8
|
|
3 4 5
|
|
0 1 2
|
|
*/
|
|
static aFD_offset_c draw_block_offset_table[] = {
|
|
{ -1, 1 }, // bot-left
|
|
{ 0, 1 }, // bot
|
|
{ 1, 1 }, // bot-right
|
|
{ -1, 0 }, // left
|
|
{ 0, 0 }, // current
|
|
{ 1, 0 }, // right
|
|
{ -1, -1 }, // top-left
|
|
{ 0, -1 }, // top
|
|
{ 1, -1 } // top-right
|
|
};
|
|
|
|
GAME_PLAY* play = (GAME_PLAY*)game;
|
|
FIELD_DRAW_ACTOR* field_draw = (FIELD_DRAW_ACTOR*)actorx;
|
|
aFD_block_c* block = field_draw->block;
|
|
mFM_field_draw_info_c* draw_info = mFI_BGDisplayListTop();
|
|
PLAYER_ACTOR* player = GET_PLAYER_ACTOR(play);
|
|
int bx;
|
|
int bz;
|
|
int i;
|
|
|
|
mFI_Wpos2BlockNum(&bx, &bz, player->actor_class.world.position);
|
|
aFD_SetActorPosition(actorx, play);
|
|
|
|
for (i = 0; i < aFD_BLOCK_DRAW_NUM; i++) {
|
|
block->bx = bx + draw_block_offset_table[i].offset_x;
|
|
block->bz = bz + draw_block_offset_table[i].offset_z;
|
|
mFI_BkNum2WposXZ(&block->wpos.x, &block->wpos.z, block->bx, block->bz);
|
|
block->wpos.y = mFI_BkNum2BaseHeight(block->bx, block->bz);
|
|
block->exist = TRUE;
|
|
block++;
|
|
}
|
|
|
|
aFD_MakeMarinScrollInfo(actorx, game);
|
|
}
|
|
|
|
static void aFD_SetPositionOffset(f32 ofs) {
|
|
aFD_position_offset = ofs;
|
|
}
|
|
|
|
static void aFD_SetDefaultPositionOffset() {
|
|
aFD_SetPositionOffset(1000.0f);
|
|
}
|
|
|
|
static void Bg_Draw_Actor_ct(ACTOR* actorx, GAME* game) {
|
|
aFD_PrepareFieldDraw(actorx, game);
|
|
aFD_SetDefaultPositionOffset();
|
|
}
|
|
|
|
static void Bg_Draw_Actor_dt(ACTOR* actorx, GAME* game) {
|
|
|
|
}
|
|
|
|
static void Bg_Draw_Actor_move(ACTOR* actorx, GAME* game) {
|
|
GAME_PLAY* play = (GAME_PLAY*)game;
|
|
PLAYER_ACTOR* player = GET_PLAYER_ACTOR(play);
|
|
lbRTC_time_c* rtc_time = Common_GetPointer(time.rtc_time);
|
|
int bx;
|
|
int bz;
|
|
int pond_x;
|
|
int pond_z;
|
|
|
|
aFD_PrepareFieldDraw(actorx, game);
|
|
|
|
if (mFI_Wpos2BlockNum(&bx, &bz, player->actor_class.world.position)) {
|
|
if ((mFI_BkNum2BlockKind(bx, bz) & mRF_BLOCKKIND_MARINE) != 0) {
|
|
aFD_OperateWaterSound(&player->actor_class.world.position, actorx, 2, 28, 0.0f, 175.0f, aFD_SEARCH_ROW);
|
|
}
|
|
else {
|
|
aFD_OperateWaterSound(&player->actor_class.world.position, actorx, 1, 11, 0.0f, 0.0f, aFD_SEARCH_FULL);
|
|
}
|
|
|
|
if (mRF_SearchPond(&pond_x, &pond_z, bx, bz)) {
|
|
xyz_t frog_se_pos;
|
|
xyz_t pond_pos;
|
|
|
|
/* Play the frog sound effect */
|
|
if (
|
|
rtc_time->month >= lbRTC_MAY && rtc_time->month <= lbRTC_AUGUST &&
|
|
(
|
|
(rtc_time->hour >= 18 && rtc_time->hour <= 21) ||
|
|
(rtc_time->hour >= 4 && rtc_time->hour <= 6)
|
|
)
|
|
) {
|
|
frog_se_pos.x = mFI_UNIT_BASE_SIZE_F + (f32)pond_x * mFI_UNIT_BASE_SIZE_F;
|
|
frog_se_pos.y = 0.0f;
|
|
frog_se_pos.z = mFI_UNIT_BASE_SIZE_F + (f32)pond_z * mFI_UNIT_BASE_SIZE_F;
|
|
frog_se_pos.y = mCoBG_GetBgY_OnlyCenter_FromWpos(frog_se_pos, 0.0f);
|
|
sAdo_OngenPos((u32)&Bg_Draw_Actor_move, 0xA1, &frog_se_pos);
|
|
}
|
|
|
|
/* Pond sound effect */
|
|
pond_pos.x = mFI_UNIT_BASE_SIZE_F * 0.5f + (f32)pond_x * mFI_UNIT_BASE_SIZE_F;
|
|
pond_pos.y = 0.0f;
|
|
pond_pos.z = mFI_UNIT_BASE_SIZE_F * 0.5f + (f32)pond_z * mFI_UNIT_BASE_SIZE_F;
|
|
pond_pos.y = mCoBG_GetBgY_OnlyCenter_FromWpos(pond_pos, 0.0f);
|
|
sAdo_OngenPos((u32)&Bg_Draw_Actor_ct, 0x16, &pond_pos);
|
|
}
|
|
}
|
|
|
|
if (GETREG(CRV, 39)) {
|
|
int i;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
// ??
|
|
}
|
|
|
|
SETREG(CRV, 39, 0);
|
|
}
|
|
}
|
|
|
|
/* Culling box which is aproximately 128:25 (5.12:1) on the xz plane */
|
|
/* NOTE: these vertices are only included because they are not used in any art asset */
|
|
static Vtx aFD_culling_vtx[] ATTRIBUTE_ALIGN(32) = {
|
|
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
|
|
{ 0, 0, 10240, 0, 0, 0, 0, 0, 0, 0 },
|
|
{ 10240, 0, 10240, 0, 0, 0, 0, 0, 0, 0 },
|
|
{ 10240, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
|
|
{ 0, 2000, 0, 0, 0, 0, 0, 0, 0, 0 },
|
|
{ 0, 2000, 10240, 0, 0, 0, 0, 0, 0, 0 },
|
|
{ 10240, 2000, 10240, 0, 0, 0, 0, 0, 0, 0 },
|
|
{ 10240, 2000, 0, 0, 0, 0, 0, 0, 0, 0 },
|
|
};
|
|
|
|
static Gfx aFD_cull_set_gfx[] ATTRIBUTE_ALIGN(32) = {
|
|
gsSPClearGeometryMode(G_FOG | G_LIGHTING),
|
|
gsSPVertex(&aFD_culling_vtx[0], 8, 0),
|
|
gsSPCullDisplayList(0, 7),
|
|
gsSPSetGeometryMode(G_FOG | G_LIGHTING),
|
|
gsSPEndDisplayList(),
|
|
};
|
|
|
|
static Gfx aFD_cull_set_model[] ATTRIBUTE_ALIGN(32) = {
|
|
gsSPDisplayList(aFD_cull_set_gfx),
|
|
gsSPDisplayList(SEGMENT_ADDR(G_MWO_SEGMENT_A, 0)), /* Dynamic segment 0x0A */
|
|
gsSPEndDisplayList(),
|
|
};
|
|
|
|
static EVW_ANIME_SCROLL aFD_texture_scroll2_data[2] = {
|
|
{ 1, -1, 32, 32 },
|
|
{ -1, -2, 32, 32 }
|
|
};
|
|
|
|
static EVW_ANIME_DATA aFD_evw_data = {
|
|
-4, EVW_ANIME_TYPE_SCROLL2, aFD_texture_scroll2_data
|
|
};
|
|
|
|
static void aFD_SetRiverFlow(GAME_PLAY* play) {
|
|
Evw_Anime_Set(play, &aFD_evw_data);
|
|
}
|
|
|
|
static void aFD_SetViewerData(EVW_ANIME_DATA* data, GAME_PLAY* play) {
|
|
if (data != NULL) {
|
|
Evw_Anime_Set(play, data);
|
|
}
|
|
else {
|
|
aFD_SetRiverFlow(play);
|
|
}
|
|
}
|
|
|
|
static int aFD_SetBeachColorOpaSegment(ACTOR* actorx, GAME* game, int bx, int bz) {
|
|
FIELD_DRAW_ACTOR* field_draw = (FIELD_DRAW_ACTOR*)actorx;
|
|
aFD_marin_info_c* marin_info = &field_draw->marin_info;
|
|
|
|
if ((mFI_BkNum2BlockKind(bx, bz) & mRF_BLOCKKIND_MARINE) != 0) {
|
|
Gfx* gfx = aFD_MakeEnvSetDisplayList(marin_info->beach_env_color.r, marin_info->beach_env_color.g, marin_info->beach_env_color.b, marin_info->beach_env_color.a, game);
|
|
|
|
if (gfx == NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
OPEN_DISP(game->graph);
|
|
|
|
gSPSegment(NEXT_BG_OPA_DISP, G_MWO_SEGMENT_C, gfx);
|
|
|
|
CLOSE_DISP(game->graph);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static int aFD_SetMarinScrollXluSegment(ACTOR* actorx, GAME* game, int bx, int bz) {
|
|
FIELD_DRAW_ACTOR* field_draw = (FIELD_DRAW_ACTOR*)actorx;
|
|
aFD_marin_info_c* marin_info = &field_draw->marin_info;
|
|
|
|
if ((mFI_BkNum2BlockKind(bx, bz) & mRF_BLOCKKIND_MARINE) != 0) {
|
|
Gfx* gfx0 = two_tex_scroll_dolphin(game->graph, 0, 0, marin_info->tile0_scroll << 1, 32, 32, 1, 0, marin_info->tile1_scroll << 1, 32, 64);
|
|
Gfx* gfx1 = two_tex_scroll_dolphin(game->graph, 0, 0, marin_info->tile0_scroll << 1, 32, 32, 1, 0, marin_info->tile1_scroll << 1, 32, 32);
|
|
|
|
if (gfx0 == NULL || gfx1 == NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
OPEN_DISP(game->graph);
|
|
|
|
gSPSegment(NEXT_POLY_XLU_DISP, G_MWO_SEGMENT_B, gfx0);
|
|
gSPSegment(NEXT_POLY_XLU_DISP, G_MWO_SEGMENT_D, gfx1);
|
|
|
|
CLOSE_DISP(game->graph);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void aFD_DrawBg(Gfx* gfx, int exists, GAME* game) {
|
|
if (gfx != NULL) {
|
|
OPEN_DISP(game->graph);
|
|
|
|
gSPSegment(NEXT_BG_OPA_DISP, G_MWO_SEGMENT_A, gfx); /* Bg display list is called in between culling microcode */
|
|
gSPDisplayList(NEXT_BG_OPA_DISP, aFD_cull_set_model);
|
|
|
|
CLOSE_DISP(game->graph);
|
|
}
|
|
}
|
|
|
|
static void aFD_DrawXluBg(Gfx* gfx, int exists, GAME* game) {
|
|
if (gfx != NULL) {
|
|
OPEN_DISP(game->graph);
|
|
|
|
if (mFI_GetFieldId() == mFI_FIELD_ROOM_BUGGY) {
|
|
GAME_PLAY* play = (GAME_PLAY*)game;
|
|
static xyz_t ball = { 160.0f, 70.0f, 180.0f }; // Katrina's crystal ball highlight
|
|
|
|
Setpos_HiliteReflect_xlu_init(&ball, play);
|
|
}
|
|
|
|
gSPDisplayList(NEXT_POLY_XLU_DISP, gfx);
|
|
|
|
CLOSE_DISP(game->graph);
|
|
}
|
|
}
|
|
|
|
typedef void (*aFD_DRAW_PROC)(GAME* game);
|
|
|
|
static void aFD_DrawBlock(aFD_block_c* block, ACTOR* actorx, GAME* game) {
|
|
static aFD_DRAW_PROC draw_proc[] = {
|
|
(aFD_DRAW_PROC)&none_proc1,
|
|
&Global_kankyo_set_room_prim,
|
|
&Global_kankyo_set_room_prim,
|
|
(aFD_DRAW_PROC)&none_proc1
|
|
};
|
|
|
|
int block_type = mFI_BkNum2BlockType(block->bx, block->bz);
|
|
s8 anime_frame_count;
|
|
EVW_ANIME_DATA* anime_data;
|
|
u32 exist = block->exist;
|
|
Gfx* opa_gfx;
|
|
Gfx* xlu_gfx;
|
|
GAME_PLAY* play = (GAME_PLAY*)game;
|
|
|
|
if (exist != FALSE) {
|
|
opa_gfx = mFI_GetBGDisplayListRom(block->bx, block->bz);
|
|
xlu_gfx = mFI_GetBGDisplayListRom_XLU(block->bx, block->bz);
|
|
anime_data = mFI_GetBGTexAnimInfo(&anime_frame_count, block->bx, block->bz);
|
|
|
|
Matrix_translate(block->wpos.x, block->wpos.y, block->wpos.z, 0);
|
|
Matrix_scale(0.0625f, 0.0625f, 0.0625f, 1);
|
|
_texture_z_light_fog_prim_xlu(game->graph);
|
|
_texture_z_light_fog_prim_bg(game->graph);
|
|
|
|
OPEN_DISP(game->graph);
|
|
|
|
gSPMatrix(NEXT_POLY_XLU_DISP, _Matrix_to_Mtx_new(game->graph), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
|
|
gSPMatrix(NEXT_BG_OPA_DISP, _Matrix_to_Mtx_new(game->graph), G_MTX_NOPUSH | G_MTX_LOAD | G_MTX_MODELVIEW);
|
|
|
|
CLOSE_DISP(game->graph);
|
|
|
|
aFD_SetViewerData(anime_data, play);
|
|
(*draw_proc[Common_Get(field_draw_type)])(game);
|
|
|
|
if (aFD_SetBeachColorOpaSegment(actorx, game, block->bx, block->bz)) {
|
|
u32 kind = mFI_BkNum2BlockKind(block->bx, block->bz);
|
|
|
|
switch (GETREG(MYKREG, 77)) {
|
|
case 0:
|
|
{
|
|
// Draw all BG
|
|
aFD_DrawBg(opa_gfx, exist, game);
|
|
break;
|
|
}
|
|
|
|
case 1:
|
|
{
|
|
// Do not draw BG unless we're in an island block
|
|
if ((kind & mRF_BLOCKKIND_ISLAND) == 0) {
|
|
aFD_DrawBg(opa_gfx, exist, game);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 2:
|
|
{
|
|
// Do not draw BG at all
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
// Draw all BG
|
|
aFD_DrawBg(opa_gfx, exist, game);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (aFD_SetMarinScrollXluSegment(actorx, game, block->bx, block->bz)) {
|
|
if (GETREG(MYKREG, 77) != 3) {
|
|
aFD_DrawXluBg(xlu_gfx, exist, game);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void aFD_MakeMarinScrollInfo(ACTOR* actorx, GAME* game) {
|
|
FIELD_DRAW_ACTOR* field_draw = (FIELD_DRAW_ACTOR*)actorx;
|
|
aFD_marin_info_c* marin_info = &field_draw->marin_info;
|
|
GAME_PLAY* play = (GAME_PLAY*)game;
|
|
|
|
int frame = play->game_frame % 300;
|
|
f32 frame_f = (f32)frame;
|
|
f32 wave_radian = (frame_f / 300.0f) * F_PI * 2.0f;
|
|
f32 wave_cos = cosf_table(wave_radian);
|
|
f32 beach_cos = cosf_table((wave_radian - 1.2f) + (f32)GETREG(MYKREG, 53) * 0.01f);
|
|
|
|
marin_info->frame = frame;
|
|
marin_info->tile0_scroll = (int)((f32)play->game_frame * -0.42666667f) - 7;
|
|
marin_info->tile1_scroll = (int)(wave_cos * -32.0f - -32.0f);
|
|
|
|
mCoBG_WaveCos2BgCheck(wave_cos);
|
|
|
|
marin_info->beach_env_color.r = (u8)(int)(144.0f + ((beach_cos * -21.0f) + 21.0f));
|
|
marin_info->beach_env_color.g = (u8)(int)(128.0f + ((beach_cos * -18.0f) + 18.0f));
|
|
marin_info->beach_env_color.b = (u8)(int)( 96.0f + ((beach_cos * -14.0f) + 14.0f));
|
|
marin_info->beach_env_color.a = (u8)255;
|
|
}
|
|
|
|
static void Bg_Draw_Actor_draw(ACTOR* actorx, GAME* game) {
|
|
FIELD_DRAW_ACTOR* field_draw = (FIELD_DRAW_ACTOR*)actorx;
|
|
aFD_block_c* block = field_draw->block;
|
|
int i;
|
|
|
|
OPEN_DISP(game->graph);
|
|
|
|
gDPSetTexEdgeAlpha(NEXT_BG_OPA_DISP, 144);
|
|
gDPSetTexEdgeAlpha(NEXT_POLY_XLU_DISP, 144);
|
|
gDPSetTextureAdjustMode(NEXT_BG_OPA_DISP, G_TA_DOLPHIN);
|
|
gDPSetTextureAdjustMode(NEXT_POLY_XLU_DISP, G_TA_DOLPHIN);
|
|
|
|
CLOSE_DISP(game->graph);
|
|
|
|
for (i = 0; i < aFD_BLOCK_DRAW_NUM; i++) {
|
|
aFD_DrawBlock(block, actorx, game);
|
|
block++;
|
|
}
|
|
|
|
OPEN_DISP(game->graph);
|
|
|
|
gDPSetTextureAdjustMode(NEXT_BG_OPA_DISP, G_TA_N64);
|
|
gDPSetTextureAdjustMode(NEXT_POLY_XLU_DISP, G_TA_N64);
|
|
|
|
CLOSE_DISP(game->graph);
|
|
}
|