thirdpartymirrors/sm64coopdx
1
0
Fork 0
mirror of https://github.com/coop-deluxe/sm64coopdx.git synced 2025-10-30 08:01:01 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add fov adjustment to djui_hud_world_pos_to_screen_pos (#374)

Browse source 
* Add fov adjustment to djui_hud_world_pos_to_screen_pos
sFOVState is now a global (gFOVState)
djui_hud_world_pos_to_screen_pos now returns false if the position is behind the camera

* Fix aspect ratio parentheses

* Rerun autogen

---------

Co-authored-by: Marioiscool246 <marioiscool101@gmail.com>
This commit is contained in:
Marioiscool246 2023-04-30 22:54:55 -04:00 • committed by GitHub
parent 9b1123dde9
commit 7b4b873d39
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 72 additions and 64 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
autogen/lua_definitions/functions.lua
View file

@ -3745,7 +3745,7 @@ end
--- @param pos Vec3f --- @param pos Vec3f
--- @param out Vec3f --- @param out Vec3f
--- @return nil --- @return boolean
function djui_hud_world_pos_to_screen_pos(pos, out) function djui_hud_world_pos_to_screen_pos(pos, out)
-- ... -- ...
end end

6
docs/lua/functions-3.md
View file

@ -2426,7 +2426,7 @@
## [djui_hud_world_pos_to_screen_pos](#djui_hud_world_pos_to_screen_pos) ## [djui_hud_world_pos_to_screen_pos](#djui_hud_world_pos_to_screen_pos)
### Lua Example ### Lua Example
`djui_hud_world_pos_to_screen_pos(pos, out)` `local booleanValue = djui_hud_world_pos_to_screen_pos(pos, out)`
### Parameters ### Parameters
| Field | Type | | Field | Type |
@ -2435,10 +2435,10 @@
| out | [Vec3f](structs.md#Vec3f) | | out | [Vec3f](structs.md#Vec3f) |
### Returns ### Returns
- None - `boolean`
### C Prototype ### C Prototype
`void djui_hud_world_pos_to_screen_pos(Vec3f pos, Vec3f out);` `bool djui_hud_world_pos_to_screen_pos(Vec3f pos, Vec3f out);`
[:arrow_up_small:](#) [:arrow_up_small:](#)

96
src/game/camera.c
View file

@ -115,7 +115,7 @@ s16 sCreditsPlayer2Yaw;
*/ */
u8 sFramesPaused; u8 sFramesPaused;
extern struct CameraFOVStatus sFOVState; extern struct CameraFOVStatus gFOVState;
extern struct TransitionInfo sModeTransition; extern struct TransitionInfo sModeTransition;
extern struct PlayerGeometry sMarioGeometry; extern struct PlayerGeometry sMarioGeometry;
extern s16 unusedFreeRoamWallYaw; extern s16 unusedFreeRoamWallYaw;
@ -182,7 +182,7 @@ extern struct Camera *gCamera;
* @see LakituState * @see LakituState
*/ */
struct LakituState gLakituState = { 0 }; struct LakituState gLakituState = { 0 };
struct CameraFOVStatus sFOVState = { 0 }; struct CameraFOVStatus gFOVState = { 0 };
struct TransitionInfo sModeTransition = { 0 }; struct TransitionInfo sModeTransition = { 0 };
struct PlayerGeometry sMarioGeometry = { 0 }; struct PlayerGeometry sMarioGeometry = { 0 };
struct Camera *gCamera; struct Camera *gCamera;
@ -3359,11 +3359,11 @@ void reset_camera(struct Camera *c) {
gLakituState.lastFrameAction = 0; gLakituState.lastFrameAction = 0;
set_fov_function(CAM_FOV_DEFAULT); set_fov_function(CAM_FOV_DEFAULT);
sFOVState.fov = 45.f; gFOVState.fov = 45.f;
sFOVState.fovOffset = 0.f; gFOVState.fovOffset = 0.f;
sFOVState.unusedIsSleeping = 0; gFOVState.unusedIsSleeping = 0;
sFOVState.shakeAmplitude = 0.f; gFOVState.shakeAmplitude = 0.f;
sFOVState.shakePhase = 0; gFOVState.shakePhase = 0;
sObjectCutscene = 0; sObjectCutscene = 0;
gRecentCutscene = 0; gRecentCutscene = 0;
@ -7617,7 +7617,7 @@ BAD_RETURN(s32) cutscene_ending_look_at_sky(struct Camera *c) {
* called, it will stay at about 37.26f * called, it will stay at about 37.26f
*/ */
BAD_RETURN(s32) cutscene_ending_zoom_fov(UNUSED struct Camera *c) { BAD_RETURN(s32) cutscene_ending_zoom_fov(UNUSED struct Camera *c) {
sFOVState.fov = 37.f; gFOVState.fov = 37.f;
} }
/** /**
@ -8492,7 +8492,7 @@ BAD_RETURN(s32) cutscene_red_coin_star_start(struct Camera *c) {
object_pos_to_vec3f(sCutsceneVars[1].point, gCutsceneFocus); object_pos_to_vec3f(sCutsceneVars[1].point, gCutsceneFocus);
store_info_star(c); store_info_star(c);
// Store the default fov for after the cutscene // Store the default fov for after the cutscene
sCutsceneVars[2].point[2] = sFOVState.fov; sCutsceneVars[2].point[2] = gFOVState.fov;
} }
/** /**
@ -8544,7 +8544,7 @@ BAD_RETURN(s32) cutscene_red_coin_star_warp(struct Camera *c) {
* Zoom out while looking at the star. * Zoom out while looking at the star.
*/ */
BAD_RETURN(s32) cutscene_red_coin_star_set_fov(UNUSED struct Camera *c) { BAD_RETURN(s32) cutscene_red_coin_star_set_fov(UNUSED struct Camera *c) {
sFOVState.fov = 60.f; gFOVState.fov = 60.f;
} }
BAD_RETURN(s32) cutscene_red_coin_star(struct Camera *c) { BAD_RETURN(s32) cutscene_red_coin_star(struct Camera *c) {
@ -8570,7 +8570,7 @@ BAD_RETURN(s32) cutscene_red_coin_star_end(struct Camera *c) {
gCutsceneTimer = CUTSCENE_STOP; gCutsceneTimer = CUTSCENE_STOP;
c->cutscene = 0; c->cutscene = 0;
// Restore the default fov // Restore the default fov
sFOVState.fov = sCutsceneVars[2].point[2]; gFOVState.fov = sCutsceneVars[2].point[2];
} }
/** /**
@ -8949,7 +8949,7 @@ BAD_RETURN(s32) cutscene_pyramid_top_explode_warp(struct Camera *c) {
f32 dist; f32 dist;
set_fov_function(CAM_FOV_DEFAULT); set_fov_function(CAM_FOV_DEFAULT);
sFOVState.fov = 45.f; gFOVState.fov = 45.f;
vec3f_copy(sCutsceneVars[4].point, c->pos); vec3f_copy(sCutsceneVars[4].point, c->pos);
vec3f_copy(sCutsceneVars[5].point, c->focus); vec3f_copy(sCutsceneVars[5].point, c->focus);
@ -8973,7 +8973,7 @@ BAD_RETURN(s32) cutscene_pyramid_top_explode_closeup(struct Camera *c) {
c->focus[1] += 4.f; c->focus[1] += 4.f;
c->pos[1] -= 5.f; c->pos[1] -= 5.f;
sFOVState.fov = 45.f; gFOVState.fov = 45.f;
set_handheld_shake(HAND_CAM_SHAKE_CUTSCENE); set_handheld_shake(HAND_CAM_SHAKE_CUTSCENE);
} }
@ -9739,7 +9739,7 @@ BAD_RETURN(s32) cutscene_intro_peach_clear_cutscene_status(UNUSED struct Camera
* Set fov to 8 degrees, then zoom out to 30. * Set fov to 8 degrees, then zoom out to 30.
*/ */
BAD_RETURN(s32) cutscene_intro_peach_zoom_fov(UNUSED struct Camera *c) { BAD_RETURN(s32) cutscene_intro_peach_zoom_fov(UNUSED struct Camera *c) {
sFOVState.fov = 8.f; gFOVState.fov = 8.f;
set_fov_function(CAM_FOV_ZOOM_30); set_fov_function(CAM_FOV_ZOOM_30);
} }
@ -11493,10 +11493,10 @@ s32 cutscene_spawn_obj(u32 obj, s16 frame) {
* calculated from coss(), so this parameter can be thought of as an angular velocity. * calculated from coss(), so this parameter can be thought of as an angular velocity.
*/ */
void set_fov_shake(s16 amplitude, s16 decay, s16 shakeSpeed) { void set_fov_shake(s16 amplitude, s16 decay, s16 shakeSpeed) {
if (amplitude > sFOVState.shakeAmplitude) { if (amplitude > gFOVState.shakeAmplitude) {
sFOVState.shakeAmplitude = amplitude; gFOVState.shakeAmplitude = amplitude;
sFOVState.decay = decay; gFOVState.decay = decay;
sFOVState.shakeSpeed = shakeSpeed; gFOVState.shakeSpeed = shakeSpeed;
} }
} }
@ -11507,10 +11507,10 @@ void set_fov_shake_from_point(s16 amplitude, s16 decay, s16 shakeSpeed, f32 maxD
amplitude = reduce_by_dist_from_camera(amplitude, maxDist, posX, posY, posZ); amplitude = reduce_by_dist_from_camera(amplitude, maxDist, posX, posY, posZ);
if (amplitude != 0) { if (amplitude != 0) {
if (amplitude > sFOVState.shakeAmplitude) { // literally use the function above you silly nintendo, smh if (amplitude > gFOVState.shakeAmplitude) { // literally use the function above you silly nintendo, smh
sFOVState.shakeAmplitude = amplitude; gFOVState.shakeAmplitude = amplitude;
sFOVState.decay = decay; gFOVState.decay = decay;
sFOVState.shakeSpeed = shakeSpeed; gFOVState.shakeSpeed = shakeSpeed;
} }
} }
} }
@ -11519,13 +11519,13 @@ void set_fov_shake_from_point(s16 amplitude, s16 decay, s16 shakeSpeed, f32 maxD
* Add a cyclic offset to the camera's field of view based on a cosine wave * Add a cyclic offset to the camera's field of view based on a cosine wave
*/ */
void shake_camera_fov(struct GraphNodePerspective *perspective) { void shake_camera_fov(struct GraphNodePerspective *perspective) {
if (sFOVState.shakeAmplitude != 0.f) { if (gFOVState.shakeAmplitude != 0.f) {
sFOVState.fovOffset = coss(sFOVState.shakePhase) * sFOVState.shakeAmplitude / 0x100; gFOVState.fovOffset = coss(gFOVState.shakePhase) * gFOVState.shakeAmplitude / 0x100;
sFOVState.shakePhase += sFOVState.shakeSpeed; gFOVState.shakePhase += gFOVState.shakeSpeed;
camera_approach_f32_symmetric_bool(&sFOVState.shakeAmplitude, 0.f, sFOVState.decay); camera_approach_f32_symmetric_bool(&gFOVState.shakeAmplitude, 0.f, gFOVState.decay);
perspective->fov += sFOVState.fovOffset; perspective->fov += gFOVState.fovOffset;
} else { } else {
sFOVState.shakePhase = 0; gFOVState.shakePhase = 0;
} }
} }
@ -11534,25 +11534,25 @@ static UNUSED void unused_deactivate_sleeping_camera(UNUSED struct MarioState *m
} }
void set_fov_30(UNUSED struct MarioState *m) { void set_fov_30(UNUSED struct MarioState *m) {
sFOVState.fov = 30.f; gFOVState.fov = 30.f;
} }
void approach_fov_20(UNUSED struct MarioState *m) { void approach_fov_20(UNUSED struct MarioState *m) {
camera_approach_f32_symmetric_bool(&sFOVState.fov, 20.f, 0.3f); camera_approach_f32_symmetric_bool(&gFOVState.fov, 20.f, 0.3f);
} }
void set_fov_45(UNUSED struct MarioState *m) { void set_fov_45(UNUSED struct MarioState *m) {
sFOVState.fov = 45.f; gFOVState.fov = 45.f;
} }
void set_fov_29(UNUSED struct MarioState *m) { void set_fov_29(UNUSED struct MarioState *m) {
sFOVState.fov = 29.f; gFOVState.fov = 29.f;
} }
void zoom_fov_30(UNUSED struct MarioState *m) { void zoom_fov_30(UNUSED struct MarioState *m) {
// Pretty sure approach_f32_asymptotic_bool would do a much nicer job here, but you do you, // Pretty sure approach_f32_asymptotic_bool would do a much nicer job here, but you do you,
// Nintendo. // Nintendo.
camera_approach_f32_symmetric_bool(&sFOVState.fov, 30.f, (30.f - sFOVState.fov) / 60.f); camera_approach_f32_symmetric_bool(&gFOVState.fov, 30.f, (30.f - gFOVState.fov) / 60.f);
} }
/** /**
@ -11563,32 +11563,32 @@ void fov_default(struct MarioState *m) {
sStatusFlags &= ~CAM_FLAG_SLEEPING; sStatusFlags &= ~CAM_FLAG_SLEEPING;
if ((m->action == ACT_SLEEPING) || (m->action == ACT_START_SLEEPING)) { if ((m->action == ACT_SLEEPING) || (m->action == ACT_START_SLEEPING)) {
camera_approach_f32_symmetric_bool(&sFOVState.fov, 30.f, (30.f - sFOVState.fov) / 30.f); camera_approach_f32_symmetric_bool(&gFOVState.fov, 30.f, (30.f - gFOVState.fov) / 30.f);
sStatusFlags |= CAM_FLAG_SLEEPING; sStatusFlags |= CAM_FLAG_SLEEPING;
} else { } else {
camera_approach_f32_symmetric_bool(&sFOVState.fov, 45.f, (45.f - sFOVState.fov) / 30.f); camera_approach_f32_symmetric_bool(&gFOVState.fov, 45.f, (45.f - gFOVState.fov) / 30.f);
sFOVState.unusedIsSleeping = 0; gFOVState.unusedIsSleeping = 0;
} }
if (m->area->camera->cutscene == CUTSCENE_0F_UNUSED) { if (m->area->camera->cutscene == CUTSCENE_0F_UNUSED) {
sFOVState.fov = 45.f; gFOVState.fov = 45.f;
} }
} }
//??! Literally the exact same as below //??! Literally the exact same as below
static UNUSED void unused_approach_fov_30(UNUSED struct MarioState *m) { static UNUSED void unused_approach_fov_30(UNUSED struct MarioState *m) {
camera_approach_f32_symmetric_bool(&sFOVState.fov, 30.f, 1.f); camera_approach_f32_symmetric_bool(&gFOVState.fov, 30.f, 1.f);
} }
void approach_fov_30(UNUSED struct MarioState *m) { void approach_fov_30(UNUSED struct MarioState *m) {
camera_approach_f32_symmetric_bool(&sFOVState.fov, 30.f, 1.f); camera_approach_f32_symmetric_bool(&gFOVState.fov, 30.f, 1.f);
} }
void approach_fov_60(UNUSED struct MarioState *m) { void approach_fov_60(UNUSED struct MarioState *m) {
camera_approach_f32_symmetric_bool(&sFOVState.fov, 60.f, 1.f); camera_approach_f32_symmetric_bool(&gFOVState.fov, 60.f, 1.f);
} }
void approach_fov_45(struct MarioState *m) { void approach_fov_45(struct MarioState *m) {
f32 targetFoV = sFOVState.fov; f32 targetFoV = gFOVState.fov;
if (m->area->camera->mode == CAMERA_MODE_FIXED && m->area->camera->cutscene == 0) { if (m->area->camera->mode == CAMERA_MODE_FIXED && m->area->camera->cutscene == 0) {
targetFoV = 45.f; targetFoV = 45.f;
@ -11596,11 +11596,11 @@ void approach_fov_45(struct MarioState *m) {
targetFoV = 45.f; targetFoV = 45.f;
} }
sFOVState.fov = approach_f32(sFOVState.fov, targetFoV, 2.f, 2.f); gFOVState.fov = approach_f32(gFOVState.fov, targetFoV, 2.f, 2.f);
} }
void approach_fov_80(UNUSED struct MarioState *m) { void approach_fov_80(UNUSED struct MarioState *m) {
camera_approach_f32_symmetric_bool(&sFOVState.fov, 80.f, 3.5f); camera_approach_f32_symmetric_bool(&gFOVState.fov, 80.f, 3.5f);
} }
/** /**
@ -11608,7 +11608,7 @@ void approach_fov_80(UNUSED struct MarioState *m) {
* If there's a cutscene, sets fov to 45. Otherwise sets fov to 60. * If there's a cutscene, sets fov to 45. Otherwise sets fov to 60.
*/ */
void set_fov_bbh(struct MarioState *m) { void set_fov_bbh(struct MarioState *m) {
f32 targetFoV = sFOVState.fov; f32 targetFoV = gFOVState.fov;
if (m->area->camera->mode == CAMERA_MODE_FIXED && m->area->camera->cutscene == 0) { if (m->area->camera->mode == CAMERA_MODE_FIXED && m->area->camera->cutscene == 0) {
targetFoV = 60.f; targetFoV = 60.f;
@ -11616,7 +11616,7 @@ void set_fov_bbh(struct MarioState *m) {
targetFoV = 45.f; targetFoV = 45.f;
} }
sFOVState.fov = approach_f32(sFOVState.fov, targetFoV, 2.f, 2.f); gFOVState.fov = approach_f32(gFOVState.fov, targetFoV, 2.f, 2.f);
} }
/** /**
@ -11625,7 +11625,7 @@ void set_fov_bbh(struct MarioState *m) {
Gfx *geo_camera_fov(s32 callContext, struct GraphNode *g, UNUSED void *context) { Gfx *geo_camera_fov(s32 callContext, struct GraphNode *g, UNUSED void *context) {
struct GraphNodePerspective *perspective = (struct GraphNodePerspective *) g; struct GraphNodePerspective *perspective = (struct GraphNodePerspective *) g;
struct MarioState *marioState = &gMarioStates[0]; struct MarioState *marioState = &gMarioStates[0];
u8 fovFunc = sFOVState.fovFunc; u8 fovFunc = gFOVState.fovFunc;
if (callContext == GEO_CONTEXT_RENDER) { if (callContext == GEO_CONTEXT_RENDER) {
switch (fovFunc) { switch (fovFunc) {
@ -11666,7 +11666,7 @@ Gfx *geo_camera_fov(s32 callContext, struct GraphNode *g, UNUSED void *context)
} }
} }
perspective->fov = sFOVState.fov; perspective->fov = gFOVState.fov;
shake_camera_fov(perspective); shake_camera_fov(perspective);
return NULL; return NULL;
} }
@ -11677,7 +11677,7 @@ Gfx *geo_camera_fov(s32 callContext, struct GraphNode *g, UNUSED void *context)
* @see geo_camera_fov * @see geo_camera_fov
*/ */
void set_fov_function(u8 func) { void set_fov_function(u8 func) {
sFOVState.fovFunc = func; gFOVState.fovFunc = func;
} }
/** /**

1
src/game/camera.h
View file

@ -678,6 +678,7 @@ extern s32 gObjCutsceneDone;
extern struct Camera *gCamera; extern struct Camera *gCamera;
#endif #endif
extern struct CameraFOVStatus gFOVState;
extern u8 gCameraUseCourseSpecificSettings; extern u8 gCameraUseCourseSpecificSettings;
extern struct Object *gCutsceneFocus; extern struct Object *gCutsceneFocus;
extern struct Object *gSecondCameraFocus; extern struct Object *gSecondCameraFocus;

25
src/pc/djui/djui_hud_utils.c
View file

@ -177,7 +177,7 @@ u32 djui_hud_get_screen_width(void) {
} }
return (sResolution == RESOLUTION_N64) return (sResolution == RESOLUTION_N64)
? ((use_forced_4by3() ? (4.0f / 3.0f) : GFX_DIMENSIONS_ASPECT_RATIO) * SCREEN_HEIGHT) ? (use_forced_4by3() ? (4.0f / 3.0f) : (GFX_DIMENSIONS_ASPECT_RATIO * SCREEN_HEIGHT))
: (windowWidth / djui_gfx_get_scale()); : (windowWidth / djui_gfx_get_scale());
} }
@ -524,21 +524,28 @@ static void hud_rotate_and_translate_vec3f(Vec3f vec, Mat4* mtx, Vec3f out) {
out[2] += (*mtx)[3][2]; out[2] += (*mtx)[3][2];
} }
void djui_hud_world_pos_to_screen_pos(Vec3f pos, Vec3f out) { bool djui_hud_world_pos_to_screen_pos(Vec3f pos, Vec3f out) {
hud_rotate_and_translate_vec3f(pos, &gCamera->mtx, out); hud_rotate_and_translate_vec3f(pos, &gCamera->mtx, out);
if (out[2] > -256.0f) { if (out[2] >= 0.0f) {
return; return false;
} }
out[0] *= 256.0 / -out[2]; out[0] *= 256.0f / -out[2];
out[1] *= 256.0 / out[2]; out[1] *= 256.0f / out[2];
// TODO: this is a hack to correct for the FOV. It only sort of works for the default fov // fov of 45.0 is the default fov
out[0] *= 1.135; f32 fovDefault = tanf(45.0f * ((f32)M_PI / 360.0f));
out[1] *= 1.135; f32 fovCurrent = tanf((gFOVState.fov + gFOVState.fovOffset) * ((f32)M_PI / 360.0f));
f32 fovDifference = (fovDefault / fovCurrent) * 1.13f;
out[0] *= fovDifference;
out[1] *= fovDifference;
out[0] += djui_hud_get_screen_width() / 2.0f; out[0] += djui_hud_get_screen_width() / 2.0f;
out[1] += djui_hud_get_screen_height() / 2.0f; out[1] += djui_hud_get_screen_height() / 2.0f;
return true;
} }
void djui_hud_set_render_behind_hud(bool enable) { void djui_hud_set_render_behind_hud(bool enable) {

2
src/pc/djui/djui_hud_utils.h
View file

@ -63,7 +63,7 @@ void djui_hud_render_texture_tile_interpolated(struct TextureInfo* texInfo, f32
void djui_hud_render_rect(f32 x, f32 y, f32 width, f32 height); void djui_hud_render_rect(f32 x, f32 y, f32 width, f32 height);
void djui_hud_render_rect_interpolated(f32 prevX, f32 prevY, f32 prevWidth, f32 prevHeight, f32 x, f32 y, f32 width, f32 height); void djui_hud_render_rect_interpolated(f32 prevX, f32 prevY, f32 prevWidth, f32 prevHeight, f32 x, f32 y, f32 width, f32 height);
void djui_hud_world_pos_to_screen_pos(Vec3f pos, Vec3f out); bool djui_hud_world_pos_to_screen_pos(Vec3f pos, Vec3f out);
void djui_hud_set_render_behind_hud(bool enable); void djui_hud_set_render_behind_hud(bool enable);

2
src/pc/lua/smlua_functions_autogen.c
View file

@ -11859,7 +11859,7 @@ int smlua_func_djui_hud_world_pos_to_screen_pos(lua_State* L) {
out[2] = smlua_get_number_field(2, "z"); out[2] = smlua_get_number_field(2, "z");
if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 2, "djui_hud_world_pos_to_screen_pos"); return 0; } if (!gSmLuaConvertSuccess) { LOG_LUA("Failed to convert parameter %u for function '%s'", 2, "djui_hud_world_pos_to_screen_pos"); return 0; }
djui_hud_world_pos_to_screen_pos(pos, out); lua_pushboolean(L, djui_hud_world_pos_to_screen_pos(pos, out));
smlua_push_number_field(1, "x", pos[0]); smlua_push_number_field(1, "x", pos[0]);
smlua_push_number_field(1, "y", pos[1]); smlua_push_number_field(1, "y", pos[1]);