kobayashi90/marioparty4
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Decompile more of board/main.c

Browse source
This commit is contained in:
gamemasterplc 2024-01-02 21:39:51 -06:00
parent 8e0e8a9e2a
commit c03ef31c81
10 changed files with 680 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

2
config/GMPE01_00/splits.txt
View file

@ -347,7 +347,7 @@ game/board/window.c:
.sbss start:0x801D3F68 end:0x801D3F90
.sdata2 start:0x801D5318 end:0x801D5328
game/board/speaker.c:
game/board/audio.c:
.text start:0x80070D84 end:0x80071290
.data start:0x80139AE8 end:0x80139B00
.sdata start:0x801D36E8 end:0x801D36F0

26
config/GMPE01_00/symbols.txt
View file

@ -1013,14 +1013,14 @@ BoardPartyConfigSet = .text:0x8005BE30; // type:function size:0x160
DestroyMainFunc = .text:0x8005BF90; // type:function size:0xC scope:local
MainFunc = .text:0x8005BF9C; // type:function size:0x7D0 scope:local
BoardTurnNext = .text:0x8005C76C; // type:function size:0x8C
BoardTurnStartExec = .text:0x8005C7F8; // type:function size:0x28C
ExecTurnStart = .text:0x8005C7F8; // type:function size:0x28C scope:local
BoardNextOvlSet = .text:0x8005CA84; // type:function size:0xC4
BoardIsStarted = .text:0x8005CB48; // type:function size:0x8C
CreateBoard = .text:0x8005CBD4; // type:function size:0x410 scope:local
DestroyBoard = .text:0x8005CFE4; // type:function size:0x128 scope:local
BoardLightHookSet = .text:0x8005D10C; // type:function size:0xC
BoardLightSet = .text:0x8005D118; // type:function size:0x44
BoardLightReset = .text:0x8005D15C; // type:function size:0x50
BoardLightSetExec = .text:0x8005D118; // type:function size:0x44
BoardLightResetExec = .text:0x8005D15C; // type:function size:0x50
BoardCameraBackup = .text:0x8005D1AC; // type:function size:0x3C
BoardCameraRestore = .text:0x8005D1E8; // type:function size:0x48
BoardCameraScissorSet = .text:0x8005D230; // type:function size:0x54
@ -1031,32 +1031,32 @@ BoardCameraRotGet = .text:0x8005D5C0; // type:function size:0x48
BoardCameraZoomGet = .text:0x8005D608; // type:function size:0x20
BoardCameraDirGet = .text:0x8005D628; // type:function size:0xA8
BoardCameraPointDirGet = .text:0x8005D6D0; // type:function size:0xBC
BoardCameraSet = .text:0x8005D78C; // type:function size:0x28
BoardCameraVisibleSet = .text:0x8005D7B4; // type:function size:0x50
BoardCameraMaskSet = .text:0x8005D78C; // type:function size:0x28
BoardCameraMoveSet = .text:0x8005D7B4; // type:function size:0x50
BoardCameraOffsetSet = .text:0x8005D804; // type:function size:0x30
BoardCameraTargetPlayerSet = .text:0x8005D834; // type:function size:0xB4
BoardCameraTargetModelSet = .text:0x8005D8E8; // type:function size:0x40
BoardCameraTargetSpaceSet = .text:0x8005D928; // type:function size:0x44
BoardCameraVecCalcFuncSet = .text:0x8005D96C; // type:function size:0x28
BoardCameraPosCalcFuncSet = .text:0x8005D96C; // type:function size:0x28
BoardCameraQuakeSet = .text:0x8005D994; // type:function size:0x3C
BoardCameraQuakeReset = .text:0x8005D9D0; // type:function size:0x3C
BoardCameraTargetSet = .text:0x8005DA0C; // type:function size:0x28
BoardCameraPosSet = .text:0x8005DA34; // type:function size:0x28
BoardCameraAngleZoomSet = .text:0x8005DA5C; // type:function size:0x24
BoardCameraXRotZoomSet = .text:0x8005DA5C; // type:function size:0x24
BoardCameraZoomSet = .text:0x8005DA80; // type:function size:0x20
BoardCameraAngleSet = .text:0x8005DAA0; // type:function size:0x24
BoardCameraRotSet = .text:0x8005DAA0; // type:function size:0x24
BoardCameraNearFarSet = .text:0x8005DAC4; // type:function size:0x24
BoardCameraNearFarGet = .text:0x8005DAE8; // type:function size:0x3C
BoardCameraStartMotion = .text:0x8005DB24; // type:function size:0x48
BoardCameraStartMotion2 = .text:0x8005DB6C; // type:function size:0x230
BoardCameraMotionStart = .text:0x8005DB24; // type:function size:0x48
BoardCameraMotionStartEx = .text:0x8005DB6C; // type:function size:0x230
BoardCameraFovSet = .text:0x8005DD9C; // type:function size:0x20
BoardCameraCullCheck = .text:0x8005DDBC; // type:function size:0x2BC
BoardCameraMotionIsDone = .text:0x8005E078; // type:function size:0x48
BoardCameraMotionWait = .text:0x8005E0C0; // type:function size:0x58
BoardCameraInit = .text:0x8005E118; // type:function size:0x24C
BoardCameraUpdate = .text:0x8005E364; // type:function size:0x350
BoardCameraCalcTarget = .text:0x8005E6B4; // type:function size:0xE4
BoardCameraCalcVec = .text:0x8005E798; // type:function size:0x764
UpdateCamera = .text:0x8005E364; // type:function size:0x350 scope:local
CalcCameraTarget = .text:0x8005E6B4; // type:function size:0xE4 scope:local
CalcCameraPos = .text:0x8005E798; // type:function size:0x764 scope:local
BoardMGDoneFlagSet = .text:0x8005EEFC; // type:function size:0x48
BoardMGDoneFlagGet = .text:0x8005EF44; // type:function size:0x48
BoardMGExit = .text:0x8005EF8C; // type:function size:0x170

