![]() |
Jo Engine 2026.11.6
Jo Sega Saturn Engine
|
Jo Engine Math tools. More...
Go to the source code of this file.
Macros | |
| #define | JO_PI |
| PI value. | |
| #define | JO_PI_2 |
| PI/2 value. | |
| #define | JO_MULT_BY_2(X) |
| Multiply a variable by 2. | |
| #define | JO_MULT_BY_4(X) |
| Multiply a variable by 4. | |
| #define | JO_MULT_BY_8(X) |
| Multiply a variable by 8. | |
| #define | JO_MULT_BY_16(X) |
| Multiply a variable by 16. | |
| #define | JO_MULT_BY_32(X) |
| Multiply a variable by 32. | |
| #define | JO_MULT_BY_64(X) |
| Multiply a variable by 64. | |
| #define | JO_MULT_BY_128(X) |
| Multiply a variable by 128. | |
| #define | JO_MULT_BY_256(X) |
| Multiply a variable by 256. | |
| #define | JO_MULT_BY_512(X) |
| Multiply a variable by 512. | |
| #define | JO_MULT_BY_1024(X) |
| Multiply a variable by 1024. | |
| #define | JO_MULT_BY_2048(X) |
| Multiply a variable by 2048. | |
| #define | JO_MULT_BY_4096(X) |
| Multiply a variable by 4096. | |
| #define | JO_MULT_BY_32768(X) |
| Multiply a variable by 32768. | |
| #define | JO_MULT_BY_65536(X) |
| Multiply a variable by 65536. | |
| #define | JO_DIV_BY_2(X) |
| Devide a variable by 2. | |
| #define | JO_DIV_BY_4(X) |
| Devide a variable by 4. | |
| #define | JO_DIV_BY_8(X) |
| Devide a variable by 8. | |
| #define | JO_DIV_BY_16(X) |
| Devide a variable by 16. | |
| #define | JO_DIV_BY_32(X) |
| Devide a variable by 32. | |
| #define | JO_DIV_BY_64(X) |
| Devide a variable by 64. | |
| #define | JO_DIV_BY_128(X) |
| Devide a variable by 128. | |
| #define | JO_DIV_BY_256(X) |
| Devide a variable by 256. | |
| #define | JO_DIV_BY_512(X) |
| Devide a variable by 512. | |
| #define | JO_DIV_BY_1024(X) |
| Devide a variable by 1024. | |
| #define | JO_DIV_BY_32768(X) |
| Devide a variable by 32768. | |
| #define | JO_DIV_BY_65536(X) |
| Devide a variable by 65536. | |
| #define | JO_DIV_BY_2147483648(X) |
| Devide a variable by 2147483648. | |
| #define | JO_ZERO(X) |
| Set a variable to zero. | |
| #define | JO_MOD_POW2(N, M) |
| Fast modulo of a power of 2. | |
| #define | JO_IS_POW2(N) |
| Fast check if N of a power of 2. | |
| #define | JO_ABS(X) |
| Get the absolute value of X. | |
| #define | JO_FABS(X) |
| Get the absolute value of X. | |
| #define | JO_MIN(A, B) |
| Get the smaller value between A and B. | |
| #define | JO_MAX(A, B) |
| Get the bigger value between A and B. | |
| #define | JO_CLAMP(X, MIN, MAX) |
| Keep X between MIN and MAX. | |
| #define | JO_CHANGE_SIGN(X) |
| Change the sign of X. | |
| #define | JO_FLOAT_EPSILON |
| Float minimum positive value. | |
| #define | JO_FLOAT_NEARLY_EQUALS(A, B) |
| Check if A and B is nearly the same value. | |
| #define | JO_IS_FLOAT_NULL(A) |
| Check if A nearly equals zero. | |
| #define | JO_RAD_TO_DEG(A) |
| Convert radians to degrees. | |
| #define | JO_DEG_TO_RAD(A) |
| Convert degrees to radians. | |
| #define | JO_IS_ODD(A) |
| Check if A is odd. | |
| #define | JO_SWAP(A, B) |
| Swap A and B values. | |
| #define | JO_OPAQUE(VAR) |
| Hide the value of a variable from the optimizer of the compiler (no instruction). | |
| #define | JO_PERCENT_USED(TOTAL, FREE) |
| Compute percent ((TOTAL - FREE) x 100 / TOTAL, rounded down). | |
| #define | JO_SQUARE(A) |
| Square computation (x²). | |
| #define | JO_BCD_INT(BCD) |
| BCD to integer. | |
| #define | JO_SET_FLAGS(BYTEFIELD, FLAGS) |
| Set flags in bytefield. | |
| #define | JO_SET_ALL_FLAGS(BYTEFIELD) |
| Set all flags in bytefield. | |
| #define | JO_ADD_FLAG(BYTEFIELD, FLAG) |
| Add flag in bytefield. | |
| #define | JO_REMOVE_FLAG(BYTEFIELD, FLAG) |
| Remove flag in bytefield. | |
| #define | JO_REMOVE_ALL_FLAGS(BYTEFIELD) |
| Remove all flags in bytefield. | |
| #define | JO_HAS_FLAG(BYTEFIELD, FLAG) |
| Check if flag is checked in bytefield. | |
| #define | JO_FIXED_0 |
| Fixed floating point value for 0. | |
| #define | JO_FIXED_1_DIV_2 |
| Fixed floating point value for 0.5. | |
| #define | JO_FIXED_ALMOST_1 |
| Fixed floating point value for 0.999. | |
| #define | JO_FIXED_1 |
| Fixed floating point value for 1. | |
| #define | JO_FIXED_2 |
| Fixed floating point value for 2. | |
| #define | JO_FIXED_3 |
| Fixed floating point value for 3. | |
| #define | JO_FIXED_4 |
| Fixed floating point value for 4. | |
| #define | JO_FIXED_8 |
| Fixed floating point value for 8. | |
| #define | JO_FIXED_16 |
| Fixed floating point value for 16. | |
| #define | JO_FIXED_32 |
| Fixed floating point value for 32. | |
| #define | JO_FIXED_120 |
| Fixed floating point value for 120. | |
| #define | JO_FIXED_150 |
| Fixed floating point value for 150. | |
| #define | JO_FIXED_180 |
| Fixed floating point value for 180. | |
| #define | JO_FIXED_360 |
| Fixed floating point value for 360. | |
| #define | JO_FIXED_MIN |
| Fixed floating point value for -32767.99998. | |
| #define | JO_FIXED_MAX |
| Fixed floating point value for +32767.99998. | |
| #define | JO_FIXED_EPSILON |
| Jo Fixed minimum positive value. | |
| #define | JO_FIXED_OVERFLOW |
| Indicate an overflow error. | |
| #define | JO_FIXED_PI |
| Fixed value of PI. | |
| #define | JO_FIXED_PI_2 |
| Fixed value of 2 PI. | |
| #define | JO_FIXED_180_DIV_PI |
| Fixed value of 180/PI. | |
| #define | JO_FIXED_PI_DIV_180 |
| Fixed value of PI/180. | |
| #define | JO_FIXED_PI_DIV_2 |
| Fixed value of PI/2. | |
| #define | JO_FIXED_PI_OVER_2 |
| Fixed value of PI/2. | |
| #define | JO_FIXED_3_PI_OVER_2 |
| Fixed value of 3 PI / 2. | |
| #define | JO_FIXED_1_DIV |
| Fixed value of 1/65536. | |
| #define | JO_INT_TO_FIXED(X) |
| Convert int to jo_fixed. | |
| #define | JO_FIXED_TO_INT(X) |
| Convert jo_fixed to int. | |
| #define | JO_FIXED_DECIMAL_MASK |
| Decimal part mask of a jo_fixed. | |
| #define | JO_FLOAT_TO_FIXED(X) |
| Convert a float to jo_fixed. | |
| #define | JO_DEG_TO_ANGLE(X) |
| Convert a degree to jo_angle. | |
| #define | JO_RAD_TO_ANGLE(X) |
| Convert a radian to jo_angle. | |
| #define | __JO_DEG_TO_ANGLE_MAGIC |
| See https://github.com/johannes-fetz/joengine/issues/42. | |
Functions | |
| static __jo_force_inline jo_fixed | jo_int2fixed (const int x) |
| Convert int to jo engine fixed. | |
| static __jo_force_inline int | jo_fixed2int (const jo_fixed x) |
| Convert jo engine fixed to int. | |
| static __jo_force_inline unsigned int | __jo_float_bits (const float f) |
| The bits of a float (Internal usage). | |
| static __jo_force_inline float | __jo_float_from_bits (const unsigned int i) |
| A float from its bits (Internal usage). | |
| jo_fixed | __jo_float_to_fixed (const float x) |
| Convert float to jo engine fixed at run time (Internal usage, see jo_float2fixed()). | |
| float | __jo_fixed_to_float (const jo_fixed x) |
| Convert jo engine fixed to float at run time (Internal usage, see jo_fixed2float()). | |
| static __jo_force_inline jo_fixed | jo_float2fixed (const float x) |
| Convert float to jo engine fixed (avoid usage of GCC Soft Float). | |
| static __jo_force_inline float | jo_fixed2float (const jo_fixed x) |
| Convert jo engine fixed to float. | |
| float | __jo_float_scale2 (const float x, const int shift) |
| A float times 2^shift, in integers on its bits (Internal usage). | |
| static __jo_force_inline int | __jo_float_sign (const float x) |
| The sign of a float, in integers on its bits (Internal usage). | |
| int | __jo_floats_to_fixed_scaled (const float *const in, jo_fixed *const out, const int count, const int top) |
| Convert floats to fixed numbers with the same power of 2 for all, in integers (Internal usage). | |
| jo_angle | __jo_atan2_floats (const float y, const float x) |
| The angle of a vector of 2 floats (Internal usage, see jo_atan2f_rad()). | |
| static __jo_force_inline jo_fixed | __jo_angle_to_fixed_rad (const jo_angle angle) |
| Convert jo_angle to fixed radian (Internal usage). | |
| static __jo_force_inline jo_fixed | jo_fixed_wrap_to_pi (jo_fixed rad) |
| Wrap rad in [−pi pi]. | |
| static __jo_force_inline jo_fixed | jo_fixed_wrap_to_180 (jo_fixed deg) |
| Wrap deg in [-180 180]. | |
| jo_fixed | jo_fixed_pow (jo_fixed x, jo_fixed y) |
| x raised to the power of the integer part of y | |
| static __jo_force_inline jo_fixed | jo_fixed_mult (const jo_fixed x, const jo_fixed y) |
| Multiply to fixed number. | |
| static __jo_force_inline int | jo_fixed_mult_to_int (const jo_fixed x, const jo_fixed y) |
| Multiply to fixed number and keep the integer part: jo_fixed2int(jo_fixed_mult(x, y)), without overflow. | |
| static __jo_force_inline jo_fixed | jo_fixed_dot (const jo_fixed ptA[3], const jo_fixed ptB[3]) |
| Dot product two fixed 3D points. | |
| static __jo_force_inline jo_fixed | jo_fixed_div (const jo_fixed dividend, const jo_fixed divisor) |
| Divide fixed-point numbers (expresses dividend / divisor). | |
| static __jo_force_inline int | jo_int_div (const int dividend, const int divisor) |
| Divide 2 integers (dividend / divisor, rounded toward 0 as in C). | |
| static __jo_force_inline int | jo_shift_right8 (const int x) |
| Arithmetic right shift by 8 bits (x >> 8, rounded toward minus infinity) of any value. | |
| static __jo_force_inline int | jo_shift_right8_small (const int x) |
| Arithmetic right shift by 8 bits (x >> 8) of a value in [-2^23, 2^23) (a 16 bits value x 0 to 256 for example). | |
| static __jo_force_inline void | jo_fixed_div_start (const jo_fixed dividend, const jo_fixed divisor) |
| Start a fixed-point division in the background (see jo_fixed_div_result()). | |
| static __jo_force_inline jo_fixed | jo_fixed_div_result (void) |
| Get the result of the division started by jo_fixed_div_start(). | |
| static __jo_force_inline jo_fixed | jo_fixed_deg2rad (const jo_fixed deg) |
| Convert fixed degree to fixed radian. | |
| static __jo_force_inline jo_fixed | jo_fixed_rad2deg (const jo_fixed rad) |
| Convert fixed radian to fixed degree. | |
| static __jo_force_inline jo_fixed | jo_fixed_ceil (const jo_fixed x) |
| Returns the smallest (fixed) integer value greater than or equal to x. | |
| static __jo_force_inline jo_fixed | jo_fixed_floor (const jo_fixed x) |
| Returns the largest (fixed) integer value less than or equal to x. | |
| int | jo_random (int max) |
| Get a random number. | |
| static __jo_force_inline int | jo_random_using_multiple (int max, int multiple) |
| Get a random number with a specific multiple. | |
| static __jo_force_inline int | jo_random_seeded (unsigned int *const seed) |
| Get a random number of a sequence of its own (the effects of a game: the same at each run, whatever the other calls of jo_random()). | |
| static __jo_force_inline unsigned int | jo_highest_bit (unsigned int x) |
| Index of the highest bit set in a value (31 - number of leading zeros). | |
| jo_fixed | jo_fixed_sqrt (jo_fixed value) |
| Fast Square root using fixed number. | |
| unsigned int | jo_sqrt (unsigned int value) |
| Fast square root. | |
| static __jo_force_inline float | jo_sqrtf (float value) |
| Fast Square root using floating number. | |
| jo_fixed | jo_fixed_rsqrt (jo_fixed value) |
| Fast Reciprocal Square root using fixed number. | |
| float | jo_rsqrt (float value) |
| Fast Reciprocal Square root using floating number. | |
| static __jo_force_inline jo_angle | jo_DEGtoANG (const float deg) |
| Convert a degree to jo_angle using floating number. | |
| static __jo_force_inline jo_angle | jo_DEGtoANG_int (const int deg) |
| Convert a degree to jo_angle using interger. | |
| static __jo_force_inline jo_angle | jo_fixed_rad2ANGLE (const jo_fixed rad) |
| Convert fixed radian to jo_angle. | |
| static __jo_force_inline jo_fixed | __jo_sin_index (const unsigned int index) |
| Sinus of a table index (Internal usage). | |
| static __jo_force_inline unsigned int | __jo_angle_to_sin_index (const jo_angle angle) |
| Table index of an angle (Internal usage). | |
| static __jo_force_inline jo_fixed | jo_sin_angle (const jo_angle angle) |
| Sinus of an angle (table lookup, fast). | |
| static __jo_force_inline jo_fixed | jo_cos_angle (const jo_angle angle) |
| Cosinus of an angle (table lookup, fast). | |
| static __jo_force_inline void | jo_sincos_angle (const jo_angle angle, jo_fixed *const sin_value, jo_fixed *const cos_value) |
| Sinus and cosinus of the same angle (table lookup, fast). | |
| static __jo_force_inline jo_angle | jo_fixed_deg2ANGLE (const jo_fixed deg) |
| Convert fixed degree to jo_angle. | |
| static __jo_force_inline jo_fixed | jo_fixed_sin (const jo_fixed rad) |
| Fast sinus computation using fixed number. | |
| static __jo_force_inline jo_fixed | jo_sin (const int deg) |
| Fast sinus computation. | |
| static __jo_force_inline float | jo_sinf (const int deg) |
| Sinus computation. | |
| static __jo_force_inline jo_fixed | jo_sin_rad (const float rad) |
| Sinus computation. | |
| static __jo_force_inline float | jo_sin_radf (const float rad) |
| Sinus computation. | |
| static __jo_force_inline int | jo_sin_mult (const int value, const int deg) |
| Fast sinus multiplication. | |
| static __jo_force_inline float | jo_sinf_mult (const float value, const int deg) |
| Fast sinus multiplication. | |
| static __jo_force_inline jo_fixed | jo_fixed_cos (const jo_fixed rad) |
| Fast cosinus computation using fixed number. | |
| static __jo_force_inline jo_fixed | jo_cos (const int deg) |
| Fast cosinus computation. | |
| static __jo_force_inline void | jo_sincos (const int deg, jo_fixed *const sin_value, jo_fixed *const cos_value) |
| Sinus and cosinus of the same angle in degree (table lookup, fast). | |
| static __jo_force_inline float | jo_cosf (const int deg) |
| Cosinus computation. | |
| static __jo_force_inline jo_fixed | jo_cos_rad (const float rad) |
| Cosinus computation. | |
| static __jo_force_inline float | jo_cos_radf (const float rad) |
| Cosinus computation. | |
| static __jo_force_inline int | jo_cos_mult (const int value, const int deg) |
| Fast cosinus multiplication. | |
| static __jo_force_inline float | jo_cosf_mult (const float value, const int deg) |
| Fast cosinus multiplication. | |
| static __jo_force_inline jo_fixed | jo_tan (const int deg) |
| Fast tangent computation. | |
| static __jo_force_inline jo_fixed | jo_tan_angle (const jo_angle angle) |
| Fast tangent of a jo_angle (table lookup and the division unit). | |
| static __jo_force_inline float | jo_tanf (const float deg) |
| Tangent computation. | |
| static __jo_force_inline jo_fixed | jo_tan_rad (const float rad) |
| Tangent computation. | |
| static __jo_force_inline float | jo_tan_radf (const float rad) |
| Tangent computation. | |
| jo_fixed | __jo_acos_fixed_rad (jo_fixed cosinus) |
| Arc cosinus in fixed numbers (Internal usage, see jo_acos_radf()). | |
| static __jo_force_inline float | jo_acos_radf (const float angle) |
| Fast Arc Cosinus computation. | |
| float | jo_atan2f_rad (const float y, const float x) |
| Fast ATAN2 computation in radian. | |
| static __jo_force_inline int | jo_atan2f (const float y, const float x) |
| Fast ATAN2 computation in degree. | |
| static __jo_force_inline jo_angle | jo_atan2_angle (const float y, const float x) |
| ATAN2 as a jo_angle (65536 per turn, like jo_sin_angle() and the rotations of the 3D). | |
| jo_angle | jo_atan2_fixed (const jo_fixed y, const jo_fixed x) |
| ATAN2 as a jo_angle without floating point (fixed numbers). | |
| int | jo_atan2_degrees (const jo_fixed y, const jo_fixed x) |
| ATAN2 in degree without floating point (fixed numbers). | |
| static __jo_force_inline int | __jo_wrap_360 (const int deg) |
| An angle in degree brought in 0 to 359 (Internal usage). | |
| static __jo_force_inline int | jo_turn_toward (const int angle, const int target, const int max_step) |
| Turn an angle toward another angle, by the shortest way. | |
| void | jo_vector_fixed_compute_bezier_point (const jo_fixed t, jo_vector_fixed p0, jo_vector_fixed p1, jo_vector_fixed p2, jo_vector_fixed p3, jo_vector_fixed *result) |
| Compute cubic bezier curve point for vectors (using fixed numbers). | |
| static __jo_force_inline void | jo_vector_fixed_add (const jo_vector_fixed *const a, const jo_vector_fixed *const b, jo_vector_fixed *const result) |
| Add 2 vectors (using fixed numbers). | |
| static __jo_force_inline void | jo_vector_fixed_muls (const jo_vector_fixed *const a, const jo_fixed s, jo_vector_fixed *const result) |
| Multiply value to vector (using fixed numbers). | |
| static __jo_force_inline void | jo_vector_fixed_sub (const jo_vector_fixed *const a, const jo_vector_fixed *const b, jo_vector_fixed *const result) |
| Substract 2 vectors (using fixed numbers). | |
| static __jo_force_inline jo_fixed | jo_vector_fixed_dot (const jo_vector_fixed *const a, const jo_vector_fixed *const b) |
| Dot product of 2 vectors (using fixed numbers). | |
| static __jo_force_inline void | jo_vector_fixed_cross (const jo_vector_fixed *const a, const jo_vector_fixed *const b, jo_vector_fixed *const result) |
| Cross product of 2 vectors (using fixed numbers). | |
| jo_fixed | jo_vector_fixed_length (const jo_vector_fixed *const a) |
| Length of a vector (using fixed numbers). | |
| void | jo_vector_fixed_normalize (const jo_vector_fixed *const a, jo_vector_fixed *const result) |
| Normalize a vector (using fixed numbers). | |
| static __jo_force_inline void | jo_vector4_fixed_add (const jo_vector4_fixed *const a, const jo_vector4_fixed *const b, jo_vector4_fixed *const result) |
| Add 2 vectors4 (using fixed numbers). | |
| static __jo_force_inline void | jo_vector4_fixed_sub (const jo_vector4_fixed *const a, const jo_vector4_fixed *const b, jo_vector4_fixed *const result) |
| Substract 2 vectors4 (using fixed numbers). | |
| static __jo_force_inline void | jo_vector4_fixed_cross (const jo_vector4_fixed *const a, const jo_vector4_fixed *const b, jo_vector4_fixed *const result) |
| Cross product of 2 vectors4 (using fixed numbers). | |
| static __jo_force_inline jo_fixed | jo_vector4_fixed_dot (const jo_vector4_fixed *const a, const jo_vector4_fixed *const b) |
| Dot product of 2 vectors4 (using fixed numbers). | |
| static __jo_force_inline void | jo_vector4_swap (jo_vector4_fixed *const a, jo_vector4_fixed *const b) |
| Swap 2 vectors4 (using fixed numbers). | |
| void | jo_vectorf_compute_bezier_point (const float t, jo_vectorf p0, jo_vectorf p1, jo_vectorf p2, jo_vectorf p3, jo_vectorf *result) |
| Compute cubic bezier curve point for vectors (using floating numbers). | |
| void | jo_vectorf_add (const jo_vectorf *const a, const jo_vectorf *const b, jo_vectorf *const result) |
| Add 2 vectors (using floating numbers). | |
| void | jo_vectorf_adds (const jo_vectorf *const a, const float s, jo_vectorf *const result) |
| Add value to vector (using floating numbers). | |
| void | jo_vectorf_sub (const jo_vectorf *const a, const jo_vectorf *const b, jo_vectorf *const result) |
| Subtract 2 vectors (using floating numbers). | |
| void | jo_vectorf_subs (const jo_vectorf *const a, const float s, jo_vectorf *const result) |
| Subtract value to vector (using floating numbers). | |
| void | jo_vectorf_mul (const jo_vectorf *const a, const jo_vectorf *const b, jo_vectorf *const result) |
| Multiply 2 vectors (using floating numbers). | |
| void | jo_vectorf_muls (const jo_vectorf *const a, const float s, jo_vectorf *const result) |
| Multiply value to vector (using floating numbers). | |
| void | jo_vectorf_div (const jo_vectorf *const a, const jo_vectorf *const b, jo_vectorf *const result) |
| Divide 2 vectors (using floating numbers). | |
| void | jo_vectorf_divs (const jo_vectorf *const a, const float s, jo_vectorf *const result) |
| Divide value to vector (using floating numbers). | |
| float | jo_vectorf_length (const jo_vectorf *const a) |
| Get the length of a vector (using floating numbers). | |
| float | jo_vectorf_dot (const jo_vectorf *const a, const jo_vectorf *const b) |
| Get the dot product of 2 vectors (using floating numbers). | |
| void | jo_vectorf_normalize (const jo_vectorf *const a, jo_vectorf *const result) |
| Normalize a vector (using floating numbers). | |
| void | jo_vectorf_proj (const jo_vectorf *const v, const jo_vectorf *const onto, jo_vectorf *const result) |
| Compute projection vector (using floating numbers). | |
| void | jo_vectorf_cross (const jo_vectorf *const a, const jo_vectorf *const b, jo_vectorf *const result) |
| Cross 2 vectors (using floating numbers). | |
| float | jo_vectorf_angle_between_radf (const jo_vectorf *const a, const jo_vectorf *const b) |
| Get the angle between 2 vectors (using floating numbers). | |
| static __jo_force_inline void | jo_matrix_identity (jo_matrix *const result) |
| Creates the identity matrix (using fixed numbers). | |
| static __jo_force_inline void | jo_matrixf_identity (jo_matrixf *const result) |
| Creates the identity matrix (using floating numbers). | |
| static __jo_force_inline void | jo_matrix_translation (const jo_vector_fixed *const offset, jo_matrix *const result) |
| Creates translation matrix (using fixed numbers). | |
| static __jo_force_inline void | jo_matrixf_translation (const jo_vectorf *const offset, jo_matrixf *const result) |
| Creates translation matrix (using floating numbers). | |
| static __jo_force_inline void | jo_matrix_scaling (const jo_vector_fixed *const scale, jo_matrix *const result) |
| Creates scaling matrix (using fixed numbers). | |
| static __jo_force_inline void | jo_matrixf_scaling (const jo_vectorf *const scale, jo_matrixf *const result) |
| Creates scaling matrix (using floating numbers). | |
| static __jo_force_inline void | jo_matrix_rotation_x_angle (const jo_angle angle, jo_matrix *const result) |
| Rotation matrix around the X axis (using fixed numbers). | |
| static __jo_force_inline void | jo_matrix_rotation_x_rad (const float angle_in_rad, jo_matrix *const result) |
| Rotation matrix around the X axis (radian, using floating numbers: converted, then jo_matrix_rotation_x_angle()). | |
| static __jo_force_inline void | jo_matrixf_rotation_x_rad (const float angle_in_rad, jo_matrixf *const result) |
| Creates rotating matrix (X axis) (using floating numbers). | |
| static __jo_force_inline void | jo_matrix_rotation_y_angle (const jo_angle angle, jo_matrix *const result) |
| Rotation matrix around the Y axis (using fixed numbers). | |
| static __jo_force_inline void | jo_matrix_rotation_y_rad (const float angle_in_rad, jo_matrix *const result) |
| Rotation matrix around the Y axis (radian, using floating numbers: converted, then jo_matrix_rotation_y_angle()). | |
| static __jo_force_inline void | jo_matrixf_rotation_y_rad (const float angle_in_rad, jo_matrixf *const result) |
| Creates rotating matrix (Y axis) (using floating numbers). | |
| static __jo_force_inline void | jo_matrix_rotation_z_angle (const jo_angle angle, jo_matrix *const result) |
| Rotation matrix around the Z axis (using fixed numbers). | |
| static __jo_force_inline void | jo_matrix_rotation_z_rad (const float angle_in_rad, jo_matrix *const result) |
| Rotation matrix around the Z axis (radian, using floating numbers: converted, then jo_matrix_rotation_z_angle()). | |
| static __jo_force_inline void | jo_matrixf_rotation_z_rad (const float angle_in_rad, jo_matrixf *const result) |
| Creates rotating matrix (Z axis) (using floating numbers). | |
| static __jo_force_inline void | jo_matrix_transpose (const jo_matrix *const matrix, jo_matrix *const result) |
| Creates transpose matrix (using fixed numbers). | |
| static __jo_force_inline void | jo_matrixf_transpose (const jo_matrixf *const matrix, jo_matrixf *const result) |
| Creates transpose matrix (using floating numbers). | |
| static __jo_force_inline jo_fixed | __jo_fixed_dot4 (const jo_fixed ptA[4], const jo_fixed ptB[4]) |
| Dot product of 2 vectors of 4 fixed numbers (Internal usage). | |
| static __jo_force_inline void | jo_matrix_mul_vector4 (const jo_matrix *const m, const jo_vector4_fixed *const v, jo_vector4_fixed *const result) |
| Multiply a matrix by a vector4 (using fixed numbers). | |
| static __jo_force_inline void | jo_matrix_mul (const jo_matrix *const a, const jo_matrix *const b, jo_matrix *const result) |
| Multiply 2 matrix (using fixed numbers). | |
| void | jo_matrixf_mul (const jo_matrixf *const a, const jo_matrixf *const b, jo_matrixf *const result) |
| Multiply 2 matrix (using floating numbers). | |
| void | jo_matrixf_rotation (const float angle_in_rad, const jo_vectorf *const axis, jo_matrixf *const result) |
| Creates a matrix to rotate around an axis by a given angle in radiant (using floating numbers). | |
| void | jo_matrixf_ortho (const float left, const float right, const float bottom, const float top, const float back, const float front, jo_matrixf *const result) |
| Creates an orthographic projection matrix (using floating numbers). | |
| void | jo_matrixf_perspective (const float vertical_field_of_view_in_deg, const float aspect_ratio, const float near_view_distance, const float far_view_distance, jo_matrixf *const result) |
| Creates a perspective projection matrix for a camera (using floating numbers). | |
| void | jo_matrixf_look_at (const jo_vectorf *const from, const jo_vectorf *const to, const jo_vectorf *const up, jo_matrixf *const result) |
| Builds a transformation matrix for a camera (using floating numbers). | |
| void | jo_matrixf_invert_affine (const jo_matrixf *const matrix, jo_matrixf *const result) |
| Inverts an affine transformation matrix (using floating numbers). | |
| void | jo_matrixf_mul_pos (const jo_matrixf *const matrix, const jo_vectorf *const position, jo_vectorf *const result) |
| Multiplies a 4x4 matrix with a 3D vector representing a point in 3D space (using floating numbers). | |
| void | jo_matrixf_mul_dir (const jo_matrixf *const matrix, const jo_vectorf *const direction, jo_vectorf *const result) |
| Multiplies a 4x4 matrix with a 3D vector representing a direction in 3D space (using floating numbers). | |
| static __jo_force_inline jo_fixed | jo_lerp (const jo_fixed v0, const jo_fixed v1, const jo_fixed t) |
| Linear interpolation which guarantees v = v1 when t = 1. | |
| static __jo_force_inline bool | jo_is_float_equals_zero (const float f) |
| Check if float almost equals 0. | |
| static __jo_force_inline bool | jo_square_intersect (const int x1, const int y1, const int w1, const int h1, const int x2, const int y2, const int w2, const int h2) |
| Fast method to get if two square intersects (HitBox processing). | |
| int | jo_gcd (int a, int b) |
| Get the greatest common divisor. | |
| void | jo_planar_rotate (const jo_pos2D *const point, const jo_pos2D *const origin, const int angle, jo_pos2D *const result) |
| Rotate a point on the plan with a specific origin. | |
| static __jo_force_inline short | jo_direction_to_angle (const jo_8_directions direction) |
| Convert jo_8_directions to angle in degree. | |
Variables | |
| int | jo_random_seed |
| Get or set current random seed. | |
| const jo_fixed | __jo_sin_table [1025] |
| Sinus table: sin(x) for x in [0, pi/2] (1024 steps, Q16.16) (Internal usage, see math.c). | |
| #define __JO_DEG_TO_ANGLE_MAGIC |
| #define JO_ABS | ( | X | ) |
Get the absolute value of X.
| X | Variable name |
| #define JO_ADD_FLAG | ( | BYTEFIELD, | |
| FLAG ) |
Add flag in bytefield.
| BYTEFIELD | Bytefield |
| FLAG | Flag |
| #define JO_BCD_INT | ( | BCD | ) |
BCD to integer.
| BCD | BCD |
| #define JO_CHANGE_SIGN | ( | X | ) |
Change the sign of X.
| X | Variable name |
| #define JO_CLAMP | ( | X, | |
| MIN, | |||
| MAX ) |
Keep X between MIN and MAX.
| X | Value |
| MIN | Smallest value |
| MAX | Biggest value (MAX >= MIN) |
| #define JO_DEG_TO_ANGLE | ( | X | ) |
Convert a degree to jo_angle.
| X | Degree (constant expression friendly, usable in static initializers) |
| #define JO_DEG_TO_RAD | ( | A | ) |
Convert degrees to radians.
| A | operand |
| #define JO_DIV_BY_1024 | ( | X | ) |
Devide a variable by 1024.
| X | Variable name |
| #define JO_DIV_BY_128 | ( | X | ) |
Devide a variable by 128.
| X | Variable name |
| #define JO_DIV_BY_16 | ( | X | ) |
Devide a variable by 16.
| X | Variable name |
| #define JO_DIV_BY_2 | ( | X | ) |
Devide a variable by 2.
| X | Variable name |
| #define JO_DIV_BY_2147483648 | ( | X | ) |
Devide a variable by 2147483648.
| X | Variable name |
| #define JO_DIV_BY_256 | ( | X | ) |
Devide a variable by 256.
| X | Variable name |
| #define JO_DIV_BY_32 | ( | X | ) |
Devide a variable by 32.
| X | Variable name |
| #define JO_DIV_BY_32768 | ( | X | ) |
Devide a variable by 32768.
| X | Variable name |
| #define JO_DIV_BY_4 | ( | X | ) |
Devide a variable by 4.
| X | Variable name |
| #define JO_DIV_BY_512 | ( | X | ) |
Devide a variable by 512.
| X | Variable name |
| #define JO_DIV_BY_64 | ( | X | ) |
Devide a variable by 64.
| X | Variable name |
| #define JO_DIV_BY_65536 | ( | X | ) |
Devide a variable by 65536.
| X | Variable name |
| #define JO_DIV_BY_8 | ( | X | ) |
Devide a variable by 8.
| X | Variable name |
| #define JO_FABS | ( | X | ) |
Get the absolute value of X.
| X | Variable name |
| #define JO_FIXED_0 |
Fixed floating point value for 0.
| #define JO_FIXED_1 |
Fixed floating point value for 1.
| #define JO_FIXED_120 |
Fixed floating point value for 120.
| #define JO_FIXED_150 |
Fixed floating point value for 150.
| #define JO_FIXED_16 |
Fixed floating point value for 16.
| #define JO_FIXED_180 |
Fixed floating point value for 180.
| #define JO_FIXED_180_DIV_PI |
Fixed value of 180/PI.
| #define JO_FIXED_1_DIV |
Fixed value of 1/65536.
| #define JO_FIXED_1_DIV_2 |
Fixed floating point value for 0.5.
| #define JO_FIXED_2 |
Fixed floating point value for 2.
| #define JO_FIXED_3 |
Fixed floating point value for 3.
| #define JO_FIXED_32 |
Fixed floating point value for 32.
| #define JO_FIXED_360 |
Fixed floating point value for 360.
| #define JO_FIXED_3_PI_OVER_2 |
Fixed value of 3 PI / 2.
| #define JO_FIXED_4 |
Fixed floating point value for 4.
| #define JO_FIXED_8 |
Fixed floating point value for 8.
| #define JO_FIXED_ALMOST_1 |
Fixed floating point value for 0.999.
| #define JO_FIXED_DECIMAL_MASK |
Decimal part mask of a jo_fixed.
| #define JO_FIXED_EPSILON |
Jo Fixed minimum positive value.
| #define JO_FIXED_MAX |
Fixed floating point value for +32767.99998.
| #define JO_FIXED_MIN |
Fixed floating point value for -32767.99998.
| #define JO_FIXED_OVERFLOW |
Indicate an overflow error.
| #define JO_FIXED_PI |
Fixed value of PI.
| #define JO_FIXED_PI_2 |
Fixed value of 2 PI.
| #define JO_FIXED_PI_DIV_180 |
Fixed value of PI/180.
| #define JO_FIXED_PI_DIV_2 |
Fixed value of PI/2.
| #define JO_FIXED_PI_OVER_2 |
Fixed value of PI/2.
| #define JO_FIXED_TO_INT | ( | X | ) |
Convert jo_fixed to int.
| X | operand |
| #define JO_FLOAT_EPSILON |
Float minimum positive value.
| #define JO_FLOAT_NEARLY_EQUALS | ( | A, | |
| B ) |
Check if A and B is nearly the same value.
| A | First operand |
| B | Second operand |
| #define JO_FLOAT_TO_FIXED | ( | X | ) |
Convert a float to jo_fixed.
| X | Float (constant expression friendly, usable in static initializers) |
| #define JO_HAS_FLAG | ( | BYTEFIELD, | |
| FLAG ) |
Check if flag is checked in bytefield.
| BYTEFIELD | Bytefield |
| FLAG | Flag |
| #define JO_INT_TO_FIXED | ( | X | ) |
Convert int to jo_fixed.
| X | operand |
| #define JO_IS_FLOAT_NULL | ( | A | ) |
Check if A nearly equals zero.
| A | operand |
| #define JO_IS_ODD | ( | A | ) |
Check if A is odd.
| A | operand |
| #define JO_IS_POW2 | ( | N | ) |
Fast check if N of a power of 2.
| N | Number |
| #define JO_MAX | ( | A, | |
| B ) |
Get the bigger value between A and B.
| A | First operand |
| B | Second operand |
| #define JO_MIN | ( | A, | |
| B ) |
Get the smaller value between A and B.
| A | First operand |
| B | Second operand |
| #define JO_MOD_POW2 | ( | N, | |
| M ) |
Fast modulo of a power of 2.
| N | Number |
| M | Modulo |
| #define JO_MULT_BY_1024 | ( | X | ) |
Multiply a variable by 1024.
| X | Variable name |
| #define JO_MULT_BY_128 | ( | X | ) |
Multiply a variable by 128.
| X | Variable name |
| #define JO_MULT_BY_16 | ( | X | ) |
Multiply a variable by 16.
| X | Variable name |
| #define JO_MULT_BY_2 | ( | X | ) |
Multiply a variable by 2.
| X | Variable name |
| #define JO_MULT_BY_2048 | ( | X | ) |
Multiply a variable by 2048.
| X | Variable name |
| #define JO_MULT_BY_256 | ( | X | ) |
Multiply a variable by 256.
| X | Variable name |
| #define JO_MULT_BY_32 | ( | X | ) |
Multiply a variable by 32.
| X | Variable name |
| #define JO_MULT_BY_32768 | ( | X | ) |
Multiply a variable by 32768.
| X | Variable name |
| #define JO_MULT_BY_4 | ( | X | ) |
Multiply a variable by 4.
| X | Variable name |
| #define JO_MULT_BY_4096 | ( | X | ) |
Multiply a variable by 4096.
| X | Variable name |
| #define JO_MULT_BY_512 | ( | X | ) |
Multiply a variable by 512.
| X | Variable name |
| #define JO_MULT_BY_64 | ( | X | ) |
Multiply a variable by 64.
| X | Variable name |
| #define JO_MULT_BY_65536 | ( | X | ) |
Multiply a variable by 65536.
| X | Variable name |
| #define JO_MULT_BY_8 | ( | X | ) |
Multiply a variable by 8.
| X | Variable name |
| #define JO_OPAQUE | ( | VAR | ) |
Hide the value of a variable from the optimizer of the compiler (no instruction).
| VAR | Variable (in a register) |
| #define JO_PERCENT_USED | ( | TOTAL, | |
| FREE ) |
Compute percent ((TOTAL - FREE) x 100 / TOTAL, rounded down).
| TOTAL | Total (42 949 672 at most, 0: 0 %) |
| FREE | Free |
| #define JO_PI |
PI value.
| #define JO_PI_2 |
PI/2 value.
| #define JO_RAD_TO_ANGLE | ( | X | ) |
Convert a radian to jo_angle.
| X | Radian (constant expression friendly, usable in static initializers) |
| #define JO_RAD_TO_DEG | ( | A | ) |
Convert radians to degrees.
| A | operand |
| #define JO_REMOVE_ALL_FLAGS | ( | BYTEFIELD | ) |
Remove all flags in bytefield.
| BYTEFIELD | Bytefield |
| #define JO_REMOVE_FLAG | ( | BYTEFIELD, | |
| FLAG ) |
Remove flag in bytefield.
| BYTEFIELD | Bytefield |
| FLAG | Flag |
| #define JO_SET_ALL_FLAGS | ( | BYTEFIELD | ) |
Set all flags in bytefield.
| BYTEFIELD | Bytefield |
| #define JO_SET_FLAGS | ( | BYTEFIELD, | |
| FLAGS ) |
Set flags in bytefield.
| BYTEFIELD | Bytefield |
| FLAGS | Flags |
| #define JO_SQUARE | ( | A | ) |
Square computation (x²).
| A | operand |
| #define JO_SWAP | ( | A, | |
| B ) |
Swap A and B values.
| A | operand |
| B | operand |
| #define JO_ZERO | ( | X | ) |
Set a variable to zero.
| X | Variable name |
Arc cosinus in fixed numbers (Internal usage, see jo_acos_radf()).
| cosinus | Cosinus (-1 to 1, Q16.16: kept in the range) |
|
static |
|
static |
Table index of an angle (Internal usage).
| angle | jo_angle |
| jo_angle __jo_atan2_floats | ( | const float | y, |
| const float | x ) |
The angle of a vector of 2 floats (Internal usage, see jo_atan2f_rad()).
| y | First value |
| x | Second value |
|
static |
Dot product of 2 vectors of 4 fixed numbers (Internal usage).
| ptA | First vector (4 contiguous fixed numbers) |
| ptB | Second vector (4 contiguous fixed numbers) |
| float __jo_fixed_to_float | ( | const jo_fixed | x | ) |
Convert jo engine fixed to float at run time (Internal usage, see jo_fixed2float()).
| x | Fixed |
|
static |
The bits of a float (Internal usage).
| f | Float |
|
static |
A float from its bits (Internal usage).
| i | Its 32 bits |
| float __jo_float_scale2 | ( | const float | x, |
| const int | shift ) |
A float times 2^shift, in integers on its bits (Internal usage).
| x | Float |
| shift | Power of 2 added to its exponent |
|
static |
The sign of a float, in integers on its bits (Internal usage).
| x | Float |
| jo_fixed __jo_float_to_fixed | ( | const float | x | ) |
Convert float to jo engine fixed at run time (Internal usage, see jo_float2fixed()).
| x | Float |
| int __jo_floats_to_fixed_scaled | ( | const float *const | in, |
| jo_fixed *const | out, | ||
| const int | count, | ||
| const int | top ) |
Convert floats to fixed numbers with the same power of 2 for all, in integers (Internal usage).
| in | Floats |
| out | Fixed numbers: in[k] * 2^shift |
| count | Number of values |
| top | The largest value is brought between 2^top and 2^(top + 1) (from -16 to 14) |
|
static |
Sinus of a table index (Internal usage).
| index | 0 to 4095 (4096 steps per turn) |
|
static |
An angle in degree brought in 0 to 359 (Internal usage).
| deg | Angle in degree (any value) |
|
static |
Fast Arc Cosinus computation.
| angle | Cosinus (-1 to 1) |
|
static |
ATAN2 as a jo_angle (65536 per turn, like jo_sin_angle() and the rotations of the 3D).
| y | First value |
| x | Second value |
ATAN2 in degree without floating point (fixed numbers).
| y | First value (Q16.16) |
| x | Second value (Q16.16) |
ATAN2 as a jo_angle without floating point (fixed numbers).
| y | First value (Q16.16) |
| x | Second value (Q16.16) |
|
static |
Fast ATAN2 computation in degree.
| y | First value |
| x | Second value |
| float jo_atan2f_rad | ( | const float | y, |
| const float | x ) |
Fast ATAN2 computation in radian.
| y | First value |
| x | Second value |
|
static |
Fast cosinus computation.
| deg | Angle in degree (any value: negative or over 360, no modulo needed) |
|
static |
Cosinus of an angle (table lookup, fast).
| angle | jo_angle (0x10000 = 360 degrees, it wraps) |
|
static |
Fast cosinus multiplication.
| deg | Angle in degree (any value: negative or over 360, no modulo needed) |
| value | Value |
|
static |
Cosinus computation.
| rad | Angle in radian |
|
static |
Cosinus computation.
| rad | Angle in radian |
|
static |
Cosinus computation.
| deg | Angle in degree |
|
static |
Fast cosinus multiplication.
| deg | Angle in degree |
| value | Value |
|
static |
|
static |
|
static |
|
static |
Convert jo engine fixed to float.
| x | Fixed to convert |
|
static |
Convert jo engine fixed to int.
| x | Fixed |
|
static |
Returns the smallest (fixed) integer value greater than or equal to x.
| x | Fixed value |
|
static |
Fast cosinus computation using fixed number.
| rad | Fixed angle in radian |
|
static |
|
static |
Convert fixed degree to fixed radian.
| deg | Fixed angle in degree |
|
static |
Divide fixed-point numbers (expresses dividend / divisor).
| dividend | (first operand) |
| divisor | (second operand) |
|
static |
Get the result of the division started by jo_fixed_div_start().
|
static |
Start a fixed-point division in the background (see jo_fixed_div_result()).
| dividend | (first operand) |
| divisor | (second operand) |
|
static |
Dot product two fixed 3D points.
| ptA | Point A (first operand) |
| ptB | Point B (second operand) |
|
static |
Returns the largest (fixed) integer value less than or equal to x.
| x | Fixed value |
|
static |
Multiply to fixed number.
| x | First operand |
| y | Second operand |
|
static |
Multiply to fixed number and keep the integer part: jo_fixed2int(jo_fixed_mult(x, y)), without overflow.
| x | First operand |
| y | Second operand |
x raised to the power of the integer part of y
| x | First operand |
| y | Second operand |
|
static |
|
static |
Convert fixed radian to fixed degree.
| rad | Fixed angle in radian |
Fast Reciprocal Square root using fixed number.
| value | Value |
|
static |
Fast sinus computation using fixed number.
| rad | Fixed angle in radian |
Fast Square root using fixed number.
| value | Value |
|
static |
Wrap deg in [-180 180].
| deg | Fixed degree |
|
static |
Wrap rad in [−pi pi].
| rad | Fixed radian |
|
static |
Convert float to jo engine fixed (avoid usage of GCC Soft Float).
| x | Float to convert (from -32768 to 32767.99998: saturated outside) |
| int jo_gcd | ( | int | a, |
| int | b ) |
Get the greatest common divisor.
| a | First value (> 0) |
| b | Second value (> 0) |
|
static |
Index of the highest bit set in a value (31 - number of leading zeros).
| x | Value |
|
static |
Convert int to jo engine fixed.
| x | Float to convert |
|
static |
Divide 2 integers (dividend / divisor, rounded toward 0 as in C).
| dividend | (first operand) |
| divisor | (second operand) |
|
static |
Check if float almost equals 0.
| f | floating point number |
|
static |
Linear interpolation which guarantees v = v1 when t = 1.
| v0 | First value |
| v1 | Second value |
| t | T [0, 1] |
|
static |
Creates the identity matrix (using fixed numbers).
| result | Result matrix |
|
static |
Multiply 2 matrix (using fixed numbers).
| a | First matrix |
| b | Second matrix |
| result | Result matrix |
|
static |
Multiply a matrix by a vector4 (using fixed numbers).
| m | Matrix |
| v | Vector4 |
| result | Result vector4 |
|
static |
Rotation matrix around the X axis (using fixed numbers).
| angle | jo_angle (65536 per turn) |
| result | Output matrix |
|
static |
Rotation matrix around the X axis (radian, using floating numbers: converted, then jo_matrix_rotation_x_angle()).
| angle_in_rad | Angle in radian |
| result | Output matrix |
|
static |
Rotation matrix around the Y axis (using fixed numbers).
| angle | jo_angle (65536 per turn) |
| result | Output matrix |
|
static |
Rotation matrix around the Y axis (radian, using floating numbers: converted, then jo_matrix_rotation_y_angle()).
| angle_in_rad | Angle in radian |
| result | Output matrix |
|
static |
Rotation matrix around the Z axis (using fixed numbers).
| angle | jo_angle (65536 per turn) |
| result | Output matrix |
|
static |
Rotation matrix around the Z axis (radian, using floating numbers: converted, then jo_matrix_rotation_z_angle()).
| angle_in_rad | Angle in radian |
| result | Output matrix |
|
static |
Creates scaling matrix (using fixed numbers).
| scale | Scale vector |
| result | Result matrix |
|
static |
Creates translation matrix (using fixed numbers).
| offset | Offset vector |
| result | Result matrix |
|
static |
Creates transpose matrix (using fixed numbers).
| matrix | Input matrix |
| result | Result matrix |
|
static |
Creates the identity matrix (using floating numbers).
| result | Result matrix |
| void jo_matrixf_invert_affine | ( | const jo_matrixf *const | matrix, |
| jo_matrixf *const | result ) |
Inverts an affine transformation matrix (using floating numbers).
| matrix | Matrix |
| result | Result matrix |
| void jo_matrixf_look_at | ( | const jo_vectorf *const | from, |
| const jo_vectorf *const | to, | ||
| const jo_vectorf *const | up, | ||
| jo_matrixf *const | result ) |
Builds a transformation matrix for a camera (using floating numbers).
| from | Viewpoint |
| to | target |
| up | Defines the direction that's upwards for the camera |
| result | Result matrix |
| void jo_matrixf_mul | ( | const jo_matrixf *const | a, |
| const jo_matrixf *const | b, | ||
| jo_matrixf *const | result ) |
Multiply 2 matrix (using floating numbers).
| a | First matrix |
| b | Second matrix |
| result | Result matrix |
| void jo_matrixf_mul_dir | ( | const jo_matrixf *const | matrix, |
| const jo_vectorf *const | direction, | ||
| jo_vectorf *const | result ) |
Multiplies a 4x4 matrix with a 3D vector representing a direction in 3D space (using floating numbers).
| matrix | Matrix |
| direction | Direction |
| result | Result matrix |
| void jo_matrixf_mul_pos | ( | const jo_matrixf *const | matrix, |
| const jo_vectorf *const | position, | ||
| jo_vectorf *const | result ) |
Multiplies a 4x4 matrix with a 3D vector representing a point in 3D space (using floating numbers).
| matrix | Matrix |
| position | Position |
| result | Result matrix |
| void jo_matrixf_ortho | ( | const float | left, |
| const float | right, | ||
| const float | bottom, | ||
| const float | top, | ||
| const float | back, | ||
| const float | front, | ||
| jo_matrixf *const | result ) |
Creates an orthographic projection matrix (using floating numbers).
| left | Left (Cube) |
| right | Right (Cube) |
| bottom | Bottom (Cube) |
| top | Top (Cube) |
| back | Back (Cube) |
| front | Front (Cube) |
| result | Result matrix |
| void jo_matrixf_perspective | ( | const float | vertical_field_of_view_in_deg, |
| const float | aspect_ratio, | ||
| const float | near_view_distance, | ||
| const float | far_view_distance, | ||
| jo_matrixf *const | result ) |
Creates a perspective projection matrix for a camera (using floating numbers).
| vertical_field_of_view_in_deg | Specifies the field of view angle, in degrees, in the y direction. |
| aspect_ratio | Specifies the aspect ratio that determines the field of view in the x direction. The aspect ratio is the ratio of x (width) to y (height). |
| near_view_distance | Specifies the distance from the viewer to the near clipping plane (always positive). |
| far_view_distance | Specifies the distance from the viewer to the far clipping plane (always positive). |
| result | Result matrix |
| void jo_matrixf_rotation | ( | const float | angle_in_rad, |
| const jo_vectorf *const | axis, | ||
| jo_matrixf *const | result ) |
Creates a matrix to rotate around an axis by a given angle in radiant (using floating numbers).
| angle_in_rad | Angle in radiant |
| axis | Axis |
| result | Result matrix |
|
static |
Creates rotating matrix (X axis) (using floating numbers).
| angle_in_rad | Angle in radiant |
| result | Result matrix |
|
static |
Creates rotating matrix (Y axis) (using floating numbers).
| angle_in_rad | Angle in radiant |
| result | Result matrix |
|
static |
Creates rotating matrix (Z axis) (using floating numbers).
| angle_in_rad | Angle in radiant |
| result | Result matrix |
|
static |
Creates scaling matrix (using floating numbers).
| scale | Scale vector |
| result | Result matrix |
|
static |
Creates translation matrix (using floating numbers).
| offset | Offset vector |
| result | Result matrix |
|
static |
Creates transpose matrix (using floating numbers).
| matrix | Input matrix |
| result | Result matrix |
| void jo_planar_rotate | ( | const jo_pos2D *const | point, |
| const jo_pos2D *const | origin, | ||
| const int | angle, | ||
| jo_pos2D *const | result ) |
Rotate a point on the plan with a specific origin.
| point | Point to rotate |
| origin | Rotation origin |
| angle | Angle in degrees |
| result | The new point coordinate |
| int jo_random | ( | int | max | ) |
Get a random number.
| max | maximum value |
|
static |
Get a random number of a sequence of its own (the effects of a game: the same at each run, whatever the other calls of jo_random()).
| seed | The seed of the sequence (any value at the start; updated) |
|
static |
Get a random number with a specific multiple.
| max | maximum value |
| multiple | multiple |
| float jo_rsqrt | ( | float | value | ) |
Fast Reciprocal Square root using floating number.
| value | Value |
|
static |
Arithmetic right shift by 8 bits (x >> 8, rounded toward minus infinity) of any value.
| x | Value |
|
static |
Arithmetic right shift by 8 bits (x >> 8) of a value in [-2^23, 2^23) (a 16 bits value x 0 to 256 for example).
| x | Value |
|
static |
Fast sinus computation.
| deg | Angle in degree (any value: negative or over 360, no modulo needed) |
|
static |
|
static |
Fast sinus multiplication.
| deg | Angle in degree (any value: negative or over 360, no modulo needed) |
| value | Value |
|
static |
Sinus computation.
| rad | Angle in radian |
|
static |
Sinus computation.
| rad | Angle in radian |
|
static |
|
static |
Sinus and cosinus of the same angle (table lookup, fast).
| angle | jo_angle (0x10000 = 360 degrees, it wraps) |
| sin_value | Sinus (Q16.16 fixed number) |
| cos_value | Cosinus (Q16.16 fixed number) |
|
static |
Sinus computation.
| deg | Angle in degree |
|
static |
Fast sinus multiplication.
| deg | Angle in degree |
| value | Value |
| unsigned int jo_sqrt | ( | unsigned int | value | ) |
Fast square root.
| value | Value |
|
static |
Fast Square root using floating number.
| value | Value |
|
static |
Fast method to get if two square intersects (HitBox processing).
| x1 | Horizontal position of the first square |
| y1 | Vertical position of the first square |
| w1 | Width of the first square |
| h1 | Height of the first square |
| x2 | Horizontal position of the second square |
| y2 | Vertical position of the second square |
| w2 | Width of the second square |
| h2 | Height of the second square |
|
static |
Fast tangent computation.
| deg | Angle in degree |
|
static |
Fast tangent of a jo_angle (table lookup and the division unit).
| angle | jo_angle (0x10000 = 360 degrees, it wraps) |
|
static |
Tangent computation.
| rad | Angle in radian |
|
static |
Tangent computation.
| rad | Angle in radian |
|
static |
Tangent computation.
| deg | Angle in degree |
|
static |
Turn an angle toward another angle, by the shortest way.
| angle | Current angle in degree (0 to 359) |
| target | Target angle in degree (any value) |
| max_step | Largest change in degree (positive) |
|
static |
Add 2 vectors4 (using fixed numbers).
| a | First vector4 |
| b | Second vector4 |
| result | output vector4 |
|
static |
Cross product of 2 vectors4 (using fixed numbers).
| a | First vector4 |
| b | Second vector4 |
| result | output vector4 |
|
static |
Dot product of 2 vectors4 (using fixed numbers).
| a | First vector4 |
| b | Second vector4 |
|
static |
Substract 2 vectors4 (using fixed numbers).
| a | First vector4 |
| b | Second vector4 |
| result | output vector4 |
|
static |
Swap 2 vectors4 (using fixed numbers).
| a | First vector4 |
| b | Second vector4 |
|
static |
Add 2 vectors (using fixed numbers).
| a | First vector |
| b | Second vector |
| result | output vector |
| void jo_vector_fixed_compute_bezier_point | ( | const jo_fixed | t, |
| jo_vector_fixed | p0, | ||
| jo_vector_fixed | p1, | ||
| jo_vector_fixed | p2, | ||
| jo_vector_fixed | p3, | ||
| jo_vector_fixed * | result ) |
Compute cubic bezier curve point for vectors (using fixed numbers).
| t | Value of the function on the curve [0 to JO_FIXED_1] |
| p0 | First vector |
| p1 | Second vector |
| p2 | Third vector |
| p3 | Fourth vector |
| result | output vector |
|
static |
Cross product of 2 vectors (using fixed numbers).
| a | First vector |
| b | Second vector |
| result | output vector (a x b) |
|
static |
Dot product of 2 vectors (using fixed numbers).
| a | First vector |
| b | Second vector |
| jo_fixed jo_vector_fixed_length | ( | const jo_vector_fixed *const | a | ) |
Length of a vector (using fixed numbers).
| a | Vector |
|
static |
Multiply value to vector (using fixed numbers).
| a | Vector |
| s | Constant |
| result | output vector |
| void jo_vector_fixed_normalize | ( | const jo_vector_fixed *const | a, |
| jo_vector_fixed *const | result ) |
Normalize a vector (using fixed numbers).
| a | Vector |
| result | output vector: length 1 (0, 0, 0 if a is 0, 0, 0) |
|
static |
Substract 2 vectors (using fixed numbers).
| a | First vector |
| b | Second vector |
| result | output vector (a - b) |
| void jo_vectorf_add | ( | const jo_vectorf *const | a, |
| const jo_vectorf *const | b, | ||
| jo_vectorf *const | result ) |
Add 2 vectors (using floating numbers).
| a | First vector |
| b | Second vector |
| result | output vector |
| void jo_vectorf_adds | ( | const jo_vectorf *const | a, |
| const float | s, | ||
| jo_vectorf *const | result ) |
Add value to vector (using floating numbers).
| a | Vector |
| s | Constant |
| result | output vector |
| float jo_vectorf_angle_between_radf | ( | const jo_vectorf *const | a, |
| const jo_vectorf *const | b ) |
Get the angle between 2 vectors (using floating numbers).
| a | First vector |
| b | Second vector |
| void jo_vectorf_compute_bezier_point | ( | const float | t, |
| jo_vectorf | p0, | ||
| jo_vectorf | p1, | ||
| jo_vectorf | p2, | ||
| jo_vectorf | p3, | ||
| jo_vectorf * | result ) |
Compute cubic bezier curve point for vectors (using floating numbers).
| t | Value of the function on the curve [0.0f to 1.0f] |
| p0 | First vector |
| p1 | Second vector |
| p2 | Third vector |
| p3 | Fourth vector |
| result | output vector |
| void jo_vectorf_cross | ( | const jo_vectorf *const | a, |
| const jo_vectorf *const | b, | ||
| jo_vectorf *const | result ) |
Cross 2 vectors (using floating numbers).
| a | First vector |
| b | Second vector |
| result | output vector |
| void jo_vectorf_div | ( | const jo_vectorf *const | a, |
| const jo_vectorf *const | b, | ||
| jo_vectorf *const | result ) |
Divide 2 vectors (using floating numbers).
| a | First vector |
| b | Second vector |
| result | output vector |
| void jo_vectorf_divs | ( | const jo_vectorf *const | a, |
| const float | s, | ||
| jo_vectorf *const | result ) |
Divide value to vector (using floating numbers).
| a | Vector |
| s | Constant |
| result | output vector |
| float jo_vectorf_dot | ( | const jo_vectorf *const | a, |
| const jo_vectorf *const | b ) |
Get the dot product of 2 vectors (using floating numbers).
| a | First vector |
| b | Second vector |
| float jo_vectorf_length | ( | const jo_vectorf *const | a | ) |
Get the length of a vector (using floating numbers).
| a | Vector |
| void jo_vectorf_mul | ( | const jo_vectorf *const | a, |
| const jo_vectorf *const | b, | ||
| jo_vectorf *const | result ) |
Multiply 2 vectors (using floating numbers).
| a | First vector |
| b | Second vector |
| result | output vector |
| void jo_vectorf_muls | ( | const jo_vectorf *const | a, |
| const float | s, | ||
| jo_vectorf *const | result ) |
Multiply value to vector (using floating numbers).
| a | Vector |
| s | Constant |
| result | output vector |
| void jo_vectorf_normalize | ( | const jo_vectorf *const | a, |
| jo_vectorf *const | result ) |
Normalize a vector (using floating numbers).
| a | Vector |
| result | output vector |
| void jo_vectorf_proj | ( | const jo_vectorf *const | v, |
| const jo_vectorf *const | onto, | ||
| jo_vectorf *const | result ) |
Compute projection vector (using floating numbers).
| v | Vector |
| onto | Vector |
| result | output vector |
| void jo_vectorf_sub | ( | const jo_vectorf *const | a, |
| const jo_vectorf *const | b, | ||
| jo_vectorf *const | result ) |
Subtract 2 vectors (using floating numbers).
| a | First vector |
| b | Second vector |
| result | output vector |
| void jo_vectorf_subs | ( | const jo_vectorf *const | a, |
| const float | s, | ||
| jo_vectorf *const | result ) |
Subtract value to vector (using floating numbers).
| a | Vector |
| s | Constant |
| result | output vector |
|
extern |
Sinus table: sin(x) for x in [0, pi/2] (1024 steps, Q16.16) (Internal usage, see math.c).
|
extern |
Get or set current random seed.