thirdpartymirrors/sm64coopdx
1
0
Fork 0
mirror of https://github.com/coop-deluxe/sm64coopdx.git synced 2025-12-15 20:42:27 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Fix vec3f bugs (#837)

Browse source
This commit is contained in:
PeachyPeach 2025-06-05 11:44:09 +02:00 • committed by GitHub
parent e1aab9c479
commit c79d59d8ec
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
52 changed files with 599 additions and 763 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

15
autogen/convert_functions.py
View file

@ -902,8 +902,9 @@ def build_param(fid, param, i):
def build_param_after(param, i):
ptype = param['type']
pid = param['identifier']
is_output = param.get('out', False)
if ptype in VEC_TYPES:
if ptype in VEC_TYPES and is_output:
return (vec_type_after % (ptype.lower())).replace('$[IDENTIFIER]', str(pid)).replace('$[INDEX]', str(i))
else:
return ''
@ -997,9 +998,12 @@ def build_function(function, do_extern):
i += 1
s += '\n'
# To allow chaining vector functions calls, return the table corresponding to `dest` parameter
# To allow chaining vector functions calls, return the table corresponding to the `OUT` parameter
if function['type'] in VECP_TYPES:
s += ' lua_settop(L, 1);\n'
for i, param in enumerate(function['params']):
if param.get('out', False):
s += ' lua_settop(L, %d);\n' % (i + 1)
break
s += ' return 1;\n}\n'
@ -1099,6 +1103,11 @@ def process_function(fname, line, description):
for param_str in params_str.split(','):
param = {}
param_str = param_str.strip()
if param_str.startswith('OUT '):
param['out'] = True
param_str = param_str[len('OUT'):].strip()
if param_str.endswith('*') or ' ' not in param_str:
param['type'] = normalize_type(param_str)
param['identifier'] = 'arg%d' % param_index

2
autogen/gen_math.py
View file