2
configure.py
View file

@ -363,7 +363,7 @@ config.libs = [
Object(NonMatching, "game/board/player.c"),
Object(NonMatching, "game/board/model.c"),
Object(Matching, "game/board/window.c"),
Object(NonMatching, "game/board/speaker.c"),
Object(NonMatching, "game/board/audio.c"),
Object(NonMatching, "game/board/com.c"),
Object(NonMatching, "game/board/overhead.c"),
Object(NonMatching, "game/board/space.c"),

5
include/functions.h
View file

@ -46,7 +46,7 @@ void fn_8004D6F4(s16 arg);
s32 rand8(void);
void BoardCameraTargetModelSet(s16 model);
void BoardCameraStartMotion2(s16, Vec*, s32, f32, f32, s32);
void BoardCameraMotionStartEx(s16, Vec*, s32, f32, f32, s32);
void BoardCameraMotionWait(void);
void BoardSpacePosGet(s32, s32, Vec*);
void fn_8007A360(s32);
@ -65,7 +65,6 @@ f32 BoardModelRotYGet(s32);
void BoardModelLayerSet(s16, s32);
void BoardTutorialHostSet(s16);
s16 BoardModelIDGet(s16);
void BoardCommonInit(void*, void*);
void BoardModelScaleSetV(s32, Vec*);
void BoardLightHookSet(void*, void*);
s16 BoardModelCreate(s32, void*, s32);
@ -89,7 +88,7 @@ void fn_80083EDC(s16);
void fn_800A4F6C(s16);
void BoardTutorialHookSet(void*);
void BoardTutorialBlockSetPos(s32, s32);
void BoardCameraRotGet(Vec*);
s32 BoardCameraRotGet(Vec*);
void BoardModelScaleSet(s16, f32, f32, f32);
s32 BoardIsKill(void);
void BoardModelMtxSet(s16, Mtx);

2
include/game/hsfman.h
View file

@ -204,7 +204,7 @@ void Hu3DModelReflectTypeSet(s16, s16);
void Hu3DCameraCreate(s32);
void Hu3DCameraPerspectiveSet(s32, f32, f32, f32, f32);
void Hu3DCameraViewportSet(s32, f32, f32, f32, f32, f32, f32);
void Hu3DCameraScissorSet(s32, s32, s32, s32, s32);
void Hu3DCameraScissorSet(s32, u32, u32, u32, u32);
void Hu3DCameraPosSet(s32, f32, f32, f32, f32, f32, f32, f32, f32, f32);
void Hu3DCameraPosSetV(s32 cam, Vec *pos, Vec *up, Vec *target);
void Hu3DCameraKill(s32);

7
include/math.h
View file

@ -63,10 +63,17 @@ float acosf(float x);
#define abs(x) __abs(x)
extern inline double fabs(double x)
{
return __fabs(x);
}
_MATH_INLINE float fabsf(float x) { return (float)fabs((double)x); }
_MATH_INLINE float sinf(float x) { return (float)sin((double)x); }
_MATH_INLINE float cosf(float x) { return (float)cos((double)x); }
_MATH_INLINE float atan2f(float y, float x) { return (float)atan2((double)y, (double)x); }
_MATH_INLINE float atanf(float x) { return (float)atan((double)x); }
_MATH_INLINE float fmodf(float x, float m) { return (float)fmod((double)x, (double)m); }
_MATH_INLINE float floorf(float x) { return floor(x); }

12
src/REL/w10Dll/scene.c
View file

@ -185,29 +185,29 @@ void fn_1_13A4(void) {
temp_r3_2 = BoardSpaceFlagSearch(0, 0x80000);
BoardSpacePosGet(0, temp_r3_2, &sp14);
BoardModelPosSetV(lbl_1_bss_0->unk8, &sp14);
BoardCameraStartMotion2(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
BoardCameraMotionStartEx(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
BoardCameraMotionWait();
fn_1_BA0(0x2E002C);
fn_8007A360(temp_r3_2);
BoardCameraStartMotion2(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
BoardCameraMotionStartEx(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
BoardCameraMotionWait();
temp_r3_2 = BoardSpaceFlagSearch(0, 0x10000000);
BoardSpacePosGet(0, temp_r3_2, &sp14);
BoardModelPosSetV(lbl_1_bss_0->unk8, &sp14);
BoardCameraStartMotion2(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
BoardCameraMotionStartEx(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
BoardCameraMotionWait();
fn_1_BA0(0x2E002E);
fn_8007F894();
BoardCameraStartMotion2(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
BoardCameraMotionStartEx(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
BoardCameraMotionWait();
temp_r3_2 = BoardSpaceFlagSearch(0, 0x08000000);
BoardSpacePosGet(0, temp_r3_2, &sp14);
BoardModelPosSetV(lbl_1_bss_0->unk8, &sp14);
BoardCameraStartMotion2(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
BoardCameraMotionStartEx(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
BoardCameraMotionWait();
fn_1_BA0(0x2E0030);
fn_800A6B10();
BoardCameraStartMotion2(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
BoardCameraMotionStartEx(lbl_1_bss_0->unk8, &sp8, 0, 3200.0f, -1.0f, 0x1E);
BoardCameraMotionWait();
fn_1_BA0(0x2E0032);
BoardCameraTargetModelSet(fn_80083F84());

649
src/game/board/main.c
View file

@ -4,6 +4,60 @@
#include "game/flag.h"
#include "game/data.h"
#include "game/wipe.h"
#include "string.h"
#include "game/hsfman.h"
typedef struct board_focus_data {
u16 view_type;
s16 time;
s16 max_time;
float fov_start;
float fov_end;
float zoom_start;
float zoom_end;
Vec rot_start;
Vec rot_end;
Vec target_start;
Vec target_end;
} BoardFocusData;
typedef struct board_camera_data {
struct {
u8 hide_all : 1;
u8 moving : 1;
u8 quaking : 1;
};
u16 mask;
s16 target_mdl;
s16 target_space;
s32 quake_timer;
float quake_strength;
float fov;
float near;
float far;
float aspect;
float viewport_x;
float viewport_y;
float viewport_w;
float viewport_h;
float viewport_near;
float viewport_far;
Vec pos;
Vec up;
Vec target;
Vec offset;
Vec rot;
float zoom;
void (*pos_calc)(struct board_camera_data *camera);
BoardFocusData focus;
} BoardCameraData;
typedef struct camera_view {
s16 x_rot;
s16 zoom;
s16 fov;
} CameraView;
typedef void (*VoidFunc)(void);
@ -27,20 +81,44 @@ static omObjData *cameraObj;
Process *boardObjMan;
Process *boardMainProc;
static BoardCameraData cameraBackup;
BoardCameraData boardCamera;
static OverlayID nextOvl = OVL_INVALID;
static CameraView camViewTbl[] = {
{ 0, 0, 25 },
{ -33, 3200, 25 },
{ -33, 2100, 25 },
{ -33, 1800, 25 },
{ -33, 12640, 25 },
{ -33, 3200, 25 },
};
extern void BoardPlayerCoinsSet(s32 player, s32 value);
extern void BoardPlayerAutoSizeSet(s32 player, s32 value);
extern void BoardModelPosGet(s16 model, Vec *pos);
extern void fn_800A4A7C(void);
extern void fn_800A6EE4(void);
extern s8 boardTutorialF;
extern s16 boardPlayerMdl[4];
void BoardKill(void);
void BoardCameraTargetPlayerSet(s32 player);
void BoardCameraOffsetSet(float x, float y, float z);
void BoardCameraMoveSet(s32 move);
void BoardCameraMotionStartEx(s16 model_target, Vec *rot_target, Vec *offset_end, float zoom_target, float fov_target, s16 max_time);
float BoardRandFloat(void);
static void InitBoardFunc(omObjData *object);
static void ExecBoardFunc(omObjData *object);
static void KillBoardFunc(omObjData *object);
static void UpdateCamera(omObjData *object);
static void CalcCameraTarget(BoardCameraData *camera);
static void CalcCameraPos(BoardCameraData *camera);
static void MainFunc(void);
static void DestroyMainFunc(void);
@ -64,6 +142,35 @@ static inline s16 BoardHandicapGet(s32 player)
return GWPlayer[player].handicap;
}
static inline s32 BoardPlayerCurrGetIdx()
{
return GWSystem.player_curr;
}
static inline PlayerState *BoardPlayerGet(s32 player)
{
return &GWPlayer[player];
}
static inline PlayerState *BoardPlayerCurrGet()
{
return &GWPlayer[BoardPlayerCurrGetIdx()];
}
static inline s16 BoardPlayerModelGet(s32 player)
{
PlayerState *player_ptr = BoardPlayerGet(player);
return boardPlayerMdl[player_ptr->player_idx];
}
static inline s16 BoardPlayerCurrModelGet()
{
PlayerState *player = BoardPlayerCurrGet();
return boardPlayerMdl[player->player_idx];
}
#define BoardFAbs(value) ((value < 0) ? -(value) : (value))
void BoardCommonInit(VoidFunc create, VoidFunc destroy)
{
omSysPauseEnable(FALSE);
@ -396,7 +503,7 @@ static void MainFunc(void)
} else {
fade_enable = 0;
}
if(BoardIsTurnCont()) {
if(ExecTurnStart()) {
turn_cont = 1;
}
if((int)(GWSystem.max_turn-GWSystem.turn) < 5 && GWSystem.player_curr == 0 && !turn_cont) {
@ -432,9 +539,9 @@ static void MainFunc(void)
BoardPlayerTurnExec(i);
} else {
if(!turn_cont) {
BoardCameraVisibleSet(0);
BoardCameraMoveSet(0);
GWSystem.player_curr = i;
BoardCameraTargetModelSet(i);
BoardCameraTargetPlayerSet(i);
BoardCameraMotionWait();
{
Vec pos;
@ -508,7 +615,7 @@ static void MainFunc(void)
_SetFlag(FLAG_ID_MAKE(1, 28));
_SetFlag(FLAG_ID_MAKE(1, 14));
BoardPauseEnableSet(1);
_CheckFlag(FLAG_ID_MAKE(1, 9));
_ClearFlag(FLAG_ID_MAKE(1, 9));
if(_CheckFlag(FLAG_ID_MAKE(2, 0)) || _CheckFlag(FLAG_ID_MAKE(1, 11)) ) {
for(i=0; i<4; i++) {
GWPlayer[i].color = 0;
@ -562,6 +669,540 @@ static void DestroyBoard(void)
}
void BoardCameraBackup(void)
{
cameraUseBackup = TRUE;
memcpy(&cameraBackup, &boardCamera, sizeof(BoardCameraData));
}
void BoardCameraRestore(void)
{
if(cameraUseBackup) {
memcpy(&boardCamera, &cameraBackup, sizeof(BoardCameraData));
cameraUseBackup = FALSE;
}
}
void BoardCameraScissorSet(s32 x, s32 y, s32 w, s32 h)
{
BoardCameraData *camera = &boardCamera;
Hu3DCameraScissorSet(camera->mask, x, y, w, h);
}
void BoardCameraViewSet(s32 type)
{
BoardCameraData *camera = &boardCamera;
BoardFocusData *focus;
float size;
if(!cameraObj) {
return;
}
focus = &camera->focus;
if(type == 0) {
focus->view_type = 0;
return;
}
OSs16tof32(&camViewTbl[type].fov, &focus->fov_end);
focus->fov_start = camera->fov;
OSs16tof32(&camViewTbl[type].zoom, &focus->zoom_end);
focus->zoom_start = camera->zoom;
OSs16tof32(&camViewTbl[type].x_rot, &focus->rot_end.x);
focus->rot_end.y = 0;
focus->rot_end.z = 0;
focus->rot_start = camera->rot;
focus->target_start = camera->target;
if(BoardPlayerSizeGet(GWSystem.player_curr) == 2 || GWPlayer[GWSystem.player_curr].bowser_suit) {
focus->zoom_end += 400.0f;
size = 2.5f;
} else {
size = 1.0f;
}
BoardCameraTargetModelSet(BoardPlayerCurrModelGet());
BoardPlayerPosGet(GWSystem.player_curr, &focus->target_end);
BoardCameraOffsetSet(0.0f, 100.0f*size, 0.0f);
focus->target_end.y += 100.0f*size;
_SetFlag(FLAG_ID_MAKE(1, 21));
focus->view_type = type;
focus->time = 0;
if(camera->moving) {
focus->max_time = 21;
} else {
focus->max_time = 1;
}
}
s32 BoardCameraPosGet(Vec *dst)
{
BoardCameraData *camera;
if(!dst) {
return -1;
}
camera = &boardCamera;
*dst = camera->pos;
return 0;
}
s32 BoardCameraTargetGet(Vec *dst)
{
BoardCameraData *camera;
if(!dst) {
return -1;
}
camera = &boardCamera;
*dst = camera->target;
return 0;
}
s32 BoardCameraRotGet(Vec *dst)
{
BoardCameraData *camera;
if(!dst) {
return -1;
}
camera = &boardCamera;
*dst = camera->rot;
return 0;
}
float BoardCameraZoomGet()
{
BoardCameraData *camera;
camera = &boardCamera;
return camera->zoom;
}
s32 BoardCameraDirGet(Vec *dst)
{
BoardCameraData *camera;
if(!dst) {
return -1;
}
camera = &boardCamera;
if(!camera) {
return -1;
}
VECSubtract(&camera->target, &camera->pos, dst);
if(dst->x != 0 || dst->y != 0 || dst->z != 0) {
VECNormalize(dst, dst);
}
return 0;
}
s32 BoardCameraPointDirGet(Vec *point, Vec *dst)
{
BoardCameraData *camera;
if(!dst || !point) {
return -1;
}
camera = &boardCamera;
if(!camera) {
return -1;
}
VECSubtract(point, &camera->pos, dst);
if(dst->x != 0 || dst->y != 0 || dst->z != 0) {
VECNormalize(dst, dst);
}
return 0;
}
void BoardCameraMaskSet(u16 mask)
{
BoardCameraData *camera = &boardCamera;
if(!camera) {
return;
}
camera->mask = mask;
}
void BoardCameraMoveSet(s32 move)
{
BoardCameraData *camera = &boardCamera;
if(!camera) {
return;
}
if(!move) {
camera->moving = 0;
} else {
camera->moving = 1;
}
}
void BoardCameraOffsetSet(float x, float y, float z)
{
BoardCameraData *camera = &boardCamera;
if(!camera) {
return;
}
camera->offset.x = x;
camera->offset.y = y;
camera->offset.z = z;
}
void BoardCameraTargetPlayerSet(s32 player)
{
PlayerState *player_ptr = BoardPlayerGet(player);
if(!player_ptr) {
BoardCameraTargetModelSet(-1);
return;
}
BoardCameraTargetModelSet(BoardPlayerModelGet(player));
BoardCameraOffsetSet(0, 100, 0);
}
void BoardCameraTargetModelSet(s16 model)
{
BoardCameraData *camera = &boardCamera;
if(!camera) {
return;
}
camera->target_mdl = model;
camera->target_space = -1;
camera->offset.x = camera->offset.y = camera->offset.z = 0;
}
void BoardCameraTargetSpaceSet(s32 space)
{
BoardCameraData *camera = &boardCamera;
if(!camera) {
return;
}
camera->target_mdl = -1;
camera->target_space = space;
camera->offset.x = camera->offset.y = camera->offset.z = 0;
}
void BoardCameraPosCalcFuncSet(void (*func)(struct board_camera_data *camera))
{
BoardCameraData *camera = &boardCamera;
if(!camera) {
return;
}
camera->pos_calc = func;
}
void BoardCameraQuakeSet(s32 duration, float strength)
{
BoardCameraData *camera = &boardCamera;
if(!camera) {
return;
}
camera->quaking = 1;
camera->quake_strength = strength;
camera->quake_timer = duration;
}
void BoardCameraQuakeReset(s32 duration, float strength)
{
BoardCameraData *camera = &boardCamera;
camera->quaking = 0;
camera->quake_strength = 0;
camera->quake_timer = 0;
}
void BoardCameraTargetSet(float x, float y, float z)
{
BoardCameraData *camera = &boardCamera;
camera->target.x = x;
camera->target.y = y;
camera->target.z = z;
}
void BoardCameraPosSet(float x, float y, float z)
{
BoardCameraData *camera = &boardCamera;
camera->pos.x = x;
camera->pos.y = y;
camera->pos.z = z;
}
void BoardCameraXRotZoomSet(float zoom, float x_rot)
{
BoardCameraData *camera = &boardCamera;
camera->zoom = zoom;
camera->rot.x = x_rot;
}
void BoardCameraZoomSet(float zoom)
{
BoardCameraData *camera = &boardCamera;
camera->zoom = zoom;
}
void BoardCameraRotSet(float x, float y)
{
BoardCameraData *camera = &boardCamera;
camera->rot.x = x;
camera->rot.y = y;
}
void BoardCameraNearFarSet(float near, float far)
{
BoardCameraData *camera = &boardCamera;
camera->near = near;
camera->far = far;
}
void BoardCameraNearFarGet(float *near, float *far)
{
BoardCameraData *camera = &boardCamera;
if(near) {
*near = camera->near;
}
if(far) {
*far = camera->far;
}
}
void BoardCameraMotionStart(s16 model_target, Vec *rot_target, float zoom_target, float fov_target)
{
BoardCameraMotionStartEx(model_target, rot_target, 0, zoom_target, fov_target, 21);
}
void BoardCameraMotionStartEx(s16 model_target, Vec *rot_target, Vec *offset_end, float zoom_target, float fov_target, s16 max_time)
{
BoardCameraData *camera = &boardCamera;
BoardFocusData *focus;
if(!cameraObj) {
return;
}
focus = &camera->focus;
focus->fov_start = camera->fov;
focus->zoom_start = camera->zoom;
focus->rot_start = camera->rot;
focus->target_start = camera->target;
if(fov_target == -1) {
focus->fov_end = focus->fov_start;
} else {
focus->fov_end = fov_target;
}
if(zoom_target == -1) {
focus->zoom_end = focus->zoom_start;
} else {
focus->zoom_end = zoom_target;
}
if(!rot_target) {
focus->rot_end = focus->rot_start;
} else {
focus->rot_end = *rot_target;
}
if(model_target == -1) {
focus->target_end = focus->target_start;
} else {
BoardCameraTargetModelSet(model_target);
BoardModelPosGet(model_target, &focus->target_end);
}
if(offset_end) {
BoardCameraOffsetSet(offset_end->x, offset_end->y, offset_end->z);
VECAdd(offset_end, &focus->target_end, &focus->target_end);
}
_SetFlag(FLAG_ID_MAKE(1, 21));
focus->view_type = 5;
focus->time = 0;
if(max_time < 0) {
max_time = 1;
}
focus->max_time = max_time;
}
void BoardCameraFovSet(float fov)
{
BoardCameraData *camera = &boardCamera;
camera->fov = fov;
}
s32 BoardCameraCullCheck(Vec *point, float radius)
{
Vec dir;
Vec pos;
float dist;
float dot;
BoardCameraData *camera = &boardCamera;
if(!camera->hide_all) {
return 0;
}
BoardCameraDirGet(&dir);
VECSubtract(point, &camera->pos, &pos);
dist = sqrtf((pos.x*pos.x)+(pos.y*pos.y)+(pos.z*pos.z));
if(25000 < dist-(radius*2.0f)) {
return 0;
}
BoardCameraPointDirGet(point, &pos);
dot = VECDotProduct(&dir, &pos);
if(BoardFAbs(dot) < cos((camera->fov*M_PI)/180)) {
return 0;
} else {
return 1;
}
}
s32 BoardCameraMotionIsDone(void)
{
return (_CheckFlag(FLAG_ID_MAKE(1, 21))) ? 0 : 1;
}
void BoardCameraMotionWait(void)
{
while(!BoardCameraMotionIsDone()) {
HuPrcVSleep();
}
HuPrcVSleep();
}
void BoardCameraInit(void)
{
BoardCameraData *camera;
cameraUseBackup = FALSE;
memset(&cameraBackup, 0, sizeof(BoardCameraData));
memset(&boardCamera, 0, sizeof(BoardCameraData));
camera = &boardCamera;
camera->fov = 25;
camera->near = 100;
camera->far = 13000;
camera->aspect = 1.2;
camera->viewport_x = 0;
camera->viewport_y = 0;
camera->viewport_h = 480;
camera->viewport_w = 640;
camera->viewport_near = 0;
camera->viewport_far = 1;
camera->up.y = 1;
camera->moving = 0;
camera->quaking = 0;
camera->quake_timer = 0;
camera->pos.x = 0;
camera->pos.y = 5000;
camera->pos.z = 5000;
camera->offset.x = 0;
camera->offset.y = 0;
camera->offset.z = 0;
camera->pos_calc = NULL;
BoardSpaceFlagPosGet(0, 0x80000000, &camera->target);
camera->rot.x = camViewTbl[1].x_rot;
camera->zoom = camViewTbl[1].zoom;
camera->hide_all = 1;
camera->mask = 1;
Hu3DCameraCreate(1);
Hu3DCameraScissorSet(1, camera->viewport_x, camera->viewport_y, camera->viewport_w, camera->viewport_h);
Hu3DCameraScissorSet(2, 0, 0, 0, 0);
Hu3DCameraPerspectiveSet(2, -1, 100, 13000, 1.2);
cameraObj = omAddObjEx(boardObjMan, 32258, 0, 0, -1, UpdateCamera);
}
static void CalcCameraView(void)
{
BoardCameraData *camera = &boardCamera;
CalcCameraTarget(camera);
CalcCameraPos(camera);
}
static void UpdateCamera(omObjData *object)
{
BoardCameraData *camera;
Vec *target;
float x, y, z;
if(BoardIsKill()) {
omDelObjEx(HuPrcCurrentGet(), object);
return;
}
CalcCameraView();
camera = &boardCamera;
Hu3DCameraPerspectiveSet(camera->mask, camera->fov, camera->near, camera->far, camera->aspect);
Hu3DCameraViewportSet(camera->mask, camera->viewport_x, camera->viewport_y, camera->viewport_w, camera->viewport_h, camera->viewport_near, camera->viewport_far);
target = &camera->target;
if(camera->pos_calc) {
camera->pos_calc(camera);
} else {
x = camera->rot.x;
y = camera->rot.y;
camera->pos.x = target->x+(sin((y*M_PI)/180.0)*cos((x*M_PI)/180.0)*camera->zoom);
camera->pos.y = target->y+(-sin((x*M_PI)/180.0)*camera->zoom);
camera->pos.z = target->z+(cos((y*M_PI)/180.0)*cos((x*M_PI)/180.0)*camera->zoom);
camera->up.x = sin((y*M_PI)/180.0)*sin((x*M_PI)/180.0);
camera->up.y = cos((x*M_PI)/180.0);
camera->up.z = cos((y*M_PI)/180.0)*sin((x*M_PI)/180.0);
if(camera->quaking) {
x = BoardRandFloat();
y = BoardRandFloat();
z = BoardRandFloat();
camera->pos.x += (x-0.5f)*camera->quake_strength;
camera->pos.y += (y-0.5f)*camera->quake_strength;
camera->pos.z += (z-0.5f)*camera->quake_strength;
if(--camera->quake_timer <= 0) {
camera->quaking = 0;
camera->quake_timer = 0;
camera->quake_strength = 0;
}
}
}
Hu3DCameraPosSetV(camera->mask, &camera->pos, &camera->up, target);
}
static void CalcCameraTarget(BoardCameraData *camera)
{
Vec offset;
Vec pos = { 0, 0, 0 };
BoardFocusData *focus = &camera->focus;
if(camera->target_mdl != -1) {
BoardModelPosGet(camera->target_mdl, &pos);
} else {
if(camera->target_space != -1) {
BoardSpacePosGet(0, camera->target_space, &pos);
} else {
return;
}
}
VECAdd(&camera->offset, &pos, &pos);
VECSubtract(&pos, &camera->target, &offset);
if(camera->moving) {
VECScale(&offset, &offset, 0.2f);
}
VECAdd(&offset, &camera->target, &camera->target);
}
static void CalcCameraPos(BoardCameraData *camera)
{
}
float BoardArcSin(float value)
{
float result;
s32 sign;
if(value < 0) {
sign = 1;
value = BoardFAbs(value);
} else {
sign = 0;
}
if(value > 1.0f) {
return 0;
}
if(value <= (float)(M_PI/2)) {
result = atanf(value/(float)sqrtf(1-(value*value)));
} else {
result = 1.0f-atanf((float)sqrtf(1-(value*value))/value);
}
if(sign) {
result = BoardFAbs(result);
}
return result;
}
float BoardArcCos(float value)
{
if(BoardFAbs(value) > 1) {
return 0;
}
return 1.0f-BoardArcSin(value);
}
void BoardRandInit(void)
{
boardRandSeed = OSGetTime();
}
u32 BoardRand(void)
{
boardRandSeed = (boardRandSeed*0x19660D)+(0x3C6EF35F);

6
src/game/board/warp.c
View file

@ -14,7 +14,7 @@ extern void Hu3DModelObjPosGet(s16, char*, Vec*);
extern s32 BoardModelMotionEndCheck(s16);
extern void BoardPlayerPosSetV(s32, Point3d*);
void BoardPlayerRotSet(s32, f32, f32, f32);
void BoardCameraVisibleSet(s32);
void BoardCameraMoveSet(s32);
void BoardCameraTargetSpaceSet(s16);
extern void BoardRotateDiceNumbers(s32);
extern void BoardPlayerPosGet(s32, Vec*);
@ -195,14 +195,14 @@ void fn_80081278(s32 arg0) {
lbl_801D374A = BoardModelCreate(0x70002, NULL, 0);
BoardModelVisibilitySet(lbl_801D374A, 0);
BoardModelMotionSpeedSet(lbl_801D374A, 0.0f);
BoardCameraVisibleSet(0);
BoardCameraMoveSet(0);
BoardCameraTargetSpaceSet(lbl_801D4034);
HuPrcSleep(1);
WipeCreate(1, 0, 0x15);
while (WipeStatGet() != 0) {
HuPrcVSleep();
}
BoardCameraVisibleSet(1);
BoardCameraMoveSet(1);
lbl_801D402C = -10.0f;
lbl_801D4038 = 4;
}

2
src/game/hsfman.c
View file

@ -1129,7 +1129,7 @@ void Hu3DCameraViewportSet(s32 cam, f32 vx, f32 vy, f32 vw, f32 vh, f32 nz, f32
}
}
void Hu3DCameraScissorSet(s32 cam, s32 x, s32 y, s32 w, s32 h) {
void Hu3DCameraScissorSet(s32 cam, u32 x, u32 y, u32 w, u32 h) {
s16 mask;
s16 i;
CameraData* cam_ptr;