@ -5,7 +5,7 @@ VEC3X_TO_VEC3Y = """
/* |description|
Converts a 3D {{desc}} vector `a` into a 3D {{desc_2}} vector and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3{{suffix_2}}p vec3{{suffix}}_to_vec3{{suffix_2}}(Vec3{{suffix_2}} dest, Vec3{{suffix}} a) {
INLINE OPTIMIZE_O3 Vec3{{suffix_2}}p vec3{{suffix}}_to_vec3{{suffix_2}}(OUT Vec3{{suffix_2}} dest, Vec3{{suffix}} a) {
dest[0] = a[0]{{rounding_0}};
dest[1] = a[1]{{rounding_1}};
dest[2] = a[2]{{rounding_2}};

2
autogen/lua_constants/built-in.lua
View file

@ -61,7 +61,7 @@ end
-----------
--- @type Vec3f
gGlobalSoundSource = { x = 0, y = 0, z = 0 }
gGlobalSoundSource = create_read_only_table({ x = 0, y = 0, z = 0 })
--- @param bank number
--- @param soundID number

2
autogen/lua_definitions/constants.lua
View file

@ -63,7 +63,7 @@ end
-----------
--- @type Vec3f
gGlobalSoundSource = { x = 0, y = 0, z = 0 }
gGlobalSoundSource = create_read_only_table({ x = 0, y = 0, z = 0 })
--- @param bank number
--- @param soundID number

39
autogen/lua_definitions/functions.lua
View file

@ -109,13 +109,6 @@ function arc_to_goal_pos(goal, pos, yVel, gravity)
-- ...
end
--- @param dest Vec3f
--- @param src Vec3f
--- Duplicate of vec3f_copy except without bad return
function vec3f_copy_2(dest, src)
-- ...
end
--- @param forwardVel number
--- @param a1 number
--- @param deltaPitch integer
@ -3144,6 +3137,34 @@ function vec3f_to_object_pos(o, src)
-- ...
end
--- @param dst Vec3s
--- @param o Object
--- Converts an object's face angle to a `Vec3s` format
function object_face_angle_to_vec3s(dst, o)
-- ...
end
--- @param o Object
--- @param src Vec3s
--- Converts a `Vec3s` angle to an object's face angle internal format
function vec3s_to_object_face_angle(o, src)
-- ...
end
--- @param dst Vec3s
--- @param o Object
--- Converts an object's move angle to a `Vec3s` format
function object_move_angle_to_vec3s(dst, o)
-- ...
end
--- @param o Object
--- @param src Vec3s
--- Converts a `Vec3s` angle to an object's move angle internal format
function vec3s_to_object_move_angle(o, src)
-- ...
end
--- @param angle integer
--- @return integer
--- Selects an alternate camera mode based on the given angle. Used to toggle between predefined camera modes dynamically
@ -6497,7 +6518,7 @@ end
--- @param mtx Mat4
--- @param b Vec3s
--- @return Pointer_integer
--- @return Vec3s
--- Multiplies the 3D signed-integer vector `b` with the 4x4 floating-point matrix `mtx`, which applies the transformation to the point
function mtxf_mul_vec3s(mtx, b)
-- ...
@ -6583,7 +6604,7 @@ end
--- @param dest Mat4
--- @param b Vec3f
--- Applies a translation to the 4x4 floating-point matrix `dest` by adding the coordinates in the 3D floating-point vector `b`. This shifts any transformed point by `b`
--- Sets the 4x4 floating-point matrix `dest` to the translation matrix decribed by the 3D floating-point vector `b`. This matrix is used to shift any transformed point by `b`
function mtxf_translate(dest, b)
-- ...
end

24
docs/lua/functions-2.md
View file

@ -205,30 +205,6 @@ Calculates the time it takes for the current object to follow an arc from `pos`
<br />
## [vec3f_copy_2](#vec3f_copy_2)
### Description
Duplicate of vec3f_copy except without bad return
### Lua Example
`vec3f_copy_2(dest, src)`
### Parameters
| Field | Type |
| ----- | ---- |
| dest | [Vec3f](structs.md#Vec3f) |
| src | [Vec3f](structs.md#Vec3f) |
### Returns
- None
### C Prototype
`void vec3f_copy_2(Vec3f dest, Vec3f src);`
[:arrow_up_small:](#)
<br />
## [tox_box_move](#tox_box_move)
### Description

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

@ -537,7 +537,7 @@ Converts an object's position to a `Vec3f` format. Useful for aligning object be
- None
### C Prototype
`void object_pos_to_vec3f(Vec3f dst, struct Object *o);`
`void object_pos_to_vec3f(OUT Vec3f dst, struct Object *o);`
[:arrow_up_small:](#)
@ -567,6 +567,102 @@ Converts a `Vec3f` position to an object's internal format. Useful for syncing 3
<br />
## [object_face_angle_to_vec3s](#object_face_angle_to_vec3s)
### Description
Converts an object's face angle to a `Vec3s` format
### Lua Example
`object_face_angle_to_vec3s(dst, o)`
### Parameters
| Field | Type |
| ----- | ---- |
| dst | [Vec3s](structs.md#Vec3s) |
| o | [Object](structs.md#Object) |
### Returns
- None
### C Prototype
`void object_face_angle_to_vec3s(OUT Vec3s dst, struct Object *o);`
[:arrow_up_small:](#)
<br />
## [vec3s_to_object_face_angle](#vec3s_to_object_face_angle)
### Description
Converts a `Vec3s` angle to an object's face angle internal format
### Lua Example
`vec3s_to_object_face_angle(o, src)`
### Parameters
| Field | Type |
| ----- | ---- |
| o | [Object](structs.md#Object) |
| src | [Vec3s](structs.md#Vec3s) |
### Returns
- None
### C Prototype
`void vec3s_to_object_face_angle(struct Object *o, Vec3s src);`
[:arrow_up_small:](#)
<br />
## [object_move_angle_to_vec3s](#object_move_angle_to_vec3s)
### Description
Converts an object's move angle to a `Vec3s` format
### Lua Example
`object_move_angle_to_vec3s(dst, o)`
### Parameters
| Field | Type |
| ----- | ---- |
| dst | [Vec3s](structs.md#Vec3s) |
| o | [Object](structs.md#Object) |
### Returns
- None
### C Prototype
`void object_move_angle_to_vec3s(OUT Vec3s dst, struct Object *o);`
[:arrow_up_small:](#)
<br />
## [vec3s_to_object_move_angle](#vec3s_to_object_move_angle)
### Description
Converts a `Vec3s` angle to an object's move angle internal format
### Lua Example
`vec3s_to_object_move_angle(o, src)`
### Parameters
| Field | Type |
| ----- | ---- |
| o | [Object](structs.md#Object) |
| src | [Vec3s](structs.md#Vec3s) |
### Returns
- None
### C Prototype
`void vec3s_to_object_move_angle(struct Object *o, Vec3s src);`
[:arrow_up_small:](#)
<br />
## [cam_select_alt_mode](#cam_select_alt_mode)
### Description
@ -654,7 +750,7 @@ Activates a handheld camera shake effect. Calculates positional and focus adjust
- None
### C Prototype
`void shake_camera_handheld(Vec3f pos, Vec3f focus);`
`void shake_camera_handheld(Vec3f pos, OUT Vec3f focus);`
[:arrow_up_small:](#)
@ -704,7 +800,7 @@ Checks for collisions between the camera and level geometry. Adjusts the camera'
- `integer`
### C Prototype
`s32 collide_with_walls(Vec3f pos, f32 offsetY, f32 radius);`
`s32 collide_with_walls(OUT Vec3f pos, f32 offsetY, f32 radius);`
[:arrow_up_small:](#)
@ -730,7 +826,7 @@ Clamps the camera's pitch angle between a maximum and minimum value. Prevents ov
- `integer`
### C Prototype
`s32 clamp_pitch(Vec3f from, Vec3f to, s16 maxPitch, s16 minPitch);`
`s32 clamp_pitch(Vec3f from, OUT Vec3f to, s16 maxPitch, s16 minPitch);`
[:arrow_up_small:](#)
@ -907,7 +1003,7 @@ Smoothly transitions a 3D vector (`current`) towards a target vector (`target`)
- None
### C Prototype
`void approach_vec3f_asymptotic(Vec3f current, Vec3f target, f32 xMul, f32 yMul, f32 zMul);`
`void approach_vec3f_asymptotic(OUT Vec3f current, Vec3f target, f32 xMul, f32 yMul, f32 zMul);`
[:arrow_up_small:](#)
@ -934,7 +1030,7 @@ Smoothly transitions a 3D vector (`current`) toward a target vector (`goal`) usi
- None
### C Prototype
`void set_or_approach_vec3f_asymptotic(Vec3f dst, Vec3f goal, f32 xMul, f32 yMul, f32 zMul);`
`void set_or_approach_vec3f_asymptotic(OUT Vec3f dst, Vec3f goal, f32 xMul, f32 yMul, f32 zMul);`
[:arrow_up_small:](#)
@ -1060,7 +1156,7 @@ Generates a random 3D vector with short integer components. Useful for randomize
- None
### C Prototype
`void random_vec3s(Vec3s dst, s16 xRange, s16 yRange, s16 zRange);`
`void random_vec3s(OUT Vec3s dst, s16 xRange, s16 yRange, s16 zRange);`
[:arrow_up_small:](#)
@ -1088,7 +1184,7 @@ Clamps a position within specified X and Z bounds and calculates the yaw angle f
- `integer`
### C Prototype
`s32 clamp_positions_and_find_yaw(Vec3f pos, Vec3f origin, f32 xMax, f32 xMin, f32 zMax, f32 zMin);`
`s32 clamp_positions_and_find_yaw(OUT Vec3f pos, Vec3f origin, f32 xMax, f32 xMin, f32 zMax, f32 zMin);`
[:arrow_up_small:](#)
@ -1141,7 +1237,7 @@ Scales a point along a line between two 3D points (`from` and `to`). The scaling
- None
### C Prototype
`void scale_along_line(Vec3f dest, Vec3f from, Vec3f to, f32 scale);`
`void scale_along_line(OUT Vec3f dest, Vec3f from, Vec3f to, f32 scale);`
[:arrow_up_small:](#)
@ -1288,7 +1384,7 @@ Rotates a vector around the XZ-plane by a specified yaw angle. The result is sto
- None
### C Prototype
`void rotate_in_xz(Vec3f dst, Vec3f src, s16 yaw);`
`void rotate_in_xz(OUT Vec3f dst, Vec3f src, s16 yaw);`
[:arrow_up_small:](#)
@ -1313,7 +1409,7 @@ Rotates a vector around the YZ-plane by a specified pitch angle. The result is s
- None
### C Prototype
`void rotate_in_yz(Vec3f dst, Vec3f src, s16 pitch);`
`void rotate_in_yz(OUT Vec3f dst, Vec3f src, s16 pitch);`
[:arrow_up_small:](#)
@ -1441,7 +1537,7 @@ Activates a pitch-based shake effect. Adds vertical vibrational movement to the
- None
### C Prototype
`void shake_camera_pitch(Vec3f pos, Vec3f focus);`
`void shake_camera_pitch(Vec3f pos, OUT Vec3f focus);`
[:arrow_up_small:](#)
@ -1465,7 +1561,7 @@ Activates a yaw-based shake effect. Adds horizontal vibrational movement to the
- None
### C Prototype
`void shake_camera_yaw(Vec3f pos, Vec3f focus);`
`void shake_camera_yaw(Vec3f pos, OUT Vec3f focus);`
[:arrow_up_small:](#)
@ -1894,7 +1990,7 @@ Offsets a vector by rotating it in 3D space relative to a reference position. Th
- None
### C Prototype
`void offset_rotated(Vec3f dst, Vec3f from, Vec3f to, Vec3s rotation);`
`void offset_rotated(OUT Vec3f dst, Vec3f from, Vec3f to, Vec3s rotation);`
[:arrow_up_small:](#)
@ -1923,7 +2019,7 @@ Transitions the camera to the next Lakitu state, updating position and focus. Th
- `integer`
### C Prototype
`s16 next_lakitu_state(Vec3f newPos, Vec3f newFoc, Vec3f curPos, Vec3f curFoc, Vec3f oldPos, Vec3f oldFoc, s16 yaw);`
`s16 next_lakitu_state(OUT Vec3f newPos, OUT Vec3f newFoc, Vec3f curPos, Vec3f curFoc, Vec3f oldPos, Vec3f oldFoc, s16 yaw);`
[:arrow_up_small:](#)
@ -1993,7 +2089,7 @@ Resolves collisions between the camera and level geometry. Adjusts the camera's
- None
### C Prototype
`void resolve_geometry_collisions(Vec3f pos, UNUSED Vec3f lastGood);`
`void resolve_geometry_collisions(OUT Vec3f pos, UNUSED Vec3f lastGood);`
[:arrow_up_small:](#)
@ -3366,7 +3462,7 @@ Converts a world position to screen position
- `boolean`
### C Prototype
`bool djui_hud_world_pos_to_screen_pos(Vec3f pos, Vec3f out);`
`bool djui_hud_world_pos_to_screen_pos(Vec3f pos, OUT Vec3f out);`
[:arrow_up_small:](#)
@ -6432,7 +6528,7 @@ Calculates the lighting with `lightIntensityScalar` at a position and outputs th
- None
### C Prototype
`void le_calculate_lighting_color(Vec3f pos, Color out, f32 lightIntensityScalar);`
`void le_calculate_lighting_color(Vec3f pos, OUT Color out, f32 lightIntensityScalar);`
[:arrow_up_small:](#)
@ -6456,7 +6552,7 @@ Calculates the lighting direction from a position and outputs the result in `out
- None
### C Prototype
`void le_calculate_lighting_dir(Vec3f pos, Vec3f out);`
`void le_calculate_lighting_dir(Vec3f pos, OUT Vec3f out);`
[:arrow_up_small:](#)

170
docs/lua/functions-4.md
View file

@ -222,7 +222,7 @@ Retrieves the current animation flags and calculates the translation for Mario's
- `integer`
### C Prototype
`s16 find_mario_anim_flags_and_translation(struct Object *o, s32 yaw, Vec3s translation);`
`s16 find_mario_anim_flags_and_translation(struct Object *o, s32 yaw, OUT Vec3s translation);`
[:arrow_up_small:](#)
@ -697,7 +697,7 @@ Checks for and resolves wall collisions at a given position `pos`, returning the
[Surface](structs.md#Surface)
### C Prototype
`struct Surface *resolve_and_return_wall_collisions(Vec3f pos, f32 offset, f32 radius);`
`struct Surface *resolve_and_return_wall_collisions(OUT Vec3f pos, f32 offset, f32 radius);`
[:arrow_up_small:](#)
@ -723,7 +723,7 @@ Similar to `resolve_and_return_wall_collisions` but also returns detailed collis
- None
### C Prototype
`void resolve_and_return_wall_collisions_data(Vec3f pos, f32 offset, f32 radius, struct WallCollisionData* collisionData);`
`void resolve_and_return_wall_collisions_data(OUT Vec3f pos, f32 offset, f32 radius, struct WallCollisionData* collisionData);`
[:arrow_up_small:](#)
@ -1872,7 +1872,7 @@ Performs a single step of movement while Mario is hanging from a ceiling. It han
- `integer`
### C Prototype
`s32 perform_hanging_step(struct MarioState *m, Vec3f nextPos);`
`s32 perform_hanging_step(struct MarioState *m, OUT Vec3f nextPos);`
[:arrow_up_small:](#)
@ -3620,7 +3620,7 @@ Performs a full water movement step where ceilings, floors, and walls are handle
- `integer`
### C Prototype
`u32 perform_water_full_step(struct MarioState *m, Vec3f nextPos);`
`u32 perform_water_full_step(struct MarioState *m, OUT Vec3f nextPos);`
[:arrow_up_small:](#)
@ -3644,7 +3644,7 @@ Calculates a water current and outputs it in `step`
- None
### C Prototype
`void apply_water_current(struct MarioState *m, Vec3f step);`
`void apply_water_current(struct MarioState *m, OUT Vec3f step);`
[:arrow_up_small:](#)
@ -4311,7 +4311,7 @@ Computes spline interpolation weights for a given parameter `t` and stores these
- None
### C Prototype
`void spline_get_weights(struct MarioState* m, Vec4f result, f32 t, UNUSED s32 c);`
`void spline_get_weights(struct MarioState* m, OUT Vec4f result, f32 t, UNUSED s32 c);`
[:arrow_up_small:](#)
@ -4359,7 +4359,7 @@ Advances the spline-based animation associated with `m` and stores the current i
- `integer`
### C Prototype
`s32 anim_spline_poll(struct MarioState* m, Vec3f result);`
`s32 anim_spline_poll(struct MarioState* m, OUT Vec3f result);`
[:arrow_up_small:](#)
@ -4383,7 +4383,7 @@ Rotates the 3D floating-point vector `v` by the angles specified in the 3D signe
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_rotate_zxy(Vec3f v, Vec3s rotate);`
`Vec3fp vec3f_rotate_zxy(OUT Vec3f v, Vec3s rotate);`
[:arrow_up_small:](#)
@ -4409,7 +4409,7 @@ Rotates the 3D floating-point vector `v` around the vector `n`, given a rotation
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_rotate_around_n(Vec3f dest, Vec3f v, Vec3f n, s16 r);`
`Vec3fp vec3f_rotate_around_n(OUT Vec3f dest, Vec3f v, Vec3f n, s16 r);`
[:arrow_up_small:](#)
@ -4434,7 +4434,7 @@ Projects the 3D floating-point vector `v` onto another 3D floating-point vector
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_project(Vec3f dest, Vec3f v, Vec3f onto);`
`Vec3fp vec3f_project(OUT Vec3f dest, Vec3f v, Vec3f onto);`
[:arrow_up_small:](#)
@ -4461,7 +4461,7 @@ Scales the 3D floating-point vector `v` by the vector `scale`, then rotates it b
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_transform(Vec3f dest, Vec3f v, Vec3f translation, Vec3s rotation, Vec3f scale);`
`Vec3fp vec3f_transform(OUT Vec3f dest, Vec3f v, Vec3f translation, Vec3s rotation, Vec3f scale);`
[:arrow_up_small:](#)
@ -4515,7 +4515,7 @@ Positions the point `to` at a given `dist`, `pitch`, and `yaw` relative to the p
- None
### C Prototype
`void vec3f_set_dist_and_angle(Vec3f from, Vec3f to, f32 dist, s16 pitch, s16 yaw);`
`void vec3f_set_dist_and_angle(Vec3f from, OUT Vec3f to, f32 dist, s16 pitch, s16 yaw);`
[:arrow_up_small:](#)
@ -4541,7 +4541,7 @@ Determines a vector that is perpendicular (normal) to the plane defined by three
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp find_vector_perpendicular_to_plane(Vec3f dest, Vec3f a, Vec3f b, Vec3f c);`
`Vec3fp find_vector_perpendicular_to_plane(OUT Vec3f dest, Vec3f a, Vec3f b, Vec3f c);`
[:arrow_up_small:](#)
@ -4567,7 +4567,7 @@ Adjusts the 4x4 floating-point matrix `mtx` so that it represents a viewing tran
- None
### C Prototype
`void mtxf_lookat(Mat4 mtx, Vec3f from, Vec3f to, s16 roll);`
`void mtxf_lookat(OUT Mat4 mtx, Vec3f from, Vec3f to, s16 roll);`
[:arrow_up_small:](#)
@ -4592,7 +4592,7 @@ Rotates `dest` according to the angles in `rotate` using ZXY order, and then tra
- None
### C Prototype
`void mtxf_rotate_zxy_and_translate(Mat4 dest, Vec3f translate, Vec3s rotate);`
`void mtxf_rotate_zxy_and_translate(OUT Mat4 dest, Vec3f translate, Vec3s rotate);`
[:arrow_up_small:](#)
@ -4617,7 +4617,7 @@ Rotates `dest` using angles in XYZ order, and then translates it by the 3D float
- None
### C Prototype
`void mtxf_rotate_xyz_and_translate(Mat4 dest, Vec3f b, Vec3s c);`
`void mtxf_rotate_xyz_and_translate(OUT Mat4 dest, Vec3f b, Vec3s c);`
[:arrow_up_small:](#)
@ -4643,7 +4643,7 @@ Transforms a 4x4 floating-point matrix `mtx` into a "billboard" oriented toward
- None
### C Prototype
`void mtxf_billboard(Mat4 dest, Mat4 mtx, Vec3f position, s16 angle);`
`void mtxf_billboard(OUT Mat4 dest, Mat4 mtx, Vec3f position, s16 angle);`
[:arrow_up_small:](#)
@ -4669,7 +4669,7 @@ Creates a "cylindrical billboard" transformation from the 4x4 matrix `mtx` place
- None
### C Prototype
`void mtxf_cylboard(Mat4 dest, Mat4 mtx, Vec3f position, s16 angle);`
`void mtxf_cylboard(OUT Mat4 dest, Mat4 mtx, Vec3f position, s16 angle);`
[:arrow_up_small:](#)
@ -4695,7 +4695,7 @@ Aligns `dest` so that it fits the orientation of a terrain surface defined by it
- None
### C Prototype
`void mtxf_align_terrain_normal(Mat4 dest, Vec3f upDir, Vec3f pos, s16 yaw);`
`void mtxf_align_terrain_normal(OUT Mat4 dest, Vec3f upDir, Vec3f pos, s16 yaw);`
[:arrow_up_small:](#)
@ -4721,7 +4721,7 @@ Aligns `mtx` to fit onto a terrain triangle at `pos`, applying a given `yaw` and
- None
### C Prototype
`void mtxf_align_terrain_triangle(Mat4 mtx, Vec3f pos, s16 yaw, f32 radius);`
`void mtxf_align_terrain_triangle(OUT Mat4 mtx, Vec3f pos, s16 yaw, f32 radius);`
[:arrow_up_small:](#)
@ -4746,7 +4746,7 @@ Multiplies two 4x4 floating-point matrices `a` and `b` (in that order), storing
- None
### C Prototype
`void mtxf_mul(Mat4 dest, Mat4 a, Mat4 b);`
`void mtxf_mul(OUT Mat4 dest, Mat4 a, Mat4 b);`
[:arrow_up_small:](#)
@ -4758,7 +4758,7 @@ Multiplies two 4x4 floating-point matrices `a` and `b` (in that order), storing
Multiplies the 3D signed-integer vector `b` with the 4x4 floating-point matrix `mtx`, which applies the transformation to the point
### Lua Example
`local PointerValue = mtxf_mul_vec3s(mtx, b)`
`local Vec3sValue = mtxf_mul_vec3s(mtx, b)`
### Parameters
| Field | Type |
@ -4767,10 +4767,10 @@ Multiplies the 3D signed-integer vector `b` with the 4x4 floating-point matrix `
| b | [Vec3s](structs.md#Vec3s) |
### Returns
- `Pointer` <`integer`>
[Vec3s](structs.md#Vec3s)
### C Prototype
`s16 *mtxf_mul_vec3s(Mat4 mtx, Vec3s b);`
`Vec3sp mtxf_mul_vec3s(Mat4 mtx, OUT Vec3s b);`
[:arrow_up_small:](#)
@ -4794,7 +4794,7 @@ Rotates the matrix `mtx` in the XY plane by the given `angle`. Rotating in the X
- None
### C Prototype
`void mtxf_rotate_xy(Mat4 mtx, s16 angle);`
`void mtxf_rotate_xy(OUT Mat4 mtx, s16 angle);`
[:arrow_up_small:](#)
@ -4818,7 +4818,7 @@ Inverts the 4x4 floating-point matrix `src` and stores the inverse in `dest`. Ap
- None
### C Prototype
`void mtxf_inverse(Mat4 dest, Mat4 src);`
`void mtxf_inverse(OUT Mat4 dest, Mat4 src);`
[:arrow_up_small:](#)
@ -4843,7 +4843,7 @@ Extracts the position (translation component) from the transformation matrix `ob
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp get_pos_from_transform_mtx(Vec3f dest, Mat4 objMtx, Mat4 camMtx);`
`Vec3fp get_pos_from_transform_mtx(OUT Vec3f dest, Mat4 objMtx, Mat4 camMtx);`
[:arrow_up_small:](#)
@ -4994,7 +4994,7 @@ Sets the 4x4 floating-point matrix `mtx` to all zeros. Unless you really need th
- None
### C Prototype
`void mtxf_zero(Mat4 mtx);`
`void mtxf_zero(OUT Mat4 mtx);`
[:arrow_up_small:](#)
@ -5018,7 +5018,7 @@ Copies the 4x4 floating-point matrix `src` into `dest`. After this operation, `d
- None
### C Prototype
`void mtxf_copy(Mat4 dest, Mat4 src);`
`void mtxf_copy(OUT Mat4 dest, Mat4 src);`
[:arrow_up_small:](#)
@ -5041,7 +5041,7 @@ Sets the 4x4 floating-point matrix `mtx` to the identity matrix. The identity ma
- None
### C Prototype
`void mtxf_identity(Mat4 mtx);`
`void mtxf_identity(OUT Mat4 mtx);`
[:arrow_up_small:](#)
@ -5050,7 +5050,7 @@ Sets the 4x4 floating-point matrix `mtx` to the identity matrix. The identity ma
## [mtxf_translate](#mtxf_translate)
### Description
Applies a translation to the 4x4 floating-point matrix `dest` by adding the coordinates in the 3D floating-point vector `b`. This shifts any transformed point by `b`
Sets the 4x4 floating-point matrix `dest` to the translation matrix decribed by the 3D floating-point vector `b`. This matrix is used to shift any transformed point by `b`
### Lua Example
`mtxf_translate(dest, b)`
@ -5065,7 +5065,7 @@ Applies a translation to the 4x4 floating-point matrix `dest` by adding the coor
- None
### C Prototype
`void mtxf_translate(Mat4 dest, Vec3f b);`
`void mtxf_translate(OUT Mat4 dest, Vec3f b);`
[:arrow_up_small:](#)
@ -5090,7 +5090,7 @@ Scales the 4x4 floating-point matrix `mtx` by the scaling factors found in the 3
- None
### C Prototype
`void mtxf_scale_vec3f(Mat4 dest, Mat4 mtx, Vec3f s);`
`void mtxf_scale_vec3f(OUT Mat4 dest, Mat4 mtx, Vec3f s);`
[:arrow_up_small:](#)
@ -5119,7 +5119,7 @@ Sets the components of the 3D floating-point vector `v` to 0
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_zero(Vec3f v);`
`Vec3fp vec3f_zero(OUT Vec3f v);`
[:arrow_up_small:](#)
@ -5143,7 +5143,7 @@ Copies the contents of a 3D floating-point vector (`src`) into another 3D floati
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_copy(Vec3f dest, Vec3f src);`
`Vec3fp vec3f_copy(OUT Vec3f dest, Vec3f src);`
[:arrow_up_small:](#)
@ -5169,7 +5169,7 @@ Sets the values of the 3D floating-point vector `dest` to the given x, y, and z
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_set(Vec3f dest, f32 x, f32 y, f32 z);`
`Vec3fp vec3f_set(OUT Vec3f dest, f32 x, f32 y, f32 z);`
[:arrow_up_small:](#)
@ -5193,7 +5193,7 @@ Adds the components of the 3D floating-point vector `a` to `dest`
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_add(Vec3f dest, Vec3f a);`
`Vec3fp vec3f_add(OUT Vec3f dest, Vec3f a);`
[:arrow_up_small:](#)
@ -5218,7 +5218,7 @@ Adds the components of two 3D floating-point vectors `a` and `b` and stores the
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_sum(Vec3f dest, Vec3f a, Vec3f b);`
`Vec3fp vec3f_sum(OUT Vec3f dest, Vec3f a, Vec3f b);`
[:arrow_up_small:](#)
@ -5242,7 +5242,7 @@ Subtracts the components of the 3D floating-point vector `a` from `dest`
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_sub(Vec3f dest, Vec3f a);`
`Vec3fp vec3f_sub(OUT Vec3f dest, Vec3f a);`
[:arrow_up_small:](#)
@ -5267,7 +5267,7 @@ Subtracts the components of the 3D floating-point vector `b` from the components
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_dif(Vec3f dest, Vec3f a, Vec3f b);`
`Vec3fp vec3f_dif(OUT Vec3f dest, Vec3f a, Vec3f b);`
[:arrow_up_small:](#)
@ -5291,7 +5291,7 @@ Multiplies each component of the 3D floating-point vector `dest` by the scalar v
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_mul(Vec3f dest, f32 a);`
`Vec3fp vec3f_mul(OUT Vec3f dest, f32 a);`
[:arrow_up_small:](#)
@ -5315,7 +5315,7 @@ Multiplies the components of the 3D floating-point vector `dest` with the compon
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_mult(Vec3f dest, Vec3f a);`
`Vec3fp vec3f_mult(OUT Vec3f dest, Vec3f a);`
[:arrow_up_small:](#)
@ -5340,7 +5340,7 @@ Multiplies the components of two 3D floating-point vectors `a` and `b` and store
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_prod(Vec3f dest, Vec3f a, Vec3f b);`
`Vec3fp vec3f_prod(OUT Vec3f dest, Vec3f a, Vec3f b);`
[:arrow_up_small:](#)
@ -5364,7 +5364,7 @@ Divides each component of the 3D floating-point vector `dest` by the scalar valu
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_div(Vec3f dest, f32 a);`
`Vec3fp vec3f_div(OUT Vec3f dest, f32 a);`
[:arrow_up_small:](#)
@ -5410,7 +5410,7 @@ Normalizes the 3D floating-point vector `v` so that its length (magnitude) becom
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_normalize(Vec3f v);`
`Vec3fp vec3f_normalize(OUT Vec3f v);`
[:arrow_up_small:](#)
@ -5434,7 +5434,7 @@ Sets the length (magnitude) of 3D floating-point vector `v`, while retaining its
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_set_magnitude(Vec3f v, f32 mag);`
`Vec3fp vec3f_set_magnitude(OUT Vec3f v, f32 mag);`
[:arrow_up_small:](#)
@ -5483,7 +5483,7 @@ Computes the cross product of two 3D floating-point vectors `a` and `b` and stor
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_cross(Vec3f dest, Vec3f a, Vec3f b);`
`Vec3fp vec3f_cross(OUT Vec3f dest, Vec3f a, Vec3f b);`
[:arrow_up_small:](#)
@ -5510,7 +5510,7 @@ Takes two 3D floating-point vectors `vecA` and `vecB`, multiplies them by `sclA`
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3f_combine(Vec3f dest, Vec3f vecA, Vec3f vecB, f32 sclA, f32 sclB);`
`Vec3fp vec3f_combine(OUT Vec3f dest, Vec3f vecA, Vec3f vecB, f32 sclA, f32 sclB);`
[:arrow_up_small:](#)
@ -5605,7 +5605,7 @@ Converts a 3D floating-point vector `a` into a 3D integer vector and stores the
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3f_to_vec3i(Vec3i dest, Vec3f a);`
`Vec3ip vec3f_to_vec3i(OUT Vec3i dest, Vec3f a);`
[:arrow_up_small:](#)
@ -5629,7 +5629,7 @@ Converts a 3D floating-point vector `a` into a 3D short integer vector and store
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3f_to_vec3s(Vec3s dest, Vec3f a);`
`Vec3sp vec3f_to_vec3s(OUT Vec3s dest, Vec3f a);`
[:arrow_up_small:](#)
@ -5658,7 +5658,7 @@ Sets the components of the 3D integer vector `v` to 0
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3i_zero(Vec3i v);`
`Vec3ip vec3i_zero(OUT Vec3i v);`
[:arrow_up_small:](#)
@ -5682,7 +5682,7 @@ Copies the contents of a 3D integer vector (`src`) into another 3D integer vecto
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3i_copy(Vec3i dest, Vec3i src);`
`Vec3ip vec3i_copy(OUT Vec3i dest, Vec3i src);`
[:arrow_up_small:](#)
@ -5708,7 +5708,7 @@ Sets the values of the 3D integer vector `dest` to the given x, y, and z values
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3i_set(Vec3i dest, s32 x, s32 y, s32 z);`
`Vec3ip vec3i_set(OUT Vec3i dest, s32 x, s32 y, s32 z);`
[:arrow_up_small:](#)
@ -5732,7 +5732,7 @@ Adds the components of the 3D integer vector `a` to `dest`
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3i_add(Vec3i dest, Vec3i a);`
`Vec3ip vec3i_add(OUT Vec3i dest, Vec3i a);`
[:arrow_up_small:](#)
@ -5757,7 +5757,7 @@ Adds the components of two 3D integer vectors `a` and `b` and stores the result
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3i_sum(Vec3i dest, Vec3i a, Vec3i b);`
`Vec3ip vec3i_sum(OUT Vec3i dest, Vec3i a, Vec3i b);`
[:arrow_up_small:](#)
@ -5781,7 +5781,7 @@ Subtracts the components of the 3D integer vector `a` from `dest`
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3i_sub(Vec3i dest, Vec3i a);`
`Vec3ip vec3i_sub(OUT Vec3i dest, Vec3i a);`
[:arrow_up_small:](#)
@ -5806,7 +5806,7 @@ Subtracts the components of the 3D integer vector `b` from the components of `a`
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3i_dif(Vec3i dest, Vec3i a, Vec3i b);`
`Vec3ip vec3i_dif(OUT Vec3i dest, Vec3i a, Vec3i b);`
[:arrow_up_small:](#)
@ -5830,7 +5830,7 @@ Multiplies each component of the 3D integer vector `dest` by the scalar value `a
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3i_mul(Vec3i dest, f32 a);`
`Vec3ip vec3i_mul(OUT Vec3i dest, f32 a);`
[:arrow_up_small:](#)
@ -5854,7 +5854,7 @@ Multiplies the components of the 3D integer vector `dest` with the components of
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3i_mult(Vec3i dest, Vec3i a);`
`Vec3ip vec3i_mult(OUT Vec3i dest, Vec3i a);`
[:arrow_up_small:](#)
@ -5879,7 +5879,7 @@ Multiplies the components of two 3D integer vectors `a` and `b` and stores the r
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3i_prod(Vec3i dest, Vec3i a, Vec3i b);`
`Vec3ip vec3i_prod(OUT Vec3i dest, Vec3i a, Vec3i b);`
[:arrow_up_small:](#)
@ -5903,7 +5903,7 @@ Divides each component of the 3D integer vector `dest` by the scalar value `a`
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3i_div(Vec3i dest, f32 a);`
`Vec3ip vec3i_div(OUT Vec3i dest, f32 a);`
[:arrow_up_small:](#)
@ -5949,7 +5949,7 @@ Normalizes the 3D integer vector `v` so that its length (magnitude) becomes 1, w
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3i_normalize(Vec3i v);`
`Vec3ip vec3i_normalize(OUT Vec3i v);`
[:arrow_up_small:](#)
@ -5973,7 +5973,7 @@ Sets the length (magnitude) of 3D integer vector `v`, while retaining its direct
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3i_set_magnitude(Vec3i v, f32 mag);`
`Vec3ip vec3i_set_magnitude(OUT Vec3i v, f32 mag);`
[:arrow_up_small:](#)
@ -6022,7 +6022,7 @@ Computes the cross product of two 3D integer vectors `a` and `b` and stores the
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3i_cross(Vec3i dest, Vec3i a, Vec3i b);`
`Vec3ip vec3i_cross(OUT Vec3i dest, Vec3i a, Vec3i b);`
[:arrow_up_small:](#)
@ -6049,7 +6049,7 @@ Takes two 3D integer vectors `vecA` and `vecB`, multiplies them by `sclA` and `s
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3i_combine(Vec3i dest, Vec3i vecA, Vec3i vecB, f32 sclA, f32 sclB);`
`Vec3ip vec3i_combine(OUT Vec3i dest, Vec3i vecA, Vec3i vecB, f32 sclA, f32 sclB);`
[:arrow_up_small:](#)
@ -6144,7 +6144,7 @@ Converts a 3D integer vector `a` into a 3D floating-point vector and stores the
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3i_to_vec3f(Vec3f dest, Vec3i a);`
`Vec3fp vec3i_to_vec3f(OUT Vec3f dest, Vec3i a);`
[:arrow_up_small:](#)
@ -6168,7 +6168,7 @@ Converts a 3D integer vector `a` into a 3D short integer vector and stores the r
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3i_to_vec3s(Vec3s dest, Vec3i a);`
`Vec3sp vec3i_to_vec3s(OUT Vec3s dest, Vec3i a);`
[:arrow_up_small:](#)
@ -6197,7 +6197,7 @@ Sets the components of the 3D short integer vector `v` to 0
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3s_zero(Vec3s v);`
`Vec3sp vec3s_zero(OUT Vec3s v);`
[:arrow_up_small:](#)
@ -6221,7 +6221,7 @@ Copies the contents of a 3D short integer vector (`src`) into another 3D short i
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3s_copy(Vec3s dest, Vec3s src);`
`Vec3sp vec3s_copy(OUT Vec3s dest, Vec3s src);`
[:arrow_up_small:](#)
@ -6247,7 +6247,7 @@ Sets the values of the 3D short integer vector `dest` to the given x, y, and z v
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3s_set(Vec3s dest, s16 x, s16 y, s16 z);`
`Vec3sp vec3s_set(OUT Vec3s dest, s16 x, s16 y, s16 z);`
[:arrow_up_small:](#)
@ -6271,7 +6271,7 @@ Adds the components of the 3D short integer vector `a` to `dest`
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3s_add(Vec3s dest, Vec3s a);`
`Vec3sp vec3s_add(OUT Vec3s dest, Vec3s a);`
[:arrow_up_small:](#)
@ -6296,7 +6296,7 @@ Adds the components of two 3D short integer vectors `a` and `b` and stores the r
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3s_sum(Vec3s dest, Vec3s a, Vec3s b);`
`Vec3sp vec3s_sum(OUT Vec3s dest, Vec3s a, Vec3s b);`
[:arrow_up_small:](#)
@ -6320,7 +6320,7 @@ Subtracts the components of the 3D short integer vector `a` from `dest`
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3s_sub(Vec3s dest, Vec3s a);`
`Vec3sp vec3s_sub(OUT Vec3s dest, Vec3s a);`
[:arrow_up_small:](#)
@ -6345,7 +6345,7 @@ Subtracts the components of the 3D short integer vector `b` from the components
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3s_dif(Vec3s dest, Vec3s a, Vec3s b);`
`Vec3sp vec3s_dif(OUT Vec3s dest, Vec3s a, Vec3s b);`
[:arrow_up_small:](#)
@ -6369,7 +6369,7 @@ Multiplies each component of the 3D short integer vector `dest` by the scalar va
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3s_mul(Vec3s dest, f32 a);`
`Vec3sp vec3s_mul(OUT Vec3s dest, f32 a);`
[:arrow_up_small:](#)
@ -6393,7 +6393,7 @@ Multiplies the components of the 3D short integer vector `dest` with the compone
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3s_mult(Vec3s dest, Vec3s a);`
`Vec3sp vec3s_mult(OUT Vec3s dest, Vec3s a);`
[:arrow_up_small:](#)
@ -6418,7 +6418,7 @@ Multiplies the components of two 3D short integer vectors `a` and `b` and stores
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3s_prod(Vec3s dest, Vec3s a, Vec3s b);`
`Vec3sp vec3s_prod(OUT Vec3s dest, Vec3s a, Vec3s b);`
[:arrow_up_small:](#)
@ -6442,7 +6442,7 @@ Divides each component of the 3D short integer vector `dest` by the scalar value
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3s_div(Vec3s dest, f32 a);`
`Vec3sp vec3s_div(OUT Vec3s dest, f32 a);`
[:arrow_up_small:](#)
@ -6488,7 +6488,7 @@ Normalizes the 3D short integer vector `v` so that its length (magnitude) become
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3s_normalize(Vec3s v);`
`Vec3sp vec3s_normalize(OUT Vec3s v);`
[:arrow_up_small:](#)
@ -6512,7 +6512,7 @@ Sets the length (magnitude) of 3D short integer vector `v`, while retaining its
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3s_set_magnitude(Vec3s v, f32 mag);`
`Vec3sp vec3s_set_magnitude(OUT Vec3s v, f32 mag);`
[:arrow_up_small:](#)
@ -6561,7 +6561,7 @@ Computes the cross product of two 3D short integer vectors `a` and `b` and store
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3s_cross(Vec3s dest, Vec3s a, Vec3s b);`
`Vec3sp vec3s_cross(OUT Vec3s dest, Vec3s a, Vec3s b);`
[:arrow_up_small:](#)
@ -6588,7 +6588,7 @@ Takes two 3D short integer vectors `vecA` and `vecB`, multiplies them by `sclA`
[Vec3s](structs.md#Vec3s)
### C Prototype
`Vec3sp vec3s_combine(Vec3s dest, Vec3s vecA, Vec3s vecB, f32 sclA, f32 sclB);`
`Vec3sp vec3s_combine(OUT Vec3s dest, Vec3s vecA, Vec3s vecB, f32 sclA, f32 sclB);`
[:arrow_up_small:](#)
@ -6683,7 +6683,7 @@ Converts a 3D short integer vector `a` into a 3D floating-point vector and store
[Vec3f](structs.md#Vec3f)
### C Prototype
`Vec3fp vec3s_to_vec3f(Vec3f dest, Vec3s a);`
`Vec3fp vec3s_to_vec3f(OUT Vec3f dest, Vec3s a);`
[:arrow_up_small:](#)
@ -6707,7 +6707,7 @@ Converts a 3D short integer vector `a` into a 3D integer vector and stores the r
[Vec3i](structs.md#Vec3i)
### C Prototype
`Vec3ip vec3s_to_vec3i(Vec3i dest, Vec3s a);`
`Vec3ip vec3s_to_vec3i(OUT Vec3i dest, Vec3s a);`
[:arrow_up_small:](#)

16
docs/lua/functions-5.md
View file

@ -214,7 +214,7 @@ Linearly interpolates `res` between `a` and `b` with `delta`
- None
### C Prototype
`void delta_interpolate_vec3f(Vec3f res, Vec3f a, Vec3f b, f32 delta);`
`void delta_interpolate_vec3f(OUT Vec3f res, Vec3f a, Vec3f b, f32 delta);`
[:arrow_up_small:](#)
@ -240,7 +240,7 @@ Linearly interpolates `res` between `a` and `b` with `delta`
- None
### C Prototype
`void delta_interpolate_vec3s(Vec3s res, Vec3s a, Vec3s b, f32 delta);`
`void delta_interpolate_vec3s(OUT Vec3s res, Vec3s a, Vec3s b, f32 delta);`
[:arrow_up_small:](#)
@ -1615,7 +1615,7 @@ Finds any wall collisions and returns what the displacement vector would be.
- `integer`
### C Prototype
`s8 obj_find_wall_displacement(Vec3f dist, f32 x, f32 y, f32 z, f32 radius);`
`s8 obj_find_wall_displacement(OUT Vec3f dist, f32 x, f32 y, f32 z, f32 radius);`
[:arrow_up_small:](#)
@ -2929,7 +2929,7 @@ Overrides the current room Mario is in. Set to -1 to reset override
- None
### C Prototype
`void obj_apply_scale_to_matrix(struct Object *obj, Mat4 dst, Mat4 src);`
`void obj_apply_scale_to_matrix(struct Object *obj, OUT Mat4 dst, Mat4 src);`
[:arrow_up_small:](#)
@ -2951,7 +2951,7 @@ Overrides the current room Mario is in. Set to -1 to reset override
- None
### C Prototype
`void create_transformation_from_matrices(Mat4 a0, Mat4 a1, Mat4 a2);`
`void create_transformation_from_matrices(OUT Mat4 a0, Mat4 a1, Mat4 a2);`
[:arrow_up_small:](#)
@ -3625,7 +3625,7 @@ Multiplies a vector by a matrix of the form: `| ? ? ? 0 |` `| ? ? ? 0 |` `| ? ?
- None
### C Prototype
`void linear_mtxf_mul_vec3f(Mat4 m, Vec3f dst, Vec3f v);`
`void linear_mtxf_mul_vec3f(Mat4 m, OUT Vec3f dst, Vec3f v);`
[:arrow_up_small:](#)
@ -3650,7 +3650,7 @@ Multiplies a vector by the transpose of a matrix of the form: `| ? ? ? 0 |` `| ?
- None
### C Prototype
`void linear_mtxf_transpose_mul_vec3f(Mat4 m, Vec3f dst, Vec3f v);`
`void linear_mtxf_transpose_mul_vec3f(Mat4 m, OUT Vec3f dst, Vec3f v);`
[:arrow_up_small:](#)
@ -8077,7 +8077,7 @@ Retrieves the current position of Mario's cap, if it is on the ground in the cur
- `integer`
### C Prototype
`s32 save_file_get_cap_pos(Vec3s capPos);`
`s32 save_file_get_cap_pos(OUT Vec3s capPos);`
[:arrow_up_small:](#)

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

@ -4284,7 +4284,7 @@ Retrieves the animated part position associated to `animPart` from the MarioStat
- `boolean`
### C Prototype
`bool get_mario_anim_part_pos(struct MarioState *m, u32 animPart, Vec3f pos);`
`bool get_mario_anim_part_pos(struct MarioState *m, u32 animPart, OUT Vec3f pos);`
[:arrow_up_small:](#)
@ -7350,7 +7350,7 @@ Gets the closest point of the triangle to `src` and returns it in `out`.
- None
### C Prototype
`void closest_point_to_triangle(struct Surface* surf, Vec3f src, Vec3f out);`
`void closest_point_to_triangle(struct Surface* surf, Vec3f src, OUT Vec3f out);`
[:arrow_up_small:](#)

5
docs/lua/functions.md
View file

@ -51,7 +51,6 @@
- [spawn_wind_particles](functions-2.md#spawn_wind_particles)
- [check_if_moving_over_floor](functions-2.md#check_if_moving_over_floor)
- [arc_to_goal_pos](functions-2.md#arc_to_goal_pos)
- [vec3f_copy_2](functions-2.md#vec3f_copy_2)
- [tox_box_move](functions-2.md#tox_box_move)
- [play_penguin_walking_sound](functions-2.md#play_penguin_walking_sound)
- [update_angle_from_move_flags](functions-2.md#update_angle_from_move_flags)
@ -654,6 +653,10 @@
- [select_mario_cam_mode](functions-3.md#select_mario_cam_mode)
- [object_pos_to_vec3f](functions-3.md#object_pos_to_vec3f)
- [vec3f_to_object_pos](functions-3.md#vec3f_to_object_pos)
- [object_face_angle_to_vec3s](functions-3.md#object_face_angle_to_vec3s)
- [vec3s_to_object_face_angle](functions-3.md#vec3s_to_object_face_angle)
- [object_move_angle_to_vec3s](functions-3.md#object_move_angle_to_vec3s)
- [vec3s_to_object_move_angle](functions-3.md#vec3s_to_object_move_angle)
- [cam_select_alt_mode](functions-3.md#cam_select_alt_mode)
- [set_cam_angle](functions-3.md#set_cam_angle)
- [set_handheld_shake](functions-3.md#set_handheld_shake)

4
include/types.h
View file

@ -40,6 +40,10 @@ struct Controller
OSContPad *controllerData;
};
// A macro to tell autogen which function parameters are modified during the function call and should be pushed again
// Only works with Vec3, Mat4 and Color types
#define OUT
typedef f32 Vec2f[2]; // X, Y
typedef s16 Vec2s[2];
typedef s32 Vec2i[2];

6
src/engine/lighting_engine.c
View file

@ -17,7 +17,7 @@ static inline void color_set(Color color, u8 r, u8 g, u8 b) {
color[2] = b;
}
void le_calculate_vertex_lighting(Vtx_t* v, Color out) {
void le_calculate_vertex_lighting(Vtx_t* v, OUT Color out) {
if (sLights == NULL) { return; }
#ifdef LE_TOTAL_WEIGHTED_LIGHTING
@ -56,7 +56,7 @@ void le_calculate_vertex_lighting(Vtx_t* v, Color out) {
#endif
}
void le_calculate_lighting_color(Vec3f pos, Color out, f32 lightIntensityScalar) {
void le_calculate_lighting_color(Vec3f pos, OUT Color out, f32 lightIntensityScalar) {
if (sLights == NULL) { return; }
#ifdef LE_TOTAL_WEIGHTED_LIGHTING
@ -95,7 +95,7 @@ void le_calculate_lighting_color(Vec3f pos, Color out, f32 lightIntensityScalar)
#endif
}
void le_calculate_lighting_dir(Vec3f pos, Vec3f out) {
void le_calculate_lighting_dir(Vec3f pos, OUT Vec3f out) {
if (sLights == NULL) { return; }
Vec3f lightingDir = { 0, 0, 0 };

6
src/engine/lighting_engine.h
View file

@ -15,11 +15,11 @@ struct LELight
f32 intensity;
};
void le_calculate_vertex_lighting(Vtx_t* v, Color out);
void le_calculate_vertex_lighting(Vtx_t* v, OUT Color out);
/* |description|Calculates the lighting with `lightIntensityScalar` at a position and outputs the color in `out`|descriptionEnd|*/
void le_calculate_lighting_color(Vec3f pos, Color out, f32 lightIntensityScalar);
void le_calculate_lighting_color(Vec3f pos, OUT Color out, f32 lightIntensityScalar);
/* |description|Calculates the lighting direction from a position and outputs the result in `out`|descriptionEnd| */
void le_calculate_lighting_dir(Vec3f pos, Vec3f out);
void le_calculate_lighting_dir(Vec3f pos, OUT Vec3f out);
/* |description|Adds a lighting engine point light at `x`, `y`, `z` with color `r`, `g`, `b` and `radius` with `intensity`|descriptionEnd| */
s32 le_add_light(f32 x, f32 y, f32 z, u8 r, u8 g, u8 b, f32 radius, f32 intensity);
/* |description|Removes a lighting engine point light corresponding to `id`|descriptionEnd| */

40
src/engine/math_util.c
View file

@ -133,7 +133,7 @@ OPTIMIZE_O3 f32 approach_f32(f32 current, f32 target, f32 inc, f32 dec) {
* [0, 0, 0, 0, 1, 2, ... n-1, n, n, n, n]
* TODO: verify the classification of the spline / figure out how polynomials were computed
*/
OPTIMIZE_O3 void spline_get_weights(struct MarioState* m, Vec4f result, f32 t, UNUSED s32 c) {
OPTIMIZE_O3 void spline_get_weights(struct MarioState* m, OUT Vec4f result, f32 t, UNUSED s32 c) {
if (!m) { return; }
f32 tinv = 1 - t;
f32 tinv2 = tinv * tinv;
@ -195,7 +195,7 @@ OPTIMIZE_O3 void anim_spline_init(struct MarioState* m, Vec4s *keyFrames) {
* anim_spline_init should be called before polling for vectors.
* Returns TRUE when the last point is reached, FALSE otherwise.
*/
OPTIMIZE_O3 s32 anim_spline_poll(struct MarioState* m, Vec3f result) {
OPTIMIZE_O3 s32 anim_spline_poll(struct MarioState* m, OUT Vec3f result) {
if (!m) { return 0; }
Vec4f weights = { 0 };
s32 i;
@ -245,7 +245,7 @@ Vec3f gVec3fOne = { 1.0f, 1.0f, 1.0f };
* Returns a vector rotated around the z axis, then the x axis, then the y
* axis.
*/
OPTIMIZE_O3 Vec3fp vec3f_rotate_zxy(Vec3f dest, Vec3s rotate) {
OPTIMIZE_O3 Vec3fp vec3f_rotate_zxy(OUT Vec3f dest, Vec3s rotate) {
Vec3f v = { dest[0], dest[1], dest[2] };
f32 sx = sins(rotate[0]);
@ -270,7 +270,7 @@ OPTIMIZE_O3 Vec3fp vec3f_rotate_zxy(Vec3f dest, Vec3s rotate) {
// Rodrigues' formula
// dest = v * cos(r) + (n x v) * sin(r) + n * (n . v) * (1 - cos(r))
OPTIMIZE_O3 Vec3fp vec3f_rotate_around_n(Vec3f dest, Vec3f v, Vec3f n, s16 r) {
OPTIMIZE_O3 Vec3fp vec3f_rotate_around_n(OUT Vec3f dest, Vec3f v, Vec3f n, s16 r) {
Vec3f nvCross;
vec3f_cross(nvCross, n, v);
f32 nvDot = vec3f_dot(n, v);
@ -282,7 +282,7 @@ OPTIMIZE_O3 Vec3fp vec3f_rotate_around_n(Vec3f dest, Vec3f v, Vec3f n, s16 r) {
return dest;
}
OPTIMIZE_O3 Vec3fp vec3f_project(Vec3f dest, Vec3f v, Vec3f onto) {
OPTIMIZE_O3 Vec3fp vec3f_project(OUT Vec3f dest, Vec3f v, Vec3f onto) {
f32 numerator = vec3f_dot(v, onto);
f32 denominator = vec3f_dot(onto, onto);
if (denominator == 0) {
@ -294,7 +294,7 @@ OPTIMIZE_O3 Vec3fp vec3f_project(Vec3f dest, Vec3f v, Vec3f onto) {
return dest;
}
OPTIMIZE_O3 Vec3fp vec3f_transform(Vec3f dest, Vec3f v, Vec3f translation, Vec3s rotation, Vec3f scale) {
OPTIMIZE_O3 Vec3fp vec3f_transform(OUT Vec3f dest, Vec3f v, Vec3f translation, Vec3s rotation, Vec3f scale) {
vec3f_copy(dest, v);
// scale
@ -330,7 +330,7 @@ OPTIMIZE_O3 void vec3f_get_dist_and_angle(Vec3f from, Vec3f to, f32 *dist, s16 *
* Construct the 'to' point which is distance 'dist' away from the 'from' position,
* and has the angles pitch and yaw.
*/
OPTIMIZE_O3 void vec3f_set_dist_and_angle(Vec3f from, Vec3f to, f32 dist, s16 pitch, s16 yaw) {
OPTIMIZE_O3 void vec3f_set_dist_and_angle(Vec3f from, OUT Vec3f to, f32 dist, s16 pitch, s16 yaw) {
to[0] = from[0] + dist * coss(pitch) * sins(yaw);
to[1] = from[1] + dist * sins(pitch);
to[2] = from[2] + dist * coss(pitch) * coss(yaw);
@ -341,7 +341,7 @@ OPTIMIZE_O3 void vec3f_set_dist_and_angle(Vec3f from, Vec3f to, f32 dist, s16 pi
* It is similar to vec3f_cross, but it calculates the vectors (c-b) and (b-a)
* at the same time.
*/
OPTIMIZE_O3 Vec3fp find_vector_perpendicular_to_plane(Vec3f dest, Vec3f a, Vec3f b, Vec3f c) {
OPTIMIZE_O3 Vec3fp find_vector_perpendicular_to_plane(OUT Vec3f dest, Vec3f a, Vec3f b, Vec3f c) {
dest[0] = (b[1] - a[1]) * (c[2] - b[2]) - (c[1] - b[1]) * (b[2] - a[2]);
dest[1] = (b[2] - a[2]) * (c[0] - b[0]) - (c[2] - b[2]) * (b[0] - a[0]);
dest[2] = (b[0] - a[0]) * (c[1] - b[1]) - (c[0] - b[0]) * (b[1] - a[1]);
@ -388,7 +388,7 @@ Mat4 gMat4Zero = {
* at the position 'to'. The up-vector is assumed to be (0, 1, 0), but the 'roll'
* angle allows a bank rotation of the camera.
*/
OPTIMIZE_O3 void mtxf_lookat(Mat4 mtx, Vec3f from, Vec3f to, s16 roll) {
OPTIMIZE_O3 void mtxf_lookat(OUT Mat4 mtx, Vec3f from, Vec3f to, s16 roll) {
Vec3f forward, right, up;
f32 sinRoll, cosRoll;
f32 dx, dz, xzDist;
@ -456,7 +456,7 @@ OPTIMIZE_O3 void mtxf_lookat(Mat4 mtx, Vec3f from, Vec3f to, s16 roll) {
* Build a matrix that rotates around the z axis, then the x axis, then the y
* axis, and then translates.
*/
OPTIMIZE_O3 void mtxf_rotate_zxy_and_translate(Mat4 dest, Vec3f translate, Vec3s rotate) {
OPTIMIZE_O3 void mtxf_rotate_zxy_and_translate(OUT Mat4 dest, Vec3f translate, Vec3s rotate) {
f32 sx = sins(rotate[0]);
f32 cx = coss(rotate[0]);
@ -489,7 +489,7 @@ OPTIMIZE_O3 void mtxf_rotate_zxy_and_translate(Mat4 dest, Vec3f translate, Vec3s
* Build a matrix that rotates around the x axis, then the y axis, then the z
* axis, and then translates.
*/
OPTIMIZE_O3 void mtxf_rotate_xyz_and_translate(Mat4 dest, Vec3f b, Vec3s c) {
OPTIMIZE_O3 void mtxf_rotate_xyz_and_translate(OUT Mat4 dest, Vec3f b, Vec3s c) {
f32 sx = sins(c[0]);
f32 cx = coss(c[0]);
@ -526,7 +526,7 @@ OPTIMIZE_O3 void mtxf_rotate_xyz_and_translate(Mat4 dest, Vec3f b, Vec3s c) {
* 'position' is the position of the object in the world
* 'angle' rotates the object while still facing the camera.
*/
OPTIMIZE_O3 void mtxf_billboard(Mat4 dest, Mat4 mtx, Vec3f position, s16 angle) {
OPTIMIZE_O3 void mtxf_billboard(OUT Mat4 dest, Mat4 mtx, Vec3f position, s16 angle) {
dest[0][0] = coss(angle);
dest[0][1] = sins(angle);
dest[0][2] = 0;
@ -549,7 +549,7 @@ OPTIMIZE_O3 void mtxf_billboard(Mat4 dest, Mat4 mtx, Vec3f position, s16 angle)
}
// straight up mtxf_billboard but minus the dest[1][n] lines. transform for cylindrical billboards
OPTIMIZE_O3 void mtxf_cylboard(Mat4 dest, Mat4 mtx, Vec3f position, s16 angle) {
OPTIMIZE_O3 void mtxf_cylboard(OUT Mat4 dest, Mat4 mtx, Vec3f position, s16 angle) {
dest[0][0] = coss(angle);
dest[0][1] = sins(angle);
dest[0][2] = 0;
@ -578,7 +578,7 @@ OPTIMIZE_O3 void mtxf_cylboard(Mat4 dest, Mat4 mtx, Vec3f position, s16 angle) {
* 'yaw' is the angle which it should face
* 'pos' is the object's position in the world
*/
OPTIMIZE_O3 void mtxf_align_terrain_normal(Mat4 dest, Vec3f upDir, Vec3f pos, s16 yaw) {
OPTIMIZE_O3 void mtxf_align_terrain_normal(OUT Mat4 dest, Vec3f upDir, Vec3f pos, s16 yaw) {
Vec3f lateralDir;
Vec3f leftDir;
Vec3f forwardDir;
@ -621,7 +621,7 @@ OPTIMIZE_O3 void mtxf_align_terrain_normal(Mat4 dest, Vec3f upDir, Vec3f pos, s1
* 'pos' is the object's position in the world
* 'radius' is the distance from each triangle vertex to the center
*/
OPTIMIZE_O3 void mtxf_align_terrain_triangle(Mat4 mtx, Vec3f pos, s16 yaw, f32 radius) {
OPTIMIZE_O3 void mtxf_align_terrain_triangle(OUT Mat4 mtx, Vec3f pos, s16 yaw, f32 radius) {
struct Surface *sp74;
Vec3f point0;
Vec3f point1;
@ -692,7 +692,7 @@ OPTIMIZE_O3 void mtxf_align_terrain_triangle(Mat4 mtx, Vec3f pos, s16 yaw, f32 r
* The resulting matrix represents first applying transformation b and
* then a.
*/
OPTIMIZE_O3 void mtxf_mul(Mat4 dest, Mat4 a, Mat4 b) {
OPTIMIZE_O3 void mtxf_mul(OUT Mat4 dest, Mat4 a, Mat4 b) {
Mat4 tmp;
for (s32 i = 0; i < 4; i++) {
for (s32 j = 0; j < 4; j++) {
@ -710,7 +710,7 @@ OPTIMIZE_O3 void mtxf_mul(Mat4 dest, Mat4 a, Mat4 b) {
* to the point. Note that the bottom row is assumed to be [0, 0, 0, 1], which is
* true for transformation matrices if the translation has a w component of 1.
*/
OPTIMIZE_O3 s16 *mtxf_mul_vec3s(Mat4 mtx, Vec3s b) {
OPTIMIZE_O3 Vec3sp mtxf_mul_vec3s(Mat4 mtx, OUT Vec3s b) {
f32 x = b[0];
f32 y = b[1];
f32 z = b[2];
@ -725,7 +725,7 @@ OPTIMIZE_O3 s16 *mtxf_mul_vec3s(Mat4 mtx, Vec3s b) {
/**
* Set 'mtx' to a transformation matrix that rotates around the z axis.
*/
OPTIMIZE_O3 void mtxf_rotate_xy(Mat4 mtx, s16 angle) {
OPTIMIZE_O3 void mtxf_rotate_xy(OUT Mat4 mtx, s16 angle) {
mtxf_identity(mtx);
mtx[0][0] = coss(angle);
mtx[0][1] = sins(angle);
@ -746,7 +746,7 @@ OPTIMIZE_O3 void mtxf_rotate_xy(Mat4 mtx, s16 angle) {
* furthermore, this is currently only used to get the inverse of the camera transform
* because that is always orthonormal, the determinant will never be 0, so that check is removed
*/
OPTIMIZE_O3 void mtxf_inverse(Mat4 dest, Mat4 src) {
OPTIMIZE_O3 void mtxf_inverse(OUT Mat4 dest, Mat4 src) {
Mat4 buf;
// calculating the determinant has been reduced since the check is removed
@ -789,7 +789,7 @@ OPTIMIZE_O3 void mtxf_inverse(Mat4 dest, Mat4 src) {
* objMtx back from screen orientation to world orientation, and then subtracting
* the camera position.
*/
OPTIMIZE_O3 Vec3fp get_pos_from_transform_mtx(Vec3f dest, Mat4 objMtx, Mat4 camMtx) {
OPTIMIZE_O3 Vec3fp get_pos_from_transform_mtx(OUT Vec3f dest, Mat4 objMtx, Mat4 camMtx) {
f32 camX = camMtx[3][0] * camMtx[0][0] + camMtx[3][1] * camMtx[0][1] + camMtx[3][2] * camMtx[0][2];
f32 camY = camMtx[3][0] * camMtx[1][0] + camMtx[3][1] * camMtx[1][1] + camMtx[3][2] * camMtx[1][2];
f32 camZ = camMtx[3][0] * camMtx[2][0] + camMtx[3][1] * camMtx[2][1] + camMtx[3][2] * camMtx[2][2];

40
src/engine/math_util.h
View file

@ -131,7 +131,7 @@ OPTIMIZE_O3 f32 approach_f32(f32 current, f32 target, f32 inc, f32 dec);
/* |description|
Computes spline interpolation weights for a given parameter `t` and stores these weights in `result`. This is used in spline-based animations to find intermediate positions between keyframes
|descriptionEnd| */
OPTIMIZE_O3 void spline_get_weights(struct MarioState* m, Vec4f result, f32 t, UNUSED s32 c);
OPTIMIZE_O3 void spline_get_weights(struct MarioState* m, OUT Vec4f result, f32 t, UNUSED s32 c);
/* |description|
Initializes a spline-based animation for the `MarioState` structure `m` using the provided array of 3D signed-integer vectors `keyFrames`. This sets up the animation so that it can be advanced by polling
@ -141,7 +141,7 @@ OPTIMIZE_O3 void anim_spline_init(struct MarioState* m, Vec4s *keyFrames);
/* |description|
Advances the spline-based animation associated with `m` and stores the current interpolated position in `result`. It returns the animation's status, allowing the caller to determine if the animation is ongoing or has completed
|descriptionEnd| */
OPTIMIZE_O3 s32 anim_spline_poll(struct MarioState* m, Vec3f result);
OPTIMIZE_O3 s32 anim_spline_poll(struct MarioState* m, OUT Vec3f result);
///////////
// Vec3f //
@ -152,22 +152,22 @@ OPTIMIZE_O3 s32 anim_spline_poll(struct MarioState* m, Vec3f result);
/* |description|
Rotates the 3D floating-point vector `v` by the angles specified in the 3D signed-integer vector `rotate`, applying the rotations in the order Z, then X, then Y. The rotated vector replaces `v`
|descriptionEnd| */
OPTIMIZE_O3 Vec3fp vec3f_rotate_zxy(Vec3f v, Vec3s rotate);
OPTIMIZE_O3 Vec3fp vec3f_rotate_zxy(OUT Vec3f v, Vec3s rotate);
/* |description|
Rotates the 3D floating-point vector `v` around the vector `n`, given a rotation `r` (in sm64 angle units), and stores the result in `dest`
|descriptionEnd| */
OPTIMIZE_O3 Vec3fp vec3f_rotate_around_n(Vec3f dest, Vec3f v, Vec3f n, s16 r);
OPTIMIZE_O3 Vec3fp vec3f_rotate_around_n(OUT Vec3f dest, Vec3f v, Vec3f n, s16 r);
/* |description|
Projects the 3D floating-point vector `v` onto another 3D floating-point vector `onto`. The resulting projection, stored in `dest`, represents how much of `v` lies along the direction of `onto`
|descriptionEnd| */
OPTIMIZE_O3 Vec3fp vec3f_project(Vec3f dest, Vec3f v, Vec3f onto);
OPTIMIZE_O3 Vec3fp vec3f_project(OUT Vec3f dest, Vec3f v, Vec3f onto);
/* |description|
Scales the 3D floating-point vector `v` by the vector `scale`, then rotates it by the rotation vector `rotation`, and finally translates it by the vector `translation`. The resulting vector is stored in `dest`
|descriptionEnd| */
OPTIMIZE_O3 Vec3fp vec3f_transform(Vec3f dest, Vec3f v, Vec3f translation, Vec3s rotation, Vec3f scale);
OPTIMIZE_O3 Vec3fp vec3f_transform(OUT Vec3f dest, Vec3f v, Vec3f translation, Vec3s rotation, Vec3f scale);
/* |description|
Calculates the distance between two points in 3D space (`from` and `to`), as well as the pitch and yaw angles that describe the direction from `from` to `to`. The results are stored in `dist`, `pitch`, and `yaw`
@ -177,12 +177,12 @@ OPTIMIZE_O3 void vec3f_get_dist_and_angle(Vec3f from, Vec3f to, f32 *dist, s16 *
/* |description|
Positions the point `to` at a given `dist`, `pitch`, and `yaw` relative to the point `from`. This can be used to place objects around a reference point at specific angles and distances
|descriptionEnd| */
OPTIMIZE_O3 void vec3f_set_dist_and_angle(Vec3f from, Vec3f to, f32 dist, s16 pitch, s16 yaw);
OPTIMIZE_O3 void vec3f_set_dist_and_angle(Vec3f from, OUT Vec3f to, f32 dist, s16 pitch, s16 yaw);
/* |description|
Determines a vector that is perpendicular (normal) to the plane defined by three given 3D floating-point points `a`, `b`, and `c`. The resulting perpendicular vector is stored in `dest`
|descriptionEnd| */
OPTIMIZE_O3 Vec3fp find_vector_perpendicular_to_plane(Vec3f dest, Vec3f a, Vec3f b, Vec3f c);
OPTIMIZE_O3 Vec3fp find_vector_perpendicular_to_plane(OUT Vec3f dest, Vec3f a, Vec3f b, Vec3f c);
///////////
// Vec3i //
@ -205,62 +205,62 @@ OPTIMIZE_O3 Vec3fp find_vector_perpendicular_to_plane(Vec3f dest, Vec3f a, Vec3f
/* |description|
Adjusts the 4x4 floating-point matrix `mtx` so that it represents a viewing transformation looking from the point `from` toward the point `to`, with a given roll angle. This creates a view matrix oriented toward `to`
|descriptionEnd| */
OPTIMIZE_O3 void mtxf_lookat(Mat4 mtx, Vec3f from, Vec3f to, s16 roll);
OPTIMIZE_O3 void mtxf_lookat(OUT Mat4 mtx, Vec3f from, Vec3f to, s16 roll);
/* |description|
Rotates `dest` according to the angles in `rotate` using ZXY order, and then translates it by the 3D floating-point vector `translate`. This effectively positions and orients `dest` in 3D space
|descriptionEnd| */
OPTIMIZE_O3 void mtxf_rotate_zxy_and_translate(Mat4 dest, Vec3f translate, Vec3s rotate);
OPTIMIZE_O3 void mtxf_rotate_zxy_and_translate(OUT Mat4 dest, Vec3f translate, Vec3s rotate);
/* |description|
Rotates `dest` using angles in XYZ order, and then translates it by the 3D floating-point vector `b` and applies the rotations described by `c`. This sets up `dest` with a specific orientation and position in space
|descriptionEnd| */
OPTIMIZE_O3 void mtxf_rotate_xyz_and_translate(Mat4 dest, Vec3f b, Vec3s c);
OPTIMIZE_O3 void mtxf_rotate_xyz_and_translate(OUT Mat4 dest, Vec3f b, Vec3s c);
/* |description|
Transforms a 4x4 floating-point matrix `mtx` into a "billboard" oriented toward the camera or a given direction. The billboard is placed at `position` and rotated by `angle`. This is useful for objects that should always face the viewer
|descriptionEnd| */
OPTIMIZE_O3 void mtxf_billboard(Mat4 dest, Mat4 mtx, Vec3f position, s16 angle);
OPTIMIZE_O3 void mtxf_billboard(OUT Mat4 dest, Mat4 mtx, Vec3f position, s16 angle);
/* |description|
Creates a "cylindrical billboard" transformation from the 4x4 matrix `mtx` placed at `position` with a given `angle`. Unlike a full billboard, this might allow rotation around one axis while still facing the viewer on others
|descriptionEnd| */
OPTIMIZE_O3 void mtxf_cylboard(Mat4 dest, Mat4 mtx, Vec3f position, s16 angle);
OPTIMIZE_O3 void mtxf_cylboard(OUT Mat4 dest, Mat4 mtx, Vec3f position, s16 angle);
/* |description|
Aligns `dest` so that it fits the orientation of a terrain surface defined by its normal vector `upDir`. The transformation is positioned at `pos` and oriented with a given `yaw`. This is often used to make objects sit naturally on uneven ground
|descriptionEnd| */
OPTIMIZE_O3 void mtxf_align_terrain_normal(Mat4 dest, Vec3f upDir, Vec3f pos, s16 yaw);
OPTIMIZE_O3 void mtxf_align_terrain_normal(OUT Mat4 dest, Vec3f upDir, Vec3f pos, s16 yaw);
/* |description|
Aligns `mtx` to fit onto a terrain triangle at `pos`, applying a given `yaw` and scaling by `radius`. This helps position objects so they match the orientation of the terrain's surface
|descriptionEnd| */
OPTIMIZE_O3 void mtxf_align_terrain_triangle(Mat4 mtx, Vec3f pos, s16 yaw, f32 radius);
OPTIMIZE_O3 void mtxf_align_terrain_triangle(OUT Mat4 mtx, Vec3f pos, s16 yaw, f32 radius);
/* |description|
Multiplies two 4x4 floating-point matrices `a` and `b` (in that order), storing the product in `dest`. This can be used for combining multiple transformations into one
|descriptionEnd| */
OPTIMIZE_O3 void mtxf_mul(Mat4 dest, Mat4 a, Mat4 b);
OPTIMIZE_O3 void mtxf_mul(OUT Mat4 dest, Mat4 a, Mat4 b);
/* |description|
Multiplies the 3D signed-integer vector `b` with the 4x4 floating-point matrix `mtx`, which applies the transformation to the point
|descriptionEnd| */
OPTIMIZE_O3 s16 *mtxf_mul_vec3s(Mat4 mtx, Vec3s b);
OPTIMIZE_O3 Vec3sp mtxf_mul_vec3s(Mat4 mtx, OUT Vec3s b);
/* |description|
Rotates the matrix `mtx` in the XY plane by the given `angle`. Rotating in the XY plane typically means pivoting around the Z axis
|descriptionEnd| */
OPTIMIZE_O3 void mtxf_rotate_xy(Mat4 mtx, s16 angle);
OPTIMIZE_O3 void mtxf_rotate_xy(OUT Mat4 mtx, s16 angle);
/* |description|
Inverts the 4x4 floating-point matrix `src` and stores the inverse in `dest`. Applying the inverse transformation undoes whatever `src` did, returning points back to their original coordinate space
|descriptionEnd| */
OPTIMIZE_O3 void mtxf_inverse(Mat4 dest, Mat4 src);
OPTIMIZE_O3 void mtxf_inverse(OUT Mat4 dest, Mat4 src);
/* |description|
Extracts the position (translation component) from the transformation matrix `objMtx` relative to the coordinate system defined by `camMtx` and stores that 3D position in `dest`. This can be used to get the object's coordinates in camera space
|descriptionEnd| */
OPTIMIZE_O3 Vec3fp get_pos_from_transform_mtx(Vec3f dest, Mat4 objMtx, Mat4 camMtx);
OPTIMIZE_O3 Vec3fp get_pos_from_transform_mtx(OUT Vec3f dest, Mat4 objMtx, Mat4 camMtx);
#endif // MATH_UTIL_H

12
src/engine/math_util_mat4.inl
View file

@ -14,28 +14,28 @@ optimizations and bug reports.
Sets the 4x4 floating-point matrix `mtx` to all zeros.
Unless you really need this-It's reccomended to use mtxf_identity instead.
|descriptionEnd| */
INLINE OPTIMIZE_O3 void mtxf_zero(Mat4 mtx) {
INLINE OPTIMIZE_O3 void mtxf_zero(OUT Mat4 mtx) {
memset(mtx, 0, sizeof(Mat4));
}
/* |description|
Copies the 4x4 floating-point matrix `src` into `dest`. After this operation, `dest` contains the same matrix values as `src`
|descriptionEnd| */
INLINE OPTIMIZE_O3 void mtxf_copy(Mat4 dest, Mat4 src) {
INLINE OPTIMIZE_O3 void mtxf_copy(OUT Mat4 dest, Mat4 src) {
memcpy(dest, src, sizeof(Mat4));
}
/* |description|
Sets the 4x4 floating-point matrix `mtx` to the identity matrix. The identity matrix leaves points unchanged when they are transformed by it which is useful for matrix math
|descriptionEnd| */
INLINE OPTIMIZE_O3 void mtxf_identity(Mat4 mtx) {
INLINE OPTIMIZE_O3 void mtxf_identity(OUT Mat4 mtx) {
mtxf_copy(mtx, gMat4Identity);
}
/* |description|
Applies a translation to the 4x4 floating-point matrix `dest` by adding the coordinates in the 3D floating-point vector `b`. This shifts any transformed point by `b`
Sets the 4x4 floating-point matrix `dest` to the translation matrix decribed by the 3D floating-point vector `b`. This matrix is used to shift any transformed point by `b`
|descriptionEnd| */
INLINE OPTIMIZE_O3 void mtxf_translate(Mat4 dest, Vec3f b) {
INLINE OPTIMIZE_O3 void mtxf_translate(OUT Mat4 dest, Vec3f b) {
mtxf_identity(dest);
vec3f_copy(dest[3], b);
}
@ -43,7 +43,7 @@ INLINE OPTIMIZE_O3 void mtxf_translate(Mat4 dest, Vec3f b) {
/* |description|
Scales the 4x4 floating-point matrix `mtx` by the scaling factors found in the 3D floating-point vector `s`, and stores the result in `dest`. This enlarges or shrinks objects in 3D space
|descriptionEnd| */
INLINE OPTIMIZE_O3 void mtxf_scale_vec3f(Mat4 dest, Mat4 mtx, Vec3f s) {
INLINE OPTIMIZE_O3 void mtxf_scale_vec3f(OUT Mat4 dest, Mat4 mtx, Vec3f s) {
mtxf_copy(dest, mtx);
vec3f_mul(dest[0], s[0]);
vec3f_mul(dest[1], s[1]);

30
src/engine/math_util_vec3.tmpl
View file

@ -3,7 +3,7 @@
/* |description|
Sets the components of the 3D {{desc}} vector `v` to 0
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_zero(Vec3{{suffix}} v) {
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_zero(OUT Vec3{{suffix}} v) {
memset(v, 0, sizeof(Vec3{{suffix}}));
return v;
}
@ -11,7 +11,7 @@ INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_zero(Vec3{{suffix}} v) {
/* |description|
Copies the contents of a 3D {{desc}} vector (`src`) into another 3D {{desc}} vector (`dest`)
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_copy(Vec3{{suffix}} dest, Vec3{{suffix}} src) {
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_copy(OUT Vec3{{suffix}} dest, Vec3{{suffix}} src) {
dest[0] = src[0];
dest[1] = src[1];
dest[2] = src[2];
@ -21,7 +21,7 @@ INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_copy(Vec3{{suffix}} dest, Vec3
/* |description|
Sets the values of the 3D {{desc}} vector `dest` to the given x, y, and z values
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_set(Vec3{{suffix}} dest, {{type}} x, {{type}} y, {{type}} z) {
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_set(OUT Vec3{{suffix}} dest, {{type}} x, {{type}} y, {{type}} z) {
dest[0] = x;
dest[1] = y;
dest[2] = z;
@ -31,7 +31,7 @@ INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_set(Vec3{{suffix}} dest, {{typ
/* |description|
Adds the components of the 3D {{desc}} vector `a` to `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_add(Vec3{{suffix}} dest, Vec3{{suffix}} a) {
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_add(OUT Vec3{{suffix}} dest, Vec3{{suffix}} a) {
dest[0] += a[0];
dest[1] += a[1];
dest[2] += a[2];
@ -41,7 +41,7 @@ INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_add(Vec3{{suffix}} dest, Vec3{
/* |description|
Adds the components of two 3D {{desc}} vectors `a` and `b` and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_sum(Vec3{{suffix}} dest, Vec3{{suffix}} a, Vec3{{suffix}} b) {
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_sum(OUT Vec3{{suffix}} dest, Vec3{{suffix}} a, Vec3{{suffix}} b) {
dest[0] = a[0] + b[0];
dest[1] = a[1] + b[1];
dest[2] = a[2] + b[2];
@ -51,7 +51,7 @@ INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_sum(Vec3{{suffix}} dest, Vec3{
/* |description|
Subtracts the components of the 3D {{desc}} vector `a` from `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_sub(Vec3{{suffix}} dest, Vec3{{suffix}} a) {
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_sub(OUT Vec3{{suffix}} dest, Vec3{{suffix}} a) {
dest[0] -= a[0];
dest[1] -= a[1];
dest[2] -= a[2];
@ -61,7 +61,7 @@ INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_sub(Vec3{{suffix}} dest, Vec3{
/* |description|
Subtracts the components of the 3D {{desc}} vector `b` from the components of `a` and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_dif(Vec3{{suffix}} dest, Vec3{{suffix}} a, Vec3{{suffix}} b) {
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_dif(OUT Vec3{{suffix}} dest, Vec3{{suffix}} a, Vec3{{suffix}} b) {
dest[0] = a[0] - b[0];
dest[1] = a[1] - b[1];
dest[2] = a[2] - b[2];
@ -71,7 +71,7 @@ INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_dif(Vec3{{suffix}} dest, Vec3{
/* |description|
Multiplies each component of the 3D {{desc}} vector `dest` by the scalar value `a`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_mul(Vec3{{suffix}} dest, f32 a) {
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_mul(OUT Vec3{{suffix}} dest, f32 a) {
dest[0] *= a;
dest[1] *= a;
dest[2] *= a;
@ -81,7 +81,7 @@ INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_mul(Vec3{{suffix}} dest, f32 a
/* |description|
Multiplies the components of the 3D {{desc}} vector `dest` with the components of `a`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_mult(Vec3{{suffix}} dest, Vec3{{suffix}} a) {
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_mult(OUT Vec3{{suffix}} dest, Vec3{{suffix}} a) {
dest[0] *= a[0];
dest[1] *= a[1];
dest[2] *= a[2];
@ -91,7 +91,7 @@ INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_mult(Vec3{{suffix}} dest, Vec3
/* |description|
Multiplies the components of two 3D {{desc}} vectors `a` and `b` and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_prod(Vec3{{suffix}} dest, Vec3{{suffix}} a, Vec3{{suffix}} b) {
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_prod(OUT Vec3{{suffix}} dest, Vec3{{suffix}} a, Vec3{{suffix}} b) {
dest[0] = a[0] * b[0];
dest[1] = a[1] * b[1];
dest[2] = a[2] * b[2];
@ -101,7 +101,7 @@ INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_prod(Vec3{{suffix}} dest, Vec3
/* |description|
Divides each component of the 3D {{desc}} vector `dest` by the scalar value `a`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_div(Vec3{{suffix}} dest, f32 a) {
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_div(OUT Vec3{{suffix}} dest, f32 a) {
if (a == 0) { return dest; }
dest[0] /= a;
dest[1] /= a;
@ -119,7 +119,7 @@ INLINE OPTIMIZE_O3 f32 vec3{{suffix}}_length(Vec3{{suffix}} a) {
/* |description|
Normalizes the 3D {{desc}} vector `v` so that its length (magnitude) becomes 1, while retaining its direction
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_normalize(Vec3{{suffix}} v) {
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_normalize(OUT Vec3{{suffix}} v) {
f32 mag = vec3{{suffix}}_length(v);
vec3{{suffix}}_div(v, mag);
return v;
@ -128,7 +128,7 @@ INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_normalize(Vec3{{suffix}} v) {
/* |description|
Sets the length (magnitude) of 3D {{desc}} vector `v`, while retaining its direction
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_set_magnitude(Vec3{{suffix}} v, f32 mag) {
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_set_magnitude(OUT Vec3{{suffix}} v, f32 mag) {
vec3{{suffix}}_normalize(v);
vec3{{suffix}}_mul(v, mag);
return v;
@ -144,7 +144,7 @@ INLINE OPTIMIZE_O3 f32 vec3{{suffix}}_dot(Vec3{{suffix}} a, Vec3{{suffix}} b) {
/* |description|
Computes the cross product of two 3D {{desc}} vectors `a` and `b` and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_cross(Vec3{{suffix}} dest, Vec3{{suffix}} a, Vec3{{suffix}} b) {
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_cross(OUT Vec3{{suffix}} dest, Vec3{{suffix}} a, Vec3{{suffix}} b) {
dest[0] = a[1] * b[2] - b[1] * a[2];
dest[1] = a[2] * b[0] - b[2] * a[0];
dest[2] = a[0] * b[1] - b[0] * a[1];
@ -154,7 +154,7 @@ INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_cross(Vec3{{suffix}} dest, Vec
/* |description|
Takes two 3D {{desc}} vectors `vecA` and `vecB`, multiplies them by `sclA` and `sclB` respectively, adds the scaled vectors together and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_combine(Vec3{{suffix}} dest, Vec3{{suffix}} vecA, Vec3{{suffix}} vecB, f32 sclA, f32 sclB) {
INLINE OPTIMIZE_O3 Vec3{{suffix}}p vec3{{suffix}}_combine(OUT Vec3{{suffix}} dest, Vec3{{suffix}} vecA, Vec3{{suffix}} vecB, f32 sclA, f32 sclB) {
dest[0] = vecA[0] * sclA + vecB[0] * sclB;
dest[1] = vecA[1] * sclA + vecB[1] * sclB;
dest[2] = vecA[2] * sclA + vecB[2] * sclB;

34
src/engine/math_util_vec3f.inl
View file

@ -6,7 +6,7 @@
/* |description|
Sets the components of the 3D floating-point vector `v` to 0
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3f_zero(Vec3f v) {
INLINE OPTIMIZE_O3 Vec3fp vec3f_zero(OUT Vec3f v) {
memset(v, 0, sizeof(Vec3f));
return v;
}
@ -14,7 +14,7 @@ INLINE OPTIMIZE_O3 Vec3fp vec3f_zero(Vec3f v) {
/* |description|
Copies the contents of a 3D floating-point vector (`src`) into another 3D floating-point vector (`dest`)
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3f_copy(Vec3f dest, Vec3f src) {
INLINE OPTIMIZE_O3 Vec3fp vec3f_copy(OUT Vec3f dest, Vec3f src) {
dest[0] = src[0];
dest[1] = src[1];
dest[2] = src[2];
@ -24,7 +24,7 @@ INLINE OPTIMIZE_O3 Vec3fp vec3f_copy(Vec3f dest, Vec3f src) {
/* |description|
Sets the values of the 3D floating-point vector `dest` to the given x, y, and z values
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3f_set(Vec3f dest, f32 x, f32 y, f32 z) {
INLINE OPTIMIZE_O3 Vec3fp vec3f_set(OUT Vec3f dest, f32 x, f32 y, f32 z) {
dest[0] = x;
dest[1] = y;
dest[2] = z;
@ -34,7 +34,7 @@ INLINE OPTIMIZE_O3 Vec3fp vec3f_set(Vec3f dest, f32 x, f32 y, f32 z) {
/* |description|
Adds the components of the 3D floating-point vector `a` to `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3f_add(Vec3f dest, Vec3f a) {
INLINE OPTIMIZE_O3 Vec3fp vec3f_add(OUT Vec3f dest, Vec3f a) {
dest[0] += a[0];
dest[1] += a[1];
dest[2] += a[2];
@ -44,7 +44,7 @@ INLINE OPTIMIZE_O3 Vec3fp vec3f_add(Vec3f dest, Vec3f a) {
/* |description|
Adds the components of two 3D floating-point vectors `a` and `b` and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3f_sum(Vec3f dest, Vec3f a, Vec3f b) {
INLINE OPTIMIZE_O3 Vec3fp vec3f_sum(OUT Vec3f dest, Vec3f a, Vec3f b) {
dest[0] = a[0] + b[0];
dest[1] = a[1] + b[1];
dest[2] = a[2] + b[2];
@ -54,7 +54,7 @@ INLINE OPTIMIZE_O3 Vec3fp vec3f_sum(Vec3f dest, Vec3f a, Vec3f b) {
/* |description|
Subtracts the components of the 3D floating-point vector `a` from `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3f_sub(Vec3f dest, Vec3f a) {
INLINE OPTIMIZE_O3 Vec3fp vec3f_sub(OUT Vec3f dest, Vec3f a) {
dest[0] -= a[0];
dest[1] -= a[1];
dest[2] -= a[2];
@ -64,7 +64,7 @@ INLINE OPTIMIZE_O3 Vec3fp vec3f_sub(Vec3f dest, Vec3f a) {
/* |description|
Subtracts the components of the 3D floating-point vector `b` from the components of `a` and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3f_dif(Vec3f dest, Vec3f a, Vec3f b) {
INLINE OPTIMIZE_O3 Vec3fp vec3f_dif(OUT Vec3f dest, Vec3f a, Vec3f b) {
dest[0] = a[0] - b[0];
dest[1] = a[1] - b[1];
dest[2] = a[2] - b[2];
@ -74,7 +74,7 @@ INLINE OPTIMIZE_O3 Vec3fp vec3f_dif(Vec3f dest, Vec3f a, Vec3f b) {
/* |description|
Multiplies each component of the 3D floating-point vector `dest` by the scalar value `a`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3f_mul(Vec3f dest, f32 a) {
INLINE OPTIMIZE_O3 Vec3fp vec3f_mul(OUT Vec3f dest, f32 a) {
dest[0] *= a;
dest[1] *= a;
dest[2] *= a;
@ -84,7 +84,7 @@ INLINE OPTIMIZE_O3 Vec3fp vec3f_mul(Vec3f dest, f32 a) {
/* |description|
Multiplies the components of the 3D floating-point vector `dest` with the components of `a`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3f_mult(Vec3f dest, Vec3f a) {
INLINE OPTIMIZE_O3 Vec3fp vec3f_mult(OUT Vec3f dest, Vec3f a) {
dest[0] *= a[0];
dest[1] *= a[1];
dest[2] *= a[2];
@ -94,7 +94,7 @@ INLINE OPTIMIZE_O3 Vec3fp vec3f_mult(Vec3f dest, Vec3f a) {
/* |description|
Multiplies the components of two 3D floating-point vectors `a` and `b` and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3f_prod(Vec3f dest, Vec3f a, Vec3f b) {
INLINE OPTIMIZE_O3 Vec3fp vec3f_prod(OUT Vec3f dest, Vec3f a, Vec3f b) {
dest[0] = a[0] * b[0];
dest[1] = a[1] * b[1];
dest[2] = a[2] * b[2];
@ -104,7 +104,7 @@ INLINE OPTIMIZE_O3 Vec3fp vec3f_prod(Vec3f dest, Vec3f a, Vec3f b) {
/* |description|
Divides each component of the 3D floating-point vector `dest` by the scalar value `a`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3f_div(Vec3f dest, f32 a) {
INLINE OPTIMIZE_O3 Vec3fp vec3f_div(OUT Vec3f dest, f32 a) {
if (a == 0) { return dest; }
dest[0] /= a;
dest[1] /= a;
@ -122,7 +122,7 @@ INLINE OPTIMIZE_O3 f32 vec3f_length(Vec3f a) {
/* |description|
Normalizes the 3D floating-point vector `v` so that its length (magnitude) becomes 1, while retaining its direction
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3f_normalize(Vec3f v) {
INLINE OPTIMIZE_O3 Vec3fp vec3f_normalize(OUT Vec3f v) {
f32 mag = vec3f_length(v);
vec3f_div(v, mag);
return v;
@ -131,7 +131,7 @@ INLINE OPTIMIZE_O3 Vec3fp vec3f_normalize(Vec3f v) {
/* |description|
Sets the length (magnitude) of 3D floating-point vector `v`, while retaining its direction
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3f_set_magnitude(Vec3f v, f32 mag) {
INLINE OPTIMIZE_O3 Vec3fp vec3f_set_magnitude(OUT Vec3f v, f32 mag) {
vec3f_normalize(v);
vec3f_mul(v, mag);
return v;
@ -147,7 +147,7 @@ INLINE OPTIMIZE_O3 f32 vec3f_dot(Vec3f a, Vec3f b) {
/* |description|
Computes the cross product of two 3D floating-point vectors `a` and `b` and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3f_cross(Vec3f dest, Vec3f a, Vec3f b) {
INLINE OPTIMIZE_O3 Vec3fp vec3f_cross(OUT Vec3f dest, Vec3f a, Vec3f b) {
dest[0] = a[1] * b[2] - b[1] * a[2];
dest[1] = a[2] * b[0] - b[2] * a[0];
dest[2] = a[0] * b[1] - b[0] * a[1];
@ -157,7 +157,7 @@ INLINE OPTIMIZE_O3 Vec3fp vec3f_cross(Vec3f dest, Vec3f a, Vec3f b) {
/* |description|
Takes two 3D floating-point vectors `vecA` and `vecB`, multiplies them by `sclA` and `sclB` respectively, adds the scaled vectors together and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3f_combine(Vec3f dest, Vec3f vecA, Vec3f vecB, f32 sclA, f32 sclB) {
INLINE OPTIMIZE_O3 Vec3fp vec3f_combine(OUT Vec3f dest, Vec3f vecA, Vec3f vecB, f32 sclA, f32 sclB) {
dest[0] = vecA[0] * sclA + vecB[0] * sclB;
dest[1] = vecA[1] * sclA + vecB[1] * sclB;
dest[2] = vecA[2] * sclA + vecB[2] * sclB;
@ -191,7 +191,7 @@ INLINE OPTIMIZE_O3 bool vec3f_is_zero(Vec3f v) {
/* |description|
Converts a 3D floating-point vector `a` into a 3D integer vector and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3f_to_vec3i(Vec3i dest, Vec3f a) {
INLINE OPTIMIZE_O3 Vec3ip vec3f_to_vec3i(OUT Vec3i dest, Vec3f a) {
dest[0] = a[0] + ((a[0] > 0) ? 0.5f : -0.5f);
dest[1] = a[1] + ((a[1] > 0) ? 0.5f : -0.5f);
dest[2] = a[2] + ((a[2] > 0) ? 0.5f : -0.5f);
@ -201,7 +201,7 @@ INLINE OPTIMIZE_O3 Vec3ip vec3f_to_vec3i(Vec3i dest, Vec3f a) {
/* |description|
Converts a 3D floating-point vector `a` into a 3D short integer vector and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3f_to_vec3s(Vec3s dest, Vec3f a) {
INLINE OPTIMIZE_O3 Vec3sp vec3f_to_vec3s(OUT Vec3s dest, Vec3f a) {
dest[0] = a[0] + ((a[0] > 0) ? 0.5f : -0.5f);
dest[1] = a[1] + ((a[1] > 0) ? 0.5f : -0.5f);
dest[2] = a[2] + ((a[2] > 0) ? 0.5f : -0.5f);

34
src/engine/math_util_vec3i.inl
View file

@ -6,7 +6,7 @@
/* |description|
Sets the components of the 3D integer vector `v` to 0
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3i_zero(Vec3i v) {
INLINE OPTIMIZE_O3 Vec3ip vec3i_zero(OUT Vec3i v) {
memset(v, 0, sizeof(Vec3i));
return v;
}
@ -14,7 +14,7 @@ INLINE OPTIMIZE_O3 Vec3ip vec3i_zero(Vec3i v) {
/* |description|
Copies the contents of a 3D integer vector (`src`) into another 3D integer vector (`dest`)
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3i_copy(Vec3i dest, Vec3i src) {
INLINE OPTIMIZE_O3 Vec3ip vec3i_copy(OUT Vec3i dest, Vec3i src) {
dest[0] = src[0];
dest[1] = src[1];
dest[2] = src[2];
@ -24,7 +24,7 @@ INLINE OPTIMIZE_O3 Vec3ip vec3i_copy(Vec3i dest, Vec3i src) {
/* |description|
Sets the values of the 3D integer vector `dest` to the given x, y, and z values
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3i_set(Vec3i dest, s32 x, s32 y, s32 z) {
INLINE OPTIMIZE_O3 Vec3ip vec3i_set(OUT Vec3i dest, s32 x, s32 y, s32 z) {
dest[0] = x;
dest[1] = y;
dest[2] = z;
@ -34,7 +34,7 @@ INLINE OPTIMIZE_O3 Vec3ip vec3i_set(Vec3i dest, s32 x, s32 y, s32 z) {
/* |description|
Adds the components of the 3D integer vector `a` to `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3i_add(Vec3i dest, Vec3i a) {
INLINE OPTIMIZE_O3 Vec3ip vec3i_add(OUT Vec3i dest, Vec3i a) {
dest[0] += a[0];
dest[1] += a[1];
dest[2] += a[2];
@ -44,7 +44,7 @@ INLINE OPTIMIZE_O3 Vec3ip vec3i_add(Vec3i dest, Vec3i a) {
/* |description|
Adds the components of two 3D integer vectors `a` and `b` and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3i_sum(Vec3i dest, Vec3i a, Vec3i b) {
INLINE OPTIMIZE_O3 Vec3ip vec3i_sum(OUT Vec3i dest, Vec3i a, Vec3i b) {
dest[0] = a[0] + b[0];
dest[1] = a[1] + b[1];
dest[2] = a[2] + b[2];
@ -54,7 +54,7 @@ INLINE OPTIMIZE_O3 Vec3ip vec3i_sum(Vec3i dest, Vec3i a, Vec3i b) {
/* |description|
Subtracts the components of the 3D integer vector `a` from `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3i_sub(Vec3i dest, Vec3i a) {
INLINE OPTIMIZE_O3 Vec3ip vec3i_sub(OUT Vec3i dest, Vec3i a) {
dest[0] -= a[0];
dest[1] -= a[1];
dest[2] -= a[2];
@ -64,7 +64,7 @@ INLINE OPTIMIZE_O3 Vec3ip vec3i_sub(Vec3i dest, Vec3i a) {
/* |description|
Subtracts the components of the 3D integer vector `b` from the components of `a` and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3i_dif(Vec3i dest, Vec3i a, Vec3i b) {
INLINE OPTIMIZE_O3 Vec3ip vec3i_dif(OUT Vec3i dest, Vec3i a, Vec3i b) {
dest[0] = a[0] - b[0];
dest[1] = a[1] - b[1];
dest[2] = a[2] - b[2];
@ -74,7 +74,7 @@ INLINE OPTIMIZE_O3 Vec3ip vec3i_dif(Vec3i dest, Vec3i a, Vec3i b) {
/* |description|
Multiplies each component of the 3D integer vector `dest` by the scalar value `a`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3i_mul(Vec3i dest, f32 a) {
INLINE OPTIMIZE_O3 Vec3ip vec3i_mul(OUT Vec3i dest, f32 a) {
dest[0] *= a;
dest[1] *= a;
dest[2] *= a;
@ -84,7 +84,7 @@ INLINE OPTIMIZE_O3 Vec3ip vec3i_mul(Vec3i dest, f32 a) {
/* |description|
Multiplies the components of the 3D integer vector `dest` with the components of `a`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3i_mult(Vec3i dest, Vec3i a) {
INLINE OPTIMIZE_O3 Vec3ip vec3i_mult(OUT Vec3i dest, Vec3i a) {
dest[0] *= a[0];
dest[1] *= a[1];
dest[2] *= a[2];
@ -94,7 +94,7 @@ INLINE OPTIMIZE_O3 Vec3ip vec3i_mult(Vec3i dest, Vec3i a) {
/* |description|
Multiplies the components of two 3D integer vectors `a` and `b` and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3i_prod(Vec3i dest, Vec3i a, Vec3i b) {
INLINE OPTIMIZE_O3 Vec3ip vec3i_prod(OUT Vec3i dest, Vec3i a, Vec3i b) {
dest[0] = a[0] * b[0];
dest[1] = a[1] * b[1];
dest[2] = a[2] * b[2];
@ -104,7 +104,7 @@ INLINE OPTIMIZE_O3 Vec3ip vec3i_prod(Vec3i dest, Vec3i a, Vec3i b) {
/* |description|
Divides each component of the 3D integer vector `dest` by the scalar value `a`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3i_div(Vec3i dest, f32 a) {
INLINE OPTIMIZE_O3 Vec3ip vec3i_div(OUT Vec3i dest, f32 a) {
if (a == 0) { return dest; }
dest[0] /= a;
dest[1] /= a;
@ -122,7 +122,7 @@ INLINE OPTIMIZE_O3 f32 vec3i_length(Vec3i a) {
/* |description|
Normalizes the 3D integer vector `v` so that its length (magnitude) becomes 1, while retaining its direction
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3i_normalize(Vec3i v) {
INLINE OPTIMIZE_O3 Vec3ip vec3i_normalize(OUT Vec3i v) {
f32 mag = vec3i_length(v);
vec3i_div(v, mag);
return v;
@ -131,7 +131,7 @@ INLINE OPTIMIZE_O3 Vec3ip vec3i_normalize(Vec3i v) {
/* |description|
Sets the length (magnitude) of 3D integer vector `v`, while retaining its direction
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3i_set_magnitude(Vec3i v, f32 mag) {
INLINE OPTIMIZE_O3 Vec3ip vec3i_set_magnitude(OUT Vec3i v, f32 mag) {
vec3i_normalize(v);
vec3i_mul(v, mag);
return v;
@ -147,7 +147,7 @@ INLINE OPTIMIZE_O3 f32 vec3i_dot(Vec3i a, Vec3i b) {
/* |description|
Computes the cross product of two 3D integer vectors `a` and `b` and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3i_cross(Vec3i dest, Vec3i a, Vec3i b) {
INLINE OPTIMIZE_O3 Vec3ip vec3i_cross(OUT Vec3i dest, Vec3i a, Vec3i b) {
dest[0] = a[1] * b[2] - b[1] * a[2];
dest[1] = a[2] * b[0] - b[2] * a[0];
dest[2] = a[0] * b[1] - b[0] * a[1];
@ -157,7 +157,7 @@ INLINE OPTIMIZE_O3 Vec3ip vec3i_cross(Vec3i dest, Vec3i a, Vec3i b) {
/* |description|
Takes two 3D integer vectors `vecA` and `vecB`, multiplies them by `sclA` and `sclB` respectively, adds the scaled vectors together and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3i_combine(Vec3i dest, Vec3i vecA, Vec3i vecB, f32 sclA, f32 sclB) {
INLINE OPTIMIZE_O3 Vec3ip vec3i_combine(OUT Vec3i dest, Vec3i vecA, Vec3i vecB, f32 sclA, f32 sclB) {
dest[0] = vecA[0] * sclA + vecB[0] * sclB;
dest[1] = vecA[1] * sclA + vecB[1] * sclB;
dest[2] = vecA[2] * sclA + vecB[2] * sclB;
@ -191,7 +191,7 @@ INLINE OPTIMIZE_O3 bool vec3i_is_zero(Vec3i v) {
/* |description|
Converts a 3D integer vector `a` into a 3D floating-point vector and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3i_to_vec3f(Vec3f dest, Vec3i a) {
INLINE OPTIMIZE_O3 Vec3fp vec3i_to_vec3f(OUT Vec3f dest, Vec3i a) {
dest[0] = a[0];
dest[1] = a[1];
dest[2] = a[2];
@ -201,7 +201,7 @@ INLINE OPTIMIZE_O3 Vec3fp vec3i_to_vec3f(Vec3f dest, Vec3i a) {
/* |description|
Converts a 3D integer vector `a` into a 3D short integer vector and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3i_to_vec3s(Vec3s dest, Vec3i a) {
INLINE OPTIMIZE_O3 Vec3sp vec3i_to_vec3s(OUT Vec3s dest, Vec3i a) {
dest[0] = a[0];
dest[1] = a[1];
dest[2] = a[2];

34
src/engine/math_util_vec3s.inl
View file

@ -6,7 +6,7 @@
/* |description|
Sets the components of the 3D short integer vector `v` to 0
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3s_zero(Vec3s v) {
INLINE OPTIMIZE_O3 Vec3sp vec3s_zero(OUT Vec3s v) {
memset(v, 0, sizeof(Vec3s));
return v;
}
@ -14,7 +14,7 @@ INLINE OPTIMIZE_O3 Vec3sp vec3s_zero(Vec3s v) {
/* |description|
Copies the contents of a 3D short integer vector (`src`) into another 3D short integer vector (`dest`)
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3s_copy(Vec3s dest, Vec3s src) {
INLINE OPTIMIZE_O3 Vec3sp vec3s_copy(OUT Vec3s dest, Vec3s src) {
dest[0] = src[0];
dest[1] = src[1];
dest[2] = src[2];
@ -24,7 +24,7 @@ INLINE OPTIMIZE_O3 Vec3sp vec3s_copy(Vec3s dest, Vec3s src) {
/* |description|
Sets the values of the 3D short integer vector `dest` to the given x, y, and z values
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3s_set(Vec3s dest, s16 x, s16 y, s16 z) {
INLINE OPTIMIZE_O3 Vec3sp vec3s_set(OUT Vec3s dest, s16 x, s16 y, s16 z) {
dest[0] = x;
dest[1] = y;
dest[2] = z;
@ -34,7 +34,7 @@ INLINE OPTIMIZE_O3 Vec3sp vec3s_set(Vec3s dest, s16 x, s16 y, s16 z) {
/* |description|
Adds the components of the 3D short integer vector `a` to `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3s_add(Vec3s dest, Vec3s a) {
INLINE OPTIMIZE_O3 Vec3sp vec3s_add(OUT Vec3s dest, Vec3s a) {
dest[0] += a[0];
dest[1] += a[1];
dest[2] += a[2];
@ -44,7 +44,7 @@ INLINE OPTIMIZE_O3 Vec3sp vec3s_add(Vec3s dest, Vec3s a) {
/* |description|
Adds the components of two 3D short integer vectors `a` and `b` and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3s_sum(Vec3s dest, Vec3s a, Vec3s b) {
INLINE OPTIMIZE_O3 Vec3sp vec3s_sum(OUT Vec3s dest, Vec3s a, Vec3s b) {
dest[0] = a[0] + b[0];
dest[1] = a[1] + b[1];
dest[2] = a[2] + b[2];
@ -54,7 +54,7 @@ INLINE OPTIMIZE_O3 Vec3sp vec3s_sum(Vec3s dest, Vec3s a, Vec3s b) {
/* |description|
Subtracts the components of the 3D short integer vector `a` from `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3s_sub(Vec3s dest, Vec3s a) {
INLINE OPTIMIZE_O3 Vec3sp vec3s_sub(OUT Vec3s dest, Vec3s a) {
dest[0] -= a[0];
dest[1] -= a[1];
dest[2] -= a[2];
@ -64,7 +64,7 @@ INLINE OPTIMIZE_O3 Vec3sp vec3s_sub(Vec3s dest, Vec3s a) {
/* |description|
Subtracts the components of the 3D short integer vector `b` from the components of `a` and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3s_dif(Vec3s dest, Vec3s a, Vec3s b) {
INLINE OPTIMIZE_O3 Vec3sp vec3s_dif(OUT Vec3s dest, Vec3s a, Vec3s b) {
dest[0] = a[0] - b[0];
dest[1] = a[1] - b[1];
dest[2] = a[2] - b[2];
@ -74,7 +74,7 @@ INLINE OPTIMIZE_O3 Vec3sp vec3s_dif(Vec3s dest, Vec3s a, Vec3s b) {
/* |description|
Multiplies each component of the 3D short integer vector `dest` by the scalar value `a`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3s_mul(Vec3s dest, f32 a) {
INLINE OPTIMIZE_O3 Vec3sp vec3s_mul(OUT Vec3s dest, f32 a) {
dest[0] *= a;
dest[1] *= a;
dest[2] *= a;
@ -84,7 +84,7 @@ INLINE OPTIMIZE_O3 Vec3sp vec3s_mul(Vec3s dest, f32 a) {
/* |description|
Multiplies the components of the 3D short integer vector `dest` with the components of `a`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3s_mult(Vec3s dest, Vec3s a) {
INLINE OPTIMIZE_O3 Vec3sp vec3s_mult(OUT Vec3s dest, Vec3s a) {
dest[0] *= a[0];
dest[1] *= a[1];
dest[2] *= a[2];
@ -94,7 +94,7 @@ INLINE OPTIMIZE_O3 Vec3sp vec3s_mult(Vec3s dest, Vec3s a) {
/* |description|
Multiplies the components of two 3D short integer vectors `a` and `b` and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3s_prod(Vec3s dest, Vec3s a, Vec3s b) {
INLINE OPTIMIZE_O3 Vec3sp vec3s_prod(OUT Vec3s dest, Vec3s a, Vec3s b) {
dest[0] = a[0] * b[0];
dest[1] = a[1] * b[1];
dest[2] = a[2] * b[2];
@ -104,7 +104,7 @@ INLINE OPTIMIZE_O3 Vec3sp vec3s_prod(Vec3s dest, Vec3s a, Vec3s b) {
/* |description|
Divides each component of the 3D short integer vector `dest` by the scalar value `a`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3s_div(Vec3s dest, f32 a) {
INLINE OPTIMIZE_O3 Vec3sp vec3s_div(OUT Vec3s dest, f32 a) {
if (a == 0) { return dest; }
dest[0] /= a;
dest[1] /= a;
@ -122,7 +122,7 @@ INLINE OPTIMIZE_O3 f32 vec3s_length(Vec3s a) {
/* |description|
Normalizes the 3D short integer vector `v` so that its length (magnitude) becomes 1, while retaining its direction
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3s_normalize(Vec3s v) {
INLINE OPTIMIZE_O3 Vec3sp vec3s_normalize(OUT Vec3s v) {
f32 mag = vec3s_length(v);
vec3s_div(v, mag);
return v;
@ -131,7 +131,7 @@ INLINE OPTIMIZE_O3 Vec3sp vec3s_normalize(Vec3s v) {
/* |description|
Sets the length (magnitude) of 3D short integer vector `v`, while retaining its direction
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3s_set_magnitude(Vec3s v, f32 mag) {
INLINE OPTIMIZE_O3 Vec3sp vec3s_set_magnitude(OUT Vec3s v, f32 mag) {
vec3s_normalize(v);
vec3s_mul(v, mag);
return v;
@ -147,7 +147,7 @@ INLINE OPTIMIZE_O3 f32 vec3s_dot(Vec3s a, Vec3s b) {
/* |description|
Computes the cross product of two 3D short integer vectors `a` and `b` and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3s_cross(Vec3s dest, Vec3s a, Vec3s b) {
INLINE OPTIMIZE_O3 Vec3sp vec3s_cross(OUT Vec3s dest, Vec3s a, Vec3s b) {
dest[0] = a[1] * b[2] - b[1] * a[2];
dest[1] = a[2] * b[0] - b[2] * a[0];
dest[2] = a[0] * b[1] - b[0] * a[1];
@ -157,7 +157,7 @@ INLINE OPTIMIZE_O3 Vec3sp vec3s_cross(Vec3s dest, Vec3s a, Vec3s b) {
/* |description|
Takes two 3D short integer vectors `vecA` and `vecB`, multiplies them by `sclA` and `sclB` respectively, adds the scaled vectors together and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3sp vec3s_combine(Vec3s dest, Vec3s vecA, Vec3s vecB, f32 sclA, f32 sclB) {
INLINE OPTIMIZE_O3 Vec3sp vec3s_combine(OUT Vec3s dest, Vec3s vecA, Vec3s vecB, f32 sclA, f32 sclB) {
dest[0] = vecA[0] * sclA + vecB[0] * sclB;
dest[1] = vecA[1] * sclA + vecB[1] * sclB;
dest[2] = vecA[2] * sclA + vecB[2] * sclB;
@ -191,7 +191,7 @@ INLINE OPTIMIZE_O3 bool vec3s_is_zero(Vec3s v) {
/* |description|
Converts a 3D short integer vector `a` into a 3D floating-point vector and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3fp vec3s_to_vec3f(Vec3f dest, Vec3s a) {
INLINE OPTIMIZE_O3 Vec3fp vec3s_to_vec3f(OUT Vec3f dest, Vec3s a) {
dest[0] = a[0];
dest[1] = a[1];
dest[2] = a[2];
@ -201,7 +201,7 @@ INLINE OPTIMIZE_O3 Vec3fp vec3s_to_vec3f(Vec3f dest, Vec3s a) {
/* |description|
Converts a 3D short integer vector `a` into a 3D integer vector and stores the result in `dest`
|descriptionEnd| */
INLINE OPTIMIZE_O3 Vec3ip vec3s_to_vec3i(Vec3i dest, Vec3s a) {
INLINE OPTIMIZE_O3 Vec3ip vec3s_to_vec3i(OUT Vec3i dest, Vec3s a) {
dest[0] = a[0];
dest[1] = a[1];
dest[2] = a[2];

2
src/engine/surface_collision.c
View file

@ -25,7 +25,7 @@ void set_find_wall_direction(Vec3f dir, bool active, bool airborne) {
gFindWallDirectionAirborne = airborne;
}
void closest_point_to_triangle(struct Surface* surf, Vec3f src, Vec3f out) {
void closest_point_to_triangle(struct Surface* surf, Vec3f src, OUT Vec3f out) {
Vec3f v1; vec3s_to_vec3f(v1, surf->vertex1);
Vec3f v2; vec3s_to_vec3f(v2, surf->vertex2);
Vec3f v3; vec3s_to_vec3f(v3, surf->vertex3);

2
src/engine/surface_collision.h
View file

@ -87,6 +87,6 @@ void set_find_wall_direction(Vec3f dir, bool active, bool airborne);
/* |description|
Gets the closest point of the triangle to `src` and returns it in `out`.
|descriptionEnd| */
void closest_point_to_triangle(struct Surface* surf, Vec3f src, Vec3f out);
void closest_point_to_triangle(struct Surface* surf, Vec3f src, OUT Vec3f out);
#endif // SURFACE_COLLISION_H

9
src/game/behavior_actions.c
View file

@ -204,15 +204,6 @@ void spawn_sparkle_particles(s32 n, s32 a1, s32 a2, s32 r) {
#include "behaviors/bullet_bill.inc.c"
#include "behaviors/bowser.inc.c"
#include "behaviors/blue_fish.inc.c"
// Not in behavior file, duplicate of vec3f_copy except without bad return.
// Used in a few behavior files.
void vec3f_copy_2(Vec3f dest, Vec3f src) {
dest[0] = src[0];
dest[1] = src[1];
dest[2] = src[2];
}
#include "behaviors/checkerboard_platform.inc.c"
#include "behaviors/ddd_warp.inc.c"
#include "behaviors/water_pillar.inc.c"

2
src/game/behavior_actions.h
View file

@ -21,8 +21,6 @@ void spawn_wind_particles(s16 pitch, s16 yaw);
s32 check_if_moving_over_floor(f32 a0, f32 a1);
/* |description|Calculates the time it takes for the current object to follow an arc from `pos` to `goal`|descriptionEnd| */
s32 arc_to_goal_pos(Vec3f goal, Vec3f pos, f32 yVel, f32 gravity);
/* |description|Duplicate of vec3f_copy except without bad return|descriptionEnd| */
void vec3f_copy_2(Vec3f dest, Vec3f src);
/* |description|Moves Tox Box|descriptionEnd| */
void tox_box_move(f32 forwardVel, f32 a1, s16 deltaPitch, s16 deltaRoll);
/* |description|Plays the penguin walking sound|descriptionEnd| */

4
src/game/behaviors/bowser.inc.c
View file

@ -1612,7 +1612,7 @@ void falling_bowser_plat_act_2(void) {
if ((o->oTimer & 1) == 0 && o->oTimer < 14 && BHV_ARR_CHECK(D_8032F698, o->oBehParams2ndByte, struct Struct8032F698)) {
sp22 = D_8032F698[o->oBehParams2ndByte].unk3 + (gDebugInfo[4][1] << 8);
sp1C = -(o->oTimer / 2) * 290 + 1740;
vec3f_copy_2(sp24, &o->oPosX);
vec3f_copy(sp24, &o->oPosX);
o->oPosX = D_8032F698[o->oBehParams2ndByte].unk1 + sins(sp22 + 5296) * sp1C;
o->oPosZ = D_8032F698[o->oBehParams2ndByte].unk2 + coss(sp22 + 5296) * sp1C;
o->oPosY = 307.0f;
@ -1620,7 +1620,7 @@ void falling_bowser_plat_act_2(void) {
o->oPosX = D_8032F698[o->oBehParams2ndByte].unk1 + sins(sp22 - 5296) * sp1C;
o->oPosZ = D_8032F698[o->oBehParams2ndByte].unk2 + coss(sp22 - 5296) * sp1C;
spawn_mist_particles_variable(4, 0, 100);
vec3f_copy_2(&o->oPosX, sp24);
vec3f_copy(&o->oPosX, sp24);
}
cur_obj_move_using_fvel_and_gravity();
if (o->oTimer > 300)

2
src/game/behaviors/checkerboard_platform.inc.c
View file

@ -25,7 +25,7 @@ void bhv_checkerboard_elevator_group_init(void) {
if (sp2C == NULL) { continue; }
sp2C->oCheckerBoardPlatformUnk1AC = D_8032F754[sp34].unk2;
sp2C->oTimer = 0;
vec3f_copy_2(sp2C->header.gfx.scale, D_8032F754[sp34].unk1);
vec3f_copy(sp2C->header.gfx.scale, D_8032F754[sp34].unk1);
}
}

4
src/game/behaviors/sl_snowman_wind.inc.c
View file

@ -28,11 +28,11 @@ void bhv_sl_snowman_wind_loop(void) {
o->oDistanceToMario = 0;
// Check if Mario is within 1000 units of the center of the bridge, and ready to speak.
vec3f_copy_2(tempPos, &o->oPosX);
vec3f_copy(tempPos, &o->oPosX);
obj_set_pos(o, 1100, 3328, 1164); // Position is in the middle of the ice bridge
if (cur_obj_can_mario_activate_textbox(&gMarioStates[0], 1000.0f, 30.0f, 0x7FFF))
o->oSubAction++;
vec3f_copy_2(&o->oPosX, tempPos);
vec3f_copy(&o->oPosX, tempPos);
// Mario has come close, begin dialog.
} else if (o->oSubAction == SL_SNOWMAN_WIND_ACT_TALKING) {

6
src/game/behaviors/whomp.inc.c
View file

@ -160,14 +160,14 @@ void king_whomp_on_ground(void) {
if (o->oHealth == 0)
o->oAction = 8;
else {
vec3f_copy_2(pos, &o->oPosX);
vec3f_copy(pos, &o->oPosX);
if (player) {
vec3f_copy_2(&o->oPosX, &player->oPosX);
vec3f_copy(&o->oPosX, &player->oPosX);
}
spawn_mist_particles_variable(0, 0, 100.0f);
spawn_triangle_break_particles(20, 138, 3.0f, 4);
cur_obj_shake_screen(SHAKE_POS_SMALL);
vec3f_copy_2(&o->oPosX, pos);
vec3f_copy(&o->oPosX, pos);
}
o->oSubAction++;
}

57
src/game/camera.c
View file

@ -3788,7 +3788,7 @@ void stub_camera_2(UNUSED struct Camera *c) {
void stub_camera_3(UNUSED struct Camera *c) {
}
void object_pos_to_vec3f(Vec3f dst, struct Object *o) {
void object_pos_to_vec3f(OUT Vec3f dst, struct Object *o) {
if (!dst || !o) { return; }
dst[0] = o->oPosX;
dst[1] = o->oPosY;
@ -3802,13 +3802,34 @@ void vec3f_to_object_pos(struct Object *o, Vec3f src) {
o->oPosZ = src[2];
}
void unused_object_angle_to_vec3s(Vec3s dst, struct Object *o) {
void object_face_angle_to_vec3s(OUT Vec3s dst, struct Object *o) {
if (!dst || !o) { return; }
dst[0] = o->oFaceAnglePitch;
dst[1] = o->oFaceAngleYaw;
dst[2] = o->oFaceAngleRoll;
}
void vec3s_to_object_face_angle(struct Object *o, Vec3s src) {
if (!o || !src) { return; }
o->oFaceAnglePitch = src[0];
o->oFaceAngleYaw = src[1];
o->oFaceAngleRoll = src[2];
}
void object_move_angle_to_vec3s(OUT Vec3s dst, struct Object *o) {
if (!dst || !o) { return; }
dst[0] = o->oMoveAnglePitch;
dst[1] = o->oMoveAngleYaw;
dst[2] = o->oMoveAngleRoll;
}
void vec3s_to_object_move_angle(struct Object *o, Vec3s src) {
if (!o || !src) { return; }
o->oMoveAnglePitch = src[0];
o->oMoveAngleYaw = src[1];
o->oMoveAngleRoll = src[2];
}
/**
* Produces values using a cubic b-spline curve. Basically Q is the used output,
* u is a value between 0 and 1 that represents the position along the spline,
@ -4040,7 +4061,7 @@ void set_handheld_shake(u8 mode) {
* This function must be called every frame in order to actually apply the effect, since the effect's
* mag and inc are set to 0 every frame at the end of this function.
*/
void shake_camera_handheld(Vec3f pos, Vec3f focus) {
void shake_camera_handheld(Vec3f pos, OUT Vec3f focus) {
s32 i;
Vec3f shakeOffset;
Vec3f shakeSpline[4];
@ -4165,7 +4186,7 @@ s32 update_camera_hud_status(struct Camera *c) {
*
* @return the number of collisions found
*/
s32 collide_with_walls(Vec3f pos, f32 offsetY, f32 radius) {
s32 collide_with_walls(OUT Vec3f pos, f32 offsetY, f32 radius) {
struct WallCollisionData collisionData;
struct Surface *wall = NULL;
f32 normX;
@ -4216,7 +4237,7 @@ s32 vec3f_compare(Vec3f pos, f32 posX, f32 posY, f32 posZ) {
return equal;
}
s32 clamp_pitch(Vec3f from, Vec3f to, s16 maxPitch, s16 minPitch) {
s32 clamp_pitch(Vec3f from, OUT Vec3f to, s16 maxPitch, s16 minPitch) {
s32 outOfRange = 0;
s16 pitch;
s16 yaw;
@ -4332,7 +4353,7 @@ s32 approach_s16_asymptotic(s16 current, s16 target, s16 divisor) {
* Applies the approach_f32_asymptotic_bool function to each of the X, Y, & Z components of the given
* vector.
*/
void approach_vec3f_asymptotic(Vec3f current, Vec3f target, f32 xMul, f32 yMul, f32 zMul) {
void approach_vec3f_asymptotic(OUT Vec3f current, Vec3f target, f32 xMul, f32 yMul, f32 zMul) {
approach_f32_asymptotic_bool(&current[0], target[0], xMul);
approach_f32_asymptotic_bool(&current[1], target[1], yMul);
approach_f32_asymptotic_bool(&current[2], target[2], zMul);
@ -4342,7 +4363,7 @@ void approach_vec3f_asymptotic(Vec3f current, Vec3f target, f32 xMul, f32 yMul,
* Applies the set_or_approach_f32_asymptotic_bool function to each of the X, Y, & Z components of the
* given vector.
*/
void set_or_approach_vec3f_asymptotic(Vec3f dst, Vec3f goal, f32 xMul, f32 yMul, f32 zMul) {
void set_or_approach_vec3f_asymptotic(OUT Vec3f dst, Vec3f goal, f32 xMul, f32 yMul, f32 zMul) {
set_or_approach_f32_asymptotic(&dst[0], goal[0], xMul);
set_or_approach_f32_asymptotic(&dst[1], goal[1], yMul);
set_or_approach_f32_asymptotic(&dst[2], goal[2], zMul);
@ -4352,7 +4373,7 @@ void set_or_approach_vec3f_asymptotic(Vec3f dst, Vec3f goal, f32 xMul, f32 yMul,
* Applies the approach_s32_asymptotic function to each of the X, Y, & Z components of the given
* vector.
*/
void approach_vec3s_asymptotic(Vec3s current, Vec3s target, s16 xMul, s16 yMul, s16 zMul) {
void approach_vec3s_asymptotic(OUT Vec3s current, Vec3s target, s16 xMul, s16 yMul, s16 zMul) {
approach_s16_asymptotic_bool(&current[0], target[0], xMul);
approach_s16_asymptotic_bool(&current[1], target[1], yMul);
approach_s16_asymptotic_bool(&current[2], target[2], zMul);
@ -4490,7 +4511,7 @@ f32 camera_approach_f32_symmetric(f32 current, f32 target, f32 increment) {
* Generate a vector with all three values about zero. The
* three ranges determine how wide the range about zero.
*/
void random_vec3s(Vec3s dst, s16 xRange, s16 yRange, s16 zRange) {
void random_vec3s(OUT Vec3s dst, s16 xRange, s16 yRange, s16 zRange) {
f32 randomFloat;
UNUSED u8 unused[4];
f32 tempXRange;
@ -4557,7 +4578,7 @@ s16 reduce_by_dist_from_camera(s16 value, f32 maxDist, f32 posX, f32 posY, f32 p
return result;
}
s32 clamp_positions_and_find_yaw(Vec3f pos, Vec3f origin, f32 xMax, f32 xMin, f32 zMax, f32 zMin) {
s32 clamp_positions_and_find_yaw(OUT Vec3f pos, Vec3f origin, f32 xMax, f32 xMin, f32 zMax, f32 zMin) {
s16 yaw = gCamera->nextYaw;
if (pos[0] >= xMax) {
@ -4737,7 +4758,7 @@ s32 is_mario_behind_surface(UNUSED struct Camera *c, struct Surface *surf) {
* Calculates the distance between two points and sets a vector to a point
* scaled along a line between them. Typically, somewhere in the middle.
*/
void scale_along_line(Vec3f dst, Vec3f from, Vec3f to, f32 scale) {
void scale_along_line(OUT Vec3f dst, Vec3f from, Vec3f to, f32 scale) {
Vec3f tempVec;
tempVec[0] = (to[0] - from[0]) * scale + from[0];
@ -4823,7 +4844,7 @@ f32 calc_hor_dist(Vec3f a, Vec3f b) {
/**
* Rotates a vector in the horizontal plane and copies it to a new vector.
*/
void rotate_in_xz(Vec3f dst, Vec3f src, s16 yaw) {
void rotate_in_xz(OUT Vec3f dst, Vec3f src, s16 yaw) {
Vec3f tempVec;
vec3f_copy(tempVec, src);
@ -4838,7 +4859,7 @@ void rotate_in_xz(Vec3f dst, Vec3f src, s16 yaw) {
* Note: This function also flips the Z axis, so +Z moves forward, not backward like it would in world
* space. If possible, use vec3f_set_dist_and_angle()
*/
void rotate_in_yz(Vec3f dst, Vec3f src, s16 pitch) {
void rotate_in_yz(OUT Vec3f dst, Vec3f src, s16 pitch) {
Vec3f tempVec;
vec3f_copy(tempVec, src);
@ -4932,7 +4953,7 @@ void increment_shake_offset(s16 *offset, s16 increment) {
/**
* Apply a vertical shake to the camera by adjusting its pitch
*/
void shake_camera_pitch(Vec3f pos, Vec3f focus) {
void shake_camera_pitch(Vec3f pos, OUT Vec3f focus) {
f32 dist;
s16 pitch;
s16 yaw;
@ -4952,7 +4973,7 @@ void shake_camera_pitch(Vec3f pos, Vec3f focus) {
/**
* Apply a horizontal shake to the camera by adjusting its yaw
*/
void shake_camera_yaw(Vec3f pos, Vec3f focus) {
void shake_camera_yaw(Vec3f pos, OUT Vec3f focus) {
f32 dist;
s16 pitch;
s16 yaw;
@ -5599,7 +5620,7 @@ static void unused_set_pos_rel_mario(struct Camera *c, f32 leftRight, f32 yOff,
*
* @warning Flips the Z axis, so that relative to `rotation`, -Z moves forwards and +Z moves backwards.
*/
void offset_rotated(Vec3f dst, Vec3f from, Vec3f to, Vec3s rotation) {
void offset_rotated(OUT Vec3f dst, Vec3f from, Vec3f to, Vec3s rotation) {
Vec3f unusedCopy;
Vec3f pitchRotated;
@ -5653,7 +5674,7 @@ void determine_pushing_or_pulling_door(s16 *rotation) {
*
* @return Lakitu's next yaw, which is the same as the yaw passed in if no transition happened
*/
s16 next_lakitu_state(Vec3f newPos, Vec3f newFoc, Vec3f curPos, Vec3f curFoc,
s16 next_lakitu_state(OUT Vec3f newPos, OUT Vec3f newFoc, Vec3f curPos, Vec3f curFoc,
Vec3f oldPos, Vec3f oldFoc, s16 yaw) {
s16 yawVelocity;
s16 pitchVelocity;
@ -7043,7 +7064,7 @@ s16 camera_course_processing(struct Camera *c) {
* Move `pos` between the nearest floor and ceiling
* @param lastGood unused, passed as the last position the camera was in
*/
void resolve_geometry_collisions(Vec3f pos, UNUSED Vec3f lastGood) {
void resolve_geometry_collisions(OUT Vec3f pos, UNUSED Vec3f lastGood) {
f32 ceilY, floorY;
struct Surface *surf;

52
src/game/camera.h
View file

@ -788,7 +788,7 @@ void stub_camera_3(UNUSED struct Camera *c);
Converts an object's position to a `Vec3f` format.
Useful for aligning object behaviors or interactions with the camera system
|descriptionEnd| */
void object_pos_to_vec3f(Vec3f dst, struct Object *o);
void object_pos_to_vec3f(OUT Vec3f dst, struct Object *o);
/* |description|
Converts a `Vec3f` position to an object's internal format.
@ -796,6 +796,26 @@ Useful for syncing 3D positions between objects and the game world
|descriptionEnd| */
void vec3f_to_object_pos(struct Object *o, Vec3f src);
/* |description|
Converts an object's face angle to a `Vec3s` format
|descriptionEnd| */
void object_face_angle_to_vec3s(OUT Vec3s dst, struct Object *o);
/* |description|
Converts a `Vec3s` angle to an object's face angle internal format
|descriptionEnd| */
void vec3s_to_object_face_angle(struct Object *o, Vec3s src);
/* |description|
Converts an object's move angle to a `Vec3s` format
|descriptionEnd| */
void object_move_angle_to_vec3s(OUT Vec3s dst, struct Object *o);
/* |description|
Converts a `Vec3s` angle to an object's move angle internal format
|descriptionEnd| */
void vec3s_to_object_move_angle(struct Object *o, Vec3s src);
s32 move_point_along_spline(Vec3f p, struct CutsceneSplinePoint spline[], s16 *splineSegment, f32 *progress);
/* |description|
@ -820,7 +840,7 @@ void set_handheld_shake(u8 mode);
Activates a handheld camera shake effect.
Calculates positional and focus adjustments to simulate manual movement
|descriptionEnd| */
void shake_camera_handheld(Vec3f pos, Vec3f focus);
void shake_camera_handheld(Vec3f pos, OUT Vec3f focus);
/* |description|
Determines which C-buttons are currently pressed by the player.
@ -834,13 +854,13 @@ s32 update_camera_hud_status(struct Camera *c);
Checks for collisions between the camera and level geometry.
Adjusts the camera's position to avoid clipping into walls or obstacles
|descriptionEnd| */
s32 collide_with_walls(Vec3f pos, f32 offsetY, f32 radius);
s32 collide_with_walls(OUT Vec3f pos, f32 offsetY, f32 radius);
/* |description|
Clamps the camera's pitch angle between a maximum and minimum value.
Prevents over-rotation and maintains a consistent viewing angle
|descriptionEnd| */
s32 clamp_pitch(Vec3f from, Vec3f to, s16 maxPitch, s16 minPitch);
s32 clamp_pitch(Vec3f from, OUT Vec3f to, s16 maxPitch, s16 minPitch);
/* |description|
Checks if a position is within 100 units of Mario's current position.
@ -886,13 +906,13 @@ s32 approach_s16_asymptotic(s16 current, s16 target, s16 divisor);
Smoothly transitions a 3D vector (`current`) towards a target vector (`target`) using asymptotic scaling.
Scaling values (the `Mul` variables) for x, y, and z axes determine the speed of adjustment for each component
|descriptionEnd| */
void approach_vec3f_asymptotic(Vec3f current, Vec3f target, f32 xMul, f32 yMul, f32 zMul);
void approach_vec3f_asymptotic(OUT Vec3f current, Vec3f target, f32 xMul, f32 yMul, f32 zMul);
/* |description|
Smoothly transitions a 3D vector (`current`) toward a target vector (`goal`) using asymptotic scaling.
Allows gradual or instantaneous alignment of 3D positions. Scaling values (the `Mul` variables) for x, y, and z axes determine the speed of adjustment for each component
|descriptionEnd| */
void set_or_approach_vec3f_asymptotic(Vec3f dst, Vec3f goal, f32 xMul, f32 yMul, f32 zMul);
void set_or_approach_vec3f_asymptotic(OUT Vec3f dst, Vec3f goal, f32 xMul, f32 yMul, f32 zMul);
/* |description|
Adjusts a signed 16-bit integer (`current`) towards a target (`target`) symmetrically with a fixed increment (`increment`).
@ -922,13 +942,13 @@ f32 camera_approach_f32_symmetric(f32 value, f32 target, f32 increment);
Generates a random 3D vector with short integer components.
Useful for randomized offsets or environmental effects
|descriptionEnd| */
void random_vec3s(Vec3s dst, s16 xRange, s16 yRange, s16 zRange);
void random_vec3s(OUT Vec3s dst, s16 xRange, s16 yRange, s16 zRange);
/* |description|
Clamps a position within specified X and Z bounds and calculates the yaw angle from the origin.
Prevents the camera from moving outside of the designated area
|descriptionEnd| */
s32 clamp_positions_and_find_yaw(Vec3f pos, Vec3f origin, f32 xMax, f32 xMin, f32 zMax, f32 zMin);
s32 clamp_positions_and_find_yaw(OUT Vec3f pos, Vec3f origin, f32 xMax, f32 xMin, f32 zMax, f32 zMin);
/* |description|
Determines if a range is obstructed by a surface relative to the camera.
@ -941,7 +961,7 @@ Scales a point along a line between two 3D points (`from` and `to`).
The scaling factor determines how far along the line the resulting point will be.
The result is stored in the destination vector (`dest`)
|descriptionEnd| */
void scale_along_line(Vec3f dest, Vec3f from, Vec3f to, f32 scale);
void scale_along_line(OUT Vec3f dest, Vec3f from, Vec3f to, f32 scale);
/* |description|
Calculates the pitch angle (rotation around the X-axis) from one 3D point (`from`) to another (`to`).
@ -980,14 +1000,14 @@ Rotates a vector around the XZ-plane by a specified yaw angle.
The result is stored in the destination vector (`dst`).
Useful for rotating camera positions or object coordinates horizontally
|descriptionEnd| */
void rotate_in_xz(Vec3f dst, Vec3f src, s16 yaw);
void rotate_in_xz(OUT Vec3f dst, Vec3f src, s16 yaw);
/* |description|
Rotates a vector around the YZ-plane by a specified pitch angle.
The result is stored in the destination vector (`dst`).
Useful for vertical camera rotations or object transformations
|descriptionEnd| */
void rotate_in_yz(Vec3f dst, Vec3f src, s16 pitch);
void rotate_in_yz(OUT Vec3f dst, Vec3f src, s16 pitch);
/* |description|
Applies a pitch-based shake effect to the camera.
@ -1018,13 +1038,13 @@ void set_pitch_shake_from_point(s16 mag, s16 decay, s16 inc, f32 maxDist, f32 po
Activates a pitch-based shake effect.
Adds vertical vibrational movement to the camera's behavior
|descriptionEnd| */
void shake_camera_pitch(Vec3f pos, Vec3f focus);
void shake_camera_pitch(Vec3f pos, OUT Vec3f focus);
/* |description|
Activates a yaw-based shake effect.
Adds horizontal vibrational movement to the camera's behavior
|descriptionEnd| */
void shake_camera_yaw(Vec3f pos, Vec3f focus);
void shake_camera_yaw(Vec3f pos, OUT Vec3f focus);
/* |description|
Applies a roll-based shake effect to the camera.
@ -1138,13 +1158,13 @@ void approach_camera_height(struct Camera *c, f32 goal, f32 inc);
Offsets a vector by rotating it in 3D space relative to a reference position.
This is useful for creating radial effects or dynamic transformations
|descriptionEnd| */
void offset_rotated(Vec3f dst, Vec3f from, Vec3f to, Vec3s rotation);
void offset_rotated(OUT Vec3f dst, Vec3f from, Vec3f to, Vec3s rotation);
/* |description|
Transitions the camera to the next Lakitu state, updating position and focus.
This function handles smooth transitions between different gameplay scenarios
|descriptionEnd| */
s16 next_lakitu_state(Vec3f newPos, Vec3f newFoc, Vec3f curPos, Vec3f curFoc, Vec3f oldPos, Vec3f oldFoc, s16 yaw);
s16 next_lakitu_state(OUT Vec3f newPos, OUT Vec3f newFoc, Vec3f curPos, Vec3f curFoc, Vec3f oldPos, Vec3f oldFoc, s16 yaw);
/* |description|Set the fixed camera base pos depending on the current level area|descriptionEnd| */
void set_fixed_cam_axis_sa_lobby(UNUSED s16 preset);
@ -1158,7 +1178,7 @@ s16 camera_course_processing(struct Camera *c);
Resolves collisions between the camera and level geometry.
Adjusts the camera's position to prevent clipping or intersecting with objects
|descriptionEnd| */
void resolve_geometry_collisions(Vec3f pos, UNUSED Vec3f lastGood);
void resolve_geometry_collisions(OUT Vec3f pos, UNUSED Vec3f lastGood);
/* |description|
Rotates the camera to avoid walls or other obstructions.

6
src/game/mario.c
View file

@ -200,7 +200,7 @@ s32 is_anim_past_frame(struct MarioState *m, s16 animFrame) {
* Rotates the animation's translation into the global coordinate system
* and returns the animation's flags.
*/
s16 find_mario_anim_flags_and_translation(struct Object *obj, s32 yaw, Vec3s translation) {
s16 find_mario_anim_flags_and_translation(struct Object *obj, s32 yaw, OUT Vec3s translation) {
if (!obj) { return 0; }
f32 dx;
f32 dz;
@ -618,7 +618,7 @@ u32 mario_get_terrain_sound_addend(struct MarioState *m) {
/**
* Collides with walls and returns the most recent wall.
*/
struct Surface *resolve_and_return_wall_collisions(Vec3f pos, f32 offset, f32 radius) {
struct Surface *resolve_and_return_wall_collisions(OUT Vec3f pos, f32 offset, f32 radius) {
struct WallCollisionData collisionData;
struct Surface *wall = NULL;
@ -643,7 +643,7 @@ struct Surface *resolve_and_return_wall_collisions(Vec3f pos, f32 offset, f32 ra
/**
* Collides with walls and returns the wall collision data.
*/
void resolve_and_return_wall_collisions_data(Vec3f pos, f32 offset, f32 radius, struct WallCollisionData* collisionData) {
void resolve_and_return_wall_collisions_data(OUT Vec3f pos, f32 offset, f32 radius, struct WallCollisionData* collisionData) {
if (!collisionData || !pos) { return; }
collisionData->x = pos[0];

6
src/game/mario.h
View file

@ -58,7 +58,7 @@ s32 is_anim_past_frame(struct MarioState *m, s16 animFrame);
Retrieves the current animation flags and calculates the translation for Mario's animation, rotating it into the global coordinate system based on `yaw`.
Useful for determining positional offsets from animations (e.g., stepping forward in a walk animation) and applying them to Mario's position
|descriptionEnd| */
s16 find_mario_anim_flags_and_translation(struct Object *o, s32 yaw, Vec3s translation);
s16 find_mario_anim_flags_and_translation(struct Object *o, s32 yaw, OUT Vec3s translation);
/* |description|
Applies the translation from Mario's current animation to his world position. Considers animation flags (horizontal/vertical translation)
@ -166,12 +166,12 @@ u32 mario_get_terrain_sound_addend(struct MarioState *m);
Checks for and resolves wall collisions at a given position `pos`, returning the last wall encountered. Primarily used to prevent Mario from going through walls.
Useful for collision detection when updating Mario's movement or adjusting his position
|descriptionEnd| */
struct Surface *resolve_and_return_wall_collisions(Vec3f pos, f32 offset, f32 radius);
struct Surface *resolve_and_return_wall_collisions(OUT Vec3f pos, f32 offset, f32 radius);
/* |description|
Similar to `resolve_and_return_wall_collisions` but also returns detailed collision data (`WallCollisionData`). This can handle multiple walls and store them for further checks
|descriptionEnd| */
void resolve_and_return_wall_collisions_data(Vec3f pos, f32 offset, f32 radius, struct WallCollisionData* collisionData);
void resolve_and_return_wall_collisions_data(OUT Vec3f pos, f32 offset, f32 radius, struct WallCollisionData* collisionData);
f32 vec3f_find_ceil(Vec3f pos, f32 height, struct Surface **ceil);
f32 vec3f_mario_ceil(Vec3f pos, f32 height, struct Surface **ceil);

2
src/game/mario_actions_automatic.c
View file

@ -344,7 +344,7 @@ s32 act_top_of_pole(struct MarioState *m) {
/* |description|
Performs a single step of movement while Mario is hanging from a ceiling. It handles wall collisions and checks the floor and ceiling to determine if Mario remains hanging, leaves the ceiling, or hits it
|descriptionEnd| */
s32 perform_hanging_step(struct MarioState *m, Vec3f nextPos) {
s32 perform_hanging_step(struct MarioState *m, OUT Vec3f nextPos) {
if (!m) { return 0; }
UNUSED s32 unused;
struct Surface *ceil;

4
src/game/mario_actions_submerged.c
View file

@ -85,7 +85,7 @@ static f32 get_buoyancy(struct MarioState *m) {
}
/* |description|Performs a full water movement step where ceilings, floors, and walls are handled. Generally, you should use `perform_water_step` for the full step functionality|descriptionEnd| */
u32 perform_water_full_step(struct MarioState *m, Vec3f nextPos) {
u32 perform_water_full_step(struct MarioState *m, OUT Vec3f nextPos) {
if (!m) { return 0; }
struct WallCollisionData wcd = { 0 };
struct Surface *ceil;
@ -136,7 +136,7 @@ u32 perform_water_full_step(struct MarioState *m, Vec3f nextPos) {
}
/* |description|Calculates a water current and outputs it in `step`|descriptionEnd| */
void apply_water_current(struct MarioState *m, Vec3f step) {
void apply_water_current(struct MarioState *m, OUT Vec3f step) {
if (!m) { return; }
s32 i;
f32 whirlpoolRadius = 2000.0f;

2
src/game/obj_behaviors.c
View file

@ -760,7 +760,7 @@ s8 obj_check_if_facing_toward_angle(u32 base, u32 goal, s16 range) {
}
/* |description|Finds any wall collisions and returns what the displacement vector would be.|descriptionEnd| */
s8 obj_find_wall_displacement(Vec3f dist, f32 x, f32 y, f32 z, f32 radius) {
s8 obj_find_wall_displacement(OUT Vec3f dist, f32 x, f32 y, f32 z, f32 radius) {
struct WallCollisionData hitbox;
UNUSED u8 filler[0x20];

8
src/game/object_helpers.c
View file

@ -273,7 +273,7 @@ void obj_update_pos_from_parent_transformation(Mat4 a0, struct Object *a1) {
a1->oPosZ = spC * a0[0][2] + sp8 * a0[1][2] + sp4 * a0[2][2] + a0[3][2];
}
void obj_apply_scale_to_matrix(struct Object *obj, Mat4 dst, Mat4 src) {
void obj_apply_scale_to_matrix(struct Object *obj, OUT Mat4 dst, Mat4 src) {
if (obj == NULL) { return; }
dst[0][0] = src[0][0] * obj->header.gfx.scale[0];
dst[1][0] = src[1][0] * obj->header.gfx.scale[1];
@ -296,7 +296,7 @@ void obj_apply_scale_to_matrix(struct Object *obj, Mat4 dst, Mat4 src) {
dst[3][3] = src[3][3];
}
void create_transformation_from_matrices(Mat4 a0, Mat4 a1, Mat4 a2) {
void create_transformation_from_matrices(OUT Mat4 a0, Mat4 a1, Mat4 a2) {
f32 spC, sp8, sp4;
spC = a2[3][0] * a2[0][0] + a2[3][1] * a2[0][1] + a2[3][2] * a2[0][2];
@ -825,7 +825,7 @@ Multiplies a vector by a matrix of the form:
`| 0 0 0 1 |`
i.e. a matrix representing a linear transformation over 3 space
|descriptionEnd| */
void linear_mtxf_mul_vec3f(Mat4 m, Vec3f dst, Vec3f v) {
void linear_mtxf_mul_vec3f(Mat4 m, OUT Vec3f dst, Vec3f v) {
s32 i;
for (i = 0; i < 3; i++) {
dst[i] = m[0][i] * v[0] + m[1][i] * v[1] + m[2][i] * v[2];
@ -840,7 +840,7 @@ Multiplies a vector by the transpose of a matrix of the form:
`| 0 0 0 1 |`
i.e. a matrix representing a linear transformation over 3 space
|descriptionEnd| */
void linear_mtxf_transpose_mul_vec3f(Mat4 m, Vec3f dst, Vec3f v) {
void linear_mtxf_transpose_mul_vec3f(Mat4 m, OUT Vec3f dst, Vec3f v) {
s32 i;
for (i = 0; i < 3; i++) {
dst[i] = m[i][0] * v[0] + m[i][1] * v[1] + m[i][2] * v[2];

8
src/game/object_helpers.h
View file

@ -73,8 +73,8 @@ Gfx *geo_switch_area(s32 callContext, struct GraphNode *node);
#endif
Gfx *geo_choose_area_ext(s32 callContext, UNUSED struct GraphNode *node, Mat4 mtx);
void obj_update_pos_from_parent_transformation(Mat4 a0, struct Object *a1);
void obj_apply_scale_to_matrix(struct Object *obj, Mat4 dst, Mat4 src);
void create_transformation_from_matrices(Mat4 a0, Mat4 a1, Mat4 a2);
void obj_apply_scale_to_matrix(struct Object *obj, OUT Mat4 dst, Mat4 src);
void create_transformation_from_matrices(OUT Mat4 a0, Mat4 a1, Mat4 a2);
void obj_set_held_state(struct Object *obj, const BehaviorScript *heldBehavior);
f32 lateral_dist_between_objects(struct Object *obj1, struct Object *obj2);
f32 dist_between_objects(struct Object *obj1, struct Object *obj2);
@ -119,8 +119,8 @@ void obj_copy_pos_and_angle(struct Object *dst, struct Object *src);
void obj_copy_pos(struct Object *dst, struct Object *src);
void obj_copy_angle(struct Object *dst, struct Object *src);
void obj_set_gfx_pos_from_pos(struct Object *obj);
void linear_mtxf_mul_vec3f(Mat4 m, Vec3f dst, Vec3f v);
void linear_mtxf_transpose_mul_vec3f(Mat4 m, Vec3f dst, Vec3f v);
void linear_mtxf_mul_vec3f(Mat4 m, OUT Vec3f dst, Vec3f v);
void linear_mtxf_transpose_mul_vec3f(Mat4 m, OUT Vec3f dst, Vec3f v);
void obj_apply_scale_to_transform(struct Object *obj);
void obj_copy_scale(struct Object *dst, struct Object *src);
void obj_scale_xyz(struct Object* obj, f32 xScale, f32 yScale, f32 zScale);

2
src/game/rendering_graph_node.h
View file

@ -43,8 +43,6 @@ extern f32 gOverrideFar;
void geo_process_node_and_siblings(struct GraphNode *firstNode);
void geo_process_root(struct GraphNodeRoot *node, Vp *b, Vp *c, s32 clearColor);
void interpolate_vectors(Vec3f res, Vec3f a, Vec3f b);
void interpolate_vectors_s16(Vec3s res, Vec3s a, Vec3s b);
struct ShadowInterp {
Gfx* gfx;

2
src/game/save_file.c
View file

@ -791,7 +791,7 @@ void save_file_set_cap_pos(s16 x, s16 y, s16 z) {
save_file_set_flags(SAVE_FLAG_CAP_ON_GROUND);
}
s32 save_file_get_cap_pos(Vec3s capPos) {
s32 save_file_get_cap_pos(OUT Vec3s capPos) {
if (INVALID_FILE_INDEX(gCurrSaveFileNum - 1)) { return 0; }
if (INVALID_SRC_SLOT(gSaveFileUsingBackupSlot)) { return 0; }
struct SaveFile *saveFile = &gSaveBuffer.files[gCurrSaveFileNum - 1][gSaveFileUsingBackupSlot];

2
src/game/save_file.h
View file

@ -248,7 +248,7 @@ void save_file_set_cap_pos(s16 x, s16 y, s16 z);
Retrieves the current position of Mario's cap, if it is on the ground in the current level and area. The position is stored in the provided `capPos` parameter.
Useful for tracking the cap's location after it has been dropped or lost
|descriptionEnd| */
s32 save_file_get_cap_pos(Vec3s capPos);
s32 save_file_get_cap_pos(OUT Vec3s capPos);
void save_file_set_sound_mode(u16 mode);

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

@ -646,7 +646,7 @@ f32 djui_hud_get_fov_coeff() {
return (fovDefault / fovCurrent) * 1.13f;
}
bool djui_hud_world_pos_to_screen_pos(Vec3f pos, Vec3f out) {
bool djui_hud_world_pos_to_screen_pos(Vec3f pos, OUT Vec3f out) {
if (!gCamera) { return false; }
hud_rotate_and_translate_vec3f(pos, &gCamera->mtx, out);
if (out[2] >= 0.0f) {

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

@ -131,7 +131,7 @@ f32 get_current_fov();
/* |description|Gets the camera FOV coefficient|descriptionEnd| */
f32 djui_hud_get_fov_coeff();
/* |description|Converts a world position to screen position|descriptionEnd| */
bool djui_hud_world_pos_to_screen_pos(Vec3f pos, Vec3f out);
bool djui_hud_world_pos_to_screen_pos(Vec3f pos, OUT Vec3f out);
/* |description|Checks if the DJUI pause menu is created|descriptionEnd| */
bool djui_hud_is_pause_menu_created(void);

2
src/pc/gfx/gfx_pc.c
View file

@ -603,7 +603,7 @@ static void import_texture(int tile) {
//printf("Time diff: %d\n", t1 - t0);
}
static void OPTIMIZE_O3 gfx_transposed_matrix_mul(Vec3f res, const Vec3f a, const Mat4 b) {
static void OPTIMIZE_O3 gfx_transposed_matrix_mul(OUT Vec3f res, const Vec3f a, const Mat4 b) {
res[0] = a[0] * b[0][0] + a[1] * b[0][1] + a[2] * b[0][2];
res[1] = a[0] * b[1][0] + a[1] * b[1][1] + a[2] * b[1][2];
res[2] = a[0] * b[2][0] + a[1] * b[2][1] + a[2] * b[2][2];

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

@ -54,7 +54,7 @@ char gSmluaConstants[] = ""
"-- sound --\n"
"-----------\n"
"--- @type Vec3f\n"
"gGlobalSoundSource = { x = 0, y = 0, z = 0 }\n"
"gGlobalSoundSource = create_read_only_table({ x = 0, y = 0, z = 0 })\n"
"--- @param bank number\n"
"--- @param soundID number\n"
"--- @param priority number\n"

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

File diff suppressed because it is too large Load diff

2
src/pc/lua/utils/smlua_deprecated.c
View file

@ -34,7 +34,7 @@ void network_player_color_to_palette(struct NetworkPlayer *np, enum PlayerPart p
np->overridePalette = np->palette;
}
void network_player_palette_to_color(struct NetworkPlayer *np, enum PlayerPart part, Color out) {
void network_player_palette_to_color(struct NetworkPlayer *np, enum PlayerPart part, OUT Color out) {
LOG_LUA_LINE_WARNING("[LUA] network_player_palette_to_color() is deprecated! Use network_player_get_palette_color() or network_player_get_override_palette_color() instead.");
if (np == NULL || !(part < PLAYER_PART_MAX && part >= 0)) {
if (np == NULL) { // output config palette instead if np is NULL

2
src/pc/lua/utils/smlua_deprecated.h
View file

@ -13,4 +13,4 @@ void audio_stream_set_speed(struct ModAudio* audio, f32 initial_freq, f32 speed,
/* |description|[DEPRECATED: Use `network_player_set_override_palette_color` instead]|descriptionEnd| */
void network_player_color_to_palette(struct NetworkPlayer *np, enum PlayerPart part, Color color);
/* |description|[DEPRECATED: Use `network_player_get_palette_color` or `network_player_get_override_palette_color` instead]|descriptionEnd| */
void network_player_palette_to_color(struct NetworkPlayer *np, enum PlayerPart part, Color out);
void network_player_palette_to_color(struct NetworkPlayer *np, enum PlayerPart part, OUT Color out);

2
src/pc/lua/utils/smlua_misc_utils.c
View file

@ -322,7 +322,7 @@ f32 get_hand_foot_pos_z(struct MarioState* m, u8 index) {
return m->marioBodyState->animPartsPos[sHandFootToAnimParts[index]][2];
}
bool get_mario_anim_part_pos(struct MarioState *m, u32 animPart, Vec3f pos) {
bool get_mario_anim_part_pos(struct MarioState *m, u32 animPart, OUT Vec3f pos) {
if (!m) { return false; }
if (animPart >= MARIO_ANIM_PART_MAX) { return false; }
vec3f_copy(pos, m->marioBodyState->animPartsPos[animPart]);

2
src/pc/lua/utils/smlua_misc_utils.h
View file

@ -136,7 +136,7 @@ f32 get_hand_foot_pos_z(struct MarioState* m, u8 index);
/* |description|
Retrieves the animated part position associated to `animPart` from the MarioState `m` and stores it into `pos`. Returns `true` on success or `false` on failure
|descriptionEnd| */
bool get_mario_anim_part_pos(struct MarioState *m, u32 animPart, Vec3f pos);
bool get_mario_anim_part_pos(struct MarioState *m, u32 animPart, OUT Vec3f pos);
/* |description|Gets the current save file number (1-indexed)|descriptionEnd| */
s16 get_current_save_file_num(void);

4
src/pc/utils/misc.c
View file

@ -135,14 +135,14 @@ s32 delta_interpolate_s32(s32 a, s32 b, f32 delta) {
return a * (1.0f - delta) + b * delta;
}
void delta_interpolate_vec3f(Vec3f res, Vec3f a, Vec3f b, f32 delta) {
void delta_interpolate_vec3f(OUT Vec3f res, Vec3f a, Vec3f b, f32 delta) {
f32 antiDelta = 1.0f - delta;
res[0] = ((a[0] * antiDelta) + (b[0] * delta));
res[1] = ((a[1] * antiDelta) + (b[1] * delta));
res[2] = ((a[2] * antiDelta) + (b[2] * delta));
}
void delta_interpolate_vec3s(Vec3s res, Vec3s a, Vec3s b, f32 delta) {
void delta_interpolate_vec3s(OUT Vec3s res, Vec3s a, Vec3s b, f32 delta) {
f32 antiDelta = 1.0f - delta;
res[0] = ((a[0] * antiDelta) + (b[0] * delta));
res[1] = ((a[1] * antiDelta) + (b[1] * delta));

4
src/pc/utils/misc.h
View file

@ -26,9 +26,9 @@ f32 delta_interpolate_f32(f32 a, f32 b, f32 delta);
/* |description|Linearly interpolates between `a` and `b` with `delta`|descriptionEnd| */
s32 delta_interpolate_s32(s32 a, s32 b, f32 delta);
/* |description|Linearly interpolates `res` between `a` and `b` with `delta`|descriptionEnd| */
void delta_interpolate_vec3f(Vec3f res, Vec3f a, Vec3f b, f32 delta);
void delta_interpolate_vec3f(OUT Vec3f res, Vec3f a, Vec3f b, f32 delta);
/* |description|Linearly interpolates `res` between `a` and `b` with `delta`|descriptionEnd| */
void delta_interpolate_vec3s(Vec3s res, Vec3s a, Vec3s b, f32 delta);
void delta_interpolate_vec3s(OUT Vec3s res, Vec3s a, Vec3s b, f32 delta);
void delta_interpolate_normal(s8* res, s8* a, s8* b, f32 delta);
void delta_interpolate_rgba(u8* res, u8* a, u8* b, f32 delta);
void delta_interpolate_mtx(Mtx* out, Mtx* a, Mtx* b, f32 delta);